#ifdef TIER_TWO

#error "This file is for Tier 1 only"

#define TIER_ONE 1

TARGET(BEFORE_ASYNC_WITH) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BEFORE_ASYNC_WITH);

PyObject *mgr;

PyObject *exit;

PyObject *res;

mgr = stack_pointer[-1];

PyObject *enter = _PyObject_LookupSpecial(mgr, &_Py_ID(__aenter__));

if (enter == NULL) {

if (!_PyErr_Occurred(tstate)) {

_PyErr_Format(tstate, PyExc_TypeError,

"'%.200s' object does not support the "

"asynchronous context manager protocol",

Py_TYPE(mgr)->tp_name);

}

GOTO_ERROR(error);

}

exit = _PyObject_LookupSpecial(mgr, &_Py_ID(__aexit__));

if (exit == NULL) {

if (!_PyErr_Occurred(tstate)) {

_PyErr_Format(tstate, PyExc_TypeError,

"'%.200s' object does not support the "

"asynchronous context manager protocol "

"(missed __aexit__ method)",

Py_TYPE(mgr)->tp_name);

}

Py_DECREF(enter);

GOTO_ERROR(error);

}

Py_DECREF(mgr);

res = _PyObject_CallNoArgsTstate(tstate, enter);

Py_DECREF(enter);

if (res == NULL) {

Py_DECREF(exit);

if (true) goto pop_1_error;

}

stack_pointer[-1] = exit;

stack_pointer[0] = res;

stack_pointer += 1;

DISPATCH();

}

TARGET(BEFORE_WITH) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BEFORE_WITH);

PyObject *mgr;

PyObject *exit;

PyObject *res;

mgr = stack_pointer[-1];

/* pop the context manager, push its __exit__ and the

PyObject *enter = _PyObject_LookupSpecial(mgr, &_Py_ID(__enter__));

if (enter == NULL) {

if (!_PyErr_Occurred(tstate)) {

_PyErr_Format(tstate, PyExc_TypeError,

"'%.200s' object does not support the "

"context manager protocol",

Py_TYPE(mgr)->tp_name);

}

GOTO_ERROR(error);

}

exit = _PyObject_LookupSpecial(mgr, &_Py_ID(__exit__));

if (exit == NULL) {

if (!_PyErr_Occurred(tstate)) {

_PyErr_Format(tstate, PyExc_TypeError,

"'%.200s' object does not support the "

"context manager protocol "

"(missed __exit__ method)",

Py_TYPE(mgr)->tp_name);

}

Py_DECREF(enter);

GOTO_ERROR(error);

}

Py_DECREF(mgr);

res = _PyObject_CallNoArgsTstate(tstate, enter);

Py_DECREF(enter);

if (res == NULL) {

Py_DECREF(exit);

if (true) goto pop_1_error;

}

stack_pointer[-1] = exit;

stack_pointer[0] = res;

stack_pointer += 1;

DISPATCH();

}

TARGET(BINARY_OP) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_OP);

PREDICTED(BINARY_OP);

_Py_CODEUNIT *this_instr = next_instr - 2;

PyObject *rhs;

PyObject *lhs;

PyObject *res;

// _SPECIALIZE_BINARY_OP

rhs = stack_pointer[-1];

lhs = stack_pointer[-2];

{

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

TIER_ONE_ONLY

#if ENABLE_SPECIALIZATION

if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {

next_instr = this_instr;

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

DISPATCH_SAME_OPARG();

}

STAT_INC(BINARY_OP, deferred);

DECREMENT_ADAPTIVE_COUNTER(this_instr[1].cache);

#endif /* ENABLE_SPECIALIZATION */

assert(NB_ADD <= oparg);

assert(oparg <= NB_INPLACE_XOR);

}

// _BINARY_OP

