WARNING: the argument --multi-file is deprecated. This is not fatal, as GenProg can handle certain deprecated options as of the March 2012 refactor.
However, you may want to consult the GenProg documentation to avoid using 
deprecated options in the future, and verify that your config is doing what you
think it is doing.WARNING: the argument --suffix-extension is deprecated. This is not fatal, as GenProg can handle certain deprecated options as of the March 2012 refactor.
However, you may want to consult the GenProg documentation to avoid using 
deprecated options in the future, and verify that your config is doing what you
think it is doing.WARNING: the argument --mutp is deprecated. This is not fatal, as GenProg can handle certain deprecated options as of the March 2012 refactor.
However, you may want to consult the GenProg documentation to avoid using 
deprecated options in the future, and verify that your config is doing what you
think it is doing.WARNING: the argument --uniq-cov is deprecated. This is not fatal, as GenProg can handle certain deprecated options as of the March 2012 refactor.
However, you may want to consult the GenProg documentation to avoid using 
deprecated options in the future, and verify that your config is doing what you
think it is doing.new deprecated: /root/repair --uniq 
new deprecated: /root/repair --uniq 
--allow-coverage-fail false
--appp 0.33333
--asm-code-only false
--best-edit-rule "1 * fault_loc_weight ; 1 * max_test_fail_prob ; -1 * num_tests"
--best-test-rule "1 * test_fail_prob ; 1 * test_fail_count ; -1 * test_pass_count"
--compiler "gcc"
--compiler-command "perl compile.pl __EXE_NAME__ > /dev/null"
--compiler-opts ""
--continue false
--coverage-info ""
--coverage-per-test false
--crossover "subset"
--crossp 0.5
--delp 0.33333
--describe-machine true
--diversity-selection 0
--edit-script false
--elf-risc false
--exp-diff false
--fault-file ""
--fault-path "coverage.path.neg"
--fault-scheme "path"
--fitness-in-parallel 1
--fix-file ""
--fix-oracle ""
--fix-path "coverage.path.pos"
--fix-scheme "default"
--flatten-path ""
--format "txt"
--gen-per-exchange 1
--generations 10
--gui false
--hostname "127.0.0.1"
--ignore-dead-code true
--ignore-equiv-appends true
--ignore-standard-headers true
--ignore-string-equiv-fixes true
--ignore-untyped-returns true
--incoming-pop ""
--keep-source false
--label-repair false
--max-evals 0
--minimization false
--mt-cov true
--multiopt-minimize false
--multiopt-no-inf false
--neg-tests 1
--neg-weight 1
--negative-test-weight 2
--neutral-walk-max-size 0
--neutral-walk-weight ""
--nht-id "global"
--nht-port 51000
--nht-server ""
--no-rep-cache false
--no-test-cache false
--num-comps 2
--num-objectives 2
--oracle-genome ""
--popsize 40
--port 60000
--pos-tests 305
--pos-weight 0.1
--prefix "preprocessed"
--preprocessor ""
--print-incremental-evals false
--print-source-name false
--program "bugged-program.txt"
--promut 1
--quiet false
--regen-paths false
--rep "cilpatch"
--rep-cache "default.cache"
--repp 0
--samp-strat "variant"
--sample 1
--sample-runs 100
--sanity "yes"
--search "ww"
--seed 1
--semantic-check "scope"
--single-fitness false
--skip-failed-sanity-tests true
--skip-tests ""
--split-search 0
--sport 65000
--subatom-constp 0.5
--subatom-mutp 0
--super-mutant true
--super-mutant-size 50
--swap-bug false
--swapp 0.33333
--template-cache ""
--templates ""
--test-command "__TEST_SCRIPT__ __TEST_NAME__ >& /dev/null"
--test-script "./test.sh"
--tournament-size 2
--tweet false
--uniq true
--valgrind false
--variants-exchanged 50
uname -a: Linux domU-12-31-39-0B-B8-D6 2.6.34.7-61.fc13.i686.PAE #1 SMP Tue Oct 19 04:24:06 UTC 2010 i686 i686 i386 GNU/Linux
date: Tue May  7 23:32:02 EDT 2013
id: uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel) context=system_u:system_r:kernel_t:s0
cat /etc/redhat-release: Fedora release 13 (Goddard)
grep 'model name' /proc/cpuinfo: model name	: Intel(R) Xeon(R) CPU           E5410  @ 2.33GHz
grep 'MemTotal' /proc/meminfo: MemTotal:        1747596 kB
grep 'SwapTotal' /proc/meminfo: SwapTotal:             0 kB
cilRep: preprocessing IO function signatures: /tmp/tmp2d932c.c /tmp/tmp017c73.c
cilRep: done preprocessing IO function signatures
Exception in loading: Sys_error("default.cache: No such file or directory")
cilrep: from_source: pre: stmt_count = 1
cilRep: preprocessed/Python/ceval.c: parsing
cilRep: preprocessed/Python/ceval.c: parsed (0.683249 MB)
cilRep: computing liveness
Bug: BF(Liveness): stmtStartData is not initialized for -1: _ready: 
#line 399 "Python/ceval_gil.h"
tmp___2 = pthread_mutex_lock(& switch_mutex);
Liveness failed on function:
 static void take_gil(PyThreadState *tstate ) 
{ int err ;
  int *tmp ;
  int tmp___0 ;
  _Py_atomic_int *atomic_val ;
  int result ;
  int volatile   *volatile_data ;
  _Py_memory_order order ;
  int timed_out ;
  unsigned long saved_switchnum ;
  int r ;
  struct timespec ts ;
  struct timeval deadline ;
  unsigned long tmp___1 ;
  _Py_atomic_int *atomic_val___0 ;
  int new_val ;
  int volatile   *volatile_data___0 ;
  _Py_memory_order order___0 ;
  _Py_atomic_int *atomic_val___1 ;
  int new_val___0 ;
  int volatile   *volatile_data___1 ;
  _Py_memory_order order___1 ;
  _Py_atomic_int *atomic_val___2 ;
  int result___0 ;
  int volatile   *volatile_data___2 ;
  _Py_memory_order order___2 ;
  _Py_atomic_int *atomic_val___3 ;
  int result___1 ;
  int volatile   *volatile_data___3 ;
  _Py_memory_order order___3 ;
  int tmp___2 ;
  _Py_atomic_int *atomic_val___4 ;
  int new_val___1 ;
  int volatile   *volatile_data___4 ;
  _Py_memory_order order___4 ;
  _Py_atomic_address *atomic_val___5 ;
  void *new_val___2 ;
  void * volatile  *volatile_data___5 ;
  _Py_memory_order order___5 ;
  _Py_atomic_address *atomic_val___6 ;
  void *result___2 ;
  void * volatile  *volatile_data___6 ;
  _Py_memory_order order___6 ;
  int tmp___3 ;
  int tmp___4 ;
  _Py_atomic_int *atomic_val___7 ;
  int new_val___3 ;
  int volatile   *volatile_data___7 ;
  _Py_memory_order order___7 ;
  _Py_atomic_int *atomic_val___8 ;
  int new_val___4 ;
  _Py_atomic_int *atomic_val___9 ;
  int result___3 ;
  int volatile   *volatile_data___8 ;
  _Py_memory_order order___8 ;
  _Py_atomic_int *atomic_val___10 ;
  int result___4 ;
  int volatile   *volatile_data___9 ;
  _Py_memory_order order___9 ;
  int volatile   *volatile_data___10 ;
  _Py_memory_order order___10 ;
  _Py_atomic_int *atomic_val___11 ;
  int result___5 ;
  int volatile   *volatile_data___11 ;
  _Py_memory_order order___11 ;
  int tmp___5 ;
  int *tmp___6 ;

  {
   681: /* CIL Label */ 
#line 373
  if ((unsigned int )tstate == (unsigned int )((void *)0)) {
#line 374
    Py_FatalError("take_gil: NULL tstate");
  } else {

  }
   682: /* CIL Label */ 
#line 376
  tmp = __errno_location();
   683: /* CIL Label */ 
#line 376
  err = *tmp;
   684: /* CIL Label */ 
#line 377
  tmp___0 = pthread_mutex_lock(& gil_mutex);
   685: /* CIL Label */ 
#line 377
  if (tmp___0) {
#line 377
    Py_FatalError("pthread_mutex_lock(gil_mutex) failed");
  } else {

  }
   686: /* CIL Label */ 
#line 379
  atomic_val = & gil_locked;
   687: /* CIL Label */ 
#line 379
  volatile_data = (int volatile   *)(& atomic_val->_value);
   688: /* CIL Label */ 
#line 379
  order = (_Py_memory_order )0;
   689: /* CIL Label */ 
#line 379
  _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val, order);
   0: /* CIL Label */ 
#line 379
  switch ((int )order) {
  case 2: 
  case 3: 
  case 4: 
#line 379
  _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 379
  break;
  default: ;
#line 379
  break;
  }
   690: /* CIL Label */ 
#line 379
  result = (int )*volatile_data;
   0: /* CIL Label */ 
#line 379
  switch ((int )order) {
  case 1: 
  case 3: 
  case 4: 
#line 379
  _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 379
  break;
  default: ;
#line 379
  break;
  }
   691: /* CIL Label */ 
#line 379
  if (result) {

  } else {
    goto _ready;
  }
   692: /* CIL Label */ 
#line 382
  while (1) {
#line 382
    atomic_val___3 = & gil_locked;
#line 382
    volatile_data___3 = (int volatile   *)(& atomic_val___3->_value);
#line 382
    order___3 = (_Py_memory_order )0;
#line 382
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___3, order___3);
#line 382
    switch ((int )order___3) {
    case 2: 
    case 3: 
    case 4: 
#line 382
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 382
    break;
    default: ;
#line 382
    break;
    }
#line 382
    result___1 = (int )*volatile_data___3;
#line 382
    switch ((int )order___3) {
    case 1: 
    case 3: 
    case 4: 
#line 382
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 382
    break;
    default: ;
#line 382
    break;
    }
#line 382
    if (result___1) {

    } else {
#line 382
      break;
    }
#line 383
    timed_out = 0;
#line 386
    saved_switchnum = gil_switch_number;
#line 387
    gettimeofday((struct timeval */* __restrict  */)(& deadline),
                 (struct timezone */* __restrict  */)((struct timezone *)((void *)0)));
#line 387
    while (1) {
#line 387
      if (gil_interval >= 1UL) {
#line 387
        tmp___1 = gil_interval;
      } else {
#line 387
        tmp___1 = 1UL;
      }
#line 387
      deadline.tv_usec += (long )tmp___1;
#line 387
      deadline.tv_sec += deadline.tv_usec / 1000000L;
#line 387
      deadline.tv_usec %= 1000000L;
#line 387
      break;
    }
#line 387
    ts.tv_sec = deadline.tv_sec;
#line 387
    ts.tv_nsec = deadline.tv_usec * 1000L;
#line 387
    r = pthread_cond_timedwait((pthread_cond_t */* __restrict  */)(& gil_cond),
                               (pthread_mutex_t */* __restrict  */)(& gil_mutex),
                               (struct timespec  const  */* __restrict  */)(& ts));
#line 387
    if (r == 110) {
#line 387
      timed_out = 1;
    } else {
#line 387
      if (r) {
#line 387
        Py_FatalError("pthread_cond_timedwait(gil_cond) failed");
      } else {
#line 387
        timed_out = 0;
      }
    }
#line 391
    if (timed_out) {
#line 391
      atomic_val___2 = & gil_locked;
#line 391
      volatile_data___2 = (int volatile   *)(& atomic_val___2->_value);
#line 391
      order___2 = (_Py_memory_order )0;
#line 391
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___2,
                                order___2);
#line 391
      switch ((int )order___2) {
      case 2: 
      case 3: 
      case 4: 
#line 391
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 391
      break;
      default: ;
#line 391
      break;
      }
#line 391
      result___0 = (int )*volatile_data___2;
#line 391
      switch ((int )order___2) {
      case 1: 
      case 3: 
      case 4: 
#line 391
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 391
      break;
      default: ;
#line 391
      break;
      }
#line 391
      if (result___0) {
#line 391
        if (gil_switch_number == saved_switchnum) {
#line 393
          while (1) {
#line 393
            atomic_val___0 = & gil_drop_request;
#line 393
            new_val = 1;
#line 393
            volatile_data___0 = (int volatile   *)(& atomic_val___0->_value);
#line 393
            order___0 = (_Py_memory_order )0;
#line 393
            _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___0,
                                      order___0);
#line 393
            switch ((int )order___0) {
            case 2: 
#line 393
            _Py_atomic_signal_fence((enum _Py_memory_order )2);
            case 0: 
#line 393
            *volatile_data___0 = (int volatile   )new_val;
#line 393
            break;
            case 1: 
            case 3: 
            case 4: 
#line 393
            __asm__  volatile   ("xchg %0, %1": "+r" (new_val): "m" (atomic_val___0->_value): "memory");
#line 393
            break;
            }
#line 393
            atomic_val___1 = & eval_breaker;
#line 393
            new_val___0 = 1;
#line 393
            volatile_data___1 = (int volatile   *)(& atomic_val___1->_value);
#line 393
            order___1 = (_Py_memory_order )0;
#line 393
            _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___1,
                                      order___1);
#line 393
            switch ((int )order___1) {
            case 2: 
#line 393
            _Py_atomic_signal_fence((enum _Py_memory_order )2);
            case 0: 
#line 393
            *volatile_data___1 = (int volatile   )new_val___0;
#line 393
            break;
            case 1: 
            case 3: 
            case 4: 
#line 393
            __asm__  volatile   ("xchg %0, %1": "+r" (new_val___0): "m" (atomic_val___1->_value): "memory");
#line 393
            break;
            }
#line 393
            break;
          }
        } else {

        }
      } else {

      }
    } else {

    }
  }
   693: /* CIL Label */ 
  _ready: 
#line 399
  tmp___2 = pthread_mutex_lock(& switch_mutex);
   694: /* CIL Label */ 
#line 399
  if (tmp___2) {
#line 399
    Py_FatalError("pthread_mutex_lock(switch_mutex) failed");
  } else {

  }
   695: /* CIL Label */ 
#line 402
  atomic_val___4 = & gil_locked;
   696: /* CIL Label */ 
#line 402
  new_val___1 = 1;
   697: /* CIL Label */ 
#line 402
  volatile_data___4 = (int volatile   *)(& atomic_val___4->_value);
   698: /* CIL Label */ 
#line 402
  order___4 = (_Py_memory_order )0;
   699: /* CIL Label */ 
#line 402
  _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___4, order___4);
   0: /* CIL Label */ 
#line 402
  switch ((int )order___4) {
  case 2: 
#line 402
  _Py_atomic_signal_fence((enum _Py_memory_order )2);
  case 0: 
#line 402
  *volatile_data___4 = (int volatile   )new_val___1;
#line 402
  break;
  case 1: 
  case 3: 
  case 4: 
#line 402
  __asm__  volatile   ("xchg %0, %1": "+r" (new_val___1): "m" (atomic_val___4->_value): "memory");
#line 402
  break;
  }
   700: /* CIL Label */ 
#line 405
  atomic_val___6 = & gil_last_holder;
   701: /* CIL Label */ 
#line 405
  volatile_data___6 = (void * volatile  *)(& atomic_val___6->_value);
   702: /* CIL Label */ 
#line 405
  order___6 = (_Py_memory_order )0;
   703: /* CIL Label */ 
#line 405
  _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___6, order___6);
   0: /* CIL Label */ 
#line 405
  switch ((int )order___6) {
  case 2: 
  case 3: 
  case 4: 
#line 405
  _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 405
  break;
  default: ;
#line 405
  break;
  }
   704: /* CIL Label */ 
#line 405
  result___2 = (void *)*volatile_data___6;
   0: /* CIL Label */ 
#line 405
  switch ((int )order___6) {
  case 1: 
  case 3: 
  case 4: 
#line 405
  _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 405
  break;
  default: ;
#line 405
  break;
  }
   705: /* CIL Label */ 
#line 405
  if ((unsigned int )tstate != (unsigned int )result___2) {
#line 406
    atomic_val___5 = & gil_last_holder;
#line 406
    new_val___2 = (void *)tstate;
#line 406
    volatile_data___5 = (void * volatile  *)(& atomic_val___5->_value);
#line 406
    order___5 = (_Py_memory_order )0;
#line 406
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___5, order___5);
#line 406
    switch ((int )order___5) {
    case 2: 
#line 406
    _Py_atomic_signal_fence((enum _Py_memory_order )2);
    case 0: 
#line 406
    *volatile_data___5 = (void */* volatile  */)new_val___2;
#line 406
    break;
    case 1: 
    case 3: 
    case 4: 
#line 406
    __asm__  volatile   ("xchg %0, %1": "+r" (new_val___2): "m" (atomic_val___5->_value): "memory");
#line 406
    break;
    }
#line 407
    gil_switch_number ++;
  } else {

  }
   706: /* CIL Label */ 
#line 411
  tmp___3 = pthread_cond_signal(& switch_cond);
   707: /* CIL Label */ 
#line 411
  if (tmp___3) {
#line 411
    Py_FatalError("pthread_cond_signal(switch_cond) failed");
  } else {

  }
   708: /* CIL Label */ 
#line 412
  tmp___4 = pthread_mutex_unlock(& switch_mutex);
   709: /* CIL Label */ 
#line 412
  if (tmp___4) {
#line 412
    Py_FatalError("pthread_mutex_unlock(switch_mutex) failed");
  } else {

  }
   710: /* CIL Label */ 
#line 414
  atomic_val___11 = & gil_drop_request;
   711: /* CIL Label */ 
#line 414
  volatile_data___11 = (int volatile   *)(& atomic_val___11->_value);
   712: /* CIL Label */ 
#line 414
  order___11 = (_Py_memory_order )0;
   713: /* CIL Label */ 
#line 414
  _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___11, order___11);
   0: /* CIL Label */ 
#line 414
  switch ((int )order___11) {
  case 2: 
  case 3: 
  case 4: 
#line 414
  _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 414
  break;
  default: ;
#line 414
  break;
  }
   714: /* CIL Label */ 
#line 414
  result___5 = (int )*volatile_data___11;
   0: /* CIL Label */ 
#line 414
  switch ((int )order___11) {
  case 1: 
  case 3: 
  case 4: 
#line 414
  _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 414
  break;
  default: ;
#line 414
  break;
  }
   715: /* CIL Label */ 
#line 414
  if (result___5) {
#line 415
    while (1) {
#line 415
      atomic_val___7 = & gil_drop_request;
#line 415
      new_val___3 = 0;
#line 415
      volatile_data___7 = (int volatile   *)(& atomic_val___7->_value);
#line 415
      order___7 = (_Py_memory_order )0;
#line 415
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___7,
                                order___7);
#line 415
      switch ((int )order___7) {
      case 2: 
#line 415
      _Py_atomic_signal_fence((enum _Py_memory_order )2);
      case 0: 
#line 415
      *volatile_data___7 = (int volatile   )new_val___3;
#line 415
      break;
      case 1: 
      case 3: 
      case 4: 
#line 415
      __asm__  volatile   ("xchg %0, %1": "+r" (new_val___3): "m" (atomic_val___7->_value): "memory");
#line 415
      break;
      }
#line 415
      atomic_val___8 = & eval_breaker;
#line 415
      atomic_val___9 = & gil_drop_request;
#line 415
      volatile_data___8 = (int volatile   *)(& atomic_val___9->_value);
#line 415
      order___8 = (_Py_memory_order )0;
#line 415
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___9,
                                order___8);
#line 415
      switch ((int )order___8) {
      case 2: 
      case 3: 
      case 4: 
#line 415
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 415
      break;
      default: ;
#line 415
      break;
      }
#line 415
      result___3 = (int )*volatile_data___8;
#line 415
      switch ((int )order___8) {
      case 1: 
      case 3: 
      case 4: 
#line 415
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 415
      break;
      default: ;
#line 415
      break;
      }
#line 415
      atomic_val___10 = & pendingcalls_to_do;
#line 415
      volatile_data___9 = (int volatile   *)(& atomic_val___10->_value);
#line 415
      order___9 = (_Py_memory_order )0;
#line 415
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___10,
                                order___9);
#line 415
      switch ((int )order___9) {
      case 2: 
      case 3: 
      case 4: 
#line 415
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 415
      break;
      default: ;
#line 415
      break;
      }
#line 415
      result___4 = (int )*volatile_data___9;
#line 415
      switch ((int )order___9) {
      case 1: 
      case 3: 
      case 4: 
#line 415
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 415
      break;
      default: ;
#line 415
      break;
      }
#line 415
      new_val___4 = (result___3 | result___4) | pending_async_exc;
#line 415
      volatile_data___10 = (int volatile   *)(& atomic_val___8->_value);
#line 415
      order___10 = (_Py_memory_order )0;
#line 415
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___8,
                                order___10);
#line 415
      switch ((int )order___10) {
      case 2: 
#line 415
      _Py_atomic_signal_fence((enum _Py_memory_order )2);
      case 0: 
#line 415
      *volatile_data___10 = (int volatile   )new_val___4;
#line 415
      break;
      case 1: 
      case 3: 
      case 4: 
#line 415
      __asm__  volatile   ("xchg %0, %1": "+r" (new_val___4): "m" (atomic_val___8->_value): "memory");
#line 415
      break;
      }
#line 415
      break;
    }
  } else {

  }
   716: /* CIL Label */ 
#line 417
  if ((unsigned int )tstate->async_exc != (unsigned int )((void *)0)) {
#line 418
    _PyEval_SignalAsyncExc();
  } else {

  }
   717: /* CIL Label */ 
#line 421
  tmp___5 = pthread_mutex_unlock(& gil_mutex);
   718: /* CIL Label */ 
#line 421
  if (tmp___5) {
#line 421
    Py_FatalError("pthread_mutex_unlock(gil_mutex) failed");
  } else {

  }
   719: /* CIL Label */ 
#line 422
  tmp___6 = __errno_location();
   720: /* CIL Label */ 
#line 422
  *tmp___6 = err;
   721: /* CIL Label */ 
#line 423
  return;
}
}

cilRep: liveness failure for take_gil: Errormsg.Error
Bug: BF(Liveness): stmtStartData is not initialized for -1: _L___6: /* CIL Label */ 
#line 3005 "Python/ceval.c"
tmp___161 = call_trace(tstate->c_tracefunc, tstate->c_traceobj, f, 3, retval);
Liveness failed on function:
 PyObject *PyEval_EvalFrameEx(struct _frame *f , int throwflag ) 
{ register PyObject **stack_pointer ;
  register unsigned char *next_instr ;
  register int opcode ;
  register int oparg ;
  register enum why_code why ;
  register int err ;
  register PyObject *x ;
  register PyObject *v ;
  register PyObject *w ;
  register PyObject *u ;
  register PyObject *t ;
  register PyObject **fastlocals ;
  register PyObject **freevars ;
  PyObject *retval ;
  PyThreadState *tstate ;
  _Py_atomic_address *atomic_val ;
  void *result ;
  void * volatile  *volatile_data ;
  _Py_memory_order order ;
  PyCodeObject *co ;
  int instr_ub ;
  int instr_lb ;
  int instr_prev ;
  unsigned char *first_instr ;
  PyObject *names ;
  PyObject *consts ;
  _Py_atomic_address *atomic_val___0 ;
  void *result___0 ;
  void * volatile  *volatile_data___0 ;
  _Py_memory_order order___0 ;
  int tmp ;
  int tmp___0 ;
  int tmp___1 ;
  PyObject *tmp___2 ;
  PyObject *type ;
  PyObject *value ;
  PyObject *traceback ;
  int tmp___3 ;
  _Py_atomic_int *atomic_val___1 ;
  int result___1 ;
  int volatile   *volatile_data___1 ;
  _Py_memory_order order___1 ;
  PyThreadState *tmp___4 ;
  PyThreadState *tmp___5 ;
  _Py_atomic_int *atomic_val___2 ;
  int result___2 ;
  int volatile   *volatile_data___2 ;
  _Py_memory_order order___2 ;
  _Py_atomic_int *atomic_val___3 ;
  int new_val ;
  _Py_atomic_int *atomic_val___4 ;
  int result___3 ;
  int volatile   *volatile_data___3 ;
  _Py_memory_order order___3 ;
  _Py_atomic_int *atomic_val___5 ;
  int result___4 ;
  int volatile   *volatile_data___4 ;
  _Py_memory_order order___4 ;
  int volatile   *volatile_data___5 ;
  _Py_memory_order order___5 ;
  _Py_atomic_int *atomic_val___6 ;
  int result___5 ;
  int volatile   *volatile_data___6 ;
  _Py_memory_order order___6 ;
  unsigned char *tmp___6 ;
  unsigned char *tmp___7 ;
  int __compgoto ;
  PyObject **tmp___8 ;
  unsigned char *tmp___9 ;
  PyObject *tmp___10 ;
  PyObject **tmp___11 ;
  unsigned char *tmp___12 ;
  PyObject *tmp___13 ;
  unsigned char *tmp___14 ;
  unsigned char *tmp___15 ;
  unsigned char *tmp___16 ;
  unsigned char *tmp___17 ;
  PyObject **tmp___18 ;
  unsigned char *tmp___19 ;
  unsigned char *tmp___20 ;
  unsigned char *tmp___21 ;
  _Py_atomic_int *atomic_val___7 ;
  int result___6 ;
  int volatile   *volatile_data___7 ;
  _Py_memory_order order___7 ;
  unsigned char *tmp___22 ;
  _Py_atomic_int *atomic_val___8 ;
  int result___7 ;
  int volatile   *volatile_data___8 ;
  _Py_memory_order order___8 ;
  unsigned char *tmp___23 ;
  _Py_atomic_int *atomic_val___9 ;
  int result___8 ;
  int volatile   *volatile_data___9 ;
  _Py_memory_order order___9 ;
  unsigned char *tmp___24 ;
  _Py_atomic_int *atomic_val___10 ;
  int result___9 ;
  int volatile   *volatile_data___10 ;
  _Py_memory_order order___10 ;
  unsigned char *tmp___25 ;
  _Py_atomic_int *atomic_val___11 ;
  int result___10 ;
  int volatile   *volatile_data___11 ;
  _Py_memory_order order___11 ;
  unsigned char *tmp___26 ;
  _Py_atomic_int *atomic_val___12 ;
  int result___11 ;
  int volatile   *volatile_data___12 ;
  _Py_memory_order order___12 ;
  unsigned char *tmp___27 ;
  _Py_atomic_int *atomic_val___13 ;
  int result___12 ;
  int volatile   *volatile_data___13 ;
  _Py_memory_order order___13 ;
  unsigned char *tmp___28 ;
  _Py_atomic_int *atomic_val___14 ;
  int result___13 ;
  int volatile   *volatile_data___14 ;
  _Py_memory_order order___14 ;
  unsigned char *tmp___29 ;
  _Py_atomic_int *atomic_val___15 ;
  int result___14 ;
  int volatile   *volatile_data___15 ;
  _Py_memory_order order___15 ;
  unsigned char *tmp___30 ;
  _Py_atomic_int *atomic_val___16 ;
  int result___15 ;
  int volatile   *volatile_data___16 ;
  _Py_memory_order order___16 ;
  unsigned char *tmp___31 ;
  _Py_atomic_int *atomic_val___17 ;
  int result___16 ;
  int volatile   *volatile_data___17 ;
  _Py_memory_order order___17 ;
  unsigned char *tmp___32 ;
  _Py_atomic_int *atomic_val___18 ;
  int result___17 ;
  int volatile   *volatile_data___18 ;
  _Py_memory_order order___18 ;
  unsigned char *tmp___33 ;
  _Py_atomic_int *atomic_val___19 ;
  int result___18 ;
  int volatile   *volatile_data___19 ;
  _Py_memory_order order___19 ;
  unsigned char *tmp___34 ;
  _Py_atomic_int *atomic_val___20 ;
  int result___19 ;
  int volatile   *volatile_data___20 ;
  _Py_memory_order order___20 ;
  unsigned char *tmp___35 ;
  _Py_atomic_int *atomic_val___21 ;
  int result___20 ;
  int volatile   *volatile_data___21 ;
  _Py_memory_order order___21 ;
  unsigned char *tmp___36 ;
  _Py_atomic_int *atomic_val___22 ;
  int result___21 ;
  int volatile   *volatile_data___22 ;
  _Py_memory_order order___22 ;
  unsigned char *tmp___37 ;
  _Py_atomic_int *atomic_val___23 ;
  int result___22 ;
  int volatile   *volatile_data___23 ;
  _Py_memory_order order___23 ;
  unsigned char *tmp___38 ;
  _Py_atomic_int *atomic_val___24 ;
  int result___23 ;
  int volatile   *volatile_data___24 ;
  _Py_memory_order order___24 ;
  unsigned char *tmp___39 ;
  _Py_atomic_int *atomic_val___25 ;
  int result___24 ;
  int volatile   *volatile_data___25 ;
  _Py_memory_order order___25 ;
  unsigned char *tmp___40 ;
  _Py_atomic_int *atomic_val___26 ;
  int result___25 ;
  int volatile   *volatile_data___26 ;
  _Py_memory_order order___26 ;
  unsigned char *tmp___41 ;
  _Py_atomic_int *atomic_val___27 ;
  int result___26 ;
  int volatile   *volatile_data___27 ;
  _Py_memory_order order___27 ;
  unsigned char *tmp___42 ;
  _Py_atomic_int *atomic_val___28 ;
  int result___27 ;
  int volatile   *volatile_data___28 ;
  _Py_memory_order order___28 ;
  unsigned char *tmp___43 ;
  _Py_atomic_int *atomic_val___29 ;
  int result___28 ;
  int volatile   *volatile_data___29 ;
  _Py_memory_order order___29 ;
  unsigned char *tmp___44 ;
  _Py_atomic_int *atomic_val___30 ;
  int result___29 ;
  int volatile   *volatile_data___30 ;
  _Py_memory_order order___30 ;
  unsigned char *tmp___45 ;
  _Py_atomic_int *atomic_val___31 ;
  int result___30 ;
  int volatile   *volatile_data___31 ;
  _Py_memory_order order___31 ;
  unsigned char *tmp___46 ;
  _Py_atomic_int *atomic_val___32 ;
  int result___31 ;
  int volatile   *volatile_data___32 ;
  _Py_memory_order order___32 ;
  unsigned char *tmp___47 ;
  _Py_atomic_int *atomic_val___33 ;
  int result___32 ;
  int volatile   *volatile_data___33 ;
  _Py_memory_order order___33 ;
  unsigned char *tmp___48 ;
  _Py_atomic_int *atomic_val___34 ;
  int result___33 ;
  int volatile   *volatile_data___34 ;
  _Py_memory_order order___34 ;
  unsigned char *tmp___49 ;
  _Py_atomic_int *atomic_val___35 ;
  int result___34 ;
  int volatile   *volatile_data___35 ;
  _Py_memory_order order___35 ;
  unsigned char *tmp___50 ;
  _Py_atomic_int *atomic_val___36 ;
  int result___35 ;
  int volatile   *volatile_data___36 ;
  _Py_memory_order order___36 ;
  unsigned char *tmp___51 ;
  _Py_atomic_int *atomic_val___37 ;
  int result___36 ;
  int volatile   *volatile_data___37 ;
  _Py_memory_order order___37 ;
  unsigned char *tmp___52 ;
  _Py_atomic_int *atomic_val___38 ;
  int result___37 ;
  int volatile   *volatile_data___38 ;
  _Py_memory_order order___38 ;
  unsigned char *tmp___53 ;
  _Py_atomic_int *atomic_val___39 ;
  int result___38 ;
  int volatile   *volatile_data___39 ;
  _Py_memory_order order___39 ;
  unsigned char *tmp___54 ;
  _Py_atomic_int *atomic_val___40 ;
  int result___39 ;
  int volatile   *volatile_data___40 ;
  _Py_memory_order order___40 ;
  unsigned char *tmp___55 ;
  _Py_atomic_int *atomic_val___41 ;
  int result___40 ;
  int volatile   *volatile_data___41 ;
  _Py_memory_order order___41 ;
  PyObject *tmp___56 ;
  PyTryBlock *b ;
  PyTryBlock *tmp___57 ;
  PyObject *type___0 ;
  PyObject *value___0 ;
  PyObject *traceback___0 ;
  unsigned char *tmp___58 ;
  _Py_atomic_int *atomic_val___42 ;
  int result___41 ;
  int volatile   *volatile_data___42 ;
  _Py_memory_order order___42 ;
  PyTryBlock *b___0 ;
  PyTryBlock *tmp___59 ;
  PyObject *v___0 ;
  unsigned char *tmp___60 ;
  _Py_atomic_int *atomic_val___43 ;
  int result___42 ;
  int volatile   *volatile_data___43 ;
  _Py_memory_order order___43 ;
  long tmp___61 ;
  PyTryBlock *b___1 ;
  PyTryBlock *tmp___62 ;
  PyObject *type___1 ;
  PyObject *value___1 ;
  PyObject *traceback___1 ;
  PyObject **tmp___63 ;
  unsigned char *tmp___64 ;
  _Py_atomic_int *atomic_val___44 ;
  int result___43 ;
  int volatile   *volatile_data___44 ;
  _Py_memory_order order___44 ;
  PyObject **items ;
  PyObject **tmp___65 ;
  int tmp___66 ;
  unsigned char *tmp___67 ;
  _Py_atomic_int *atomic_val___45 ;
  int result___44 ;
  int volatile   *volatile_data___45 ;
  _Py_memory_order order___45 ;
  PyObject **items___0 ;
  PyObject **tmp___68 ;
  int tmp___69 ;
  int tmp___70 ;
  int totalargs ;
  int tmp___71 ;
  unsigned char *tmp___72 ;
  _Py_atomic_int *atomic_val___46 ;
  int result___45 ;
  int volatile   *volatile_data___46 ;
  _Py_memory_order order___46 ;
  unsigned char *tmp___73 ;
  _Py_atomic_int *atomic_val___47 ;
  int result___46 ;
  int volatile   *volatile_data___47 ;
  _Py_memory_order order___47 ;
  int tmp___74 ;
  PyObject *tmp___75 ;
  PyObject **tmp___76 ;
  unsigned char *tmp___77 ;
  _Py_atomic_int *atomic_val___48 ;
  int result___47 ;
  int volatile   *volatile_data___48 ;
  _Py_memory_order order___48 ;
  Py_hash_t hash ;
  PyDictObject *d ;
  PyDictEntry *e ;
  PyObject **tmp___78 ;
  unsigned char *tmp___79 ;
  _Py_atomic_int *atomic_val___49 ;
  int result___48 ;
  int volatile   *volatile_data___49 ;
  _Py_memory_order order___49 ;
  PyObject **tmp___80 ;
  unsigned char *tmp___81 ;
  _Py_atomic_int *atomic_val___50 ;
  int result___49 ;
  int volatile   *volatile_data___50 ;
  _Py_memory_order order___50 ;
  PyObject **tmp___82 ;
  unsigned char *tmp___83 ;
  _Py_atomic_int *atomic_val___51 ;
  int result___50 ;
  int volatile   *volatile_data___51 ;
  _Py_memory_order order___51 ;
  PyObject *tmp___84 ;
  unsigned char *tmp___85 ;
  _Py_atomic_int *atomic_val___52 ;
  int result___51 ;
  int volatile   *volatile_data___52 ;
  _Py_memory_order order___52 ;
  PyObject *tmp___86 ;
  unsigned char *tmp___87 ;
  _Py_atomic_int *atomic_val___53 ;
  int result___52 ;
  int volatile   *volatile_data___53 ;
  _Py_memory_order order___53 ;
  PyObject **tmp___88 ;
  unsigned char *tmp___89 ;
  _Py_atomic_int *atomic_val___54 ;
  int result___53 ;
  int volatile   *volatile_data___54 ;
  _Py_memory_order order___54 ;
  PyObject **tmp___90 ;
  unsigned char *tmp___91 ;
  _Py_atomic_int *atomic_val___55 ;
  int result___54 ;
  int volatile   *volatile_data___55 ;
  _Py_memory_order order___55 ;
  unsigned char *tmp___92 ;
  _Py_atomic_int *atomic_val___56 ;
  int result___55 ;
  int volatile   *volatile_data___56 ;
  _Py_memory_order order___56 ;
  PyObject **tmp___93 ;
  unsigned char *tmp___94 ;
  _Py_atomic_int *atomic_val___57 ;
  int result___56 ;
  int volatile   *volatile_data___57 ;
  _Py_memory_order order___57 ;
  PyObject **tmp___95 ;
  unsigned char *tmp___96 ;
  _Py_atomic_int *atomic_val___58 ;
  int result___57 ;
  int volatile   *volatile_data___58 ;
  _Py_memory_order order___58 ;
  PyObject **tmp___97 ;
  unsigned char *tmp___98 ;
  _Py_atomic_int *atomic_val___59 ;
  int result___58 ;
  int volatile   *volatile_data___59 ;
  _Py_memory_order order___59 ;
  PyObject **tmp___99 ;
  unsigned char *tmp___100 ;
  _Py_atomic_int *atomic_val___60 ;
  int result___59 ;
  int volatile   *volatile_data___60 ;
  _Py_memory_order order___60 ;
  unsigned char *tmp___101 ;
  _Py_atomic_int *atomic_val___61 ;
  int result___60 ;
  int volatile   *volatile_data___61 ;
  _Py_memory_order order___61 ;
  unsigned char *tmp___102 ;
  _Py_atomic_int *atomic_val___62 ;
  int result___61 ;
  int volatile   *volatile_data___62 ;
  _Py_memory_order order___62 ;
  unsigned char *tmp___103 ;
  _Py_atomic_int *atomic_val___63 ;
  int result___62 ;
  int volatile   *volatile_data___63 ;
  _Py_memory_order order___63 ;
  unsigned char *tmp___104 ;
  _Py_atomic_int *atomic_val___64 ;
  int result___63 ;
  int volatile   *volatile_data___64 ;
  _Py_memory_order order___64 ;
  PyObject *tmp___105 ;
  PyObject *tmp___106 ;
  long tmp___107 ;
  PyObject *tmp___108 ;
  unsigned char *tmp___109 ;
  _Py_atomic_int *atomic_val___65 ;
  int result___64 ;
  int volatile   *volatile_data___65 ;
  _Py_memory_order order___65 ;
  unsigned char *tmp___110 ;
  _Py_atomic_int *atomic_val___66 ;
  int result___65 ;
  int volatile   *volatile_data___66 ;
  _Py_memory_order order___66 ;
  PyObject **tmp___111 ;
  unsigned char *tmp___112 ;
  _Py_atomic_int *atomic_val___67 ;
  int result___66 ;
  int volatile   *volatile_data___67 ;
  _Py_memory_order order___67 ;
  unsigned char *tmp___113 ;
  unsigned char *tmp___114 ;
  unsigned char *tmp___115 ;
  unsigned char *tmp___116 ;
  _Py_atomic_int *atomic_val___68 ;
  int result___67 ;
  int volatile   *volatile_data___68 ;
  _Py_memory_order order___68 ;
  unsigned char *tmp___117 ;
  unsigned char *tmp___118 ;
  unsigned char *tmp___119 ;
  _Py_atomic_int *atomic_val___69 ;
  int result___68 ;
  int volatile   *volatile_data___69 ;
  _Py_memory_order order___69 ;
  unsigned char *tmp___120 ;
  unsigned char *tmp___121 ;
  unsigned char *tmp___122 ;
  _Py_atomic_int *atomic_val___70 ;
  int result___69 ;
  int volatile   *volatile_data___70 ;
  _Py_memory_order order___70 ;
  unsigned char *tmp___123 ;
  unsigned char *tmp___124 ;
  unsigned char *tmp___125 ;
  _Py_atomic_int *atomic_val___71 ;
  int result___70 ;
  int volatile   *volatile_data___71 ;
  _Py_memory_order order___71 ;
  unsigned char *tmp___126 ;
  _Py_atomic_int *atomic_val___72 ;
  int result___71 ;
  int volatile   *volatile_data___72 ;
  _Py_memory_order order___72 ;
  unsigned char *tmp___127 ;
  _Py_atomic_int *atomic_val___73 ;
  int result___72 ;
  int volatile   *volatile_data___73 ;
  _Py_memory_order order___73 ;
  PyObject **tmp___128 ;
  unsigned char *tmp___129 ;
  _Py_atomic_int *atomic_val___74 ;
  int result___73 ;
  int volatile   *volatile_data___74 ;
  _Py_memory_order order___74 ;
  int tmp___130 ;
  PyObject *tmp___131 ;
  unsigned char *tmp___132 ;
  _Py_atomic_int *atomic_val___75 ;
  int result___74 ;
  int volatile   *volatile_data___75 ;
  _Py_memory_order order___75 ;
  unsigned char *tmp___133 ;
  _Py_atomic_int *atomic_val___76 ;
  int result___75 ;
  int volatile   *volatile_data___76 ;
  _Py_memory_order order___76 ;
  PyObject **tmp___134 ;
  unsigned char *tmp___135 ;
  _Py_atomic_int *atomic_val___77 ;
  int result___76 ;
  int volatile   *volatile_data___77 ;
  _Py_memory_order order___77 ;
  PyObject *exit_func ;
  long tmp___136 ;
  PyObject *tp ;
  PyObject *exc ;
  PyObject *tb ;
  PyTryBlock *block ;
  PyObject **tmp___137 ;
  PyObject **sp ;
  PyObject **tmp___138 ;
  unsigned char *tmp___139 ;
  _Py_atomic_int *atomic_val___78 ;
  int result___77 ;
  int volatile   *volatile_data___78 ;
  _Py_memory_order order___78 ;
  int na ;
  int nk ;
  int flags ;
  int n ;
  PyObject **pfunc ;
  PyObject *func ;
  PyObject **sp___0 ;
  PyObject *self ;
  PyObject **tmp___140 ;
  unsigned char *tmp___141 ;
  _Py_atomic_int *atomic_val___79 ;
  int result___78 ;
  int volatile   *volatile_data___79 ;
  _Py_memory_order order___79 ;
  int posdefaults ;
  int kwdefaults ;
  int num_annotations ;
  int tmp___142 ;
  Py_ssize_t name_ix ;
  int tmp___143 ;
  int tmp___144 ;
  int tmp___145 ;
  PyObject **tmp___146 ;
  unsigned char *tmp___147 ;
  _Py_atomic_int *atomic_val___80 ;
  int result___79 ;
  int volatile   *volatile_data___80 ;
  _Py_memory_order order___80 ;
  unsigned char *tmp___148 ;
  int tmp___149 ;
  PyObject *tmp___150 ;
  PyTryBlock *b___2 ;
  long tmp___151 ;
  PyObject *type___2 ;
  PyObject *value___2 ;
  PyObject *traceback___2 ;
  PyObject *v___1 ;
  PyObject *exc___0 ;
  PyObject *val ;
  PyObject *tb___0 ;
  int handler ;
  PyObject **tmp___152 ;
  PyObject **tmp___153 ;
  PyObject **tmp___154 ;
  PyObject **tmp___155 ;
  PyObject **tmp___156 ;
  PyObject **tmp___157 ;
  PyObject **tmp___158 ;
  PyObject **tmp___159 ;
  PyObject **tmp___160 ;
  int tmp___161 ;
  int tmp___162 ;
  _Py_atomic_address *atomic_val___81 ;
  void *result___80 ;
  void * volatile  *volatile_data___81 ;
  _Py_memory_order order___81 ;
  _Py_atomic_address *atomic_val___82 ;
  void *result___81 ;
  void * volatile  *volatile_data___82 ;
  _Py_memory_order order___82 ;
  int tmp___163 ;

  {
   4803: /* CIL Label */ 
#line 798
  retval = (PyObject *)((void *)0);
   4804: /* CIL Label */ 
#line 799
  atomic_val = & _PyThreadState_Current;
   4805: /* CIL Label */ 
#line 799
  volatile_data = (void * volatile  *)(& atomic_val->_value);
   4806: /* CIL Label */ 
#line 799
  order = (_Py_memory_order )0;
   4807: /* CIL Label */ 
#line 799
  _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val, order);
   0: /* CIL Label */ 
#line 799
  switch ((int )order) {
  case 2: 
  case 3: 
  case 4: 
#line 799
  _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 799
  break;
  default: ;
#line 799
  break;
  }
   4808: /* CIL Label */ 
#line 799
  result = (void *)*volatile_data;
   0: /* CIL Label */ 
#line 799
  switch ((int )order) {
  case 1: 
  case 3: 
  case 4: 
#line 799
  _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 799
  break;
  default: ;
#line 799
  break;
  }
   4809: /* CIL Label */ 
#line 799
  tstate = (PyThreadState *)result;
   4810: /* CIL Label */ 
#line 809
  instr_ub = -1;
   4811: /* CIL Label */ 
#line 809
  instr_lb = 0;
   4812: /* CIL Label */ 
#line 809
  instr_prev = -1;
   4813: /* CIL Label */ 
#line 1140
  if ((unsigned int )f == (unsigned int )((void *)0)) {
#line 1141
    return ((PyObject *)((void *)0));
  } else {

  }
   4814: /* CIL Label */ 
#line 1144
  atomic_val___0 = & _PyThreadState_Current;
   4815: /* CIL Label */ 
#line 1144
  volatile_data___0 = (void * volatile  *)(& atomic_val___0->_value);
   4816: /* CIL Label */ 
#line 1144
  order___0 = (_Py_memory_order )0;
   4817: /* CIL Label */ 
#line 1144
  _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___0, order___0);
   0: /* CIL Label */ 
