LCOV - code coverage report
Current view: top level - Python - generated_cases.c.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 1001 1094 91.5 %
Date: 2023-03-20 08:15:36 Functions: 0 0 -
Branches: 294 421 69.8 %

           Branch data     Line data    Source code
       1                 :            : // This file is generated by Tools/cases_generator/generate_cases.py
       2                 :            : // from:
       3                 :            : //   Python/bytecodes.c
       4                 :            : // Do not edit!
       5                 :            : 
       6                 :     383992 :         TARGET(NOP) {
       7                 :     383992 :             DISPATCH();
       8                 :            :         }
       9                 :            : 
      10         [ +  + ]:    4035495 :         TARGET(RESUME) {
      11                 :            :             #line 89 "Python/bytecodes.c"
      12                 :            :             assert(tstate->cframe == &cframe);
      13                 :            :             assert(frame == cframe.current_frame);
      14                 :            :             if (_Py_atomic_load_relaxed_int32(eval_breaker) && oparg < 2) {
      15                 :            :                 goto handle_eval_breaker;
      16                 :            :             }
      17                 :            :             #line 18 "Python/generated_cases.c.h"
      18                 :    4035436 :             DISPATCH();
      19                 :            :         }
      20                 :            : 
      21         [ -  + ]:      46173 :         TARGET(LOAD_CLOSURE) {
      22                 :            :             PyObject *value;
      23                 :            :             #line 97 "Python/bytecodes.c"
      24                 :            :             /* We keep LOAD_CLOSURE so that the bytecode stays more readable. */
      25                 :            :             value = GETLOCAL(oparg);
      26                 :            :             if (value == NULL) goto unbound_local_error;
      27                 :            :             Py_INCREF(value);
      28                 :            :             #line 29 "Python/generated_cases.c.h"
      29                 :      46173 :             STACK_GROW(1);
      30                 :      46173 :             stack_pointer[-1] = value;
      31                 :      46173 :             DISPATCH();
      32                 :            :         }
      33                 :            : 
      34         [ -  + ]:       3012 :         TARGET(LOAD_FAST_CHECK) {
      35                 :            :             PyObject *value;
      36                 :            :             #line 104 "Python/bytecodes.c"
      37                 :            :             value = GETLOCAL(oparg);
      38                 :            :             if (value == NULL) goto unbound_local_error;
      39                 :            :             Py_INCREF(value);
      40                 :            :             #line 41 "Python/generated_cases.c.h"
      41                 :       3012 :             STACK_GROW(1);
      42                 :       3012 :             stack_pointer[-1] = value;
      43                 :       3012 :             DISPATCH();
      44                 :            :         }
      45                 :            : 
      46                 :   17197868 :         TARGET(LOAD_FAST) {
      47                 :            :             PyObject *value;
      48                 :            :             #line 110 "Python/bytecodes.c"
      49                 :            :             value = GETLOCAL(oparg);
      50                 :            :             assert(value != NULL);
      51                 :            :             Py_INCREF(value);
      52                 :            :             #line 53 "Python/generated_cases.c.h"
      53                 :   17197868 :             STACK_GROW(1);
      54                 :   17197868 :             stack_pointer[-1] = value;
      55                 :   17197868 :             DISPATCH();
      56                 :            :         }
      57                 :            : 
      58                 :    3477988 :         TARGET(LOAD_CONST) {
      59                 :    3477988 :             PREDICTED(LOAD_CONST);
      60                 :            :             PyObject *value;
      61                 :            :             #line 116 "Python/bytecodes.c"
      62                 :            :             value = GETITEM(frame->f_code->co_consts, oparg);
      63                 :            :             Py_INCREF(value);
      64                 :            :             #line 65 "Python/generated_cases.c.h"
      65                 :    3477988 :             STACK_GROW(1);
      66                 :    3477988 :             stack_pointer[-1] = value;
      67                 :    3477988 :             DISPATCH();
      68                 :            :         }
      69                 :            : 
      70                 :    3795677 :         TARGET(STORE_FAST) {
      71         [ +  + ]:    3795677 :             PyObject *value = stack_pointer[-1];
      72                 :            :             #line 121 "Python/bytecodes.c"
      73                 :            :             SETLOCAL(oparg, value);
      74                 :            :             #line 75 "Python/generated_cases.c.h"
      75                 :    3795677 :             STACK_SHRINK(1);
      76                 :    3795677 :             DISPATCH();
      77                 :            :         }
      78                 :            : 
      79                 :    6611510 :         TARGET(LOAD_FAST__LOAD_FAST) {
      80                 :            :             PyObject *_tmp_1;
      81                 :            :             PyObject *_tmp_2;
      82                 :            :             {
      83                 :            :                 PyObject *value;
      84                 :            :                 #line 110 "Python/bytecodes.c"
      85                 :            :                 value = GETLOCAL(oparg);
      86                 :            :                 assert(value != NULL);
      87                 :            :                 Py_INCREF(value);
      88                 :            :                 #line 89 "Python/generated_cases.c.h"
      89                 :    6611510 :                 _tmp_2 = value;
      90                 :            :             }
      91                 :    6611510 :             oparg = (next_instr++)->op.arg;
      92                 :            :             {
      93                 :            :                 PyObject *value;
      94                 :            :                 #line 110 "Python/bytecodes.c"
      95                 :            :                 value = GETLOCAL(oparg);
      96                 :            :                 assert(value != NULL);
      97                 :            :                 Py_INCREF(value);
      98                 :            :                 #line 99 "Python/generated_cases.c.h"
      99                 :    6611510 :                 _tmp_1 = value;
     100                 :            :             }
     101                 :    6611510 :             STACK_GROW(2);
     102                 :    6611510 :             stack_pointer[-1] = _tmp_1;
     103                 :    6611510 :             stack_pointer[-2] = _tmp_2;
     104                 :    6611510 :             DISPATCH();
     105                 :            :         }
     106                 :            : 
     107                 :    1272619 :         TARGET(LOAD_FAST__LOAD_CONST) {
     108                 :            :             PyObject *_tmp_1;
     109                 :            :             PyObject *_tmp_2;
     110                 :            :             {
     111                 :            :                 PyObject *value;
     112                 :            :                 #line 110 "Python/bytecodes.c"
     113                 :            :                 value = GETLOCAL(oparg);
     114                 :            :                 assert(value != NULL);
     115                 :            :                 Py_INCREF(value);
     116                 :            :                 #line 117 "Python/generated_cases.c.h"
     117                 :    1272619 :                 _tmp_2 = value;
     118                 :            :             }
     119                 :    1272619 :             oparg = (next_instr++)->op.arg;
     120                 :            :             {
     121                 :            :                 PyObject *value;
     122                 :            :                 #line 116 "Python/bytecodes.c"
     123                 :            :                 value = GETITEM(frame->f_code->co_consts, oparg);
     124                 :            :                 Py_INCREF(value);
     125                 :            :                 #line 126 "Python/generated_cases.c.h"
     126                 :    1272619 :                 _tmp_1 = value;
     127                 :            :             }
     128                 :    1272619 :             STACK_GROW(2);
     129                 :    1272619 :             stack_pointer[-1] = _tmp_1;
     130                 :    1272619 :             stack_pointer[-2] = _tmp_2;
     131                 :    1272619 :             DISPATCH();
     132                 :            :         }
     133                 :            : 
     134                 :    3895432 :         TARGET(STORE_FAST__LOAD_FAST) {
     135                 :    3895432 :             PyObject *_tmp_1 = stack_pointer[-1];
     136                 :            :             {
     137         [ +  + ]:    3895432 :                 PyObject *value = _tmp_1;
     138                 :            :                 #line 121 "Python/bytecodes.c"
     139                 :            :                 SETLOCAL(oparg, value);
     140                 :            :                 #line 141 "Python/generated_cases.c.h"
     141                 :            :             }
     142                 :    3895432 :             oparg = (next_instr++)->op.arg;
     143                 :            :             {
     144                 :            :                 PyObject *value;
     145                 :            :                 #line 110 "Python/bytecodes.c"
     146                 :            :                 value = GETLOCAL(oparg);
     147                 :            :                 assert(value != NULL);
     148                 :            :                 Py_INCREF(value);
     149                 :            :                 #line 150 "Python/generated_cases.c.h"
     150                 :    3895432 :                 _tmp_1 = value;
     151                 :            :             }
     152                 :    3895432 :             stack_pointer[-1] = _tmp_1;
     153                 :    3895432 :             DISPATCH();
     154                 :            :         }
     155                 :            : 
     156                 :    2334263 :         TARGET(STORE_FAST__STORE_FAST) {
     157                 :    2334263 :             PyObject *_tmp_1 = stack_pointer[-1];
     158                 :    2334263 :             PyObject *_tmp_2 = stack_pointer[-2];
     159                 :            :             {
     160         [ +  + ]:    2334263 :                 PyObject *value = _tmp_1;
     161                 :            :                 #line 121 "Python/bytecodes.c"
     162                 :            :                 SETLOCAL(oparg, value);
     163                 :            :                 #line 164 "Python/generated_cases.c.h"
     164                 :            :             }
     165                 :    2334263 :             oparg = (next_instr++)->op.arg;
     166                 :            :             {
     167         [ +  + ]:    2334263 :                 PyObject *value = _tmp_2;
     168                 :            :                 #line 121 "Python/bytecodes.c"
     169                 :            :                 SETLOCAL(oparg, value);
     170                 :            :                 #line 171 "Python/generated_cases.c.h"
     171                 :            :             }
     172                 :    2334263 :             STACK_SHRINK(2);
     173                 :    2334263 :             DISPATCH();
     174                 :            :         }
     175                 :            : 
     176                 :     936610 :         TARGET(LOAD_CONST__LOAD_FAST) {
     177                 :            :             PyObject *_tmp_1;
     178                 :            :             PyObject *_tmp_2;
     179                 :            :             {
     180                 :            :                 PyObject *value;
     181                 :            :                 #line 116 "Python/bytecodes.c"
     182                 :            :                 value = GETITEM(frame->f_code->co_consts, oparg);
     183                 :            :                 Py_INCREF(value);
     184                 :            :                 #line 185 "Python/generated_cases.c.h"
     185                 :     936610 :                 _tmp_2 = value;
     186                 :            :             }
     187                 :     936610 :             oparg = (next_instr++)->op.arg;
     188                 :            :             {
     189                 :            :                 PyObject *value;
     190                 :            :                 #line 110 "Python/bytecodes.c"
     191                 :            :                 value = GETLOCAL(oparg);
     192                 :            :                 assert(value != NULL);
     193                 :            :                 Py_INCREF(value);
     194                 :            :                 #line 195 "Python/generated_cases.c.h"
     195                 :     936610 :                 _tmp_1 = value;
     196                 :            :             }
     197                 :     936610 :             STACK_GROW(2);
     198                 :     936610 :             stack_pointer[-1] = _tmp_1;
     199                 :     936610 :             stack_pointer[-2] = _tmp_2;
     200                 :     936610 :             DISPATCH();
     201                 :            :         }
     202                 :            : 
     203                 :    1797369 :         TARGET(POP_TOP) {
     204                 :    1797369 :             PyObject *value = stack_pointer[-1];
     205                 :            :             #line 131 "Python/bytecodes.c"
     206                 :            :             #line 207 "Python/generated_cases.c.h"
     207         [ +  + ]:    1797369 :             Py_DECREF(value);
     208                 :    1797369 :             STACK_SHRINK(1);
     209                 :    1797369 :             DISPATCH();
     210                 :            :         }
     211                 :            : 
     212                 :    1841863 :         TARGET(PUSH_NULL) {
     213                 :            :             PyObject *res;
     214                 :            :             #line 135 "Python/bytecodes.c"
     215                 :            :             res = NULL;
     216                 :            :             #line 217 "Python/generated_cases.c.h"
     217                 :    1841863 :             STACK_GROW(1);
     218                 :    1841863 :             stack_pointer[-1] = res;
     219                 :    1841863 :             DISPATCH();
     220                 :            :         }
     221                 :            : 
     222                 :         69 :         TARGET(END_FOR) {
     223                 :         69 :             PyObject *_tmp_1 = stack_pointer[-1];
     224                 :         69 :             PyObject *_tmp_2 = stack_pointer[-2];
     225                 :            :             {
     226                 :         69 :                 PyObject *value = _tmp_1;
     227                 :            :                 #line 131 "Python/bytecodes.c"
     228                 :            :                 #line 229 "Python/generated_cases.c.h"
     229         [ -  + ]:         69 :                 Py_DECREF(value);
     230                 :            :             }
     231                 :            :             {
     232                 :         69 :                 PyObject *value = _tmp_2;
     233                 :            :                 #line 131 "Python/bytecodes.c"
     234                 :            :                 #line 235 "Python/generated_cases.c.h"
     235         [ +  + ]:         69 :                 Py_DECREF(value);
     236                 :            :             }
     237                 :         69 :             STACK_SHRINK(2);
     238                 :         69 :             DISPATCH();
     239                 :            :         }
     240                 :            : 
     241                 :      45079 :         TARGET(UNARY_NEGATIVE) {
     242                 :      45079 :             PyObject *value = stack_pointer[-1];
     243                 :            :             PyObject *res;
     244                 :            :             #line 141 "Python/bytecodes.c"
     245                 :            :             res = PyNumber_Negative(value);
     246                 :            :             #line 247 "Python/generated_cases.c.h"
     247         [ +  + ]:      45079 :             Py_DECREF(value);
     248                 :            :             #line 143 "Python/bytecodes.c"
     249                 :            :             if (res == NULL) goto pop_1_error;
     250                 :            :             #line 251 "Python/generated_cases.c.h"
     251                 :      45079 :             stack_pointer[-1] = res;
     252                 :      45079 :             DISPATCH();
     253                 :            :         }
     254                 :            : 
     255                 :        636 :         TARGET(UNARY_NOT) {
     256                 :        636 :             PyObject *value = stack_pointer[-1];
     257                 :            :             PyObject *res;
     258                 :            :             #line 147 "Python/bytecodes.c"
     259                 :            :             int err = PyObject_IsTrue(value);
     260                 :            :             #line 261 "Python/generated_cases.c.h"
     261         [ -  + ]:        636 :             Py_DECREF(value);
     262                 :            :             #line 149 "Python/bytecodes.c"
     263                 :            :             if (err < 0) goto pop_1_error;
     264                 :            :             if (err == 0) {
     265                 :            :                 res = Py_True;
     266                 :            :             }
     267                 :            :             else {
     268                 :            :                 res = Py_False;
     269                 :            :             }
     270                 :            :             Py_INCREF(res);
     271                 :            :             #line 272 "Python/generated_cases.c.h"
     272                 :        636 :             stack_pointer[-1] = res;
     273                 :        636 :             DISPATCH();
     274                 :            :         }
     275                 :            : 
     276                 :      18211 :         TARGET(UNARY_INVERT) {
     277                 :      18211 :             PyObject *value = stack_pointer[-1];
     278                 :            :             PyObject *res;
     279                 :            :             #line 160 "Python/bytecodes.c"
     280                 :            :             res = PyNumber_Invert(value);
     281                 :            :             #line 282 "Python/generated_cases.c.h"
     282         [ +  + ]:      18211 :             Py_DECREF(value);
     283                 :            :             #line 162 "Python/bytecodes.c"
     284                 :            :             if (res == NULL) goto pop_1_error;
     285                 :            :             #line 286 "Python/generated_cases.c.h"
     286                 :      18211 :             stack_pointer[-1] = res;
     287                 :      18211 :             DISPATCH();
     288                 :            :         }
     289                 :            : 
     290                 :     439353 :         TARGET(BINARY_OP_MULTIPLY_INT) {
     291                 :     439353 :             PyObject *right = stack_pointer[-1];
     292         [ +  + ]:     439353 :             PyObject *left = stack_pointer[-2];
     293                 :            :             PyObject *prod;
     294                 :            :             #line 179 "Python/bytecodes.c"
     295                 :            :             assert(cframe.use_tracing == 0);
     296                 :            :             DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
     297                 :            :             DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);
     298                 :            :             STAT_INC(BINARY_OP, hit);
     299                 :            :             prod = _PyLong_Multiply((PyLongObject *)left, (PyLongObject *)right);
     300                 :            :             _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
     301                 :            :             _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
     302                 :            :             if (prod == NULL) goto pop_2_error;
     303                 :            :             #line 304 "Python/generated_cases.c.h"
     304                 :     439275 :             STACK_SHRINK(1);
     305                 :     439275 :             stack_pointer[-1] = prod;
     306                 :     439275 :             next_instr += 1;
     307                 :     439275 :             DISPATCH();
     308                 :            :         }
     309                 :            : 
     310                 :     602046 :         TARGET(BINARY_OP_MULTIPLY_FLOAT) {
     311                 :     602046 :             PyObject *right = stack_pointer[-1];
     312         [ +  + ]:     602046 :             PyObject *left = stack_pointer[-2];
     313                 :            :             PyObject *prod;
     314                 :            :             #line 190 "Python/bytecodes.c"
     315                 :            :             assert(cframe.use_tracing == 0);
     316                 :            :             DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);
     317                 :            :             DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);
     318                 :            :             STAT_INC(BINARY_OP, hit);
     319                 :            :             double dprod = ((PyFloatObject *)left)->ob_fval *
     320                 :            :                 ((PyFloatObject *)right)->ob_fval;
     321                 :            :             DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dprod, prod);
     322                 :            :             #line 323 "Python/generated_cases.c.h"
     323                 :     602045 :             STACK_SHRINK(1);
     324                 :     602045 :             stack_pointer[-1] = prod;
     325                 :     602045 :             next_instr += 1;
     326                 :     602045 :             DISPATCH();
     327                 :            :         }
     328                 :            : 
     329                 :    1662277 :         TARGET(BINARY_OP_SUBTRACT_INT) {
     330                 :    1662277 :             PyObject *right = stack_pointer[-1];
     331         [ -  + ]:    1662277 :             PyObject *left = stack_pointer[-2];
     332                 :            :             PyObject *sub;
     333                 :            :             #line 200 "Python/bytecodes.c"
     334                 :            :             assert(cframe.use_tracing == 0);
     335                 :            :             DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
     336                 :            :             DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);
     337                 :            :             STAT_INC(BINARY_OP, hit);
     338                 :            :             sub = _PyLong_Subtract((PyLongObject *)left, (PyLongObject *)right);
     339                 :            :             _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
     340                 :            :             _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
     341                 :            :             if (sub == NULL) goto pop_2_error;
     342                 :            :             #line 343 "Python/generated_cases.c.h"
     343                 :    1662277 :             STACK_SHRINK(1);
     344                 :    1662277 :             stack_pointer[-1] = sub;
     345                 :    1662277 :             next_instr += 1;
     346                 :    1662277 :             DISPATCH();
     347                 :            :         }
     348                 :            : 
     349                 :     655270 :         TARGET(BINARY_OP_SUBTRACT_FLOAT) {
     350                 :     655270 :             PyObject *right = stack_pointer[-1];
     351         [ -  + ]:     655270 :             PyObject *left = stack_pointer[-2];
     352                 :            :             PyObject *sub;
     353                 :            :             #line 211 "Python/bytecodes.c"
     354                 :            :             assert(cframe.use_tracing == 0);
     355                 :            :             DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);
     356                 :            :             DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);
     357                 :            :             STAT_INC(BINARY_OP, hit);
     358                 :            :             double dsub = ((PyFloatObject *)left)->ob_fval - ((PyFloatObject *)right)->ob_fval;
     359                 :            :             DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dsub, sub);
     360                 :            :             #line 361 "Python/generated_cases.c.h"
     361                 :     654271 :             STACK_SHRINK(1);
     362                 :     654271 :             stack_pointer[-1] = sub;
     363                 :     654271 :             next_instr += 1;
     364                 :     654271 :             DISPATCH();
     365                 :            :         }
     366                 :            : 
     367                 :      92351 :         TARGET(BINARY_OP_ADD_UNICODE) {
     368                 :      92351 :             PyObject *right = stack_pointer[-1];
     369         [ -  + ]:      92351 :             PyObject *left = stack_pointer[-2];
     370                 :            :             PyObject *res;
     371                 :            :             #line 220 "Python/bytecodes.c"
     372                 :            :             assert(cframe.use_tracing == 0);
     373                 :            :             DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);
     374                 :            :             DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
     375                 :            :             STAT_INC(BINARY_OP, hit);
     376                 :            :             res = PyUnicode_Concat(left, right);
     377                 :            :             _Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc);
     378                 :            :             _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
     379                 :            :             if (res == NULL) goto pop_2_error;
     380                 :            :             #line 381 "Python/generated_cases.c.h"
     381                 :      92351 :             STACK_SHRINK(1);
     382                 :      92351 :             stack_pointer[-1] = res;
     383                 :      92351 :             next_instr += 1;
     384                 :      92351 :             DISPATCH();
     385                 :            :         }
     386                 :            : 
     387                 :       2240 :         TARGET(BINARY_OP_INPLACE_ADD_UNICODE) {
     388                 :       2240 :             PyObject *right = stack_pointer[-1];
     389         [ -  + ]:       2240 :             PyObject *left = stack_pointer[-2];
     390                 :            :             #line 237 "Python/bytecodes.c"
     391                 :            :             assert(cframe.use_tracing == 0);
     392                 :            :             DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);
     393                 :            :             DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
     394                 :            :             _Py_CODEUNIT true_next = next_instr[INLINE_CACHE_ENTRIES_BINARY_OP];
     395                 :            :             assert(true_next.op.code == STORE_FAST ||
     396                 :            :                    true_next.op.code == STORE_FAST__LOAD_FAST);
     397                 :            :             PyObject **target_local = &GETLOCAL(true_next.op.arg);
     398                 :            :             DEOPT_IF(*target_local != left, BINARY_OP);
     399                 :            :             STAT_INC(BINARY_OP, hit);
     400                 :            :             /* Handle `left = left + right` or `left += right` for str.
     401                 :            :              *
     402                 :            :              * When possible, extend `left` in place rather than
     403                 :            :              * allocating a new PyUnicodeObject. This attempts to avoid
     404                 :            :              * quadratic behavior when one neglects to use str.join().
     405                 :            :              *
     406                 :            :              * If `left` has only two references remaining (one from
     407                 :            :              * the stack, one in the locals), DECREFing `left` leaves
     408                 :            :              * only the locals reference, so PyUnicode_Append knows
     409                 :            :              * that the string is safe to mutate.
     410                 :            :              */
     411                 :            :             assert(Py_REFCNT(left) >= 2);
     412                 :            :             _Py_DECREF_NO_DEALLOC(left);
     413                 :            :             PyUnicode_Append(target_local, right);
     414                 :            :             _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
     415                 :            :             if (*target_local == NULL) goto pop_2_error;
     416                 :            :             // The STORE_FAST is already done.
     417                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP + 1);
     418                 :            :             #line 419 "Python/generated_cases.c.h"
     419                 :       2187 :             STACK_SHRINK(2);
     420                 :       2187 :             DISPATCH();
     421                 :            :         }
     422                 :            : 
     423                 :     201021 :         TARGET(BINARY_OP_ADD_FLOAT) {
     424                 :     201021 :             PyObject *right = stack_pointer[-1];
     425         [ +  + ]:     201021 :             PyObject *left = stack_pointer[-2];
     426                 :            :             PyObject *sum;
     427                 :            :             #line 267 "Python/bytecodes.c"
     428                 :            :             assert(cframe.use_tracing == 0);
     429                 :            :             DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);
     430                 :            :             DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
     431                 :            :             STAT_INC(BINARY_OP, hit);
     432                 :            :             double dsum = ((PyFloatObject *)left)->ob_fval +
     433                 :            :                 ((PyFloatObject *)right)->ob_fval;
     434                 :            :             DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dsum, sum);
     435                 :            :             #line 436 "Python/generated_cases.c.h"
     436                 :     200022 :             STACK_SHRINK(1);
     437                 :     200022 :             stack_pointer[-1] = sum;
     438                 :     200022 :             next_instr += 1;
     439                 :     200022 :             DISPATCH();
     440                 :            :         }
     441                 :            : 
     442                 :    1310070 :         TARGET(BINARY_OP_ADD_INT) {
     443                 :    1310070 :             PyObject *right = stack_pointer[-1];
     444         [ -  + ]:    1310070 :             PyObject *left = stack_pointer[-2];
     445                 :            :             PyObject *sum;
     446                 :            :             #line 277 "Python/bytecodes.c"
     447                 :            :             assert(cframe.use_tracing == 0);
     448                 :            :             DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
     449                 :            :             DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
     450                 :            :             STAT_INC(BINARY_OP, hit);
     451                 :            :             sum = _PyLong_Add((PyLongObject *)left, (PyLongObject *)right);
     452                 :            :             _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
     453                 :            :             _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
     454                 :            :             if (sum == NULL) goto pop_2_error;
     455                 :            :             #line 456 "Python/generated_cases.c.h"
     456                 :    1310038 :             STACK_SHRINK(1);
     457                 :    1310038 :             stack_pointer[-1] = sum;
     458                 :    1310038 :             next_instr += 1;
     459                 :    1310038 :             DISPATCH();
     460                 :            :         }
     461                 :            : 
     462                 :     113713 :         TARGET(BINARY_SUBSCR) {
     463                 :     114248 :             PREDICTED(BINARY_SUBSCR);
     464                 :            :             static_assert(INLINE_CACHE_ENTRIES_BINARY_SUBSCR == 4, "incorrect cache size");
     465                 :     114248 :             PyObject *sub = stack_pointer[-1];
     466         [ +  + ]:     114248 :             PyObject *container = stack_pointer[-2];
     467                 :            :             PyObject *res;
     468                 :            :             #line 296 "Python/bytecodes.c"
     469                 :            :             #if ENABLE_SPECIALIZATION
     470                 :            :             _PyBinarySubscrCache *cache = (_PyBinarySubscrCache *)next_instr;
     471                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
     472                 :            :                 assert(cframe.use_tracing == 0);
     473                 :            :                 next_instr--;
     474                 :            :                 _Py_Specialize_BinarySubscr(container, sub, next_instr);
     475                 :            :                 DISPATCH_SAME_OPARG();
     476                 :            :             }
     477                 :            :             STAT_INC(BINARY_SUBSCR, deferred);
     478                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
     479                 :            :             #endif  /* ENABLE_SPECIALIZATION */
     480                 :            :             res = PyObject_GetItem(container, sub);
     481                 :            :             #line 482 "Python/generated_cases.c.h"
     482         [ +  + ]:     112805 :             Py_DECREF(container);
     483         [ +  + ]:     112805 :             Py_DECREF(sub);
     484                 :            :             #line 309 "Python/bytecodes.c"
     485                 :            :             if (res == NULL) goto pop_2_error;
     486                 :            :             #line 487 "Python/generated_cases.c.h"
     487                 :     112051 :             STACK_SHRINK(1);
     488                 :     112051 :             stack_pointer[-1] = res;
     489                 :     112051 :             next_instr += 4;
     490                 :     112051 :             DISPATCH();
     491                 :            :         }
     492                 :            : 
     493                 :      81347 :         TARGET(BINARY_SLICE) {
     494                 :      81347 :             PyObject *stop = stack_pointer[-1];
     495                 :      81347 :             PyObject *start = stack_pointer[-2];
     496                 :      81347 :             PyObject *container = stack_pointer[-3];
     497                 :            :             PyObject *res;
     498                 :            :             #line 313 "Python/bytecodes.c"
     499                 :            :             PyObject *slice = _PyBuildSlice_ConsumeRefs(start, stop);
     500                 :            :             // Can't use ERROR_IF() here, because we haven't
     501                 :            :             // DECREF'ed container yet, and we still own slice.
     502                 :            :             if (slice == NULL) {
     503                 :            :                 res = NULL;
     504                 :            :             }
     505                 :            :             else {
     506                 :            :                 res = PyObject_GetItem(container, slice);
     507                 :            :                 Py_DECREF(slice);
     508                 :            :             }
     509                 :            :             Py_DECREF(container);
     510                 :            :             if (res == NULL) goto pop_3_error;
     511                 :            :             #line 512 "Python/generated_cases.c.h"
     512                 :      81347 :             STACK_SHRINK(2);
     513                 :      81347 :             stack_pointer[-1] = res;
     514                 :      81347 :             DISPATCH();
     515                 :            :         }
     516                 :            : 
     517                 :         46 :         TARGET(STORE_SLICE) {
     518                 :         46 :             PyObject *stop = stack_pointer[-1];
     519                 :         46 :             PyObject *start = stack_pointer[-2];
     520                 :         46 :             PyObject *container = stack_pointer[-3];
     521                 :         46 :             PyObject *v = stack_pointer[-4];
     522                 :            :             #line 328 "Python/bytecodes.c"
     523                 :            :             PyObject *slice = _PyBuildSlice_ConsumeRefs(start, stop);
     524                 :            :             int err;
     525                 :            :             if (slice == NULL) {
     526                 :            :                 err = 1;
     527                 :            :             }
     528                 :            :             else {
     529                 :            :                 err = PyObject_SetItem(container, slice, v);
     530                 :            :                 Py_DECREF(slice);
     531                 :            :             }
     532                 :            :             Py_DECREF(v);
     533                 :            :             Py_DECREF(container);
     534                 :            :             if (err) goto pop_4_error;
     535                 :            :             #line 536 "Python/generated_cases.c.h"
     536                 :         46 :             STACK_SHRINK(4);
     537                 :         46 :             DISPATCH();
     538                 :            :         }
     539                 :            : 
     540                 :     538690 :         TARGET(BINARY_SUBSCR_LIST_INT) {
     541                 :     538690 :             PyObject *sub = stack_pointer[-1];
     542         [ -  + ]:     538690 :             PyObject *list = stack_pointer[-2];
     543                 :            :             PyObject *res;
     544                 :            :             #line 343 "Python/bytecodes.c"
     545                 :            :             assert(cframe.use_tracing == 0);
     546                 :            :             DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);
     547                 :            :             DEOPT_IF(!PyList_CheckExact(list), BINARY_SUBSCR);
     548                 :            : 
     549                 :            :             // Deopt unless 0 <= sub < PyList_Size(list)
     550                 :            :             DEOPT_IF(!_PyLong_IsPositiveSingleDigit(sub), BINARY_SUBSCR);
     551                 :            :             assert(((PyLongObject *)_PyLong_GetZero())->long_value.ob_digit[0] == 0);
     552                 :            :             Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
     553                 :            :             DEOPT_IF(index >= PyList_GET_SIZE(list), BINARY_SUBSCR);
     554                 :            :             STAT_INC(BINARY_SUBSCR, hit);
     555                 :            :             res = PyList_GET_ITEM(list, index);
     556                 :            :             assert(res != NULL);
     557                 :            :             Py_INCREF(res);
     558                 :            :             _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
     559                 :            :             Py_DECREF(list);
     560                 :            :             #line 561 "Python/generated_cases.c.h"
     561                 :     538155 :             STACK_SHRINK(1);
     562                 :     538155 :             stack_pointer[-1] = res;
     563                 :     538155 :             next_instr += 4;
     564                 :     538155 :             DISPATCH();
     565                 :            :         }
     566                 :            : 
     567                 :      12648 :         TARGET(BINARY_SUBSCR_TUPLE_INT) {
     568                 :      12648 :             PyObject *sub = stack_pointer[-1];
     569         [ -  + ]:      12648 :             PyObject *tuple = stack_pointer[-2];
     570                 :            :             PyObject *res;
     571                 :            :             #line 361 "Python/bytecodes.c"
     572                 :            :             assert(cframe.use_tracing == 0);
     573                 :            :             DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);
     574                 :            :             DEOPT_IF(!PyTuple_CheckExact(tuple), BINARY_SUBSCR);
     575                 :            : 
     576                 :            :             // Deopt unless 0 <= sub < PyTuple_Size(list)
     577                 :            :             DEOPT_IF(!_PyLong_IsPositiveSingleDigit(sub), BINARY_SUBSCR);
     578                 :            :             assert(((PyLongObject *)_PyLong_GetZero())->long_value.ob_digit[0] == 0);
     579                 :            :             Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
     580                 :            :             DEOPT_IF(index >= PyTuple_GET_SIZE(tuple), BINARY_SUBSCR);
     581                 :            :             STAT_INC(BINARY_SUBSCR, hit);
     582                 :            :             res = PyTuple_GET_ITEM(tuple, index);
     583                 :            :             assert(res != NULL);
     584                 :            :             Py_INCREF(res);
     585                 :            :             _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
     586                 :            :             Py_DECREF(tuple);
     587                 :            :             #line 588 "Python/generated_cases.c.h"
     588                 :      12648 :             STACK_SHRINK(1);
     589                 :      12648 :             stack_pointer[-1] = res;
     590                 :      12648 :             next_instr += 4;
     591                 :      12648 :             DISPATCH();
     592                 :            :         }
     593                 :            : 
     594                 :      24503 :         TARGET(BINARY_SUBSCR_DICT) {
     595                 :      24503 :             PyObject *sub = stack_pointer[-1];
     596         [ -  + ]:      24503 :             PyObject *dict = stack_pointer[-2];
     597                 :            :             PyObject *res;
     598                 :            :             #line 379 "Python/bytecodes.c"
     599                 :            :             assert(cframe.use_tracing == 0);
     600                 :            :             DEOPT_IF(!PyDict_CheckExact(dict), BINARY_SUBSCR);
     601                 :            :             STAT_INC(BINARY_SUBSCR, hit);
     602                 :            :             res = PyDict_GetItemWithError(dict, sub);
     603                 :            :             if (res == NULL) {
     604                 :            :                 if (!_PyErr_Occurred(tstate)) {
     605                 :            :                     _PyErr_SetKeyError(sub);
     606                 :            :                 }
     607                 :            :             #line 608 "Python/generated_cases.c.h"
     608         [ -  + ]:       1336 :                 Py_DECREF(dict);
     609         [ -  + ]:       1336 :                 Py_DECREF(sub);
     610                 :            :             #line 388 "Python/bytecodes.c"
     611                 :            :                 if (true) goto pop_2_error;
     612                 :            :             }
     613                 :            :             Py_INCREF(res);  // Do this before DECREF'ing dict, sub
     614                 :            :             #line 615 "Python/generated_cases.c.h"
     615         [ +  + ]:      23167 :             Py_DECREF(dict);
     616         [ +  + ]:      23167 :             Py_DECREF(sub);
     617                 :      23167 :             STACK_SHRINK(1);
     618                 :      23167 :             stack_pointer[-1] = res;
     619                 :      23167 :             next_instr += 4;
     620                 :      23167 :             DISPATCH();
     621                 :            :         }
     622                 :            : 
     623                 :       2025 :         TARGET(BINARY_SUBSCR_GETITEM) {
     624                 :       2025 :             PyObject *sub = stack_pointer[-1];
     625                 :       2025 :             PyObject *container = stack_pointer[-2];
     626                 :       2025 :             uint32_t type_version = read_u32(&next_instr[1].cache);
     627                 :       2025 :             uint16_t func_version = read_u16(&next_instr[3].cache);
     628                 :            :             #line 395 "Python/bytecodes.c"
     629                 :            :             PyTypeObject *tp = Py_TYPE(container);
     630                 :            :             DEOPT_IF(tp->tp_version_tag != type_version, BINARY_SUBSCR);
     631                 :            :             assert(tp->tp_flags & Py_TPFLAGS_HEAPTYPE);
     632                 :            :             PyObject *cached = ((PyHeapTypeObject *)tp)->_spec_cache.getitem;
     633                 :            :             assert(PyFunction_Check(cached));
     634                 :            :             PyFunctionObject *getitem = (PyFunctionObject *)cached;
     635                 :            :             DEOPT_IF(getitem->func_version != func_version, BINARY_SUBSCR);
     636                 :            :             PyCodeObject *code = (PyCodeObject *)getitem->func_code;
     637                 :            :             assert(code->co_argcount == 2);
     638                 :            :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), BINARY_SUBSCR);
     639                 :            :             STAT_INC(BINARY_SUBSCR, hit);
     640                 :            :             Py_INCREF(getitem);
     641                 :            :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, getitem, 2);
     642                 :            :             STACK_SHRINK(2);
     643                 :            :             new_frame->localsplus[0] = container;
     644                 :            :             new_frame->localsplus[1] = sub;
     645                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
     646                 :            :             DISPATCH_INLINED(new_frame);
     647                 :            :             #line 648 "Python/generated_cases.c.h"
     648                 :            :         }
     649                 :            : 
     650                 :     411909 :         TARGET(LIST_APPEND) {
     651                 :     411909 :             PyObject *v = stack_pointer[-1];
     652                 :     411909 :             PyObject *list = stack_pointer[-(2 + (oparg-1))];
     653                 :            :             #line 416 "Python/bytecodes.c"
     654                 :            :             if (_PyList_AppendTakeRef((PyListObject *)list, v) < 0) goto pop_1_error;
     655                 :            :             #line 656 "Python/generated_cases.c.h"
     656                 :     411909 :             STACK_SHRINK(1);
     657                 :            :             PREDICT(JUMP_BACKWARD);
     658                 :     411909 :             DISPATCH();
     659                 :            :         }
     660                 :            : 
     661                 :         51 :         TARGET(SET_ADD) {
     662                 :         51 :             PyObject *v = stack_pointer[-1];
     663                 :         51 :             PyObject *set = stack_pointer[-(2 + (oparg-1))];
     664                 :            :             #line 421 "Python/bytecodes.c"
     665                 :            :             int err = PySet_Add(set, v);
     666                 :            :             #line 667 "Python/generated_cases.c.h"
     667         [ -  + ]:         51 :             Py_DECREF(v);
     668                 :            :             #line 423 "Python/bytecodes.c"
     669                 :            :             if (err) goto pop_1_error;
     670                 :            :             #line 671 "Python/generated_cases.c.h"
     671                 :         51 :             STACK_SHRINK(1);
     672                 :            :             PREDICT(JUMP_BACKWARD);
     673                 :         51 :             DISPATCH();
     674                 :            :         }
     675                 :            : 
     676                 :       6909 :         TARGET(STORE_SUBSCR) {
     677                 :       6909 :             PREDICTED(STORE_SUBSCR);
     678                 :            :             static_assert(INLINE_CACHE_ENTRIES_STORE_SUBSCR == 1, "incorrect cache size");
     679                 :       6909 :             PyObject *sub = stack_pointer[-1];
     680                 :       6909 :             PyObject *container = stack_pointer[-2];
     681                 :       6909 :             PyObject *v = stack_pointer[-3];
     682                 :       6909 :             uint16_t counter = read_u16(&next_instr[0].cache);
     683                 :            :             #line 434 "Python/bytecodes.c"
     684                 :            :             #if ENABLE_SPECIALIZATION
     685                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {
     686                 :            :                 assert(cframe.use_tracing == 0);
     687                 :            :                 next_instr--;
     688                 :            :                 _Py_Specialize_StoreSubscr(container, sub, next_instr);
     689                 :            :                 DISPATCH_SAME_OPARG();
     690                 :            :             }
     691                 :            :             STAT_INC(STORE_SUBSCR, deferred);
     692                 :            :             _PyStoreSubscrCache *cache = (_PyStoreSubscrCache *)next_instr;
     693                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
     694                 :            :             #else
     695                 :            :             (void)counter;  // Unused.
     696                 :            :             #endif  /* ENABLE_SPECIALIZATION */
     697                 :            :             /* container[sub] = v */
     698                 :            :             int err = PyObject_SetItem(container, sub, v);
     699                 :            :             #line 700 "Python/generated_cases.c.h"
     700         [ -  + ]:       6344 :             Py_DECREF(v);
     701         [ -  + ]:       6344 :             Py_DECREF(container);
     702         [ -  + ]:       6344 :             Py_DECREF(sub);
     703                 :            :             #line 450 "Python/bytecodes.c"
     704                 :            :             if (err) goto pop_3_error;
     705                 :            :             #line 706 "Python/generated_cases.c.h"
     706                 :       6341 :             STACK_SHRINK(3);
     707                 :       6341 :             next_instr += 1;
     708                 :       6341 :             DISPATCH();
     709                 :            :         }
     710                 :            : 
     711                 :     519769 :         TARGET(STORE_SUBSCR_LIST_INT) {
     712                 :     519769 :             PyObject *sub = stack_pointer[-1];
     713                 :     519769 :             PyObject *list = stack_pointer[-2];
     714         [ -  + ]:     519769 :             PyObject *value = stack_pointer[-3];
     715                 :            :             #line 454 "Python/bytecodes.c"
     716                 :            :             assert(cframe.use_tracing == 0);
     717                 :            :             DEOPT_IF(!PyLong_CheckExact(sub), STORE_SUBSCR);
     718                 :            :             DEOPT_IF(!PyList_CheckExact(list), STORE_SUBSCR);
     719                 :            : 
     720                 :            :             // Ensure nonnegative, zero-or-one-digit ints.
     721                 :            :             DEOPT_IF(!_PyLong_IsPositiveSingleDigit(sub), STORE_SUBSCR);
     722                 :            :             Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0];
     723                 :            :             // Ensure index < len(list)
     724                 :            :             DEOPT_IF(index >= PyList_GET_SIZE(list), STORE_SUBSCR);
     725                 :            :             STAT_INC(STORE_SUBSCR, hit);
     726                 :            : 
     727                 :            :             PyObject *old_value = PyList_GET_ITEM(list, index);
     728                 :            :             PyList_SET_ITEM(list, index, value);
     729                 :            :             assert(old_value != NULL);
     730                 :            :             Py_DECREF(old_value);
     731                 :            :             _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
     732                 :            :             Py_DECREF(list);
     733                 :            :             #line 734 "Python/generated_cases.c.h"
     734                 :     519769 :             STACK_SHRINK(3);
     735                 :     519769 :             next_instr += 1;
     736                 :     519769 :             DISPATCH();
     737                 :            :         }
     738                 :            : 
     739                 :     101571 :         TARGET(STORE_SUBSCR_DICT) {
     740                 :     101571 :             PyObject *sub = stack_pointer[-1];
     741                 :     101571 :             PyObject *dict = stack_pointer[-2];
     742         [ -  + ]:     101571 :             PyObject *value = stack_pointer[-3];
     743                 :            :             #line 474 "Python/bytecodes.c"
     744                 :            :             assert(cframe.use_tracing == 0);
     745                 :            :             DEOPT_IF(!PyDict_CheckExact(dict), STORE_SUBSCR);
     746                 :            :             STAT_INC(STORE_SUBSCR, hit);
     747                 :            :             int err = _PyDict_SetItem_Take2((PyDictObject *)dict, sub, value);
     748                 :            :             Py_DECREF(dict);
     749                 :            :             if (err) goto pop_3_error;
     750                 :            :             #line 751 "Python/generated_cases.c.h"
     751                 :     101571 :             STACK_SHRINK(3);
     752                 :     101571 :             next_instr += 1;
     753                 :     101571 :             DISPATCH();
     754                 :            :         }
     755                 :            : 
     756                 :       1235 :         TARGET(DELETE_SUBSCR) {
     757                 :       1235 :             PyObject *sub = stack_pointer[-1];
     758                 :       1235 :             PyObject *container = stack_pointer[-2];
     759                 :            :             #line 483 "Python/bytecodes.c"
     760                 :            :             /* del container[sub] */
     761                 :            :             int err = PyObject_DelItem(container, sub);
     762                 :            :             #line 763 "Python/generated_cases.c.h"
     763         [ -  + ]:       1235 :             Py_DECREF(container);
     764         [ +  + ]:       1235 :             Py_DECREF(sub);
     765                 :            :             #line 486 "Python/bytecodes.c"
     766                 :            :             if (err) goto pop_2_error;
     767                 :            :             #line 768 "Python/generated_cases.c.h"
     768                 :       1234 :             STACK_SHRINK(2);
     769                 :       1234 :             DISPATCH();
     770                 :            :         }
     771                 :            : 
     772                 :       3351 :         TARGET(CALL_INTRINSIC_1) {
     773                 :       3351 :             PyObject *value = stack_pointer[-1];
     774                 :            :             PyObject *res;
     775                 :            :             #line 490 "Python/bytecodes.c"
     776                 :            :             assert(oparg <= MAX_INTRINSIC_1);
     777                 :            :             res = _PyIntrinsics_UnaryFunctions[oparg](tstate, value);
     778                 :            :             #line 779 "Python/generated_cases.c.h"
     779         [ +  + ]:       3351 :             Py_DECREF(value);
     780                 :            :             #line 493 "Python/bytecodes.c"
     781                 :            :             if (res == NULL) goto pop_1_error;
     782                 :            :             #line 783 "Python/generated_cases.c.h"
     783                 :       3351 :             stack_pointer[-1] = res;
     784                 :       3351 :             DISPATCH();
     785                 :            :         }
     786                 :            : 
     787                 :          0 :         TARGET(CALL_INTRINSIC_2) {
     788                 :          0 :             PyObject *value1 = stack_pointer[-1];
     789                 :          0 :             PyObject *value2 = stack_pointer[-2];
     790                 :            :             PyObject *res;
     791                 :            :             #line 497 "Python/bytecodes.c"
     792                 :            :             assert(oparg <= MAX_INTRINSIC_2);
     793                 :            :             res = _PyIntrinsics_BinaryFunctions[oparg](tstate, value2, value1);
     794                 :            :             #line 795 "Python/generated_cases.c.h"
     795         [ #  # ]:          0 :             Py_DECREF(value2);
     796         [ #  # ]:          0 :             Py_DECREF(value1);
     797                 :            :             #line 500 "Python/bytecodes.c"
     798                 :            :             if (res == NULL) goto pop_2_error;
     799                 :            :             #line 800 "Python/generated_cases.c.h"
     800                 :          0 :             STACK_SHRINK(1);
     801                 :          0 :             stack_pointer[-1] = res;
     802                 :          0 :             DISPATCH();
     803                 :            :         }
     804                 :            : 
     805                 :        413 :         TARGET(RAISE_VARARGS) {
     806   [ +  +  +  - ]:        413 :             PyObject **args = (stack_pointer - oparg);
     807                 :            :             #line 504 "Python/bytecodes.c"
     808                 :            :             PyObject *cause = NULL, *exc = NULL;
     809                 :            :             switch (oparg) {
     810                 :            :             case 2:
     811                 :            :                 cause = args[1];
     812                 :            :                 /* fall through */
     813                 :            :             case 1:
     814                 :            :                 exc = args[0];
     815                 :            :                 /* fall through */
     816                 :            :             case 0:
     817                 :            :                 if (do_raise(tstate, exc, cause)) { STACK_SHRINK(oparg); goto exception_unwind; }
     818                 :            :                 break;
     819                 :            :             default:
     820                 :            :                 _PyErr_SetString(tstate, PyExc_SystemError,
     821                 :            :                                  "bad RAISE_VARARGS oparg");
     822                 :            :                 break;
     823                 :            :             }
     824                 :            :             if (true) { STACK_SHRINK(oparg); goto error; }
     825                 :            :             #line 826 "Python/generated_cases.c.h"
     826                 :            :         }
     827                 :            : 
     828                 :    1673510 :         TARGET(INTERPRETER_EXIT) {
     829                 :    1673510 :             PyObject *retval = stack_pointer[-1];
     830                 :            :             #line 524 "Python/bytecodes.c"
     831                 :            :             assert(frame == &entry_frame);
     832                 :            :             assert(_PyFrame_IsIncomplete(frame));
     833                 :            :             STACK_SHRINK(1);  // Since we're not going to DISPATCH()
     834                 :            :             assert(EMPTY());
     835                 :            :             /* Restore previous cframe and return. */
     836                 :            :             tstate->cframe = cframe.previous;
     837                 :            :             tstate->cframe->use_tracing = cframe.use_tracing;
     838                 :            :             assert(tstate->cframe->current_frame == frame->previous);
     839                 :            :             assert(!_PyErr_Occurred(tstate));
     840                 :            :             _Py_LeaveRecursiveCallTstate(tstate);
     841                 :            :             return retval;
     842                 :            :             #line 843 "Python/generated_cases.c.h"
     843                 :            :         }
     844                 :            : 
     845                 :    2531207 :         TARGET(RETURN_VALUE) {
     846                 :    2531207 :             PyObject *retval = stack_pointer[-1];
     847                 :            :             #line 538 "Python/bytecodes.c"
     848                 :            :             STACK_SHRINK(1);
     849                 :            :             assert(EMPTY());
     850                 :            :             _PyFrame_SetStackPointer(frame, stack_pointer);
     851                 :            :             TRACE_FUNCTION_EXIT();
     852                 :            :             DTRACE_FUNCTION_EXIT();
     853                 :            :             _Py_LeaveRecursiveCallPy(tstate);
     854                 :            :             assert(frame != &entry_frame);
     855                 :            :             // GH-99729: We need to unlink the frame *before* clearing it:
     856                 :            :             _PyInterpreterFrame *dying = frame;
     857                 :            :             frame = cframe.current_frame = dying->previous;
     858                 :            :             _PyEvalFrameClearAndPop(tstate, dying);
     859                 :            :             _PyFrame_StackPush(frame, retval);
     860                 :            :             goto resume_frame;
     861                 :            :             #line 862 "Python/generated_cases.c.h"
     862                 :            :         }
     863                 :            : 
     864                 :    1073392 :         TARGET(RETURN_CONST) {
     865                 :            :             #line 554 "Python/bytecodes.c"
     866                 :            :             PyObject *retval = GETITEM(frame->f_code->co_consts, oparg);
     867                 :            :             Py_INCREF(retval);
     868                 :            :             assert(EMPTY());
     869                 :            :             _PyFrame_SetStackPointer(frame, stack_pointer);
     870                 :            :             TRACE_FUNCTION_EXIT();
     871                 :            :             DTRACE_FUNCTION_EXIT();
     872                 :            :             _Py_LeaveRecursiveCallPy(tstate);
     873                 :            :             assert(frame != &entry_frame);
     874                 :            :             // GH-99729: We need to unlink the frame *before* clearing it:
     875                 :            :             _PyInterpreterFrame *dying = frame;
     876                 :            :             frame = cframe.current_frame = dying->previous;
     877                 :            :             _PyEvalFrameClearAndPop(tstate, dying);
     878                 :            :             _PyFrame_StackPush(frame, retval);
     879                 :            :             goto resume_frame;
     880                 :            :             #line 881 "Python/generated_cases.c.h"
     881                 :            :         }
     882                 :            : 
     883                 :          0 :         TARGET(GET_AITER) {
     884                 :          0 :             PyObject *obj = stack_pointer[-1];
     885                 :            :             PyObject *iter;
     886                 :            :             #line 571 "Python/bytecodes.c"
     887                 :            :             unaryfunc getter = NULL;
     888                 :            :             PyTypeObject *type = Py_TYPE(obj);
     889                 :            : 
     890                 :            :             if (type->tp_as_async != NULL) {
     891                 :            :                 getter = type->tp_as_async->am_aiter;
     892                 :            :             }
     893                 :            : 
     894                 :            :             if (getter == NULL) {
     895                 :            :                 _PyErr_Format(tstate, PyExc_TypeError,
     896                 :            :                               "'async for' requires an object with "
     897                 :            :                               "__aiter__ method, got %.100s",
     898                 :            :                               type->tp_name);
     899                 :            :             #line 900 "Python/generated_cases.c.h"
     900         [ #  # ]:          0 :                 Py_DECREF(obj);
     901                 :            :             #line 584 "Python/bytecodes.c"
     902                 :            :                 if (true) goto pop_1_error;
     903                 :            :             }
     904                 :            : 
     905                 :            :             iter = (*getter)(obj);
     906                 :            :             #line 907 "Python/generated_cases.c.h"
     907         [ #  # ]:          0 :             Py_DECREF(obj);
     908                 :            :             #line 589 "Python/bytecodes.c"
     909                 :            :             if (iter == NULL) goto pop_1_error;
     910                 :            : 
     911                 :            :             if (Py_TYPE(iter)->tp_as_async == NULL ||
     912                 :            :                     Py_TYPE(iter)->tp_as_async->am_anext == NULL) {
     913                 :            : 
     914                 :            :                 _PyErr_Format(tstate, PyExc_TypeError,
     915                 :            :                               "'async for' received an object from __aiter__ "
     916                 :            :                               "that does not implement __anext__: %.100s",
     917                 :            :                               Py_TYPE(iter)->tp_name);
     918                 :            :                 Py_DECREF(iter);
     919                 :            :                 if (true) goto pop_1_error;
     920                 :            :             }
     921                 :            :             #line 922 "Python/generated_cases.c.h"
     922                 :          0 :             stack_pointer[-1] = iter;
     923                 :          0 :             DISPATCH();
     924                 :            :         }
     925                 :            : 
     926                 :          0 :         TARGET(GET_ANEXT) {
     927                 :          0 :             PyObject *aiter = stack_pointer[-1];
     928                 :            :             PyObject *awaitable;
     929                 :            :             #line 604 "Python/bytecodes.c"
     930                 :            :             unaryfunc getter = NULL;
     931                 :            :             PyObject *next_iter = NULL;
     932                 :            :             PyTypeObject *type = Py_TYPE(aiter);
     933                 :            : 
     934                 :            :             if (PyAsyncGen_CheckExact(aiter)) {
     935                 :            :                 awaitable = type->tp_as_async->am_anext(aiter);
     936                 :            :                 if (awaitable == NULL) {
     937                 :            :                     goto error;
     938                 :            :                 }
     939                 :            :             } else {
     940                 :            :                 if (type->tp_as_async != NULL){
     941                 :            :                     getter = type->tp_as_async->am_anext;
     942                 :            :                 }
     943                 :            : 
     944                 :            :                 if (getter != NULL) {
     945                 :            :                     next_iter = (*getter)(aiter);
     946                 :            :                     if (next_iter == NULL) {
     947                 :            :                         goto error;
     948                 :            :                     }
     949                 :            :                 }
     950                 :            :                 else {
     951                 :            :                     _PyErr_Format(tstate, PyExc_TypeError,
     952                 :            :                                   "'async for' requires an iterator with "
     953                 :            :                                   "__anext__ method, got %.100s",
     954                 :            :                                   type->tp_name);
     955                 :            :                     goto error;
     956                 :            :                 }
     957                 :            : 
     958                 :            :                 awaitable = _PyCoro_GetAwaitableIter(next_iter);
     959                 :            :                 if (awaitable == NULL) {
     960                 :            :                     _PyErr_FormatFromCause(
     961                 :            :                         PyExc_TypeError,
     962                 :            :                         "'async for' received an invalid object "
     963                 :            :                         "from __anext__: %.100s",
     964                 :            :                         Py_TYPE(next_iter)->tp_name);
     965                 :            : 
     966                 :            :                     Py_DECREF(next_iter);
     967                 :            :                     goto error;
     968                 :            :                 } else {
     969                 :            :                     Py_DECREF(next_iter);
     970                 :            :                 }
     971                 :            :             }
     972                 :            : 
     973                 :            :             #line 974 "Python/generated_cases.c.h"
     974                 :          0 :             STACK_GROW(1);
     975                 :          0 :             stack_pointer[-1] = awaitable;
     976                 :            :             PREDICT(LOAD_CONST);
     977                 :          0 :             DISPATCH();
     978                 :            :         }
     979                 :            : 
     980                 :          0 :         TARGET(GET_AWAITABLE) {
     981                 :          0 :             PREDICTED(GET_AWAITABLE);
     982                 :          0 :             PyObject *iterable = stack_pointer[-1];
     983                 :            :             PyObject *iter;
     984                 :            :             #line 651 "Python/bytecodes.c"
     985                 :            :             iter = _PyCoro_GetAwaitableIter(iterable);
     986                 :            : 
     987                 :            :             if (iter == NULL) {
     988                 :            :                 format_awaitable_error(tstate, Py_TYPE(iterable), oparg);
     989                 :            :             }
     990                 :            : 
     991                 :            :             #line 992 "Python/generated_cases.c.h"
     992         [ #  # ]:          0 :             Py_DECREF(iterable);
     993                 :            :             #line 658 "Python/bytecodes.c"
     994                 :            : 
     995                 :            :             if (iter != NULL && PyCoro_CheckExact(iter)) {
     996                 :            :                 PyObject *yf = _PyGen_yf((PyGenObject*)iter);
     997                 :            :                 if (yf != NULL) {
     998                 :            :                     /* `iter` is a coroutine object that is being
     999                 :            :                        awaited, `yf` is a pointer to the current awaitable
    1000                 :            :                        being awaited on. */
    1001                 :            :                     Py_DECREF(yf);
    1002                 :            :                     Py_CLEAR(iter);
    1003                 :            :                     _PyErr_SetString(tstate, PyExc_RuntimeError,
    1004                 :            :                                      "coroutine is being awaited already");
    1005                 :            :                     /* The code below jumps to `error` if `iter` is NULL. */
    1006                 :            :                 }
    1007                 :            :             }
    1008                 :            : 
    1009                 :            :             if (iter == NULL) goto pop_1_error;
    1010                 :            : 
    1011                 :            :             #line 1012 "Python/generated_cases.c.h"
    1012                 :          0 :             stack_pointer[-1] = iter;
    1013                 :            :             PREDICT(LOAD_CONST);
    1014                 :          0 :             DISPATCH();
    1015                 :            :         }
    1016                 :            : 
    1017                 :         36 :         TARGET(SEND) {
    1018                 :         36 :             PREDICTED(SEND);
    1019                 :         36 :             PyObject *v = stack_pointer[-1];
    1020         [ +  + ]:         36 :             PyObject *receiver = stack_pointer[-2];
    1021                 :            :             PyObject *retval;
    1022                 :            :             #line 684 "Python/bytecodes.c"
    1023                 :            :             #if ENABLE_SPECIALIZATION
    1024                 :            :             _PySendCache *cache = (_PySendCache *)next_instr;
    1025                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
    1026                 :            :                 assert(cframe.use_tracing == 0);
    1027                 :            :                 next_instr--;
    1028                 :            :                 _Py_Specialize_Send(receiver, next_instr);
    1029                 :            :                 DISPATCH_SAME_OPARG();
    1030                 :            :             }
    1031                 :            :             STAT_INC(SEND, deferred);
    1032                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
    1033                 :            :             #endif  /* ENABLE_SPECIALIZATION */
    1034                 :            :             assert(frame != &entry_frame);
    1035                 :            :             if (Py_IsNone(v) && PyIter_Check(receiver)) {
    1036                 :            :                 retval = Py_TYPE(receiver)->tp_iternext(receiver);
    1037                 :            :             }
    1038                 :            :             else {
    1039                 :            :                 retval = PyObject_CallMethodOneArg(receiver, &_Py_ID(send), v);
    1040                 :            :             }
    1041                 :            :             if (retval == NULL) {
    1042                 :            :                 if (tstate->c_tracefunc != NULL
    1043                 :            :                         && _PyErr_ExceptionMatches(tstate, PyExc_StopIteration))
    1044                 :            :                     call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, frame);
    1045                 :            :                 if (_PyGen_FetchStopIterationValue(&retval) == 0) {
    1046                 :            :                     assert(retval != NULL);
    1047                 :            :                     JUMPBY(oparg);
    1048                 :            :                 }
    1049                 :            :                 else {
    1050                 :            :                     assert(retval == NULL);
    1051                 :            :                     goto error;
    1052                 :            :                 }
    1053                 :            :             }
    1054                 :            :             else {
    1055                 :            :                 assert(retval != NULL);
    1056                 :            :             }
    1057                 :            :             Py_DECREF(v);
    1058                 :            :             #line 1059 "Python/generated_cases.c.h"
    1059                 :         26 :             stack_pointer[-1] = retval;
    1060                 :         26 :             next_instr += 1;
    1061                 :         26 :             DISPATCH();
    1062                 :            :         }
    1063                 :            : 
    1064                 :        351 :         TARGET(SEND_GEN) {
    1065                 :        351 :             PyObject *v = stack_pointer[-1];
    1066                 :        351 :             PyObject *receiver = stack_pointer[-2];
    1067                 :            :             #line 722 "Python/bytecodes.c"
    1068                 :            :             assert(cframe.use_tracing == 0);
    1069                 :            :             PyGenObject *gen = (PyGenObject *)receiver;
    1070                 :            :             DEOPT_IF(Py_TYPE(gen) != &PyGen_Type &&
    1071                 :            :                      Py_TYPE(gen) != &PyCoro_Type, SEND);
    1072                 :            :             DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING, SEND);
    1073                 :            :             STAT_INC(SEND, hit);
    1074                 :            :             _PyInterpreterFrame *gen_frame = (_PyInterpreterFrame *)gen->gi_iframe;
    1075                 :            :             frame->yield_offset = oparg;
    1076                 :            :             STACK_SHRINK(1);
    1077                 :            :             _PyFrame_StackPush(gen_frame, v);
    1078                 :            :             gen->gi_frame_state = FRAME_EXECUTING;
    1079                 :            :             gen->gi_exc_state.previous_item = tstate->exc_info;
    1080                 :            :             tstate->exc_info = &gen->gi_exc_state;
    1081                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_SEND + oparg);
    1082                 :            :             DISPATCH_INLINED(gen_frame);
    1083                 :            :             #line 1084 "Python/generated_cases.c.h"
    1084                 :            :         }
    1085                 :            : 
    1086                 :     429374 :         TARGET(YIELD_VALUE) {
    1087                 :     429374 :             PyObject *retval = stack_pointer[-1];
    1088                 :            :             #line 740 "Python/bytecodes.c"
    1089                 :            :             // NOTE: It's important that YIELD_VALUE never raises an exception!
    1090                 :            :             // The compiler treats any exception raised here as a failed close()
    1091                 :            :             // or throw() call.
    1092                 :            :             assert(frame != &entry_frame);
    1093                 :            :             PyGenObject *gen = _PyFrame_GetGenerator(frame);
    1094                 :            :             gen->gi_frame_state = FRAME_SUSPENDED;
    1095                 :            :             _PyFrame_SetStackPointer(frame, stack_pointer - 1);
    1096                 :            :             TRACE_FUNCTION_EXIT();
    1097                 :            :             DTRACE_FUNCTION_EXIT();
    1098                 :            :             tstate->exc_info = gen->gi_exc_state.previous_item;
    1099                 :            :             gen->gi_exc_state.previous_item = NULL;
    1100                 :            :             _Py_LeaveRecursiveCallPy(tstate);
    1101                 :            :             _PyInterpreterFrame *gen_frame = frame;
    1102                 :            :             frame = cframe.current_frame = frame->previous;
    1103                 :            :             gen_frame->previous = NULL;
    1104                 :            :             frame->prev_instr -= frame->yield_offset;
    1105                 :            :             _PyFrame_StackPush(frame, retval);
    1106                 :            :             goto resume_frame;
    1107                 :            :             #line 1108 "Python/generated_cases.c.h"
    1108                 :            :         }
    1109                 :            : 
    1110                 :     101972 :         TARGET(POP_EXCEPT) {
    1111         [ +  - ]:     101972 :             PyObject *exc_value = stack_pointer[-1];
    1112                 :            :             #line 761 "Python/bytecodes.c"
    1113                 :            :             _PyErr_StackItem *exc_info = tstate->exc_info;
    1114                 :            :             Py_XSETREF(exc_info->exc_value, exc_value);
    1115                 :            :             #line 1116 "Python/generated_cases.c.h"
    1116                 :     101972 :             STACK_SHRINK(1);
    1117                 :     101972 :             DISPATCH();
    1118                 :            :         }
    1119                 :            : 
    1120                 :       2415 :         TARGET(RERAISE) {
    1121                 :       2415 :             PyObject *exc = stack_pointer[-1];
    1122         [ +  + ]:       2415 :             PyObject **values = (stack_pointer - (1 + oparg));
    1123                 :            :             #line 766 "Python/bytecodes.c"
    1124                 :            :             assert(oparg >= 0 && oparg <= 2);
    1125                 :            :             if (oparg) {
    1126                 :            :                 PyObject *lasti = values[0];
    1127                 :            :                 if (PyLong_Check(lasti)) {
    1128                 :            :                     frame->prev_instr = _PyCode_CODE(frame->f_code) + PyLong_AsLong(lasti);
    1129                 :            :                     assert(!_PyErr_Occurred(tstate));
    1130                 :            :                 }
    1131                 :            :                 else {
    1132                 :            :                     assert(PyLong_Check(lasti));
    1133                 :            :                     _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int");
    1134                 :            :                     goto error;
    1135                 :            :                 }
    1136                 :            :             }
    1137                 :            :             assert(exc && PyExceptionInstance_Check(exc));
    1138                 :            :             Py_INCREF(exc);
    1139                 :            :             _PyErr_SetRaisedException(tstate, exc);
    1140                 :            :             goto exception_unwind;
    1141                 :            :             #line 1142 "Python/generated_cases.c.h"
    1142                 :            :         }
    1143                 :            : 
    1144                 :          0 :         TARGET(END_ASYNC_FOR) {
    1145                 :          0 :             PyObject *exc = stack_pointer[-1];
    1146                 :          0 :             PyObject *awaitable = stack_pointer[-2];
    1147                 :            :             #line 786 "Python/bytecodes.c"
    1148                 :            :             assert(exc && PyExceptionInstance_Check(exc));
    1149                 :            :             if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) {
    1150                 :            :             #line 1151 "Python/generated_cases.c.h"
    1151         [ #  # ]:          0 :                 Py_DECREF(awaitable);
    1152         [ #  # ]:          0 :                 Py_DECREF(exc);
    1153                 :            :             #line 789 "Python/bytecodes.c"
    1154                 :            :             }
    1155                 :            :             else {
    1156                 :            :                 Py_INCREF(exc);
    1157                 :            :                 _PyErr_SetRaisedException(tstate, exc);
    1158                 :            :                 goto exception_unwind;
    1159                 :            :             }
    1160                 :            :             #line 1161 "Python/generated_cases.c.h"
    1161                 :          0 :             STACK_SHRINK(2);
    1162                 :          0 :             DISPATCH();
    1163                 :            :         }
    1164                 :            : 
    1165                 :          0 :         TARGET(CLEANUP_THROW) {
    1166                 :          0 :             PyObject *exc_value = stack_pointer[-1];
    1167                 :          0 :             PyObject *last_sent_val = stack_pointer[-2];
    1168                 :          0 :             PyObject *sub_iter = stack_pointer[-3];
    1169                 :            :             PyObject *none;
    1170                 :            :             PyObject *value;
    1171                 :            :             #line 798 "Python/bytecodes.c"
    1172                 :            :             assert(throwflag);
    1173                 :            :             assert(exc_value && PyExceptionInstance_Check(exc_value));
    1174                 :            :             if (PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration)) {
    1175                 :            :                 value = Py_NewRef(((PyStopIterationObject *)exc_value)->value);
    1176                 :            :             #line 1177 "Python/generated_cases.c.h"
    1177         [ #  # ]:          0 :                 Py_DECREF(sub_iter);
    1178         [ #  # ]:          0 :                 Py_DECREF(last_sent_val);
    1179         [ #  # ]:          0 :                 Py_DECREF(exc_value);
    1180                 :            :             #line 803 "Python/bytecodes.c"
    1181                 :            :                 none = Py_NewRef(Py_None);
    1182                 :            :             }
    1183                 :            :             else {
    1184                 :            :                 _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));
    1185                 :            :                 goto exception_unwind;
    1186                 :            :             }
    1187                 :            :             #line 1188 "Python/generated_cases.c.h"
    1188                 :          0 :             STACK_SHRINK(1);
    1189                 :          0 :             stack_pointer[-1] = value;
    1190                 :          0 :             stack_pointer[-2] = none;
    1191                 :          0 :             DISPATCH();
    1192                 :            :         }
    1193                 :            : 
    1194                 :          0 :         TARGET(LOAD_ASSERTION_ERROR) {
    1195                 :            :             PyObject *value;
    1196                 :            :             #line 812 "Python/bytecodes.c"
    1197                 :            :             value = Py_NewRef(PyExc_AssertionError);
    1198                 :            :             #line 1199 "Python/generated_cases.c.h"
    1199                 :          0 :             STACK_GROW(1);
    1200                 :          0 :             stack_pointer[-1] = value;
    1201                 :          0 :             DISPATCH();
    1202                 :            :         }
    1203                 :            : 
    1204         [ +  - ]:       3141 :         TARGET(LOAD_BUILD_CLASS) {
    1205                 :            :             PyObject *bc;
    1206                 :            :             #line 816 "Python/bytecodes.c"
    1207                 :            :             if (PyDict_CheckExact(BUILTINS())) {
    1208                 :            :                 bc = _PyDict_GetItemWithError(BUILTINS(),
    1209                 :            :                                               &_Py_ID(__build_class__));
    1210                 :            :                 if (bc == NULL) {
    1211                 :            :                     if (!_PyErr_Occurred(tstate)) {
    1212                 :            :                         _PyErr_SetString(tstate, PyExc_NameError,
    1213                 :            :                                          "__build_class__ not found");
    1214                 :            :                     }
    1215                 :            :                     if (true) goto error;
    1216                 :            :                 }
    1217                 :            :                 Py_INCREF(bc);
    1218                 :            :             }
    1219                 :            :             else {
    1220                 :            :                 bc = PyObject_GetItem(BUILTINS(), &_Py_ID(__build_class__));
    1221                 :            :                 if (bc == NULL) {
    1222                 :            :                     if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError))
    1223                 :            :                         _PyErr_SetString(tstate, PyExc_NameError,
    1224                 :            :                                          "__build_class__ not found");
    1225                 :            :                     if (true) goto error;
    1226                 :            :                 }
    1227                 :            :             }
    1228                 :            :             #line 1229 "Python/generated_cases.c.h"
    1229                 :       3141 :             STACK_GROW(1);
    1230                 :       3141 :             stack_pointer[-1] = bc;
    1231                 :       3141 :             DISPATCH();
    1232                 :            :         }
    1233                 :            : 
    1234                 :      54214 :         TARGET(STORE_NAME) {
    1235         [ -  + ]:      54214 :             PyObject *v = stack_pointer[-1];
    1236                 :            :             #line 840 "Python/bytecodes.c"
    1237                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    1238                 :            :             PyObject *ns = LOCALS();
    1239                 :            :             int err;
    1240                 :            :             if (ns == NULL) {
    1241                 :            :                 _PyErr_Format(tstate, PyExc_SystemError,
    1242                 :            :                               "no locals found when storing %R", name);
    1243                 :            :             #line 1244 "Python/generated_cases.c.h"
    1244         [ #  # ]:          0 :                 Py_DECREF(v);
    1245                 :            :             #line 847 "Python/bytecodes.c"
    1246                 :            :                 if (true) goto pop_1_error;
    1247                 :            :             }
    1248                 :            :             if (PyDict_CheckExact(ns))
    1249                 :            :                 err = PyDict_SetItem(ns, name, v);
    1250                 :            :             else
    1251                 :            :                 err = PyObject_SetItem(ns, name, v);
    1252                 :            :             #line 1253 "Python/generated_cases.c.h"
    1253         [ +  + ]:      54214 :             Py_DECREF(v);
    1254                 :            :             #line 854 "Python/bytecodes.c"
    1255                 :            :             if (err) goto pop_1_error;
    1256                 :            :             #line 1257 "Python/generated_cases.c.h"
    1257                 :      54214 :             STACK_SHRINK(1);
    1258                 :      54214 :             DISPATCH();
    1259                 :            :         }
    1260                 :            : 
    1261         [ -  + ]:        514 :         TARGET(DELETE_NAME) {
    1262                 :            :             #line 858 "Python/bytecodes.c"
    1263                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    1264                 :            :             PyObject *ns = LOCALS();
    1265                 :            :             int err;
    1266                 :            :             if (ns == NULL) {
    1267                 :            :                 _PyErr_Format(tstate, PyExc_SystemError,
    1268                 :            :                               "no locals when deleting %R", name);
    1269                 :            :                 goto error;
    1270                 :            :             }
    1271                 :            :             err = PyObject_DelItem(ns, name);
    1272                 :            :             // Can't use ERROR_IF here.
    1273                 :            :             if (err != 0) {
    1274                 :            :                 format_exc_check_arg(tstate, PyExc_NameError,
    1275                 :            :                                      NAME_ERROR_MSG,
    1276                 :            :                                      name);
    1277                 :            :                 goto error;
    1278                 :            :             }
    1279                 :            :             #line 1280 "Python/generated_cases.c.h"
    1280                 :        514 :             DISPATCH();
    1281                 :            :         }
    1282                 :            : 
    1283                 :       1203 :         TARGET(UNPACK_SEQUENCE) {
    1284                 :       1203 :             PREDICTED(UNPACK_SEQUENCE);
    1285                 :            :             static_assert(INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE == 1, "incorrect cache size");
    1286         [ +  + ]:       1203 :             PyObject *seq = stack_pointer[-1];
    1287                 :            :             #line 884 "Python/bytecodes.c"
    1288                 :            :             #if ENABLE_SPECIALIZATION
    1289                 :            :             _PyUnpackSequenceCache *cache = (_PyUnpackSequenceCache *)next_instr;
    1290                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
    1291                 :            :                 assert(cframe.use_tracing == 0);
    1292                 :            :                 next_instr--;
    1293                 :            :                 _Py_Specialize_UnpackSequence(seq, next_instr, oparg);
    1294                 :            :                 DISPATCH_SAME_OPARG();
    1295                 :            :             }
    1296                 :            :             STAT_INC(UNPACK_SEQUENCE, deferred);
    1297                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
    1298                 :            :             #endif  /* ENABLE_SPECIALIZATION */
    1299                 :            :             PyObject **top = stack_pointer + oparg - 1;
    1300                 :            :             int res = unpack_iterable(tstate, seq, oparg, -1, top);
    1301                 :            :             #line 1302 "Python/generated_cases.c.h"
    1302         [ +  + ]:        671 :             Py_DECREF(seq);
    1303                 :            :             #line 898 "Python/bytecodes.c"
    1304                 :            :             if (res == 0) goto pop_1_error;
    1305                 :            :             #line 1306 "Python/generated_cases.c.h"
    1306                 :        671 :             STACK_SHRINK(1);
    1307                 :        671 :             STACK_GROW(oparg);
    1308                 :        671 :             next_instr += 1;
    1309                 :        671 :             DISPATCH();
    1310                 :            :         }
    1311                 :            : 
    1312                 :    1690349 :         TARGET(UNPACK_SEQUENCE_TWO_TUPLE) {
    1313                 :    1690349 :             PyObject *seq = stack_pointer[-1];
    1314         [ -  + ]:    1690349 :             PyObject **values = stack_pointer - (1);
    1315                 :            :             #line 902 "Python/bytecodes.c"
    1316                 :            :             DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
    1317                 :            :             DEOPT_IF(PyTuple_GET_SIZE(seq) != 2, UNPACK_SEQUENCE);
    1318                 :            :             assert(oparg == 2);
    1319                 :            :             STAT_INC(UNPACK_SEQUENCE, hit);
    1320                 :            :             values[0] = Py_NewRef(PyTuple_GET_ITEM(seq, 1));
    1321                 :            :             values[1] = Py_NewRef(PyTuple_GET_ITEM(seq, 0));
    1322                 :            :             #line 1323 "Python/generated_cases.c.h"
    1323         [ +  + ]:    1690349 :             Py_DECREF(seq);
    1324                 :    1690349 :             STACK_SHRINK(1);
    1325                 :    1690349 :             STACK_GROW(oparg);
    1326                 :    1690349 :             next_instr += 1;
    1327                 :    1690349 :             DISPATCH();
    1328                 :            :         }
    1329                 :            : 
    1330                 :      11126 :         TARGET(UNPACK_SEQUENCE_TUPLE) {
    1331                 :      11126 :             PyObject *seq = stack_pointer[-1];
    1332         [ -  + ]:      11126 :             PyObject **values = stack_pointer - (1);
    1333                 :            :             #line 912 "Python/bytecodes.c"
    1334                 :            :             DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
    1335                 :            :             DEOPT_IF(PyTuple_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
    1336                 :            :             STAT_INC(UNPACK_SEQUENCE, hit);
    1337                 :            :             PyObject **items = _PyTuple_ITEMS(seq);
    1338                 :            :             for (int i = oparg; --i >= 0; ) {
    1339                 :            :                 *values++ = Py_NewRef(items[i]);
    1340                 :            :             }
    1341                 :            :             #line 1342 "Python/generated_cases.c.h"
    1342         [ +  + ]:      11126 :             Py_DECREF(seq);
    1343                 :      11126 :             STACK_SHRINK(1);
    1344                 :      11126 :             STACK_GROW(oparg);
    1345                 :      11126 :             next_instr += 1;
    1346                 :      11126 :             DISPATCH();
    1347                 :            :         }
    1348                 :            : 
    1349                 :       5127 :         TARGET(UNPACK_SEQUENCE_LIST) {
    1350                 :       5127 :             PyObject *seq = stack_pointer[-1];
    1351         [ -  + ]:       5127 :             PyObject **values = stack_pointer - (1);
    1352                 :            :             #line 923 "Python/bytecodes.c"
    1353                 :            :             DEOPT_IF(!PyList_CheckExact(seq), UNPACK_SEQUENCE);
    1354                 :            :             DEOPT_IF(PyList_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
    1355                 :            :             STAT_INC(UNPACK_SEQUENCE, hit);
    1356                 :            :             PyObject **items = _PyList_ITEMS(seq);
    1357                 :            :             for (int i = oparg; --i >= 0; ) {
    1358                 :            :                 *values++ = Py_NewRef(items[i]);
    1359                 :            :             }
    1360                 :            :             #line 1361 "Python/generated_cases.c.h"
    1361         [ +  + ]:       5127 :             Py_DECREF(seq);
    1362                 :       5127 :             STACK_SHRINK(1);
    1363                 :       5127 :             STACK_GROW(oparg);
    1364                 :       5127 :             next_instr += 1;
    1365                 :       5127 :             DISPATCH();
    1366                 :            :         }
    1367                 :            : 
    1368                 :       1994 :         TARGET(UNPACK_EX) {
    1369                 :       1994 :             PyObject *seq = stack_pointer[-1];
    1370                 :            :             #line 934 "Python/bytecodes.c"
    1371                 :            :             int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
    1372                 :            :             PyObject **top = stack_pointer + totalargs - 1;
    1373                 :            :             int res = unpack_iterable(tstate, seq, oparg & 0xFF, oparg >> 8, top);
    1374                 :            :             #line 1375 "Python/generated_cases.c.h"
    1375         [ +  + ]:       1994 :             Py_DECREF(seq);
    1376                 :            :             #line 938 "Python/bytecodes.c"
    1377                 :            :             if (res == 0) goto pop_1_error;
    1378                 :            :             #line 1379 "Python/generated_cases.c.h"
    1379                 :       1994 :             STACK_GROW((oparg & 0xFF) + (oparg >> 8));
    1380                 :       1994 :             DISPATCH();
    1381                 :            :         }
    1382                 :            : 
    1383                 :     129025 :         TARGET(STORE_ATTR) {
    1384                 :     450233 :             PREDICTED(STORE_ATTR);
    1385                 :            :             static_assert(INLINE_CACHE_ENTRIES_STORE_ATTR == 4, "incorrect cache size");
    1386                 :     450233 :             PyObject *owner = stack_pointer[-1];
    1387                 :     450233 :             PyObject *v = stack_pointer[-2];
    1388                 :     450233 :             uint16_t counter = read_u16(&next_instr[0].cache);
    1389                 :            :             #line 949 "Python/bytecodes.c"
    1390                 :            :             #if ENABLE_SPECIALIZATION
    1391                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(counter)) {
    1392                 :            :                 assert(cframe.use_tracing == 0);
    1393                 :            :                 PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    1394                 :            :                 next_instr--;
    1395                 :            :                 _Py_Specialize_StoreAttr(owner, next_instr, name);
    1396                 :            :                 DISPATCH_SAME_OPARG();
    1397                 :            :             }
    1398                 :            :             STAT_INC(STORE_ATTR, deferred);
    1399                 :            :             _PyAttrCache *cache = (_PyAttrCache *)next_instr;
    1400                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
    1401                 :            :             #else
    1402                 :            :             (void)counter;  // Unused.
    1403                 :            :             #endif  /* ENABLE_SPECIALIZATION */
    1404                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    1405                 :            :             int err = PyObject_SetAttr(owner, name, v);
    1406                 :            :             #line 1407 "Python/generated_cases.c.h"
    1407         [ -  + ]:     440926 :             Py_DECREF(v);
    1408         [ -  + ]:     440926 :             Py_DECREF(owner);
    1409                 :            :             #line 966 "Python/bytecodes.c"
    1410                 :            :             if (err) goto pop_2_error;
    1411                 :            :             #line 1412 "Python/generated_cases.c.h"
    1412                 :     440926 :             STACK_SHRINK(2);
    1413                 :     440926 :             next_instr += 4;
    1414                 :     440926 :             DISPATCH();
    1415                 :            :         }
    1416                 :            : 
    1417                 :     292839 :         TARGET(DELETE_ATTR) {
    1418                 :     292839 :             PyObject *owner = stack_pointer[-1];
    1419                 :            :             #line 970 "Python/bytecodes.c"
    1420                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    1421                 :            :             int err = PyObject_SetAttr(owner, name, (PyObject *)NULL);
    1422                 :            :             #line 1423 "Python/generated_cases.c.h"
    1423         [ -  + ]:     292839 :             Py_DECREF(owner);
    1424                 :            :             #line 973 "Python/bytecodes.c"
    1425                 :            :             if (err) goto pop_1_error;
    1426                 :            :             #line 1427 "Python/generated_cases.c.h"
    1427                 :     292839 :             STACK_SHRINK(1);
    1428                 :     292839 :             DISPATCH();
    1429                 :            :         }
    1430                 :            : 
    1431                 :       1270 :         TARGET(STORE_GLOBAL) {
    1432                 :       1270 :             PyObject *v = stack_pointer[-1];
    1433                 :            :             #line 977 "Python/bytecodes.c"
    1434                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    1435                 :            :             int err = PyDict_SetItem(GLOBALS(), name, v);
    1436                 :            :             #line 1437 "Python/generated_cases.c.h"
    1437         [ -  + ]:       1270 :             Py_DECREF(v);
    1438                 :            :             #line 980 "Python/bytecodes.c"
    1439                 :            :             if (err) goto pop_1_error;
    1440                 :            :             #line 1441 "Python/generated_cases.c.h"
    1441                 :       1270 :             STACK_SHRINK(1);
    1442                 :       1270 :             DISPATCH();
    1443                 :            :         }
    1444                 :            : 
    1445                 :          0 :         TARGET(DELETE_GLOBAL) {
    1446                 :            :             #line 984 "Python/bytecodes.c"
    1447                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    1448                 :            :             int err;
    1449                 :            :             err = PyDict_DelItem(GLOBALS(), name);
    1450                 :            :             // Can't use ERROR_IF here.
    1451                 :            :             if (err != 0) {
    1452                 :            :                 if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
    1453                 :            :                     format_exc_check_arg(tstate, PyExc_NameError,
    1454                 :            :                                          NAME_ERROR_MSG, name);
    1455                 :            :                 }
    1456                 :            :                 goto error;
    1457                 :            :             }
    1458                 :            :             #line 1459 "Python/generated_cases.c.h"
    1459                 :          0 :             DISPATCH();
    1460                 :            :         }
    1461                 :            : 
    1462         [ -  + ]:      35562 :         TARGET(LOAD_NAME) {
    1463                 :            :             PyObject *v;
    1464                 :            :             #line 998 "Python/bytecodes.c"
    1465                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    1466                 :            :             PyObject *locals = LOCALS();
    1467                 :            :             if (locals == NULL) {
    1468                 :            :                 _PyErr_Format(tstate, PyExc_SystemError,
    1469                 :            :                               "no locals when loading %R", name);
    1470                 :            :                 goto error;
    1471                 :            :             }
    1472                 :            :             if (PyDict_CheckExact(locals)) {
    1473                 :            :                 v = PyDict_GetItemWithError(locals, name);
    1474                 :            :                 if (v != NULL) {
    1475                 :            :                     Py_INCREF(v);
    1476                 :            :                 }
    1477                 :            :                 else if (_PyErr_Occurred(tstate)) {
    1478                 :            :                     goto error;
    1479                 :            :                 }
    1480                 :            :             }
    1481                 :            :             else {
    1482                 :            :                 v = PyObject_GetItem(locals, name);
    1483                 :            :                 if (v == NULL) {
    1484                 :            :                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError))
    1485                 :            :                         goto error;
    1486                 :            :                     _PyErr_Clear(tstate);
    1487                 :            :                 }
    1488                 :            :             }
    1489                 :            :             if (v == NULL) {
    1490                 :            :                 v = PyDict_GetItemWithError(GLOBALS(), name);
    1491                 :            :                 if (v != NULL) {
    1492                 :            :                     Py_INCREF(v);
    1493                 :            :                 }
    1494                 :            :                 else if (_PyErr_Occurred(tstate)) {
    1495                 :            :                     goto error;
    1496                 :            :                 }
    1497                 :            :                 else {
    1498                 :            :                     if (PyDict_CheckExact(BUILTINS())) {
    1499                 :            :                         v = PyDict_GetItemWithError(BUILTINS(), name);
    1500                 :            :                         if (v == NULL) {
    1501                 :            :                             if (!_PyErr_Occurred(tstate)) {
    1502                 :            :                                 format_exc_check_arg(
    1503                 :            :                                         tstate, PyExc_NameError,
    1504                 :            :                                         NAME_ERROR_MSG, name);
    1505                 :            :                             }
    1506                 :            :                             goto error;
    1507                 :            :                         }
    1508                 :            :                         Py_INCREF(v);
    1509                 :            :                     }
    1510                 :            :                     else {
    1511                 :            :                         v = PyObject_GetItem(BUILTINS(), name);
    1512                 :            :                         if (v == NULL) {
    1513                 :            :                             if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
    1514                 :            :                                 format_exc_check_arg(
    1515                 :            :                                             tstate, PyExc_NameError,
    1516                 :            :                                             NAME_ERROR_MSG, name);
    1517                 :            :                             }
    1518                 :            :                             goto error;
    1519                 :            :                         }
    1520                 :            :                     }
    1521                 :            :                 }
    1522                 :            :             }
    1523                 :            :             #line 1524 "Python/generated_cases.c.h"
    1524                 :      35561 :             STACK_GROW(1);
    1525                 :      35561 :             stack_pointer[-1] = v;
    1526                 :      35561 :             DISPATCH();
    1527                 :            :         }
    1528                 :            : 
    1529                 :      28880 :         TARGET(LOAD_GLOBAL) {
    1530                 :      74883 :             PREDICTED(LOAD_GLOBAL);
    1531                 :            :             static_assert(INLINE_CACHE_ENTRIES_LOAD_GLOBAL == 4, "incorrect cache size");
    1532         [ +  + ]:      74883 :             PyObject *null = NULL;
    1533                 :            :             PyObject *v;
    1534                 :            :             #line 1065 "Python/bytecodes.c"
    1535                 :            :             #if ENABLE_SPECIALIZATION
    1536                 :            :             _PyLoadGlobalCache *cache = (_PyLoadGlobalCache *)next_instr;
    1537                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
    1538                 :            :                 assert(cframe.use_tracing == 0);
    1539                 :            :                 PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
    1540                 :            :                 next_instr--;
    1541                 :            :                 _Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name);
    1542                 :            :                 DISPATCH_SAME_OPARG();
    1543                 :            :             }
    1544                 :            :             STAT_INC(LOAD_GLOBAL, deferred);
    1545                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
    1546                 :            :             #endif  /* ENABLE_SPECIALIZATION */
    1547                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
    1548                 :            :             if (PyDict_CheckExact(GLOBALS())
    1549                 :            :                 && PyDict_CheckExact(BUILTINS()))
    1550                 :            :             {
    1551                 :            :                 v = _PyDict_LoadGlobal((PyDictObject *)GLOBALS(),
    1552                 :            :                                        (PyDictObject *)BUILTINS(),
    1553                 :            :                                        name);
    1554                 :            :                 if (v == NULL) {
    1555                 :            :                     if (!_PyErr_Occurred(tstate)) {
    1556                 :            :                         /* _PyDict_LoadGlobal() returns NULL without raising
    1557                 :            :                          * an exception if the key doesn't exist */
    1558                 :            :                         format_exc_check_arg(tstate, PyExc_NameError,
    1559                 :            :                                              NAME_ERROR_MSG, name);
    1560                 :            :                     }
    1561                 :            :                     if (true) goto error;
    1562                 :            :                 }
    1563                 :            :                 Py_INCREF(v);
    1564                 :            :             }
    1565                 :            :             else {
    1566                 :            :                 /* Slow-path if globals or builtins is not a dict */
    1567                 :            : 
    1568                 :            :                 /* namespace 1: globals */
    1569                 :            :                 v = PyObject_GetItem(GLOBALS(), name);
    1570                 :            :                 if (v == NULL) {
    1571                 :            :                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) goto error;
    1572                 :            :                     _PyErr_Clear(tstate);
    1573                 :            : 
    1574                 :            :                     /* namespace 2: builtins */
    1575                 :            :                     v = PyObject_GetItem(BUILTINS(), name);
    1576                 :            :                     if (v == NULL) {
    1577                 :            :                         if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
    1578                 :            :                             format_exc_check_arg(
    1579                 :            :                                         tstate, PyExc_NameError,
    1580                 :            :                                         NAME_ERROR_MSG, name);
    1581                 :            :                         }
    1582                 :            :                         if (true) goto error;
    1583                 :            :                     }
    1584                 :            :                 }
    1585                 :            :             }
    1586                 :            :             null = NULL;
    1587                 :            :             #line 1588 "Python/generated_cases.c.h"
    1588                 :      63803 :             STACK_GROW(1);
    1589                 :      63803 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    1590                 :      63803 :             stack_pointer[-1] = v;
    1591         [ +  + ]:      63803 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = null; }
    1592                 :      63803 :             next_instr += 4;
    1593                 :      63803 :             DISPATCH();
    1594                 :            :         }
    1595                 :            : 
    1596                 :    4127977 :         TARGET(LOAD_GLOBAL_MODULE) {
    1597                 :    4127977 :             PyObject *null = NULL;
    1598                 :            :             PyObject *res;
    1599                 :    4127977 :             uint16_t index = read_u16(&next_instr[1].cache);
    1600                 :    4127977 :             uint16_t version = read_u16(&next_instr[2].cache);
    1601                 :            :             #line 1120 "Python/bytecodes.c"
    1602                 :            :             assert(cframe.use_tracing == 0);
    1603                 :            :             DEOPT_IF(!PyDict_CheckExact(GLOBALS()), LOAD_GLOBAL);
    1604                 :            :             PyDictObject *dict = (PyDictObject *)GLOBALS();
    1605                 :            :             DEOPT_IF(dict->ma_keys->dk_version != version, LOAD_GLOBAL);
    1606                 :            :             assert(DK_IS_UNICODE(dict->ma_keys));
    1607                 :            :             PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(dict->ma_keys);
    1608                 :            :             res = entries[index].me_value;
    1609                 :            :             DEOPT_IF(res == NULL, LOAD_GLOBAL);
    1610                 :            :             Py_INCREF(res);
    1611                 :            :             STAT_INC(LOAD_GLOBAL, hit);
    1612                 :            :             null = NULL;
    1613                 :            :             #line 1614 "Python/generated_cases.c.h"
    1614                 :    4109990 :             STACK_GROW(1);
    1615                 :    4109990 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    1616                 :    4109990 :             stack_pointer[-1] = res;
    1617         [ +  + ]:    4109990 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = null; }
    1618                 :    4109990 :             next_instr += 4;
    1619                 :    4109990 :             DISPATCH();
    1620                 :            :         }
    1621                 :            : 
    1622                 :    3589529 :         TARGET(LOAD_GLOBAL_BUILTIN) {
    1623                 :    3589529 :             PyObject *null = NULL;
    1624                 :            :             PyObject *res;
    1625                 :    3589529 :             uint16_t index = read_u16(&next_instr[1].cache);
    1626                 :    3589529 :             uint16_t mod_version = read_u16(&next_instr[2].cache);
    1627                 :    3589529 :             uint16_t bltn_version = read_u16(&next_instr[3].cache);
    1628                 :            :             #line 1134 "Python/bytecodes.c"
    1629                 :            :             assert(cframe.use_tracing == 0);
    1630                 :            :             DEOPT_IF(!PyDict_CheckExact(GLOBALS()), LOAD_GLOBAL);
    1631                 :            :             DEOPT_IF(!PyDict_CheckExact(BUILTINS()), LOAD_GLOBAL);
    1632                 :            :             PyDictObject *mdict = (PyDictObject *)GLOBALS();
    1633                 :            :             PyDictObject *bdict = (PyDictObject *)BUILTINS();
    1634                 :            :             DEOPT_IF(mdict->ma_keys->dk_version != mod_version, LOAD_GLOBAL);
    1635                 :            :             DEOPT_IF(bdict->ma_keys->dk_version != bltn_version, LOAD_GLOBAL);
    1636                 :            :             assert(DK_IS_UNICODE(bdict->ma_keys));
    1637                 :            :             PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(bdict->ma_keys);
    1638                 :            :             res = entries[index].me_value;
    1639                 :            :             DEOPT_IF(res == NULL, LOAD_GLOBAL);
    1640                 :            :             Py_INCREF(res);
    1641                 :            :             STAT_INC(LOAD_GLOBAL, hit);
    1642                 :            :             null = NULL;
    1643                 :            :             #line 1644 "Python/generated_cases.c.h"
    1644                 :    3561513 :             STACK_GROW(1);
    1645                 :    3561513 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    1646                 :    3561513 :             stack_pointer[-1] = res;
    1647         [ +  + ]:    3561513 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = null; }
    1648                 :    3561513 :             next_instr += 4;
    1649                 :    3561513 :             DISPATCH();
    1650                 :            :         }
    1651                 :            : 
    1652         [ -  + ]:         85 :         TARGET(DELETE_FAST) {
    1653                 :            :             #line 1151 "Python/bytecodes.c"
    1654                 :            :             PyObject *v = GETLOCAL(oparg);
    1655                 :            :             if (v == NULL) goto unbound_local_error;
    1656                 :            :             SETLOCAL(oparg, NULL);
    1657                 :            :             #line 1658 "Python/generated_cases.c.h"
    1658                 :         85 :             DISPATCH();
    1659                 :            :         }
    1660                 :            : 
    1661                 :      43879 :         TARGET(MAKE_CELL) {
    1662                 :            :             #line 1157 "Python/bytecodes.c"
    1663                 :            :             // "initial" is probably NULL but not if it's an arg (or set
    1664                 :            :             // via PyFrame_LocalsToFast() before MAKE_CELL has run).
    1665                 :            :             PyObject *initial = GETLOCAL(oparg);
    1666                 :            :             PyObject *cell = PyCell_New(initial);
    1667                 :            :             if (cell == NULL) {
    1668                 :            :                 goto resume_with_error;
    1669                 :            :             }
    1670                 :            :             SETLOCAL(oparg, cell);
    1671                 :            :             #line 1672 "Python/generated_cases.c.h"
    1672                 :      43879 :             DISPATCH();
    1673                 :            :         }
    1674                 :            : 
    1675                 :          0 :         TARGET(DELETE_DEREF) {
    1676                 :            :             #line 1168 "Python/bytecodes.c"
    1677                 :            :             PyObject *cell = GETLOCAL(oparg);
    1678                 :            :             PyObject *oldobj = PyCell_GET(cell);
    1679                 :            :             // Can't use ERROR_IF here.
    1680                 :            :             // Fortunately we don't need its superpower.
    1681                 :            :             if (oldobj == NULL) {
    1682                 :            :                 format_exc_unbound(tstate, frame->f_code, oparg);
    1683                 :            :                 goto error;
    1684                 :            :             }
    1685                 :            :             PyCell_SET(cell, NULL);
    1686                 :            :             Py_DECREF(oldobj);
    1687                 :            :             #line 1688 "Python/generated_cases.c.h"
    1688                 :          0 :             DISPATCH();
    1689                 :            :         }
    1690                 :            : 
    1691         [ +  - ]:         14 :         TARGET(LOAD_CLASSDEREF) {
    1692                 :            :             PyObject *value;
    1693                 :            :             #line 1181 "Python/bytecodes.c"
    1694                 :            :             PyObject *name, *locals = LOCALS();
    1695                 :            :             assert(locals);
    1696                 :            :             assert(oparg >= 0 && oparg < frame->f_code->co_nlocalsplus);
    1697                 :            :             name = PyTuple_GET_ITEM(frame->f_code->co_localsplusnames, oparg);
    1698                 :            :             if (PyDict_CheckExact(locals)) {
    1699                 :            :                 value = PyDict_GetItemWithError(locals, name);
    1700                 :            :                 if (value != NULL) {
    1701                 :            :                     Py_INCREF(value);
    1702                 :            :                 }
    1703                 :            :                 else if (_PyErr_Occurred(tstate)) {
    1704                 :            :                     goto error;
    1705                 :            :                 }
    1706                 :            :             }
    1707                 :            :             else {
    1708                 :            :                 value = PyObject_GetItem(locals, name);
    1709                 :            :                 if (value == NULL) {
    1710                 :            :                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
    1711                 :            :                         goto error;
    1712                 :            :                     }
    1713                 :            :                     _PyErr_Clear(tstate);
    1714                 :            :                 }
    1715                 :            :             }
    1716                 :            :             if (!value) {
    1717                 :            :                 PyObject *cell = GETLOCAL(oparg);
    1718                 :            :                 value = PyCell_GET(cell);
    1719                 :            :                 if (value == NULL) {
    1720                 :            :                     format_exc_unbound(tstate, frame->f_code, oparg);
    1721                 :            :                     goto error;
    1722                 :            :                 }
    1723                 :            :                 Py_INCREF(value);
    1724                 :            :             }
    1725                 :            :             #line 1726 "Python/generated_cases.c.h"
    1726                 :         14 :             STACK_GROW(1);
    1727                 :         14 :             stack_pointer[-1] = value;
    1728                 :         14 :             DISPATCH();
    1729                 :            :         }
    1730                 :            : 
    1731                 :    1415494 :         TARGET(LOAD_DEREF) {
    1732                 :            :             PyObject *value;
    1733                 :            :             #line 1215 "Python/bytecodes.c"
    1734                 :            :             PyObject *cell = GETLOCAL(oparg);
    1735                 :            :             value = PyCell_GET(cell);
    1736                 :            :             if (value == NULL) {
    1737                 :            :                 format_exc_unbound(tstate, frame->f_code, oparg);
    1738                 :            :                 if (true) goto error;
    1739                 :            :             }
    1740                 :            :             Py_INCREF(value);
    1741                 :            :             #line 1742 "Python/generated_cases.c.h"
    1742                 :    1415494 :             STACK_GROW(1);
    1743                 :    1415494 :             stack_pointer[-1] = value;
    1744                 :    1415494 :             DISPATCH();
    1745                 :            :         }
    1746                 :            : 
    1747                 :      19694 :         TARGET(STORE_DEREF) {
    1748                 :      19694 :             PyObject *v = stack_pointer[-1];
    1749                 :            :             #line 1225 "Python/bytecodes.c"
    1750                 :            :             PyObject *cell = GETLOCAL(oparg);
    1751                 :            :             PyObject *oldobj = PyCell_GET(cell);
    1752                 :            :             PyCell_SET(cell, v);
    1753                 :            :             Py_XDECREF(oldobj);
    1754                 :            :             #line 1755 "Python/generated_cases.c.h"
    1755                 :      19694 :             STACK_SHRINK(1);
    1756                 :      19694 :             DISPATCH();
    1757                 :            :         }
    1758                 :            : 
    1759                 :     736039 :         TARGET(COPY_FREE_VARS) {
    1760                 :            :             #line 1232 "Python/bytecodes.c"
    1761                 :            :             /* Copy closure variables to free variables */
    1762                 :            :             PyCodeObject *co = frame->f_code;
    1763                 :            :             assert(PyFunction_Check(frame->f_funcobj));
    1764                 :            :             PyObject *closure = ((PyFunctionObject *)frame->f_funcobj)->func_closure;
    1765                 :            :             assert(oparg == co->co_nfreevars);
    1766                 :            :             int offset = co->co_nlocalsplus - oparg;
    1767                 :            :             for (int i = 0; i < oparg; ++i) {
    1768                 :            :                 PyObject *o = PyTuple_GET_ITEM(closure, i);
    1769                 :            :                 frame->localsplus[offset + i] = Py_NewRef(o);
    1770                 :            :             }
    1771                 :            :             #line 1772 "Python/generated_cases.c.h"
    1772                 :     736039 :             DISPATCH();
    1773                 :            :         }
    1774                 :            : 
    1775                 :     342034 :         TARGET(BUILD_STRING) {
    1776                 :     342034 :             PyObject **pieces = (stack_pointer - oparg);
    1777                 :            :             PyObject *str;
    1778                 :            :             #line 1245 "Python/bytecodes.c"
    1779                 :            :             str = _PyUnicode_JoinArray(&_Py_STR(empty), pieces, oparg);
    1780                 :            :             #line 1781 "Python/generated_cases.c.h"
    1781         [ +  + ]:    1104955 :             for (int _i = oparg; --_i >= 0;) {
    1782         [ +  + ]:     762921 :                 Py_DECREF(pieces[_i]);
    1783                 :            :             }
    1784                 :            :             #line 1247 "Python/bytecodes.c"
    1785                 :            :             if (str == NULL) { STACK_SHRINK(oparg); goto error; }
    1786                 :            :             #line 1787 "Python/generated_cases.c.h"
    1787                 :     342034 :             STACK_SHRINK(oparg);
    1788                 :     342034 :             STACK_GROW(1);
    1789                 :     342034 :             stack_pointer[-1] = str;
    1790                 :     342034 :             DISPATCH();
    1791                 :            :         }
    1792                 :            : 
    1793                 :     278852 :         TARGET(BUILD_TUPLE) {
    1794                 :     278852 :             PyObject **values = (stack_pointer - oparg);
    1795                 :            :             PyObject *tup;
    1796                 :            :             #line 1251 "Python/bytecodes.c"
    1797                 :            :             tup = _PyTuple_FromArraySteal(values, oparg);
    1798                 :            :             if (tup == NULL) { STACK_SHRINK(oparg); goto error; }
    1799                 :            :             #line 1800 "Python/generated_cases.c.h"
    1800                 :     278852 :             STACK_SHRINK(oparg);
    1801                 :     278852 :             STACK_GROW(1);
    1802                 :     278852 :             stack_pointer[-1] = tup;
    1803                 :     278852 :             DISPATCH();
    1804                 :            :         }
    1805                 :            : 
    1806                 :     165891 :         TARGET(BUILD_LIST) {
    1807                 :     165891 :             PyObject **values = (stack_pointer - oparg);
    1808                 :            :             PyObject *list;
    1809                 :            :             #line 1256 "Python/bytecodes.c"
    1810                 :            :             list = _PyList_FromArraySteal(values, oparg);
    1811                 :            :             if (list == NULL) { STACK_SHRINK(oparg); goto error; }
    1812                 :            :             #line 1813 "Python/generated_cases.c.h"
    1813                 :     165891 :             STACK_SHRINK(oparg);
    1814                 :     165891 :             STACK_GROW(1);
    1815                 :     165891 :             stack_pointer[-1] = list;
    1816                 :     165891 :             DISPATCH();
    1817                 :            :         }
    1818                 :            : 
    1819                 :       2739 :         TARGET(LIST_EXTEND) {
    1820                 :       2739 :             PyObject *iterable = stack_pointer[-1];
    1821                 :       2739 :             PyObject *list = stack_pointer[-(2 + (oparg-1))];
    1822                 :            :             #line 1261 "Python/bytecodes.c"
    1823                 :            :             PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
    1824                 :            :             if (none_val == NULL) {
    1825                 :            :                 if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) &&
    1826                 :            :                    (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
    1827                 :            :                 {
    1828                 :            :                     _PyErr_Clear(tstate);
    1829                 :            :                     _PyErr_Format(tstate, PyExc_TypeError,
    1830                 :            :                           "Value after * must be an iterable, not %.200s",
    1831                 :            :                           Py_TYPE(iterable)->tp_name);
    1832                 :            :                 }
    1833                 :            :             #line 1834 "Python/generated_cases.c.h"
    1834         [ #  # ]:          0 :                 Py_DECREF(iterable);
    1835                 :            :             #line 1272 "Python/bytecodes.c"
    1836                 :            :                 if (true) goto pop_1_error;
    1837                 :            :             }
    1838                 :            :             Py_DECREF(none_val);
    1839                 :            :             #line 1840 "Python/generated_cases.c.h"
    1840         [ +  + ]:       2739 :             Py_DECREF(iterable);
    1841                 :       2739 :             STACK_SHRINK(1);
    1842                 :       2739 :             DISPATCH();
    1843                 :            :         }
    1844                 :            : 
    1845                 :         10 :         TARGET(SET_UPDATE) {
    1846                 :         10 :             PyObject *iterable = stack_pointer[-1];
    1847                 :         10 :             PyObject *set = stack_pointer[-(2 + (oparg-1))];
    1848                 :            :             #line 1279 "Python/bytecodes.c"
    1849                 :            :             int err = _PySet_Update(set, iterable);
    1850                 :            :             #line 1851 "Python/generated_cases.c.h"
    1851         [ -  + ]:         10 :             Py_DECREF(iterable);
    1852                 :            :             #line 1281 "Python/bytecodes.c"
    1853                 :            :             if (err < 0) goto pop_1_error;
    1854                 :            :             #line 1855 "Python/generated_cases.c.h"
    1855                 :         10 :             STACK_SHRINK(1);
    1856                 :         10 :             DISPATCH();
    1857                 :            :         }
    1858                 :            : 
    1859                 :        374 :         TARGET(BUILD_SET) {
    1860                 :        374 :             PyObject **values = (stack_pointer - oparg);
    1861                 :            :             PyObject *set;
    1862                 :            :             #line 1285 "Python/bytecodes.c"
    1863                 :            :             set = PySet_New(NULL);
    1864                 :            :             if (set == NULL)
    1865                 :            :                 goto error;
    1866                 :            :             int err = 0;
    1867                 :            :             for (int i = 0; i < oparg; i++) {
    1868                 :            :                 PyObject *item = values[i];
    1869                 :            :                 if (err == 0)
    1870                 :            :                     err = PySet_Add(set, item);
    1871                 :            :                 Py_DECREF(item);
    1872                 :            :             }
    1873                 :            :             if (err != 0) {
    1874                 :            :                 Py_DECREF(set);
    1875                 :            :                 if (true) { STACK_SHRINK(oparg); goto error; }
    1876                 :            :             }
    1877                 :            :             #line 1878 "Python/generated_cases.c.h"
    1878                 :        374 :             STACK_SHRINK(oparg);
    1879                 :        374 :             STACK_GROW(1);
    1880                 :        374 :             stack_pointer[-1] = set;
    1881                 :        374 :             DISPATCH();
    1882                 :            :         }
    1883                 :            : 
    1884                 :     120365 :         TARGET(BUILD_MAP) {
    1885                 :     120365 :             PyObject **values = (stack_pointer - oparg*2);
    1886                 :            :             PyObject *map;
    1887                 :            :             #line 1302 "Python/bytecodes.c"
    1888                 :            :             map = _PyDict_FromItems(
    1889                 :            :                     values, 2,
    1890                 :            :                     values+1, 2,
    1891                 :            :                     oparg);
    1892                 :            :             if (map == NULL)
    1893                 :            :                 goto error;
    1894                 :            : 
    1895                 :            :             #line 1896 "Python/generated_cases.c.h"
    1896         [ +  + ]:     120831 :             for (int _i = oparg*2; --_i >= 0;) {
    1897         [ -  + ]:        466 :                 Py_DECREF(values[_i]);
    1898                 :            :             }
    1899                 :            :             #line 1310 "Python/bytecodes.c"
    1900                 :            :             if (map == NULL) { STACK_SHRINK(oparg*2); goto error; }
    1901                 :            :             #line 1902 "Python/generated_cases.c.h"
    1902                 :     120365 :             STACK_SHRINK(oparg*2);
    1903                 :     120365 :             STACK_GROW(1);
    1904                 :     120365 :             stack_pointer[-1] = map;
    1905                 :     120365 :             DISPATCH();
    1906                 :            :         }
    1907                 :            : 
    1908         [ -  + ]:          1 :         TARGET(SETUP_ANNOTATIONS) {
    1909                 :            :             #line 1314 "Python/bytecodes.c"
    1910                 :            :             int err;
    1911                 :            :             PyObject *ann_dict;
    1912                 :            :             if (LOCALS() == NULL) {
    1913                 :            :                 _PyErr_Format(tstate, PyExc_SystemError,
    1914                 :            :                               "no locals found when setting up annotations");
    1915                 :            :                 if (true) goto error;
    1916                 :            :             }
    1917                 :            :             /* check if __annotations__ in locals()... */
    1918                 :            :             if (PyDict_CheckExact(LOCALS())) {
    1919                 :            :                 ann_dict = _PyDict_GetItemWithError(LOCALS(),
    1920                 :            :                                                     &_Py_ID(__annotations__));
    1921                 :            :                 if (ann_dict == NULL) {
    1922                 :            :                     if (_PyErr_Occurred(tstate)) goto error;
    1923                 :            :                     /* ...if not, create a new one */
    1924                 :            :                     ann_dict = PyDict_New();
    1925                 :            :                     if (ann_dict == NULL) goto error;
    1926                 :            :                     err = PyDict_SetItem(LOCALS(), &_Py_ID(__annotations__),
    1927                 :            :                                          ann_dict);
    1928                 :            :                     Py_DECREF(ann_dict);
    1929                 :            :                     if (err) goto error;
    1930                 :            :                 }
    1931                 :            :             }
    1932                 :            :             else {
    1933                 :            :                 /* do the same if locals() is not a dict */
    1934                 :            :                 ann_dict = PyObject_GetItem(LOCALS(), &_Py_ID(__annotations__));
    1935                 :            :                 if (ann_dict == NULL) {
    1936                 :            :                     if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) goto error;
    1937                 :            :                     _PyErr_Clear(tstate);
    1938                 :            :                     ann_dict = PyDict_New();
    1939                 :            :                     if (ann_dict == NULL) goto error;
    1940                 :            :                     err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
    1941                 :            :                                            ann_dict);
    1942                 :            :                     Py_DECREF(ann_dict);
    1943                 :            :                     if (err) goto error;
    1944                 :            :                 }
    1945                 :            :                 else {
    1946                 :            :                     Py_DECREF(ann_dict);
    1947                 :            :                 }
    1948                 :            :             }
    1949                 :            :             #line 1950 "Python/generated_cases.c.h"
    1950                 :          1 :             DISPATCH();
    1951                 :            :         }
    1952                 :            : 
    1953                 :       1911 :         TARGET(BUILD_CONST_KEY_MAP) {
    1954                 :       1911 :             PyObject *keys = stack_pointer[-1];
    1955         [ +  - ]:       1911 :             PyObject **values = (stack_pointer - (1 + oparg));
    1956                 :            :             PyObject *map;
    1957                 :            :             #line 1356 "Python/bytecodes.c"
    1958                 :            :             if (!PyTuple_CheckExact(keys) ||
    1959                 :            :                 PyTuple_GET_SIZE(keys) != (Py_ssize_t)oparg) {
    1960                 :            :                 _PyErr_SetString(tstate, PyExc_SystemError,
    1961                 :            :                                  "bad BUILD_CONST_KEY_MAP keys argument");
    1962                 :            :                 goto error;  // Pop the keys and values.
    1963                 :            :             }
    1964                 :            :             map = _PyDict_FromItems(
    1965                 :            :                     &PyTuple_GET_ITEM(keys, 0), 1,
    1966                 :            :                     values, 1, oparg);
    1967                 :            :             #line 1968 "Python/generated_cases.c.h"
    1968         [ +  + ]:       7081 :             for (int _i = oparg; --_i >= 0;) {
    1969         [ -  + ]:       5170 :                 Py_DECREF(values[_i]);
    1970                 :            :             }
    1971         [ -  + ]:       1911 :             Py_DECREF(keys);
    1972                 :            :             #line 1366 "Python/bytecodes.c"
    1973                 :            :             if (map == NULL) { STACK_SHRINK(oparg); goto pop_1_error; }
    1974                 :            :             #line 1975 "Python/generated_cases.c.h"
    1975                 :       1911 :             STACK_SHRINK(oparg);
    1976                 :       1911 :             stack_pointer[-1] = map;
    1977                 :       1911 :             DISPATCH();
    1978                 :            :         }
    1979                 :            : 
    1980                 :        750 :         TARGET(DICT_UPDATE) {
    1981                 :        750 :             PyObject *update = stack_pointer[-1];
    1982                 :            :             #line 1370 "Python/bytecodes.c"
    1983                 :            :             PyObject *dict = PEEK(oparg + 1);  // update is still on the stack
    1984                 :            :             if (PyDict_Update(dict, update) < 0) {
    1985                 :            :                 if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
    1986                 :            :                     _PyErr_Format(tstate, PyExc_TypeError,
    1987                 :            :                                     "'%.200s' object is not a mapping",
    1988                 :            :                                     Py_TYPE(update)->tp_name);
    1989                 :            :                 }
    1990                 :            :             #line 1991 "Python/generated_cases.c.h"
    1991         [ #  # ]:          0 :                 Py_DECREF(update);
    1992                 :            :             #line 1378 "Python/bytecodes.c"
    1993                 :            :                 if (true) goto pop_1_error;
    1994                 :            :             }
    1995                 :            :             #line 1996 "Python/generated_cases.c.h"
    1996         [ +  - ]:        750 :             Py_DECREF(update);
    1997                 :        750 :             STACK_SHRINK(1);
    1998                 :        750 :             DISPATCH();
    1999                 :            :         }
    2000                 :            : 
    2001                 :     102304 :         TARGET(DICT_MERGE) {
    2002                 :     102304 :             PyObject *update = stack_pointer[-1];
    2003                 :            :             #line 1384 "Python/bytecodes.c"
    2004                 :            :             PyObject *dict = PEEK(oparg + 1);  // update is still on the stack
    2005                 :            : 
    2006                 :            :             if (_PyDict_MergeEx(dict, update, 2) < 0) {
    2007                 :            :                 format_kwargs_error(tstate, PEEK(3 + oparg), update);
    2008                 :            :             #line 2009 "Python/generated_cases.c.h"
    2009         [ #  # ]:          0 :                 Py_DECREF(update);
    2010                 :            :             #line 1389 "Python/bytecodes.c"
    2011                 :            :                 if (true) goto pop_1_error;
    2012                 :            :             }
    2013                 :            :             #line 2014 "Python/generated_cases.c.h"
    2014         [ -  + ]:     102304 :             Py_DECREF(update);
    2015                 :     102304 :             STACK_SHRINK(1);
    2016                 :            :             PREDICT(CALL_FUNCTION_EX);
    2017                 :     102304 :             DISPATCH();
    2018                 :            :         }
    2019                 :            : 
    2020                 :      13896 :         TARGET(MAP_ADD) {
    2021                 :      13896 :             PyObject *value = stack_pointer[-1];
    2022                 :      13896 :             PyObject *key = stack_pointer[-2];
    2023                 :            :             #line 1396 "Python/bytecodes.c"
    2024                 :            :             PyObject *dict = PEEK(oparg + 2);  // key, value are still on the stack
    2025                 :            :             assert(PyDict_CheckExact(dict));
    2026                 :            :             /* dict[key] = value */
    2027                 :            :             // Do not DECREF INPUTS because the function steals the references
    2028                 :            :             if (_PyDict_SetItem_Take2((PyDictObject *)dict, key, value) != 0) goto pop_2_error;
    2029                 :            :             #line 2030 "Python/generated_cases.c.h"
    2030                 :      13896 :             STACK_SHRINK(2);
    2031                 :            :             PREDICT(JUMP_BACKWARD);
    2032                 :      13896 :             DISPATCH();
    2033                 :            :         }
    2034                 :            : 
    2035                 :    1650808 :         TARGET(LOAD_ATTR) {
    2036                 :    1891903 :             PREDICTED(LOAD_ATTR);
    2037                 :            :             static_assert(INLINE_CACHE_ENTRIES_LOAD_ATTR == 9, "incorrect cache size");
    2038                 :    1891903 :             PyObject *owner = stack_pointer[-1];
    2039         [ +  + ]:    1891903 :             PyObject *res2 = NULL;
    2040                 :            :             PyObject *res;
    2041                 :            :             #line 1419 "Python/bytecodes.c"
    2042                 :            :             #if ENABLE_SPECIALIZATION
    2043                 :            :             _PyAttrCache *cache = (_PyAttrCache *)next_instr;
    2044                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
    2045                 :            :                 assert(cframe.use_tracing == 0);
    2046                 :            :                 PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
    2047                 :            :                 next_instr--;
    2048                 :            :                 _Py_Specialize_LoadAttr(owner, next_instr, name);
    2049                 :            :                 DISPATCH_SAME_OPARG();
    2050                 :            :             }
    2051                 :            :             STAT_INC(LOAD_ATTR, deferred);
    2052                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
    2053                 :            :             #endif  /* ENABLE_SPECIALIZATION */
    2054                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg >> 1);
    2055                 :            :             if (oparg & 1) {
    2056                 :            :                 /* Designed to work in tandem with CALL, pushes two values. */
    2057                 :            :                 PyObject* meth = NULL;
    2058                 :            :                 if (_PyObject_GetMethod(owner, name, &meth)) {
    2059                 :            :                     /* We can bypass temporary bound method object.
    2060                 :            :                        meth is unbound method and obj is self.
    2061                 :            : 
    2062                 :            :                        meth | self | arg1 | ... | argN
    2063                 :            :                      */
    2064                 :            :                     assert(meth != NULL);  // No errors on this branch
    2065                 :            :                     res2 = meth;
    2066                 :            :                     res = owner;  // Transfer ownership
    2067                 :            :                 }
    2068                 :            :                 else {
    2069                 :            :                     /* meth is not an unbound method (but a regular attr, or
    2070                 :            :                        something was returned by a descriptor protocol).  Set
    2071                 :            :                        the second element of the stack to NULL, to signal
    2072                 :            :                        CALL that it's not a method call.
    2073                 :            : 
    2074                 :            :                        NULL | meth | arg1 | ... | argN
    2075                 :            :                     */
    2076                 :            :             #line 2077 "Python/generated_cases.c.h"
    2077         [ +  + ]:     256938 :                     Py_DECREF(owner);
    2078                 :            :             #line 1454 "Python/bytecodes.c"
    2079                 :            :                     if (meth == NULL) goto pop_1_error;
    2080                 :            :                     res2 = NULL;
    2081                 :            :                     res = meth;
    2082                 :            :                 }
    2083                 :            :             }
    2084                 :            :             else {
    2085                 :            :                 /* Classic, pushes one value. */
    2086                 :            :                 res = PyObject_GetAttr(owner, name);
    2087                 :            :             #line 2088 "Python/generated_cases.c.h"
    2088         [ +  + ]:    1403529 :                 Py_DECREF(owner);
    2089                 :            :             #line 1463 "Python/bytecodes.c"
    2090                 :            :                 if (res == NULL) goto pop_1_error;
    2091                 :            :             }
    2092                 :            :             #line 2093 "Python/generated_cases.c.h"
    2093                 :    1873557 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    2094                 :    1873557 :             stack_pointer[-1] = res;
    2095         [ +  + ]:    1873557 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
    2096                 :    1873557 :             next_instr += 9;
    2097                 :    1873557 :             DISPATCH();
    2098                 :            :         }
    2099                 :            : 
    2100                 :    1481398 :         TARGET(LOAD_ATTR_INSTANCE_VALUE) {
    2101                 :    1481398 :             PyObject *owner = stack_pointer[-1];
    2102                 :    1481398 :             PyObject *res2 = NULL;
    2103                 :            :             PyObject *res;
    2104                 :    1481398 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2105                 :    1481398 :             uint16_t index = read_u16(&next_instr[3].cache);
    2106                 :            :             #line 1468 "Python/bytecodes.c"
    2107                 :            :             assert(cframe.use_tracing == 0);
    2108                 :            :             PyTypeObject *tp = Py_TYPE(owner);
    2109                 :            :             assert(type_version != 0);
    2110                 :            :             DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
    2111                 :            :             assert(tp->tp_dictoffset < 0);
    2112                 :            :             assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
    2113                 :            :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(owner);
    2114                 :            :             DEOPT_IF(!_PyDictOrValues_IsValues(dorv), LOAD_ATTR);
    2115                 :            :             res = _PyDictOrValues_GetValues(dorv)->values[index];
    2116                 :            :             DEOPT_IF(res == NULL, LOAD_ATTR);
    2117                 :            :             STAT_INC(LOAD_ATTR, hit);
    2118                 :            :             Py_INCREF(res);
    2119                 :            :             res2 = NULL;
    2120                 :            :             #line 2121 "Python/generated_cases.c.h"
    2121         [ -  + ]:    1480649 :             Py_DECREF(owner);
    2122                 :    1480649 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    2123                 :    1480649 :             stack_pointer[-1] = res;
    2124         [ +  + ]:    1480649 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
    2125                 :    1480649 :             next_instr += 9;
    2126                 :    1480649 :             DISPATCH();
    2127                 :            :         }
    2128                 :            : 
    2129                 :    1473626 :         TARGET(LOAD_ATTR_MODULE) {
    2130                 :    1473626 :             PyObject *owner = stack_pointer[-1];
    2131                 :    1473626 :             PyObject *res2 = NULL;
    2132                 :            :             PyObject *res;
    2133                 :    1473626 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2134                 :    1473626 :             uint16_t index = read_u16(&next_instr[3].cache);
    2135                 :            :             #line 1485 "Python/bytecodes.c"
    2136                 :            :             assert(cframe.use_tracing == 0);
    2137                 :            :             DEOPT_IF(!PyModule_CheckExact(owner), LOAD_ATTR);
    2138                 :            :             PyDictObject *dict = (PyDictObject *)((PyModuleObject *)owner)->md_dict;
    2139                 :            :             assert(dict != NULL);
    2140                 :            :             DEOPT_IF(dict->ma_keys->dk_version != type_version, LOAD_ATTR);
    2141                 :            :             assert(dict->ma_keys->dk_kind == DICT_KEYS_UNICODE);
    2142                 :            :             assert(index < dict->ma_keys->dk_nentries);
    2143                 :            :             PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + index;
    2144                 :            :             res = ep->me_value;
    2145                 :            :             DEOPT_IF(res == NULL, LOAD_ATTR);
    2146                 :            :             STAT_INC(LOAD_ATTR, hit);
    2147                 :            :             Py_INCREF(res);
    2148                 :            :             res2 = NULL;
    2149                 :            :             #line 2150 "Python/generated_cases.c.h"
    2150         [ -  + ]:    1462832 :             Py_DECREF(owner);
    2151                 :    1462832 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    2152                 :    1462832 :             stack_pointer[-1] = res;
    2153         [ +  + ]:    1462832 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
    2154                 :    1462832 :             next_instr += 9;
    2155                 :    1462832 :             DISPATCH();
    2156                 :            :         }
    2157                 :            : 
    2158                 :     227690 :         TARGET(LOAD_ATTR_WITH_HINT) {
    2159                 :     227690 :             PyObject *owner = stack_pointer[-1];
    2160                 :     227690 :             PyObject *res2 = NULL;
    2161                 :            :             PyObject *res;
    2162                 :     227690 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2163                 :     227690 :             uint16_t index = read_u16(&next_instr[3].cache);
    2164                 :            :             #line 1502 "Python/bytecodes.c"
    2165                 :            :             assert(cframe.use_tracing == 0);
    2166                 :            :             PyTypeObject *tp = Py_TYPE(owner);
    2167                 :            :             assert(type_version != 0);
    2168                 :            :             DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
    2169                 :            :             assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
    2170                 :            :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(owner);
    2171                 :            :             DEOPT_IF(_PyDictOrValues_IsValues(dorv), LOAD_ATTR);
    2172                 :            :             PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(dorv);
    2173                 :            :             DEOPT_IF(dict == NULL, LOAD_ATTR);
    2174                 :            :             assert(PyDict_CheckExact((PyObject *)dict));
    2175                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg>>1);
    2176                 :            :             uint16_t hint = index;
    2177                 :            :             DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, LOAD_ATTR);
    2178                 :            :             if (DK_IS_UNICODE(dict->ma_keys)) {
    2179                 :            :                 PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint;
    2180                 :            :                 DEOPT_IF(ep->me_key != name, LOAD_ATTR);
    2181                 :            :                 res = ep->me_value;
    2182                 :            :             }
    2183                 :            :             else {
    2184                 :            :                 PyDictKeyEntry *ep = DK_ENTRIES(dict->ma_keys) + hint;
    2185                 :            :                 DEOPT_IF(ep->me_key != name, LOAD_ATTR);
    2186                 :            :                 res = ep->me_value;
    2187                 :            :             }
    2188                 :            :             DEOPT_IF(res == NULL, LOAD_ATTR);
    2189                 :            :             STAT_INC(LOAD_ATTR, hit);
    2190                 :            :             Py_INCREF(res);
    2191                 :            :             res2 = NULL;
    2192                 :            :             #line 2193 "Python/generated_cases.c.h"
    2193         [ -  + ]:         59 :             Py_DECREF(owner);
    2194                 :         59 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    2195                 :         59 :             stack_pointer[-1] = res;
    2196         [ -  + ]:         59 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
    2197                 :         59 :             next_instr += 9;
    2198                 :         59 :             DISPATCH();
    2199                 :            :         }
    2200                 :            : 
    2201                 :     375316 :         TARGET(LOAD_ATTR_SLOT) {
    2202                 :     375316 :             PyObject *owner = stack_pointer[-1];
    2203                 :     375316 :             PyObject *res2 = NULL;
    2204                 :            :             PyObject *res;
    2205                 :     375316 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2206                 :     375316 :             uint16_t index = read_u16(&next_instr[3].cache);
    2207                 :            :             #line 1533 "Python/bytecodes.c"
    2208                 :            :             assert(cframe.use_tracing == 0);
    2209                 :            :             PyTypeObject *tp = Py_TYPE(owner);
    2210                 :            :             assert(type_version != 0);
    2211                 :            :             DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
    2212                 :            :             char *addr = (char *)owner + index;
    2213                 :            :             res = *(PyObject **)addr;
    2214                 :            :             DEOPT_IF(res == NULL, LOAD_ATTR);
    2215                 :            :             STAT_INC(LOAD_ATTR, hit);
    2216                 :            :             Py_INCREF(res);
    2217                 :            :             res2 = NULL;
    2218                 :            :             #line 2219 "Python/generated_cases.c.h"
    2219         [ -  + ]:     374910 :             Py_DECREF(owner);
    2220                 :     374910 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    2221                 :     374910 :             stack_pointer[-1] = res;
    2222         [ +  + ]:     374910 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
    2223                 :     374910 :             next_instr += 9;
    2224                 :     374910 :             DISPATCH();
    2225                 :            :         }
    2226                 :            : 
    2227                 :     376321 :         TARGET(LOAD_ATTR_CLASS) {
    2228                 :     376321 :             PyObject *cls = stack_pointer[-1];
    2229                 :     376321 :             PyObject *res2 = NULL;
    2230                 :            :             PyObject *res;
    2231                 :     376321 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2232                 :     376321 :             PyObject *descr = read_obj(&next_instr[5].cache);
    2233                 :            :             #line 1547 "Python/bytecodes.c"
    2234                 :            :             assert(cframe.use_tracing == 0);
    2235                 :            : 
    2236                 :            :             DEOPT_IF(!PyType_Check(cls), LOAD_ATTR);
    2237                 :            :             DEOPT_IF(((PyTypeObject *)cls)->tp_version_tag != type_version,
    2238                 :            :                 LOAD_ATTR);
    2239                 :            :             assert(type_version != 0);
    2240                 :            : 
    2241                 :            :             STAT_INC(LOAD_ATTR, hit);
    2242                 :            :             res2 = NULL;
    2243                 :            :             res = descr;
    2244                 :            :             assert(res != NULL);
    2245                 :            :             Py_INCREF(res);
    2246                 :            :             #line 2247 "Python/generated_cases.c.h"
    2247         [ -  + ]:     376319 :             Py_DECREF(cls);
    2248                 :     376319 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    2249                 :     376319 :             stack_pointer[-1] = res;
    2250         [ -  + ]:     376319 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
    2251                 :     376319 :             next_instr += 9;
    2252                 :     376319 :             DISPATCH();
    2253                 :            :         }
    2254                 :            : 
    2255                 :      41965 :         TARGET(LOAD_ATTR_PROPERTY) {
    2256                 :      41965 :             PyObject *owner = stack_pointer[-1];
    2257                 :      41965 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2258                 :      41965 :             uint32_t func_version = read_u32(&next_instr[3].cache);
    2259                 :      41965 :             PyObject *fget = read_obj(&next_instr[5].cache);
    2260                 :            :             #line 1563 "Python/bytecodes.c"
    2261                 :            :             assert(cframe.use_tracing == 0);
    2262                 :            :             DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR);
    2263                 :            : 
    2264                 :            :             PyTypeObject *cls = Py_TYPE(owner);
    2265                 :            :             DEOPT_IF(cls->tp_version_tag != type_version, LOAD_ATTR);
    2266                 :            :             assert(type_version != 0);
    2267                 :            :             assert(Py_IS_TYPE(fget, &PyFunction_Type));
    2268                 :            :             PyFunctionObject *f = (PyFunctionObject *)fget;
    2269                 :            :             assert(func_version != 0);
    2270                 :            :             DEOPT_IF(f->func_version != func_version, LOAD_ATTR);
    2271                 :            :             PyCodeObject *code = (PyCodeObject *)f->func_code;
    2272                 :            :             assert(code->co_argcount == 1);
    2273                 :            :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), LOAD_ATTR);
    2274                 :            :             STAT_INC(LOAD_ATTR, hit);
    2275                 :            :             Py_INCREF(fget);
    2276                 :            :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, f, 1);
    2277                 :            :             // Manipulate stack directly because we exit with DISPATCH_INLINED().
    2278                 :            :             SET_TOP(NULL);
    2279                 :            :             int shrink_stack = !(oparg & 1);
    2280                 :            :             STACK_SHRINK(shrink_stack);
    2281                 :            :             new_frame->localsplus[0] = owner;
    2282                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
    2283                 :            :             DISPATCH_INLINED(new_frame);
    2284                 :            :             #line 2285 "Python/generated_cases.c.h"
    2285                 :            :         }
    2286                 :            : 
    2287                 :          0 :         TARGET(LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN) {
    2288                 :          0 :             PyObject *owner = stack_pointer[-1];
    2289                 :          0 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2290                 :          0 :             uint32_t func_version = read_u32(&next_instr[3].cache);
    2291                 :          0 :             PyObject *getattribute = read_obj(&next_instr[5].cache);
    2292                 :            :             #line 1589 "Python/bytecodes.c"
    2293                 :            :             assert(cframe.use_tracing == 0);
    2294                 :            :             DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR);
    2295                 :            :             PyTypeObject *cls = Py_TYPE(owner);
    2296                 :            :             DEOPT_IF(cls->tp_version_tag != type_version, LOAD_ATTR);
    2297                 :            :             assert(type_version != 0);
    2298                 :            :             assert(Py_IS_TYPE(getattribute, &PyFunction_Type));
    2299                 :            :             PyFunctionObject *f = (PyFunctionObject *)getattribute;
    2300                 :            :             assert(func_version != 0);
    2301                 :            :             DEOPT_IF(f->func_version != func_version, LOAD_ATTR);
    2302                 :            :             PyCodeObject *code = (PyCodeObject *)f->func_code;
    2303                 :            :             assert(code->co_argcount == 2);
    2304                 :            :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), LOAD_ATTR);
    2305                 :            :             STAT_INC(LOAD_ATTR, hit);
    2306                 :            : 
    2307                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg >> 1);
    2308                 :            :             Py_INCREF(f);
    2309                 :            :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, f, 2);
    2310                 :            :             // Manipulate stack directly because we exit with DISPATCH_INLINED().
    2311                 :            :             SET_TOP(NULL);
    2312                 :            :             int shrink_stack = !(oparg & 1);
    2313                 :            :             STACK_SHRINK(shrink_stack);
    2314                 :            :             new_frame->localsplus[0] = owner;
    2315                 :            :             new_frame->localsplus[1] = Py_NewRef(name);
    2316                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
    2317                 :            :             DISPATCH_INLINED(new_frame);
    2318                 :            :             #line 2319 "Python/generated_cases.c.h"
    2319                 :            :         }
    2320                 :            : 
    2321                 :     842732 :         TARGET(STORE_ATTR_INSTANCE_VALUE) {
    2322                 :     842732 :             PyObject *owner = stack_pointer[-1];
    2323                 :     842732 :             PyObject *value = stack_pointer[-2];
    2324                 :     842732 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2325                 :     842732 :             uint16_t index = read_u16(&next_instr[3].cache);
    2326                 :            :             #line 1617 "Python/bytecodes.c"
    2327                 :            :             assert(cframe.use_tracing == 0);
    2328                 :            :             PyTypeObject *tp = Py_TYPE(owner);
    2329                 :            :             assert(type_version != 0);
    2330                 :            :             DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
    2331                 :            :             assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
    2332                 :            :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(owner);
    2333                 :            :             DEOPT_IF(!_PyDictOrValues_IsValues(dorv), STORE_ATTR);
    2334                 :            :             STAT_INC(STORE_ATTR, hit);
    2335                 :            :             PyDictValues *values = _PyDictOrValues_GetValues(dorv);
    2336                 :            :             PyObject *old_value = values->values[index];
    2337                 :            :             values->values[index] = value;
    2338                 :            :             if (old_value == NULL) {
    2339                 :            :                 _PyDictValues_AddToInsertionOrder(values, index);
    2340                 :            :             }
    2341                 :            :             else {
    2342                 :            :                 Py_DECREF(old_value);
    2343                 :            :             }
    2344                 :            :             Py_DECREF(owner);
    2345                 :            :             #line 2346 "Python/generated_cases.c.h"
    2346                 :     841574 :             STACK_SHRINK(2);
    2347                 :     841574 :             next_instr += 4;
    2348                 :     841574 :             DISPATCH();
    2349                 :            :         }
    2350                 :            : 
    2351                 :     319989 :         TARGET(STORE_ATTR_WITH_HINT) {
    2352                 :     319989 :             PyObject *owner = stack_pointer[-1];
    2353                 :     319989 :             PyObject *value = stack_pointer[-2];
    2354                 :     319989 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2355                 :     319989 :             uint16_t hint = read_u16(&next_instr[3].cache);
    2356                 :            :             #line 1638 "Python/bytecodes.c"
    2357                 :            :             assert(cframe.use_tracing == 0);
    2358                 :            :             PyTypeObject *tp = Py_TYPE(owner);
    2359                 :            :             assert(type_version != 0);
    2360                 :            :             DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
    2361                 :            :             assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
    2362                 :            :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(owner);
    2363                 :            :             DEOPT_IF(_PyDictOrValues_IsValues(dorv), STORE_ATTR);
    2364                 :            :             PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(dorv);
    2365                 :            :             DEOPT_IF(dict == NULL, STORE_ATTR);
    2366                 :            :             assert(PyDict_CheckExact((PyObject *)dict));
    2367                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    2368                 :            :             DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, STORE_ATTR);
    2369                 :            :             PyObject *old_value;
    2370                 :            :             uint64_t new_version;
    2371                 :            :             if (DK_IS_UNICODE(dict->ma_keys)) {
    2372                 :            :                 PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint;
    2373                 :            :                 DEOPT_IF(ep->me_key != name, STORE_ATTR);
    2374                 :            :                 old_value = ep->me_value;
    2375                 :            :                 DEOPT_IF(old_value == NULL, STORE_ATTR);
    2376                 :            :                 new_version = _PyDict_NotifyEvent(tstate->interp, PyDict_EVENT_MODIFIED, dict, name, value);
    2377                 :            :                 ep->me_value = value;
    2378                 :            :             }
    2379                 :            :             else {
    2380                 :            :                 PyDictKeyEntry *ep = DK_ENTRIES(dict->ma_keys) + hint;
    2381                 :            :                 DEOPT_IF(ep->me_key != name, STORE_ATTR);
    2382                 :            :                 old_value = ep->me_value;
    2383                 :            :                 DEOPT_IF(old_value == NULL, STORE_ATTR);
    2384                 :            :                 new_version = _PyDict_NotifyEvent(tstate->interp, PyDict_EVENT_MODIFIED, dict, name, value);
    2385                 :            :                 ep->me_value = value;
    2386                 :            :             }
    2387                 :            :             Py_DECREF(old_value);
    2388                 :            :             STAT_INC(STORE_ATTR, hit);
    2389                 :            :             /* Ensure dict is GC tracked if it needs to be */
    2390                 :            :             if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(value)) {
    2391                 :            :                 _PyObject_GC_TRACK(dict);
    2392                 :            :             }
    2393                 :            :             /* PEP 509 */
    2394                 :            :             dict->ma_version_tag = new_version;
    2395                 :            :             Py_DECREF(owner);
    2396                 :            :             #line 2397 "Python/generated_cases.c.h"
    2397                 :          0 :             STACK_SHRINK(2);
    2398                 :          0 :             next_instr += 4;
    2399                 :          0 :             DISPATCH();
    2400                 :            :         }
    2401                 :            : 
    2402                 :     266076 :         TARGET(STORE_ATTR_SLOT) {
    2403                 :     266076 :             PyObject *owner = stack_pointer[-1];
    2404                 :     266076 :             PyObject *value = stack_pointer[-2];
    2405                 :     266076 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    2406                 :     266076 :             uint16_t index = read_u16(&next_instr[3].cache);
    2407                 :            :             #line 1680 "Python/bytecodes.c"
    2408                 :            :             assert(cframe.use_tracing == 0);
    2409                 :            :             PyTypeObject *tp = Py_TYPE(owner);
    2410                 :            :             assert(type_version != 0);
    2411                 :            :             DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
    2412                 :            :             char *addr = (char *)owner + index;
    2413                 :            :             STAT_INC(STORE_ATTR, hit);
    2414                 :            :             PyObject *old_value = *(PyObject **)addr;
    2415                 :            :             *(PyObject **)addr = value;
    2416                 :            :             Py_XDECREF(old_value);
    2417                 :            :             Py_DECREF(owner);
    2418                 :            :             #line 2419 "Python/generated_cases.c.h"
    2419                 :     266015 :             STACK_SHRINK(2);
    2420                 :     266015 :             next_instr += 4;
    2421                 :     266015 :             DISPATCH();
    2422                 :            :         }
    2423                 :            : 
    2424                 :     163293 :         TARGET(COMPARE_OP) {
    2425                 :     163293 :             PyObject *right = stack_pointer[-1];
    2426                 :     163293 :             PyObject *left = stack_pointer[-2];
    2427                 :            :             PyObject *res;
    2428                 :            :             #line 1693 "Python/bytecodes.c"
    2429                 :            :             STAT_INC(COMPARE_OP, deferred);
    2430                 :            :             assert((oparg >> 4) <= Py_GE);
    2431                 :            :             res = PyObject_RichCompare(left, right, oparg>>4);
    2432                 :            :             #line 2433 "Python/generated_cases.c.h"
    2433         [ +  + ]:     163293 :             Py_DECREF(left);
    2434         [ +  + ]:     163293 :             Py_DECREF(right);
    2435                 :            :             #line 1697 "Python/bytecodes.c"
    2436                 :            :             if (res == NULL) goto pop_2_error;
    2437                 :            :             #line 2438 "Python/generated_cases.c.h"
    2438                 :     163293 :             STACK_SHRINK(1);
    2439                 :     163293 :             stack_pointer[-1] = res;
    2440                 :     163293 :             next_instr += 1;
    2441                 :     163293 :             DISPATCH();
    2442                 :            :         }
    2443                 :            : 
    2444                 :     110231 :         TARGET(COMPARE_AND_BRANCH) {
    2445                 :     143382 :             PREDICTED(COMPARE_AND_BRANCH);
    2446                 :     143382 :             PyObject *right = stack_pointer[-1];
    2447         [ +  + ]:     143382 :             PyObject *left = stack_pointer[-2];
    2448                 :            :             #line 1709 "Python/bytecodes.c"
    2449                 :            :             #if ENABLE_SPECIALIZATION
    2450                 :            :             _PyCompareOpCache *cache = (_PyCompareOpCache *)next_instr;
    2451                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
    2452                 :            :                 assert(cframe.use_tracing == 0);
    2453                 :            :                 next_instr--;
    2454                 :            :                 _Py_Specialize_CompareAndBranch(left, right, next_instr, oparg);
    2455                 :            :                 DISPATCH_SAME_OPARG();
    2456                 :            :             }
    2457                 :            :             STAT_INC(COMPARE_AND_BRANCH, deferred);
    2458                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
    2459                 :            :             #endif  /* ENABLE_SPECIALIZATION */
    2460                 :            :             assert((oparg >> 4) <= Py_GE);
    2461                 :            :             PyObject *cond = PyObject_RichCompare(left, right, oparg>>4);
    2462                 :            :             #line 2463 "Python/generated_cases.c.h"
    2463         [ +  + ]:     139548 :             Py_DECREF(left);
    2464         [ +  + ]:     139548 :             Py_DECREF(right);
    2465                 :            :             #line 1723 "Python/bytecodes.c"
    2466                 :            :             if (cond == NULL) goto pop_2_error;
    2467                 :            :             assert(next_instr[1].op.code == POP_JUMP_IF_FALSE ||
    2468                 :            :                    next_instr[1].op.code == POP_JUMP_IF_TRUE);
    2469                 :            :             bool jump_on_true = next_instr[1].op.code == POP_JUMP_IF_TRUE;
    2470                 :            :             int offset = next_instr[1].op.arg;
    2471                 :            :             int err = PyObject_IsTrue(cond);
    2472                 :            :             Py_DECREF(cond);
    2473                 :            :             if (err < 0) goto pop_2_error;
    2474                 :            :             if (jump_on_true == (err != 0)) {
    2475                 :            :                 JUMPBY(offset);
    2476                 :            :             }
    2477                 :            :             #line 2478 "Python/generated_cases.c.h"
    2478                 :     139548 :             STACK_SHRINK(2);
    2479                 :     139548 :             next_instr += 2;
    2480                 :     139548 :             DISPATCH();
    2481                 :            :         }
    2482                 :            : 
    2483                 :      92283 :         TARGET(COMPARE_AND_BRANCH_FLOAT) {
    2484                 :      92283 :             PyObject *right = stack_pointer[-1];
    2485         [ +  + ]:      92283 :             PyObject *left = stack_pointer[-2];
    2486                 :            :             #line 1737 "Python/bytecodes.c"
    2487                 :            :             assert(cframe.use_tracing == 0);
    2488                 :            :             DEOPT_IF(!PyFloat_CheckExact(left), COMPARE_AND_BRANCH);
    2489                 :            :             DEOPT_IF(!PyFloat_CheckExact(right), COMPARE_AND_BRANCH);
    2490                 :            :             STAT_INC(COMPARE_AND_BRANCH, hit);
    2491                 :            :             double dleft = PyFloat_AS_DOUBLE(left);
    2492                 :            :             double dright = PyFloat_AS_DOUBLE(right);
    2493                 :            :             // 1 if NaN, 2 if <, 4 if >, 8 if ==; this matches low four bits of the oparg
    2494                 :            :             int sign_ish = COMPARISON_BIT(dleft, dright);
    2495                 :            :             _Py_DECREF_SPECIALIZED(left, _PyFloat_ExactDealloc);
    2496                 :            :             _Py_DECREF_SPECIALIZED(right, _PyFloat_ExactDealloc);
    2497                 :            :             if (sign_ish & oparg) {
    2498                 :            :                 int offset = next_instr[1].op.arg;
    2499                 :            :                 JUMPBY(offset);
    2500                 :            :             }
    2501                 :            :             #line 2502 "Python/generated_cases.c.h"
    2502                 :      91957 :             STACK_SHRINK(2);
    2503                 :      91957 :             next_instr += 2;
    2504                 :      91957 :             DISPATCH();
    2505                 :            :         }
    2506                 :            : 
    2507                 :    2025806 :         TARGET(COMPARE_AND_BRANCH_INT) {
    2508                 :    2025806 :             PyObject *right = stack_pointer[-1];
    2509         [ -  + ]:    2025806 :             PyObject *left = stack_pointer[-2];
    2510                 :            :             #line 1755 "Python/bytecodes.c"
    2511                 :            :             assert(cframe.use_tracing == 0);
    2512                 :            :             DEOPT_IF(!PyLong_CheckExact(left), COMPARE_AND_BRANCH);
    2513                 :            :             DEOPT_IF(!PyLong_CheckExact(right), COMPARE_AND_BRANCH);
    2514                 :            :             DEOPT_IF((size_t)(Py_SIZE(left) + 1) > 2, COMPARE_AND_BRANCH);
    2515                 :            :             DEOPT_IF((size_t)(Py_SIZE(right) + 1) > 2, COMPARE_AND_BRANCH);
    2516                 :            :             STAT_INC(COMPARE_AND_BRANCH, hit);
    2517                 :            :             assert(Py_ABS(Py_SIZE(left)) <= 1 && Py_ABS(Py_SIZE(right)) <= 1);
    2518                 :            :             Py_ssize_t ileft = Py_SIZE(left) * ((PyLongObject *)left)->long_value.ob_digit[0];
    2519                 :            :             Py_ssize_t iright = Py_SIZE(right) * ((PyLongObject *)right)->long_value.ob_digit[0];
    2520                 :            :             // 2 if <, 4 if >, 8 if ==; this matches the low 4 bits of the oparg
    2521                 :            :             int sign_ish = COMPARISON_BIT(ileft, iright);
    2522                 :            :             _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
    2523                 :            :             _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
    2524                 :            :             if (sign_ish & oparg) {
    2525                 :            :                 int offset = next_instr[1].op.arg;
    2526                 :            :                 JUMPBY(offset);
    2527                 :            :             }
    2528                 :            :             #line 2529 "Python/generated_cases.c.h"
    2529                 :    1993163 :             STACK_SHRINK(2);
    2530                 :    1993163 :             next_instr += 2;
    2531                 :    1993163 :             DISPATCH();
    2532                 :            :         }
    2533                 :            : 
    2534                 :      34573 :         TARGET(COMPARE_AND_BRANCH_STR) {
    2535                 :      34573 :             PyObject *right = stack_pointer[-1];
    2536         [ +  + ]:      34573 :             PyObject *left = stack_pointer[-2];
    2537                 :            :             #line 1776 "Python/bytecodes.c"
    2538                 :            :             assert(cframe.use_tracing == 0);
    2539                 :            :             DEOPT_IF(!PyUnicode_CheckExact(left), COMPARE_AND_BRANCH);
    2540                 :            :             DEOPT_IF(!PyUnicode_CheckExact(right), COMPARE_AND_BRANCH);
    2541                 :            :             STAT_INC(COMPARE_AND_BRANCH, hit);
    2542                 :            :             int res = _PyUnicode_Equal(left, right);
    2543                 :            :             assert((oparg >>4) == Py_EQ || (oparg >>4) == Py_NE);
    2544                 :            :             _Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc);
    2545                 :            :             _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
    2546                 :            :             assert(res == 0 || res == 1);
    2547                 :            :             assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS);
    2548                 :            :             assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS);
    2549                 :            :             if ((res + COMPARISON_NOT_EQUALS) & oparg) {
    2550                 :            :                 int offset = next_instr[1].op.arg;
    2551                 :            :                 JUMPBY(offset);
    2552                 :            :             }
    2553                 :            :             #line 2554 "Python/generated_cases.c.h"
    2554                 :      34391 :             STACK_SHRINK(2);
    2555                 :      34391 :             next_instr += 2;
    2556                 :      34391 :             DISPATCH();
    2557                 :            :         }
    2558                 :            : 
    2559                 :     242056 :         TARGET(IS_OP) {
    2560                 :     242056 :             PyObject *right = stack_pointer[-1];
    2561         [ +  + ]:     242056 :             PyObject *left = stack_pointer[-2];
    2562                 :            :             PyObject *b;
    2563                 :            :             #line 1794 "Python/bytecodes.c"
    2564                 :            :             int res = Py_Is(left, right) ^ oparg;
    2565                 :            :             #line 2566 "Python/generated_cases.c.h"
    2566         [ +  + ]:     242056 :             Py_DECREF(left);
    2567         [ -  + ]:     242056 :             Py_DECREF(right);
    2568                 :            :             #line 1796 "Python/bytecodes.c"
    2569                 :            :             b = Py_NewRef(res ? Py_True : Py_False);
    2570                 :            :             #line 2571 "Python/generated_cases.c.h"
    2571                 :     242056 :             STACK_SHRINK(1);
    2572                 :     242056 :             stack_pointer[-1] = b;
    2573                 :     242056 :             DISPATCH();
    2574                 :            :         }
    2575                 :            : 
    2576                 :      66972 :         TARGET(CONTAINS_OP) {
    2577                 :      66972 :             PyObject *right = stack_pointer[-1];
    2578                 :      66972 :             PyObject *left = stack_pointer[-2];
    2579                 :            :             PyObject *b;
    2580                 :            :             #line 1800 "Python/bytecodes.c"
    2581                 :            :             int res = PySequence_Contains(right, left);
    2582                 :            :             #line 2583 "Python/generated_cases.c.h"
    2583         [ +  + ]:      66972 :             Py_DECREF(left);
    2584         [ +  + ]:      66972 :             Py_DECREF(right);
    2585                 :            :             #line 1802 "Python/bytecodes.c"
    2586                 :            :             if (res < 0) goto pop_2_error;
    2587                 :            :             b = Py_NewRef((res^oparg) ? Py_True : Py_False);
    2588                 :            :             #line 2589 "Python/generated_cases.c.h"
    2589                 :      66972 :             STACK_SHRINK(1);
    2590                 :      66972 :             stack_pointer[-1] = b;
    2591                 :      66972 :             DISPATCH();
    2592                 :            :         }
    2593                 :            : 
    2594                 :          0 :         TARGET(CHECK_EG_MATCH) {
    2595                 :          0 :             PyObject *match_type = stack_pointer[-1];
    2596                 :          0 :             PyObject *exc_value = stack_pointer[-2];
    2597                 :            :             PyObject *rest;
    2598                 :            :             PyObject *match;
    2599                 :            :             #line 1807 "Python/bytecodes.c"
    2600                 :            :             if (check_except_star_type_valid(tstate, match_type) < 0) {
    2601                 :            :             #line 2602 "Python/generated_cases.c.h"
    2602         [ #  # ]:          0 :                 Py_DECREF(exc_value);
    2603         [ #  # ]:          0 :                 Py_DECREF(match_type);
    2604                 :            :             #line 1809 "Python/bytecodes.c"
    2605                 :            :                 if (true) goto pop_2_error;
    2606                 :            :             }
    2607                 :            : 
    2608                 :            :             match = NULL;
    2609                 :            :             rest = NULL;
    2610                 :            :             int res = exception_group_match(exc_value, match_type,
    2611                 :            :                                             &match, &rest);
    2612                 :            :             #line 2613 "Python/generated_cases.c.h"
    2613         [ #  # ]:          0 :             Py_DECREF(exc_value);
    2614         [ #  # ]:          0 :             Py_DECREF(match_type);
    2615                 :            :             #line 1817 "Python/bytecodes.c"
    2616                 :            :             if (res < 0) goto pop_2_error;
    2617                 :            : 
    2618                 :            :             assert((match == NULL) == (rest == NULL));
    2619                 :            :             if (match == NULL) goto pop_2_error;
    2620                 :            : 
    2621                 :            :             if (!Py_IsNone(match)) {
    2622                 :            :                 PyErr_SetExcInfo(NULL, Py_NewRef(match), NULL);
    2623                 :            :             }
    2624                 :            :             #line 2625 "Python/generated_cases.c.h"
    2625                 :          0 :             stack_pointer[-1] = match;
    2626                 :          0 :             stack_pointer[-2] = rest;
    2627                 :          0 :             DISPATCH();
    2628                 :            :         }
    2629                 :            : 
    2630                 :     101696 :         TARGET(CHECK_EXC_MATCH) {
    2631                 :     101696 :             PyObject *right = stack_pointer[-1];
    2632                 :     101696 :             PyObject *left = stack_pointer[-2];
    2633                 :            :             PyObject *b;
    2634                 :            :             #line 1828 "Python/bytecodes.c"
    2635                 :            :             assert(PyExceptionInstance_Check(left));
    2636                 :            :             if (check_except_type_valid(tstate, right) < 0) {
    2637                 :            :             #line 2638 "Python/generated_cases.c.h"
    2638         [ #  # ]:          0 :                  Py_DECREF(right);
    2639                 :            :             #line 1831 "Python/bytecodes.c"
    2640                 :            :                  if (true) goto pop_1_error;
    2641                 :            :             }
    2642                 :            : 
    2643                 :            :             int res = PyErr_GivenExceptionMatches(left, right);
    2644                 :            :             #line 2645 "Python/generated_cases.c.h"
    2645         [ +  + ]:     101696 :             Py_DECREF(right);
    2646                 :            :             #line 1836 "Python/bytecodes.c"
    2647                 :            :             b = Py_NewRef(res ? Py_True : Py_False);
    2648                 :            :             #line 2649 "Python/generated_cases.c.h"
    2649                 :     101696 :             stack_pointer[-1] = b;
    2650                 :     101696 :             DISPATCH();
    2651                 :            :         }
    2652                 :            : 
    2653                 :       3157 :         TARGET(IMPORT_NAME) {
    2654                 :       3157 :             PyObject *fromlist = stack_pointer[-1];
    2655                 :       3157 :             PyObject *level = stack_pointer[-2];
    2656                 :            :             PyObject *res;
    2657                 :            :             #line 1840 "Python/bytecodes.c"
    2658                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    2659                 :            :             res = import_name(tstate, frame, name, fromlist, level);
    2660                 :            :             #line 2661 "Python/generated_cases.c.h"
    2661         [ -  + ]:       3157 :             Py_DECREF(level);
    2662         [ -  + ]:       3157 :             Py_DECREF(fromlist);
    2663                 :            :             #line 1843 "Python/bytecodes.c"
    2664                 :            :             if (res == NULL) goto pop_2_error;
    2665                 :            :             #line 2666 "Python/generated_cases.c.h"
    2666                 :       3113 :             STACK_SHRINK(1);
    2667                 :       3113 :             stack_pointer[-1] = res;
    2668                 :       3113 :             DISPATCH();
    2669                 :            :         }
    2670                 :            : 
    2671                 :       2022 :         TARGET(IMPORT_FROM) {
    2672                 :       2022 :             PyObject *from = stack_pointer[-1];
    2673                 :            :             PyObject *res;
    2674                 :            :             #line 1847 "Python/bytecodes.c"
    2675                 :            :             PyObject *name = GETITEM(frame->f_code->co_names, oparg);
    2676                 :            :             res = import_from(tstate, from, name);
    2677                 :            :             if (res == NULL) goto error;
    2678                 :            :             #line 2679 "Python/generated_cases.c.h"
    2679                 :       1994 :             STACK_GROW(1);
    2680                 :       1994 :             stack_pointer[-1] = res;
    2681                 :       1994 :             DISPATCH();
    2682                 :            :         }
    2683                 :            : 
    2684                 :     101239 :         TARGET(JUMP_FORWARD) {
    2685                 :            :             #line 1853 "Python/bytecodes.c"
    2686                 :            :             JUMPBY(oparg);
    2687                 :            :             #line 2688 "Python/generated_cases.c.h"
    2688                 :     101239 :             DISPATCH();
    2689                 :            :         }
    2690                 :            : 
    2691                 :    3172588 :         TARGET(JUMP_BACKWARD) {
    2692         [ +  + ]:    3172588 :             PREDICTED(JUMP_BACKWARD);
    2693                 :            :             #line 1857 "Python/bytecodes.c"
    2694                 :            :             assert(oparg < INSTR_OFFSET());
    2695                 :            :             JUMPBY(-oparg);
    2696                 :            :             #line 2697 "Python/generated_cases.c.h"
    2697         [ +  + ]:    3172588 :             CHECK_EVAL_BREAKER();
    2698                 :    3172587 :             DISPATCH();
    2699                 :            :         }
    2700                 :            : 
    2701                 :    1257996 :         TARGET(POP_JUMP_IF_FALSE) {
    2702                 :    1257996 :             PREDICTED(POP_JUMP_IF_FALSE);
    2703         [ +  + ]:    1257996 :             PyObject *cond = stack_pointer[-1];
    2704                 :            :             #line 1863 "Python/bytecodes.c"
    2705                 :            :             if (Py_IsTrue(cond)) {
    2706                 :            :                 _Py_DECREF_NO_DEALLOC(cond);
    2707                 :            :             }
    2708                 :            :             else if (Py_IsFalse(cond)) {
    2709                 :            :                 _Py_DECREF_NO_DEALLOC(cond);
    2710                 :            :                 JUMPBY(oparg);
    2711                 :            :             }
    2712                 :            :             else {
    2713                 :            :                 int err = PyObject_IsTrue(cond);
    2714                 :            :             #line 2715 "Python/generated_cases.c.h"
    2715         [ +  + ]:      77359 :                 Py_DECREF(cond);
    2716                 :            :             #line 1873 "Python/bytecodes.c"
    2717                 :            :                 if (err == 0) {
    2718                 :            :                     JUMPBY(oparg);
    2719                 :            :                 }
    2720                 :            :                 else {
    2721                 :            :                     if (err < 0) goto pop_1_error;
    2722                 :            :                 }
    2723                 :            :             }
    2724                 :            :             #line 2725 "Python/generated_cases.c.h"
    2725                 :    1257996 :             STACK_SHRINK(1);
    2726                 :    1257996 :             DISPATCH();
    2727                 :            :         }
    2728                 :            : 
    2729                 :     667438 :         TARGET(POP_JUMP_IF_TRUE) {
    2730         [ +  + ]:     667438 :             PyObject *cond = stack_pointer[-1];
    2731                 :            :             #line 1883 "Python/bytecodes.c"
    2732                 :            :             if (Py_IsFalse(cond)) {
    2733                 :            :                 _Py_DECREF_NO_DEALLOC(cond);
    2734                 :            :             }
    2735                 :            :             else if (Py_IsTrue(cond)) {
    2736                 :            :                 _Py_DECREF_NO_DEALLOC(cond);
    2737                 :            :                 JUMPBY(oparg);
    2738                 :            :             }
    2739                 :            :             else {
    2740                 :            :                 int err = PyObject_IsTrue(cond);
    2741                 :            :             #line 2742 "Python/generated_cases.c.h"
    2742         [ +  + ]:     532230 :                 Py_DECREF(cond);
    2743                 :            :             #line 1893 "Python/bytecodes.c"
    2744                 :            :                 if (err > 0) {
    2745                 :            :                     JUMPBY(oparg);
    2746                 :            :                 }
    2747                 :            :                 else {
    2748                 :            :                     if (err < 0) goto pop_1_error;
    2749                 :            :                 }
    2750                 :            :             }
    2751                 :            :             #line 2752 "Python/generated_cases.c.h"
    2752                 :     667438 :             STACK_SHRINK(1);
    2753                 :     667438 :             DISPATCH();
    2754                 :            :         }
    2755                 :            : 
    2756                 :     513172 :         TARGET(POP_JUMP_IF_NOT_NONE) {
    2757         [ +  + ]:     513172 :             PyObject *value = stack_pointer[-1];
    2758                 :            :             #line 1903 "Python/bytecodes.c"
    2759                 :            :             if (!Py_IsNone(value)) {
    2760                 :            :             #line 2761 "Python/generated_cases.c.h"
    2761         [ +  + ]:     146583 :                 Py_DECREF(value);
    2762                 :            :             #line 1905 "Python/bytecodes.c"
    2763                 :            :                 JUMPBY(oparg);
    2764                 :            :             }
    2765                 :            :             else {
    2766                 :            :                 _Py_DECREF_NO_DEALLOC(value);
    2767                 :            :             }
    2768                 :            :             #line 2769 "Python/generated_cases.c.h"
    2769                 :     513172 :             STACK_SHRINK(1);
    2770                 :     513172 :             DISPATCH();
    2771                 :            :         }
    2772                 :            : 
    2773                 :     186654 :         TARGET(POP_JUMP_IF_NONE) {
    2774         [ +  + ]:     186654 :             PyObject *value = stack_pointer[-1];
    2775                 :            :             #line 1913 "Python/bytecodes.c"
    2776                 :            :             if (Py_IsNone(value)) {
    2777                 :            :                 _Py_DECREF_NO_DEALLOC(value);
    2778                 :            :                 JUMPBY(oparg);
    2779                 :            :             }
    2780                 :            :             else {
    2781                 :            :             #line 2782 "Python/generated_cases.c.h"
    2782         [ -  + ]:      23894 :                 Py_DECREF(value);
    2783                 :            :             #line 1919 "Python/bytecodes.c"
    2784                 :            :             }
    2785                 :            :             #line 2786 "Python/generated_cases.c.h"
    2786                 :     186654 :             STACK_SHRINK(1);
    2787                 :     186654 :             DISPATCH();
    2788                 :            :         }
    2789                 :            : 
    2790                 :      99575 :         TARGET(JUMP_IF_FALSE_OR_POP) {
    2791         [ +  + ]:      99575 :             PyObject *cond = stack_pointer[-1];
    2792                 :            :             #line 1923 "Python/bytecodes.c"
    2793                 :            :             bool jump = false;
    2794                 :            :             int err;
    2795                 :            :             if (Py_IsTrue(cond)) {
    2796                 :            :                 _Py_DECREF_NO_DEALLOC(cond);
    2797                 :            :             }
    2798                 :            :             else if (Py_IsFalse(cond)) {
    2799                 :            :                 JUMPBY(oparg);
    2800                 :            :                 jump = true;
    2801                 :            :             }
    2802                 :            :             else {
    2803                 :            :                 err = PyObject_IsTrue(cond);
    2804                 :            :                 if (err > 0) {
    2805                 :            :                     Py_DECREF(cond);
    2806                 :            :                 }
    2807                 :            :                 else if (err == 0) {
    2808                 :            :                     JUMPBY(oparg);
    2809                 :            :                     jump = true;
    2810                 :            :                 }
    2811                 :            :                 else {
    2812                 :            :                     goto error;
    2813                 :            :                 }
    2814                 :            :             }
    2815                 :            :             #line 2816 "Python/generated_cases.c.h"
    2816                 :      99575 :             STACK_SHRINK(1);
    2817         [ +  + ]:      99575 :             STACK_GROW((jump ? 1 : 0));
    2818                 :      99575 :             DISPATCH();
    2819                 :            :         }
    2820                 :            : 
    2821                 :      18928 :         TARGET(JUMP_IF_TRUE_OR_POP) {
    2822         [ +  + ]:      18928 :             PyObject *cond = stack_pointer[-1];
    2823                 :            :             #line 1948 "Python/bytecodes.c"
    2824                 :            :             bool jump = false;
    2825                 :            :             int err;
    2826                 :            :             if (Py_IsFalse(cond)) {
    2827                 :            :                 _Py_DECREF_NO_DEALLOC(cond);
    2828                 :            :             }
    2829                 :            :             else if (Py_IsTrue(cond)) {
    2830                 :            :                 JUMPBY(oparg);
    2831                 :            :                 jump = true;
    2832                 :            :             }
    2833                 :            :             else {
    2834                 :            :                 err = PyObject_IsTrue(cond);
    2835                 :            :                 if (err > 0) {
    2836                 :            :                     JUMPBY(oparg);
    2837                 :            :                     jump = true;
    2838                 :            :                 }
    2839                 :            :                 else if (err == 0) {
    2840                 :            :                     Py_DECREF(cond);
    2841                 :            :                 }
    2842                 :            :                 else {
    2843                 :            :                     goto error;
    2844                 :            :                 }
    2845                 :            :             }
    2846                 :            :             #line 2847 "Python/generated_cases.c.h"
    2847                 :      18928 :             STACK_SHRINK(1);
    2848         [ +  + ]:      18928 :             STACK_GROW((jump ? 1 : 0));
    2849                 :      18928 :             DISPATCH();
    2850                 :            :         }
    2851                 :            : 
    2852                 :        339 :         TARGET(JUMP_BACKWARD_NO_INTERRUPT) {
    2853                 :            :             #line 1973 "Python/bytecodes.c"
    2854                 :            :             /* This bytecode is used in the `yield from` or `await` loop.
    2855                 :            :              * If there is an interrupt, we want it handled in the innermost
    2856                 :            :              * generator or coroutine, so we deliberately do not check it here.
    2857                 :            :              * (see bpo-30039).
    2858                 :            :              */
    2859                 :            :             JUMPBY(-oparg);
    2860                 :            :             #line 2861 "Python/generated_cases.c.h"
    2861                 :        339 :             DISPATCH();
    2862                 :            :         }
    2863                 :            : 
    2864                 :        408 :         TARGET(GET_LEN) {
    2865                 :        408 :             PyObject *obj = stack_pointer[-1];
    2866                 :            :             PyObject *len_o;
    2867                 :            :             #line 1982 "Python/bytecodes.c"
    2868                 :            :             // PUSH(len(TOS))
    2869                 :            :             Py_ssize_t len_i = PyObject_Length(obj);
    2870                 :            :             if (len_i < 0) goto error;
    2871                 :            :             len_o = PyLong_FromSsize_t(len_i);
    2872                 :            :             if (len_o == NULL) goto error;
    2873                 :            :             #line 2874 "Python/generated_cases.c.h"
    2874                 :        408 :             STACK_GROW(1);
    2875                 :        408 :             stack_pointer[-1] = len_o;
    2876                 :        408 :             DISPATCH();
    2877                 :            :         }
    2878                 :            : 
    2879                 :         26 :         TARGET(MATCH_CLASS) {
    2880                 :         26 :             PyObject *names = stack_pointer[-1];
    2881                 :         26 :             PyObject *type = stack_pointer[-2];
    2882                 :         26 :             PyObject *subject = stack_pointer[-3];
    2883                 :            :             PyObject *attrs;
    2884                 :            :             #line 1990 "Python/bytecodes.c"
    2885                 :            :             // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or
    2886                 :            :             // None on failure.
    2887                 :            :             assert(PyTuple_CheckExact(names));
    2888                 :            :             attrs = match_class(tstate, subject, type, oparg, names);
    2889                 :            :             #line 2890 "Python/generated_cases.c.h"
    2890         [ -  + ]:         26 :             Py_DECREF(subject);
    2891         [ -  + ]:         26 :             Py_DECREF(type);
    2892         [ -  + ]:         26 :             Py_DECREF(names);
    2893                 :            :             #line 1995 "Python/bytecodes.c"
    2894                 :            :             if (attrs) {
    2895                 :            :                 assert(PyTuple_CheckExact(attrs));  // Success!
    2896                 :            :             }
    2897                 :            :             else {
    2898                 :            :                 if (_PyErr_Occurred(tstate)) goto pop_3_error;
    2899                 :            :                 attrs = Py_NewRef(Py_None);  // Failure!
    2900                 :            :             }
    2901                 :            :             #line 2902 "Python/generated_cases.c.h"
    2902                 :         26 :             STACK_SHRINK(2);
    2903                 :         26 :             stack_pointer[-1] = attrs;
    2904                 :         26 :             DISPATCH();
    2905                 :            :         }
    2906                 :            : 
    2907                 :          0 :         TARGET(MATCH_MAPPING) {
    2908                 :          0 :             PyObject *subject = stack_pointer[-1];
    2909                 :            :             PyObject *res;
    2910                 :            :             #line 2005 "Python/bytecodes.c"
    2911                 :            :             int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING;
    2912                 :            :             res = Py_NewRef(match ? Py_True : Py_False);
    2913                 :            :             #line 2914 "Python/generated_cases.c.h"
    2914                 :          0 :             STACK_GROW(1);
    2915                 :          0 :             stack_pointer[-1] = res;
    2916                 :            :             PREDICT(POP_JUMP_IF_FALSE);
    2917                 :          0 :             DISPATCH();
    2918                 :            :         }
    2919                 :            : 
    2920                 :        509 :         TARGET(MATCH_SEQUENCE) {
    2921                 :        509 :             PyObject *subject = stack_pointer[-1];
    2922                 :            :             PyObject *res;
    2923                 :            :             #line 2011 "Python/bytecodes.c"
    2924                 :            :             int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE;
    2925                 :            :             res = Py_NewRef(match ? Py_True : Py_False);
    2926                 :            :             #line 2927 "Python/generated_cases.c.h"
    2927                 :        509 :             STACK_GROW(1);
    2928                 :        509 :             stack_pointer[-1] = res;
    2929                 :            :             PREDICT(POP_JUMP_IF_FALSE);
    2930                 :        509 :             DISPATCH();
    2931                 :            :         }
    2932                 :            : 
    2933                 :          0 :         TARGET(MATCH_KEYS) {
    2934                 :          0 :             PyObject *keys = stack_pointer[-1];
    2935                 :          0 :             PyObject *subject = stack_pointer[-2];
    2936                 :            :             PyObject *values_or_none;
    2937                 :            :             #line 2017 "Python/bytecodes.c"
    2938                 :            :             // On successful match, PUSH(values). Otherwise, PUSH(None).
    2939                 :            :             values_or_none = match_keys(tstate, subject, keys);
    2940                 :            :             if (values_or_none == NULL) goto error;
    2941                 :            :             #line 2942 "Python/generated_cases.c.h"
    2942                 :          0 :             STACK_GROW(1);
    2943                 :          0 :             stack_pointer[-1] = values_or_none;
    2944                 :          0 :             DISPATCH();
    2945                 :            :         }
    2946                 :            : 
    2947                 :    1629120 :         TARGET(GET_ITER) {
    2948                 :    1629120 :             PyObject *iterable = stack_pointer[-1];
    2949                 :            :             PyObject *iter;
    2950                 :            :             #line 2023 "Python/bytecodes.c"
    2951                 :            :             /* before: [obj]; after [getiter(obj)] */
    2952                 :            :             iter = PyObject_GetIter(iterable);
    2953                 :            :             #line 2954 "Python/generated_cases.c.h"
    2954         [ +  + ]:    1629120 :             Py_DECREF(iterable);
    2955                 :            :             #line 2026 "Python/bytecodes.c"
    2956                 :            :             if (iter == NULL) goto pop_1_error;
    2957                 :            :             #line 2958 "Python/generated_cases.c.h"
    2958                 :    1629120 :             stack_pointer[-1] = iter;
    2959                 :    1629120 :             DISPATCH();
    2960                 :            :         }
    2961                 :            : 
    2962                 :         38 :         TARGET(GET_YIELD_FROM_ITER) {
    2963         [ -  + ]:         38 :             PyObject *iterable = stack_pointer[-1];
    2964                 :            :             PyObject *iter;
    2965                 :            :             #line 2030 "Python/bytecodes.c"
    2966                 :            :             /* before: [obj]; after [getiter(obj)] */
    2967                 :            :             if (PyCoro_CheckExact(iterable)) {
    2968                 :            :                 /* `iterable` is a coroutine */
    2969                 :            :                 if (!(frame->f_code->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
    2970                 :            :                     /* and it is used in a 'yield from' expression of a
    2971                 :            :                        regular generator. */
    2972                 :            :                     _PyErr_SetString(tstate, PyExc_TypeError,
    2973                 :            :                                      "cannot 'yield from' a coroutine object "
    2974                 :            :                                      "in a non-coroutine generator");
    2975                 :            :                     goto error;
    2976                 :            :                 }
    2977                 :            :                 iter = iterable;
    2978                 :            :             }
    2979                 :            :             else if (PyGen_CheckExact(iterable)) {
    2980                 :            :                 iter = iterable;
    2981                 :            :             }
    2982                 :            :             else {
    2983                 :            :                 /* `iterable` is not a generator. */
    2984                 :            :                 iter = PyObject_GetIter(iterable);
    2985                 :            :                 if (iter == NULL) {
    2986                 :            :                     goto error;
    2987                 :            :                 }
    2988                 :            :             #line 2989 "Python/generated_cases.c.h"
    2989         [ -  + ]:         11 :                 Py_DECREF(iterable);
    2990                 :            :             #line 2053 "Python/bytecodes.c"
    2991                 :            :             }
    2992                 :            :             #line 2993 "Python/generated_cases.c.h"
    2993                 :         38 :             stack_pointer[-1] = iter;
    2994                 :            :             PREDICT(LOAD_CONST);
    2995                 :         38 :             DISPATCH();
    2996                 :            :         }
    2997                 :            : 
    2998                 :    3536529 :         TARGET(FOR_ITER) {
    2999                 :    3537147 :             PREDICTED(FOR_ITER);
    3000                 :            :             static_assert(INLINE_CACHE_ENTRIES_FOR_ITER == 1, "incorrect cache size");
    3001         [ +  + ]:    3537147 :             PyObject *iter = stack_pointer[-1];
    3002                 :            :             PyObject *next;
    3003                 :            :             #line 2072 "Python/bytecodes.c"
    3004                 :            :             #if ENABLE_SPECIALIZATION
    3005                 :            :             _PyForIterCache *cache = (_PyForIterCache *)next_instr;
    3006                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
    3007                 :            :                 assert(cframe.use_tracing == 0);
    3008                 :            :                 next_instr--;
    3009                 :            :                 _Py_Specialize_ForIter(iter, next_instr, oparg);
    3010                 :            :                 DISPATCH_SAME_OPARG();
    3011                 :            :             }
    3012                 :            :             STAT_INC(FOR_ITER, deferred);
    3013                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
    3014                 :            :             #endif  /* ENABLE_SPECIALIZATION */
    3015                 :            :             /* before: [iter]; after: [iter, iter()] *or* [] (and jump over END_FOR.) */
    3016                 :            :             next = (*Py_TYPE(iter)->tp_iternext)(iter);
    3017                 :            :             if (next == NULL) {
    3018                 :            :                 if (_PyErr_Occurred(tstate)) {
    3019                 :            :                     if (!_PyErr_ExceptionMatches(tstate, PyExc_StopIteration)) {
    3020                 :            :                         goto error;
    3021                 :            :                     }
    3022                 :            :                     else if (tstate->c_tracefunc != NULL) {
    3023                 :            :                         call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, frame);
    3024                 :            :                     }
    3025                 :            :                     _PyErr_Clear(tstate);
    3026                 :            :                 }
    3027                 :            :                 /* iterator ended normally */
    3028                 :            :                 assert(next_instr[INLINE_CACHE_ENTRIES_FOR_ITER + oparg].op.code == END_FOR);
    3029                 :            :                 Py_DECREF(iter);
    3030                 :            :                 STACK_SHRINK(1);
    3031                 :            :                 /* Jump forward oparg, then skip following END_FOR instruction */
    3032                 :            :                 JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1);
    3033                 :            :                 DISPATCH();
    3034                 :            :             }
    3035                 :            :             // Common case: no jump, leave it to the code generator
    3036                 :            :             #line 3037 "Python/generated_cases.c.h"
    3037                 :    1935227 :             STACK_GROW(1);
    3038                 :    1935227 :             stack_pointer[-1] = next;
    3039                 :    1935227 :             next_instr += 1;
    3040                 :    1935227 :             DISPATCH();
    3041                 :            :         }
    3042                 :            : 
    3043                 :     586273 :         TARGET(FOR_ITER_LIST) {
    3044                 :     586273 :             PyObject *iter = stack_pointer[-1];
    3045                 :            :             PyObject *next;
    3046                 :            :             #line 2107 "Python/bytecodes.c"
    3047                 :            :             assert(cframe.use_tracing == 0);
    3048                 :            :             DEOPT_IF(Py_TYPE(iter) != &PyListIter_Type, FOR_ITER);
    3049                 :            :             _PyListIterObject *it = (_PyListIterObject *)iter;
    3050                 :            :             STAT_INC(FOR_ITER, hit);
    3051                 :            :             PyListObject *seq = it->it_seq;
    3052                 :            :             if (seq) {
    3053                 :            :                 if (it->it_index < PyList_GET_SIZE(seq)) {
    3054                 :            :                     next = Py_NewRef(PyList_GET_ITEM(seq, it->it_index++));
    3055                 :            :                     goto end_for_iter_list;  // End of this instruction
    3056                 :            :                 }
    3057                 :            :                 it->it_seq = NULL;
    3058                 :            :                 Py_DECREF(seq);
    3059                 :            :             }
    3060                 :            :             Py_DECREF(iter);
    3061                 :            :             STACK_SHRINK(1);
    3062                 :            :             /* Jump forward oparg, then skip following END_FOR instruction */
    3063                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1);
    3064                 :            :             DISPATCH();
    3065                 :            :         end_for_iter_list:
    3066                 :            :             // Common case: no jump, leave it to the code generator
    3067                 :            :             #line 3068 "Python/generated_cases.c.h"
    3068                 :     578555 :             STACK_GROW(1);
    3069                 :     578555 :             stack_pointer[-1] = next;
    3070                 :     578555 :             next_instr += 1;
    3071                 :     578555 :             DISPATCH();
    3072                 :            :         }
    3073                 :            : 
    3074                 :      31091 :         TARGET(FOR_ITER_TUPLE) {
    3075                 :      31091 :             PyObject *iter = stack_pointer[-1];
    3076                 :            :             PyObject *next;
    3077                 :            :             #line 2130 "Python/bytecodes.c"
    3078                 :            :             assert(cframe.use_tracing == 0);
    3079                 :            :             _PyTupleIterObject *it = (_PyTupleIterObject *)iter;
    3080                 :            :             DEOPT_IF(Py_TYPE(it) != &PyTupleIter_Type, FOR_ITER);
    3081                 :            :             STAT_INC(FOR_ITER, hit);
    3082                 :            :             PyTupleObject *seq = it->it_seq;
    3083                 :            :             if (seq) {
    3084                 :            :                 if (it->it_index < PyTuple_GET_SIZE(seq)) {
    3085                 :            :                     next = Py_NewRef(PyTuple_GET_ITEM(seq, it->it_index++));
    3086                 :            :                     goto end_for_iter_tuple;  // End of this instruction
    3087                 :            :                 }
    3088                 :            :                 it->it_seq = NULL;
    3089                 :            :                 Py_DECREF(seq);
    3090                 :            :             }
    3091                 :            :             Py_DECREF(iter);
    3092                 :            :             STACK_SHRINK(1);
    3093                 :            :             /* Jump forward oparg, then skip following END_FOR instruction */
    3094                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1);
    3095                 :            :             DISPATCH();
    3096                 :            :         end_for_iter_tuple:
    3097                 :            :             // Common case: no jump, leave it to the code generator
    3098                 :            :             #line 3099 "Python/generated_cases.c.h"
    3099                 :      21063 :             STACK_GROW(1);
    3100                 :      21063 :             stack_pointer[-1] = next;
    3101                 :      21063 :             next_instr += 1;
    3102                 :      21063 :             DISPATCH();
    3103                 :            :         }
    3104                 :            : 
    3105                 :     594262 :         TARGET(FOR_ITER_RANGE) {
    3106                 :     594262 :             PyObject *iter = stack_pointer[-1];
    3107                 :            :             PyObject *next;
    3108                 :            :             #line 2153 "Python/bytecodes.c"
    3109                 :            :             assert(cframe.use_tracing == 0);
    3110                 :            :             _PyRangeIterObject *r = (_PyRangeIterObject *)iter;
    3111                 :            :             DEOPT_IF(Py_TYPE(r) != &PyRangeIter_Type, FOR_ITER);
    3112                 :            :             STAT_INC(FOR_ITER, hit);
    3113                 :            :             if (r->len <= 0) {
    3114                 :            :                 STACK_SHRINK(1);
    3115                 :            :                 Py_DECREF(r);
    3116                 :            :                 // Jump over END_FOR instruction.
    3117                 :            :                 JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1);
    3118                 :            :                 DISPATCH();
    3119                 :            :             }
    3120                 :            :             long value = r->start;
    3121                 :            :             r->start = value + r->step;
    3122                 :            :             r->len--;
    3123                 :            :             next = PyLong_FromLong(value);
    3124                 :            :             if (next == NULL) {
    3125                 :            :                 goto error;
    3126                 :            :             }
    3127                 :            :             #line 3128 "Python/generated_cases.c.h"
    3128                 :     587220 :             STACK_GROW(1);
    3129                 :     587220 :             stack_pointer[-1] = next;
    3130                 :     587220 :             next_instr += 1;
    3131                 :     587220 :             DISPATCH();
    3132                 :            :         }
    3133                 :            : 
    3134                 :       5388 :         TARGET(FOR_ITER_GEN) {
    3135                 :       5388 :             PyObject *iter = stack_pointer[-1];
    3136                 :            :             #line 2174 "Python/bytecodes.c"
    3137                 :            :             assert(cframe.use_tracing == 0);
    3138                 :            :             PyGenObject *gen = (PyGenObject *)iter;
    3139                 :            :             DEOPT_IF(Py_TYPE(gen) != &PyGen_Type, FOR_ITER);
    3140                 :            :             DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING, FOR_ITER);
    3141                 :            :             STAT_INC(FOR_ITER, hit);
    3142                 :            :             _PyInterpreterFrame *gen_frame = (_PyInterpreterFrame *)gen->gi_iframe;
    3143                 :            :             frame->yield_offset = oparg;
    3144                 :            :             _PyFrame_StackPush(gen_frame, Py_NewRef(Py_None));
    3145                 :            :             gen->gi_frame_state = FRAME_EXECUTING;
    3146                 :            :             gen->gi_exc_state.previous_item = tstate->exc_info;
    3147                 :            :             tstate->exc_info = &gen->gi_exc_state;
    3148                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg);
    3149                 :            :             assert(next_instr->op.code == END_FOR);
    3150                 :            :             DISPATCH_INLINED(gen_frame);
    3151                 :            :             #line 3152 "Python/generated_cases.c.h"
    3152                 :            :         }
    3153                 :            : 
    3154                 :          0 :         TARGET(BEFORE_ASYNC_WITH) {
    3155                 :          0 :             PyObject *mgr = stack_pointer[-1];
    3156                 :            :             PyObject *exit;
    3157                 :            :             PyObject *res;
    3158                 :            :             #line 2191 "Python/bytecodes.c"
    3159                 :            :             PyObject *enter = _PyObject_LookupSpecial(mgr, &_Py_ID(__aenter__));
    3160                 :            :             if (enter == NULL) {
    3161                 :            :                 if (!_PyErr_Occurred(tstate)) {
    3162                 :            :                     _PyErr_Format(tstate, PyExc_TypeError,
    3163                 :            :                                   "'%.200s' object does not support the "
    3164                 :            :                                   "asynchronous context manager protocol",
    3165                 :            :                                   Py_TYPE(mgr)->tp_name);
    3166                 :            :                 }
    3167                 :            :                 goto error;
    3168                 :            :             }
    3169                 :            :             exit = _PyObject_LookupSpecial(mgr, &_Py_ID(__aexit__));
    3170                 :            :             if (exit == NULL) {
    3171                 :            :                 if (!_PyErr_Occurred(tstate)) {
    3172                 :            :                     _PyErr_Format(tstate, PyExc_TypeError,
    3173                 :            :                                   "'%.200s' object does not support the "
    3174                 :            :                                   "asynchronous context manager protocol "
    3175                 :            :                                   "(missed __aexit__ method)",
    3176                 :            :                                   Py_TYPE(mgr)->tp_name);
    3177                 :            :                 }
    3178                 :            :                 Py_DECREF(enter);
    3179                 :            :                 goto error;
    3180                 :            :             }
    3181                 :            :             #line 3182 "Python/generated_cases.c.h"
    3182         [ #  # ]:          0 :             Py_DECREF(mgr);
    3183                 :            :             #line 2214 "Python/bytecodes.c"
    3184                 :            :             res = _PyObject_CallNoArgs(enter);
    3185                 :            :             Py_DECREF(enter);
    3186                 :            :             if (res == NULL) {
    3187                 :            :                 Py_DECREF(exit);
    3188                 :            :                 if (true) goto pop_1_error;
    3189                 :            :             }
    3190                 :            :             #line 3191 "Python/generated_cases.c.h"
    3191                 :          0 :             STACK_GROW(1);
    3192                 :          0 :             stack_pointer[-1] = res;
    3193                 :          0 :             stack_pointer[-2] = exit;
    3194                 :            :             PREDICT(GET_AWAITABLE);
    3195                 :          0 :             DISPATCH();
    3196                 :            :         }
    3197                 :            : 
    3198                 :     106669 :         TARGET(BEFORE_WITH) {
    3199                 :     106669 :             PyObject *mgr = stack_pointer[-1];
    3200                 :            :             PyObject *exit;
    3201                 :            :             PyObject *res;
    3202                 :            :             #line 2224 "Python/bytecodes.c"
    3203                 :            :             /* pop the context manager, push its __exit__ and the
    3204                 :            :              * value returned from calling its __enter__
    3205                 :            :              */
    3206                 :            :             PyObject *enter = _PyObject_LookupSpecial(mgr, &_Py_ID(__enter__));
    3207                 :            :             if (enter == NULL) {
    3208                 :            :                 if (!_PyErr_Occurred(tstate)) {
    3209                 :            :                     _PyErr_Format(tstate, PyExc_TypeError,
    3210                 :            :                                   "'%.200s' object does not support the "
    3211                 :            :                                   "context manager protocol",
    3212                 :            :                                   Py_TYPE(mgr)->tp_name);
    3213                 :            :                 }
    3214                 :            :                 goto error;
    3215                 :            :             }
    3216                 :            :             exit = _PyObject_LookupSpecial(mgr, &_Py_ID(__exit__));
    3217                 :            :             if (exit == NULL) {
    3218                 :            :                 if (!_PyErr_Occurred(tstate)) {
    3219                 :            :                     _PyErr_Format(tstate, PyExc_TypeError,
    3220                 :            :                                   "'%.200s' object does not support the "
    3221                 :            :                                   "context manager protocol "
    3222                 :            :                                   "(missed __exit__ method)",
    3223                 :            :                                   Py_TYPE(mgr)->tp_name);
    3224                 :            :                 }
    3225                 :            :                 Py_DECREF(enter);
    3226                 :            :                 goto error;
    3227                 :            :             }
    3228                 :            :             #line 3229 "Python/generated_cases.c.h"
    3229         [ -  + ]:     106669 :             Py_DECREF(mgr);
    3230                 :            :             #line 2250 "Python/bytecodes.c"
    3231                 :            :             res = _PyObject_CallNoArgs(enter);
    3232                 :            :             Py_DECREF(enter);
    3233                 :            :             if (res == NULL) {
    3234                 :            :                 Py_DECREF(exit);
    3235                 :            :                 if (true) goto pop_1_error;
    3236                 :            :             }
    3237                 :            :             #line 3238 "Python/generated_cases.c.h"
    3238                 :     106669 :             STACK_GROW(1);
    3239                 :     106669 :             stack_pointer[-1] = res;
    3240                 :     106669 :             stack_pointer[-2] = exit;
    3241                 :     106669 :             DISPATCH();
    3242                 :            :         }
    3243                 :            : 
    3244                 :        293 :         TARGET(WITH_EXCEPT_START) {
    3245                 :        293 :             PyObject *val = stack_pointer[-1];
    3246                 :        293 :             PyObject *lasti = stack_pointer[-3];
    3247                 :        293 :             PyObject *exit_func = stack_pointer[-4];
    3248                 :            :             PyObject *res;
    3249                 :            :             #line 2259 "Python/bytecodes.c"
    3250                 :            :             /* At the top of the stack are 4 values:
    3251                 :            :                - val: TOP = exc_info()
    3252                 :            :                - unused: SECOND = previous exception
    3253                 :            :                - lasti: THIRD = lasti of exception in exc_info()
    3254                 :            :                - exit_func: FOURTH = the context.__exit__ bound method
    3255                 :            :                We call FOURTH(type(TOP), TOP, GetTraceback(TOP)).
    3256                 :            :                Then we push the __exit__ return value.
    3257                 :            :             */
    3258                 :            :             PyObject *exc, *tb;
    3259                 :            : 
    3260                 :            :             assert(val && PyExceptionInstance_Check(val));
    3261                 :            :             exc = PyExceptionInstance_Class(val);
    3262                 :            :             tb = PyException_GetTraceback(val);
    3263                 :            :             Py_XDECREF(tb);
    3264                 :            :             assert(PyLong_Check(lasti));
    3265                 :            :             (void)lasti; // Shut up compiler warning if asserts are off
    3266                 :            :             PyObject *stack[4] = {NULL, exc, val, tb};
    3267                 :            :             res = PyObject_Vectorcall(exit_func, stack + 1,
    3268                 :            :                     3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
    3269                 :            :             if (res == NULL) goto error;
    3270                 :            :             #line 3271 "Python/generated_cases.c.h"
    3271                 :        293 :             STACK_GROW(1);
    3272                 :        293 :             stack_pointer[-1] = res;
    3273                 :        293 :             DISPATCH();
    3274                 :            :         }
    3275                 :            : 
    3276                 :     101972 :         TARGET(PUSH_EXC_INFO) {
    3277         [ +  + ]:     101972 :             PyObject *new_exc = stack_pointer[-1];
    3278                 :            :             PyObject *prev_exc;
    3279                 :            :             #line 2282 "Python/bytecodes.c"
    3280                 :            :             _PyErr_StackItem *exc_info = tstate->exc_info;
    3281                 :            :             if (exc_info->exc_value != NULL) {
    3282                 :            :                 prev_exc = exc_info->exc_value;
    3283                 :            :             }
    3284                 :            :             else {
    3285                 :            :                 prev_exc = Py_NewRef(Py_None);
    3286                 :            :             }
    3287                 :            :             assert(PyExceptionInstance_Check(new_exc));
    3288                 :            :             exc_info->exc_value = Py_NewRef(new_exc);
    3289                 :            :             #line 3290 "Python/generated_cases.c.h"
    3290                 :     101972 :             STACK_GROW(1);
    3291                 :     101972 :             stack_pointer[-1] = new_exc;
    3292                 :     101972 :             stack_pointer[-2] = prev_exc;
    3293                 :     101972 :             DISPATCH();
    3294                 :            :         }
    3295                 :            : 
    3296                 :     894487 :         TARGET(LOAD_ATTR_METHOD_WITH_VALUES) {
    3297                 :     894487 :             PyObject *self = stack_pointer[-1];
    3298                 :     894487 :             PyObject *res2 = NULL;
    3299                 :            :             PyObject *res;
    3300                 :     894487 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    3301                 :     894487 :             uint32_t keys_version = read_u32(&next_instr[3].cache);
    3302                 :     894487 :             PyObject *descr = read_obj(&next_instr[5].cache);
    3303                 :            :             #line 2294 "Python/bytecodes.c"
    3304                 :            :             /* Cached method object */
    3305                 :            :             assert(cframe.use_tracing == 0);
    3306                 :            :             PyTypeObject *self_cls = Py_TYPE(self);
    3307                 :            :             assert(type_version != 0);
    3308                 :            :             DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
    3309                 :            :             assert(self_cls->tp_flags & Py_TPFLAGS_MANAGED_DICT);
    3310                 :            :             PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(self);
    3311                 :            :             DEOPT_IF(!_PyDictOrValues_IsValues(dorv), LOAD_ATTR);
    3312                 :            :             PyHeapTypeObject *self_heap_type = (PyHeapTypeObject *)self_cls;
    3313                 :            :             DEOPT_IF(self_heap_type->ht_cached_keys->dk_version !=
    3314                 :            :                      keys_version, LOAD_ATTR);
    3315                 :            :             STAT_INC(LOAD_ATTR, hit);
    3316                 :            :             assert(descr != NULL);
    3317                 :            :             res2 = Py_NewRef(descr);
    3318                 :            :             assert(_PyType_HasFeature(Py_TYPE(res2), Py_TPFLAGS_METHOD_DESCRIPTOR));
    3319                 :            :             res = self;
    3320                 :            :             assert(oparg & 1);
    3321                 :            :             #line 3322 "Python/generated_cases.c.h"
    3322                 :     893123 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    3323                 :     893123 :             stack_pointer[-1] = res;
    3324         [ +  - ]:     893123 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
    3325                 :     893123 :             next_instr += 9;
    3326                 :     893123 :             DISPATCH();
    3327                 :            :         }
    3328                 :            : 
    3329                 :    2507024 :         TARGET(LOAD_ATTR_METHOD_NO_DICT) {
    3330                 :    2507024 :             PyObject *self = stack_pointer[-1];
    3331                 :    2507024 :             PyObject *res2 = NULL;
    3332                 :            :             PyObject *res;
    3333                 :    2507024 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    3334                 :    2507024 :             PyObject *descr = read_obj(&next_instr[5].cache);
    3335                 :            :             #line 2314 "Python/bytecodes.c"
    3336                 :            :             assert(cframe.use_tracing == 0);
    3337                 :            :             PyTypeObject *self_cls = Py_TYPE(self);
    3338                 :            :             DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
    3339                 :            :             assert(self_cls->tp_dictoffset == 0);
    3340                 :            :             STAT_INC(LOAD_ATTR, hit);
    3341                 :            :             assert(descr != NULL);
    3342                 :            :             assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
    3343                 :            :             res2 = Py_NewRef(descr);
    3344                 :            :             res = self;
    3345                 :            :             assert(oparg & 1);
    3346                 :            :             #line 3347 "Python/generated_cases.c.h"
    3347                 :    2507024 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    3348                 :    2507024 :             stack_pointer[-1] = res;
    3349         [ +  - ]:    2507024 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
    3350                 :    2507024 :             next_instr += 9;
    3351                 :    2507024 :             DISPATCH();
    3352                 :            :         }
    3353                 :            : 
    3354                 :        919 :         TARGET(LOAD_ATTR_METHOD_LAZY_DICT) {
    3355                 :        919 :             PyObject *self = stack_pointer[-1];
    3356                 :        919 :             PyObject *res2 = NULL;
    3357                 :            :             PyObject *res;
    3358                 :        919 :             uint32_t type_version = read_u32(&next_instr[1].cache);
    3359                 :        919 :             PyObject *descr = read_obj(&next_instr[5].cache);
    3360                 :            :             #line 2327 "Python/bytecodes.c"
    3361                 :            :             assert(cframe.use_tracing == 0);
    3362                 :            :             PyTypeObject *self_cls = Py_TYPE(self);
    3363                 :            :             DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
    3364                 :            :             Py_ssize_t dictoffset = self_cls->tp_dictoffset;
    3365                 :            :             assert(dictoffset > 0);
    3366                 :            :             PyObject *dict = *(PyObject **)((char *)self + dictoffset);
    3367                 :            :             /* This object has a __dict__, just not yet created */
    3368                 :            :             DEOPT_IF(dict != NULL, LOAD_ATTR);
    3369                 :            :             STAT_INC(LOAD_ATTR, hit);
    3370                 :            :             assert(descr != NULL);
    3371                 :            :             assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
    3372                 :            :             res2 = Py_NewRef(descr);
    3373                 :            :             res = self;
    3374                 :            :             assert(oparg & 1);
    3375                 :            :             #line 3376 "Python/generated_cases.c.h"
    3376                 :        770 :             STACK_GROW(((oparg & 1) ? 1 : 0));
    3377                 :        770 :             stack_pointer[-1] = res;
    3378         [ +  - ]:        770 :             if (oparg & 1) { stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))] = res2; }
    3379                 :        770 :             next_instr += 9;
    3380                 :        770 :             DISPATCH();
    3381                 :            :         }
    3382                 :            : 
    3383                 :     175409 :         TARGET(KW_NAMES) {
    3384                 :            :             #line 2344 "Python/bytecodes.c"
    3385                 :            :             assert(kwnames == NULL);
    3386                 :            :             assert(oparg < PyTuple_GET_SIZE(frame->f_code->co_consts));
    3387                 :            :             kwnames = GETITEM(frame->f_code->co_consts, oparg);
    3388                 :            :             #line 3389 "Python/generated_cases.c.h"
    3389                 :     175409 :             DISPATCH();
    3390                 :            :         }
    3391                 :            : 
    3392                 :    3419612 :         TARGET(CALL) {
    3393                 :    3688976 :             PREDICTED(CALL);
    3394                 :            :             static_assert(INLINE_CACHE_ENTRIES_CALL == 4, "incorrect cache size");
    3395                 :    3688976 :             PyObject **args = (stack_pointer - oparg);
    3396                 :    3688976 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3397         [ +  + ]:    3688976 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3398                 :            :             PyObject *res;
    3399                 :            :             #line 2380 "Python/bytecodes.c"
    3400                 :            :             int is_meth = method != NULL;
    3401                 :            :             int total_args = oparg;
    3402                 :            :             if (is_meth) {
    3403                 :            :                 callable = method;
    3404                 :            :                 args--;
    3405                 :            :                 total_args++;
    3406                 :            :             }
    3407                 :            :             #if ENABLE_SPECIALIZATION
    3408                 :            :             _PyCallCache *cache = (_PyCallCache *)next_instr;
    3409                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
    3410                 :            :                 assert(cframe.use_tracing == 0);
    3411                 :            :                 next_instr--;
    3412                 :            :                 _Py_Specialize_Call(callable, next_instr, total_args, kwnames);
    3413                 :            :                 DISPATCH_SAME_OPARG();
    3414                 :            :             }
    3415                 :            :             STAT_INC(CALL, deferred);
    3416                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
    3417                 :            :             #endif  /* ENABLE_SPECIALIZATION */
    3418                 :            :             if (!is_meth && Py_TYPE(callable) == &PyMethod_Type) {
    3419                 :            :                 is_meth = 1;  // For consistenct; it's dead, though
    3420                 :            :                 args--;
    3421                 :            :                 total_args++;
    3422                 :            :                 PyObject *self = ((PyMethodObject *)callable)->im_self;
    3423                 :            :                 args[0] = Py_NewRef(self);
    3424                 :            :                 method = ((PyMethodObject *)callable)->im_func;
    3425                 :            :                 args[-1] = Py_NewRef(method);
    3426                 :            :                 Py_DECREF(callable);
    3427                 :            :                 callable = method;
    3428                 :            :             }
    3429                 :            :             int positional_args = total_args - KWNAMES_LEN();
    3430                 :            :             // Check if the call can be inlined or not
    3431                 :            :             if (Py_TYPE(callable) == &PyFunction_Type &&
    3432                 :            :                 tstate->interp->eval_frame == NULL &&
    3433                 :            :                 ((PyFunctionObject *)callable)->vectorcall == _PyFunction_Vectorcall)
    3434                 :            :             {
    3435                 :            :                 int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable))->co_flags;
    3436                 :            :                 PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable));
    3437                 :            :                 _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
    3438                 :            :                     tstate, (PyFunctionObject *)callable, locals,
    3439                 :            :                     args, positional_args, kwnames
    3440                 :            :                 );
    3441                 :            :                 kwnames = NULL;
    3442                 :            :                 // Manipulate stack directly since we leave using DISPATCH_INLINED().
    3443                 :            :                 STACK_SHRINK(oparg + 2);
    3444                 :            :                 // The frame has stolen all the arguments from the stack,
    3445                 :            :                 // so there is no need to clean them up.
    3446                 :            :                 if (new_frame == NULL) {
    3447                 :            :                     goto error;
    3448                 :            :                 }
    3449                 :            :                 JUMPBY(INLINE_CACHE_ENTRIES_CALL);
    3450                 :            :                 DISPATCH_INLINED(new_frame);
    3451                 :            :             }
    3452                 :            :             /* Callable is not a normal Python function */
    3453                 :            :             if (cframe.use_tracing) {
    3454                 :            :                 res = trace_call_function(
    3455                 :            :                     tstate, callable, args,
    3456                 :            :                     positional_args, kwnames);
    3457                 :            :             }
    3458                 :            :             else {
    3459                 :            :                 res = PyObject_Vectorcall(
    3460                 :            :                     callable, args,
    3461                 :            :                     positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
    3462                 :            :                     kwnames);
    3463                 :            :             }
    3464                 :            :             kwnames = NULL;
    3465                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    3466                 :            :             Py_DECREF(callable);
    3467                 :            :             for (int i = 0; i < total_args; i++) {
    3468                 :            :                 Py_DECREF(args[i]);
    3469                 :            :             }
    3470                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3471                 :            :             #line 3472 "Python/generated_cases.c.h"
    3472                 :    3372693 :             STACK_SHRINK(oparg);
    3473                 :    3372693 :             STACK_SHRINK(1);
    3474                 :    3372693 :             stack_pointer[-1] = res;
    3475                 :    3372693 :             next_instr += 4;
    3476         [ +  + ]:    3372693 :             CHECK_EVAL_BREAKER();
    3477                 :    3372609 :             DISPATCH();
    3478                 :            :         }
    3479                 :            : 
    3480                 :     671078 :         TARGET(CALL_BOUND_METHOD_EXACT_ARGS) {
    3481                 :     671078 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3482         [ +  + ]:     671078 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3483                 :            :             #line 2458 "Python/bytecodes.c"
    3484                 :            :             DEOPT_IF(method != NULL, CALL);
    3485                 :            :             DEOPT_IF(Py_TYPE(callable) != &PyMethod_Type, CALL);
    3486                 :            :             STAT_INC(CALL, hit);
    3487                 :            :             PyObject *self = ((PyMethodObject *)callable)->im_self;
    3488                 :            :             PEEK(oparg + 1) = Py_NewRef(self);  // callable
    3489                 :            :             PyObject *meth = ((PyMethodObject *)callable)->im_func;
    3490                 :            :             PEEK(oparg + 2) = Py_NewRef(meth);  // method
    3491                 :            :             Py_DECREF(callable);
    3492                 :            :             GO_TO_INSTRUCTION(CALL_PY_EXACT_ARGS);
    3493                 :            :             #line 3494 "Python/generated_cases.c.h"
    3494                 :            :         }
    3495                 :            : 
    3496                 :    1362125 :         TARGET(CALL_PY_EXACT_ARGS) {
    3497                 :    1931482 :             PREDICTED(CALL_PY_EXACT_ARGS);
    3498                 :    1931482 :             PyObject **args = (stack_pointer - oparg);
    3499                 :    1931482 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3500                 :    1931482 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3501                 :    1931482 :             uint32_t func_version = read_u32(&next_instr[1].cache);
    3502                 :            :             #line 2470 "Python/bytecodes.c"
    3503                 :            :             assert(kwnames == NULL);
    3504                 :            :             DEOPT_IF(tstate->interp->eval_frame, CALL);
    3505                 :            :             int is_meth = method != NULL;
    3506                 :            :             int argcount = oparg;
    3507                 :            :             if (is_meth) {
    3508                 :            :                 callable = method;
    3509                 :            :                 args--;
    3510                 :            :                 argcount++;
    3511                 :            :             }
    3512                 :            :             DEOPT_IF(!PyFunction_Check(callable), CALL);
    3513                 :            :             PyFunctionObject *func = (PyFunctionObject *)callable;
    3514                 :            :             DEOPT_IF(func->func_version != func_version, CALL);
    3515                 :            :             PyCodeObject *code = (PyCodeObject *)func->func_code;
    3516                 :            :             DEOPT_IF(code->co_argcount != argcount, CALL);
    3517                 :            :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL);
    3518                 :            :             STAT_INC(CALL, hit);
    3519                 :            :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, func, argcount);
    3520                 :            :             for (int i = 0; i < argcount; i++) {
    3521                 :            :                 new_frame->localsplus[i] = args[i];
    3522                 :            :             }
    3523                 :            :             // Manipulate stack directly since we leave using DISPATCH_INLINED().
    3524                 :            :             STACK_SHRINK(oparg + 2);
    3525                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_CALL);
    3526                 :            :             DISPATCH_INLINED(new_frame);
    3527                 :            :             #line 3528 "Python/generated_cases.c.h"
    3528                 :            :         }
    3529                 :            : 
    3530                 :     222502 :         TARGET(CALL_PY_WITH_DEFAULTS) {
    3531                 :     222502 :             PyObject **args = (stack_pointer - oparg);
    3532                 :     222502 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3533                 :     222502 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3534                 :     222502 :             uint32_t func_version = read_u32(&next_instr[1].cache);
    3535                 :     222502 :             uint16_t min_args = read_u16(&next_instr[3].cache);
    3536                 :            :             #line 2497 "Python/bytecodes.c"
    3537                 :            :             assert(kwnames == NULL);
    3538                 :            :             DEOPT_IF(tstate->interp->eval_frame, CALL);
    3539                 :            :             int is_meth = method != NULL;
    3540                 :            :             int argcount = oparg;
    3541                 :            :             if (is_meth) {
    3542                 :            :                 callable = method;
    3543                 :            :                 args--;
    3544                 :            :                 argcount++;
    3545                 :            :             }
    3546                 :            :             DEOPT_IF(!PyFunction_Check(callable), CALL);
    3547                 :            :             PyFunctionObject *func = (PyFunctionObject *)callable;
    3548                 :            :             DEOPT_IF(func->func_version != func_version, CALL);
    3549                 :            :             PyCodeObject *code = (PyCodeObject *)func->func_code;
    3550                 :            :             DEOPT_IF(argcount > code->co_argcount, CALL);
    3551                 :            :             DEOPT_IF(argcount < min_args, CALL);
    3552                 :            :             DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL);
    3553                 :            :             STAT_INC(CALL, hit);
    3554                 :            :             _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, func, code->co_argcount);
    3555                 :            :             for (int i = 0; i < argcount; i++) {
    3556                 :            :                 new_frame->localsplus[i] = args[i];
    3557                 :            :             }
    3558                 :            :             for (int i = argcount; i < code->co_argcount; i++) {
    3559                 :            :                 PyObject *def = PyTuple_GET_ITEM(func->func_defaults, i - min_args);
    3560                 :            :                 new_frame->localsplus[i] = Py_NewRef(def);
    3561                 :            :             }
    3562                 :            :             // Manipulate stack and cache directly since we leave using DISPATCH_INLINED().
    3563                 :            :             STACK_SHRINK(oparg + 2);
    3564                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_CALL);
    3565                 :            :             DISPATCH_INLINED(new_frame);
    3566                 :            :             #line 3567 "Python/generated_cases.c.h"
    3567                 :            :         }
    3568                 :            : 
    3569                 :     597184 :         TARGET(CALL_NO_KW_TYPE_1) {
    3570                 :     597184 :             PyObject **args = (stack_pointer - oparg);
    3571                 :     597184 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3572         [ -  + ]:     597184 :             PyObject *null = stack_pointer[-(2 + oparg)];
    3573                 :            :             PyObject *res;
    3574                 :            :             #line 2529 "Python/bytecodes.c"
    3575                 :            :             assert(kwnames == NULL);
    3576                 :            :             assert(cframe.use_tracing == 0);
    3577                 :            :             assert(oparg == 1);
    3578                 :            :             DEOPT_IF(null != NULL, CALL);
    3579                 :            :             PyObject *obj = args[0];
    3580                 :            :             DEOPT_IF(callable != (PyObject *)&PyType_Type, CALL);
    3581                 :            :             STAT_INC(CALL, hit);
    3582                 :            :             res = Py_NewRef(Py_TYPE(obj));
    3583                 :            :             Py_DECREF(obj);
    3584                 :            :             Py_DECREF(&PyType_Type);  // I.e., callable
    3585                 :            :             #line 3586 "Python/generated_cases.c.h"
    3586                 :     597184 :             STACK_SHRINK(oparg);
    3587                 :     597184 :             STACK_SHRINK(1);
    3588                 :     597184 :             stack_pointer[-1] = res;
    3589                 :     597184 :             next_instr += 4;
    3590                 :     597184 :             DISPATCH();
    3591                 :            :         }
    3592                 :            : 
    3593                 :     262860 :         TARGET(CALL_NO_KW_STR_1) {
    3594                 :     262860 :             PyObject **args = (stack_pointer - oparg);
    3595                 :     262860 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3596         [ -  + ]:     262860 :             PyObject *null = stack_pointer[-(2 + oparg)];
    3597                 :            :             PyObject *res;
    3598                 :            :             #line 2542 "Python/bytecodes.c"
    3599                 :            :             assert(kwnames == NULL);
    3600                 :            :             assert(cframe.use_tracing == 0);
    3601                 :            :             assert(oparg == 1);
    3602                 :            :             DEOPT_IF(null != NULL, CALL);
    3603                 :            :             DEOPT_IF(callable != (PyObject *)&PyUnicode_Type, CALL);
    3604                 :            :             STAT_INC(CALL, hit);
    3605                 :            :             PyObject *arg = args[0];
    3606                 :            :             res = PyObject_Str(arg);
    3607                 :            :             Py_DECREF(arg);
    3608                 :            :             Py_DECREF(&PyUnicode_Type);  // I.e., callable
    3609                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3610                 :            :             #line 3611 "Python/generated_cases.c.h"
    3611                 :     262860 :             STACK_SHRINK(oparg);
    3612                 :     262860 :             STACK_SHRINK(1);
    3613                 :     262860 :             stack_pointer[-1] = res;
    3614                 :     262860 :             next_instr += 4;
    3615         [ -  + ]:     262860 :             CHECK_EVAL_BREAKER();
    3616                 :     262860 :             DISPATCH();
    3617                 :            :         }
    3618                 :            : 
    3619                 :      10082 :         TARGET(CALL_NO_KW_TUPLE_1) {
    3620                 :      10082 :             PyObject **args = (stack_pointer - oparg);
    3621                 :      10082 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3622         [ -  + ]:      10082 :             PyObject *null = stack_pointer[-(2 + oparg)];
    3623                 :            :             PyObject *res;
    3624                 :            :             #line 2557 "Python/bytecodes.c"
    3625                 :            :             assert(kwnames == NULL);
    3626                 :            :             assert(oparg == 1);
    3627                 :            :             DEOPT_IF(null != NULL, CALL);
    3628                 :            :             DEOPT_IF(callable != (PyObject *)&PyTuple_Type, CALL);
    3629                 :            :             STAT_INC(CALL, hit);
    3630                 :            :             PyObject *arg = args[0];
    3631                 :            :             res = PySequence_Tuple(arg);
    3632                 :            :             Py_DECREF(arg);
    3633                 :            :             Py_DECREF(&PyTuple_Type);  // I.e., tuple
    3634                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3635                 :            :             #line 3636 "Python/generated_cases.c.h"
    3636                 :      10082 :             STACK_SHRINK(oparg);
    3637                 :      10082 :             STACK_SHRINK(1);
    3638                 :      10082 :             stack_pointer[-1] = res;
    3639                 :      10082 :             next_instr += 4;
    3640         [ -  + ]:      10082 :             CHECK_EVAL_BREAKER();
    3641                 :      10082 :             DISPATCH();
    3642                 :            :         }
    3643                 :            : 
    3644                 :     358271 :         TARGET(CALL_BUILTIN_CLASS) {
    3645                 :     358271 :             PyObject **args = (stack_pointer - oparg);
    3646                 :     358271 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3647         [ -  + ]:     358271 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3648                 :            :             PyObject *res;
    3649                 :            :             #line 2571 "Python/bytecodes.c"
    3650                 :            :             int is_meth = method != NULL;
    3651                 :            :             int total_args = oparg;
    3652                 :            :             if (is_meth) {
    3653                 :            :                 callable = method;
    3654                 :            :                 args--;
    3655                 :            :                 total_args++;
    3656                 :            :             }
    3657                 :            :             int kwnames_len = KWNAMES_LEN();
    3658                 :            :             DEOPT_IF(!PyType_Check(callable), CALL);
    3659                 :            :             PyTypeObject *tp = (PyTypeObject *)callable;
    3660                 :            :             DEOPT_IF(tp->tp_vectorcall == NULL, CALL);
    3661                 :            :             STAT_INC(CALL, hit);
    3662                 :            :             res = tp->tp_vectorcall((PyObject *)tp, args,
    3663                 :            :                                     total_args - kwnames_len, kwnames);
    3664                 :            :             kwnames = NULL;
    3665                 :            :             /* Free the arguments. */
    3666                 :            :             for (int i = 0; i < total_args; i++) {
    3667                 :            :                 Py_DECREF(args[i]);
    3668                 :            :             }
    3669                 :            :             Py_DECREF(tp);
    3670                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3671                 :            :             #line 3672 "Python/generated_cases.c.h"
    3672                 :     358271 :             STACK_SHRINK(oparg);
    3673                 :     358271 :             STACK_SHRINK(1);
    3674                 :     358271 :             stack_pointer[-1] = res;
    3675                 :     358271 :             next_instr += 4;
    3676         [ +  + ]:     358271 :             CHECK_EVAL_BREAKER();
    3677                 :     358269 :             DISPATCH();
    3678                 :            :         }
    3679                 :            : 
    3680                 :    1570932 :         TARGET(CALL_NO_KW_BUILTIN_O) {
    3681                 :    1570932 :             PyObject **args = (stack_pointer - oparg);
    3682                 :    1570932 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3683         [ -  + ]:    1570932 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3684                 :            :             PyObject *res;
    3685                 :            :             #line 2596 "Python/bytecodes.c"
    3686                 :            :             assert(cframe.use_tracing == 0);
    3687                 :            :             /* Builtin METH_O functions */
    3688                 :            :             assert(kwnames == NULL);
    3689                 :            :             int is_meth = method != NULL;
    3690                 :            :             int total_args = oparg;
    3691                 :            :             if (is_meth) {
    3692                 :            :                 callable = method;
    3693                 :            :                 args--;
    3694                 :            :                 total_args++;
    3695                 :            :             }
    3696                 :            :             DEOPT_IF(total_args != 1, CALL);
    3697                 :            :             DEOPT_IF(!PyCFunction_CheckExact(callable), CALL);
    3698                 :            :             DEOPT_IF(PyCFunction_GET_FLAGS(callable) != METH_O, CALL);
    3699                 :            :             STAT_INC(CALL, hit);
    3700                 :            :             PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable);
    3701                 :            :             // This is slower but CPython promises to check all non-vectorcall
    3702                 :            :             // function calls.
    3703                 :            :             if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {
    3704                 :            :                 goto error;
    3705                 :            :             }
    3706                 :            :             PyObject *arg = args[0];
    3707                 :            :             res = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable), arg);
    3708                 :            :             _Py_LeaveRecursiveCallTstate(tstate);
    3709                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    3710                 :            : 
    3711                 :            :             Py_DECREF(arg);
    3712                 :            :             Py_DECREF(callable);
    3713                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3714                 :            :             #line 3715 "Python/generated_cases.c.h"
    3715                 :    1570293 :             STACK_SHRINK(oparg);
    3716                 :    1570293 :             STACK_SHRINK(1);
    3717                 :    1570293 :             stack_pointer[-1] = res;
    3718                 :    1570293 :             next_instr += 4;
    3719         [ +  + ]:    1570293 :             CHECK_EVAL_BREAKER();
    3720                 :    1570238 :             DISPATCH();
    3721                 :            :         }
    3722                 :            : 
    3723                 :    1210517 :         TARGET(CALL_NO_KW_BUILTIN_FAST) {
    3724                 :    1210517 :             PyObject **args = (stack_pointer - oparg);
    3725                 :    1210517 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3726         [ -  + ]:    1210517 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3727                 :            :             PyObject *res;
    3728                 :            :             #line 2628 "Python/bytecodes.c"
    3729                 :            :             assert(cframe.use_tracing == 0);
    3730                 :            :             /* Builtin METH_FASTCALL functions, without keywords */
    3731                 :            :             assert(kwnames == NULL);
    3732                 :            :             int is_meth = method != NULL;
    3733                 :            :             int total_args = oparg;
    3734                 :            :             if (is_meth) {
    3735                 :            :                 callable = method;
    3736                 :            :                 args--;
    3737                 :            :                 total_args++;
    3738                 :            :             }
    3739                 :            :             DEOPT_IF(!PyCFunction_CheckExact(callable), CALL);
    3740                 :            :             DEOPT_IF(PyCFunction_GET_FLAGS(callable) != METH_FASTCALL, CALL);
    3741                 :            :             STAT_INC(CALL, hit);
    3742                 :            :             PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable);
    3743                 :            :             /* res = func(self, args, nargs) */
    3744                 :            :             res = ((_PyCFunctionFast)(void(*)(void))cfunc)(
    3745                 :            :                 PyCFunction_GET_SELF(callable),
    3746                 :            :                 args,
    3747                 :            :                 total_args);
    3748                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    3749                 :            : 
    3750                 :            :             /* Free the arguments. */
    3751                 :            :             for (int i = 0; i < total_args; i++) {
    3752                 :            :                 Py_DECREF(args[i]);
    3753                 :            :             }
    3754                 :            :             Py_DECREF(callable);
    3755                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3756                 :            :                 /* Not deopting because this doesn't mean our optimization was
    3757                 :            :                    wrong. `res` can be NULL for valid reasons. Eg. getattr(x,
    3758                 :            :                    'invalid'). In those cases an exception is set, so we must
    3759                 :            :                    handle it.
    3760                 :            :                 */
    3761                 :            :             #line 3762 "Python/generated_cases.c.h"
    3762                 :    1112600 :             STACK_SHRINK(oparg);
    3763                 :    1112600 :             STACK_SHRINK(1);
    3764                 :    1112600 :             stack_pointer[-1] = res;
    3765                 :    1112600 :             next_instr += 4;
    3766         [ +  + ]:    1112600 :             CHECK_EVAL_BREAKER();
    3767                 :    1112598 :             DISPATCH();
    3768                 :            :         }
    3769                 :            : 
    3770                 :      12250 :         TARGET(CALL_BUILTIN_FAST_WITH_KEYWORDS) {
    3771                 :      12250 :             PyObject **args = (stack_pointer - oparg);
    3772                 :      12250 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3773         [ -  + ]:      12250 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3774                 :            :             PyObject *res;
    3775                 :            :             #line 2664 "Python/bytecodes.c"
    3776                 :            :             assert(cframe.use_tracing == 0);
    3777                 :            :             /* Builtin METH_FASTCALL | METH_KEYWORDS functions */
    3778                 :            :             int is_meth = method != NULL;
    3779                 :            :             int total_args = oparg;
    3780                 :            :             if (is_meth) {
    3781                 :            :                 callable = method;
    3782                 :            :                 args--;
    3783                 :            :                 total_args++;
    3784                 :            :             }
    3785                 :            :             DEOPT_IF(!PyCFunction_CheckExact(callable), CALL);
    3786                 :            :             DEOPT_IF(PyCFunction_GET_FLAGS(callable) !=
    3787                 :            :                 (METH_FASTCALL | METH_KEYWORDS), CALL);
    3788                 :            :             STAT_INC(CALL, hit);
    3789                 :            :             /* res = func(self, args, nargs, kwnames) */
    3790                 :            :             _PyCFunctionFastWithKeywords cfunc =
    3791                 :            :                 (_PyCFunctionFastWithKeywords)(void(*)(void))
    3792                 :            :                 PyCFunction_GET_FUNCTION(callable);
    3793                 :            :             res = cfunc(
    3794                 :            :                 PyCFunction_GET_SELF(callable),
    3795                 :            :                 args,
    3796                 :            :                 total_args - KWNAMES_LEN(),
    3797                 :            :                 kwnames
    3798                 :            :             );
    3799                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    3800                 :            :             kwnames = NULL;
    3801                 :            : 
    3802                 :            :             /* Free the arguments. */
    3803                 :            :             for (int i = 0; i < total_args; i++) {
    3804                 :            :                 Py_DECREF(args[i]);
    3805                 :            :             }
    3806                 :            :             Py_DECREF(callable);
    3807                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3808                 :            :             #line 3809 "Python/generated_cases.c.h"
    3809                 :      10598 :             STACK_SHRINK(oparg);
    3810                 :      10598 :             STACK_SHRINK(1);
    3811                 :      10598 :             stack_pointer[-1] = res;
    3812                 :      10598 :             next_instr += 4;
    3813         [ +  + ]:      10598 :             CHECK_EVAL_BREAKER();
    3814                 :      10578 :             DISPATCH();
    3815                 :            :         }
    3816                 :            : 
    3817                 :      44344 :         TARGET(CALL_NO_KW_LEN) {
    3818                 :      44344 :             PyObject **args = (stack_pointer - oparg);
    3819                 :      44344 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3820         [ -  + ]:      44344 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3821                 :            :             PyObject *res;
    3822                 :            :             #line 2700 "Python/bytecodes.c"
    3823                 :            :             assert(cframe.use_tracing == 0);
    3824                 :            :             assert(kwnames == NULL);
    3825                 :            :             /* len(o) */
    3826                 :            :             int is_meth = method != NULL;
    3827                 :            :             int total_args = oparg;
    3828                 :            :             if (is_meth) {
    3829                 :            :                 callable = method;
    3830                 :            :                 args--;
    3831                 :            :                 total_args++;
    3832                 :            :             }
    3833                 :            :             DEOPT_IF(total_args != 1, CALL);
    3834                 :            :             PyInterpreterState *interp = _PyInterpreterState_GET();
    3835                 :            :             DEOPT_IF(callable != interp->callable_cache.len, CALL);
    3836                 :            :             STAT_INC(CALL, hit);
    3837                 :            :             PyObject *arg = args[0];
    3838                 :            :             Py_ssize_t len_i = PyObject_Length(arg);
    3839                 :            :             if (len_i < 0) {
    3840                 :            :                 goto error;
    3841                 :            :             }
    3842                 :            :             res = PyLong_FromSsize_t(len_i);
    3843                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    3844                 :            : 
    3845                 :            :             Py_DECREF(callable);
    3846                 :            :             Py_DECREF(arg);
    3847                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3848                 :            :             #line 3849 "Python/generated_cases.c.h"
    3849                 :      44344 :             STACK_SHRINK(oparg);
    3850                 :      44344 :             STACK_SHRINK(1);
    3851                 :      44344 :             stack_pointer[-1] = res;
    3852                 :      44344 :             next_instr += 4;
    3853                 :      44344 :             DISPATCH();
    3854                 :            :         }
    3855                 :            : 
    3856                 :     588295 :         TARGET(CALL_NO_KW_ISINSTANCE) {
    3857                 :     588295 :             PyObject **args = (stack_pointer - oparg);
    3858                 :     588295 :             PyObject *callable = stack_pointer[-(1 + oparg)];
    3859         [ -  + ]:     588295 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3860                 :            :             PyObject *res;
    3861                 :            :             #line 2728 "Python/bytecodes.c"
    3862                 :            :             assert(cframe.use_tracing == 0);
    3863                 :            :             assert(kwnames == NULL);
    3864                 :            :             /* isinstance(o, o2) */
    3865                 :            :             int is_meth = method != NULL;
    3866                 :            :             int total_args = oparg;
    3867                 :            :             if (is_meth) {
    3868                 :            :                 callable = method;
    3869                 :            :                 args--;
    3870                 :            :                 total_args++;
    3871                 :            :             }
    3872                 :            :             DEOPT_IF(total_args != 2, CALL);
    3873                 :            :             PyInterpreterState *interp = _PyInterpreterState_GET();
    3874                 :            :             DEOPT_IF(callable != interp->callable_cache.isinstance, CALL);
    3875                 :            :             STAT_INC(CALL, hit);
    3876                 :            :             PyObject *cls = args[1];
    3877                 :            :             PyObject *inst = args[0];
    3878                 :            :             int retval = PyObject_IsInstance(inst, cls);
    3879                 :            :             if (retval < 0) {
    3880                 :            :                 goto error;
    3881                 :            :             }
    3882                 :            :             res = PyBool_FromLong(retval);
    3883                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    3884                 :            : 
    3885                 :            :             Py_DECREF(inst);
    3886                 :            :             Py_DECREF(cls);
    3887                 :            :             Py_DECREF(callable);
    3888                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3889                 :            :             #line 3890 "Python/generated_cases.c.h"
    3890                 :     588295 :             STACK_SHRINK(oparg);
    3891                 :     588295 :             STACK_SHRINK(1);
    3892                 :     588295 :             stack_pointer[-1] = res;
    3893                 :     588295 :             next_instr += 4;
    3894                 :     588295 :             DISPATCH();
    3895                 :            :         }
    3896                 :            : 
    3897                 :     498519 :         TARGET(CALL_NO_KW_LIST_APPEND) {
    3898                 :     498519 :             PyObject **args = (stack_pointer - oparg);
    3899                 :     498519 :             PyObject *self = stack_pointer[-(1 + oparg)];
    3900                 :     498519 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3901                 :            :             #line 2759 "Python/bytecodes.c"
    3902                 :            :             assert(cframe.use_tracing == 0);
    3903                 :            :             assert(kwnames == NULL);
    3904                 :            :             assert(oparg == 1);
    3905                 :            :             assert(method != NULL);
    3906                 :            :             PyInterpreterState *interp = _PyInterpreterState_GET();
    3907                 :            :             DEOPT_IF(method != interp->callable_cache.list_append, CALL);
    3908                 :            :             DEOPT_IF(!PyList_Check(self), CALL);
    3909                 :            :             STAT_INC(CALL, hit);
    3910                 :            :             if (_PyList_AppendTakeRef((PyListObject *)self, args[0]) < 0) {
    3911                 :            :                 goto pop_1_error;  // Since arg is DECREF'ed already
    3912                 :            :             }
    3913                 :            :             Py_DECREF(self);
    3914                 :            :             Py_DECREF(method);
    3915                 :            :             STACK_SHRINK(3);
    3916                 :            :             // CALL + POP_TOP
    3917                 :            :             JUMPBY(INLINE_CACHE_ENTRIES_CALL + 1);
    3918                 :            :             assert(next_instr[-1].op.code == POP_TOP);
    3919                 :            :             DISPATCH();
    3920                 :            :             #line 3921 "Python/generated_cases.c.h"
    3921                 :            :         }
    3922                 :            : 
    3923                 :     237456 :         TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_O) {
    3924                 :     237456 :             PyObject **args = (stack_pointer - oparg);
    3925         [ +  - ]:     237456 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3926                 :            :             PyObject *res;
    3927                 :            :             #line 2780 "Python/bytecodes.c"
    3928                 :            :             assert(kwnames == NULL);
    3929                 :            :             int is_meth = method != NULL;
    3930                 :            :             int total_args = oparg;
    3931                 :            :             if (is_meth) {
    3932                 :            :                 args--;
    3933                 :            :                 total_args++;
    3934                 :            :             }
    3935                 :            :             PyMethodDescrObject *callable =
    3936                 :            :                 (PyMethodDescrObject *)PEEK(total_args + 1);
    3937                 :            :             DEOPT_IF(total_args != 2, CALL);
    3938                 :            :             DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
    3939                 :            :             PyMethodDef *meth = callable->d_method;
    3940                 :            :             DEOPT_IF(meth->ml_flags != METH_O, CALL);
    3941                 :            :             PyObject *arg = args[1];
    3942                 :            :             PyObject *self = args[0];
    3943                 :            :             DEOPT_IF(!Py_IS_TYPE(self, callable->d_common.d_type), CALL);
    3944                 :            :             STAT_INC(CALL, hit);
    3945                 :            :             PyCFunction cfunc = meth->ml_meth;
    3946                 :            :             // This is slower but CPython promises to check all non-vectorcall
    3947                 :            :             // function calls.
    3948                 :            :             if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {
    3949                 :            :                 goto error;
    3950                 :            :             }
    3951                 :            :             res = _PyCFunction_TrampolineCall(cfunc, self, arg);
    3952                 :            :             _Py_LeaveRecursiveCallTstate(tstate);
    3953                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    3954                 :            :             Py_DECREF(self);
    3955                 :            :             Py_DECREF(arg);
    3956                 :            :             Py_DECREF(callable);
    3957                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    3958                 :            :             #line 3959 "Python/generated_cases.c.h"
    3959                 :      87920 :             STACK_SHRINK(oparg);
    3960                 :      87920 :             STACK_SHRINK(1);
    3961                 :      87920 :             stack_pointer[-1] = res;
    3962                 :      87920 :             next_instr += 4;
    3963         [ -  + ]:      87920 :             CHECK_EVAL_BREAKER();
    3964                 :      87920 :             DISPATCH();
    3965                 :            :         }
    3966                 :            : 
    3967                 :      20601 :         TARGET(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS) {
    3968                 :      20601 :             PyObject **args = (stack_pointer - oparg);
    3969         [ +  - ]:      20601 :             PyObject *method = stack_pointer[-(2 + oparg)];
    3970                 :            :             PyObject *res;
    3971                 :            :             #line 2814 "Python/bytecodes.c"
    3972                 :            :             int is_meth = method != NULL;
    3973                 :            :             int total_args = oparg;
    3974                 :            :             if (is_meth) {
    3975                 :            :                 args--;
    3976                 :            :                 total_args++;
    3977                 :            :             }
    3978                 :            :             PyMethodDescrObject *callable =
    3979                 :            :                 (PyMethodDescrObject *)PEEK(total_args + 1);
    3980                 :            :             DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
    3981                 :            :             PyMethodDef *meth = callable->d_method;
    3982                 :            :             DEOPT_IF(meth->ml_flags != (METH_FASTCALL|METH_KEYWORDS), CALL);
    3983                 :            :             PyTypeObject *d_type = callable->d_common.d_type;
    3984                 :            :             PyObject *self = args[0];
    3985                 :            :             DEOPT_IF(!Py_IS_TYPE(self, d_type), CALL);
    3986                 :            :             STAT_INC(CALL, hit);
    3987                 :            :             int nargs = total_args - 1;
    3988                 :            :             _PyCFunctionFastWithKeywords cfunc =
    3989                 :            :                 (_PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth;
    3990                 :            :             res = cfunc(self, args + 1, nargs - KWNAMES_LEN(), kwnames);
    3991                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    3992                 :            :             kwnames = NULL;
    3993                 :            : 
    3994                 :            :             /* Free the arguments. */
    3995                 :            :             for (int i = 0; i < total_args; i++) {
    3996                 :            :                 Py_DECREF(args[i]);
    3997                 :            :             }
    3998                 :            :             Py_DECREF(callable);
    3999                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    4000                 :            :             #line 4001 "Python/generated_cases.c.h"
    4001                 :      20601 :             STACK_SHRINK(oparg);
    4002                 :      20601 :             STACK_SHRINK(1);
    4003                 :      20601 :             stack_pointer[-1] = res;
    4004                 :      20601 :             next_instr += 4;
    4005         [ -  + ]:      20601 :             CHECK_EVAL_BREAKER();
    4006                 :      20601 :             DISPATCH();
    4007                 :            :         }
    4008                 :            : 
    4009                 :     298114 :         TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_NOARGS) {
    4010                 :     298114 :             PyObject **args = (stack_pointer - oparg);
    4011         [ +  + ]:     298114 :             PyObject *method = stack_pointer[-(2 + oparg)];
    4012                 :            :             PyObject *res;
    4013                 :            :             #line 2846 "Python/bytecodes.c"
    4014                 :            :             assert(kwnames == NULL);
    4015                 :            :             assert(oparg == 0 || oparg == 1);
    4016                 :            :             int is_meth = method != NULL;
    4017                 :            :             int total_args = oparg;
    4018                 :            :             if (is_meth) {
    4019                 :            :                 args--;
    4020                 :            :                 total_args++;
    4021                 :            :             }
    4022                 :            :             DEOPT_IF(total_args != 1, CALL);
    4023                 :            :             PyMethodDescrObject *callable = (PyMethodDescrObject *)SECOND();
    4024                 :            :             DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
    4025                 :            :             PyMethodDef *meth = callable->d_method;
    4026                 :            :             PyObject *self = args[0];
    4027                 :            :             DEOPT_IF(!Py_IS_TYPE(self, callable->d_common.d_type), CALL);
    4028                 :            :             DEOPT_IF(meth->ml_flags != METH_NOARGS, CALL);
    4029                 :            :             STAT_INC(CALL, hit);
    4030                 :            :             PyCFunction cfunc = meth->ml_meth;
    4031                 :            :             // This is slower but CPython promises to check all non-vectorcall
    4032                 :            :             // function calls.
    4033                 :            :             if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {
    4034                 :            :                 goto error;
    4035                 :            :             }
    4036                 :            :             res = _PyCFunction_TrampolineCall(cfunc, self, NULL);
    4037                 :            :             _Py_LeaveRecursiveCallTstate(tstate);
    4038                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    4039                 :            :             Py_DECREF(self);
    4040                 :            :             Py_DECREF(callable);
    4041                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    4042                 :            :             #line 4043 "Python/generated_cases.c.h"
    4043                 :     295865 :             STACK_SHRINK(oparg);
    4044                 :     295865 :             STACK_SHRINK(1);
    4045                 :     295865 :             stack_pointer[-1] = res;
    4046                 :     295865 :             next_instr += 4;
    4047         [ -  + ]:     295865 :             CHECK_EVAL_BREAKER();
    4048                 :     295865 :             DISPATCH();
    4049                 :            :         }
    4050                 :            : 
    4051                 :     164246 :         TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_FAST) {
    4052                 :     164246 :             PyObject **args = (stack_pointer - oparg);
    4053         [ +  + ]:     164246 :             PyObject *method = stack_pointer[-(2 + oparg)];
    4054                 :            :             PyObject *res;
    4055                 :            :             #line 2878 "Python/bytecodes.c"
    4056                 :            :             assert(kwnames == NULL);
    4057                 :            :             int is_meth = method != NULL;
    4058                 :            :             int total_args = oparg;
    4059                 :            :             if (is_meth) {
    4060                 :            :                 args--;
    4061                 :            :                 total_args++;
    4062                 :            :             }
    4063                 :            :             PyMethodDescrObject *callable =
    4064                 :            :                 (PyMethodDescrObject *)PEEK(total_args + 1);
    4065                 :            :             /* Builtin METH_FASTCALL methods, without keywords */
    4066                 :            :             DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
    4067                 :            :             PyMethodDef *meth = callable->d_method;
    4068                 :            :             DEOPT_IF(meth->ml_flags != METH_FASTCALL, CALL);
    4069                 :            :             PyObject *self = args[0];
    4070                 :            :             DEOPT_IF(!Py_IS_TYPE(self, callable->d_common.d_type), CALL);
    4071                 :            :             STAT_INC(CALL, hit);
    4072                 :            :             _PyCFunctionFast cfunc =
    4073                 :            :                 (_PyCFunctionFast)(void(*)(void))meth->ml_meth;
    4074                 :            :             int nargs = total_args - 1;
    4075                 :            :             res = cfunc(self, args + 1, nargs);
    4076                 :            :             assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
    4077                 :            :             /* Clear the stack of the arguments. */
    4078                 :            :             for (int i = 0; i < total_args; i++) {
    4079                 :            :                 Py_DECREF(args[i]);
    4080                 :            :             }
    4081                 :            :             Py_DECREF(callable);
    4082                 :            :             if (res == NULL) { STACK_SHRINK(oparg); goto pop_2_error; }
    4083                 :            :             #line 4084 "Python/generated_cases.c.h"
    4084                 :     164027 :             STACK_SHRINK(oparg);
    4085                 :     164027 :             STACK_SHRINK(1);
    4086                 :     164027 :             stack_pointer[-1] = res;
    4087                 :     164027 :             next_instr += 4;
    4088         [ +  + ]:     164027 :             CHECK_EVAL_BREAKER();
    4089                 :     164026 :             DISPATCH();
    4090                 :            :         }
    4091                 :            : 
    4092                 :     103224 :         TARGET(CALL_FUNCTION_EX) {
    4093                 :     103224 :             PREDICTED(CALL_FUNCTION_EX);
    4094         [ +  + ]:     103224 :             PyObject *kwargs = (oparg & 1) ? stack_pointer[-(((oparg & 1) ? 1 : 0))] : NULL;
    4095                 :     103224 :             PyObject *callargs = stack_pointer[-(1 + ((oparg & 1) ? 1 : 0))];
    4096                 :     103224 :             PyObject *func = stack_pointer[-(2 + ((oparg & 1) ? 1 : 0))];
    4097                 :            :             PyObject *result;
    4098                 :            :             #line 2909 "Python/bytecodes.c"
    4099                 :            :             if (oparg & 1) {
    4100                 :            :                 // DICT_MERGE is called before this opcode if there are kwargs.
    4101                 :            :                 // It converts all dict subtypes in kwargs into regular dicts.
    4102                 :            :                 assert(PyDict_CheckExact(kwargs));
    4103                 :            :             }
    4104                 :            :             if (!PyTuple_CheckExact(callargs)) {
    4105                 :            :                 if (check_args_iterable(tstate, func, callargs) < 0) {
    4106                 :            :                     goto error;
    4107                 :            :                 }
    4108                 :            :                 PyObject *tuple = PySequence_Tuple(callargs);
    4109                 :            :                 if (tuple == NULL) {
    4110                 :            :                     goto error;
    4111                 :            :                 }
    4112                 :            :                 Py_SETREF(callargs, tuple);
    4113                 :            :             }
    4114                 :            :             assert(PyTuple_CheckExact(callargs));
    4115                 :            : 
    4116                 :            :             result = do_call_core(tstate, func, callargs, kwargs, cframe.use_tracing);
    4117                 :            :             #line 4118 "Python/generated_cases.c.h"
    4118         [ +  + ]:     103224 :             Py_DECREF(func);
    4119         [ +  + ]:     103224 :             Py_DECREF(callargs);
    4120   [ +  +  +  - ]:     103224 :             Py_XDECREF(kwargs);
    4121                 :            :             #line 2928 "Python/bytecodes.c"
    4122                 :            : 
    4123                 :            :             assert(PEEK(3 + (oparg & 1)) == NULL);
    4124                 :            :             if (result == NULL) { STACK_SHRINK(((oparg & 1) ? 1 : 0)); goto pop_3_error; }
    4125                 :            :             #line 4126 "Python/generated_cases.c.h"
    4126                 :     103023 :             STACK_SHRINK(((oparg & 1) ? 1 : 0));
    4127                 :     103023 :             STACK_SHRINK(2);
    4128                 :     103023 :             stack_pointer[-1] = result;
    4129         [ +  + ]:     103023 :             CHECK_EVAL_BREAKER();
    4130                 :     102949 :             DISPATCH();
    4131                 :            :         }
    4132                 :            : 
    4133                 :     197280 :         TARGET(MAKE_FUNCTION) {
    4134                 :     197280 :             PyObject *codeobj = stack_pointer[-1];
    4135         [ +  + ]:     197280 :             PyObject *closure = (oparg & 0x08) ? stack_pointer[-(1 + ((oparg & 0x08) ? 1 : 0))] : NULL;
    4136         [ +  + ]:     197280 :             PyObject *annotations = (oparg & 0x04) ? stack_pointer[-(1 + ((oparg & 0x08) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0))] : NULL;
    4137         [ +  + ]:     197280 :             PyObject *kwdefaults = (oparg & 0x02) ? stack_pointer[-(1 + ((oparg & 0x08) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0))] : NULL;
    4138         [ +  + ]:     197280 :             PyObject *defaults = (oparg & 0x01) ? stack_pointer[-(1 + ((oparg & 0x08) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0) + ((oparg & 0x01) ? 1 : 0))] : NULL;
    4139                 :            :             PyObject *func;
    4140                 :            :             #line 2939 "Python/bytecodes.c"
    4141                 :            : 
    4142                 :            :             PyFunctionObject *func_obj = (PyFunctionObject *)
    4143                 :            :                 PyFunction_New(codeobj, GLOBALS());
    4144                 :            : 
    4145                 :            :             Py_DECREF(codeobj);
    4146                 :            :             if (func_obj == NULL) {
    4147                 :            :                 goto error;
    4148                 :            :             }
    4149                 :            : 
    4150                 :            :             if (oparg & 0x08) {
    4151                 :            :                 assert(PyTuple_CheckExact(closure));
    4152                 :            :                 func_obj->func_closure = closure;
    4153                 :            :             }
    4154                 :            :             if (oparg & 0x04) {
    4155                 :            :                 assert(PyTuple_CheckExact(annotations));
    4156                 :            :                 func_obj->func_annotations = annotations;
    4157                 :            :             }
    4158                 :            :             if (oparg & 0x02) {
    4159                 :            :                 assert(PyDict_CheckExact(kwdefaults));
    4160                 :            :                 func_obj->func_kwdefaults = kwdefaults;
    4161                 :            :             }
    4162                 :            :             if (oparg & 0x01) {
    4163                 :            :                 assert(PyTuple_CheckExact(defaults));
    4164                 :            :                 func_obj->func_defaults = defaults;
    4165                 :            :             }
    4166                 :            : 
    4167                 :            :             func_obj->func_version = ((PyCodeObject *)codeobj)->co_version;
    4168                 :            :             func = (PyObject *)func_obj;
    4169                 :            :             #line 4170 "Python/generated_cases.c.h"
    4170                 :     197280 :             STACK_SHRINK(((oparg & 0x01) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0) + ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x08) ? 1 : 0));
    4171                 :     197280 :             stack_pointer[-1] = func;
    4172                 :     197280 :             DISPATCH();
    4173                 :            :         }
    4174                 :            : 
    4175                 :     122420 :         TARGET(RETURN_GENERATOR) {
    4176                 :            :             #line 2970 "Python/bytecodes.c"
    4177                 :            :             assert(PyFunction_Check(frame->f_funcobj));
    4178                 :            :             PyFunctionObject *func = (PyFunctionObject *)frame->f_funcobj;
    4179                 :            :             PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
    4180                 :            :             if (gen == NULL) {
    4181                 :            :                 goto error;
    4182                 :            :             }
    4183                 :            :             assert(EMPTY());
    4184                 :            :             _PyFrame_SetStackPointer(frame, stack_pointer);
    4185                 :            :             _PyInterpreterFrame *gen_frame = (_PyInterpreterFrame *)gen->gi_iframe;
    4186                 :            :             _PyFrame_Copy(frame, gen_frame);
    4187                 :            :             assert(frame->frame_obj == NULL);
    4188                 :            :             gen->gi_frame_state = FRAME_CREATED;
    4189                 :            :             gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
    4190                 :            :             _Py_LeaveRecursiveCallPy(tstate);
    4191                 :            :             assert(frame != &entry_frame);
    4192                 :            :             _PyInterpreterFrame *prev = frame->previous;
    4193                 :            :             _PyThreadState_PopFrame(tstate, frame);
    4194                 :            :             frame = cframe.current_frame = prev;
    4195                 :            :             _PyFrame_StackPush(frame, (PyObject *)gen);
    4196                 :            :             goto resume_frame;
    4197                 :            :             #line 4198 "Python/generated_cases.c.h"
    4198                 :            :         }
    4199                 :            : 
    4200                 :       1181 :         TARGET(BUILD_SLICE) {
    4201         [ +  + ]:       1181 :             PyObject *step = (oparg == 3) ? stack_pointer[-(((oparg == 3) ? 1 : 0))] : NULL;
    4202         [ +  + ]:       1181 :             PyObject *stop = stack_pointer[-(1 + ((oparg == 3) ? 1 : 0))];
    4203         [ +  + ]:       1181 :             PyObject *start = stack_pointer[-(2 + ((oparg == 3) ? 1 : 0))];
    4204                 :            :             PyObject *slice;
    4205                 :            :             #line 2993 "Python/bytecodes.c"
    4206                 :            :             slice = PySlice_New(start, stop, step);
    4207                 :            :             #line 4208 "Python/generated_cases.c.h"
    4208         [ -  + ]:       1181 :             Py_DECREF(start);
    4209         [ -  + ]:       1181 :             Py_DECREF(stop);
    4210   [ +  +  -  + ]:       1181 :             Py_XDECREF(step);
    4211                 :            :             #line 2995 "Python/bytecodes.c"
    4212                 :            :             if (slice == NULL) { STACK_SHRINK(((oparg == 3) ? 1 : 0)); goto pop_2_error; }
    4213                 :            :             #line 4214 "Python/generated_cases.c.h"
    4214                 :       1181 :             STACK_SHRINK(((oparg == 3) ? 1 : 0));
    4215                 :       1181 :             STACK_SHRINK(1);
    4216                 :       1181 :             stack_pointer[-1] = slice;
    4217                 :       1181 :             DISPATCH();
    4218                 :            :         }
    4219                 :            : 
    4220                 :     362437 :         TARGET(FORMAT_VALUE) {
    4221         [ +  + ]:     362437 :             PyObject *fmt_spec = ((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? stack_pointer[-((((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0))] : NULL;
    4222   [ +  +  +  -  :     362437 :             PyObject *value = stack_pointer[-(1 + (((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0))];
                      - ]
    4223                 :            :             PyObject *result;
    4224                 :            :             #line 2999 "Python/bytecodes.c"
    4225                 :            :             /* Handles f-string value formatting. */
    4226                 :            :             PyObject *(*conv_fn)(PyObject *);
    4227                 :            :             int which_conversion = oparg & FVC_MASK;
    4228                 :            : 
    4229                 :            :             /* See if any conversion is specified. */
    4230                 :            :             switch (which_conversion) {
    4231                 :            :             case FVC_NONE:  conv_fn = NULL;           break;
    4232                 :            :             case FVC_STR:   conv_fn = PyObject_Str;   break;
    4233                 :            :             case FVC_REPR:  conv_fn = PyObject_Repr;  break;
    4234                 :            :             case FVC_ASCII: conv_fn = PyObject_ASCII; break;
    4235                 :            :             default:
    4236                 :            :                 _PyErr_Format(tstate, PyExc_SystemError,
    4237                 :            :                               "unexpected conversion flag %d",
    4238                 :            :                               which_conversion);
    4239                 :            :                 goto error;
    4240                 :            :             }
    4241                 :            : 
    4242                 :            :             /* If there's a conversion function, call it and replace
    4243                 :            :                value with that result. Otherwise, just use value,
    4244                 :            :                without conversion. */
    4245                 :            :             if (conv_fn != NULL) {
    4246                 :            :                 result = conv_fn(value);
    4247                 :            :                 Py_DECREF(value);
    4248                 :            :                 if (result == NULL) {
    4249                 :            :                     Py_XDECREF(fmt_spec);
    4250                 :            :                     if (true) { STACK_SHRINK((((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0)); goto pop_1_error; }
    4251                 :            :                 }
    4252                 :            :                 value = result;
    4253                 :            :             }
    4254                 :            : 
    4255                 :            :             /* If value is a unicode object, and there's no fmt_spec,
    4256                 :            :                then we know the result of format(value) is value
    4257                 :            :                itself. In that case, skip calling format(). I plan to
    4258                 :            :                move this optimization in to PyObject_Format()
    4259                 :            :                itself. */
    4260                 :            :             if (PyUnicode_CheckExact(value) && fmt_spec == NULL) {
    4261                 :            :                 /* Do nothing, just transfer ownership to result. */
    4262                 :            :                 result = value;
    4263                 :            :             } else {
    4264                 :            :                 /* Actually call format(). */
    4265                 :            :                 result = PyObject_Format(value, fmt_spec);
    4266                 :            :             #line 4267 "Python/generated_cases.c.h"
    4267         [ +  + ]:     304040 :                 Py_DECREF(value);
    4268   [ +  +  +  + ]:     304040 :                 Py_XDECREF(fmt_spec);
    4269                 :            :             #line 3041 "Python/bytecodes.c"
    4270                 :            :                 if (result == NULL) { STACK_SHRINK((((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0)); goto pop_1_error; }
    4271                 :            :             }
    4272                 :            :             #line 4273 "Python/generated_cases.c.h"
    4273                 :     362437 :             STACK_SHRINK((((oparg & FVS_MASK) == FVS_HAVE_SPEC) ? 1 : 0));
    4274                 :     362437 :             stack_pointer[-1] = result;
    4275                 :     362437 :             DISPATCH();
    4276                 :            :         }
    4277                 :            : 
    4278                 :     225025 :         TARGET(COPY) {
    4279                 :     225025 :             PyObject *bottom = stack_pointer[-(1 + (oparg-1))];
    4280                 :            :             PyObject *top;
    4281                 :            :             #line 3046 "Python/bytecodes.c"
    4282                 :            :             assert(oparg > 0);
    4283                 :            :             top = Py_NewRef(bottom);
    4284                 :            :             #line 4285 "Python/generated_cases.c.h"
    4285                 :     225025 :             STACK_GROW(1);
    4286                 :     225025 :             stack_pointer[-1] = top;
    4287                 :     225025 :             DISPATCH();
    4288                 :            :         }
    4289                 :            : 
    4290                 :    2222177 :         TARGET(BINARY_OP) {
    4291                 :    2224339 :             PREDICTED(BINARY_OP);
    4292                 :            :             static_assert(INLINE_CACHE_ENTRIES_BINARY_OP == 1, "incorrect cache size");
    4293                 :    2224339 :             PyObject *rhs = stack_pointer[-1];
    4294         [ +  + ]:    2224339 :             PyObject *lhs = stack_pointer[-2];
    4295                 :            :             PyObject *res;
    4296                 :            :             #line 3051 "Python/bytecodes.c"
    4297                 :            :             #if ENABLE_SPECIALIZATION
    4298                 :            :             _PyBinaryOpCache *cache = (_PyBinaryOpCache *)next_instr;
    4299                 :            :             if (ADAPTIVE_COUNTER_IS_ZERO(cache->counter)) {
    4300                 :            :                 assert(cframe.use_tracing == 0);
    4301                 :            :                 next_instr--;
    4302                 :            :                 _Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, &GETLOCAL(0));
    4303                 :            :                 DISPATCH_SAME_OPARG();
    4304                 :            :             }
    4305                 :            :             STAT_INC(BINARY_OP, deferred);
    4306                 :            :             DECREMENT_ADAPTIVE_COUNTER(cache->counter);
    4307                 :            :             #endif  /* ENABLE_SPECIALIZATION */
    4308                 :            :             assert(0 <= oparg);
    4309                 :            :             assert((unsigned)oparg < Py_ARRAY_LENGTH(binary_ops));
    4310                 :            :             assert(binary_ops[oparg]);
    4311                 :            :             res = binary_ops[oparg](lhs, rhs);
    4312                 :            :             #line 4313 "Python/generated_cases.c.h"
    4313         [ +  + ]:    2220938 :             Py_DECREF(lhs);
    4314         [ +  + ]:    2220938 :             Py_DECREF(rhs);
    4315                 :            :             #line 3067 "Python/bytecodes.c"
    4316                 :            :             if (res == NULL) goto pop_2_error;
    4317                 :            :             #line 4318 "Python/generated_cases.c.h"
    4318                 :    2220937 :             STACK_SHRINK(1);
    4319                 :    2220937 :             stack_pointer[-1] = res;
    4320                 :    2220937 :             next_instr += 1;
    4321                 :    2220937 :             DISPATCH();
    4322                 :            :         }
    4323                 :            : 
    4324                 :     586087 :         TARGET(SWAP) {
    4325                 :     586087 :             PyObject *top = stack_pointer[-1];
    4326                 :     586087 :             PyObject *bottom = stack_pointer[-(2 + (oparg-2))];
    4327                 :            :             #line 3072 "Python/bytecodes.c"
    4328                 :            :             assert(oparg >= 2);
    4329                 :            :             #line 4330 "Python/generated_cases.c.h"
    4330                 :     586087 :             stack_pointer[-1] = bottom;
    4331                 :     586087 :             stack_pointer[-(2 + (oparg-2))] = top;
    4332                 :     586087 :             DISPATCH();
    4333                 :            :         }
    4334                 :            : 
    4335                 :      92853 :         TARGET(EXTENDED_ARG) {
    4336                 :            :             #line 3076 "Python/bytecodes.c"
    4337                 :            :             assert(oparg);
    4338                 :            :             assert(cframe.use_tracing == 0);
    4339                 :            :             opcode = next_instr->op.code;
    4340                 :            :             oparg = oparg << 8 | next_instr->op.arg;
    4341                 :            :             PRE_DISPATCH_GOTO();
    4342                 :            :             DISPATCH_GOTO();
    4343                 :            :             #line 4344 "Python/generated_cases.c.h"
    4344                 :            :         }
    4345                 :            : 
    4346                 :          0 :         TARGET(CACHE) {
    4347                 :            :             #line 3085 "Python/bytecodes.c"
    4348                 :            :             Py_UNREACHABLE();
    4349                 :            :             #line 4350 "Python/generated_cases.c.h"
    4350                 :            :         }

Generated by: LCOV version 1.14