{

assert(_PyEval_BinaryOps[oparg]);

res = _PyEval_BinaryOps[oparg](lhs, rhs);

Py_DECREF(lhs);

Py_DECREF(rhs);

if (res == NULL) goto pop_2_error;

}

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BINARY_OP_ADD_FLOAT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_OP_ADD_FLOAT);

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

PyObject *right;

PyObject *left;

PyObject *res;

// _GUARD_BOTH_FLOAT

right = stack_pointer[-1];

left = stack_pointer[-2];

{

DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);

}

/* Skip 1 cache entry */

// _BINARY_OP_ADD_FLOAT

{

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;

DISPATCH();

}

TARGET(BINARY_OP_ADD_INT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_OP_ADD_INT);

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

PyObject *right;

PyObject *left;

PyObject *res;

// _GUARD_BOTH_INT

right = stack_pointer[-1];

left = stack_pointer[-2];

{

DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);

}

/* Skip 1 cache entry */

// _BINARY_OP_ADD_INT

{

STAT_INC(BINARY_OP, hit);

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

_Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);

_Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);

if (res == NULL) goto pop_2_error;

}

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BINARY_OP_ADD_UNICODE) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_OP_ADD_UNICODE);

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

PyObject *right;

PyObject *left;

PyObject *res;

// _GUARD_BOTH_UNICODE

right = stack_pointer[-1];

left = stack_pointer[-2];

{

DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyUnicode_CheckExact(right), BINARY_OP);

}

/* Skip 1 cache entry */

// _BINARY_OP_ADD_UNICODE

{

STAT_INC(BINARY_OP, hit);

res = PyUnicode_Concat(left, right);

_Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc);

_Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);

if (res == NULL) goto pop_2_error;

}

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BINARY_OP_INPLACE_ADD_UNICODE) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_OP_INPLACE_ADD_UNICODE);

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

PyObject *right;

PyObject *left;

// _GUARD_BOTH_UNICODE

right = stack_pointer[-1];

left = stack_pointer[-2];

{

DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyUnicode_CheckExact(right), BINARY_OP);

}

/* Skip 1 cache entry */

// _BINARY_OP_INPLACE_ADD_UNICODE

{

TIER_ONE_ONLY

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

PyObject **target_local = &GETLOCAL(next_instr->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.

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

SKIP_OVER(1);

}

stack_pointer += -2;

DISPATCH();

}

TARGET(BINARY_OP_MULTIPLY_FLOAT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_OP_MULTIPLY_FLOAT);

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

PyObject *right;

PyObject *left;

PyObject *res;

// _GUARD_BOTH_FLOAT

right = stack_pointer[-1];

left = stack_pointer[-2];

{

DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);

}

/* Skip 1 cache entry */

// _BINARY_OP_MULTIPLY_FLOAT

{

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;

DISPATCH();

}

TARGET(BINARY_OP_MULTIPLY_INT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_OP_MULTIPLY_INT);

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

PyObject *right;

PyObject *left;

PyObject *res;

// _GUARD_BOTH_INT

right = stack_pointer[-1];

left = stack_pointer[-2];

{

DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);

}

/* Skip 1 cache entry */

// _BINARY_OP_MULTIPLY_INT

{

STAT_INC(BINARY_OP, hit);

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

_Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);

_Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);

if (res == NULL) goto pop_2_error;

}

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BINARY_OP_SUBTRACT_FLOAT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_OP_SUBTRACT_FLOAT);

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

PyObject *right;

PyObject *left;

PyObject *res;

// _GUARD_BOTH_FLOAT

right = stack_pointer[-1];

left = stack_pointer[-2];

{

DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);

}

/* Skip 1 cache entry */

// _BINARY_OP_SUBTRACT_FLOAT

{

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;

DISPATCH();

}

TARGET(BINARY_OP_SUBTRACT_INT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_OP_SUBTRACT_INT);

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

PyObject *right;

PyObject *left;

PyObject *res;

// _GUARD_BOTH_INT

right = stack_pointer[-1];

left = stack_pointer[-2];