#line 1144
  switch ((int )order___0) {
  case 2: 
  case 3: 
  case 4: 
#line 1144
  _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1144
  break;
  default: ;
#line 1144
  break;
  }
   4818: /* CIL Label */ 
#line 1144
  result___0 = (void *)*volatile_data___0;
   0: /* CIL Label */ 
#line 1144
  switch ((int )order___0) {
  case 1: 
  case 3: 
  case 4: 
#line 1144
  _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1144
  break;
  default: ;
#line 1144
  break;
  }
   4819: /* CIL Label */ 
#line 1144
  (((PyThreadState *)result___0)->recursion_depth) ++;
   4820: /* CIL Label */ 
#line 1144
  if (((PyThreadState *)result___0)->recursion_depth > _Py_CheckRecursionLimit) {
#line 1144
    tmp = _Py_CheckRecursiveCall((char *)"");
#line 1144
    if (tmp) {
#line 1145
      return ((PyObject *)((void *)0));
    } else {

    }
  } else {

  }
   4821: /* CIL Label */ 
#line 1147
  tstate->frame = f;
   4822: /* CIL Label */ 
#line 1149
  if (tstate->use_tracing) {
#line 1150
    if ((unsigned int )tstate->c_tracefunc != (unsigned int )((void *)0)) {
#line 1164
      tmp___0 = call_trace_protected(tstate->c_tracefunc, tstate->c_traceobj, f,
                                     0, & _Py_NoneStruct);
#line 1164
      if (tmp___0) {
        goto  4842;
      } else {

      }
    } else {

    }
#line 1171
    if ((unsigned int )tstate->c_profilefunc != (unsigned int )((void *)0)) {
#line 1174
      tmp___1 = call_trace_protected(tstate->c_profilefunc,
                                     tstate->c_profileobj, f, 0,
                                     & _Py_NoneStruct);
#line 1174
      if (tmp___1) {
        goto  4842;
      } else {

      }
    } else {

    }
  } else {

  }
   4823: /* CIL Label */ 
#line 1183
  co = f->f_code;
   4824: /* CIL Label */ 
#line 1184
  names = co->co_names;
   4825: /* CIL Label */ 
#line 1185
  consts = co->co_consts;
   4826: /* CIL Label */ 
#line 1186
  fastlocals = f->f_localsplus;
   4827: /* CIL Label */ 
#line 1187
  freevars = f->f_localsplus + co->co_nlocals;
   4828: /* CIL Label */ 
#line 1188
  first_instr = (unsigned char *)(((PyBytesObject *)co->co_code)->ob_sval);
   4829: /* CIL Label */ 
#line 1206
  next_instr = (first_instr + f->f_lasti) + 1;
   4830: /* CIL Label */ 
#line 1207
  stack_pointer = f->f_stacktop;
   4831: /* CIL Label */ 
#line 1209
  f->f_stacktop = (PyObject **)((void *)0);
   4832: /* CIL Label */ 
#line 1211
  if (co->co_flags & 0x0020) {
#line 1211
    if (! throwflag) {
#line 1212
      if ((unsigned int )f->f_exc_type != (unsigned int )((void *)0)) {
#line 1212
        if ((unsigned int )f->f_exc_type != (unsigned int )(& _Py_NoneStruct)) {
#line 1216
          tmp___2 = tstate->exc_type;
#line 1216
          tstate->exc_type = f->f_exc_type;
#line 1216
          f->f_exc_type = tmp___2;
#line 1216
          tmp___2 = tstate->exc_value;
#line 1216
          tstate->exc_value = f->f_exc_value;
#line 1216
          f->f_exc_value = tmp___2;
#line 1216
          tmp___2 = tstate->exc_traceback;
#line 1216
          tstate->exc_traceback = f->f_exc_traceback;
#line 1216
          f->f_exc_traceback = tmp___2;
        } else {
          goto _L;
        }
      } else {
        _L: /* CIL Label */ 
#line 1219
        while (1) {
#line 1219
          if ((unsigned int )tstate->exc_type == (unsigned int )((void *)0)) {

          } else {
#line 1219
            ((tstate->exc_type)->ob_refcnt) ++;
          }
#line 1219
          break;
        }
#line 1219
        while (1) {
#line 1219
          if ((unsigned int )tstate->exc_value == (unsigned int )((void *)0)) {

          } else {
#line 1219
            ((tstate->exc_value)->ob_refcnt) ++;
          }
#line 1219
          break;
        }
#line 1219
        while (1) {
#line 1219
          if ((unsigned int )tstate->exc_traceback == (unsigned int )((void *)0)) {

          } else {
#line 1219
            ((tstate->exc_traceback)->ob_refcnt) ++;
          }
#line 1219
          break;
        }
#line 1219
        type = f->f_exc_type;
#line 1219
        value = f->f_exc_value;
#line 1219
        traceback = f->f_exc_traceback;
#line 1219
        f->f_exc_type = tstate->exc_type;
#line 1219
        f->f_exc_value = tstate->exc_value;
#line 1219
        f->f_exc_traceback = tstate->exc_traceback;
#line 1219
        while (1) {
#line 1219
          if ((unsigned int )type == (unsigned int )((void *)0)) {

          } else {
#line 1219
            while (1) {
#line 1219
              (type->ob_refcnt) --;
#line 1219
              if (type->ob_refcnt != 0) {

              } else {
#line 1219
                (*((type->ob_type)->tp_dealloc))(type);
              }
#line 1219
              break;
            }
          }
#line 1219
          break;
        }
#line 1219
        while (1) {
#line 1219
          if ((unsigned int )value == (unsigned int )((void *)0)) {

          } else {
#line 1219
            while (1) {
#line 1219
              (value->ob_refcnt) --;
#line 1219
              if (value->ob_refcnt != 0) {

              } else {
#line 1219
                (*((value->ob_type)->tp_dealloc))(value);
              }
#line 1219
              break;
            }
          }
#line 1219
          break;
        }
#line 1219
        while (1) {
#line 1219
          if ((unsigned int )traceback == (unsigned int )((void *)0)) {

          } else {
#line 1219
            while (1) {
#line 1219
              (traceback->ob_refcnt) --;
#line 1219
              if (traceback->ob_refcnt != 0) {

              } else {
#line 1219
                (*((traceback->ob_type)->tp_dealloc))(traceback);
              }
#line 1219
              break;
            }
          }
#line 1219
          break;
        }
      }
    } else {

    }
  } else {

  }
   4833: /* CIL Label */ 
#line 1227
  why = (enum why_code )1;
   4834: /* CIL Label */ 
#line 1228
  err = 0;
   4835: /* CIL Label */ 
#line 1229
  x = & _Py_NoneStruct;
   4836: /* CIL Label */ 
#line 1230
  w = (PyObject *)((void *)0);
   4837: /* CIL Label */ 
#line 1232
  if (throwflag) {
#line 1233
    why = (enum why_code )2;
    goto on_error;
  } else {

  }
   4838: /* CIL Label */ 
#line 1237
  while (1) {
#line 1266
    atomic_val___6 = & eval_breaker;
#line 1266
    volatile_data___6 = (int volatile   *)(& atomic_val___6->_value);
#line 1266
    order___6 = (_Py_memory_order )0;
#line 1266
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___6, order___6);
#line 1266
    switch ((int )order___6) {
    case 2: 
    case 3: 
    case 4: 
#line 1266
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1266
    break;
    default: ;
#line 1266
    break;
    }
#line 1266
    result___5 = (int )*volatile_data___6;
#line 1266
    switch ((int )order___6) {
    case 1: 
    case 3: 
    case 4: 
#line 1266
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1266
    break;
    default: ;
#line 1266
    break;
    }
#line 1266
    if (result___5) {
#line 1267
      if ((int )*next_instr == 122) {
        goto fast_next_opcode;
      } else {

      }
#line 1272
      (tstate->tick_counter) ++;
#line 1276
      atomic_val___1 = & pendingcalls_to_do;
#line 1276
      volatile_data___1 = (int volatile   *)(& atomic_val___1->_value);
#line 1276
      order___1 = (_Py_memory_order )0;
#line 1276
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___1,
                                order___1);
#line 1276
      switch ((int )order___1) {
      case 2: 
      case 3: 
      case 4: 
#line 1276
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1276
      break;
      default: ;
#line 1276
      break;
      }
#line 1276
      result___1 = (int )*volatile_data___1;
#line 1276
      switch ((int )order___1) {
      case 1: 
      case 3: 
      case 4: 
#line 1276
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1276
      break;
      default: ;
#line 1276
      break;
      }
#line 1276
      if (result___1) {
#line 1277
        tmp___3 = Py_MakePendingCalls();
#line 1277
        if (tmp___3 < 0) {
#line 1278
          why = (enum why_code )2;
          goto on_error;
        } else {

        }
      } else {

      }
#line 1283
      atomic_val___2 = & gil_drop_request;
#line 1283
      volatile_data___2 = (int volatile   *)(& atomic_val___2->_value);
#line 1283
      order___2 = (_Py_memory_order )0;
#line 1283
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___2,
                                order___2);
#line 1283
      switch ((int )order___2) {
      case 2: 
      case 3: 
      case 4: 
#line 1283
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1283
      break;
      default: ;
#line 1283
      break;
      }
#line 1283
      result___2 = (int )*volatile_data___2;
#line 1283
      switch ((int )order___2) {
      case 1: 
      case 3: 
      case 4: 
#line 1283
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1283
      break;
      default: ;
#line 1283
      break;
      }
#line 1283
      if (result___2) {
#line 1285
        tmp___4 = PyThreadState_Swap((PyThreadState *)((void *)0));
#line 1285
        if ((unsigned int )tmp___4 != (unsigned int )tstate) {
#line 1286
          Py_FatalError("ceval: tstate mix-up");
        } else {

        }
#line 1287
        drop_gil(tstate);
#line 1291
        take_gil(tstate);
#line 1292
        tmp___5 = PyThreadState_Swap(tstate);
#line 1292
        if ((unsigned int )tmp___5 != (unsigned int )((void *)0)) {
#line 1293
          Py_FatalError("ceval: orphan tstate");
        } else {

        }
      } else {

      }
#line 1297
      if ((unsigned int )tstate->async_exc != (unsigned int )((void *)0)) {
#line 1298
        x = tstate->async_exc;
#line 1299
        tstate->async_exc = (PyObject *)((void *)0);
#line 1300
        while (1) {
#line 1300
          pending_async_exc = 0;
#line 1300
          atomic_val___3 = & eval_breaker;
#line 1300
          atomic_val___4 = & gil_drop_request;
#line 1300
          volatile_data___3 = (int volatile   *)(& atomic_val___4->_value);
#line 1300
          order___3 = (_Py_memory_order )0;
#line 1300
          _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___4,
                                    order___3);
#line 1300
          switch ((int )order___3) {
          case 2: 
          case 3: 
          case 4: 
#line 1300
          _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1300
          break;
          default: ;
#line 1300
          break;
          }
#line 1300
          result___3 = (int )*volatile_data___3;
#line 1300
          switch ((int )order___3) {
          case 1: 
          case 3: 
          case 4: 
#line 1300
          _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1300
          break;
          default: ;
#line 1300
          break;
          }
#line 1300
          atomic_val___5 = & pendingcalls_to_do;
#line 1300
          volatile_data___4 = (int volatile   *)(& atomic_val___5->_value);
#line 1300
          order___4 = (_Py_memory_order )0;
#line 1300
          _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___5,
                                    order___4);
#line 1300
          switch ((int )order___4) {
          case 2: 
          case 3: 
          case 4: 
#line 1300
          _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1300
          break;
          default: ;
#line 1300
          break;
          }
#line 1300
          result___4 = (int )*volatile_data___4;
#line 1300
          switch ((int )order___4) {
          case 1: 
          case 3: 
          case 4: 
#line 1300
          _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1300
          break;
          default: ;
#line 1300
          break;
          }
#line 1300
          new_val = (result___3 | result___4) | pending_async_exc;
#line 1300
          volatile_data___5 = (int volatile   *)(& atomic_val___3->_value);
#line 1300
          order___5 = (_Py_memory_order )0;
#line 1300
          _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___3,
                                    order___5);
#line 1300
          switch ((int )order___5) {
          case 2: 
#line 1300
          _Py_atomic_signal_fence((enum _Py_memory_order )2);
          case 0: 
#line 1300
          *volatile_data___5 = (int volatile   )new_val;
#line 1300
          break;
          case 1: 
          case 3: 
          case 4: 
#line 1300
          __asm__  volatile   ("xchg %0, %1": "+r" (new_val): "m" (atomic_val___3->_value): "memory");
#line 1300
          break;
          }
#line 1300
          break;
        }
#line 1301
        PyErr_SetNone(x);
#line 1302
        while (1) {
#line 1302
          (x->ob_refcnt) --;
#line 1302
          if (x->ob_refcnt != 0) {

          } else {
#line 1302
            (*((x->ob_type)->tp_dealloc))(x);
          }
#line 1302
          break;
        }
#line 1303
        why = (enum why_code )2;
        goto on_error;
      } else {

      }
    } else {

    }
    fast_next_opcode: 
#line 1309
    f->f_lasti = next_instr - first_instr;
#line 1313
    if (_Py_TracingPossible) {
#line 1313
      if ((unsigned int )tstate->c_tracefunc != (unsigned int )((void *)0)) {
#line 1313
        if (! tstate->tracing) {
#line 1317
          f->f_stacktop = stack_pointer;
#line 1319
          err = maybe_call_line_trace(tstate->c_tracefunc, tstate->c_traceobj,
                                      f, & instr_lb, & instr_ub, & instr_prev);
#line 1324
          next_instr = first_instr + f->f_lasti;
#line 1325
          if ((unsigned int )f->f_stacktop != (unsigned int )((void *)0)) {
#line 1326
            stack_pointer = f->f_stacktop;
#line 1327
            f->f_stacktop = (PyObject **)((void *)0);
          } else {

          }
#line 1329
          if (err) {
            goto on_error;
          } else {

          }
        } else {

        }
      } else {

      }
    } else {

    }
#line 1337
    tmp___6 = next_instr;
#line 1337
    next_instr ++;
#line 1337
    opcode = (int )*tmp___6;
#line 1338
    oparg = 0;
#line 1340
    if (opcode >= 90) {
#line 1341
      next_instr += 2;
#line 1341
      oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    } else {

    }
    dispatch_opcode: ;
