generated_cases.c.h

// This file is generated by Tools/cases_generator/tier1_generator.py
// from:
// Python/bytecodes.c
// Do not edit!

#ifdefTIER_TWO
#error "This file is for Tier 1 only"
#endif
#defineTIER_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;
 }
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;
 }
Py_DECREF(mgr);
res=PyObject_CallNoArgs(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
 * value returned from calling its __enter__
 */
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;
 }
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;
 }
Py_DECREF(mgr);
res=PyObject_CallNoArgs(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;
 (void)this_instr;
PyObject*rhs;
PyObject*lhs;
PyObject*res;
// _SPECIALIZE_BINARY_OP
rhs=stack_pointer[-1];
lhs=stack_pointer[-2];
 {
uint16_tcounter=read_u16(&this_instr[1].cache);
 (void)counter;
#ifENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr=this_instr;
_Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, LOCALS_ARRAY);
DISPATCH_SAME_OPARG();
 }
STAT_INC(BINARY_OP, deferred);
ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter);
#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);
doubledres=
 ((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
 {
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.
 *
 * When possible, extend `left` in place rather than
 * allocating a new PyUnicodeObject. This attempts to avoid
 * quadratic behavior when one neglects to use str.join().
 *
 * If `left` has only two references remaining (one from
 * the stack, one in the locals), DECREFing `left` leaves
 * only the locals reference, so PyUnicode_Append knows
 * that the string is safe to mutate.
 */
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);
doubledres=
 ((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);
doubledres=
 ((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;
 (void)this_instr;
PyObject*sub;
PyObject*container;
PyObject*res;
// _SPECIALIZE_BINARY_SUBSCR
sub=stack_pointer[-1];
container=stack_pointer[-2];
 {
uint16_tcounter=read_u16(&this_instr[1].cache);
 (void)counter;
#ifENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr=this_instr;
_Py_Specialize_BinarySubscr(container, sub, next_instr);
DISPATCH_SAME_OPARG();
 }
STAT_INC(BINARY_SUBSCR, deferred);
ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter);
#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);
intrc=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_tcached_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_tindex= ((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_tindex= ((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_UCS4c=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_tindex= ((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];
assert(PyTuple_CheckExact(keys));
assert(PyTuple_GET_SIZE(keys) == (Py_ssize_t)oparg);
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;
interr=0;
for (inti=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);
assert(0&&"Executing a cache.");
Py_FatalError("Executing a cache.");
DISPATCH();
 }

TARGET(CALL) {
frame->instr_ptr=next_instr;
next_instr+=4;
INSTRUCTION_STATS(CALL);
PREDICTED(CALL);
_Py_CODEUNIT*this_instr=next_instr-4;
 (void)this_instr;
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_tcounter=read_u16(&this_instr[1].cache);
 (void)counter;
#ifENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr=this_instr;
_Py_Specialize_Call(callable, next_instr, oparg+ (self_or_null!=NULL));
DISPATCH_SAME_OPARG();
 }
STAT_INC(CALL, deferred);
ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter);
#endif/* ENABLE_SPECIALIZATION */
 }
/* Skip 2 cache entries */
// _CALL
 {
// oparg counts all of the args, but *not* self:
inttotal_args=oparg;
if (self_or_null!=NULL) {
args--;
total_args++;
 }
elseif (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)
 {
intcode_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;
 }
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 {
interr=_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 (inti=0; i<total_args; i++) {
Py_DECREF(args[i]);
 }
if (res==NULL) { stack_pointer+=-2-oparg; goto error; }
 }
// _CHECK_PERIODIC
 {
 }
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:
 * 1. Creates the object (by calling ``object.__new__``)
 * 2. Pushes a shim frame to the frame stack (to cleanup after ``__init__``)
 * 3. Pushes the frame for ``__init__`` to the frame stack
 * */
_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);
assert(tp->tp_flags&Py_TPFLAGS_INLINE_VALUES);
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((code->co_flags& (CO_VARKEYWORDS | CO_VARARGS | CO_OPTIMIZED)) !=CO_OPTIMIZED, CALL);
DEOPT_IF(code->co_kwonlyargcount, 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;
 }
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 (inti=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.
 * We don't check recursion depth here,
 * as it will be checked after start_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_tfunc_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];
 {
inthas_self= (self_or_null!=NULL);
STAT_INC(CALL, hit);
PyFunctionObject*func= (PyFunctionObject*)callable;
new_frame=_PyFrame_PushUnchecked(tstate, func, oparg+has_self);
PyObject**first_non_self_local=new_frame->localsplus+has_self;
new_frame->localsplus[0] =self_or_null;
for (inti=0; i<oparg; i++) {
first_non_self_local[i] =args[i];
 }
 }
// _SAVE_RETURN_OFFSET
 {
#ifTIER_ONE
frame->return_offset= (uint16_t)(next_instr-this_instr);
#endif
#ifTIER_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();