{

DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);

DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);

}

/* Skip 1 cache entry */

// _BINARY_OP_SUBTRACT_INT

{

STAT_INC(BINARY_OP, hit);

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

_Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);

_Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);

if (res == NULL) goto pop_2_error;

}

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BINARY_SLICE) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BINARY_SLICE);

PyObject *stop;

PyObject *start;

PyObject *container;

PyObject *res;

stop = stack_pointer[-1];

start = stack_pointer[-2];

container = stack_pointer[-3];

PyObject *slice = _PyBuildSlice_ConsumeRefs(start, stop);

// Can't use ERROR_IF() here, because we haven't

// DECREF'ed container yet, and we still own slice.

if (slice == NULL) {

res = NULL;

}

else {

res = PyObject_GetItem(container, slice);

Py_DECREF(slice);

}

Py_DECREF(container);

if (res == NULL) goto pop_3_error;

stack_pointer[-3] = res;

stack_pointer += -2;

DISPATCH();

}

TARGET(BINARY_SUBSCR) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_SUBSCR);

PREDICTED(BINARY_SUBSCR);

_Py_CODEUNIT *this_instr = next_instr - 2;

PyObject *sub;

PyObject *container;

PyObject *res;

// _SPECIALIZE_BINARY_SUBSCR

sub = stack_pointer[-1];

container = stack_pointer[-2];

{

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

TIER_ONE_ONLY

#if ENABLE_SPECIALIZATION

if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {

next_instr = this_instr;

_Py_Specialize_BinarySubscr(container, sub, next_instr);

DISPATCH_SAME_OPARG();

}

STAT_INC(BINARY_SUBSCR, deferred);

DECREMENT_ADAPTIVE_COUNTER(this_instr[1].cache);

#endif /* ENABLE_SPECIALIZATION */

}

// _BINARY_SUBSCR

{

res = PyObject_GetItem(container, sub);

Py_DECREF(container);

Py_DECREF(sub);

if (res == NULL) goto pop_2_error;

}

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BINARY_SUBSCR_DICT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_SUBSCR_DICT);

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

PyObject *sub;

PyObject *dict;

PyObject *res;

/* Skip 1 cache entry */

sub = stack_pointer[-1];

dict = stack_pointer[-2];

DEOPT_IF(!PyDict_CheckExact(dict), BINARY_SUBSCR);

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

// not found or error

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BINARY_SUBSCR_GETITEM) {

_Py_CODEUNIT *this_instr = frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_SUBSCR_GETITEM);

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

PyObject *sub;

PyObject *container;

/* Skip 1 cache entry */

sub = stack_pointer[-1];

container = stack_pointer[-2];

DEOPT_IF(tstate->interp->eval_frame, BINARY_SUBSCR);

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;

frame->return_offset = (uint16_t)(next_instr - this_instr);

DISPATCH_INLINED(new_frame);

}

TARGET(BINARY_SUBSCR_LIST_INT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_SUBSCR_LIST_INT);

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

PyObject *sub;

PyObject *list;

PyObject *res;

/* Skip 1 cache entry */

sub = stack_pointer[-1];

list = stack_pointer[-2];

DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);

DEOPT_IF(!PyList_CheckExact(list), BINARY_SUBSCR);

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

DEOPT_IF(!_PyLong_IsNonNegativeCompact((PyLongObject *)sub), BINARY_SUBSCR);

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

DEOPT_IF(index >= PyList_GET_SIZE(list), BINARY_SUBSCR);

STAT_INC(BINARY_SUBSCR, hit);

res = PyList_GET_ITEM(list, index);

assert(res != NULL);

Py_INCREF(res);

_Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);

Py_DECREF(list);

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BINARY_SUBSCR_STR_INT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_SUBSCR_STR_INT);

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

PyObject *sub;

PyObject *str;

PyObject *res;

/* Skip 1 cache entry */

sub = stack_pointer[-1];