#line 1369
    switch (opcode) {
    TARGET_NOP: 
#line 1378
    opcode = 9;
    case 9: 
#line 1379
    if (! _Py_TracingPossible) {
#line 1379
      f->f_lasti = next_instr - first_instr;
#line 1379
      tmp___7 = next_instr;
#line 1379
      next_instr ++;
#line 1379
      __compgoto = (int )opcode_targets[*tmp___7];
      __docompgoto: /* CIL Label */ 
#line 1379
      switch (__compgoto) {
      case 13: 
      goto TARGET_BINARY_MODULO;
      case 28: 
      goto TARGET_BINARY_LSHIFT;
      case 11: 
      goto TARGET_BINARY_POWER;
      case 57: 
      goto TARGET_DELETE_ATTR;
      case 70: 
      goto TARGET_JUMP_FORWARD;
      case 74: 
      goto TARGET_POP_JUMP_IF_FALSE;
      case 31: 
      goto TARGET_BINARY_XOR;
      case 79: 
      goto TARGET_SETUP_EXCEPT;
      case 14: 
      goto TARGET_BINARY_ADD;
      case 20: 
      goto TARGET_INPLACE_TRUE_DIVIDE;
      case 65: 
      goto TARGET_BUILD_MAP;
      case 29: 
      goto TARGET_BINARY_RSHIFT;
      case 100: 
      goto TARGET_MAP_ADD;
      case 17: 
      goto TARGET_BINARY_FLOOR_DIVIDE;
      case 50: 
      goto TARGET_POP_EXCEPT;
      case 67: 
      goto TARGET_COMPARE_OP;
      case 37: 
      goto TARGET_LOAD_BUILD_CLASS;
      case 60: 
      goto TARGET_LOAD_CONST;
      case 42: 
      goto TARGET_INPLACE_OR;
      case 56: 
      goto TARGET_STORE_ATTR;
      case 41: 
      goto TARGET_INPLACE_XOR;
      case 45: 
      goto TARGET_RETURN_VALUE;
      case 19: 
      goto TARGET_INPLACE_FLOOR_DIVIDE;
      case 52: 
      goto TARGET_DELETE_NAME;
      case 55: 
      goto TARGET_UNPACK_EX;
      case 92: 
      goto TARGET_DELETE_DEREF;
      case 94: 
      goto TARGET_CALL_FUNCTION_KW;
      case 22: 
      goto TARGET_INPLACE_ADD;
      case 87: 
      goto TARGET_BUILD_SLICE;
      case 93: 
      goto TARGET_CALL_FUNCTION_VAR;
      case 48: 
      goto TARGET_POP_BLOCK;
      case 58: 
      goto TARGET_STORE_GLOBAL;
      case 64: 
      goto TARGET_BUILD_SET;
      case 75: 
      goto TARGET_POP_JUMP_IF_TRUE;
      case 32: 
      goto TARGET_BINARY_OR;
      case 46: 
      goto TARGET_IMPORT_STAR;
      case 18: 
      goto TARGET_BINARY_TRUE_DIVIDE;
      case 62: 
      goto TARGET_BUILD_TUPLE;
      case 51: 
      goto TARGET_STORE_NAME;
      case 9: 
      goto TARGET_UNARY_NOT;
      case 71: 
      goto TARGET_JUMP_IF_FALSE_OR_POP;
      case 78: 
      goto TARGET_SETUP_LOOP;
      case 84: 
      goto TARGET_RAISE_VARARGS;
      case 96: 
      goto TARGET_SETUP_WITH;
      case 99: 
      goto TARGET_SET_ADD;
      case 0: 
      goto _unknown_opcode;
      case 8: 
      goto TARGET_UNARY_NEGATIVE;
      case 98: 
      goto TARGET_LIST_APPEND;
      case 27: 
      goto TARGET_DELETE_SUBSCR;
      case 23: 
      goto TARGET_INPLACE_SUBTRACT;
      case 66: 
      goto TARGET_LOAD_ATTR;
      case 47: 
      goto TARGET_YIELD_VALUE;
      case 43: 
      goto TARGET_BREAK_LOOP;
      case 5: 
      goto TARGET_DUP_TOP_TWO;
      case 85: 
      goto TARGET_CALL_FUNCTION;
      case 53: 
      goto TARGET_UNPACK_SEQUENCE;
      case 83: 
      goto TARGET_DELETE_FAST;
      case 61: 
      goto TARGET_LOAD_NAME;
      case 76: 
      goto TARGET_LOAD_GLOBAL;
      case 95: 
      goto TARGET_CALL_FUNCTION_VAR_KW;
      case 54: 
      goto TARGET_FOR_ITER;
      case 90: 
      goto TARGET_LOAD_DEREF;
      case 80: 
      goto TARGET_SETUP_FINALLY;
      case 4: 
      goto TARGET_DUP_TOP;
      case 30: 
      goto TARGET_BINARY_AND;
      case 59: 
      goto TARGET_DELETE_GLOBAL;
      case 68: 
      goto TARGET_IMPORT_NAME;
      case 82: 
      goto TARGET_STORE_FAST;
      case 36: 
      goto TARGET_PRINT_EXPR;
      case 7: 
      goto TARGET_UNARY_POSITIVE;
      case 26: 
      goto TARGET_STORE_SUBSCR;
      case 72: 
      goto TARGET_JUMP_IF_TRUE_OR_POP;
      case 1: 
      goto TARGET_POP_TOP;
      case 35: 
      goto TARGET_STORE_LOCALS;
      case 88: 
      goto TARGET_MAKE_CLOSURE;
      case 89: 
      goto TARGET_LOAD_CLOSURE;
      case 2: 
      goto TARGET_ROT_TWO;
      case 10: 
      goto TARGET_UNARY_INVERT;
      case 25: 
      goto TARGET_INPLACE_MODULO;
      case 38: 
      goto TARGET_INPLACE_LSHIFT;
      case 34: 
      goto TARGET_GET_ITER;
      case 40: 
      goto TARGET_INPLACE_AND;
      case 6: 
      goto TARGET_NOP;
      case 73: 
      goto TARGET_JUMP_ABSOLUTE;
      case 77: 
      goto TARGET_CONTINUE_LOOP;
      case 15: 
      goto TARGET_BINARY_SUBTRACT;
      case 49: 
      goto TARGET_END_FINALLY;
      case 12: 
      goto TARGET_BINARY_MULTIPLY;
      case 97: 
      goto TARGET_EXTENDED_ARG;
      case 39: 
      goto TARGET_INPLACE_RSHIFT;
      case 3: 
      goto TARGET_ROT_THREE;
      case 24: 
      goto TARGET_INPLACE_MULTIPLY;
      case 16: 
      goto TARGET_BINARY_SUBSCR;
      case 44: 
      goto TARGET_WITH_CLEANUP;
      case 69: 
      goto TARGET_IMPORT_FROM;
      case 81: 
      goto TARGET_LOAD_FAST;
      case 33: 
      goto TARGET_INPLACE_POWER;
      case 91: 
      goto TARGET_STORE_DEREF;
      case 21: 
      goto TARGET_STORE_MAP;
      case 63: 
      goto TARGET_BUILD_LIST;
      case 86: 
      goto TARGET_MAKE_FUNCTION;
      default: 
#line 1379
      *((int *)0) = 0;
      }
    } else {

    }
    goto fast_next_opcode;
    TARGET_LOAD_FAST: 
#line 1381
    opcode = 124;
#line 1381
    next_instr += 2;
#line 1381
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 124: 
#line 1382
    x = *(fastlocals + oparg);
#line 1383
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1384
      (x->ob_refcnt) ++;
#line 1385
      tmp___8 = stack_pointer;
#line 1385
      stack_pointer ++;
#line 1385
      *tmp___8 = x;
#line 1386
      if (! _Py_TracingPossible) {
#line 1386
        f->f_lasti = next_instr - first_instr;
#line 1386
        tmp___9 = next_instr;
#line 1386
        next_instr ++;
#line 1386
        __compgoto = (int )opcode_targets[*tmp___9];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    } else {

    }
#line 1388
    tmp___10 = PyTuple_GetItem(co->co_varnames, oparg);
#line 1388
    format_exc_check_arg(PyExc_UnboundLocalError,
                         "local variable \'%.200s\' referenced before assignment",
                         tmp___10);
#line 1391
    break;
    TARGET_LOAD_CONST: 
#line 1393
    opcode = 100;
#line 1393
    next_instr += 2;
#line 1393
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 100: 
#line 1394
    x = ((PyTupleObject *)consts)->ob_item[oparg];
#line 1395
    (x->ob_refcnt) ++;
#line 1396
    tmp___11 = stack_pointer;
#line 1396
    stack_pointer ++;
#line 1396
    *tmp___11 = x;
#line 1397
    if (! _Py_TracingPossible) {
#line 1397
      f->f_lasti = next_instr - first_instr;
#line 1397
      tmp___12 = next_instr;
#line 1397
      next_instr ++;
#line 1397
      __compgoto = (int )opcode_targets[*tmp___12];
      goto __docompgoto;
    } else {

    }
    goto fast_next_opcode;
    PRED_STORE_FAST: ;
    TARGET_STORE_FAST: 
#line 1400
    opcode = 125;
#line 1400
    next_instr += 2;
#line 1400
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 125: 
#line 1401
    stack_pointer --;
#line 1401
    v = *stack_pointer;
#line 1402
    while (1) {
#line 1402
      tmp___13 = *(fastlocals + oparg);
#line 1402
      *(fastlocals + oparg) = v;
#line 1402
      while (1) {
#line 1402
        if ((unsigned int )tmp___13 == (unsigned int )((void *)0)) {

        } else {
#line 1402
          while (1) {
#line 1402
            (tmp___13->ob_refcnt) --;
#line 1402
            if (tmp___13->ob_refcnt != 0) {

            } else {
#line 1402
              (*((tmp___13->ob_type)->tp_dealloc))(tmp___13);
            }
#line 1402
            break;
          }
        }
#line 1402
        break;
      }
#line 1402
      break;
    }
#line 1403
    if (! _Py_TracingPossible) {
#line 1403
      f->f_lasti = next_instr - first_instr;
#line 1403
      tmp___14 = next_instr;
#line 1403
      next_instr ++;
#line 1403
      __compgoto = (int )opcode_targets[*tmp___14];
      goto __docompgoto;
    } else {

    }
    goto fast_next_opcode;
    TARGET_POP_TOP: 
#line 1405
    opcode = 1;
    case 1: 
#line 1406
    stack_pointer --;
#line 1406
    v = *stack_pointer;
#line 1407
    while (1) {
#line 1407
      (v->ob_refcnt) --;
#line 1407
      if (v->ob_refcnt != 0) {

      } else {
#line 1407
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1407
      break;
    }
#line 1408
    if (! _Py_TracingPossible) {
#line 1408
      f->f_lasti = next_instr - first_instr;
#line 1408
      tmp___15 = next_instr;
#line 1408
      next_instr ++;
#line 1408
      __compgoto = (int )opcode_targets[*tmp___15];
      goto __docompgoto;
    } else {

    }
    goto fast_next_opcode;
    TARGET_ROT_TWO: 
#line 1410
    opcode = 2;
    case 2: 
#line 1411
    v = *(stack_pointer + -1);
#line 1412
    w = *(stack_pointer + -2);
#line 1413
    *(stack_pointer + -1) = w;
#line 1414
    *(stack_pointer + -2) = v;
#line 1415
    if (! _Py_TracingPossible) {
#line 1415
      f->f_lasti = next_instr - first_instr;
#line 1415
      tmp___16 = next_instr;
#line 1415
      next_instr ++;
#line 1415
      __compgoto = (int )opcode_targets[*tmp___16];
      goto __docompgoto;
    } else {

    }
    goto fast_next_opcode;
    TARGET_ROT_THREE: 
#line 1417
    opcode = 3;
    case 3: 
#line 1418
    v = *(stack_pointer + -1);
#line 1419
    w = *(stack_pointer + -2);
#line 1420
    x = *(stack_pointer + -3);
#line 1421
    *(stack_pointer + -1) = w;
#line 1422
    *(stack_pointer + -2) = x;
#line 1423
    *(stack_pointer + -3) = v;
#line 1424
    if (! _Py_TracingPossible) {
#line 1424
      f->f_lasti = next_instr - first_instr;
#line 1424
      tmp___17 = next_instr;
#line 1424
      next_instr ++;
#line 1424
      __compgoto = (int )opcode_targets[*tmp___17];
      goto __docompgoto;
    } else {

    }
    goto fast_next_opcode;
    TARGET_DUP_TOP: 
#line 1426
    opcode = 4;
    case 4: 
#line 1427
    v = *(stack_pointer + -1);
#line 1428
    (v->ob_refcnt) ++;
#line 1429
    tmp___18 = stack_pointer;
#line 1429
    stack_pointer ++;
#line 1429
    *tmp___18 = v;
#line 1430
    if (! _Py_TracingPossible) {
#line 1430
      f->f_lasti = next_instr - first_instr;
#line 1430
      tmp___19 = next_instr;
#line 1430
      next_instr ++;
#line 1430
      __compgoto = (int )opcode_targets[*tmp___19];
      goto __docompgoto;
    } else {

    }
    goto fast_next_opcode;
    TARGET_DUP_TOP_TWO: 
#line 1432
    opcode = 5;
    case 5: 
#line 1433
    x = *(stack_pointer + -1);
#line 1434
    (x->ob_refcnt) ++;
#line 1435
    w = *(stack_pointer + -2);
#line 1436
    (w->ob_refcnt) ++;
#line 1437
    stack_pointer += 2;
#line 1438
    *(stack_pointer + -1) = x;
#line 1439
    *(stack_pointer + -2) = w;
#line 1440
    if (! _Py_TracingPossible) {
#line 1440
      f->f_lasti = next_instr - first_instr;
#line 1440
      tmp___20 = next_instr;
#line 1440
      next_instr ++;
#line 1440
      __compgoto = (int )opcode_targets[*tmp___20];
      goto __docompgoto;
    } else {

    }
    goto fast_next_opcode;
    TARGET_UNARY_POSITIVE: 
#line 1442
    opcode = 10;
    case 10: 
#line 1443
    v = *(stack_pointer + -1);
#line 1444
    x = PyNumber_Positive(v);
#line 1445
    while (1) {
#line 1445
      (v->ob_refcnt) --;
#line 1445
      if (v->ob_refcnt != 0) {

      } else {
#line 1445
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1445
      break;
    }
#line 1446
    *(stack_pointer + -1) = x;
#line 1447
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1447
      atomic_val___7 = & eval_breaker;
#line 1447
      volatile_data___7 = (int volatile   *)(& atomic_val___7->_value);
#line 1447
      order___7 = (_Py_memory_order )0;
#line 1447
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___7,
                                order___7);
#line 1447
      switch ((int )order___7) {
      case 2: 
      case 3: 
      case 4: 
#line 1447
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1447
      break;
      default: ;
#line 1447
      break;
      }
#line 1447
      result___6 = (int )*volatile_data___7;
#line 1447
      switch ((int )order___7) {
      case 1: 
      case 3: 
      case 4: 
#line 1447
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1447
      break;
      default: ;
#line 1447
      break;
      }
#line 1447
      if (result___6) {

      } else {
#line 1447
        if (! _Py_TracingPossible) {
#line 1447
          f->f_lasti = next_instr - first_instr;
#line 1447
          tmp___21 = next_instr;
#line 1447
          next_instr ++;
#line 1447
          __compgoto = (int )opcode_targets[*tmp___21];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1448
    break;
    TARGET_UNARY_NEGATIVE: 
#line 1450
    opcode = 11;
    case 11: 
#line 1451
    v = *(stack_pointer + -1);
#line 1452
    x = PyNumber_Negative(v);
#line 1453
    while (1) {
#line 1453
      (v->ob_refcnt) --;
#line 1453
      if (v->ob_refcnt != 0) {

      } else {
#line 1453
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1453
      break;
    }
#line 1454
    *(stack_pointer + -1) = x;
#line 1455
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1455
      atomic_val___8 = & eval_breaker;
#line 1455
      volatile_data___8 = (int volatile   *)(& atomic_val___8->_value);
#line 1455
      order___8 = (_Py_memory_order )0;
#line 1455
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___8,
                                order___8);
#line 1455
      switch ((int )order___8) {
      case 2: 
      case 3: 
      case 4: 
#line 1455
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1455
      break;
      default: ;
#line 1455
      break;
      }
#line 1455
      result___7 = (int )*volatile_data___8;
#line 1455
      switch ((int )order___8) {
      case 1: 
      case 3: 
      case 4: 
#line 1455
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1455
      break;
      default: ;
#line 1455
      break;
      }
#line 1455
      if (result___7) {

      } else {
#line 1455
        if (! _Py_TracingPossible) {
#line 1455
          f->f_lasti = next_instr - first_instr;
#line 1455
          tmp___22 = next_instr;
#line 1455
          next_instr ++;
#line 1455
          __compgoto = (int )opcode_targets[*tmp___22];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1456
    break;
    TARGET_UNARY_NOT: 
#line 1458
    opcode = 12;
    case 12: 
#line 1459
    v = *(stack_pointer + -1);
#line 1460
    err = PyObject_IsTrue(v);
#line 1461
    while (1) {
#line 1461
      (v->ob_refcnt) --;
#line 1461
      if (v->ob_refcnt != 0) {

      } else {
#line 1461
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1461
      break;
    }
#line 1462
    if (err == 0) {
#line 1463
      (((PyObject *)(& _Py_TrueStruct))->ob_refcnt) ++;
#line 1464
      *(stack_pointer + -1) = (PyObject *)(& _Py_TrueStruct);
#line 1465
      atomic_val___9 = & eval_breaker;
#line 1465
      volatile_data___9 = (int volatile   *)(& atomic_val___9->_value);
#line 1465
      order___9 = (_Py_memory_order )0;
#line 1465
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___9,
                                order___9);
#line 1465
      switch ((int )order___9) {
      case 2: 
      case 3: 
      case 4: 
#line 1465
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1465
      break;
      default: ;
#line 1465
      break;
      }
#line 1465
      result___8 = (int )*volatile_data___9;
#line 1465
      switch ((int )order___9) {
      case 1: 
      case 3: 
      case 4: 
#line 1465
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1465
      break;
      default: ;
#line 1465
      break;
      }
#line 1465
      if (result___8) {

      } else {
#line 1465
        if (! _Py_TracingPossible) {
#line 1465
          f->f_lasti = next_instr - first_instr;
#line 1465
          tmp___23 = next_instr;
#line 1465
          next_instr ++;
#line 1465
          __compgoto = (int )opcode_targets[*tmp___23];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {
#line 1467
      if (err > 0) {
#line 1468
        (((PyObject *)(& _Py_FalseStruct))->ob_refcnt) ++;
#line 1469
        *(stack_pointer + -1) = (PyObject *)(& _Py_FalseStruct);
#line 1470
        err = 0;
#line 1471
        atomic_val___10 = & eval_breaker;
#line 1471
        volatile_data___10 = (int volatile   *)(& atomic_val___10->_value);
#line 1471
        order___10 = (_Py_memory_order )0;
#line 1471
        _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___10,
                                  order___10);
#line 1471
        switch ((int )order___10) {
        case 2: 
        case 3: 
        case 4: 
#line 1471
        _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1471
        break;
        default: ;
#line 1471
        break;
        }
#line 1471
        result___9 = (int )*volatile_data___10;
#line 1471
        switch ((int )order___10) {
        case 1: 
        case 3: 
        case 4: 
#line 1471
        _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1471
        break;
        default: ;
#line 1471
        break;
        }
#line 1471
        if (result___9) {

        } else {
#line 1471
          if (! _Py_TracingPossible) {
#line 1471
            f->f_lasti = next_instr - first_instr;
#line 1471
            tmp___24 = next_instr;
#line 1471
            next_instr ++;
#line 1471
            __compgoto = (int )opcode_targets[*tmp___24];
            goto __docompgoto;
          } else {

          }
          goto fast_next_opcode;
        }
        goto __Cont;
      } else {

      }
    }
#line 1473
    stack_pointer --;
#line 1474
    break;
    TARGET_UNARY_INVERT: 
#line 1476
    opcode = 15;
    case 15: 
#line 1477
    v = *(stack_pointer + -1);
#line 1478
    x = PyNumber_Invert(v);
#line 1479
    while (1) {
#line 1479
      (v->ob_refcnt) --;
#line 1479
      if (v->ob_refcnt != 0) {

      } else {
#line 1479
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1479
      break;
    }
#line 1480
    *(stack_pointer + -1) = x;
#line 1481
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1481
      atomic_val___11 = & eval_breaker;
#line 1481
      volatile_data___11 = (int volatile   *)(& atomic_val___11->_value);
#line 1481
      order___11 = (_Py_memory_order )0;
#line 1481
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___11,
                                order___11);
#line 1481
      switch ((int )order___11) {
      case 2: 
      case 3: 
      case 4: 
#line 1481
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1481
      break;
      default: ;
#line 1481
      break;
      }
#line 1481
      result___10 = (int )*volatile_data___11;
#line 1481
      switch ((int )order___11) {
      case 1: 
      case 3: 
      case 4: 
#line 1481
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1481
      break;
      default: ;
#line 1481
      break;
      }
#line 1481
      if (result___10) {

      } else {
#line 1481
        if (! _Py_TracingPossible) {
#line 1481
          f->f_lasti = next_instr - first_instr;
#line 1481
          tmp___25 = next_instr;
#line 1481
          next_instr ++;
#line 1481
          __compgoto = (int )opcode_targets[*tmp___25];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1482
    break;
    TARGET_BINARY_POWER: 
#line 1484
    opcode = 19;
    case 19: 
#line 1485
    stack_pointer --;
#line 1485
    w = *stack_pointer;
#line 1486
    v = *(stack_pointer + -1);
#line 1487
    x = PyNumber_Power(v, w, & _Py_NoneStruct);
#line 1488
    while (1) {
#line 1488
      (v->ob_refcnt) --;
#line 1488
      if (v->ob_refcnt != 0) {

      } else {
#line 1488
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1488
      break;
    }
#line 1489
    while (1) {
#line 1489
      (w->ob_refcnt) --;
#line 1489
      if (w->ob_refcnt != 0) {

      } else {
#line 1489
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1489
      break;
    }
#line 1490
    *(stack_pointer + -1) = x;
#line 1491
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1491
      atomic_val___12 = & eval_breaker;
#line 1491
      volatile_data___12 = (int volatile   *)(& atomic_val___12->_value);
#line 1491
      order___12 = (_Py_memory_order )0;
#line 1491
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___12,
                                order___12);
#line 1491
      switch ((int )order___12) {
      case 2: 
      case 3: 
      case 4: 
#line 1491
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1491
      break;
      default: ;
#line 1491
      break;
      }
#line 1491
      result___11 = (int )*volatile_data___12;
#line 1491
      switch ((int )order___12) {
      case 1: 
      case 3: 
      case 4: 
#line 1491
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1491
      break;
      default: ;
#line 1491
      break;
      }
#line 1491
      if (result___11) {

      } else {
#line 1491
        if (! _Py_TracingPossible) {
#line 1491
          f->f_lasti = next_instr - first_instr;
#line 1491
          tmp___26 = next_instr;
#line 1491
          next_instr ++;
#line 1491
          __compgoto = (int )opcode_targets[*tmp___26];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1492
    break;
    TARGET_BINARY_MULTIPLY: 
#line 1494
    opcode = 20;
    case 20: 
#line 1495
    stack_pointer --;
#line 1495
    w = *stack_pointer;
#line 1496
    v = *(stack_pointer + -1);
#line 1497
    x = PyNumber_Multiply(v, w);
#line 1498
    while (1) {
#line 1498
      (v->ob_refcnt) --;
#line 1498
      if (v->ob_refcnt != 0) {

      } else {
#line 1498
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1498
      break;
    }
#line 1499
    while (1) {
#line 1499
      (w->ob_refcnt) --;
#line 1499
      if (w->ob_refcnt != 0) {

      } else {
#line 1499
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1499
      break;
    }
#line 1500
    *(stack_pointer + -1) = x;
#line 1501
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1501
      atomic_val___13 = & eval_breaker;
#line 1501
      volatile_data___13 = (int volatile   *)(& atomic_val___13->_value);
#line 1501
      order___13 = (_Py_memory_order )0;
#line 1501
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___13,
                                order___13);
#line 1501
      switch ((int )order___13) {
      case 2: 
      case 3: 
      case 4: 
#line 1501
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1501
      break;
      default: ;
#line 1501
      break;
      }
#line 1501
      result___12 = (int )*volatile_data___13;
#line 1501
      switch ((int )order___13) {
      case 1: 
      case 3: 
      case 4: 
#line 1501
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1501
      break;
      default: ;
#line 1501
      break;
      }
#line 1501
      if (result___12) {

      } else {
#line 1501
        if (! _Py_TracingPossible) {
#line 1501
          f->f_lasti = next_instr - first_instr;
#line 1501
          tmp___27 = next_instr;
#line 1501
          next_instr ++;
#line 1501
          __compgoto = (int )opcode_targets[*tmp___27];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1502
    break;
    TARGET_BINARY_TRUE_DIVIDE: 
#line 1504
    opcode = 27;
    case 27: 
#line 1505
    stack_pointer --;
#line 1505
    w = *stack_pointer;
#line 1506
    v = *(stack_pointer + -1);
#line 1507
    x = PyNumber_TrueDivide(v, w);
#line 1508
    while (1) {
#line 1508
      (v->ob_refcnt) --;
#line 1508
      if (v->ob_refcnt != 0) {

      } else {
#line 1508
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1508
      break;
    }
#line 1509
    while (1) {
#line 1509
      (w->ob_refcnt) --;
#line 1509
      if (w->ob_refcnt != 0) {

      } else {
#line 1509
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1509
      break;
    }
#line 1510
    *(stack_pointer + -1) = x;
#line 1511
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1511
      atomic_val___14 = & eval_breaker;
#line 1511
      volatile_data___14 = (int volatile   *)(& atomic_val___14->_value);
#line 1511
      order___14 = (_Py_memory_order )0;
#line 1511
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___14,
                                order___14);
#line 1511
      switch ((int )order___14) {
      case 2: 
      case 3: 
      case 4: 
#line 1511
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1511
      break;
      default: ;
#line 1511
      break;
      }
#line 1511
      result___13 = (int )*volatile_data___14;
#line 1511
      switch ((int )order___14) {
      case 1: 
      case 3: 
      case 4: 
#line 1511
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1511
      break;
      default: ;
#line 1511
      break;
      }
#line 1511
      if (result___13) {

      } else {
#line 1511
        if (! _Py_TracingPossible) {
#line 1511
          f->f_lasti = next_instr - first_instr;
#line 1511
          tmp___28 = next_instr;
#line 1511
          next_instr ++;
#line 1511
          __compgoto = (int )opcode_targets[*tmp___28];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1512
    break;
    TARGET_BINARY_FLOOR_DIVIDE: 
#line 1514
    opcode = 26;
    case 26: 
#line 1515
    stack_pointer --;
#line 1515
    w = *stack_pointer;
#line 1516
    v = *(stack_pointer + -1);
#line 1517
    x = PyNumber_FloorDivide(v, w);
#line 1518
    while (1) {
#line 1518
      (v->ob_refcnt) --;
#line 1518
      if (v->ob_refcnt != 0) {

      } else {
#line 1518
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1518
      break;
    }
#line 1519
    while (1) {
#line 1519
      (w->ob_refcnt) --;
#line 1519
      if (w->ob_refcnt != 0) {

      } else {
#line 1519
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1519
      break;
    }
#line 1520
    *(stack_pointer + -1) = x;
#line 1521
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1521
      atomic_val___15 = & eval_breaker;
#line 1521
      volatile_data___15 = (int volatile   *)(& atomic_val___15->_value);
#line 1521
      order___15 = (_Py_memory_order )0;
#line 1521
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___15,
                                order___15);
#line 1521
      switch ((int )order___15) {
      case 2: 
      case 3: 
      case 4: 
#line 1521
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1521
      break;
      default: ;
#line 1521
      break;
      }
#line 1521
      result___14 = (int )*volatile_data___15;
#line 1521
      switch ((int )order___15) {
      case 1: 
      case 3: 
      case 4: 
#line 1521
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1521
      break;
      default: ;
#line 1521
      break;
      }
#line 1521
      if (result___14) {

      } else {
#line 1521
        if (! _Py_TracingPossible) {
#line 1521
          f->f_lasti = next_instr - first_instr;
#line 1521
          tmp___29 = next_instr;
#line 1521
          next_instr ++;
#line 1521
          __compgoto = (int )opcode_targets[*tmp___29];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1522
    break;
    TARGET_BINARY_MODULO: 
#line 1524
    opcode = 22;
    case 22: 
#line 1525
    stack_pointer --;
#line 1525
    w = *stack_pointer;
#line 1526
    v = *(stack_pointer + -1);
#line 1527
    if ((unsigned int )v->ob_type == (unsigned int )(& PyUnicode_Type)) {
#line 1528
      x = PyUnicodeUCS2_Format(v, w);
    } else {
#line 1530
      x = PyNumber_Remainder(v, w);
    }
#line 1531
    while (1) {
#line 1531
      (v->ob_refcnt) --;
#line 1531
      if (v->ob_refcnt != 0) {

      } else {
#line 1531
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1531
      break;
    }
#line 1532
    while (1) {
#line 1532
      (w->ob_refcnt) --;
#line 1532
      if (w->ob_refcnt != 0) {

      } else {
#line 1532
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1532
      break;
    }
#line 1533
    *(stack_pointer + -1) = x;
#line 1534
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1534
      atomic_val___16 = & eval_breaker;
#line 1534
      volatile_data___16 = (int volatile   *)(& atomic_val___16->_value);
#line 1534
      order___16 = (_Py_memory_order )0;
#line 1534
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___16,
                                order___16);
#line 1534
      switch ((int )order___16) {
      case 2: 
      case 3: 
      case 4: 
#line 1534
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1534
      break;
      default: ;
#line 1534
      break;
      }
#line 1534
      result___15 = (int )*volatile_data___16;
#line 1534
      switch ((int )order___16) {
      case 1: 
      case 3: 
      case 4: 
#line 1534
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1534
      break;
      default: ;
#line 1534
      break;
      }
#line 1534
      if (result___15) {

      } else {
#line 1534
        if (! _Py_TracingPossible) {
#line 1534
          f->f_lasti = next_instr - first_instr;
#line 1534
          tmp___30 = next_instr;
#line 1534
          next_instr ++;
#line 1534
          __compgoto = (int )opcode_targets[*tmp___30];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1535
    break;
    TARGET_BINARY_ADD: 
#line 1537
    opcode = 23;
    case 23: 
#line 1538
    stack_pointer --;
#line 1538
    w = *stack_pointer;
#line 1539
    v = *(stack_pointer + -1);
#line 1540
    if ((unsigned int )v->ob_type == (unsigned int )(& PyUnicode_Type)) {
#line 1540
      if ((unsigned int )w->ob_type == (unsigned int )(& PyUnicode_Type)) {
#line 1542
        x = unicode_concatenate(v, w, f, next_instr);
        goto skip_decref_vx;
      } else {
#line 1547
        x = PyNumber_Add(v, w);
      }
    } else {
#line 1547
      x = PyNumber_Add(v, w);
    }
#line 1549
    while (1) {
#line 1549
      (v->ob_refcnt) --;
#line 1549
      if (v->ob_refcnt != 0) {

      } else {
#line 1549
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1549
      break;
    }
    skip_decref_vx: 
#line 1551
    while (1) {
#line 1551
      (w->ob_refcnt) --;
#line 1551
      if (w->ob_refcnt != 0) {

      } else {
#line 1551
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1551
      break;
    }
#line 1552
    *(stack_pointer + -1) = x;
#line 1553
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1553
      atomic_val___17 = & eval_breaker;
#line 1553
      volatile_data___17 = (int volatile   *)(& atomic_val___17->_value);
#line 1553
      order___17 = (_Py_memory_order )0;
#line 1553
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___17,
                                order___17);
#line 1553
      switch ((int )order___17) {
      case 2: 
      case 3: 
      case 4: 
#line 1553
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1553
      break;
      default: ;
#line 1553
      break;
      }
#line 1553
      result___16 = (int )*volatile_data___17;
#line 1553
      switch ((int )order___17) {
      case 1: 
      case 3: 
      case 4: 
#line 1553
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1553
      break;
      default: ;
#line 1553
      break;
      }
#line 1553
      if (result___16) {

      } else {
#line 1553
        if (! _Py_TracingPossible) {
#line 1553
          f->f_lasti = next_instr - first_instr;
#line 1553
          tmp___31 = next_instr;
#line 1553
          next_instr ++;
#line 1553
          __compgoto = (int )opcode_targets[*tmp___31];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1554
    break;
    TARGET_BINARY_SUBTRACT: 
#line 1556
    opcode = 24;
    case 24: 
#line 1557
    stack_pointer --;
#line 1557
    w = *stack_pointer;
#line 1558
    v = *(stack_pointer + -1);
#line 1559
    x = PyNumber_Subtract(v, w);
#line 1560
    while (1) {
#line 1560
      (v->ob_refcnt) --;
#line 1560
      if (v->ob_refcnt != 0) {

      } else {
#line 1560
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1560
      break;
    }
#line 1561
    while (1) {
#line 1561
      (w->ob_refcnt) --;
#line 1561
      if (w->ob_refcnt != 0) {

      } else {
#line 1561
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1561
      break;
    }
#line 1562
    *(stack_pointer + -1) = x;
#line 1563
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1563
      atomic_val___18 = & eval_breaker;
#line 1563
      volatile_data___18 = (int volatile   *)(& atomic_val___18->_value);
#line 1563
      order___18 = (_Py_memory_order )0;
#line 1563
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___18,
                                order___18);
#line 1563
      switch ((int )order___18) {
      case 2: 
      case 3: 
      case 4: 
#line 1563
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1563
      break;
      default: ;
#line 1563
      break;
      }
#line 1563
      result___17 = (int )*volatile_data___18;
#line 1563
      switch ((int )order___18) {
      case 1: 
      case 3: 
      case 4: 
#line 1563
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1563
      break;
      default: ;
#line 1563
      break;
      }
#line 1563
      if (result___17) {

      } else {
#line 1563
        if (! _Py_TracingPossible) {
#line 1563
          f->f_lasti = next_instr - first_instr;
#line 1563
          tmp___32 = next_instr;
#line 1563
          next_instr ++;
#line 1563
          __compgoto = (int )opcode_targets[*tmp___32];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1564
    break;
    TARGET_BINARY_SUBSCR: 
#line 1566
    opcode = 25;
    case 25: 
#line 1567
    stack_pointer --;
#line 1567
    w = *stack_pointer;
#line 1568
    v = *(stack_pointer + -1);
#line 1569
    x = PyObject_GetItem(v, w);
#line 1570
    while (1) {
#line 1570
      (v->ob_refcnt) --;
#line 1570
      if (v->ob_refcnt != 0) {

      } else {
#line 1570
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1570
      break;
    }
#line 1571
    while (1) {
#line 1571
      (w->ob_refcnt) --;
#line 1571
      if (w->ob_refcnt != 0) {

      } else {
#line 1571
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1571
      break;
    }
#line 1572
    *(stack_pointer + -1) = x;
#line 1573
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1573
      atomic_val___19 = & eval_breaker;
#line 1573
      volatile_data___19 = (int volatile   *)(& atomic_val___19->_value);
#line 1573
      order___19 = (_Py_memory_order )0;
#line 1573
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___19,
                                order___19);
#line 1573
      switch ((int )order___19) {
      case 2: 
      case 3: 
      case 4: 
#line 1573
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1573
      break;
      default: ;
#line 1573
      break;
      }
#line 1573
      result___18 = (int )*volatile_data___19;
#line 1573
      switch ((int )order___19) {
      case 1: 
      case 3: 
      case 4: 
#line 1573
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1573
      break;
      default: ;
#line 1573
      break;
      }
#line 1573
      if (result___18) {

      } else {
#line 1573
        if (! _Py_TracingPossible) {
#line 1573
          f->f_lasti = next_instr - first_instr;
#line 1573
          tmp___33 = next_instr;
#line 1573
          next_instr ++;
#line 1573
          __compgoto = (int )opcode_targets[*tmp___33];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1574
    break;
    TARGET_BINARY_LSHIFT: 
#line 1576
    opcode = 62;
    case 62: 
#line 1577
    stack_pointer --;
#line 1577
    w = *stack_pointer;
#line 1578
    v = *(stack_pointer + -1);
#line 1579
    x = PyNumber_Lshift(v, w);
#line 1580
    while (1) {
#line 1580
      (v->ob_refcnt) --;
#line 1580
      if (v->ob_refcnt != 0) {

      } else {
#line 1580
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1580
      break;
    }
#line 1581
    while (1) {
#line 1581
      (w->ob_refcnt) --;
#line 1581
      if (w->ob_refcnt != 0) {

      } else {
#line 1581
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1581
      break;
    }
#line 1582
    *(stack_pointer + -1) = x;
#line 1583
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1583
      atomic_val___20 = & eval_breaker;
#line 1583
      volatile_data___20 = (int volatile   *)(& atomic_val___20->_value);
#line 1583
      order___20 = (_Py_memory_order )0;
#line 1583
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___20,
                                order___20);
#line 1583
      switch ((int )order___20) {
      case 2: 
      case 3: 
      case 4: 
#line 1583
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1583
      break;
      default: ;
#line 1583
      break;
      }
#line 1583
      result___19 = (int )*volatile_data___20;
#line 1583
      switch ((int )order___20) {
      case 1: 
      case 3: 
      case 4: 
#line 1583
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1583
      break;
      default: ;
#line 1583
      break;
      }
#line 1583
      if (result___19) {

      } else {
#line 1583
        if (! _Py_TracingPossible) {
#line 1583
          f->f_lasti = next_instr - first_instr;
#line 1583
          tmp___34 = next_instr;
#line 1583
          next_instr ++;
#line 1583
          __compgoto = (int )opcode_targets[*tmp___34];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1584
    break;
    TARGET_BINARY_RSHIFT: 
#line 1586
    opcode = 63;
    case 63: 
#line 1587
    stack_pointer --;
#line 1587
    w = *stack_pointer;
#line 1588
    v = *(stack_pointer + -1);
#line 1589
    x = PyNumber_Rshift(v, w);
#line 1590
    while (1) {
#line 1590
      (v->ob_refcnt) --;
#line 1590
      if (v->ob_refcnt != 0) {

      } else {
#line 1590
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1590
      break;
    }
#line 1591
    while (1) {
#line 1591
      (w->ob_refcnt) --;
#line 1591
      if (w->ob_refcnt != 0) {

      } else {
#line 1591
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1591
      break;
    }
#line 1592
    *(stack_pointer + -1) = x;
#line 1593
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1593
      atomic_val___21 = & eval_breaker;
#line 1593
      volatile_data___21 = (int volatile   *)(& atomic_val___21->_value);
#line 1593
      order___21 = (_Py_memory_order )0;
#line 1593
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___21,
                                order___21);
#line 1593
      switch ((int )order___21) {
      case 2: 
      case 3: 
      case 4: 
#line 1593
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1593
      break;
      default: ;
#line 1593
      break;
      }
#line 1593
      result___20 = (int )*volatile_data___21;
#line 1593
      switch ((int )order___21) {
      case 1: 
      case 3: 
      case 4: 
#line 1593
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1593
      break;
      default: ;
#line 1593
      break;
      }
#line 1593
      if (result___20) {

      } else {
#line 1593
        if (! _Py_TracingPossible) {
#line 1593
          f->f_lasti = next_instr - first_instr;
#line 1593
          tmp___35 = next_instr;
#line 1593
          next_instr ++;
#line 1593
          __compgoto = (int )opcode_targets[*tmp___35];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1594
    break;
    TARGET_BINARY_AND: 
#line 1596
    opcode = 64;
    case 64: 
#line 1597
    stack_pointer --;
#line 1597
    w = *stack_pointer;
#line 1598
    v = *(stack_pointer + -1);
#line 1599
    x = PyNumber_And(v, w);
#line 1600
    while (1) {
#line 1600
      (v->ob_refcnt) --;
#line 1600
      if (v->ob_refcnt != 0) {

      } else {
#line 1600
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1600
      break;
    }
#line 1601
    while (1) {
#line 1601
      (w->ob_refcnt) --;
#line 1601
      if (w->ob_refcnt != 0) {

      } else {
#line 1601
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1601
      break;
    }
#line 1602
    *(stack_pointer + -1) = x;
#line 1603
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1603
      atomic_val___22 = & eval_breaker;
#line 1603
      volatile_data___22 = (int volatile   *)(& atomic_val___22->_value);
#line 1603
      order___22 = (_Py_memory_order )0;
#line 1603
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___22,
                                order___22);
#line 1603
      switch ((int )order___22) {
      case 2: 
      case 3: 
      case 4: 
#line 1603
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1603
      break;
      default: ;
#line 1603
      break;
      }
#line 1603
      result___21 = (int )*volatile_data___22;
#line 1603
      switch ((int )order___22) {
      case 1: 
      case 3: 
      case 4: 
#line 1603
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1603
      break;
      default: ;
#line 1603
      break;
      }
#line 1603
      if (result___21) {

      } else {
#line 1603
        if (! _Py_TracingPossible) {
#line 1603
          f->f_lasti = next_instr - first_instr;
#line 1603
          tmp___36 = next_instr;
#line 1603
          next_instr ++;
#line 1603
          __compgoto = (int )opcode_targets[*tmp___36];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1604
    break;
    TARGET_BINARY_XOR: 
#line 1606
    opcode = 65;
    case 65: 
#line 1607
    stack_pointer --;
#line 1607
    w = *stack_pointer;
#line 1608
    v = *(stack_pointer + -1);
#line 1609
    x = PyNumber_Xor(v, w);
#line 1610
    while (1) {
#line 1610
      (v->ob_refcnt) --;
#line 1610
      if (v->ob_refcnt != 0) {

      } else {
#line 1610
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1610
      break;
    }
#line 1611
    while (1) {
#line 1611
      (w->ob_refcnt) --;
#line 1611
      if (w->ob_refcnt != 0) {

      } else {
#line 1611
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1611
      break;
    }
#line 1612
    *(stack_pointer + -1) = x;
#line 1613
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1613
      atomic_val___23 = & eval_breaker;
#line 1613
      volatile_data___23 = (int volatile   *)(& atomic_val___23->_value);
#line 1613
      order___23 = (_Py_memory_order )0;
#line 1613
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___23,
                                order___23);
#line 1613
      switch ((int )order___23) {
      case 2: 
      case 3: 
      case 4: 
#line 1613
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1613
      break;
      default: ;
#line 1613
      break;
      }
#line 1613
      result___22 = (int )*volatile_data___23;
#line 1613
      switch ((int )order___23) {
      case 1: 
      case 3: 
      case 4: 
#line 1613
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1613
      break;
      default: ;
#line 1613
      break;
      }
#line 1613
      if (result___22) {

      } else {
#line 1613
        if (! _Py_TracingPossible) {
#line 1613
          f->f_lasti = next_instr - first_instr;
#line 1613
          tmp___37 = next_instr;
#line 1613
          next_instr ++;
#line 1613
          __compgoto = (int )opcode_targets[*tmp___37];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1614
    break;
    TARGET_BINARY_OR: 
#line 1616
    opcode = 66;
    case 66: 
#line 1617
    stack_pointer --;
#line 1617
    w = *stack_pointer;
#line 1618
    v = *(stack_pointer + -1);
#line 1619
    x = PyNumber_Or(v, w);
#line 1620
    while (1) {
#line 1620
      (v->ob_refcnt) --;
#line 1620
      if (v->ob_refcnt != 0) {

      } else {
#line 1620
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1620
      break;
    }
#line 1621
    while (1) {
#line 1621
      (w->ob_refcnt) --;
#line 1621
      if (w->ob_refcnt != 0) {

      } else {
#line 1621
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1621
      break;
    }
#line 1622
    *(stack_pointer + -1) = x;
#line 1623
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1623
      atomic_val___24 = & eval_breaker;
#line 1623
      volatile_data___24 = (int volatile   *)(& atomic_val___24->_value);
#line 1623
      order___24 = (_Py_memory_order )0;
#line 1623
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___24,
                                order___24);
#line 1623
      switch ((int )order___24) {
      case 2: 
      case 3: 
      case 4: 
#line 1623
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1623
      break;
      default: ;
#line 1623
      break;
      }
#line 1623
      result___23 = (int )*volatile_data___24;
#line 1623
      switch ((int )order___24) {
      case 1: 
      case 3: 
      case 4: 
#line 1623
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1623
      break;
      default: ;
#line 1623
      break;
      }
#line 1623
      if (result___23) {

      } else {
#line 1623
        if (! _Py_TracingPossible) {
#line 1623
          f->f_lasti = next_instr - first_instr;
#line 1623
          tmp___38 = next_instr;
#line 1623
          next_instr ++;
#line 1623
          __compgoto = (int )opcode_targets[*tmp___38];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1624
    break;
    TARGET_LIST_APPEND: 
#line 1626
    opcode = 145;
#line 1626
    next_instr += 2;
#line 1626
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 145: 
#line 1627
    stack_pointer --;
#line 1627
    w = *stack_pointer;
#line 1628
    v = *(stack_pointer + - oparg);
#line 1629
    err = PyList_Append(v, w);
#line 1630
    while (1) {
#line 1630
      (w->ob_refcnt) --;
#line 1630
      if (w->ob_refcnt != 0) {

      } else {
#line 1630
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1630
      break;
    }
#line 1631
    if (err == 0) {
#line 1633
      atomic_val___25 = & eval_breaker;
#line 1633
      volatile_data___25 = (int volatile   *)(& atomic_val___25->_value);
#line 1633
      order___25 = (_Py_memory_order )0;
#line 1633
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___25,
                                order___25);
#line 1633
      switch ((int )order___25) {
      case 2: 
      case 3: 
      case 4: 
#line 1633
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1633
      break;
      default: ;
#line 1633
      break;
      }
#line 1633
      result___24 = (int )*volatile_data___25;
#line 1633
      switch ((int )order___25) {
      case 1: 
      case 3: 
      case 4: 
#line 1633
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1633
      break;
      default: ;
#line 1633
      break;
      }
#line 1633
      if (result___24) {

      } else {
#line 1633
        if (! _Py_TracingPossible) {
#line 1633
          f->f_lasti = next_instr - first_instr;
#line 1633
          tmp___39 = next_instr;
#line 1633
          next_instr ++;
#line 1633
          __compgoto = (int )opcode_targets[*tmp___39];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1635
    break;
    TARGET_SET_ADD: 
#line 1637
    opcode = 146;
#line 1637
    next_instr += 2;
#line 1637
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 146: 
#line 1638
    stack_pointer --;
#line 1638
    w = *stack_pointer;
#line 1639
    v = *(stack_pointer + - oparg);
#line 1640
    err = PySet_Add(v, w);
#line 1641
    while (1) {
#line 1641
      (w->ob_refcnt) --;
#line 1641
      if (w->ob_refcnt != 0) {

      } else {
#line 1641
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1641
      break;
    }
#line 1642
    if (err == 0) {
#line 1644
      atomic_val___26 = & eval_breaker;
#line 1644
      volatile_data___26 = (int volatile   *)(& atomic_val___26->_value);
#line 1644
      order___26 = (_Py_memory_order )0;
#line 1644
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___26,
                                order___26);
#line 1644
      switch ((int )order___26) {
      case 2: 
      case 3: 
      case 4: 
#line 1644
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1644
      break;
      default: ;
#line 1644
      break;
      }
#line 1644
      result___25 = (int )*volatile_data___26;
#line 1644
      switch ((int )order___26) {
      case 1: 
      case 3: 
      case 4: 
#line 1644
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1644
      break;
      default: ;
#line 1644
      break;
      }
#line 1644
      if (result___25) {

      } else {
#line 1644
        if (! _Py_TracingPossible) {
#line 1644
          f->f_lasti = next_instr - first_instr;
#line 1644
          tmp___40 = next_instr;
#line 1644
          next_instr ++;
#line 1644
          __compgoto = (int )opcode_targets[*tmp___40];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1646
    break;
    TARGET_INPLACE_POWER: 
#line 1648
    opcode = 67;
    case 67: 
#line 1649
    stack_pointer --;
#line 1649
    w = *stack_pointer;
#line 1650
    v = *(stack_pointer + -1);
#line 1651
    x = PyNumber_InPlacePower(v, w, & _Py_NoneStruct);
#line 1652
    while (1) {
#line 1652
      (v->ob_refcnt) --;
#line 1652
      if (v->ob_refcnt != 0) {

      } else {
#line 1652
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1652
      break;
    }
#line 1653
    while (1) {
#line 1653
      (w->ob_refcnt) --;
#line 1653
      if (w->ob_refcnt != 0) {

      } else {
#line 1653
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1653
      break;
    }
#line 1654
    *(stack_pointer + -1) = x;
#line 1655
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1655
      atomic_val___27 = & eval_breaker;
#line 1655
      volatile_data___27 = (int volatile   *)(& atomic_val___27->_value);
#line 1655
      order___27 = (_Py_memory_order )0;
#line 1655
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___27,
                                order___27);
#line 1655
      switch ((int )order___27) {
      case 2: 
      case 3: 
      case 4: 
#line 1655
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1655
      break;
      default: ;
#line 1655
      break;
      }
#line 1655
      result___26 = (int )*volatile_data___27;
#line 1655
      switch ((int )order___27) {
      case 1: 
      case 3: 
      case 4: 
#line 1655
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1655
      break;
      default: ;
#line 1655
      break;
      }
#line 1655
      if (result___26) {

      } else {
#line 1655
        if (! _Py_TracingPossible) {
#line 1655
          f->f_lasti = next_instr - first_instr;
#line 1655
          tmp___41 = next_instr;
#line 1655
          next_instr ++;
#line 1655
          __compgoto = (int )opcode_targets[*tmp___41];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1656
    break;
    TARGET_INPLACE_MULTIPLY: 
#line 1658
    opcode = 57;
    case 57: 
#line 1659
    stack_pointer --;
#line 1659
    w = *stack_pointer;
#line 1660
    v = *(stack_pointer + -1);
#line 1661
    x = PyNumber_InPlaceMultiply(v, w);
#line 1662
    while (1) {
#line 1662
      (v->ob_refcnt) --;
#line 1662
      if (v->ob_refcnt != 0) {

      } else {
#line 1662
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1662
      break;
    }
#line 1663
    while (1) {
#line 1663
      (w->ob_refcnt) --;
#line 1663
      if (w->ob_refcnt != 0) {

      } else {
#line 1663
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1663
      break;
    }
#line 1664
    *(stack_pointer + -1) = x;
#line 1665
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1665
      atomic_val___28 = & eval_breaker;
#line 1665
      volatile_data___28 = (int volatile   *)(& atomic_val___28->_value);
#line 1665
      order___28 = (_Py_memory_order )0;
#line 1665
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___28,
                                order___28);
#line 1665
      switch ((int )order___28) {
      case 2: 
      case 3: 
      case 4: 
#line 1665
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1665
      break;
      default: ;
#line 1665
      break;
      }
#line 1665
      result___27 = (int )*volatile_data___28;
#line 1665
      switch ((int )order___28) {
      case 1: 
      case 3: 
      case 4: 
#line 1665
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1665
      break;
      default: ;
#line 1665
      break;
      }
#line 1665
      if (result___27) {

      } else {
#line 1665
        if (! _Py_TracingPossible) {
#line 1665
          f->f_lasti = next_instr - first_instr;
#line 1665
          tmp___42 = next_instr;
#line 1665
          next_instr ++;
#line 1665
          __compgoto = (int )opcode_targets[*tmp___42];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1666
    break;
    TARGET_INPLACE_TRUE_DIVIDE: 
#line 1668
    opcode = 29;
    case 29: 
#line 1669
    stack_pointer --;
#line 1669
    w = *stack_pointer;
#line 1670
    v = *(stack_pointer + -1);
#line 1671
    x = PyNumber_InPlaceTrueDivide(v, w);
#line 1672
    while (1) {
#line 1672
      (v->ob_refcnt) --;
#line 1672
      if (v->ob_refcnt != 0) {

      } else {
#line 1672
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1672
      break;
    }
#line 1673
    while (1) {
#line 1673
      (w->ob_refcnt) --;
#line 1673
      if (w->ob_refcnt != 0) {

      } else {
#line 1673
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1673
      break;
    }
#line 1674
    *(stack_pointer + -1) = x;
#line 1675
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1675
      atomic_val___29 = & eval_breaker;
#line 1675
      volatile_data___29 = (int volatile   *)(& atomic_val___29->_value);
#line 1675
      order___29 = (_Py_memory_order )0;
#line 1675
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___29,
                                order___29);
#line 1675
      switch ((int )order___29) {
      case 2: 
      case 3: 
      case 4: 
#line 1675
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1675
      break;
      default: ;
#line 1675
      break;
      }
#line 1675
      result___28 = (int )*volatile_data___29;
#line 1675
      switch ((int )order___29) {
      case 1: 
      case 3: 
      case 4: 
#line 1675
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1675
      break;
      default: ;
#line 1675
      break;
      }
#line 1675
      if (result___28) {

      } else {
#line 1675
        if (! _Py_TracingPossible) {
#line 1675
          f->f_lasti = next_instr - first_instr;
#line 1675
          tmp___43 = next_instr;
#line 1675
          next_instr ++;
#line 1675
          __compgoto = (int )opcode_targets[*tmp___43];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1676
    break;
    TARGET_INPLACE_FLOOR_DIVIDE: 
#line 1678
    opcode = 28;
    case 28: 
#line 1679
    stack_pointer --;
#line 1679
    w = *stack_pointer;
#line 1680
    v = *(stack_pointer + -1);
#line 1681
    x = PyNumber_InPlaceFloorDivide(v, w);
#line 1682
    while (1) {
#line 1682
      (v->ob_refcnt) --;
#line 1682
      if (v->ob_refcnt != 0) {

      } else {
#line 1682
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1682
      break;
    }
#line 1683
    while (1) {
#line 1683
      (w->ob_refcnt) --;
#line 1683
      if (w->ob_refcnt != 0) {

      } else {
#line 1683
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1683
      break;
    }
#line 1684
    *(stack_pointer + -1) = x;
#line 1685
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1685
      atomic_val___30 = & eval_breaker;
#line 1685
      volatile_data___30 = (int volatile   *)(& atomic_val___30->_value);
#line 1685
      order___30 = (_Py_memory_order )0;
#line 1685
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___30,
                                order___30);
#line 1685
      switch ((int )order___30) {
      case 2: 
      case 3: 
      case 4: 
#line 1685
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1685
      break;
      default: ;
#line 1685
      break;
      }
#line 1685
      result___29 = (int )*volatile_data___30;
#line 1685
      switch ((int )order___30) {
      case 1: 
      case 3: 
      case 4: 
#line 1685
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1685
      break;
      default: ;
#line 1685
      break;
      }
#line 1685
      if (result___29) {

      } else {
#line 1685
        if (! _Py_TracingPossible) {
#line 1685
          f->f_lasti = next_instr - first_instr;
#line 1685
          tmp___44 = next_instr;
#line 1685
          next_instr ++;
#line 1685
          __compgoto = (int )opcode_targets[*tmp___44];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1686
    break;
    TARGET_INPLACE_MODULO: 
#line 1688
    opcode = 59;
    case 59: 
#line 1689
    stack_pointer --;
#line 1689
    w = *stack_pointer;
#line 1690
    v = *(stack_pointer + -1);
#line 1691
    x = PyNumber_InPlaceRemainder(v, w);
#line 1692
    while (1) {
#line 1692
      (v->ob_refcnt) --;
#line 1692
      if (v->ob_refcnt != 0) {

      } else {
#line 1692
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1692
      break;
    }
#line 1693
    while (1) {
#line 1693
      (w->ob_refcnt) --;
#line 1693
      if (w->ob_refcnt != 0) {

      } else {
#line 1693
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1693
      break;
    }
#line 1694
    *(stack_pointer + -1) = x;
#line 1695
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1695
      atomic_val___31 = & eval_breaker;
#line 1695
      volatile_data___31 = (int volatile   *)(& atomic_val___31->_value);
#line 1695
      order___31 = (_Py_memory_order )0;
#line 1695
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___31,
                                order___31);
#line 1695
      switch ((int )order___31) {
      case 2: 
      case 3: 
      case 4: 
#line 1695
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1695
      break;
      default: ;
#line 1695
      break;
      }
#line 1695
      result___30 = (int )*volatile_data___31;
#line 1695
      switch ((int )order___31) {
      case 1: 
      case 3: 
      case 4: 
#line 1695
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1695
      break;
      default: ;
#line 1695
      break;
      }
#line 1695
      if (result___30) {

      } else {
#line 1695
        if (! _Py_TracingPossible) {
#line 1695
          f->f_lasti = next_instr - first_instr;
#line 1695
          tmp___45 = next_instr;
#line 1695
          next_instr ++;
#line 1695
          __compgoto = (int )opcode_targets[*tmp___45];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1696
    break;
    TARGET_INPLACE_ADD: 
#line 1698
    opcode = 55;
    case 55: 
#line 1699
    stack_pointer --;
#line 1699
    w = *stack_pointer;
#line 1700
    v = *(stack_pointer + -1);
#line 1701
    if ((unsigned int )v->ob_type == (unsigned int )(& PyUnicode_Type)) {
#line 1701
      if ((unsigned int )w->ob_type == (unsigned int )(& PyUnicode_Type)) {
#line 1703
        x = unicode_concatenate(v, w, f, next_instr);
        goto skip_decref_v;
      } else {
#line 1708
        x = PyNumber_InPlaceAdd(v, w);
      }
    } else {
#line 1708
      x = PyNumber_InPlaceAdd(v, w);
    }
#line 1710
    while (1) {
#line 1710
      (v->ob_refcnt) --;
#line 1710
      if (v->ob_refcnt != 0) {

      } else {
#line 1710
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1710
      break;
    }
    skip_decref_v: 
#line 1712
    while (1) {
#line 1712
      (w->ob_refcnt) --;
#line 1712
      if (w->ob_refcnt != 0) {

      } else {
#line 1712
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1712
      break;
    }
#line 1713
    *(stack_pointer + -1) = x;
#line 1714
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1714
      atomic_val___32 = & eval_breaker;
#line 1714
      volatile_data___32 = (int volatile   *)(& atomic_val___32->_value);
#line 1714
      order___32 = (_Py_memory_order )0;
#line 1714
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___32,
                                order___32);
#line 1714
      switch ((int )order___32) {
      case 2: 
      case 3: 
      case 4: 
#line 1714
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1714
      break;
      default: ;
#line 1714
      break;
      }
#line 1714
      result___31 = (int )*volatile_data___32;
#line 1714
      switch ((int )order___32) {
      case 1: 
      case 3: 
      case 4: 
#line 1714
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1714
      break;
      default: ;
#line 1714
      break;
      }
#line 1714
      if (result___31) {

      } else {
#line 1714
        if (! _Py_TracingPossible) {
#line 1714
          f->f_lasti = next_instr - first_instr;
#line 1714
          tmp___46 = next_instr;
#line 1714
          next_instr ++;
#line 1714
          __compgoto = (int )opcode_targets[*tmp___46];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1715
    break;
    TARGET_INPLACE_SUBTRACT: 
#line 1717
    opcode = 56;
    case 56: 
#line 1718
    stack_pointer --;
#line 1718
    w = *stack_pointer;
#line 1719
    v = *(stack_pointer + -1);
#line 1720
    x = PyNumber_InPlaceSubtract(v, w);
#line 1721
    while (1) {
#line 1721
      (v->ob_refcnt) --;
#line 1721
      if (v->ob_refcnt != 0) {

      } else {
#line 1721
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1721
      break;
    }
#line 1722
    while (1) {
#line 1722
      (w->ob_refcnt) --;
#line 1722
      if (w->ob_refcnt != 0) {

      } else {
#line 1722
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1722
      break;
    }
#line 1723
    *(stack_pointer + -1) = x;
#line 1724
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1724
      atomic_val___33 = & eval_breaker;
#line 1724
      volatile_data___33 = (int volatile   *)(& atomic_val___33->_value);
#line 1724
      order___33 = (_Py_memory_order )0;
#line 1724
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___33,
                                order___33);
#line 1724
      switch ((int )order___33) {
      case 2: 
      case 3: 
      case 4: 
#line 1724
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1724
      break;
      default: ;
#line 1724
      break;
      }
#line 1724
      result___32 = (int )*volatile_data___33;
#line 1724
      switch ((int )order___33) {
      case 1: 
      case 3: 
      case 4: 
#line 1724
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1724
      break;
      default: ;
#line 1724
      break;
      }
#line 1724
      if (result___32) {

      } else {
#line 1724
        if (! _Py_TracingPossible) {
#line 1724
          f->f_lasti = next_instr - first_instr;
#line 1724
          tmp___47 = next_instr;
#line 1724
          next_instr ++;
#line 1724
          __compgoto = (int )opcode_targets[*tmp___47];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1725
    break;
    TARGET_INPLACE_LSHIFT: 
#line 1727
    opcode = 75;
    case 75: 
#line 1728
    stack_pointer --;
#line 1728
    w = *stack_pointer;
#line 1729
    v = *(stack_pointer + -1);
#line 1730
    x = PyNumber_InPlaceLshift(v, w);
#line 1731
    while (1) {
#line 1731
      (v->ob_refcnt) --;
#line 1731
      if (v->ob_refcnt != 0) {

      } else {
#line 1731
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1731
      break;
    }
#line 1732
    while (1) {
#line 1732
      (w->ob_refcnt) --;
#line 1732
      if (w->ob_refcnt != 0) {

      } else {
#line 1732
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1732
      break;
    }
#line 1733
    *(stack_pointer + -1) = x;
#line 1734
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1734
      atomic_val___34 = & eval_breaker;
#line 1734
      volatile_data___34 = (int volatile   *)(& atomic_val___34->_value);
#line 1734
      order___34 = (_Py_memory_order )0;
#line 1734
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___34,
                                order___34);
#line 1734
      switch ((int )order___34) {
      case 2: 
      case 3: 
      case 4: 
#line 1734
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1734
      break;
      default: ;
#line 1734
      break;
      }
#line 1734
      result___33 = (int )*volatile_data___34;
#line 1734
      switch ((int )order___34) {
      case 1: 
      case 3: 
      case 4: 
#line 1734
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1734
      break;
      default: ;
#line 1734
      break;
      }
#line 1734
      if (result___33) {

      } else {
#line 1734
        if (! _Py_TracingPossible) {
#line 1734
          f->f_lasti = next_instr - first_instr;
#line 1734
          tmp___48 = next_instr;
#line 1734
          next_instr ++;
#line 1734
          __compgoto = (int )opcode_targets[*tmp___48];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1735
    break;
    TARGET_INPLACE_RSHIFT: 
#line 1737
    opcode = 76;
    case 76: 
#line 1738
    stack_pointer --;
#line 1738
    w = *stack_pointer;
#line 1739
    v = *(stack_pointer + -1);
#line 1740
    x = PyNumber_InPlaceRshift(v, w);
#line 1741
    while (1) {
#line 1741
      (v->ob_refcnt) --;
#line 1741
      if (v->ob_refcnt != 0) {

      } else {
#line 1741
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1741
      break;
    }
#line 1742
    while (1) {
#line 1742
      (w->ob_refcnt) --;
#line 1742
      if (w->ob_refcnt != 0) {

      } else {
#line 1742
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1742
      break;
    }
#line 1743
    *(stack_pointer + -1) = x;
#line 1744
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1744
      atomic_val___35 = & eval_breaker;
#line 1744
      volatile_data___35 = (int volatile   *)(& atomic_val___35->_value);
#line 1744
      order___35 = (_Py_memory_order )0;
#line 1744
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___35,
                                order___35);
#line 1744
      switch ((int )order___35) {
      case 2: 
      case 3: 
      case 4: 
#line 1744
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1744
      break;
      default: ;
#line 1744
      break;
      }
#line 1744
      result___34 = (int )*volatile_data___35;
#line 1744
      switch ((int )order___35) {
      case 1: 
      case 3: 
      case 4: 
#line 1744
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1744
      break;
      default: ;
#line 1744
      break;
      }
#line 1744
      if (result___34) {

      } else {
#line 1744
        if (! _Py_TracingPossible) {
#line 1744
          f->f_lasti = next_instr - first_instr;
#line 1744
          tmp___49 = next_instr;
#line 1744
          next_instr ++;
#line 1744
          __compgoto = (int )opcode_targets[*tmp___49];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1745
    break;
    TARGET_INPLACE_AND: 
#line 1747
    opcode = 77;
    case 77: 
#line 1748
    stack_pointer --;
#line 1748
    w = *stack_pointer;
#line 1749
    v = *(stack_pointer + -1);
#line 1750
    x = PyNumber_InPlaceAnd(v, w);
#line 1751
    while (1) {
#line 1751
      (v->ob_refcnt) --;
#line 1751
      if (v->ob_refcnt != 0) {

      } else {
#line 1751
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1751
      break;
    }
#line 1752
    while (1) {
#line 1752
      (w->ob_refcnt) --;
#line 1752
      if (w->ob_refcnt != 0) {

      } else {
#line 1752
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1752
      break;
    }
#line 1753
    *(stack_pointer + -1) = x;
#line 1754
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1754
      atomic_val___36 = & eval_breaker;
#line 1754
      volatile_data___36 = (int volatile   *)(& atomic_val___36->_value);
#line 1754
      order___36 = (_Py_memory_order )0;
#line 1754
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___36,
                                order___36);
#line 1754
      switch ((int )order___36) {
      case 2: 
      case 3: 
      case 4: 
#line 1754
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1754
      break;
      default: ;
#line 1754
      break;
      }
#line 1754
      result___35 = (int )*volatile_data___36;
#line 1754
      switch ((int )order___36) {
      case 1: 
      case 3: 
      case 4: 
#line 1754
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1754
      break;
      default: ;
#line 1754
      break;
      }
#line 1754
      if (result___35) {

      } else {
#line 1754
        if (! _Py_TracingPossible) {
#line 1754
          f->f_lasti = next_instr - first_instr;
#line 1754
          tmp___50 = next_instr;
#line 1754
          next_instr ++;
#line 1754
          __compgoto = (int )opcode_targets[*tmp___50];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1755
    break;
    TARGET_INPLACE_XOR: 
#line 1757
    opcode = 78;
    case 78: 
#line 1758
    stack_pointer --;
#line 1758
    w = *stack_pointer;
#line 1759
    v = *(stack_pointer + -1);
#line 1760
    x = PyNumber_InPlaceXor(v, w);
#line 1761
    while (1) {
#line 1761
      (v->ob_refcnt) --;
#line 1761
      if (v->ob_refcnt != 0) {

      } else {
#line 1761
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1761
      break;
    }
#line 1762
    while (1) {
#line 1762
      (w->ob_refcnt) --;
#line 1762
      if (w->ob_refcnt != 0) {

      } else {
#line 1762
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1762
      break;
    }
#line 1763
    *(stack_pointer + -1) = x;
#line 1764
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1764
      atomic_val___37 = & eval_breaker;
#line 1764
      volatile_data___37 = (int volatile   *)(& atomic_val___37->_value);
#line 1764
      order___37 = (_Py_memory_order )0;
#line 1764
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___37,
                                order___37);
#line 1764
      switch ((int )order___37) {
      case 2: 
      case 3: 
      case 4: 
#line 1764
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1764
      break;
      default: ;
#line 1764
      break;
      }
#line 1764
      result___36 = (int )*volatile_data___37;
#line 1764
      switch ((int )order___37) {
      case 1: 
      case 3: 
      case 4: 
#line 1764
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1764
      break;
      default: ;
#line 1764
      break;
      }
#line 1764
      if (result___36) {

      } else {
#line 1764
        if (! _Py_TracingPossible) {
#line 1764
          f->f_lasti = next_instr - first_instr;
#line 1764
          tmp___51 = next_instr;
#line 1764
          next_instr ++;
#line 1764
          __compgoto = (int )opcode_targets[*tmp___51];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1765
    break;
    TARGET_INPLACE_OR: 
#line 1767
    opcode = 79;
    case 79: 
#line 1768
    stack_pointer --;
#line 1768
    w = *stack_pointer;
#line 1769
    v = *(stack_pointer + -1);
#line 1770
    x = PyNumber_InPlaceOr(v, w);
#line 1771
    while (1) {
#line 1771
      (v->ob_refcnt) --;
#line 1771
      if (v->ob_refcnt != 0) {

      } else {
#line 1771
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1771
      break;
    }
#line 1772
    while (1) {
#line 1772
      (w->ob_refcnt) --;
#line 1772
      if (w->ob_refcnt != 0) {

      } else {
#line 1772
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1772
      break;
    }
#line 1773
    *(stack_pointer + -1) = x;
#line 1774
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1774
      atomic_val___38 = & eval_breaker;
#line 1774
      volatile_data___38 = (int volatile   *)(& atomic_val___38->_value);
#line 1774
      order___38 = (_Py_memory_order )0;
#line 1774
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___38,
                                order___38);
#line 1774
      switch ((int )order___38) {
      case 2: 
      case 3: 
      case 4: 
#line 1774
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1774
      break;
      default: ;
#line 1774
      break;
      }
#line 1774
      result___37 = (int )*volatile_data___38;
#line 1774
      switch ((int )order___38) {
      case 1: 
      case 3: 
      case 4: 
#line 1774
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1774
      break;
      default: ;
#line 1774
      break;
      }
#line 1774
      if (result___37) {

      } else {
#line 1774
        if (! _Py_TracingPossible) {
#line 1774
          f->f_lasti = next_instr - first_instr;
#line 1774
          tmp___52 = next_instr;
#line 1774
          next_instr ++;
#line 1774
          __compgoto = (int )opcode_targets[*tmp___52];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1775
    break;
    TARGET_STORE_SUBSCR: 
#line 1777
    opcode = 60;
    case 60: 
#line 1778
    w = *(stack_pointer + -1);
#line 1779
    v = *(stack_pointer + -2);
#line 1780
    u = *(stack_pointer + -3);
#line 1781
    stack_pointer += -3;
#line 1783
    err = PyObject_SetItem(v, w, u);
#line 1784
    while (1) {
#line 1784
      (u->ob_refcnt) --;
#line 1784
      if (u->ob_refcnt != 0) {

      } else {
#line 1784
        (*((u->ob_type)->tp_dealloc))(u);
      }
#line 1784
      break;
    }
#line 1785
    while (1) {
#line 1785
      (v->ob_refcnt) --;
#line 1785
      if (v->ob_refcnt != 0) {

      } else {
#line 1785
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1785
      break;
    }
#line 1786
    while (1) {
#line 1786
      (w->ob_refcnt) --;
#line 1786
      if (w->ob_refcnt != 0) {

      } else {
#line 1786
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1786
      break;
    }
#line 1787
    if (err == 0) {
#line 1787
      atomic_val___39 = & eval_breaker;
#line 1787
      volatile_data___39 = (int volatile   *)(& atomic_val___39->_value);
#line 1787
      order___39 = (_Py_memory_order )0;
#line 1787
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___39,
                                order___39);
#line 1787
      switch ((int )order___39) {
      case 2: 
      case 3: 
      case 4: 
#line 1787
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1787
      break;
      default: ;
#line 1787
      break;
      }
#line 1787
      result___38 = (int )*volatile_data___39;
#line 1787
      switch ((int )order___39) {
      case 1: 
      case 3: 
      case 4: 
#line 1787
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1787
      break;
      default: ;
#line 1787
      break;
      }
#line 1787
      if (result___38) {

      } else {
#line 1787
        if (! _Py_TracingPossible) {
#line 1787
          f->f_lasti = next_instr - first_instr;
#line 1787
          tmp___53 = next_instr;
#line 1787
          next_instr ++;
#line 1787
          __compgoto = (int )opcode_targets[*tmp___53];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1788
    break;
    TARGET_DELETE_SUBSCR: 
#line 1790
    opcode = 61;
    case 61: 
#line 1791
    w = *(stack_pointer + -1);
#line 1792
    v = *(stack_pointer + -2);
#line 1793
    stack_pointer += -2;
#line 1795
    err = PyObject_DelItem(v, w);
#line 1796
    while (1) {
#line 1796
      (v->ob_refcnt) --;
#line 1796
      if (v->ob_refcnt != 0) {

      } else {
#line 1796
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1796
      break;
    }
#line 1797
    while (1) {
#line 1797
      (w->ob_refcnt) --;
#line 1797
      if (w->ob_refcnt != 0) {

      } else {
#line 1797
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 1797
      break;
    }
#line 1798
    if (err == 0) {
#line 1798
      atomic_val___40 = & eval_breaker;
#line 1798
      volatile_data___40 = (int volatile   *)(& atomic_val___40->_value);
#line 1798
      order___40 = (_Py_memory_order )0;
#line 1798
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___40,
                                order___40);
#line 1798
      switch ((int )order___40) {
      case 2: 
      case 3: 
      case 4: 
#line 1798
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1798
      break;
      default: ;
#line 1798
      break;
      }
#line 1798
      result___39 = (int )*volatile_data___40;
#line 1798
      switch ((int )order___40) {
      case 1: 
      case 3: 
      case 4: 
#line 1798
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1798
      break;
      default: ;
#line 1798
      break;
      }
#line 1798
      if (result___39) {

      } else {
#line 1798
        if (! _Py_TracingPossible) {
#line 1798
          f->f_lasti = next_instr - first_instr;
#line 1798
          tmp___54 = next_instr;
#line 1798
          next_instr ++;
#line 1798
          __compgoto = (int )opcode_targets[*tmp___54];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 1799
    break;
    TARGET_PRINT_EXPR: 
#line 1801
    opcode = 70;
    case 70: 
#line 1802
    stack_pointer --;
#line 1802
    v = *stack_pointer;
#line 1803
    w = PySys_GetObject("displayhook");
#line 1804
    if ((unsigned int )w == (unsigned int )((void *)0)) {
#line 1805
      PyErr_SetString(PyExc_RuntimeError, "lost sys.displayhook");
#line 1807
      err = -1;
#line 1808
      x = (PyObject *)((void *)0);
    } else {

    }
#line 1810
    if (err == 0) {
#line 1811
      x = PyTuple_Pack(1, v);
#line 1812
      if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 1813
        err = -1;
      } else {

      }
    } else {

    }
#line 1815
    if (err == 0) {
#line 1816
      w = PyEval_CallObjectWithKeywords(w, x, (PyObject *)((void *)0));
#line 1817
      while (1) {
#line 1817
        if ((unsigned int )w == (unsigned int )((void *)0)) {

        } else {
#line 1817
          while (1) {
#line 1817
            (w->ob_refcnt) --;
#line 1817
            if (w->ob_refcnt != 0) {

            } else {
#line 1817
              (*((w->ob_type)->tp_dealloc))(w);
            }
#line 1817
            break;
          }
        }
#line 1817
        break;
      }
#line 1818
      if ((unsigned int )w == (unsigned int )((void *)0)) {
#line 1819
        err = -1;
      } else {

      }
    } else {

    }
#line 1821
    while (1) {
#line 1821
      (v->ob_refcnt) --;
#line 1821
      if (v->ob_refcnt != 0) {

      } else {
#line 1821
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1821
      break;
    }
#line 1822
    while (1) {
#line 1822
      if ((unsigned int )x == (unsigned int )((void *)0)) {

      } else {
#line 1822
        while (1) {
#line 1822
          (x->ob_refcnt) --;
#line 1822
          if (x->ob_refcnt != 0) {

          } else {
#line 1822
            (*((x->ob_type)->tp_dealloc))(x);
          }
#line 1822
          break;
        }
      }
#line 1822
      break;
    }
#line 1823
    break;
    TARGET_RAISE_VARARGS: 
#line 1828
    opcode = 130;
#line 1828
    next_instr += 2;
#line 1828
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 130: 
#line 1829
    w = (PyObject *)((void *)0);
#line 1829
    v = w;
#line 1830
    switch (oparg) {
    case 2: 
#line 1832
    stack_pointer --;
#line 1832
    v = *stack_pointer;
    case 1: 
#line 1834
    stack_pointer --;
#line 1834
    w = *stack_pointer;
    case 0: 
#line 1836
    why = do_raise(w, v);
#line 1837
    break;
    default: 
#line 1839
    PyErr_SetString(PyExc_SystemError, "bad RAISE_VARARGS oparg");
#line 1841
    why = (enum why_code )2;
#line 1842
    break;
    }
#line 1844
    break;
    TARGET_STORE_LOCALS: 
#line 1846
    opcode = 69;
    case 69: 
#line 1847
    stack_pointer --;
#line 1847
    x = *stack_pointer;
#line 1848
    v = f->f_locals;
#line 1849
    while (1) {
#line 1849
      if ((unsigned int )v == (unsigned int )((void *)0)) {

      } else {
#line 1849
        while (1) {
#line 1849
          (v->ob_refcnt) --;
#line 1849
          if (v->ob_refcnt != 0) {

          } else {
#line 1849
            (*((v->ob_type)->tp_dealloc))(v);
          }
#line 1849
          break;
        }
      }
#line 1849
      break;
    }
#line 1850
    f->f_locals = x;
#line 1851
    atomic_val___41 = & eval_breaker;
#line 1851
    volatile_data___41 = (int volatile   *)(& atomic_val___41->_value);
#line 1851
    order___41 = (_Py_memory_order )0;
#line 1851
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___41,
                              order___41);
#line 1851
    switch ((int )order___41) {
    case 2: 
    case 3: 
    case 4: 
#line 1851
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1851
    break;
    default: ;
#line 1851
    break;
    }
#line 1851
    result___40 = (int )*volatile_data___41;
#line 1851
    switch ((int )order___41) {
    case 1: 
    case 3: 
    case 4: 
#line 1851
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1851
    break;
    default: ;
#line 1851
    break;
    }
#line 1851
    if (result___40) {

    } else {
#line 1851
      if (! _Py_TracingPossible) {
#line 1851
        f->f_lasti = next_instr - first_instr;
#line 1851
        tmp___55 = next_instr;
#line 1851
        next_instr ++;
#line 1851
        __compgoto = (int )opcode_targets[*tmp___55];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_RETURN_VALUE: 
#line 1853
    opcode = 83;
    case 83: 
#line 1854
    stack_pointer --;
#line 1854
    retval = *stack_pointer;
#line 1855
    why = (enum why_code )8;
    goto fast_block_end;
    TARGET_YIELD_VALUE: 
#line 1858
    opcode = 86;
    case 86: 
#line 1859
    stack_pointer --;
#line 1859
    retval = *stack_pointer;
#line 1860
    f->f_stacktop = stack_pointer;
#line 1861
    why = (enum why_code )64;
#line 1865
    tmp___56 = tstate->exc_type;
#line 1865
    tstate->exc_type = f->f_exc_type;
#line 1865
    f->f_exc_type = tmp___56;
#line 1865
    tmp___56 = tstate->exc_value;
#line 1865
    tstate->exc_value = f->f_exc_value;
#line 1865
    f->f_exc_value = tmp___56;
#line 1865
    tmp___56 = tstate->exc_traceback;
#line 1865
    tstate->exc_traceback = f->f_exc_traceback;
#line 1865
    f->f_exc_traceback = tmp___56;
    goto  4841;
    TARGET_POP_EXCEPT: 
#line 1868
    opcode = 89;
    case 89: 
#line 1870
    tmp___57 = PyFrame_BlockPop(f);
#line 1870
    b = tmp___57;
#line 1871
    if (b->b_type != 257) {
#line 1872
      PyErr_SetString(PyExc_SystemError, "popped block is not an except handler");
#line 1874
      why = (enum why_code )2;
#line 1875
      break;
    } else {

    }
#line 1877
    while (stack_pointer - f->f_valuestack > b->b_level + 3) {
#line 1877
      stack_pointer --;
#line 1877
      value___0 = *stack_pointer;
#line 1877
      while (1) {
#line 1877
        if ((unsigned int )value___0 == (unsigned int )((void *)0)) {

        } else {
#line 1877
          while (1) {
#line 1877
            (value___0->ob_refcnt) --;
#line 1877
            if (value___0->ob_refcnt != 0) {

            } else {
#line 1877
              (*((value___0->ob_type)->tp_dealloc))(value___0);
            }
#line 1877
            break;
          }
        }
#line 1877
        break;
      }
    }
#line 1877
    type___0 = tstate->exc_type;
#line 1877
    value___0 = tstate->exc_value;
#line 1877
    traceback___0 = tstate->exc_traceback;
#line 1877
    stack_pointer --;
#line 1877
    tstate->exc_type = *stack_pointer;
#line 1877
    stack_pointer --;
#line 1877
    tstate->exc_value = *stack_pointer;
#line 1877
    stack_pointer --;
#line 1877
    tstate->exc_traceback = *stack_pointer;
#line 1877
    while (1) {
#line 1877
      if ((unsigned int )type___0 == (unsigned int )((void *)0)) {

      } else {
#line 1877
        while (1) {
#line 1877
          (type___0->ob_refcnt) --;
#line 1877
          if (type___0->ob_refcnt != 0) {

          } else {
#line 1877
            (*((type___0->ob_type)->tp_dealloc))(type___0);
          }
#line 1877
          break;
        }
      }
#line 1877
      break;
    }
#line 1877
    while (1) {
#line 1877
      if ((unsigned int )value___0 == (unsigned int )((void *)0)) {

      } else {
#line 1877
        while (1) {
#line 1877
          (value___0->ob_refcnt) --;
#line 1877
          if (value___0->ob_refcnt != 0) {

          } else {
#line 1877
            (*((value___0->ob_type)->tp_dealloc))(value___0);
          }
#line 1877
          break;
        }
      }
#line 1877
      break;
    }
#line 1877
    while (1) {
#line 1877
      if ((unsigned int )traceback___0 == (unsigned int )((void *)0)) {

      } else {
#line 1877
        while (1) {
#line 1877
          (traceback___0->ob_refcnt) --;
#line 1877
          if (traceback___0->ob_refcnt != 0) {

          } else {
#line 1877
            (*((traceback___0->ob_type)->tp_dealloc))(traceback___0);
          }
#line 1877
          break;
        }
      }
#line 1877
      break;
    }
#line 1879
    atomic_val___42 = & eval_breaker;
#line 1879
    volatile_data___42 = (int volatile   *)(& atomic_val___42->_value);
#line 1879
    order___42 = (_Py_memory_order )0;
#line 1879
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___42,
                              order___42);
#line 1879
    switch ((int )order___42) {
    case 2: 
    case 3: 
    case 4: 
#line 1879
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1879
    break;
    default: ;
#line 1879
    break;
    }
#line 1879
    result___41 = (int )*volatile_data___42;
#line 1879
    switch ((int )order___42) {
    case 1: 
    case 3: 
    case 4: 
#line 1879
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1879
    break;
    default: ;
#line 1879
    break;
    }
#line 1879
    if (result___41) {

    } else {
#line 1879
      if (! _Py_TracingPossible) {
#line 1879
        f->f_lasti = next_instr - first_instr;
#line 1879
        tmp___58 = next_instr;
#line 1879
        next_instr ++;
#line 1879
        __compgoto = (int )opcode_targets[*tmp___58];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_POP_BLOCK: 
#line 1881
    opcode = 87;
    case 87: 
#line 1883
    tmp___59 = PyFrame_BlockPop(f);
#line 1883
    b___0 = tmp___59;
#line 1884
    while (stack_pointer - f->f_valuestack > b___0->b_level) {
#line 1884
      stack_pointer --;
#line 1884
      v___0 = *stack_pointer;
#line 1884
      while (1) {
#line 1884
        if ((unsigned int )v___0 == (unsigned int )((void *)0)) {

        } else {
#line 1884
          while (1) {
#line 1884
            (v___0->ob_refcnt) --;
#line 1884
            if (v___0->ob_refcnt != 0) {

            } else {
#line 1884
              (*((v___0->ob_type)->tp_dealloc))(v___0);
            }
#line 1884
            break;
          }
        }
#line 1884
        break;
      }
    }
#line 1886
    atomic_val___43 = & eval_breaker;
#line 1886
    volatile_data___43 = (int volatile   *)(& atomic_val___43->_value);
#line 1886
    order___43 = (_Py_memory_order )0;
#line 1886
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___43,
                              order___43);
#line 1886
    switch ((int )order___43) {
    case 2: 
    case 3: 
    case 4: 
#line 1886
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1886
    break;
    default: ;
#line 1886
    break;
    }
#line 1886
    result___42 = (int )*volatile_data___43;
#line 1886
    switch ((int )order___43) {
    case 1: 
    case 3: 
    case 4: 
#line 1886
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1886
    break;
    default: ;
#line 1886
    break;
    }
#line 1886
    if (result___42) {

    } else {
#line 1886
      if (! _Py_TracingPossible) {
#line 1886
        f->f_lasti = next_instr - first_instr;
#line 1886
        tmp___60 = next_instr;
#line 1886
        next_instr ++;
#line 1886
        __compgoto = (int )opcode_targets[*tmp___60];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    PRED_END_FINALLY: ;
    TARGET_END_FINALLY: 
#line 1889
    opcode = 88;
    case 88: 
#line 1890
    stack_pointer --;
#line 1890
    v = *stack_pointer;
#line 1891
    if (((v->ob_type)->tp_flags & (1L << 24)) != 0L) {
#line 1892
      tmp___61 = PyLong_AsLong(v);
#line 1892
      why = (enum why_code )tmp___61;
#line 1894
      if ((unsigned int )why == 8U) {
#line 1896
        stack_pointer --;
#line 1896
        retval = *stack_pointer;
      } else {
#line 1894
        if ((unsigned int )why == 32U) {
#line 1896
          stack_pointer --;
#line 1896
          retval = *stack_pointer;
        } else {

        }
      }
#line 1897
      if ((unsigned int )why == 128U) {
#line 1902
        tmp___62 = PyFrame_BlockPop(f);
#line 1902
        b___1 = tmp___62;
#line 1904
        while (stack_pointer - f->f_valuestack > b___1->b_level + 3) {
#line 1904
          stack_pointer --;
#line 1904
          value___1 = *stack_pointer;
#line 1904
          while (1) {
#line 1904
            if ((unsigned int )value___1 == (unsigned int )((void *)0)) {

            } else {
#line 1904
              while (1) {
#line 1904
                (value___1->ob_refcnt) --;
#line 1904
                if (value___1->ob_refcnt != 0) {

                } else {
#line 1904
                  (*((value___1->ob_type)->tp_dealloc))(value___1);
                }
#line 1904
                break;
              }
            }
#line 1904
            break;
          }
        }
#line 1904
        type___1 = tstate->exc_type;
#line 1904
        value___1 = tstate->exc_value;
#line 1904
        traceback___1 = tstate->exc_traceback;
#line 1904
        stack_pointer --;
#line 1904
        tstate->exc_type = *stack_pointer;
#line 1904
        stack_pointer --;
#line 1904
        tstate->exc_value = *stack_pointer;
#line 1904
        stack_pointer --;
#line 1904
        tstate->exc_traceback = *stack_pointer;
#line 1904
        while (1) {
#line 1904
          if ((unsigned int )type___1 == (unsigned int )((void *)0)) {

          } else {
#line 1904
            while (1) {
#line 1904
              (type___1->ob_refcnt) --;
#line 1904
              if (type___1->ob_refcnt != 0) {

              } else {
#line 1904
                (*((type___1->ob_type)->tp_dealloc))(type___1);
              }
#line 1904
              break;
            }
          }
#line 1904
          break;
        }
#line 1904
        while (1) {
#line 1904
          if ((unsigned int )value___1 == (unsigned int )((void *)0)) {

          } else {
#line 1904
            while (1) {
#line 1904
              (value___1->ob_refcnt) --;
#line 1904
              if (value___1->ob_refcnt != 0) {

              } else {
#line 1904
                (*((value___1->ob_type)->tp_dealloc))(value___1);
              }
#line 1904
              break;
            }
          }
#line 1904
          break;
        }
#line 1904
        while (1) {
#line 1904
          if ((unsigned int )traceback___1 == (unsigned int )((void *)0)) {

          } else {
#line 1904
            while (1) {
#line 1904
              (traceback___1->ob_refcnt) --;
#line 1904
              if (traceback___1->ob_refcnt != 0) {

              } else {
#line 1904
                (*((traceback___1->ob_type)->tp_dealloc))(traceback___1);
              }
#line 1904
              break;
            }
          }
#line 1904
          break;
        }
#line 1905
        why = (enum why_code )1;
      } else {

      }
    } else {
#line 1908
      if (((v->ob_type)->tp_flags & (1L << 31)) != 0L) {
#line 1908
        if ((((PyTypeObject *)v)->tp_flags & (1L << 30)) != 0L) {
#line 1909
          stack_pointer --;
#line 1909
          w = *stack_pointer;
#line 1910
          stack_pointer --;
#line 1910
          u = *stack_pointer;
#line 1911
          PyErr_Restore(v, w, u);
#line 1912
          why = (enum why_code )4;
#line 1913
          break;
        } else {
          goto _L___0;
        }
      } else {
        _L___0: /* CIL Label */ 
#line 1915
        if ((unsigned int )v != (unsigned int )(& _Py_NoneStruct)) {
#line 1916
          PyErr_SetString(PyExc_SystemError, "\'finally\' pops bad exception");
#line 1918
          why = (enum why_code )2;
        } else {

        }
      }
    }
#line 1920
    while (1) {
#line 1920
      (v->ob_refcnt) --;
#line 1920
      if (v->ob_refcnt != 0) {

      } else {
#line 1920
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1920
      break;
    }
#line 1921
    break;
    TARGET_LOAD_BUILD_CLASS: 
#line 1923
    opcode = 71;
    case 71: 
#line 1924
    x = PyDict_GetItemString(f->f_builtins, "__build_class__");
#line 1926
    if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 1927
      PyErr_SetString(PyExc_ImportError, "__build_class__ not found");
#line 1929
      break;
    } else {

    }
#line 1931
    (x->ob_refcnt) ++;
#line 1932
    tmp___63 = stack_pointer;
#line 1932
    stack_pointer ++;
#line 1932
    *tmp___63 = x;
#line 1933
    break;
    TARGET_STORE_NAME: 
#line 1935
    opcode = 90;
#line 1935
    next_instr += 2;
#line 1935
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 90: 
#line 1936
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 1937
    stack_pointer --;
#line 1937
    v = *stack_pointer;
#line 1938
    x = f->f_locals;
#line 1938
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1939
      if ((unsigned int )x->ob_type == (unsigned int )(& PyDict_Type)) {
#line 1940
        err = PyDict_SetItem(x, w, v);
      } else {
#line 1942
        err = PyObject_SetItem(x, w, v);
      }
#line 1943
      while (1) {
#line 1943
        (v->ob_refcnt) --;
#line 1943
        if (v->ob_refcnt != 0) {

        } else {
#line 1943
          (*((v->ob_type)->tp_dealloc))(v);
        }
#line 1943
        break;
      }
#line 1944
      if (err == 0) {
#line 1944
        atomic_val___44 = & eval_breaker;
#line 1944
        volatile_data___44 = (int volatile   *)(& atomic_val___44->_value);
#line 1944
        order___44 = (_Py_memory_order )0;
#line 1944
        _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___44,
                                  order___44);
#line 1944
        switch ((int )order___44) {
        case 2: 
        case 3: 
        case 4: 
#line 1944
        _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1944
        break;
        default: ;
#line 1944
        break;
        }
#line 1944
        result___43 = (int )*volatile_data___44;
#line 1944
        switch ((int )order___44) {
        case 1: 
        case 3: 
        case 4: 
#line 1944
        _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1944
        break;
        default: ;
#line 1944
        break;
        }
#line 1944
        if (result___43) {

        } else {
#line 1944
          if (! _Py_TracingPossible) {
#line 1944
            f->f_lasti = next_instr - first_instr;
#line 1944
            tmp___64 = next_instr;
#line 1944
            next_instr ++;
#line 1944
            __compgoto = (int )opcode_targets[*tmp___64];
            goto __docompgoto;
          } else {

          }
          goto fast_next_opcode;
        }
        goto __Cont;
      } else {

      }
#line 1945
      break;
    } else {

    }
#line 1947
    PyErr_Format(PyExc_SystemError, "no locals found when storing %R", w);
#line 1949
    break;
    TARGET_DELETE_NAME: 
#line 1951
    opcode = 91;
#line 1951
    next_instr += 2;
#line 1951
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 91: 
#line 1952
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 1953
    x = f->f_locals;
#line 1953
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 1954
      err = PyObject_DelItem(x, w);
#line 1954
      if (err != 0) {
#line 1955
        format_exc_check_arg(PyExc_NameError, "name \'%.200s\' is not defined",
                             w);
      } else {

      }
#line 1958
      break;
    } else {

    }
#line 1960
    PyErr_Format(PyExc_SystemError, "no locals when deleting %R", w);
#line 1962
    break;
    PRED_UNPACK_SEQUENCE: ;
    TARGET_UNPACK_SEQUENCE: 
#line 1965
    opcode = 92;
#line 1965
    next_instr += 2;
#line 1965
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 92: 
#line 1966
    stack_pointer --;
#line 1966
    v = *stack_pointer;
#line 1967
    if ((unsigned int )v->ob_type == (unsigned int )(& PyTuple_Type)) {
#line 1967
      if (((PyVarObject *)v)->ob_size == oparg) {
#line 1969
        items = ((PyTupleObject *)v)->ob_item;
#line 1971
        while (1) {
#line 1971
          tmp___66 = oparg;
#line 1971
          oparg --;
#line 1971
          if (tmp___66) {

          } else {
#line 1971
            break;
          }
#line 1972
          w = *(items + oparg);
#line 1973
          (w->ob_refcnt) ++;
#line 1974
          tmp___65 = stack_pointer;
#line 1974
          stack_pointer ++;
#line 1974
          *tmp___65 = w;
        }
#line 1976
        while (1) {
#line 1976
          (v->ob_refcnt) --;
#line 1976
          if (v->ob_refcnt != 0) {

          } else {
#line 1976
            (*((v->ob_type)->tp_dealloc))(v);
          }
#line 1976
          break;
        }
#line 1977
        atomic_val___45 = & eval_breaker;
#line 1977
        volatile_data___45 = (int volatile   *)(& atomic_val___45->_value);
#line 1977
        order___45 = (_Py_memory_order )0;
#line 1977
        _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___45,
                                  order___45);
#line 1977
        switch ((int )order___45) {
        case 2: 
        case 3: 
        case 4: 
#line 1977
        _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 1977
        break;
        default: ;
#line 1977
        break;
        }
#line 1977
        result___44 = (int )*volatile_data___45;
#line 1977
        switch ((int )order___45) {
        case 1: 
        case 3: 
        case 4: 
#line 1977
        _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 1977
        break;
        default: ;
#line 1977
        break;
        }
#line 1977
        if (result___44) {

        } else {
#line 1977
          if (! _Py_TracingPossible) {
#line 1977
            f->f_lasti = next_instr - first_instr;
#line 1977
            tmp___67 = next_instr;
#line 1977
            next_instr ++;
#line 1977
            __compgoto = (int )opcode_targets[*tmp___67];
            goto __docompgoto;
          } else {

          }
          goto fast_next_opcode;
        }
        goto __Cont;
      } else {
        goto _L___2;
      }
    } else {
      _L___2: /* CIL Label */ 
#line 1978
      if ((unsigned int )v->ob_type == (unsigned int )(& PyList_Type)) {
#line 1978
        if (((PyVarObject *)v)->ob_size == oparg) {
#line 1980
          items___0 = ((PyListObject *)v)->ob_item;
#line 1982
          while (1) {
#line 1982
            tmp___69 = oparg;
#line 1982
            oparg --;
#line 1982
            if (tmp___69) {

            } else {
#line 1982
              break;
            }
#line 1983
            w = *(items___0 + oparg);
#line 1984
            (w->ob_refcnt) ++;
#line 1985
            tmp___68 = stack_pointer;
#line 1985
            stack_pointer ++;
#line 1985
            *tmp___68 = w;
          }
        } else {
          goto _L___1;
        }
      } else {
        _L___1: /* CIL Label */ 
#line 1987
        tmp___70 = unpack_iterable(v, oparg, -1, stack_pointer + oparg);
#line 1987
        if (tmp___70) {
#line 1989
          stack_pointer += oparg;
        } else {
#line 1992
          why = (enum why_code )2;
        }
      }
    }
#line 1994
    while (1) {
#line 1994
      (v->ob_refcnt) --;
#line 1994
      if (v->ob_refcnt != 0) {

      } else {
#line 1994
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 1994
      break;
    }
#line 1995
    break;
    TARGET_UNPACK_EX: 
#line 1997
    opcode = 94;
#line 1997
    next_instr += 2;
#line 1997
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 94: 
#line 1999
    totalargs = (1 + (oparg & 0xFF)) + (oparg >> 8);
#line 2000
    stack_pointer --;
#line 2000
    v = *stack_pointer;
#line 2002
    tmp___71 = unpack_iterable(v, oparg & 0xFF, oparg >> 8,
                               stack_pointer + totalargs);
#line 2002
    if (tmp___71) {
#line 2004
      stack_pointer += totalargs;
    } else {
#line 2006
      why = (enum why_code )2;
    }
#line 2008
    while (1) {
#line 2008
      (v->ob_refcnt) --;
#line 2008
      if (v->ob_refcnt != 0) {

      } else {
#line 2008
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2008
      break;
    }
#line 2009
    break;
    TARGET_STORE_ATTR: 
#line 2012
    opcode = 95;
#line 2012
    next_instr += 2;
#line 2012
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 95: 
#line 2013
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 2014
    v = *(stack_pointer + -1);
#line 2015
    u = *(stack_pointer + -2);
#line 2016
    stack_pointer += -2;
#line 2017
    err = PyObject_SetAttr(v, w, u);
#line 2018
    while (1) {
#line 2018
      (v->ob_refcnt) --;
#line 2018
      if (v->ob_refcnt != 0) {

      } else {
#line 2018
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2018
      break;
    }
#line 2019
    while (1) {
#line 2019
      (u->ob_refcnt) --;
#line 2019
      if (u->ob_refcnt != 0) {

      } else {
#line 2019
        (*((u->ob_type)->tp_dealloc))(u);
      }
#line 2019
      break;
    }
#line 2020
    if (err == 0) {
#line 2020
      atomic_val___46 = & eval_breaker;
#line 2020
      volatile_data___46 = (int volatile   *)(& atomic_val___46->_value);
#line 2020
      order___46 = (_Py_memory_order )0;
#line 2020
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___46,
                                order___46);
#line 2020
      switch ((int )order___46) {
      case 2: 
      case 3: 
      case 4: 
#line 2020
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2020
      break;
      default: ;
#line 2020
      break;
      }
#line 2020
      result___45 = (int )*volatile_data___46;
#line 2020
      switch ((int )order___46) {
      case 1: 
      case 3: 
      case 4: 
#line 2020
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2020
      break;
      default: ;
#line 2020
      break;
      }
#line 2020
      if (result___45) {

      } else {
#line 2020
        if (! _Py_TracingPossible) {
#line 2020
          f->f_lasti = next_instr - first_instr;
#line 2020
          tmp___72 = next_instr;
#line 2020
          next_instr ++;
#line 2020
          __compgoto = (int )opcode_targets[*tmp___72];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2021
    break;
    TARGET_DELETE_ATTR: 
#line 2023
    opcode = 96;
#line 2023
    next_instr += 2;
#line 2023
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 96: 
#line 2024
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 2025
    stack_pointer --;
#line 2025
    v = *stack_pointer;
#line 2026
    err = PyObject_SetAttr(v, w, (PyObject *)((void *)0));
#line 2028
    while (1) {
#line 2028
      (v->ob_refcnt) --;
#line 2028
      if (v->ob_refcnt != 0) {

      } else {
#line 2028
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2028
      break;
    }
#line 2029
    break;
    TARGET_STORE_GLOBAL: 
#line 2031
    opcode = 97;
#line 2031
    next_instr += 2;
#line 2031
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 97: 
#line 2032
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 2033
    stack_pointer --;
#line 2033
    v = *stack_pointer;
#line 2034
    err = PyDict_SetItem(f->f_globals, w, v);
#line 2035
    while (1) {
#line 2035
      (v->ob_refcnt) --;
#line 2035
      if (v->ob_refcnt != 0) {

      } else {
#line 2035
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2035
      break;
    }
#line 2036
    if (err == 0) {
#line 2036
      atomic_val___47 = & eval_breaker;
#line 2036
      volatile_data___47 = (int volatile   *)(& atomic_val___47->_value);
#line 2036
      order___47 = (_Py_memory_order )0;
#line 2036
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___47,
                                order___47);
#line 2036
      switch ((int )order___47) {
      case 2: 
      case 3: 
      case 4: 
#line 2036
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2036
      break;
      default: ;
#line 2036
      break;
      }
#line 2036
      result___46 = (int )*volatile_data___47;
#line 2036
      switch ((int )order___47) {
      case 1: 
      case 3: 
      case 4: 
#line 2036
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2036
      break;
      default: ;
#line 2036
      break;
      }
#line 2036
      if (result___46) {

      } else {
#line 2036
        if (! _Py_TracingPossible) {
#line 2036
          f->f_lasti = next_instr - first_instr;
#line 2036
          tmp___73 = next_instr;
#line 2036
          next_instr ++;
#line 2036
          __compgoto = (int )opcode_targets[*tmp___73];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2037
    break;
    TARGET_DELETE_GLOBAL: 
#line 2039
    opcode = 98;
#line 2039
    next_instr += 2;
#line 2039
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 98: 
#line 2040
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 2041
    err = PyDict_DelItem(f->f_globals, w);
#line 2041
    if (err != 0) {
#line 2042
      format_exc_check_arg(PyExc_NameError,
                           "global name \'%.200s\' is not defined", w);
    } else {

    }
#line 2044
    break;
    TARGET_LOAD_NAME: 
#line 2046
    opcode = 101;
#line 2046
    next_instr += 2;
#line 2046
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 101: 
#line 2047
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 2048
    v = f->f_locals;
#line 2048
    if ((unsigned int )v == (unsigned int )((void *)0)) {
#line 2049
      PyErr_Format(PyExc_SystemError, "no locals when loading %R", w);
#line 2051
      why = (enum why_code )2;
#line 2052
      break;
    } else {

    }
#line 2054
    if ((unsigned int )v->ob_type == (unsigned int )(& PyDict_Type)) {
#line 2055
      x = PyDict_GetItem(v, w);
#line 2056
      while (1) {
#line 2056
        if ((unsigned int )x == (unsigned int )((void *)0)) {

        } else {
#line 2056
          (x->ob_refcnt) ++;
        }
#line 2056
        break;
      }
    } else {
#line 2059
      x = PyObject_GetItem(v, w);
#line 2060
      if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 2060
        tmp___75 = PyErr_Occurred();
#line 2060
        if (tmp___75) {
#line 2061
          tmp___74 = PyErr_ExceptionMatches(PyExc_KeyError);
#line 2061
          if (tmp___74) {

          } else {
#line 2063
            break;
          }
#line 2064
          PyErr_Clear();
        } else {

        }
      } else {

      }
    }
#line 2067
    if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 2068
      x = PyDict_GetItem(f->f_globals, w);
#line 2069
      if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 2070
        x = PyDict_GetItem(f->f_builtins, w);
#line 2071
        if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 2072
          format_exc_check_arg(PyExc_NameError,
                               "name \'%.200s\' is not defined", w);
#line 2075
          break;
        } else {

        }
      } else {

      }
#line 2078
      (x->ob_refcnt) ++;
    } else {

    }
#line 2080
    tmp___76 = stack_pointer;
#line 2080
    stack_pointer ++;
#line 2080
    *tmp___76 = x;
#line 2081
    atomic_val___48 = & eval_breaker;
#line 2081
    volatile_data___48 = (int volatile   *)(& atomic_val___48->_value);
#line 2081
    order___48 = (_Py_memory_order )0;
#line 2081
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___48,
                              order___48);
#line 2081
    switch ((int )order___48) {
    case 2: 
    case 3: 
    case 4: 
#line 2081
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2081
    break;
    default: ;
#line 2081
    break;
    }
#line 2081
    result___47 = (int )*volatile_data___48;
#line 2081
    switch ((int )order___48) {
    case 1: 
    case 3: 
    case 4: 
#line 2081
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2081
    break;
    default: ;
#line 2081
    break;
    }
#line 2081
    if (result___47) {

    } else {
#line 2081
      if (! _Py_TracingPossible) {
#line 2081
        f->f_lasti = next_instr - first_instr;
#line 2081
        tmp___77 = next_instr;
#line 2081
        next_instr ++;
#line 2081
        __compgoto = (int )opcode_targets[*tmp___77];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_LOAD_GLOBAL: 
#line 2083
    opcode = 116;
#line 2083
    next_instr += 2;
#line 2083
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 116: 
#line 2084
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 2085
    if ((unsigned int )w->ob_type == (unsigned int )(& PyUnicode_Type)) {
#line 2089
      hash = ((PyUnicodeObject *)w)->hash;
#line 2090
      if (hash != -1) {
#line 2093
        d = (PyDictObject *)f->f_globals;
#line 2094
        e = (*(d->ma_lookup))(d, w, hash);
#line 2095
        if ((unsigned int )e == (unsigned int )((void *)0)) {
#line 2096
          x = (PyObject *)((void *)0);
#line 2097
          break;
        } else {

        }
#line 2099
        x = e->me_value;
#line 2100
        if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2101
          (x->ob_refcnt) ++;
#line 2102
          tmp___78 = stack_pointer;
#line 2102
          stack_pointer ++;
#line 2102
          *tmp___78 = x;
#line 2103
          atomic_val___49 = & eval_breaker;
#line 2103
          volatile_data___49 = (int volatile   *)(& atomic_val___49->_value);
#line 2103
          order___49 = (_Py_memory_order )0;
#line 2103
          _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___49,
                                    order___49);
#line 2103
          switch ((int )order___49) {
          case 2: 
          case 3: 
          case 4: 
#line 2103
          _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2103
          break;
          default: ;
#line 2103
          break;
          }
#line 2103
          result___48 = (int )*volatile_data___49;
#line 2103
          switch ((int )order___49) {
          case 1: 
          case 3: 
          case 4: 
#line 2103
          _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2103
          break;
          default: ;
#line 2103
          break;
          }
#line 2103
          if (result___48) {

          } else {
#line 2103
            if (! _Py_TracingPossible) {
#line 2103
              f->f_lasti = next_instr - first_instr;
#line 2103
              tmp___79 = next_instr;
#line 2103
              next_instr ++;
#line 2103
              __compgoto = (int )opcode_targets[*tmp___79];
              goto __docompgoto;
            } else {

            }
            goto fast_next_opcode;
          }
          goto __Cont;
        } else {

        }
#line 2105
        d = (PyDictObject *)f->f_builtins;
#line 2106
        e = (*(d->ma_lookup))(d, w, hash);
#line 2107
        if ((unsigned int )e == (unsigned int )((void *)0)) {
#line 2108
          x = (PyObject *)((void *)0);
#line 2109
          break;
        } else {

        }
#line 2111
        x = e->me_value;
#line 2112
        if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2113
          (x->ob_refcnt) ++;
#line 2114
          tmp___80 = stack_pointer;
#line 2114
          stack_pointer ++;
#line 2114
          *tmp___80 = x;
#line 2115
          atomic_val___50 = & eval_breaker;
#line 2115
          volatile_data___50 = (int volatile   *)(& atomic_val___50->_value);
#line 2115
          order___50 = (_Py_memory_order )0;
#line 2115
          _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___50,
                                    order___50);
#line 2115
          switch ((int )order___50) {
          case 2: 
          case 3: 
          case 4: 
#line 2115
          _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2115
          break;
          default: ;
#line 2115
          break;
          }
#line 2115
          result___49 = (int )*volatile_data___50;
#line 2115
          switch ((int )order___50) {
          case 1: 
          case 3: 
          case 4: 
#line 2115
          _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2115
          break;
          default: ;
#line 2115
          break;
          }
#line 2115
          if (result___49) {

          } else {
#line 2115
            if (! _Py_TracingPossible) {
#line 2115
              f->f_lasti = next_instr - first_instr;
#line 2115
              tmp___81 = next_instr;
#line 2115
              next_instr ++;
#line 2115
              __compgoto = (int )opcode_targets[*tmp___81];
              goto __docompgoto;
            } else {

            }
            goto fast_next_opcode;
          }
          goto __Cont;
        } else {

        }
        goto load_global_error;
      } else {

      }
    } else {

    }
#line 2121
    x = PyDict_GetItem(f->f_globals, w);
#line 2122
    if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 2123
      x = PyDict_GetItem(f->f_builtins, w);
#line 2124
      if ((unsigned int )x == (unsigned int )((void *)0)) {
        load_global_error: 
#line 2126
        format_exc_check_arg(PyExc_NameError,
                             "global name \'%.200s\' is not defined", w);
#line 2129
        break;
      } else {

      }
    } else {

    }
#line 2132
    (x->ob_refcnt) ++;
#line 2133
    tmp___82 = stack_pointer;
#line 2133
    stack_pointer ++;
#line 2133
    *tmp___82 = x;
#line 2134
    atomic_val___51 = & eval_breaker;
#line 2134
    volatile_data___51 = (int volatile   *)(& atomic_val___51->_value);
#line 2134
    order___51 = (_Py_memory_order )0;
#line 2134
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___51,
                              order___51);
#line 2134
    switch ((int )order___51) {
    case 2: 
    case 3: 
    case 4: 
#line 2134
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2134
    break;
    default: ;
#line 2134
    break;
    }
#line 2134
    result___50 = (int )*volatile_data___51;
#line 2134
    switch ((int )order___51) {
    case 1: 
    case 3: 
    case 4: 
#line 2134
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2134
    break;
    default: ;
#line 2134
    break;
    }
#line 2134
    if (result___50) {

    } else {
#line 2134
      if (! _Py_TracingPossible) {
#line 2134
        f->f_lasti = next_instr - first_instr;
#line 2134
        tmp___83 = next_instr;
#line 2134
        next_instr ++;
#line 2134
        __compgoto = (int )opcode_targets[*tmp___83];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_DELETE_FAST: 
#line 2136
    opcode = 126;
#line 2136
    next_instr += 2;
#line 2136
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 126: 
#line 2137
    x = *(fastlocals + oparg);
#line 2138
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2139
      while (1) {
#line 2139
        tmp___84 = *(fastlocals + oparg);
#line 2139
        *(fastlocals + oparg) = (PyObject *)((void *)0);
#line 2139
        while (1) {
#line 2139
          if ((unsigned int )tmp___84 == (unsigned int )((void *)0)) {

          } else {
#line 2139
            while (1) {
#line 2139
              (tmp___84->ob_refcnt) --;
#line 2139
              if (tmp___84->ob_refcnt != 0) {

              } else {
#line 2139
                (*((tmp___84->ob_type)->tp_dealloc))(tmp___84);
              }
#line 2139
              break;
            }
          }
#line 2139
          break;
        }
#line 2139
        break;
      }
#line 2140
      atomic_val___52 = & eval_breaker;
#line 2140
      volatile_data___52 = (int volatile   *)(& atomic_val___52->_value);
#line 2140
      order___52 = (_Py_memory_order )0;
#line 2140
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___52,
                                order___52);
#line 2140
      switch ((int )order___52) {
      case 2: 
      case 3: 
      case 4: 
#line 2140
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2140
      break;
      default: ;
#line 2140
      break;
      }
#line 2140
      result___51 = (int )*volatile_data___52;
#line 2140
      switch ((int )order___52) {
      case 1: 
      case 3: 
      case 4: 
#line 2140
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2140
      break;
      default: ;
#line 2140
      break;
      }
#line 2140
      if (result___51) {

      } else {
#line 2140
        if (! _Py_TracingPossible) {
#line 2140
          f->f_lasti = next_instr - first_instr;
#line 2140
          tmp___85 = next_instr;
#line 2140
          next_instr ++;
#line 2140
          __compgoto = (int )opcode_targets[*tmp___85];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2142
    tmp___86 = PyTuple_GetItem(co->co_varnames, oparg);
#line 2142
    format_exc_check_arg(PyExc_UnboundLocalError,
                         "local variable \'%.200s\' referenced before assignment",
                         tmp___86);
#line 2147
    break;
    TARGET_DELETE_DEREF: 
#line 2149
    opcode = 138;
#line 2149
    next_instr += 2;
#line 2149
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 138: 
#line 2150
    x = *(freevars + oparg);
#line 2151
    if ((unsigned int )((PyCellObject *)x)->ob_ref != (unsigned int )((void *)0)) {
#line 2152
      PyCell_Set(x, (PyObject *)((void *)0));
#line 2153
      atomic_val___53 = & eval_breaker;
#line 2153
      volatile_data___53 = (int volatile   *)(& atomic_val___53->_value);
#line 2153
      order___53 = (_Py_memory_order )0;
#line 2153
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___53,
                                order___53);
#line 2153
      switch ((int )order___53) {
      case 2: 
      case 3: 
      case 4: 
#line 2153
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2153
      break;
      default: ;
#line 2153
      break;
      }
#line 2153
      result___52 = (int )*volatile_data___53;
#line 2153
      switch ((int )order___53) {
      case 1: 
      case 3: 
      case 4: 
#line 2153
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2153
      break;
      default: ;
#line 2153
      break;
      }
#line 2153
      if (result___52) {

      } else {
#line 2153
        if (! _Py_TracingPossible) {
#line 2153
          f->f_lasti = next_instr - first_instr;
#line 2153
          tmp___87 = next_instr;
#line 2153
          next_instr ++;
#line 2153
          __compgoto = (int )opcode_targets[*tmp___87];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2155
    err = -1;
#line 2156
    format_exc_unbound(co, oparg);
#line 2157
    break;
    TARGET_LOAD_CLOSURE: 
#line 2159
    opcode = 135;
#line 2159
    next_instr += 2;
#line 2159
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 135: 
#line 2160
    x = *(freevars + oparg);
#line 2161
    (x->ob_refcnt) ++;
#line 2162
    tmp___88 = stack_pointer;
#line 2162
    stack_pointer ++;
#line 2162
    *tmp___88 = x;
#line 2163
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2163
      atomic_val___54 = & eval_breaker;
#line 2163
      volatile_data___54 = (int volatile   *)(& atomic_val___54->_value);
#line 2163
      order___54 = (_Py_memory_order )0;
#line 2163
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___54,
                                order___54);
#line 2163
      switch ((int )order___54) {
      case 2: 
      case 3: 
      case 4: 
#line 2163
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2163
      break;
      default: ;
#line 2163
      break;
      }
#line 2163
      result___53 = (int )*volatile_data___54;
#line 2163
      switch ((int )order___54) {
      case 1: 
      case 3: 
      case 4: 
#line 2163
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2163
      break;
      default: ;
#line 2163
      break;
      }
#line 2163
      if (result___53) {

      } else {
#line 2163
        if (! _Py_TracingPossible) {
#line 2163
          f->f_lasti = next_instr - first_instr;
#line 2163
          tmp___89 = next_instr;
#line 2163
          next_instr ++;
#line 2163
          __compgoto = (int )opcode_targets[*tmp___89];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2164
    break;
    TARGET_LOAD_DEREF: 
#line 2166
    opcode = 136;
#line 2166
    next_instr += 2;
#line 2166
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 136: 
#line 2167
    x = *(freevars + oparg);
#line 2168
    w = PyCell_Get(x);
#line 2169
    if ((unsigned int )w != (unsigned int )((void *)0)) {
#line 2170
      tmp___90 = stack_pointer;
#line 2170
      stack_pointer ++;
#line 2170
      *tmp___90 = w;
#line 2171
      atomic_val___55 = & eval_breaker;
#line 2171
      volatile_data___55 = (int volatile   *)(& atomic_val___55->_value);
#line 2171
      order___55 = (_Py_memory_order )0;
#line 2171
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___55,
                                order___55);
#line 2171
      switch ((int )order___55) {
      case 2: 
      case 3: 
      case 4: 
#line 2171
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2171
      break;
      default: ;
#line 2171
      break;
      }
#line 2171
      result___54 = (int )*volatile_data___55;
#line 2171
      switch ((int )order___55) {
      case 1: 
      case 3: 
      case 4: 
#line 2171
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2171
      break;
      default: ;
#line 2171
      break;
      }
#line 2171
      if (result___54) {

      } else {
#line 2171
        if (! _Py_TracingPossible) {
#line 2171
          f->f_lasti = next_instr - first_instr;
#line 2171
          tmp___91 = next_instr;
#line 2171
          next_instr ++;
#line 2171
          __compgoto = (int )opcode_targets[*tmp___91];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2173
    err = -1;
#line 2174
    format_exc_unbound(co, oparg);
#line 2175
    break;
    TARGET_STORE_DEREF: 
#line 2177
    opcode = 137;
#line 2177
    next_instr += 2;
#line 2177
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 137: 
#line 2178
    stack_pointer --;
#line 2178
    w = *stack_pointer;
#line 2179
    x = *(freevars + oparg);
#line 2180
    PyCell_Set(x, w);
#line 2181
    while (1) {
#line 2181
      (w->ob_refcnt) --;
#line 2181
      if (w->ob_refcnt != 0) {

      } else {
#line 2181
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 2181
      break;
    }
#line 2182
    atomic_val___56 = & eval_breaker;
#line 2182
    volatile_data___56 = (int volatile   *)(& atomic_val___56->_value);
#line 2182
    order___56 = (_Py_memory_order )0;
#line 2182
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___56,
                              order___56);
#line 2182
    switch ((int )order___56) {
    case 2: 
    case 3: 
    case 4: 
#line 2182
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2182
    break;
    default: ;
#line 2182
    break;
    }
#line 2182
    result___55 = (int )*volatile_data___56;
#line 2182
    switch ((int )order___56) {
    case 1: 
    case 3: 
    case 4: 
#line 2182
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2182
    break;
    default: ;
#line 2182
    break;
    }
#line 2182
    if (result___55) {

    } else {
#line 2182
      if (! _Py_TracingPossible) {
#line 2182
        f->f_lasti = next_instr - first_instr;
#line 2182
        tmp___92 = next_instr;
#line 2182
        next_instr ++;
#line 2182
        __compgoto = (int )opcode_targets[*tmp___92];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_BUILD_TUPLE: 
#line 2184
    opcode = 102;
#line 2184
    next_instr += 2;
#line 2184
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 102: 
#line 2185
    x = PyTuple_New(oparg);
#line 2186
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2187
      while (1) {
#line 2187
        oparg --;
#line 2187
        if (oparg >= 0) {

        } else {
#line 2187
          break;
        }
#line 2188
        stack_pointer --;
#line 2188
        w = *stack_pointer;
#line 2189
        ((PyTupleObject *)x)->ob_item[oparg] = w;
      }
#line 2191
      tmp___93 = stack_pointer;
#line 2191
      stack_pointer ++;
#line 2191
      *tmp___93 = x;
#line 2192
      atomic_val___57 = & eval_breaker;
#line 2192
      volatile_data___57 = (int volatile   *)(& atomic_val___57->_value);
#line 2192
      order___57 = (_Py_memory_order )0;
#line 2192
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___57,
                                order___57);
#line 2192
      switch ((int )order___57) {
      case 2: 
      case 3: 
      case 4: 
#line 2192
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2192
      break;
      default: ;
#line 2192
      break;
      }
#line 2192
      result___56 = (int )*volatile_data___57;
#line 2192
      switch ((int )order___57) {
      case 1: 
      case 3: 
      case 4: 
#line 2192
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2192
      break;
      default: ;
#line 2192
      break;
      }
#line 2192
      if (result___56) {

      } else {
#line 2192
        if (! _Py_TracingPossible) {
#line 2192
          f->f_lasti = next_instr - first_instr;
#line 2192
          tmp___94 = next_instr;
#line 2192
          next_instr ++;
#line 2192
          __compgoto = (int )opcode_targets[*tmp___94];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2194
    break;
    TARGET_BUILD_LIST: 
#line 2196
    opcode = 103;
#line 2196
    next_instr += 2;
#line 2196
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 103: 
#line 2197
    x = PyList_New(oparg);
#line 2198
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2199
      while (1) {
#line 2199
        oparg --;
#line 2199
        if (oparg >= 0) {

        } else {
#line 2199
          break;
        }
#line 2200
        stack_pointer --;
#line 2200
        w = *stack_pointer;
#line 2201
        *(((PyListObject *)x)->ob_item + oparg) = w;
      }
#line 2203
      tmp___95 = stack_pointer;
#line 2203
      stack_pointer ++;
#line 2203
      *tmp___95 = x;
#line 2204
      atomic_val___58 = & eval_breaker;
#line 2204
      volatile_data___58 = (int volatile   *)(& atomic_val___58->_value);
#line 2204
      order___58 = (_Py_memory_order )0;
#line 2204
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___58,
                                order___58);
#line 2204
      switch ((int )order___58) {
      case 2: 
      case 3: 
      case 4: 
#line 2204
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2204
      break;
      default: ;
#line 2204
      break;
      }
#line 2204
      result___57 = (int )*volatile_data___58;
#line 2204
      switch ((int )order___58) {
      case 1: 
      case 3: 
      case 4: 
#line 2204
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2204
      break;
      default: ;
#line 2204
      break;
      }
#line 2204
      if (result___57) {

      } else {
#line 2204
        if (! _Py_TracingPossible) {
#line 2204
          f->f_lasti = next_instr - first_instr;
#line 2204
          tmp___96 = next_instr;
#line 2204
          next_instr ++;
#line 2204
          __compgoto = (int )opcode_targets[*tmp___96];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2206
    break;
    TARGET_BUILD_SET: 
#line 2208
    opcode = 104;
#line 2208
    next_instr += 2;
#line 2208
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 104: 
#line 2209
    x = PySet_New((PyObject *)((void *)0));
#line 2210
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2211
      while (1) {
#line 2211
        oparg --;
#line 2211
        if (oparg >= 0) {

        } else {
#line 2211
          break;
        }
#line 2212
        stack_pointer --;
#line 2212
        w = *stack_pointer;
#line 2213
        if (err == 0) {
#line 2214
          err = PySet_Add(x, w);
        } else {

        }
#line 2215
        while (1) {
#line 2215
          (w->ob_refcnt) --;
#line 2215
          if (w->ob_refcnt != 0) {

          } else {
#line 2215
            (*((w->ob_type)->tp_dealloc))(w);
          }
#line 2215
          break;
        }
      }
#line 2217
      if (err != 0) {
#line 2218
        while (1) {
#line 2218
          (x->ob_refcnt) --;
#line 2218
          if (x->ob_refcnt != 0) {

          } else {
#line 2218
            (*((x->ob_type)->tp_dealloc))(x);
          }
#line 2218
          break;
        }
#line 2219
        break;
      } else {

      }
#line 2221
      tmp___97 = stack_pointer;
#line 2221
      stack_pointer ++;
#line 2221
      *tmp___97 = x;
#line 2222
      atomic_val___59 = & eval_breaker;
#line 2222
      volatile_data___59 = (int volatile   *)(& atomic_val___59->_value);
#line 2222
      order___59 = (_Py_memory_order )0;
#line 2222
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___59,
                                order___59);
#line 2222
      switch ((int )order___59) {
      case 2: 
      case 3: 
      case 4: 
#line 2222
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2222
      break;
      default: ;
#line 2222
      break;
      }
#line 2222
      result___58 = (int )*volatile_data___59;
#line 2222
      switch ((int )order___59) {
      case 1: 
      case 3: 
      case 4: 
#line 2222
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2222
      break;
      default: ;
#line 2222
      break;
      }
#line 2222
      if (result___58) {

      } else {
#line 2222
        if (! _Py_TracingPossible) {
#line 2222
          f->f_lasti = next_instr - first_instr;
#line 2222
          tmp___98 = next_instr;
#line 2222
          next_instr ++;
#line 2222
          __compgoto = (int )opcode_targets[*tmp___98];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2224
    break;
    TARGET_BUILD_MAP: 
#line 2226
    opcode = 105;
#line 2226
    next_instr += 2;
#line 2226
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 105: 
#line 2227
    x = _PyDict_NewPresized(oparg);
#line 2228
    tmp___99 = stack_pointer;
#line 2228
    stack_pointer ++;
#line 2228
    *tmp___99 = x;
#line 2229
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2229
      atomic_val___60 = & eval_breaker;
#line 2229
      volatile_data___60 = (int volatile   *)(& atomic_val___60->_value);
#line 2229
      order___60 = (_Py_memory_order )0;
#line 2229
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___60,
                                order___60);
#line 2229
      switch ((int )order___60) {
      case 2: 
      case 3: 
      case 4: 
#line 2229
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2229
      break;
      default: ;
#line 2229
      break;
      }
#line 2229
      result___59 = (int )*volatile_data___60;
#line 2229
      switch ((int )order___60) {
      case 1: 
      case 3: 
      case 4: 
#line 2229
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2229
      break;
      default: ;
#line 2229
      break;
      }
#line 2229
      if (result___59) {

      } else {
#line 2229
        if (! _Py_TracingPossible) {
#line 2229
          f->f_lasti = next_instr - first_instr;
#line 2229
          tmp___100 = next_instr;
#line 2229
          next_instr ++;
#line 2229
          __compgoto = (int )opcode_targets[*tmp___100];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2230
    break;
    TARGET_STORE_MAP: 
#line 2232
    opcode = 54;
    case 54: 
#line 2233
    w = *(stack_pointer + -1);
#line 2234
    u = *(stack_pointer + -2);
#line 2235
    v = *(stack_pointer + -3);
#line 2236
    stack_pointer += -2;
#line 2238
    err = PyDict_SetItem(v, w, u);
#line 2239
    while (1) {
#line 2239
      (u->ob_refcnt) --;
#line 2239
      if (u->ob_refcnt != 0) {

      } else {
#line 2239
        (*((u->ob_type)->tp_dealloc))(u);
      }
#line 2239
      break;
    }
#line 2240
    while (1) {
#line 2240
      (w->ob_refcnt) --;
#line 2240
      if (w->ob_refcnt != 0) {

      } else {
#line 2240
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 2240
      break;
    }
#line 2241
    if (err == 0) {
#line 2241
      atomic_val___61 = & eval_breaker;
#line 2241
      volatile_data___61 = (int volatile   *)(& atomic_val___61->_value);
#line 2241
      order___61 = (_Py_memory_order )0;
#line 2241
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___61,
                                order___61);
#line 2241
      switch ((int )order___61) {
      case 2: 
      case 3: 
      case 4: 
#line 2241
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2241
      break;
      default: ;
#line 2241
      break;
      }
#line 2241
      result___60 = (int )*volatile_data___61;
#line 2241
      switch ((int )order___61) {
      case 1: 
      case 3: 
      case 4: 
#line 2241
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2241
      break;
      default: ;
#line 2241
      break;
      }
#line 2241
      if (result___60) {

      } else {
#line 2241
        if (! _Py_TracingPossible) {
#line 2241
          f->f_lasti = next_instr - first_instr;
#line 2241
          tmp___101 = next_instr;
#line 2241
          next_instr ++;
#line 2241
          __compgoto = (int )opcode_targets[*tmp___101];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2242
    break;
    TARGET_MAP_ADD: 
#line 2244
    opcode = 147;
#line 2244
    next_instr += 2;
#line 2244
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 147: 
#line 2245
    w = *(stack_pointer + -1);
#line 2246
    u = *(stack_pointer + -2);
#line 2247
    stack_pointer += -2;
#line 2248
    v = *(stack_pointer + - oparg);
#line 2250
    err = PyDict_SetItem(v, w, u);
#line 2251
    while (1) {
#line 2251
      (u->ob_refcnt) --;
#line 2251
      if (u->ob_refcnt != 0) {

      } else {
#line 2251
        (*((u->ob_type)->tp_dealloc))(u);
      }
#line 2251
      break;
    }
#line 2252
    while (1) {
#line 2252
      (w->ob_refcnt) --;
#line 2252
      if (w->ob_refcnt != 0) {

      } else {
#line 2252
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 2252
      break;
    }
#line 2253
    if (err == 0) {
#line 2255
      atomic_val___62 = & eval_breaker;
#line 2255
      volatile_data___62 = (int volatile   *)(& atomic_val___62->_value);
#line 2255
      order___62 = (_Py_memory_order )0;
#line 2255
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___62,
                                order___62);
#line 2255
      switch ((int )order___62) {
      case 2: 
      case 3: 
      case 4: 
#line 2255
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2255
      break;
      default: ;
#line 2255
      break;
      }
#line 2255
      result___61 = (int )*volatile_data___62;
#line 2255
      switch ((int )order___62) {
      case 1: 
      case 3: 
      case 4: 
#line 2255
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2255
      break;
      default: ;
#line 2255
      break;
      }
#line 2255
      if (result___61) {

      } else {
#line 2255
        if (! _Py_TracingPossible) {
#line 2255
          f->f_lasti = next_instr - first_instr;
#line 2255
          tmp___102 = next_instr;
#line 2255
          next_instr ++;
#line 2255
          __compgoto = (int )opcode_targets[*tmp___102];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2257
    break;
    TARGET_LOAD_ATTR: 
#line 2259
    opcode = 106;
#line 2259
    next_instr += 2;
#line 2259
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 106: 
#line 2260
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 2261
    v = *(stack_pointer + -1);
#line 2262
    x = PyObject_GetAttr(v, w);
#line 2263
    while (1) {
#line 2263
      (v->ob_refcnt) --;
#line 2263
      if (v->ob_refcnt != 0) {

      } else {
#line 2263
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2263
      break;
    }
#line 2264
    *(stack_pointer + -1) = x;
#line 2265
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2265
      atomic_val___63 = & eval_breaker;
#line 2265
      volatile_data___63 = (int volatile   *)(& atomic_val___63->_value);
#line 2265
      order___63 = (_Py_memory_order )0;
#line 2265
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___63,
                                order___63);
#line 2265
      switch ((int )order___63) {
      case 2: 
      case 3: 
      case 4: 
#line 2265
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2265
      break;
      default: ;
#line 2265
      break;
      }
#line 2265
      result___62 = (int )*volatile_data___63;
#line 2265
      switch ((int )order___63) {
      case 1: 
      case 3: 
      case 4: 
#line 2265
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2265
      break;
      default: ;
#line 2265
      break;
      }
#line 2265
      if (result___62) {

      } else {
#line 2265
        if (! _Py_TracingPossible) {
#line 2265
          f->f_lasti = next_instr - first_instr;
#line 2265
          tmp___103 = next_instr;
#line 2265
          next_instr ++;
#line 2265
          __compgoto = (int )opcode_targets[*tmp___103];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2266
    break;
    TARGET_COMPARE_OP: 
#line 2268
    opcode = 107;
#line 2268
    next_instr += 2;
#line 2268
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 107: 
#line 2269
    stack_pointer --;
#line 2269
    w = *stack_pointer;
#line 2270
    v = *(stack_pointer + -1);
#line 2271
    x = cmp_outcome(oparg, v, w);
#line 2272
    while (1) {
#line 2272
      (v->ob_refcnt) --;
#line 2272
      if (v->ob_refcnt != 0) {

      } else {
#line 2272
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2272
      break;
    }
#line 2273
    while (1) {
#line 2273
      (w->ob_refcnt) --;
#line 2273
      if (w->ob_refcnt != 0) {

      } else {
#line 2273
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 2273
      break;
    }
#line 2274
    *(stack_pointer + -1) = x;
#line 2275
    if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 2275
      break;
    } else {

    }
#line 2278
    atomic_val___64 = & eval_breaker;
#line 2278
    volatile_data___64 = (int volatile   *)(& atomic_val___64->_value);
#line 2278
    order___64 = (_Py_memory_order )0;
#line 2278
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___64,
                              order___64);
#line 2278
    switch ((int )order___64) {
    case 2: 
    case 3: 
    case 4: 
#line 2278
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2278
    break;
    default: ;
#line 2278
    break;
    }
#line 2278
    result___63 = (int )*volatile_data___64;
#line 2278
    switch ((int )order___64) {
    case 1: 
    case 3: 
    case 4: 
#line 2278
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2278
    break;
    default: ;
#line 2278
    break;
    }
#line 2278
    if (result___63) {

    } else {
#line 2278
      if (! _Py_TracingPossible) {
#line 2278
        f->f_lasti = next_instr - first_instr;
#line 2278
        tmp___104 = next_instr;
#line 2278
        next_instr ++;
#line 2278
        __compgoto = (int )opcode_targets[*tmp___104];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_IMPORT_NAME: 
#line 2280
    opcode = 108;
#line 2280
    next_instr += 2;
#line 2280
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 108: 
#line 2281
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 2282
    x = PyDict_GetItemString(f->f_builtins, "__import__");
#line 2283
    if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 2284
      PyErr_SetString(PyExc_ImportError, "__import__ not found");
#line 2286
      break;
    } else {

    }
#line 2288
    (x->ob_refcnt) ++;
#line 2289
    stack_pointer --;
#line 2289
    v = *stack_pointer;
#line 2290
    u = *(stack_pointer + -1);
#line 2291
    tmp___107 = PyLong_AsLong(u);
#line 2291
    if (tmp___107 != -1L) {
      goto _L___3;
    } else {
#line 2291
      tmp___108 = PyErr_Occurred();
#line 2291
      if (tmp___108) {
        _L___3: /* CIL Label */ 
#line 2292
        if ((unsigned int )f->f_locals == (unsigned int )((void *)0)) {
#line 2292
          tmp___105 = & _Py_NoneStruct;
        } else {
#line 2292
          tmp___105 = f->f_locals;
        }
#line 2292
        w = PyTuple_Pack(5, w, f->f_globals, tmp___105, v, u);
      } else {
#line 2300
        if ((unsigned int )f->f_locals == (unsigned int )((void *)0)) {
#line 2300
          tmp___106 = & _Py_NoneStruct;
        } else {
#line 2300
          tmp___106 = f->f_locals;
        }
#line 2300
        w = PyTuple_Pack(4, w, f->f_globals, tmp___106, v);
      }
    }
#line 2306
    while (1) {
#line 2306
      (v->ob_refcnt) --;
#line 2306
      if (v->ob_refcnt != 0) {

      } else {
#line 2306
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2306
      break;
    }
#line 2307
    while (1) {
#line 2307
      (u->ob_refcnt) --;
#line 2307
      if (u->ob_refcnt != 0) {

      } else {
#line 2307
        (*((u->ob_type)->tp_dealloc))(u);
      }
#line 2307
      break;
    }
#line 2308
    if ((unsigned int )w == (unsigned int )((void *)0)) {
#line 2309
      stack_pointer --;
#line 2309
      u = *stack_pointer;
#line 2310
      while (1) {
#line 2310
        (x->ob_refcnt) --;
#line 2310
        if (x->ob_refcnt != 0) {

        } else {
#line 2310
          (*((x->ob_type)->tp_dealloc))(x);
        }
#line 2310
        break;
      }
#line 2311
      x = (PyObject *)((void *)0);
#line 2312
      break;
    } else {

    }
#line 2315
    v = x;
#line 2316
    x = PyEval_CallObjectWithKeywords(v, w, (PyObject *)((void *)0));
#line 2317
    while (1) {
#line 2317
      (v->ob_refcnt) --;
#line 2317
      if (v->ob_refcnt != 0) {

      } else {
#line 2317
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2317
      break;
    }
#line 2319
    while (1) {
#line 2319
      (w->ob_refcnt) --;
#line 2319
      if (w->ob_refcnt != 0) {

      } else {
#line 2319
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 2319
      break;
    }
#line 2320
    *(stack_pointer + -1) = x;
#line 2321
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2321
      atomic_val___65 = & eval_breaker;
#line 2321
      volatile_data___65 = (int volatile   *)(& atomic_val___65->_value);
#line 2321
      order___65 = (_Py_memory_order )0;
#line 2321
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___65,
                                order___65);
#line 2321
      switch ((int )order___65) {
      case 2: 
      case 3: 
      case 4: 
#line 2321
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2321
      break;
      default: ;
#line 2321
      break;
      }
#line 2321
      result___64 = (int )*volatile_data___65;
#line 2321
      switch ((int )order___65) {
      case 1: 
      case 3: 
      case 4: 
#line 2321
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2321
      break;
      default: ;
#line 2321
      break;
      }
#line 2321
      if (result___64) {

      } else {
#line 2321
        if (! _Py_TracingPossible) {
#line 2321
          f->f_lasti = next_instr - first_instr;
#line 2321
          tmp___109 = next_instr;
#line 2321
          next_instr ++;
#line 2321
          __compgoto = (int )opcode_targets[*tmp___109];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2322
    break;
    TARGET_IMPORT_STAR: 
#line 2324
    opcode = 84;
    case 84: 
#line 2325
    stack_pointer --;
#line 2325
    v = *stack_pointer;
#line 2326
    PyFrame_FastToLocals(f);
#line 2327
    x = f->f_locals;
#line 2327
    if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 2328
      PyErr_SetString(PyExc_SystemError, "no locals found during \'import *\'");
#line 2330
      break;
    } else {

    }
#line 2333
    err = import_all_from(x, v);
#line 2335
    PyFrame_LocalsToFast(f, 0);
#line 2336
    while (1) {
#line 2336
      (v->ob_refcnt) --;
#line 2336
      if (v->ob_refcnt != 0) {

      } else {
#line 2336
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2336
      break;
    }
#line 2337
    if (err == 0) {
#line 2337
      atomic_val___66 = & eval_breaker;
#line 2337
      volatile_data___66 = (int volatile   *)(& atomic_val___66->_value);
#line 2337
      order___66 = (_Py_memory_order )0;
#line 2337
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___66,
                                order___66);
#line 2337
      switch ((int )order___66) {
      case 2: 
      case 3: 
      case 4: 
#line 2337
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2337
      break;
      default: ;
#line 2337
      break;
      }
#line 2337
      result___65 = (int )*volatile_data___66;
#line 2337
      switch ((int )order___66) {
      case 1: 
      case 3: 
      case 4: 
#line 2337
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2337
      break;
      default: ;
#line 2337
      break;
      }
#line 2337
      if (result___65) {

      } else {
#line 2337
        if (! _Py_TracingPossible) {
#line 2337
          f->f_lasti = next_instr - first_instr;
#line 2337
          tmp___110 = next_instr;
#line 2337
          next_instr ++;
#line 2337
          __compgoto = (int )opcode_targets[*tmp___110];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2338
    break;
    TARGET_IMPORT_FROM: 
#line 2340
    opcode = 109;
#line 2340
    next_instr += 2;
#line 2340
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 109: 
#line 2341
    w = ((PyTupleObject *)names)->ob_item[oparg];
#line 2342
    v = *(stack_pointer + -1);
#line 2344
    x = import_from(v, w);
#line 2346
    tmp___111 = stack_pointer;
#line 2346
    stack_pointer ++;
#line 2346
    *tmp___111 = x;
#line 2347
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2347
      atomic_val___67 = & eval_breaker;
#line 2347
      volatile_data___67 = (int volatile   *)(& atomic_val___67->_value);
#line 2347
      order___67 = (_Py_memory_order )0;
#line 2347
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___67,
                                order___67);
#line 2347
      switch ((int )order___67) {
      case 2: 
      case 3: 
      case 4: 
#line 2347
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2347
      break;
      default: ;
#line 2347
      break;
      }
#line 2347
      result___66 = (int )*volatile_data___67;
#line 2347
      switch ((int )order___67) {
      case 1: 
      case 3: 
      case 4: 
#line 2347
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2347
      break;
      default: ;
#line 2347
      break;
      }
#line 2347
      if (result___66) {

      } else {
#line 2347
        if (! _Py_TracingPossible) {
#line 2347
          f->f_lasti = next_instr - first_instr;
#line 2347
          tmp___112 = next_instr;
#line 2347
          next_instr ++;
#line 2347
          __compgoto = (int )opcode_targets[*tmp___112];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2348
    break;
    TARGET_JUMP_FORWARD: 
#line 2350
    opcode = 110;
#line 2350
    next_instr += 2;
#line 2350
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 110: 
#line 2351
    next_instr += oparg;
#line 2352
    if (! _Py_TracingPossible) {
#line 2352
      f->f_lasti = next_instr - first_instr;
#line 2352
      tmp___113 = next_instr;
#line 2352
      next_instr ++;
#line 2352
      __compgoto = (int )opcode_targets[*tmp___113];
      goto __docompgoto;
    } else {

    }
    goto fast_next_opcode;
    PRED_POP_JUMP_IF_FALSE: ;
    TARGET_POP_JUMP_IF_FALSE: 
#line 2355
    opcode = 114;
#line 2355
    next_instr += 2;
#line 2355
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 114: 
#line 2356
    stack_pointer --;
#line 2356
    w = *stack_pointer;
#line 2357
    if ((unsigned int )w == (unsigned int )((PyObject *)(& _Py_TrueStruct))) {
#line 2358
      while (1) {
#line 2358
        (w->ob_refcnt) --;
#line 2358
        if (w->ob_refcnt != 0) {

        } else {
#line 2358
          (*((w->ob_type)->tp_dealloc))(w);
        }
#line 2358
        break;
      }
#line 2359
      if (! _Py_TracingPossible) {
#line 2359
        f->f_lasti = next_instr - first_instr;
#line 2359
        tmp___114 = next_instr;
#line 2359
        next_instr ++;
#line 2359
        __compgoto = (int )opcode_targets[*tmp___114];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    } else {

    }
#line 2361
    if ((unsigned int )w == (unsigned int )((PyObject *)(& _Py_FalseStruct))) {
#line 2362
      while (1) {
#line 2362
        (w->ob_refcnt) --;
#line 2362
        if (w->ob_refcnt != 0) {

        } else {
#line 2362
          (*((w->ob_type)->tp_dealloc))(w);
        }
#line 2362
        break;
      }
#line 2363
      next_instr = first_instr + oparg;
#line 2364
      if (! _Py_TracingPossible) {
#line 2364
        f->f_lasti = next_instr - first_instr;
#line 2364
        tmp___115 = next_instr;
#line 2364
        next_instr ++;
#line 2364
        __compgoto = (int )opcode_targets[*tmp___115];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    } else {

    }
#line 2366
    err = PyObject_IsTrue(w);
#line 2367
    while (1) {
#line 2367
      (w->ob_refcnt) --;
#line 2367
      if (w->ob_refcnt != 0) {

      } else {
#line 2367
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 2367
      break;
    }
#line 2368
    if (err > 0) {
#line 2369
      err = 0;
    } else {
#line 2370
      if (err == 0) {
#line 2371
        next_instr = first_instr + oparg;
      } else {
#line 2373
        break;
      }
    }
#line 2374
    atomic_val___68 = & eval_breaker;
#line 2374
    volatile_data___68 = (int volatile   *)(& atomic_val___68->_value);
#line 2374
    order___68 = (_Py_memory_order )0;
#line 2374
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___68,
                              order___68);
#line 2374
    switch ((int )order___68) {
    case 2: 
    case 3: 
    case 4: 
#line 2374
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2374
    break;
    default: ;
#line 2374
    break;
    }
#line 2374
    result___67 = (int )*volatile_data___68;
#line 2374
    switch ((int )order___68) {
    case 1: 
    case 3: 
    case 4: 
#line 2374
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2374
    break;
    default: ;
#line 2374
    break;
    }
#line 2374
    if (result___67) {

    } else {
#line 2374
      if (! _Py_TracingPossible) {
#line 2374
        f->f_lasti = next_instr - first_instr;
#line 2374
        tmp___116 = next_instr;
#line 2374
        next_instr ++;
#line 2374
        __compgoto = (int )opcode_targets[*tmp___116];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    PRED_POP_JUMP_IF_TRUE: ;
    TARGET_POP_JUMP_IF_TRUE: 
#line 2377
    opcode = 115;
#line 2377
    next_instr += 2;
#line 2377
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 115: 
#line 2378
    stack_pointer --;
#line 2378
    w = *stack_pointer;
#line 2379
    if ((unsigned int )w == (unsigned int )((PyObject *)(& _Py_FalseStruct))) {
#line 2380
      while (1) {
#line 2380
        (w->ob_refcnt) --;
#line 2380
        if (w->ob_refcnt != 0) {

        } else {
#line 2380
          (*((w->ob_type)->tp_dealloc))(w);
        }
#line 2380
        break;
      }
#line 2381
      if (! _Py_TracingPossible) {
#line 2381
        f->f_lasti = next_instr - first_instr;
#line 2381
        tmp___117 = next_instr;
#line 2381
        next_instr ++;
#line 2381
        __compgoto = (int )opcode_targets[*tmp___117];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    } else {

    }
#line 2383
    if ((unsigned int )w == (unsigned int )((PyObject *)(& _Py_TrueStruct))) {
#line 2384
      while (1) {
#line 2384
        (w->ob_refcnt) --;
#line 2384
        if (w->ob_refcnt != 0) {

        } else {
#line 2384
          (*((w->ob_type)->tp_dealloc))(w);
        }
#line 2384
        break;
      }
#line 2385
      next_instr = first_instr + oparg;
#line 2386
      if (! _Py_TracingPossible) {
#line 2386
        f->f_lasti = next_instr - first_instr;
#line 2386
        tmp___118 = next_instr;
#line 2386
        next_instr ++;
#line 2386
        __compgoto = (int )opcode_targets[*tmp___118];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    } else {

    }
#line 2388
    err = PyObject_IsTrue(w);
#line 2389
    while (1) {
#line 2389
      (w->ob_refcnt) --;
#line 2389
      if (w->ob_refcnt != 0) {

      } else {
#line 2389
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 2389
      break;
    }
#line 2390
    if (err > 0) {
#line 2391
      err = 0;
#line 2392
      next_instr = first_instr + oparg;
    } else {
#line 2394
      if (err == 0) {

      } else {
#line 2397
        break;
      }
    }
#line 2398
    atomic_val___69 = & eval_breaker;
#line 2398
    volatile_data___69 = (int volatile   *)(& atomic_val___69->_value);
#line 2398
    order___69 = (_Py_memory_order )0;
#line 2398
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___69,
                              order___69);
#line 2398
    switch ((int )order___69) {
    case 2: 
    case 3: 
    case 4: 
#line 2398
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2398
    break;
    default: ;
#line 2398
    break;
    }
#line 2398
    result___68 = (int )*volatile_data___69;
#line 2398
    switch ((int )order___69) {
    case 1: 
    case 3: 
    case 4: 
#line 2398
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2398
    break;
    default: ;
#line 2398
    break;
    }
#line 2398
    if (result___68) {

    } else {
#line 2398
      if (! _Py_TracingPossible) {
#line 2398
        f->f_lasti = next_instr - first_instr;
#line 2398
        tmp___119 = next_instr;
#line 2398
        next_instr ++;
#line 2398
        __compgoto = (int )opcode_targets[*tmp___119];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_JUMP_IF_FALSE_OR_POP: 
#line 2400
    opcode = 111;
#line 2400
    next_instr += 2;
#line 2400
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 111: 
#line 2401
    w = *(stack_pointer + -1);
#line 2402
    if ((unsigned int )w == (unsigned int )((PyObject *)(& _Py_TrueStruct))) {
#line 2403
      stack_pointer --;
#line 2404
      while (1) {
#line 2404
        (w->ob_refcnt) --;
#line 2404
        if (w->ob_refcnt != 0) {

        } else {
#line 2404
          (*((w->ob_type)->tp_dealloc))(w);
        }
#line 2404
        break;
      }
#line 2405
      if (! _Py_TracingPossible) {
#line 2405
        f->f_lasti = next_instr - first_instr;
#line 2405
        tmp___120 = next_instr;
#line 2405
        next_instr ++;
#line 2405
        __compgoto = (int )opcode_targets[*tmp___120];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    } else {

    }
#line 2407
    if ((unsigned int )w == (unsigned int )((PyObject *)(& _Py_FalseStruct))) {
#line 2408
      next_instr = first_instr + oparg;
#line 2409
      if (! _Py_TracingPossible) {
#line 2409
        f->f_lasti = next_instr - first_instr;
#line 2409
        tmp___121 = next_instr;
#line 2409
        next_instr ++;
#line 2409
        __compgoto = (int )opcode_targets[*tmp___121];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    } else {

    }
#line 2411
    err = PyObject_IsTrue(w);
#line 2412
    if (err > 0) {
#line 2413
      stack_pointer --;
#line 2414
      while (1) {
#line 2414
        (w->ob_refcnt) --;
#line 2414
        if (w->ob_refcnt != 0) {

        } else {
#line 2414
          (*((w->ob_type)->tp_dealloc))(w);
        }
#line 2414
        break;
      }
#line 2415
      err = 0;
    } else {
#line 2417
      if (err == 0) {
#line 2418
        next_instr = first_instr + oparg;
      } else {
#line 2420
        break;
      }
    }
#line 2421
    atomic_val___70 = & eval_breaker;
#line 2421
    volatile_data___70 = (int volatile   *)(& atomic_val___70->_value);
#line 2421
    order___70 = (_Py_memory_order )0;
#line 2421
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___70,
                              order___70);
#line 2421
    switch ((int )order___70) {
    case 2: 
    case 3: 
    case 4: 
#line 2421
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2421
    break;
    default: ;
#line 2421
    break;
    }
#line 2421
    result___69 = (int )*volatile_data___70;
#line 2421
    switch ((int )order___70) {
    case 1: 
    case 3: 
    case 4: 
#line 2421
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2421
    break;
    default: ;
#line 2421
    break;
    }
#line 2421
    if (result___69) {

    } else {
#line 2421
      if (! _Py_TracingPossible) {
#line 2421
        f->f_lasti = next_instr - first_instr;
#line 2421
        tmp___122 = next_instr;
#line 2421
        next_instr ++;
#line 2421
        __compgoto = (int )opcode_targets[*tmp___122];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_JUMP_IF_TRUE_OR_POP: 
#line 2423
    opcode = 112;
#line 2423
    next_instr += 2;
#line 2423
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 112: 
#line 2424
    w = *(stack_pointer + -1);
#line 2425
    if ((unsigned int )w == (unsigned int )((PyObject *)(& _Py_FalseStruct))) {
#line 2426
      stack_pointer --;
#line 2427
      while (1) {
#line 2427
        (w->ob_refcnt) --;
#line 2427
        if (w->ob_refcnt != 0) {

        } else {
#line 2427
          (*((w->ob_type)->tp_dealloc))(w);
        }
#line 2427
        break;
      }
#line 2428
      if (! _Py_TracingPossible) {
#line 2428
        f->f_lasti = next_instr - first_instr;
#line 2428
        tmp___123 = next_instr;
#line 2428
        next_instr ++;
#line 2428
        __compgoto = (int )opcode_targets[*tmp___123];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    } else {

    }
#line 2430
    if ((unsigned int )w == (unsigned int )((PyObject *)(& _Py_TrueStruct))) {
#line 2431
      next_instr = first_instr + oparg;
#line 2432
      if (! _Py_TracingPossible) {
#line 2432
        f->f_lasti = next_instr - first_instr;
#line 2432
        tmp___124 = next_instr;
#line 2432
        next_instr ++;
#line 2432
        __compgoto = (int )opcode_targets[*tmp___124];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    } else {

    }
#line 2434
    err = PyObject_IsTrue(w);
#line 2435
    if (err > 0) {
#line 2436
      err = 0;
#line 2437
      next_instr = first_instr + oparg;
    } else {
#line 2439
      if (err == 0) {
#line 2440
        stack_pointer --;
#line 2441
        while (1) {
#line 2441
          (w->ob_refcnt) --;
#line 2441
          if (w->ob_refcnt != 0) {

          } else {
#line 2441
            (*((w->ob_type)->tp_dealloc))(w);
          }
#line 2441
          break;
        }
      } else {
#line 2444
        break;
      }
    }
#line 2445
    atomic_val___71 = & eval_breaker;
#line 2445
    volatile_data___71 = (int volatile   *)(& atomic_val___71->_value);
#line 2445
    order___71 = (_Py_memory_order )0;
#line 2445
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___71,
                              order___71);
#line 2445
    switch ((int )order___71) {
    case 2: 
    case 3: 
    case 4: 
#line 2445
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2445
    break;
    default: ;
#line 2445
    break;
    }
#line 2445
    result___70 = (int )*volatile_data___71;
#line 2445
    switch ((int )order___71) {
    case 1: 
    case 3: 
    case 4: 
#line 2445
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2445
    break;
    default: ;
#line 2445
    break;
    }
#line 2445
    if (result___70) {

    } else {
#line 2445
      if (! _Py_TracingPossible) {
#line 2445
        f->f_lasti = next_instr - first_instr;
#line 2445
        tmp___125 = next_instr;
#line 2445
        next_instr ++;
#line 2445
        __compgoto = (int )opcode_targets[*tmp___125];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    PRED_JUMP_ABSOLUTE: ;
    TARGET_JUMP_ABSOLUTE: 
#line 2448
    opcode = 113;
#line 2448
    next_instr += 2;
#line 2448
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 113: 
#line 2449
    next_instr = first_instr + oparg;
#line 2460
    atomic_val___72 = & eval_breaker;
#line 2460
    volatile_data___72 = (int volatile   *)(& atomic_val___72->_value);
#line 2460
    order___72 = (_Py_memory_order )0;
#line 2460
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___72,
                              order___72);
#line 2460
    switch ((int )order___72) {
    case 2: 
    case 3: 
    case 4: 
#line 2460
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2460
    break;
    default: ;
#line 2460
    break;
    }
#line 2460
    result___71 = (int )*volatile_data___72;
#line 2460
    switch ((int )order___72) {
    case 1: 
    case 3: 
    case 4: 
#line 2460
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2460
    break;
    default: ;
#line 2460
    break;
    }
#line 2460
    if (result___71) {

    } else {
#line 2460
      if (! _Py_TracingPossible) {
#line 2460
        f->f_lasti = next_instr - first_instr;
#line 2460
        tmp___126 = next_instr;
#line 2460
        next_instr ++;
#line 2460
        __compgoto = (int )opcode_targets[*tmp___126];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_GET_ITER: 
#line 2463
    opcode = 68;
    case 68: 
#line 2465
    v = *(stack_pointer + -1);
#line 2466
    x = PyObject_GetIter(v);
#line 2467
    while (1) {
#line 2467
      (v->ob_refcnt) --;
#line 2467
      if (v->ob_refcnt != 0) {

      } else {
#line 2467
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2467
      break;
    }
#line 2468
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2469
      *(stack_pointer + -1) = x;
#line 2471
      atomic_val___73 = & eval_breaker;
#line 2471
      volatile_data___73 = (int volatile   *)(& atomic_val___73->_value);
#line 2471
      order___73 = (_Py_memory_order )0;
#line 2471
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___73,
                                order___73);
#line 2471
      switch ((int )order___73) {
      case 2: 
      case 3: 
      case 4: 
#line 2471
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2471
      break;
      default: ;
#line 2471
      break;
      }
#line 2471
      result___72 = (int )*volatile_data___73;
#line 2471
      switch ((int )order___73) {
      case 1: 
      case 3: 
      case 4: 
#line 2471
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2471
      break;
      default: ;
#line 2471
      break;
      }
#line 2471
      if (result___72) {

      } else {
#line 2471
        if (! _Py_TracingPossible) {
#line 2471
          f->f_lasti = next_instr - first_instr;
#line 2471
          tmp___127 = next_instr;
#line 2471
          next_instr ++;
#line 2471
          __compgoto = (int )opcode_targets[*tmp___127];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2473
    stack_pointer --;
#line 2474
    break;
    PRED_FOR_ITER: ;
    TARGET_FOR_ITER: 
#line 2477
    opcode = 93;
#line 2477
    next_instr += 2;
#line 2477
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 93: 
#line 2479
    v = *(stack_pointer + -1);
#line 2480
    x = (*((v->ob_type)->tp_iternext))(v);
#line 2481
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2482
      tmp___128 = stack_pointer;
#line 2482
      stack_pointer ++;
#line 2482
      *tmp___128 = x;
#line 2485
      atomic_val___74 = & eval_breaker;
#line 2485
      volatile_data___74 = (int volatile   *)(& atomic_val___74->_value);
#line 2485
      order___74 = (_Py_memory_order )0;
#line 2485
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___74,
                                order___74);
#line 2485
      switch ((int )order___74) {
      case 2: 
      case 3: 
      case 4: 
#line 2485
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2485
      break;
      default: ;
#line 2485
      break;
      }
#line 2485
      result___73 = (int )*volatile_data___74;
#line 2485
      switch ((int )order___74) {
      case 1: 
      case 3: 
      case 4: 
#line 2485
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2485
      break;
      default: ;
#line 2485
      break;
      }
#line 2485
      if (result___73) {

      } else {
#line 2485
        if (! _Py_TracingPossible) {
#line 2485
          f->f_lasti = next_instr - first_instr;
#line 2485
          tmp___129 = next_instr;
#line 2485
          next_instr ++;
#line 2485
          __compgoto = (int )opcode_targets[*tmp___129];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2487
    tmp___131 = PyErr_Occurred();
#line 2487
    if (tmp___131) {
#line 2488
      tmp___130 = PyErr_ExceptionMatches(PyExc_StopIteration);
#line 2488
      if (tmp___130) {

      } else {
#line 2490
        break;
      }
#line 2491
      PyErr_Clear();
    } else {

    }
#line 2494
    stack_pointer --;
#line 2494
    v = *stack_pointer;
#line 2494
    x = v;
#line 2495
    while (1) {
#line 2495
      (v->ob_refcnt) --;
#line 2495
      if (v->ob_refcnt != 0) {

      } else {
#line 2495
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2495
      break;
    }
#line 2496
    next_instr += oparg;
#line 2497
    atomic_val___75 = & eval_breaker;
#line 2497
    volatile_data___75 = (int volatile   *)(& atomic_val___75->_value);
#line 2497
    order___75 = (_Py_memory_order )0;
#line 2497
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___75,
                              order___75);
#line 2497
    switch ((int )order___75) {
    case 2: 
    case 3: 
    case 4: 
#line 2497
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2497
    break;
    default: ;
#line 2497
    break;
    }
#line 2497
    result___74 = (int )*volatile_data___75;
#line 2497
    switch ((int )order___75) {
    case 1: 
    case 3: 
    case 4: 
#line 2497
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2497
    break;
    default: ;
#line 2497
    break;
    }
#line 2497
    if (result___74) {

    } else {
#line 2497
      if (! _Py_TracingPossible) {
#line 2497
        f->f_lasti = next_instr - first_instr;
#line 2497
        tmp___132 = next_instr;
#line 2497
        next_instr ++;
#line 2497
        __compgoto = (int )opcode_targets[*tmp___132];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_BREAK_LOOP: 
#line 2499
    opcode = 80;
    case 80: 
#line 2500
    why = (enum why_code )16;
    goto fast_block_end;
    TARGET_CONTINUE_LOOP: 
#line 2503
    opcode = 119;
#line 2503
    next_instr += 2;
#line 2503
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 119: 
#line 2504
    retval = PyLong_FromLong((long )oparg);
#line 2505
    if (! retval) {
#line 2506
      x = (PyObject *)((void *)0);
#line 2507
      break;
    } else {

    }
#line 2509
    why = (enum why_code )32;
    goto fast_block_end;
    TARGET_SETUP_LOOP: 
#line 2512
    opcode = 120;
#line 2512
    next_instr += 2;
#line 2512
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 120: 
    goto _setup_finally;
    TARGET_SETUP_EXCEPT: 
#line 2513
    opcode = 121;
#line 2513
    next_instr += 2;
#line 2513
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 121: 
    goto _setup_finally;
    TARGET_SETUP_FINALLY: 
#line 2514
    opcode = 122;
#line 2514
    next_instr += 2;
#line 2514
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 122: 
    _setup_finally: 
#line 2521
    PyFrame_BlockSetup(f, opcode, (next_instr - first_instr) + oparg,
                       stack_pointer - f->f_valuestack);
#line 2523
    atomic_val___76 = & eval_breaker;
#line 2523
    volatile_data___76 = (int volatile   *)(& atomic_val___76->_value);
#line 2523
    order___76 = (_Py_memory_order )0;
#line 2523
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___76,
                              order___76);
#line 2523
    switch ((int )order___76) {
    case 2: 
    case 3: 
    case 4: 
#line 2523
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2523
    break;
    default: ;
#line 2523
    break;
    }
#line 2523
    result___75 = (int )*volatile_data___76;
#line 2523
    switch ((int )order___76) {
    case 1: 
    case 3: 
    case 4: 
#line 2523
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2523
    break;
    default: ;
#line 2523
    break;
    }
#line 2523
    if (result___75) {

    } else {
#line 2523
      if (! _Py_TracingPossible) {
#line 2523
        f->f_lasti = next_instr - first_instr;
#line 2523
        tmp___133 = next_instr;
#line 2523
        next_instr ++;
#line 2523
        __compgoto = (int )opcode_targets[*tmp___133];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_SETUP_WITH: 
#line 2525
    opcode = 143;
#line 2525
    next_instr += 2;
#line 2525
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 143: 
#line 2528
    w = *(stack_pointer + -1);
#line 2529
    x = special_lookup(w, (char *)"__exit__", & exit___0);
#line 2530
    if (! x) {
#line 2531
      break;
    } else {

    }
#line 2532
    *(stack_pointer + -1) = x;
#line 2533
    u = special_lookup(w, (char *)"__enter__", & enter);
#line 2534
    while (1) {
#line 2534
      (w->ob_refcnt) --;
#line 2534
      if (w->ob_refcnt != 0) {

      } else {
#line 2534
        (*((w->ob_type)->tp_dealloc))(w);
      }
#line 2534
      break;
    }
#line 2535
    if (! u) {
#line 2536
      x = (PyObject *)((void *)0);
#line 2537
      break;
    } else {

    }
#line 2539
    x = PyObject_CallFunctionObjArgs(u, (void *)0);
#line 2540
    while (1) {
#line 2540
      (u->ob_refcnt) --;
#line 2540
      if (u->ob_refcnt != 0) {

      } else {
#line 2540
        (*((u->ob_type)->tp_dealloc))(u);
      }
#line 2540
      break;
    }
#line 2541
    if (! x) {
#line 2542
      break;
    } else {

    }
#line 2545
    PyFrame_BlockSetup(f, 122, (next_instr - first_instr) + oparg,
                       stack_pointer - f->f_valuestack);
#line 2548
    tmp___134 = stack_pointer;
#line 2548
    stack_pointer ++;
#line 2548
    *tmp___134 = x;
#line 2549
    atomic_val___77 = & eval_breaker;
#line 2549
    volatile_data___77 = (int volatile   *)(& atomic_val___77->_value);
#line 2549
    order___77 = (_Py_memory_order )0;
#line 2549
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___77,
                              order___77);
#line 2549
    switch ((int )order___77) {
    case 2: 
    case 3: 
    case 4: 
#line 2549
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2549
    break;
    default: ;
#line 2549
    break;
    }
#line 2549
    result___76 = (int )*volatile_data___77;
#line 2549
    switch ((int )order___77) {
    case 1: 
    case 3: 
    case 4: 
#line 2549
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2549
    break;
    default: ;
#line 2549
    break;
    }
#line 2549
    if (result___76) {

    } else {
#line 2549
      if (! _Py_TracingPossible) {
#line 2549
        f->f_lasti = next_instr - first_instr;
#line 2549
        tmp___135 = next_instr;
#line 2549
        next_instr ++;
#line 2549
        __compgoto = (int )opcode_targets[*tmp___135];
        goto __docompgoto;
      } else {

      }
      goto fast_next_opcode;
    }
    goto __Cont;
    TARGET_WITH_CLEANUP: 
#line 2552
    opcode = 81;
    case 81: 
#line 2580
    u = *(stack_pointer + -1);
#line 2581
    if ((unsigned int )u == (unsigned int )(& _Py_NoneStruct)) {
#line 2582
      stack_pointer --;
#line 2583
      exit_func = *(stack_pointer + -1);
#line 2584
      *(stack_pointer + -1) = u;
#line 2585
      w = & _Py_NoneStruct;
#line 2585
      v = w;
    } else {
#line 2587
      if (((u->ob_type)->tp_flags & (1L << 24)) != 0L) {
#line 2588
        stack_pointer --;
#line 2589
        tmp___136 = PyLong_AsLong(u);
#line 2589
        switch ((int )tmp___136) {
        case 8: 
        case 32: 
#line 2593
        exit_func = *(stack_pointer + -2);
#line 2594
        *(stack_pointer + -2) = *(stack_pointer + -1);
#line 2595
        *(stack_pointer + -1) = u;
#line 2596
        break;
        default: 
#line 2598
        exit_func = *(stack_pointer + -1);
#line 2599
        *(stack_pointer + -1) = u;
#line 2600
        break;
        }
#line 2602
        w = & _Py_NoneStruct;
#line 2602
        v = w;
#line 2602
        u = v;
      } else {
#line 2607
        v = *(stack_pointer + -2);
#line 2608
        w = *(stack_pointer + -3);
#line 2609
        tp = *(stack_pointer + -4);
#line 2610
        exc = *(stack_pointer + -5);
#line 2611
        tb = *(stack_pointer + -6);
#line 2612
        exit_func = *(stack_pointer + -7);
#line 2613
        *(stack_pointer + -7) = tb;
#line 2614
        *(stack_pointer + -6) = exc;
#line 2615
        *(stack_pointer + -5) = tp;
#line 2617
        *(stack_pointer + -4) = (PyObject *)((void *)0);
#line 2621
        block = & f->f_blockstack[f->f_iblock - 1];
#line 2623
        (block->b_level) --;
      }
    }
#line 2626
    x = PyObject_CallFunctionObjArgs(exit_func, u, v, w, (void *)0);
#line 2628
    while (1) {
#line 2628
      (exit_func->ob_refcnt) --;
#line 2628
      if (exit_func->ob_refcnt != 0) {

      } else {
#line 2628
        (*((exit_func->ob_type)->tp_dealloc))(exit_func);
      }
#line 2628
      break;
    }
#line 2629
    if ((unsigned int )x == (unsigned int )((void *)0)) {
#line 2630
      break;
    } else {

    }
#line 2632
    if ((unsigned int )u != (unsigned int )(& _Py_NoneStruct)) {
#line 2633
      err = PyObject_IsTrue(x);
    } else {
#line 2635
      err = 0;
    }
#line 2636
    while (1) {
#line 2636
      (x->ob_refcnt) --;
#line 2636
      if (x->ob_refcnt != 0) {

      } else {
#line 2636
        (*((x->ob_type)->tp_dealloc))(x);
      }
#line 2636
      break;
    }
#line 2638
    if (err < 0) {
#line 2639
      break;
    } else {
#line 2640
      if (err > 0) {
#line 2641
        err = 0;
#line 2643
        tmp___137 = stack_pointer;
#line 2643
        stack_pointer ++;
#line 2643
        *tmp___137 = PyLong_FromLong(128L);
      } else {

      }
    }
#line 2646
    break;
    TARGET_CALL_FUNCTION: 
#line 2649
    opcode = 131;
#line 2649
    next_instr += 2;
#line 2649
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 131: 
#line 2653
    sp = stack_pointer;
#line 2657
    x = call_function(& sp, oparg);
#line 2659
    stack_pointer = sp;
#line 2660
    tmp___138 = stack_pointer;
#line 2660
    stack_pointer ++;
#line 2660
    *tmp___138 = x;
#line 2661
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2662
      atomic_val___78 = & eval_breaker;
#line 2662
      volatile_data___78 = (int volatile   *)(& atomic_val___78->_value);
#line 2662
      order___78 = (_Py_memory_order )0;
#line 2662
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___78,
                                order___78);
#line 2662
      switch ((int )order___78) {
      case 2: 
      case 3: 
      case 4: 
#line 2662
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2662
      break;
      default: ;
#line 2662
      break;
      }
#line 2662
      result___77 = (int )*volatile_data___78;
#line 2662
      switch ((int )order___78) {
      case 1: 
      case 3: 
      case 4: 
#line 2662
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2662
      break;
      default: ;
#line 2662
      break;
      }
#line 2662
      if (result___77) {

      } else {
#line 2662
        if (! _Py_TracingPossible) {
#line 2662
          f->f_lasti = next_instr - first_instr;
#line 2662
          tmp___139 = next_instr;
#line 2662
          next_instr ++;
#line 2662
          __compgoto = (int )opcode_targets[*tmp___139];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2663
    break;
    TARGET_CALL_FUNCTION_VAR: 
#line 2666
    opcode = 140;
#line 2666
    next_instr += 2;
#line 2666
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 140: 
    goto _call_function_var_kw;
    TARGET_CALL_FUNCTION_KW: 
#line 2667
    opcode = 141;
#line 2667
    next_instr += 2;
#line 2667
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 141: 
    goto _call_function_var_kw;
    TARGET_CALL_FUNCTION_VAR_KW: 
#line 2668
    opcode = 142;
#line 2668
    next_instr += 2;
#line 2668
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 142: 
    _call_function_var_kw: 
#line 2671
    na = oparg & 0xff;
#line 2672
    nk = (oparg >> 8) & 0xff;
#line 2673
    flags = (opcode - 131) & 3;
#line 2674
    n = na + 2 * nk;
#line 2677
    if (flags & 1) {
#line 2678
      n ++;
    } else {

    }
#line 2679
    if (flags & 2) {
#line 2680
      n ++;
    } else {

    }
#line 2681
    pfunc = (stack_pointer - n) - 1;
#line 2682
    func = *pfunc;
#line 2684
    if ((unsigned int )func->ob_type == (unsigned int )(& PyMethod_Type)) {
#line 2684
      if ((unsigned int )((PyMethodObject *)func)->im_self != (unsigned int )((void *)0)) {
#line 2686
        self = ((PyMethodObject *)func)->im_self;
#line 2687
        (self->ob_refcnt) ++;
#line 2688
        func = ((PyMethodObject *)func)->im_func;
#line 2689
        (func->ob_refcnt) ++;
#line 2690
        while (1) {
#line 2690
          ((*pfunc)->ob_refcnt) --;
#line 2690
          if ((*pfunc)->ob_refcnt != 0) {

          } else {
#line 2690
            (*(((*pfunc)->ob_type)->tp_dealloc))(*pfunc);
          }
#line 2690
          break;
        }
#line 2691
        *pfunc = self;
#line 2692
        na ++;
      } else {
#line 2695
        (func->ob_refcnt) ++;
      }
    } else {
#line 2695
      (func->ob_refcnt) ++;
    }
#line 2696
    sp___0 = stack_pointer;
#line 2698
    x = ext_do_call(func, & sp___0, flags, na, nk);
#line 2700
    stack_pointer = sp___0;
#line 2701
    while (1) {
#line 2701
      (func->ob_refcnt) --;
#line 2701
      if (func->ob_refcnt != 0) {

      } else {
#line 2701
        (*((func->ob_type)->tp_dealloc))(func);
      }
#line 2701
      break;
    }
#line 2703
    while ((unsigned int )stack_pointer > (unsigned int )pfunc) {
#line 2704
      stack_pointer --;
#line 2704
      w = *stack_pointer;
#line 2705
      while (1) {
#line 2705
        (w->ob_refcnt) --;
#line 2705
        if (w->ob_refcnt != 0) {

        } else {
#line 2705
          (*((w->ob_type)->tp_dealloc))(w);
        }
#line 2705
        break;
      }
    }
#line 2707
    tmp___140 = stack_pointer;
#line 2707
    stack_pointer ++;
#line 2707
    *tmp___140 = x;
#line 2708
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2709
      atomic_val___79 = & eval_breaker;
#line 2709
      volatile_data___79 = (int volatile   *)(& atomic_val___79->_value);
#line 2709
      order___79 = (_Py_memory_order )0;
#line 2709
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___79,
                                order___79);
#line 2709
      switch ((int )order___79) {
      case 2: 
      case 3: 
      case 4: 
#line 2709
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2709
      break;
      default: ;
#line 2709
      break;
      }
#line 2709
      result___78 = (int )*volatile_data___79;
#line 2709
      switch ((int )order___79) {
      case 1: 
      case 3: 
      case 4: 
#line 2709
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2709
      break;
      default: ;
#line 2709
      break;
      }
#line 2709
      if (result___78) {

      } else {
#line 2709
        if (! _Py_TracingPossible) {
#line 2709
          f->f_lasti = next_instr - first_instr;
#line 2709
          tmp___141 = next_instr;
#line 2709
          next_instr ++;
#line 2709
          __compgoto = (int )opcode_targets[*tmp___141];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2710
    break;
    TARGET_MAKE_CLOSURE: 
#line 2713
    opcode = 134;
#line 2713
    next_instr += 2;
#line 2713
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 134: 
    goto _make_function;
    TARGET_MAKE_FUNCTION: 
#line 2714
    opcode = 132;
#line 2714
    next_instr += 2;
#line 2714
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 132: 
    _make_function: 
#line 2717
    posdefaults = oparg & 0xff;
#line 2718
    kwdefaults = (oparg >> 8) & 0xff;
#line 2719
    num_annotations = (oparg >> 16) & 0x7fff;
#line 2721
    stack_pointer --;
#line 2721
    v = *stack_pointer;
#line 2722
    x = PyFunction_New(v, f->f_globals);
#line 2723
    while (1) {
#line 2723
      (v->ob_refcnt) --;
#line 2723
      if (v->ob_refcnt != 0) {

      } else {
#line 2723
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2723
      break;
    }
#line 2725
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2725
      if (opcode == 134) {
#line 2726
        stack_pointer --;
#line 2726
        v = *stack_pointer;
#line 2727
        tmp___142 = PyFunction_SetClosure(x, v);
#line 2727
        if (tmp___142 != 0) {
#line 2729
          why = (enum why_code )2;
        } else {

        }
#line 2731
        while (1) {
#line 2731
          (v->ob_refcnt) --;
#line 2731
          if (v->ob_refcnt != 0) {

          } else {
#line 2731
            (*((v->ob_type)->tp_dealloc))(v);
          }
#line 2731
          break;
        }
      } else {

      }
    } else {

    }
#line 2734
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2734
      if (num_annotations > 0) {
#line 2736
        stack_pointer --;
#line 2736
        u = *stack_pointer;
#line 2737
        v = PyDict_New();
#line 2738
        if ((unsigned int )v == (unsigned int )((void *)0)) {
#line 2739
          while (1) {
#line 2739
            (x->ob_refcnt) --;
#line 2739
            if (x->ob_refcnt != 0) {

            } else {
#line 2739
              (*((x->ob_type)->tp_dealloc))(x);
            }
#line 2739
            break;
          }
#line 2740
          x = (PyObject *)((void *)0);
#line 2741
          break;
        } else {

        }
#line 2743
        name_ix = PyTuple_Size(u);
#line 2745
        while (name_ix > 0) {
#line 2746
          name_ix --;
#line 2747
          t = ((PyTupleObject *)u)->ob_item[name_ix];
#line 2748
          stack_pointer --;
#line 2748
          w = *stack_pointer;
#line 2750
          PyDict_SetItem(v, t, w);
#line 2751
          while (1) {
#line 2751
            (w->ob_refcnt) --;
#line 2751
            if (w->ob_refcnt != 0) {

            } else {
#line 2751
              (*((w->ob_type)->tp_dealloc))(w);
            }
#line 2751
            break;
          }
        }
#line 2754
        tmp___143 = PyFunction_SetAnnotations(x, v);
#line 2754
        if (tmp___143 != 0) {
#line 2757
          why = (enum why_code )2;
        } else {

        }
#line 2759
        while (1) {
#line 2759
          (v->ob_refcnt) --;
#line 2759
          if (v->ob_refcnt != 0) {

          } else {
#line 2759
            (*((v->ob_type)->tp_dealloc))(v);
          }
#line 2759
          break;
        }
#line 2760
        while (1) {
#line 2760
          (u->ob_refcnt) --;
#line 2760
          if (u->ob_refcnt != 0) {

          } else {
#line 2760
            (*((u->ob_type)->tp_dealloc))(u);
          }
#line 2760
          break;
        }
      } else {

      }
    } else {

    }
#line 2764
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2764
      if (posdefaults > 0) {
#line 2765
        v = PyTuple_New(posdefaults);
#line 2766
        if ((unsigned int )v == (unsigned int )((void *)0)) {
#line 2767
          while (1) {
#line 2767
            (x->ob_refcnt) --;
#line 2767
            if (x->ob_refcnt != 0) {

            } else {
#line 2767
              (*((x->ob_type)->tp_dealloc))(x);
            }
#line 2767
            break;
          }
#line 2768
          x = (PyObject *)((void *)0);
#line 2769
          break;
        } else {

        }
#line 2771
        while (1) {
#line 2771
          posdefaults --;
#line 2771
          if (posdefaults >= 0) {

          } else {
#line 2771
            break;
          }
#line 2772
          stack_pointer --;
#line 2772
          w = *stack_pointer;
#line 2773
          ((PyTupleObject *)v)->ob_item[posdefaults] = w;
        }
#line 2775
        tmp___144 = PyFunction_SetDefaults(x, v);
#line 2775
        if (tmp___144 != 0) {
#line 2778
          why = (enum why_code )2;
        } else {

        }
#line 2780
        while (1) {
#line 2780
          (v->ob_refcnt) --;
#line 2780
          if (v->ob_refcnt != 0) {

          } else {
#line 2780
            (*((v->ob_type)->tp_dealloc))(v);
          }
#line 2780
          break;
        }
      } else {

      }
    } else {

    }
#line 2782
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2782
      if (kwdefaults > 0) {
#line 2783
        v = PyDict_New();
#line 2784
        if ((unsigned int )v == (unsigned int )((void *)0)) {
#line 2785
          while (1) {
#line 2785
            (x->ob_refcnt) --;
#line 2785
            if (x->ob_refcnt != 0) {

            } else {
#line 2785
              (*((x->ob_type)->tp_dealloc))(x);
            }
#line 2785
            break;
          }
#line 2786
          x = (PyObject *)((void *)0);
#line 2787
          break;
        } else {

        }
#line 2789
        while (1) {
#line 2789
          kwdefaults --;
#line 2789
          if (kwdefaults >= 0) {

          } else {
#line 2789
            break;
          }
#line 2790
          stack_pointer --;
#line 2790
          w = *stack_pointer;
#line 2791
          stack_pointer --;
#line 2791
          u = *stack_pointer;
#line 2793
          PyDict_SetItem(v, u, w);
#line 2794
          while (1) {
#line 2794
            (w->ob_refcnt) --;
#line 2794
            if (w->ob_refcnt != 0) {

            } else {
#line 2794
              (*((w->ob_type)->tp_dealloc))(w);
            }
#line 2794
            break;
          }
#line 2795
          while (1) {
#line 2795
            (u->ob_refcnt) --;
#line 2795
            if (u->ob_refcnt != 0) {

            } else {
#line 2795
              (*((u->ob_type)->tp_dealloc))(u);
            }
#line 2795
            break;
          }
        }
#line 2797
        tmp___145 = PyFunction_SetKwDefaults(x, v);
#line 2797
        if (tmp___145 != 0) {
#line 2800
          why = (enum why_code )2;
        } else {

        }
#line 2802
        while (1) {
#line 2802
          (v->ob_refcnt) --;
#line 2802
          if (v->ob_refcnt != 0) {

          } else {
#line 2802
            (*((v->ob_type)->tp_dealloc))(v);
          }
#line 2802
          break;
        }
      } else {

      }
    } else {

    }
#line 2804
    tmp___146 = stack_pointer;
#line 2804
    stack_pointer ++;
#line 2804
    *tmp___146 = x;
#line 2805
    break;
    TARGET_BUILD_SLICE: 
#line 2808
    opcode = 133;
#line 2808
    next_instr += 2;
#line 2808
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 133: 
#line 2809
    if (oparg == 3) {
#line 2810
      stack_pointer --;
#line 2810
      w = *stack_pointer;
    } else {
#line 2812
      w = (PyObject *)((void *)0);
    }
#line 2813
    stack_pointer --;
#line 2813
    v = *stack_pointer;
#line 2814
    u = *(stack_pointer + -1);
#line 2815
    x = PySlice_New(u, v, w);
#line 2816
    while (1) {
#line 2816
      (u->ob_refcnt) --;
#line 2816
      if (u->ob_refcnt != 0) {

      } else {
#line 2816
        (*((u->ob_type)->tp_dealloc))(u);
      }
#line 2816
      break;
    }
#line 2817
    while (1) {
#line 2817
      (v->ob_refcnt) --;
#line 2817
      if (v->ob_refcnt != 0) {

      } else {
#line 2817
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 2817
      break;
    }
#line 2818
    while (1) {
#line 2818
      if ((unsigned int )w == (unsigned int )((void *)0)) {

      } else {
#line 2818
        while (1) {
#line 2818
          (w->ob_refcnt) --;
#line 2818
          if (w->ob_refcnt != 0) {

          } else {
#line 2818
            (*((w->ob_type)->tp_dealloc))(w);
          }
#line 2818
          break;
        }
      }
#line 2818
      break;
    }
#line 2819
    *(stack_pointer + -1) = x;
#line 2820
    if ((unsigned int )x != (unsigned int )((void *)0)) {
#line 2820
      atomic_val___80 = & eval_breaker;
#line 2820
      volatile_data___80 = (int volatile   *)(& atomic_val___80->_value);
#line 2820
      order___80 = (_Py_memory_order )0;
#line 2820
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___80,
                                order___80);
#line 2820
      switch ((int )order___80) {
      case 2: 
      case 3: 
      case 4: 
#line 2820
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 2820
      break;
      default: ;
#line 2820
      break;
      }
#line 2820
      result___79 = (int )*volatile_data___80;
#line 2820
      switch ((int )order___80) {
      case 1: 
      case 3: 
      case 4: 
#line 2820
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 2820
      break;
      default: ;
#line 2820
      break;
      }
#line 2820
      if (result___79) {

      } else {
#line 2820
        if (! _Py_TracingPossible) {
#line 2820
          f->f_lasti = next_instr - first_instr;
#line 2820
          tmp___147 = next_instr;
#line 2820
          next_instr ++;
#line 2820
          __compgoto = (int )opcode_targets[*tmp___147];
          goto __docompgoto;
        } else {

        }
        goto fast_next_opcode;
      }
      goto __Cont;
    } else {

    }
#line 2821
    break;
    TARGET_EXTENDED_ARG: 
#line 2823
    opcode = 144;
#line 2823
    next_instr += 2;
#line 2823
    oparg = ((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2);
    case 144: 
#line 2824
    tmp___148 = next_instr;
#line 2824
    next_instr ++;
#line 2824
    opcode = (int )*tmp___148;
#line 2825
    next_instr += 2;
#line 2825
    oparg = (oparg << 16) | (((int )*(next_instr + -1) << 8) + (int )*(next_instr + -2));
    goto dispatch_opcode;
    _unknown_opcode: 
    default: 
#line 2832
    tmp___149 = PyFrame_GetLineNumber(f);
#line 2832
    fprintf((FILE */* __restrict  */)stderr,
            (char const   */* __restrict  */)"XXX lineno: %d, opcode: %d\n",
            tmp___149, opcode);
#line 2836
    PyErr_SetString(PyExc_SystemError, "unknown opcode");
#line 2837
    why = (enum why_code )2;
#line 2838
    break;
    }
    on_error: ;
#line 2852
    if ((unsigned int )why == 1U) {
#line 2853
      if (err == 0) {
#line 2853
        if ((unsigned int )x != (unsigned int )((void *)0)) {
          goto __Cont;
        } else {

        }
      } else {

      }
#line 2867
      why = (enum why_code )2;
#line 2868
      x = & _Py_NoneStruct;
#line 2869
      err = 0;
    } else {

    }
#line 2874
    if ((unsigned int )why == 2U) {
      goto _L___4;
    } else {
#line 2874
      if ((unsigned int )why == 4U) {
        _L___4: /* CIL Label */ 
#line 2875
        tmp___150 = PyErr_Occurred();
#line 2875
        if (tmp___150) {

        } else {
#line 2876
          PyErr_SetString(PyExc_SystemError,
                          "error return without exception set");
#line 2878
          why = (enum why_code )2;
        }
      } else {

      }
    }
#line 2895
    if ((unsigned int )why == 2U) {
#line 2896
      PyTraceBack_Here(f);
#line 2898
      if ((unsigned int )tstate->c_tracefunc != (unsigned int )((void *)0)) {
#line 2899
        call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, f);
      } else {

      }
    } else {

    }
#line 2905
    if ((unsigned int )why == 4U) {
#line 2906
      why = (enum why_code )2;
    } else {

    }
    fast_block_end: 
#line 2911
    while (1) {
#line 2911
      if ((unsigned int )why != 1U) {
#line 2911
        if (f->f_iblock > 0) {

        } else {
#line 2911
          break;
        }
      } else {
#line 2911
        break;
      }
#line 2913
      b___2 = & f->f_blockstack[f->f_iblock - 1];
#line 2916
      if (b___2->b_type == 120) {
#line 2916
        if ((unsigned int )why == 32U) {
#line 2917
          why = (enum why_code )1;
#line 2918
          tmp___151 = PyLong_AsLong(retval);
#line 2918
          next_instr = first_instr + tmp___151;
#line 2919
          while (1) {
#line 2919
            (retval->ob_refcnt) --;
#line 2919
            if (retval->ob_refcnt != 0) {

            } else {
#line 2919
              (*((retval->ob_type)->tp_dealloc))(retval);
            }
#line 2919
            break;
          }
#line 2920
          break;
        } else {

        }
      } else {

      }
#line 2923
      (f->f_iblock) --;
#line 2925
      if (b___2->b_type == 257) {
#line 2926
        while (stack_pointer - f->f_valuestack > b___2->b_level + 3) {
#line 2926
          stack_pointer --;
#line 2926
          value___2 = *stack_pointer;
#line 2926
          while (1) {
#line 2926
            if ((unsigned int )value___2 == (unsigned int )((void *)0)) {

            } else {
#line 2926
              while (1) {
#line 2926
                (value___2->ob_refcnt) --;
#line 2926
                if (value___2->ob_refcnt != 0) {

                } else {
#line 2926
                  (*((value___2->ob_type)->tp_dealloc))(value___2);
                }
#line 2926
                break;
              }
            }
#line 2926
            break;
          }
        }
#line 2926
        type___2 = tstate->exc_type;
#line 2926
        value___2 = tstate->exc_value;
#line 2926
        traceback___2 = tstate->exc_traceback;
#line 2926
        stack_pointer --;
#line 2926
        tstate->exc_type = *stack_pointer;
#line 2926
        stack_pointer --;
#line 2926
        tstate->exc_value = *stack_pointer;
#line 2926
        stack_pointer --;
#line 2926
        tstate->exc_traceback = *stack_pointer;
#line 2926
        while (1) {
#line 2926
          if ((unsigned int )type___2 == (unsigned int )((void *)0)) {

          } else {
#line 2926
            while (1) {
#line 2926
              (type___2->ob_refcnt) --;
#line 2926
              if (type___2->ob_refcnt != 0) {

              } else {
#line 2926
                (*((type___2->ob_type)->tp_dealloc))(type___2);
              }
#line 2926
              break;
            }
          }
#line 2926
          break;
        }
#line 2926
        while (1) {
#line 2926
          if ((unsigned int )value___2 == (unsigned int )((void *)0)) {

          } else {
#line 2926
            while (1) {
#line 2926
              (value___2->ob_refcnt) --;
#line 2926
              if (value___2->ob_refcnt != 0) {

              } else {
#line 2926
                (*((value___2->ob_type)->tp_dealloc))(value___2);
              }
#line 2926
              break;
            }
          }
#line 2926
          break;
        }
#line 2926
        while (1) {
#line 2926
          if ((unsigned int )traceback___2 == (unsigned int )((void *)0)) {

          } else {
#line 2926
            while (1) {
#line 2926
              (traceback___2->ob_refcnt) --;
#line 2926
              if (traceback___2->ob_refcnt != 0) {

              } else {
#line 2926
                (*((traceback___2->ob_type)->tp_dealloc))(traceback___2);
              }
#line 2926
              break;
            }
          }
#line 2926
          break;
        }
#line 2927
        continue;
      } else {

      }
#line 2929
      while (stack_pointer - f->f_valuestack > b___2->b_level) {
#line 2929
        stack_pointer --;
#line 2929
        v___1 = *stack_pointer;
#line 2929
        while (1) {
#line 2929
          if ((unsigned int )v___1 == (unsigned int )((void *)0)) {

          } else {
#line 2929
            while (1) {
#line 2929
              (v___1->ob_refcnt) --;
#line 2929
              if (v___1->ob_refcnt != 0) {

              } else {
#line 2929
                (*((v___1->ob_type)->tp_dealloc))(v___1);
              }
#line 2929
              break;
            }
          }
#line 2929
          break;
        }
      }
#line 2930
      if (b___2->b_type == 120) {
#line 2930
        if ((unsigned int )why == 16U) {
#line 2931
          why = (enum why_code )1;
#line 2932
          next_instr = first_instr + b___2->b_handler;
#line 2933
          break;
        } else {

        }
      } else {

      }
#line 2935
      if ((unsigned int )why == 2U) {
#line 2935
        if (b___2->b_type == 121) {
          goto _L___5;
        } else {
#line 2935
          if (b___2->b_type == 122) {
            _L___5: /* CIL Label */ 
#line 2938
            handler = b___2->b_handler;
#line 2940
            PyFrame_BlockSetup(f, 257, -1, stack_pointer - f->f_valuestack);
#line 2941
            tmp___152 = stack_pointer;
#line 2941
            stack_pointer ++;
#line 2941
            *tmp___152 = tstate->exc_traceback;
#line 2942
            tmp___153 = stack_pointer;
#line 2942
            stack_pointer ++;
#line 2942
            *tmp___153 = tstate->exc_value;
#line 2943
            if ((unsigned int )tstate->exc_type != (unsigned int )((void *)0)) {
#line 2944
              tmp___154 = stack_pointer;
#line 2944
              stack_pointer ++;
#line 2944
              *tmp___154 = tstate->exc_type;
            } else {
#line 2947
              (_Py_NoneStruct.ob_refcnt) ++;
#line 2948
              tmp___155 = stack_pointer;
#line 2948
              stack_pointer ++;
#line 2948
              *tmp___155 = & _Py_NoneStruct;
            }
#line 2950
            PyErr_Fetch(& exc___0, & val, & tb___0);
#line 2955
            PyErr_NormalizeException(& exc___0, & val, & tb___0);
#line 2957
            PyException_SetTraceback(val, tb___0);
#line 2958
            (exc___0->ob_refcnt) ++;
#line 2959
            tstate->exc_type = exc___0;
#line 2960
            (val->ob_refcnt) ++;
#line 2961
            tstate->exc_value = val;
#line 2962
            tstate->exc_traceback = tb___0;
#line 2963
            if ((unsigned int )tb___0 == (unsigned int )((void *)0)) {
#line 2964
              tb___0 = & _Py_NoneStruct;
            } else {

            }
#line 2965
            (tb___0->ob_refcnt) ++;
#line 2966
            tmp___156 = stack_pointer;
#line 2966
            stack_pointer ++;
#line 2966
            *tmp___156 = tb___0;
#line 2967
            tmp___157 = stack_pointer;
#line 2967
            stack_pointer ++;
#line 2967
            *tmp___157 = val;
#line 2968
            tmp___158 = stack_pointer;
#line 2968
            stack_pointer ++;
#line 2968
            *tmp___158 = exc___0;
#line 2969
            why = (enum why_code )1;
#line 2970
            next_instr = first_instr + handler;
#line 2971
            break;
          } else {

          }
        }
      } else {

      }
#line 2973
      if (b___2->b_type == 122) {
#line 2974
        if ((unsigned int )why & 40U) {
#line 2975
          tmp___159 = stack_pointer;
#line 2975
          stack_pointer ++;
#line 2975
          *tmp___159 = retval;
        } else {

        }
#line 2976
        tmp___160 = stack_pointer;
#line 2976
        stack_pointer ++;
#line 2976
        *tmp___160 = PyLong_FromLong((long )why);
#line 2977
        why = (enum why_code )1;
#line 2978
        next_instr = first_instr + b___2->b_handler;
#line 2979
        break;
      } else {

      }
    }
#line 2985
    if ((unsigned int )why != 1U) {
#line 2986
      break;
    } else {

    }
    __Cont: /* CIL Label */ ;
  }
   4839: /* CIL Label */ 
#line 2993
  while (! (stack_pointer - f->f_valuestack == 0)) {
#line 2994
    stack_pointer --;
#line 2994
    v = *stack_pointer;
#line 2995
    while (1) {
#line 2995
      if ((unsigned int )v == (unsigned int )((void *)0)) {

      } else {
#line 2995
        while (1) {
#line 2995
          (v->ob_refcnt) --;
#line 2995
          if (v->ob_refcnt != 0) {

          } else {
#line 2995
            (*((v->ob_type)->tp_dealloc))(v);
          }
#line 2995
          break;
        }
      }
#line 2995
      break;
    }
  }
   4840: /* CIL Label */ 
#line 2998
  if ((unsigned int )why != 8U) {
#line 2999
    retval = (PyObject *)((void *)0);
  } else {

  }
   4841: /* CIL Label */ 
  fast_yield: 
#line 3002
  if (tstate->use_tracing) {
#line 3003
    if (tstate->c_tracefunc) {
#line 3004
      if ((unsigned int )why == 8U) {
        goto _L___6;
      } else {
#line 3004
        if ((unsigned int )why == 64U) {
          _L___6: /* CIL Label */ 
#line 3005
          tmp___161 = call_trace(tstate->c_tracefunc, tstate->c_traceobj, f, 3,
                                 retval);
#line 3005
          if (tmp___161) {
#line 3008
            while (1) {
#line 3008
              if ((unsigned int )retval == (unsigned int )((void *)0)) {

              } else {
#line 3008
                while (1) {
#line 3008
                  (retval->ob_refcnt) --;
#line 3008
                  if (retval->ob_refcnt != 0) {

                  } else {
#line 3008
                    (*((retval->ob_type)->tp_dealloc))(retval);
                  }
#line 3008
                  break;
                }
              }
#line 3008
              break;
            }
#line 3009
            retval = (PyObject *)((void *)0);
#line 3010
            why = (enum why_code )2;
          } else {

          }
        } else {
#line 3013
          if ((unsigned int )why == 2U) {
#line 3014
            call_trace_protected(tstate->c_tracefunc, tstate->c_traceobj, f, 3,
                                 (PyObject *)((void *)0));
          } else {

          }
        }
      }
    } else {

    }
#line 3019
    if (tstate->c_profilefunc) {
#line 3020
      if ((unsigned int )why == 2U) {
#line 3021
        call_trace_protected(tstate->c_profilefunc, tstate->c_profileobj, f, 3,
                             (PyObject *)((void *)0));
      } else {
#line 3024
        tmp___162 = call_trace(tstate->c_profilefunc, tstate->c_profileobj, f,
                               3, retval);
#line 3024
        if (tmp___162) {
#line 3027
          while (1) {
#line 3027
            if ((unsigned int )retval == (unsigned int )((void *)0)) {

            } else {
#line 3027
              while (1) {
#line 3027
                (retval->ob_refcnt) --;
#line 3027
                if (retval->ob_refcnt != 0) {

                } else {
#line 3027
                  (*((retval->ob_type)->tp_dealloc))(retval);
                }
#line 3027
                break;
              }
            }
#line 3027
            break;
          }
#line 3028
          retval = (PyObject *)((void *)0);
        } else {

        }
      }
    } else {

    }
  } else {

  }
   4842: /* CIL Label */ 
  exit_eval_frame: 
#line 3036
  while (1) {
#line 3036
    atomic_val___82 = & _PyThreadState_Current;
#line 3036
    volatile_data___82 = (void * volatile  *)(& atomic_val___82->_value);
#line 3036
    order___82 = (_Py_memory_order )0;
#line 3036
    _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___82,
                              order___82);
#line 3036
    switch ((int )order___82) {
    case 2: 
    case 3: 
    case 4: 
#line 3036
    _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 3036
    break;
    default: ;
#line 3036
    break;
    }
#line 3036
    result___81 = (void *)*volatile_data___82;
#line 3036
    switch ((int )order___82) {
    case 1: 
    case 3: 
    case 4: 
#line 3036
    _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 3036
    break;
    default: ;
#line 3036
    break;
    }
#line 3036
    (((PyThreadState *)result___81)->recursion_depth) --;
#line 3036
    if (_Py_CheckRecursionLimit > 100) {
#line 3036
      tmp___163 = _Py_CheckRecursionLimit - 50;
    } else {
#line 3036
      tmp___163 = 3 * (_Py_CheckRecursionLimit >> 2);
    }
#line 3036
    if (((PyThreadState *)result___81)->recursion_depth < tmp___163) {
#line 3036
      atomic_val___81 = & _PyThreadState_Current;
#line 3036
      volatile_data___81 = (void * volatile  *)(& atomic_val___81->_value);
#line 3036
      order___81 = (_Py_memory_order )0;
#line 3036
      _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val___81,
                                order___81);
#line 3036
      switch ((int )order___81) {
      case 2: 
      case 3: 
      case 4: 
#line 3036
      _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 3036
      break;
      default: ;
#line 3036
      break;
      }
#line 3036
      result___80 = (void *)*volatile_data___81;
#line 3036
      switch ((int )order___81) {
      case 1: 
      case 3: 
      case 4: 
#line 3036
      _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 3036
      break;
      default: ;
#line 3036
      break;
      }
#line 3036
      ((PyThreadState *)result___80)->overflowed = (char)0;
    } else {

    }
#line 3036
    break;
  }
   4843: /* CIL Label */ 
#line 3037
  tstate->frame = f->f_back;
   4844: /* CIL Label */ 
#line 3039
  return (retval);
}
}

cilRep: liveness failure for PyEval_EvalFrameEx: Errormsg.Error
Bug: BF(Liveness): stmtStartData is not initialized for -1: fail: 
#line 3305
(tstate->recursion_depth) ++;
Liveness failed on function:
 PyObject *PyEval_EvalCodeEx(PyObject *_co , PyObject *globals ,
                             PyObject *locals , PyObject **args , int argcount ,
                             PyObject **kws , int kwcount , PyObject **defs ,
                             int defcount , PyObject *kwdefs ,
                             PyObject *closure ) 
{ PyCodeObject *co ;
  register PyFrameObject *f ;
  register PyObject *retval ;
  register PyObject **fastlocals ;
  register PyObject **freevars ;
  PyThreadState *tstate ;
  _Py_atomic_address *atomic_val ;
  void *result ;
  void * volatile  *volatile_data ;
  _Py_memory_order order ;
  PyObject *x ;
  PyObject *u ;
  int total_args ;
  int i ;
  int n ;
  PyObject *kwdict ;
  PyObject *tmp ;
  char const   *tmp___0 ;
  char const   *tmp___1 ;
  PyObject *tmp___2 ;
  PyObject *tmp___3 ;
  PyObject **co_varnames ;
  PyObject *keyword ;
  PyObject *value ;
  int j ;
  PyObject *nm ;
  PyObject *nm___0 ;
  int cmp ;
  int tmp___4 ;
  PyObject *tmp___5 ;
  PyObject *name ;
  PyObject *def ;
  PyObject *tmp___6 ;
  PyObject *tmp___7 ;
  int m ;
  int j___0 ;
  int given ;
  char const   *tmp___8 ;
  char const   *tmp___9 ;
  PyObject *def___0 ;
  PyObject *tmp___10 ;
  int i___0 ;
  int j___1 ;
  int nargs ;
  int found ;
  Py_UNICODE *cellname ;
  Py_UNICODE *argname ;
  PyObject *c ;
  int tmp___11 ;
  PyObject *tmp___12 ;
  int i___1 ;
  PyObject *o ;
  PyObject *tmp___13 ;

  {
   5138: /* CIL Label */ 
#line 3051
  co = (PyCodeObject *)_co;
   5139: /* CIL Label */ 
#line 3053
  retval = (PyObject *)((void *)0);
   5140: /* CIL Label */ 
#line 3055
  atomic_val = & _PyThreadState_Current;
   5141: /* CIL Label */ 
#line 3055
  volatile_data = (void * volatile  *)(& atomic_val->_value);
   5142: /* CIL Label */ 
#line 3055
  order = (_Py_memory_order )0;
   5143: /* CIL Label */ 
#line 3055
  _Py_ANNOTATE_MEMORY_ORDER((void const volatile   *)atomic_val, order);
   0: /* CIL Label */ 
#line 3055
  switch ((int )order) {
  case 2: 
  case 3: 
  case 4: 
#line 3055
  _Py_atomic_thread_fence((enum _Py_memory_order )2);
#line 3055
  break;
  default: ;
#line 3055
  break;
  }
   5144: /* CIL Label */ 
#line 3055
  result = (void *)*volatile_data;
   0: /* CIL Label */ 
#line 3055
  switch ((int )order) {
  case 1: 
  case 3: 
  case 4: 
#line 3055
  _Py_atomic_signal_fence((enum _Py_memory_order )1);
#line 3055
  break;
  default: ;
#line 3055
  break;
  }
   5145: /* CIL Label */ 
#line 3055
  tstate = (PyThreadState *)result;
   5146: /* CIL Label */ 
#line 3057
  total_args = co->co_argcount + co->co_kwonlyargcount;
   5147: /* CIL Label */ 
#line 3059
  if ((unsigned int )globals == (unsigned int )((void *)0)) {
#line 3060
    PyErr_SetString(PyExc_SystemError, "PyEval_EvalCodeEx: NULL globals");
#line 3062
    return ((PyObject *)((void *)0));
  } else {

  }
   5148: /* CIL Label */ 
#line 3067
  f = PyFrame_New(tstate, co, globals, locals);
   5149: /* CIL Label */ 
#line 3068
  if ((unsigned int )f == (unsigned int )((void *)0)) {
#line 3069
    return ((PyObject *)((void *)0));
  } else {

  }
   5150: /* CIL Label */ 
#line 3071
  fastlocals = f->f_localsplus;
   5151: /* CIL Label */ 
#line 3072
  freevars = f->f_localsplus + co->co_nlocals;
   5152: /* CIL Label */ 
#line 3074
  if (total_args) {
    goto _L;
  } else {
#line 3074
    if (co->co_flags & 12) {
      _L: /* CIL Label */ 
#line 3076
      n = argcount;
#line 3077
      kwdict = (PyObject *)((void *)0);
#line 3078
      if (co->co_flags & 0x0008) {
#line 3079
        kwdict = PyDict_New();
#line 3080
        if ((unsigned int )kwdict == (unsigned int )((void *)0)) {
          goto fail;
        } else {

        }
#line 3082
        i = total_args;
#line 3083
        if (co->co_flags & 0x0004) {
#line 3084
          i ++;
        } else {

        }
#line 3085
        while (1) {
#line 3085
          tmp = *(fastlocals + i);
#line 3085
          *(fastlocals + i) = kwdict;
#line 3085
          while (1) {
#line 3085
            if ((unsigned int )tmp == (unsigned int )((void *)0)) {

            } else {
#line 3085
              while (1) {
#line 3085
                (tmp->ob_refcnt) --;
#line 3085
                if (tmp->ob_refcnt != 0) {

                } else {
#line 3085
                  (*((tmp->ob_type)->tp_dealloc))(tmp);
                }
#line 3085
                break;
              }
            }
#line 3085
            break;
          }
#line 3085
          break;
        }
      } else {

      }
#line 3087
      if (argcount > co->co_argcount) {
#line 3088
        if (! (co->co_flags & 0x0004)) {
#line 3089
          if (co->co_argcount == 1) {
#line 3089
            tmp___0 = "";
          } else {
#line 3089
            tmp___0 = "s";
          }
#line 3089
          if (defcount) {
#line 3089
            tmp___1 = "at most";
          } else {
#line 3089
            tmp___1 = "exactly";
          }
#line 3089
          PyErr_Format(PyExc_TypeError,
                       "%U() takes %s %d positional argument%s (%d given)",
                       co->co_name, tmp___1, co->co_argcount, tmp___0,
                       argcount + kwcount);
          goto fail;
        } else {

        }
#line 3099
        n = co->co_argcount;
      } else {

      }
#line 3101
      i = 0;
#line 3101
      while (i < n) {
#line 3102
        x = *(args + i);
#line 3103
        (x->ob_refcnt) ++;
#line 3104
        while (1) {
#line 3104
          tmp___2 = *(fastlocals + i);
#line 3104
          *(fastlocals + i) = x;
#line 3104
          while (1) {
#line 3104
            if ((unsigned int )tmp___2 == (unsigned int )((void *)0)) {

            } else {
#line 3104
              while (1) {
#line 3104
                (tmp___2->ob_refcnt) --;
#line 3104
                if (tmp___2->ob_refcnt != 0) {

                } else {
#line 3104
                  (*((tmp___2->ob_type)->tp_dealloc))(tmp___2);
                }
#line 3104
                break;
              }
            }
#line 3104
            break;
          }
#line 3104
          break;
        }
#line 3101
        i ++;
      }
#line 3106
      if (co->co_flags & 0x0004) {
#line 3107
        u = PyTuple_New(argcount - n);
#line 3108
        if ((unsigned int )u == (unsigned int )((void *)0)) {
          goto fail;
        } else {

        }
#line 3110
        while (1) {
#line 3110
          tmp___3 = *(fastlocals + total_args);
#line 3110
          *(fastlocals + total_args) = u;
#line 3110
          while (1) {
#line 3110
            if ((unsigned int )tmp___3 == (unsigned int )((void *)0)) {

            } else {
#line 3110
              while (1) {
#line 3110
                (tmp___3->ob_refcnt) --;
#line 3110
                if (tmp___3->ob_refcnt != 0) {

                } else {
#line 3110
                  (*((tmp___3->ob_type)->tp_dealloc))(tmp___3);
                }
#line 3110
                break;
              }
            }
#line 3110
            break;
          }
#line 3110
          break;
        }
#line 3111
        i = n;
#line 3111
        while (i < argcount) {
#line 3112
          x = *(args + i);
#line 3113
          (x->ob_refcnt) ++;
#line 3114
          ((PyTupleObject *)u)->ob_item[i - n] = x;
#line 3111
          i ++;
        }
      } else {

      }
#line 3117
      i = 0;
#line 3117
      while (i < kwcount) {
#line 3119
        keyword = *(kws + 2 * i);
#line 3120
        value = *(kws + (2 * i + 1));
#line 3122
        if ((unsigned int )keyword == (unsigned int )((void *)0)) {
#line 3123
          PyErr_Format(PyExc_TypeError, "%U() keywords must be strings",
                       co->co_name);
          goto fail;
        } else {
#line 3122
          if (! (((keyword->ob_type)->tp_flags & (1L << 28)) != 0L)) {
#line 3123
            PyErr_Format(PyExc_TypeError, "%U() keywords must be strings",
                         co->co_name);
            goto fail;
          } else {

          }
        }
#line 3130
        co_varnames = ((PyTupleObject *)co->co_varnames)->ob_item;
#line 3131
        j = 0;
#line 3131
        while (j < total_args) {
#line 3132
          nm = *(co_varnames + j);
#line 3133
          if ((unsigned int )nm == (unsigned int )keyword) {
            goto kw_found;
          } else {

          }
#line 3131
          j ++;
        }
#line 3137
        j = 0;
#line 3137
        while (j < total_args) {
#line 3138
          nm___0 = *(co_varnames + j);
#line 3139
          tmp___4 = PyObject_RichCompareBool(keyword, nm___0, 2);
#line 3139
          cmp = tmp___4;
#line 3141
          if (cmp > 0) {
            goto kw_found;
          } else {
#line 3143
            if (cmp < 0) {
              goto fail;
            } else {

            }
          }
#line 3137
          j ++;
        }
#line 3146
        if (j >= total_args) {
#line 3146
          if ((unsigned int )kwdict == (unsigned int )((void *)0)) {
#line 3147
            PyErr_Format(PyExc_TypeError,
                         "%U() got an unexpected keyword argument \'%S\'",
                         co->co_name, keyword);
            goto fail;
          } else {

          }
        } else {

        }
#line 3154
        PyDict_SetItem(kwdict, keyword, value);
        goto __Cont;
        kw_found: 
#line 3157
        if ((unsigned int )*(fastlocals + j) != (unsigned int )((void *)0)) {
#line 3158
          PyErr_Format(PyExc_TypeError,
                       "%U() got multiple values for keyword argument \'%S\'",
                       co->co_name, keyword);
          goto fail;
        } else {

        }
#line 3166
        (value->ob_refcnt) ++;
#line 3167
        while (1) {
#line 3167
          tmp___5 = *(fastlocals + j);
#line 3167
          *(fastlocals + j) = value;
#line 3167
          while (1) {
#line 3167
            if ((unsigned int )tmp___5 == (unsigned int )((void *)0)) {

            } else {
#line 3167
              while (1) {
#line 3167
                (tmp___5->ob_refcnt) --;
#line 3167
                if (tmp___5->ob_refcnt != 0) {

                } else {
#line 3167
                  (*((tmp___5->ob_type)->tp_dealloc))(tmp___5);
                }
#line 3167
                break;
              }
            }
#line 3167
            break;
          }
#line 3167
          break;
        }
        __Cont: /* CIL Label */ 
#line 3117
        i ++;
      }
#line 3169
      if (co->co_kwonlyargcount > 0) {
#line 3170
        i = co->co_argcount;
#line 3170
        while (i < total_args) {
#line 3172
          if ((unsigned int )*(fastlocals + i) != (unsigned int )((void *)0)) {
            goto __Cont___0;
          } else {

          }
#line 3174
          name = ((PyTupleObject *)co->co_varnames)->ob_item[i];
#line 3175
          if ((unsigned int )kwdefs != (unsigned int )((void *)0)) {
#line 3176
            tmp___6 = PyDict_GetItem(kwdefs, name);
#line 3176
            def = tmp___6;
#line 3177
            if (def) {
#line 3178
              (def->ob_refcnt) ++;
#line 3179
              while (1) {
#line 3179
                tmp___7 = *(fastlocals + i);
#line 3179
                *(fastlocals + i) = def;
#line 3179
                while (1) {
#line 3179
                  if ((unsigned int )tmp___7 == (unsigned int )((void *)0)) {

                  } else {
#line 3179
                    while (1) {
#line 3179
                      (tmp___7->ob_refcnt) --;
#line 3179
                      if (tmp___7->ob_refcnt != 0) {

                      } else {
#line 3179
                        (*((tmp___7->ob_type)->tp_dealloc))(tmp___7);
                      }
#line 3179
                      break;
                    }
                  }
#line 3179
                  break;
                }
#line 3179
                break;
              }
              goto __Cont___0;
            } else {

            }
          } else {

          }
#line 3183
          PyErr_Format(PyExc_TypeError, "%U() needs keyword-only argument %S",
                       co->co_name, name);
          goto fail;
          __Cont___0: /* CIL Label */ 
#line 3170
          i ++;
        }
      } else {

      }
#line 3189
      if (argcount < co->co_argcount) {
#line 3190
        m = co->co_argcount - defcount;
#line 3191
        i = argcount;
#line 3191
        while (i < m) {
#line 3192
          if ((unsigned int )*(fastlocals + i) == (unsigned int )((void *)0)) {
#line 3193
            given = 0;
#line 3194
            j___0 = 0;
#line 3194
            while (j___0 < co->co_argcount) {
#line 3195
              if (*(fastlocals + j___0)) {
#line 3196
                given ++;
              } else {

              }
#line 3194
              j___0 ++;
            }
#line 3197
            if (m == 1) {
#line 3197
              tmp___8 = "";
            } else {
#line 3197
              tmp___8 = "s";
            }
#line 3197
            if (co->co_flags & 0x0004) {
#line 3197
              tmp___9 = "at least";
            } else {
#line 3197
              if (defcount) {
#line 3197
                tmp___9 = "at least";
              } else {
#line 3197
                tmp___9 = "exactly";
              }
            }
#line 3197
            PyErr_Format(PyExc_TypeError,
                         "%U() takes %s %d argument%s (%d given)", co->co_name,
                         tmp___9, m, tmp___8, given);
            goto fail;
          } else {

          }
#line 3191
          i ++;
        }
#line 3209
        if (n > m) {
#line 3210
          i = n - m;
        } else {
#line 3212
          i = 0;
        }
#line 3213
        while (i < defcount) {
#line 3214
          if ((unsigned int )*(fastlocals + (m + i)) == (unsigned int )((void *)0)) {
#line 3215
            def___0 = *(defs + i);
#line 3216
            (def___0->ob_refcnt) ++;
#line 3217
            while (1) {
#line 3217
              tmp___10 = *(fastlocals + (m + i));
#line 3217
              *(fastlocals + (m + i)) = def___0;
#line 3217
              while (1) {
#line 3217
                if ((unsigned int )tmp___10 == (unsigned int )((void *)0)) {

                } else {
#line 3217
                  while (1) {
#line 3217
                    (tmp___10->ob_refcnt) --;
#line 3217
                    if (tmp___10->ob_refcnt != 0) {

                    } else {
#line 3217
                      (*((tmp___10->ob_type)->tp_dealloc))(tmp___10);
                    }
#line 3217
                    break;
                  }
                }
#line 3217
                break;
              }
#line 3217
              break;
            }
          } else {

          }
#line 3213
          i ++;
        }
      } else {

      }
    } else {
#line 3222
      if (argcount > 0) {
#line 3223
        PyErr_Format(PyExc_TypeError, "%U() takes no arguments (%d given)",
                     co->co_name, argcount + kwcount);
        goto fail;
      } else {
#line 3222
        if (kwcount > 0) {
#line 3223
          PyErr_Format(PyExc_TypeError, "%U() takes no arguments (%d given)",
                       co->co_name, argcount + kwcount);
          goto fail;
        } else {

        }
      }
    }
  }
   5153: /* CIL Label */ 
#line 3231
  if (((PyVarObject *)co->co_cellvars)->ob_size) {
#line 3236
    nargs = total_args;
#line 3237
    if (co->co_flags & 0x0004) {
#line 3238
      nargs ++;
    } else {

    }
#line 3239
    if (co->co_flags & 0x0008) {
#line 3240
      nargs ++;
    } else {

    }
#line 3249
    i___0 = 0;
#line 3249
    while (i___0 < ((PyVarObject *)co->co_cellvars)->ob_size) {
#line 3250
      cellname = ((PyUnicodeObject *)((PyTupleObject *)co->co_cellvars)->ob_item[i___0])->str;
#line 3252
      found = 0;
#line 3253
      j___1 = 0;
#line 3253
      while (j___1 < nargs) {
#line 3254
        argname = ((PyUnicodeObject *)((PyTupleObject *)co->co_varnames)->ob_item[j___1])->str;
#line 3256
        tmp___11 = Py_UNICODE_strcmp((Py_UNICODE const   *)cellname,
                                     (Py_UNICODE const   *)argname);
#line 3256
        if (tmp___11 == 0) {
#line 3257
          c = PyCell_New(*(fastlocals + j___1));
#line 3258
          if ((unsigned int )c == (unsigned int )((void *)0)) {
            goto fail;
          } else {

          }
#line 3260
          *(fastlocals + (co->co_nlocals + i___0)) = c;
#line 3261
          found = 1;
#line 3262
          break;
        } else {

        }
#line 3253
        j___1 ++;
      }
#line 3265
      if (found == 0) {
#line 3266
        c = PyCell_New((PyObject *)((void *)0));
#line 3267
        if ((unsigned int )c == (unsigned int )((void *)0)) {
          goto fail;
        } else {

        }
#line 3269
        while (1) {
#line 3269
          tmp___12 = *(fastlocals + (co->co_nlocals + i___0));
#line 3269
          *(fastlocals + (co->co_nlocals + i___0)) = c;
#line 3269
          while (1) {
#line 3269
            if ((unsigned int )tmp___12 == (unsigned int )((void *)0)) {

            } else {
#line 3269
              while (1) {
#line 3269
                (tmp___12->ob_refcnt) --;
#line 3269
                if (tmp___12->ob_refcnt != 0) {

                } else {
#line 3269
                  (*((tmp___12->ob_type)->tp_dealloc))(tmp___12);
                }
#line 3269
                break;
              }
            }
#line 3269
            break;
          }
#line 3269
          break;
        }
      } else {

      }
#line 3249
      i___0 ++;
    }
  } else {

  }
   5154: /* CIL Label */ 
#line 3273
  if (((PyVarObject *)co->co_freevars)->ob_size) {
#line 3275
    i___1 = 0;
#line 3275
    while (i___1 < ((PyVarObject *)co->co_freevars)->ob_size) {
#line 3276
      o = ((PyTupleObject *)closure)->ob_item[i___1];
#line 3277
      (o->ob_refcnt) ++;
#line 3278
      *(freevars + (((PyVarObject *)co->co_cellvars)->ob_size + i___1)) = o;
#line 3275
      i___1 ++;
    }
  } else {

  }
   5155: /* CIL Label */ 
#line 3282
  if (co->co_flags & 0x0020) {
#line 3285
    while (1) {
#line 3285
      if ((unsigned int )f->f_back == (unsigned int )((void *)0)) {

      } else {
#line 3285
        while (1) {
#line 3285
          (((PyObject *)f->f_back)->ob_refcnt) --;
#line 3285
          if (((PyObject *)f->f_back)->ob_refcnt != 0) {

          } else {
#line 3285
            (*((((PyObject *)f->f_back)->ob_type)->tp_dealloc))((PyObject *)f->f_back);
          }
#line 3285
          break;
        }
      }
#line 3285
      break;
    }
#line 3286
    f->f_back = (struct _frame *)((void *)0);
#line 3292
    tmp___13 = PyGen_New(f);
#line 3292
    return (tmp___13);
  } else {

  }
   5156: /* CIL Label */ 
#line 3295
  retval = PyEval_EvalFrameEx(f, 0);
   5157: /* CIL Label */ 
  fail: 
#line 3305
  (tstate->recursion_depth) ++;
   5158: /* CIL Label */ 
#line 3306
  while (1) {
#line 3306
    (((PyObject *)f)->ob_refcnt) --;
#line 3306
    if (((PyObject *)f)->ob_refcnt != 0) {

    } else {
#line 3306
      (*((((PyObject *)f)->ob_type)->tp_dealloc))((PyObject *)f);
    }
#line 3306
    break;
  }
   5159: /* CIL Label */ 
#line 3307
  (tstate->recursion_depth) --;
   5160: /* CIL Label */ 
#line 3308
  return (retval);
}
}

cilRep: liveness failure for PyEval_EvalCodeEx: Errormsg.Error
Bug: BF(Liveness): stmtStartData is not initialized for -1: __Cont: /* CIL Label */ 
#line 4307
pos ++;
Liveness failed on function:
 static int import_all_from(PyObject *locals , PyObject *v ) 
{ PyObject *all ;
  PyObject *tmp ;
  PyObject *dict ;
  PyObject *name ;
  PyObject *value ;
  int skip_leading_underscores ;
  int pos ;
  int err ;
  int tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;

  {
   6276: /* CIL Label */ 
#line 4283
  tmp = PyObject_GetAttrString(v, "__all__");
   6277: /* CIL Label */ 
#line 4283
  all = tmp;
   6278: /* CIL Label */ 
#line 4285
  skip_leading_underscores = 0;
   6279: /* CIL Label */ 
#line 4288
  if ((unsigned int )all == (unsigned int )((void *)0)) {
#line 4289
    tmp___0 = PyErr_ExceptionMatches(PyExc_AttributeError);
#line 4289
    if (tmp___0) {

    } else {
#line 4290
      return (-1);
    }
#line 4291
    PyErr_Clear();
#line 4292
    dict = PyObject_GetAttrString(v, "__dict__");
#line 4293
    if ((unsigned int )dict == (unsigned int )((void *)0)) {
#line 4294
      tmp___1 = PyErr_ExceptionMatches(PyExc_AttributeError);
#line 4294
      if (tmp___1) {

      } else {
#line 4295
        return (-1);
      }
#line 4296
      PyErr_SetString(PyExc_ImportError,
                      "from-import-* object has no __dict__ and no __all__");
#line 4298
      return (-1);
    } else {

    }
#line 4300
    all = PyMapping_Keys(dict);
#line 4301
    while (1) {
#line 4301
      (dict->ob_refcnt) --;
#line 4301
      if (dict->ob_refcnt != 0) {

      } else {
#line 4301
        (*((dict->ob_type)->tp_dealloc))(dict);
      }
#line 4301
      break;
    }
#line 4302
    if ((unsigned int )all == (unsigned int )((void *)0)) {
#line 4303
      return (-1);
    } else {

    }
#line 4304
    skip_leading_underscores = 1;
  } else {

  }
   6280: /* CIL Label */ 
#line 4307
  pos = 0;
   6281: /* CIL Label */ 
#line 4307
  err = 0;
   6282: /* CIL Label */ 
#line 4307
  while (1) {
#line 4308
    name = PySequence_GetItem(all, pos);
#line 4309
    if ((unsigned int )name == (unsigned int )((void *)0)) {
#line 4310
      tmp___2 = PyErr_ExceptionMatches(PyExc_IndexError);
#line 4310
      if (tmp___2) {
#line 4313
        PyErr_Clear();
      } else {
#line 4311
        err = -1;
      }
#line 4314
      break;
    } else {

    }
#line 4316
    if (skip_leading_underscores) {
#line 4316
      if (((name->ob_type)->tp_flags & (1L << 28)) != 0L) {
#line 4316
        if ((int )*(((PyUnicodeObject *)name)->str + 0) == 95) {
#line 4320
          while (1) {
#line 4320
            (name->ob_refcnt) --;
#line 4320
            if (name->ob_refcnt != 0) {

            } else {
#line 4320
              (*((name->ob_type)->tp_dealloc))(name);
            }
#line 4320
            break;
          }
          goto __Cont;
        } else {

        }
      } else {

      }
    } else {

    }
#line 4323
    value = PyObject_GetAttr(v, name);
#line 4324
    if ((unsigned int )value == (unsigned int )((void *)0)) {
#line 4325
      err = -1;
    } else {
#line 4326
      if ((unsigned int )locals->ob_type == (unsigned int )(& PyDict_Type)) {
#line 4327
        err = PyDict_SetItem(locals, name, value);
      } else {
#line 4329
        err = PyObject_SetItem(locals, name, value);
      }
    }
#line 4330
    while (1) {
#line 4330
      (name->ob_refcnt) --;
#line 4330
      if (name->ob_refcnt != 0) {

      } else {
#line 4330
        (*((name->ob_type)->tp_dealloc))(name);
      }
#line 4330
      break;
    }
#line 4331
    while (1) {
#line 4331
      if ((unsigned int )value == (unsigned int )((void *)0)) {

      } else {
#line 4331
        while (1) {
#line 4331
          (value->ob_refcnt) --;
#line 4331
          if (value->ob_refcnt != 0) {

          } else {
#line 4331
            (*((value->ob_type)->tp_dealloc))(value);
          }
#line 4331
          break;
        }
      }
#line 4331
      break;
    }
#line 4332
    if (err != 0) {
#line 4333
      break;
    } else {

    }
    __Cont: /* CIL Label */ 
#line 4307
    pos ++;
  }
   6283: /* CIL Label */ 
#line 4335
  while (1) {
#line 4335
    (all->ob_refcnt) --;
#line 4335
    if (all->ob_refcnt != 0) {

    } else {
#line 4335
      (*((all->ob_type)->tp_dealloc))(all);
    }
#line 4335
    break;
  }
   6284: /* CIL Label */ 
#line 4336
  return (err);
}
}

cilRep: liveness failure for import_all_from: Errormsg.Error
Bug: BF(Liveness): stmtStartData is not initialized for -1: _L: /* CIL Label */ 
#line 4452
w = PyUnicodeUCS2_Concat(v, w);
Liveness failed on function:
 static PyObject *unicode_concatenate(PyObject *v , PyObject *w ,
                                      PyFrameObject *f ,
                                      unsigned char *next_instr ) 
{ Py_ssize_t v_len ;
  Py_ssize_t w_len ;
  Py_ssize_t new_len ;
  int oparg ;
  PyObject **fastlocals ;
  PyObject *tmp ;
  PyObject **freevars ;
  PyObject *c ;
  PyObject *names ;
  PyObject *name ;
  PyObject *locals ;
  int tmp___0 ;
  PyObject *tmp___1 ;
  int tmp___2 ;

  {
   6355: /* CIL Label */ 
#line 4382
  v_len = ((PyUnicodeObject *)v)->length;
   6356: /* CIL Label */ 
#line 4383
  w_len = ((PyUnicodeObject *)w)->length;
   6357: /* CIL Label */ 
#line 4384
  new_len = v_len + w_len;
   6358: /* CIL Label */ 
#line 4385
  if (new_len < 0) {
#line 4386
    PyErr_SetString(PyExc_OverflowError, "strings are too large to concat");
#line 4388
    return ((PyObject *)((void *)0));
  } else {

  }
   6359: /* CIL Label */ 
#line 4391
  if (v->ob_refcnt == 2) {
#line 4398
    switch ((int )*next_instr) {
    case 125: 
#line 4401
    oparg = ((int )*(next_instr + 2) << 8) + (int )*(next_instr + 1);
#line 4402
    fastlocals = f->f_localsplus;
#line 4403
    if ((unsigned int )*(fastlocals + oparg) == (unsigned int )v) {
#line 4404
      while (1) {
#line 4404
        tmp = *(fastlocals + oparg);
#line 4404
        *(fastlocals + oparg) = (PyObject *)((void *)0);
#line 4404
        while (1) {
#line 4404
          if ((unsigned int )tmp == (unsigned int )((void *)0)) {

          } else {
#line 4404
            while (1) {
#line 4404
              (tmp->ob_refcnt) --;
#line 4404
              if (tmp->ob_refcnt != 0) {

              } else {
#line 4404
                (*((tmp->ob_type)->tp_dealloc))(tmp);
              }
#line 4404
              break;
            }
          }
#line 4404
          break;
        }
#line 4404
        break;
      }
    } else {

    }
#line 4405
    break;
    case 137: 
#line 4409
    freevars = f->f_localsplus + (f->f_code)->co_nlocals;
#line 4411
    c = *(freevars + (((int )*(next_instr + 2) << 8) + (int )*(next_instr + 1)));
#line 4412
    if ((unsigned int )((PyCellObject *)c)->ob_ref == (unsigned int )v) {
#line 4413
      PyCell_Set(c, (PyObject *)((void *)0));
    } else {

    }
#line 4414
    break;
    case 90: 
#line 4418
    names = (f->f_code)->co_names;
#line 4419
    name = ((PyTupleObject *)names)->ob_item[((int )*(next_instr + 2) << 8) + (int )*(next_instr + 1)];
#line 4420
    locals = f->f_locals;
#line 4421
    if ((unsigned int )locals->ob_type == (unsigned int )(& PyDict_Type)) {
#line 4421
      tmp___1 = PyDict_GetItem(locals, name);
#line 4421
      if ((unsigned int )tmp___1 == (unsigned int )v) {
#line 4423
        tmp___0 = PyDict_DelItem(locals, name);
#line 4423
        if (tmp___0 != 0) {
#line 4424
          PyErr_Clear();
        } else {

        }
      } else {

      }
    } else {

    }
#line 4427
    break;
    }
  } else {

  }
   6360: /* CIL Label */ 
#line 4432
  if (v->ob_refcnt == 1) {
#line 4432
    if (! ((PyUnicodeObject *)v)->state) {
#line 4436
      tmp___2 = PyUnicodeUCS2_Resize(& v, new_len);
#line 4436
      if (tmp___2 != 0) {
#line 4443
        return ((PyObject *)((void *)0));
      } else {

      }
#line 4446
      memcpy((void */* __restrict  */)(((PyUnicodeObject *)v)->str + v_len),
             (void const   */* __restrict  */)((PyUnicodeObject *)w)->str,
             (unsigned int )w_len * sizeof(Py_UNICODE ));
#line 4448
      return (v);
    } else {
      goto _L;
    }
  } else {
    _L: /* CIL Label */ 
#line 4452
    w = PyUnicodeUCS2_Concat(v, w);
#line 4453
    while (1) {
#line 4453
      (v->ob_refcnt) --;
#line 4453
      if (v->ob_refcnt != 0) {

      } else {
#line 4453
        (*((v->ob_type)->tp_dealloc))(v);
      }
#line 4453
      break;
    }
#line 4454
    return (w);
  }
}
}

cilRep: liveness failure for unicode_concatenate: Errormsg.Error
cilRep: computed liveness
cilRep: preprocessed/Python/pythonrun.c: parsing
Error: There were parsing errors in preprocessed/Python/pythonrun.c
/root/repair aborting: Errormsg.Error
Rep: saving test cache

Variant Test Case Queries: 0
"Test Suite Evaluations": 0

Compile Failures: 0
Wall-Clock Seconds Elapsed: 6.52082
  Activity Name                     Count Seconds = Percent of Total Time
  TOTAL                                     0.000 = 0% (avg CPU usage)
Fatal error: exception Errormsg.Error
python-bug-69831-69833.tar.gz
Tue May  7 23:32:10 EDT 2013
shutting down