str = stack_pointer[-2];

DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);

DEOPT_IF(!PyUnicode_CheckExact(str), BINARY_SUBSCR);

DEOPT_IF(!_PyLong_IsNonNegativeCompact((PyLongObject *)sub), BINARY_SUBSCR);

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

DEOPT_IF(PyUnicode_GET_LENGTH(str) <= index, BINARY_SUBSCR);

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

Py_UCS4 c = PyUnicode_READ_CHAR(str, index);

DEOPT_IF(Py_ARRAY_LENGTH(_Py_SINGLETON(strings).ascii) <= c, BINARY_SUBSCR);

STAT_INC(BINARY_SUBSCR, hit);

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

_Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);

Py_DECREF(str);

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BINARY_SUBSCR_TUPLE_INT) {

frame->instr_ptr = next_instr;

next_instr += 2;

INSTRUCTION_STATS(BINARY_SUBSCR_TUPLE_INT);

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

PyObject *sub;

PyObject *tuple;

PyObject *res;

/* Skip 1 cache entry */

sub = stack_pointer[-1];

tuple = stack_pointer[-2];

DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);

DEOPT_IF(!PyTuple_CheckExact(tuple), BINARY_SUBSCR);

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

DEOPT_IF(!_PyLong_IsNonNegativeCompact((PyLongObject *)sub), BINARY_SUBSCR);

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

DEOPT_IF(index >= PyTuple_GET_SIZE(tuple), BINARY_SUBSCR);

STAT_INC(BINARY_SUBSCR, hit);

res = PyTuple_GET_ITEM(tuple, index);

assert(res != NULL);

Py_INCREF(res);

_Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);

Py_DECREF(tuple);

stack_pointer[-2] = res;

stack_pointer += -1;

DISPATCH();

}

TARGET(BUILD_CONST_KEY_MAP) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BUILD_CONST_KEY_MAP);

PyObject *keys;

PyObject **values;

PyObject *map;

keys = stack_pointer[-1];

values = &stack_pointer[-1 - oparg];

if (!PyTuple_CheckExact(keys) ||

PyTuple_GET_SIZE(keys) != (Py_ssize_t)oparg) {

_PyErr_SetString(tstate, PyExc_SystemError,

"bad BUILD_CONST_KEY_MAP keys argument");

GOTO_ERROR(error); // Pop the keys and values.

}

map = _PyDict_FromItems(

&PyTuple_GET_ITEM(keys, 0), 1,

values, 1, oparg);

for (int _i = oparg; --_i >= 0;) {

Py_DECREF(values[_i]);

}

Py_DECREF(keys);

if (map == NULL) { stack_pointer += -1 - oparg; goto error; }

stack_pointer[-1 - oparg] = map;

stack_pointer += -oparg;

DISPATCH();

}

TARGET(BUILD_LIST) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BUILD_LIST);

PyObject **values;

PyObject *list;

values = &stack_pointer[-oparg];

list = _PyList_FromArraySteal(values, oparg);

if (list == NULL) { stack_pointer += -oparg; goto error; }

stack_pointer[-oparg] = list;

stack_pointer += 1 - oparg;

DISPATCH();

}

TARGET(BUILD_MAP) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BUILD_MAP);

PyObject **values;

PyObject *map;

values = &stack_pointer[-oparg*2];

map = _PyDict_FromItems(

values, 2,

values+1, 2,

oparg);

for (int _i = oparg*2; --_i >= 0;) {

Py_DECREF(values[_i]);

}

if (map == NULL) { stack_pointer += -oparg*2; goto error; }

stack_pointer[-oparg*2] = map;

stack_pointer += 1 - oparg*2;

DISPATCH();

}

TARGET(BUILD_SET) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BUILD_SET);

PyObject **values;

PyObject *set;

values = &stack_pointer[-oparg];

set = PySet_New(NULL);

if (set == NULL)

GOTO_ERROR(error);

int err = 0;

for (int i = 0; i < oparg; i++) {

PyObject *item = values[i];

if (err == 0)

err = PySet_Add(set, item);

Py_DECREF(item);

}

if (err != 0) {

Py_DECREF(set);

if (true) { stack_pointer += -oparg; goto error; }

}

stack_pointer[-oparg] = set;

stack_pointer += 1 - oparg;

DISPATCH();

}

TARGET(BUILD_SLICE) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BUILD_SLICE);

PyObject *step = NULL;

PyObject *stop;

PyObject *start;

PyObject *slice;

if (oparg == 3) { step = stack_pointer[-((oparg == 3) ? 1 : 0)]; }

stop = stack_pointer[-1 - ((oparg == 3) ? 1 : 0)];

start = stack_pointer[-2 - ((oparg == 3) ? 1 : 0)];

slice = PySlice_New(start, stop, step);

Py_DECREF(start);

Py_DECREF(stop);

Py_XDECREF(step);

if (slice == NULL) { stack_pointer += -2 - ((oparg == 3) ? 1 : 0); goto error; }

stack_pointer[-2 - ((oparg == 3) ? 1 : 0)] = slice;

stack_pointer += -1 - ((oparg == 3) ? 1 : 0);

DISPATCH();

}

TARGET(BUILD_STRING) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BUILD_STRING);

PyObject **pieces;

PyObject *str;

pieces = &stack_pointer[-oparg];

str = _PyUnicode_JoinArray(&_Py_STR(empty), pieces, oparg);

for (int _i = oparg; --_i >= 0;) {

Py_DECREF(pieces[_i]);

}

if (str == NULL) { stack_pointer += -oparg; goto error; }

stack_pointer[-oparg] = str;

stack_pointer += 1 - oparg;

DISPATCH();

}

TARGET(BUILD_TUPLE) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(BUILD_TUPLE);

PyObject **values;

PyObject *tup;

values = &stack_pointer[-oparg];

tup = _PyTuple_FromArraySteal(values, oparg);

if (tup == NULL) { stack_pointer += -oparg; goto error; }

stack_pointer[-oparg] = tup;

stack_pointer += 1 - oparg;

DISPATCH();

}

TARGET(CACHE) {

frame->instr_ptr = next_instr;

next_instr += 1;

INSTRUCTION_STATS(CACHE);

TIER_ONE_ONLY

assert(0 && "Executing a cache.");

Py_UNREACHABLE();

}

TARGET(CALL) {

frame->instr_ptr = next_instr;

next_instr += 4;

INSTRUCTION_STATS(CALL);

PREDICTED(CALL);

_Py_CODEUNIT *this_instr = next_instr - 4;

PyObject **args;

PyObject *self_or_null;

PyObject *callable;

PyObject *res;

// _SPECIALIZE_CALL

args = &stack_pointer[-oparg];

self_or_null = stack_pointer[-1 - oparg];

callable = stack_pointer[-2 - oparg];

{

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

TIER_ONE_ONLY

#if ENABLE_SPECIALIZATION

if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {

next_instr = this_instr;

_Py_Specialize_Call(callable, next_instr, oparg + (self_or_null != NULL));

DISPATCH_SAME_OPARG();

}

STAT_INC(CALL, deferred);

DECREMENT_ADAPTIVE_COUNTER(this_instr[1].cache);

#endif /* ENABLE_SPECIALIZATION */

}

/* Skip 2 cache entries */

// _CALL

{

// oparg counts all of the args, but *not* self:

int total_args = oparg;

if (self_or_null != NULL) {

args--;

total_args++;

}

else if (Py_TYPE(callable) == &PyMethod_Type) {

args--;

total_args++;

PyObject *self = ((PyMethodObject *)callable)->im_self;

args[0] = Py_NewRef(self);

PyObject *method = ((PyMethodObject *)callable)->im_func;

args[-1] = Py_NewRef(method);

Py_DECREF(callable);

callable = method;

}

// Check if the call can be inlined or not

if (Py_TYPE(callable) == &PyFunction_Type &&

tstate->interp->eval_frame == NULL &&

((PyFunctionObject *)callable)->vectorcall == _PyFunction_Vectorcall)

{

int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable))->co_flags;

PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable));

_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(

tstate, (PyFunctionObject *)callable, locals,

args, total_args, NULL

);

// Manipulate stack directly since we leave using DISPATCH_INLINED().

STACK_SHRINK(oparg + 2);

// The frame has stolen all the arguments from the stack,

// so there is no need to clean them up.

if (new_frame == NULL) {

GOTO_ERROR(error);

}

frame->return_offset = (uint16_t)(next_instr - this_instr);

DISPATCH_INLINED(new_frame);

}

/* Callable is not a normal Python function */

res = PyObject_Vectorcall(

callable, args,

total_args | PY_VECTORCALL_ARGUMENTS_OFFSET,

NULL);

if (opcode == INSTRUMENTED_CALL) {

PyObject *arg = total_args == 0 ?

&_PyInstrumentation_MISSING : args[0];

if (res == NULL) {

_Py_call_instrumentation_exc2(

tstate, PY_MONITORING_EVENT_C_RAISE,

frame, this_instr, callable, arg);

}

else {

int err = _Py_call_instrumentation_2args(

tstate, PY_MONITORING_EVENT_C_RETURN,

frame, this_instr, callable, arg);

if (err < 0) {

Py_CLEAR(res);

}

}

}

assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));

Py_DECREF(callable);

for (int i = 0; i < total_args; i++) {

Py_DECREF(args[i]);

}

if (res == NULL) { stack_pointer += -2 - oparg; goto error; }

}

stack_pointer[-2 - oparg] = res;

stack_pointer += -1 - oparg;

CHECK_EVAL_BREAKER();

DISPATCH();

}

TARGET(CALL_ALLOC_AND_ENTER_INIT) {

_Py_CODEUNIT *this_instr = frame->instr_ptr = next_instr;

next_instr += 4;

INSTRUCTION_STATS(CALL_ALLOC_AND_ENTER_INIT);

static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");

PyObject **args;

PyObject *null;

PyObject *callable;

/* Skip 1 cache entry */

/* Skip 2 cache entries */

args = &stack_pointer[-oparg];

null = stack_pointer[-1 - oparg];

callable = stack_pointer[-2 - oparg];

/* This instruction does the following:

_PyCallCache *cache = (_PyCallCache *)&this_instr[1];

DEOPT_IF(null != NULL, CALL);

DEOPT_IF(!PyType_Check(callable), CALL);

PyTypeObject *tp = (PyTypeObject *)callable;

DEOPT_IF(tp->tp_version_tag != read_u32(cache->func_version), CALL);

PyHeapTypeObject *cls = (PyHeapTypeObject *)callable;

PyFunctionObject *init = (PyFunctionObject *)cls->_spec_cache.init;

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

DEOPT_IF(code->co_argcount != oparg+1, CALL);

DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize), CALL);

STAT_INC(CALL, hit);

PyObject *self = _PyType_NewManagedObject(tp);

if (self == NULL) {

GOTO_ERROR(error);

}

Py_DECREF(tp);

_PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked(

tstate, (PyCodeObject *)&_Py_InitCleanup, 1);

assert(_PyCode_CODE((PyCodeObject *)shim->f_executable)[0].op.code == EXIT_INIT_CHECK);

/* Push self onto stack of shim */

Py_INCREF(self);

shim->localsplus[0] = self;

Py_INCREF(init);

_PyInterpreterFrame *init_frame = _PyFrame_PushUnchecked(tstate, init, oparg+1);

/* Copy self followed by args to __init__ frame */

init_frame->localsplus[0] = self;

for (int i = 0; i < oparg; i++) {

init_frame->localsplus[i+1] = args[i];

}

frame->return_offset = (uint16_t)(next_instr - this_instr);

STACK_SHRINK(oparg+2);

_PyFrame_SetStackPointer(frame, stack_pointer);

/* Link frames */

init_frame->previous = shim;

shim->previous = frame;

frame = tstate->current_frame = init_frame;

CALL_STAT_INC(inlined_py_calls);

/* Account for pushing the extra frame.

tstate->py_recursion_remaining--;

goto start_frame;

}

TARGET(CALL_BOUND_METHOD_EXACT_ARGS) {

_Py_CODEUNIT *this_instr = frame->instr_ptr = next_instr;

next_instr += 4;

INSTRUCTION_STATS(CALL_BOUND_METHOD_EXACT_ARGS);

static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");

PyObject *null;

PyObject *callable;

PyObject *func;

PyObject *self;

PyObject *self_or_null;

PyObject **args;

_PyInterpreterFrame *new_frame;

/* Skip 1 cache entry */

// _CHECK_PEP_523

{

DEOPT_IF(tstate->interp->eval_frame, CALL);

}

// _CHECK_CALL_BOUND_METHOD_EXACT_ARGS

null = stack_pointer[-1 - oparg];

callable = stack_pointer[-2 - oparg];

{

DEOPT_IF(null != NULL, CALL);

DEOPT_IF(Py_TYPE(callable) != &PyMethod_Type, CALL);

}

// _INIT_CALL_BOUND_METHOD_EXACT_ARGS

{

STAT_INC(CALL, hit);

self = Py_NewRef(((PyMethodObject *)callable)->im_self);

stack_pointer[-1 - oparg] = self; // Patch stack as it is used by _INIT_CALL_PY_EXACT_ARGS

func = Py_NewRef(((PyMethodObject *)callable)->im_func);

stack_pointer[-2 - oparg] = func; // This is used by CALL, upon deoptimization

Py_DECREF(callable);

}

// _CHECK_FUNCTION_EXACT_ARGS

self_or_null = self;

callable = func;

{

uint32_t func_version = read_u32(&this_instr[2].cache);

DEOPT_IF(!PyFunction_Check(callable), CALL);

PyFunctionObject *func = (PyFunctionObject *)callable;

DEOPT_IF(func->func_version != func_version, CALL);

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

DEOPT_IF(code->co_argcount != oparg + (self_or_null != NULL), CALL);

}

// _CHECK_STACK_SPACE

{

PyFunctionObject *func = (PyFunctionObject *)callable;

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

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

DEOPT_IF(tstate->py_recursion_remaining <= 1, CALL);

}

// _INIT_CALL_PY_EXACT_ARGS

args = &stack_pointer[-oparg];

self_or_null = stack_pointer[-1 - oparg];

{

int argcount = oparg;

if (self_or_null != NULL) {

args--;

argcount++;

}

STAT_INC(CALL, hit);

PyFunctionObject *func = (PyFunctionObject *)callable;

new_frame = _PyFrame_PushUnchecked(tstate, func, argcount);

for (int i = 0; i < argcount; i++) {

new_frame->localsplus[i] = args[i];

}

}

// _SAVE_RETURN_OFFSET

{

#if TIER_ONE

frame->return_offset = (uint16_t)(next_instr - this_instr);

#endif

#if TIER_TWO

frame->return_offset = oparg;

#endif

}

// _PUSH_FRAME

{

// Write it out explicitly because it's subtly different.

// Eventually this should be the only occurrence of this code.

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

stack_pointer += -2 - oparg;

_PyFrame_SetStackPointer(frame, stack_pointer);

new_frame->previous = frame;

CALL_STAT_INC(inlined_py_calls);

frame = tstate->current_frame = new_frame;

tstate->py_recursion_remaining--;

LOAD_SP();

LOAD_IP(0);

#if LLTRACE && TIER_ONE