utils_init (int fast_time)
{
  long unsigned int D.10230;
  long unsigned int time_inc.0;
  uint64_t (*<T10b6>) (void) time_func.1;
  long unsigned int D.10237;
  long unsigned int D.10238;
  int timer_overhead.2;
  int i;
  uint64_t time_start;
  uint64_t time_end;

  if (fast_time > 1) goto <D.10225>; else goto <D.10226>;
  <D.10225>:
  time_func = null_time;
  goto <D.10227>;
  <D.10226>:
  if (fast_time != 0) goto <D.10228>; else goto <D.10229>;
  <D.10228>:
  {
    uint64_t timea;
    uint64_t timeb;

    clock_time ();
    timea = clock_time ();
    timeb = clock_time ();
    D.10230 = timeb - timea;
    time_inc.0 = D.10230 / 8;
    time_inc = time_inc.0;
    if (0 != 0) goto <D.10232>; else goto <D.10233>;
    <D.10232>:
    time_func = fast_current_time;
    goto <D.10234>;
    <D.10233>:
    time_func = fast_current_time;
    <D.10234>:
  }
  goto <D.10235>;
  <D.10229>:
  time_func = clock_time;
  <D.10235>:
  <D.10227>:
  time_func.1 = time_func;
  time_start = time_func.1 ();
  i = 0;
  goto <D.5935>;
  <D.5934>:
  time_func.1 = time_func;
  time_func.1 ();
  i = i + 1;
  <D.5935>:
  if (i <= 255) goto <D.5934>; else goto <D.5936>;
  <D.5936>:
  time_func.1 = time_func;
  time_end = time_func.1 ();
  D.10237 = time_end - time_start;
  D.10238 = D.10237 / 256;
  timer_overhead.2 = (int) D.10238;
  timer_overhead = timer_overhead.2;
}


fast_current_time ()
{
  unsigned int D.10244;
  unsigned int D.10245;
  unsigned int D.10246;
  unsigned int D.10247;
  long unsigned int D.10250;
  long unsigned int time_inc.3;
  long unsigned int D.10252;
  uint64_t D.10253;
  long unsigned int D.10254;
  struct TlsData * tls;

  tls = &tls_data;
  D.10244 = tls->timer_count;
  D.10245 = D.10244;
  D.10246 = D.10245 + 1;
  tls->timer_count = D.10246;
  D.10247 = D.10245 & 7;
  if (D.10247 != 0) goto <D.10248>; else goto <D.10249>;
  <D.10248>:
  D.10250 = tls->last_time;
  time_inc.3 = time_inc;
  D.10252 = D.10250 + time_inc.3;
  tls->last_time = D.10252;
  D.10253 = tls->last_time;
  return D.10253;
  <D.10249>:
  D.10254 = clock_time ();
  tls->last_time = D.10254;
  D.10253 = tls->last_time;
  return D.10253;
}


null_time ()
{
  uint64_t D.10257;
  long unsigned int timer.4;
  long unsigned int timer.5;
  long unsigned int timer.6;
  static uint64_t timer = 0;

  timer.4 = timer;
  timer.5 = timer.4;
  timer.6 = timer.5 + 1;
  timer = timer.6;
  D.10257 = timer.5;
  return D.10257;
}


clock_time ()
{
  uint64_t D.10262;
  long int D.10263;
  long long unsigned int D.10264;
  long long unsigned int D.10265;
  long int D.10266;
  long long unsigned int D.10267;
  struct timespec tspec;

  try
    {
      clock_gettime (1, &tspec);
      D.10263 = tspec.tv_sec;
      D.10264 = (long long unsigned int) D.10263;
      D.10265 = D.10264 * 1000000000;
      D.10266 = tspec.tv_nsec;
      D.10267 = (long long unsigned int) D.10266;
      D.10262 = D.10265 + D.10267;
      return D.10262;
    }
  finally
    {
      tspec = {CLOBBER};
    }
}


get_timer_overhead ()
{
  int D.10270;

  D.10270 = timer_overhead;
  return D.10270;
}


current_time ()
{
  uint64_t D.10272;
  uint64_t (*<T10b6>) (void) time_func.7;

  time_func.7 = time_func;
  D.10272 = time_func.7 ();
  return D.10272;
}


alloc_buffer (int size)
{
  long unsigned int D.10276;
  void * D.10279;
  void * ptr;

  D.10276 = (long unsigned int) size;
  ptr = mmap (0B, D.10276, 3, 34, -1, 0);
  if (ptr == -1B) goto <D.10277>; else goto <D.10278>;
  <D.10277>:
  D.10279 = 0B;
  return D.10279;
  <D.10278>:
  D.10279 = ptr;
  return D.10279;
}


free_buffer (void * buf, int size)
{
  long unsigned int D.10281;

  D.10281 = (long unsigned int) size;
  munmap (buf, D.10281);
}


take_lock ()
{
  pthread_mutex_lock (&log_lock);
}


release_lock ()
{
  pthread_mutex_unlock (&log_lock);
}


encode_uleb128 (uint64_t value, uint8_t * buf, uint8_t * * endbuf)
{
  unsigned char D.10282;
  uint8_t * p.8;
  uint8_t * p;

  p = buf;
  <D.5964>:
  {
    uint8_t b;

    D.10282 = (unsigned char) value;
    b = D.10282 & 127;
    value = value >> 7;
    if (value != 0) goto <D.10283>; else goto <D.10284>;
    <D.10283>:
    b = b | 128;
    <D.10284>:
    p.8 = p;
    p = p.8 + 1;
    *p.8 = b;
  }
  if (value != 0) goto <D.5964>; else goto <D.5965>;
  <D.5965>:
  *endbuf = p;
}


encode_sleb128 (intptr_t value, uint8_t * buf, uint8_t * * endbuf)
{
  _Bool D.10286;
  unsigned char D.10287;
  unsigned int D.10290;
  int D.10291;
  long int D.10292;
  long int D.10293;
  int D.10299;
  int D.10300;
  uint8_t * p.9;
  int more;
  int negative;
  unsigned int size;
  uint8_t byte;
  uint8_t * p;

  more = 1;
  D.10286 = value < 0;
  negative = (int) D.10286;
  size = 64;
  p = buf;
  goto <D.5977>;
  <D.5976>:
  D.10287 = (unsigned char) value;
  byte = D.10287 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.10288>; else goto <D.10289>;
  <D.10288>:
  D.10290 = size + 4294967289;
  D.10291 = (int) D.10290;
  D.10292 = 1 << D.10291;
  D.10293 = -D.10292;
  value = D.10293 | value;
  <D.10289>:
  if (value == 0) goto <D.10298>; else goto <D.10294>;
  <D.10298>:
  D.10299 = (int) byte;
  D.10300 = D.10299 & 64;
  if (D.10300 == 0) goto <D.10295>; else goto <D.10294>;
  <D.10294>:
  if (value == -1) goto <D.10301>; else goto <D.10296>;
  <D.10301>:
  D.10299 = (int) byte;
  D.10300 = D.10299 & 64;
  if (D.10300 != 0) goto <D.10295>; else goto <D.10296>;
  <D.10295>:
  more = 0;
  goto <D.10297>;
  <D.10296>:
  byte = byte | 128;
  <D.10297>:
  p.9 = p;
  p = p.9 + 1;
  *p.9 = byte;
  <D.5977>:
  if (more != 0) goto <D.5976>; else goto <D.5978>;
  <D.5978>:
  *endbuf = p;
}


decode_uleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  uint8_t * buf.10;
  long unsigned int D.10304;
  long unsigned int D.10305;
  long unsigned int D.10306;
  signed char b.11;
  uint64_t D.10309;
  uint64_t res;
  int shift;

  res = 0;
  shift = 0;
  <D.5987>:
  {
    uint8_t b;

    buf.10 = buf;
    buf = buf.10 + 1;
    b = *buf.10;
    D.10304 = (long unsigned int) b;
    D.10305 = D.10304 & 127;
    D.10306 = D.10305 << shift;
    res = D.10306 | res;
    b.11 = (signed char) b;
    if (b.11 >= 0) goto <D.5986>; else goto <D.10308>;
    <D.10308>:
    shift = shift + 7;
  }
  goto <D.5987>;
  <D.5986>:
  *endbuf = buf;
  D.10309 = res;
  return D.10309;
}


decode_sleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  long int D.10311;
  long int D.10312;
  long int D.10313;
  signed char b.12;
  unsigned int shift.13;
  int D.10320;
  int D.10321;
  long int D.10324;
  long int D.10325;
  intptr_t D.10326;
  uint8_t * p;
  intptr_t res;
  int shift;

  p = buf;
  res = 0;
  shift = 0;
  <D.5997>:
  {
    uint8_t b;

    b = *p;
    p = p + 1;
    D.10311 = (long int) b;
    D.10312 = D.10311 & 127;
    D.10313 = D.10312 << shift;
    res = D.10313 | res;
    shift = shift + 7;
    b.12 = (signed char) b;
    if (b.12 >= 0) goto <D.10315>; else goto <D.10316>;
    <D.10315>:
    shift.13 = (unsigned int) shift;
    if (shift.13 <= 63) goto <D.10318>; else goto <D.10319>;
    <D.10318>:
    D.10320 = (int) b;
    D.10321 = D.10320 & 64;
    if (D.10321 != 0) goto <D.10322>; else goto <D.10323>;
    <D.10322>:
    D.10324 = 1 << shift;
    D.10325 = -D.10324;
    res = D.10325 | res;
    <D.10323>:
    <D.10319>:
    goto <D.5996>;
    <D.10316>:
  }
  goto <D.5997>;
  <D.5996>:
  *endbuf = p;
  D.10326 = res;
  return D.10326;
}


thread_id ()
{
  uintptr_t D.10328;

  D.10328 = pthread_self ();
  return D.10328;
}


process_id ()
{
  uintptr_t D.10330;
  int D.10331;

  D.10331 = getpid ();
  D.10330 = (uintptr_t) D.10331;
  return D.10330;
}


main (int argc, char * * argv)
{
  struct _IO_FILE * stdout.14;
  int D.10045;
  int iftmp.15;
  int D.10041;
  long unsigned int D.10337;
  long unsigned int D.10338;
  char * * D.10339;
  const char[8] * D.10340;
  unsigned char D.10341;
  int D.10342;
  unsigned char D.10343;
  int D.10344;
  const unsigned char * D.10349;
  unsigned char D.10350;
  int D.10351;
  const unsigned char * D.10352;
  unsigned char D.10353;
  int D.10354;
  const unsigned char * D.10359;
  unsigned char D.10360;
  int D.10361;
  const unsigned char * D.10362;
  unsigned char D.10363;
  int D.10364;
  const unsigned char * D.10369;
  unsigned char D.10370;
  int D.10371;
  const unsigned char * D.10372;
  unsigned char D.10373;
  int D.10374;
  char * D.10376;
  int debug.16;
  int debug.17;
  int D.10054;
  int iftmp.18;
  int D.10050;
  const char[7] * D.10385;
  unsigned char D.10386;
  int D.10387;
  unsigned char D.10388;
  int D.10389;
  const unsigned char * D.10394;
  unsigned char D.10395;
  int D.10396;
  const unsigned char * D.10397;
  unsigned char D.10398;
  int D.10399;
  const unsigned char * D.10404;
  unsigned char D.10405;
  int D.10406;
  const unsigned char * D.10407;
  unsigned char D.10408;
  int D.10409;
  const unsigned char * D.10414;
  unsigned char D.10415;
  int D.10416;
  const unsigned char * D.10417;
  unsigned char D.10418;
  int D.10419;
  int D.10423;
  int D.10424;
  int D.10073;
  int iftmp.19;
  int D.10072;
  const char[6] * D.10430;
  unsigned char D.10431;
  int D.10432;
  unsigned char D.10433;
  int D.10434;
  const unsigned char * D.10439;
  unsigned char D.10440;
  int D.10441;
  const unsigned char * D.10442;
  unsigned char D.10443;
  int D.10444;
  const unsigned char * D.10449;
  unsigned char D.10450;
  int D.10451;
  const unsigned char * D.10452;
  unsigned char D.10453;
  int D.10454;
  const unsigned char * D.10459;
  unsigned char D.10460;
  int D.10461;
  const unsigned char * D.10462;
  unsigned char D.10463;
  int D.10464;
  int D.10082;
  int iftmp.20;
  int D.10081;
  const char[6] * D.10472;
  unsigned char D.10473;
  int D.10474;
  unsigned char D.10475;
  int D.10476;
  const unsigned char * D.10481;
  unsigned char D.10482;
  int D.10483;
  const unsigned char * D.10484;
  unsigned char D.10485;
  int D.10486;
  const unsigned char * D.10491;
  unsigned char D.10492;
  int D.10493;
  const unsigned char * D.10494;
  unsigned char D.10495;
  int D.10496;
  const unsigned char * D.10501;
  unsigned char D.10502;
  int D.10503;
  const unsigned char * D.10504;
  unsigned char D.10505;
  int D.10506;
  int D.10512;
  int D.10101;
  int iftmp.21;
  int D.10100;
  const char[6] * D.10518;
  unsigned char D.10519;
  int D.10520;
  unsigned char D.10521;
  int D.10522;
  const unsigned char * D.10527;
  unsigned char D.10528;
  int D.10529;
  const unsigned char * D.10530;
  unsigned char D.10531;
  int D.10532;
  const unsigned char * D.10537;
  unsigned char D.10538;
  int D.10539;
  const unsigned char * D.10540;
  unsigned char D.10541;
  int D.10542;
  const unsigned char * D.10547;
  unsigned char D.10548;
  int D.10549;
  const unsigned char * D.10550;
  unsigned char D.10551;
  int D.10552;
  int D.10110;
  int iftmp.22;
  int D.10109;
  const char[5] * D.10560;
  unsigned char D.10561;
  int D.10562;
  unsigned char D.10563;
  int D.10564;
  const unsigned char * D.10569;
  unsigned char D.10570;
  int D.10571;
  const unsigned char * D.10572;
  unsigned char D.10573;
  int D.10574;
  const unsigned char * D.10579;
  unsigned char D.10580;
  int D.10581;
  const unsigned char * D.10582;
  unsigned char D.10583;
  int D.10584;
  const unsigned char * D.10589;
  unsigned char D.10590;
  int D.10591;
  const unsigned char * D.10592;
  unsigned char D.10593;
  int D.10594;
  int D.10119;
  int iftmp.23;
  int D.10118;
  const char[6] * D.10602;
  unsigned char D.10603;
  int D.10604;
  unsigned char D.10605;
  int D.10606;
  const unsigned char * D.10611;
  unsigned char D.10612;
  int D.10613;
  const unsigned char * D.10614;
  unsigned char D.10615;
  int D.10616;
  const unsigned char * D.10621;
  unsigned char D.10622;
  int D.10623;
  const unsigned char * D.10624;
  unsigned char D.10625;
  int D.10626;
  const unsigned char * D.10631;
  unsigned char D.10632;
  int D.10633;
  const unsigned char * D.10634;
  unsigned char D.10635;
  int D.10636;
  int D.10642;
  int D.10645;
  int D.10649;
  struct FILE * outfile.24;
  struct FILE * outfile.25;
  int D.10657;
  long unsigned int D.10660;
  int trace_max.26;
  int D.10663;
  int D.10666;
  int D.10670;
  char D.10673;
  int D.10677;
  long unsigned int thread_filter.27;
  int D.10682;
  const char * D.10685;
  char * top.28;
  double D.10691;
  long unsigned int time_from.29;
  double D.10693;
  long unsigned int time_to.30;
  int D.10208;
  int iftmp.31;
  int D.10204;
  const char[10] * D.10699;
  unsigned char D.10700;
  int D.10701;
  unsigned char D.10702;
  int D.10703;
  const unsigned char * D.10708;
  unsigned char D.10709;
  int D.10710;
  const unsigned char * D.10711;
  unsigned char D.10712;
  int D.10713;
  const unsigned char * D.10718;
  unsigned char D.10719;
  int D.10720;
  const unsigned char * D.10721;
  unsigned char D.10722;
  int D.10723;
  const unsigned char * D.10728;
  unsigned char D.10729;
  int D.10730;
  const unsigned char * D.10731;
  unsigned char D.10732;
  int D.10733;
  int verbose.32;
  int verbose.33;
  int D.10217;
  int iftmp.34;
  int D.10213;
  const char[9] * D.10743;
  unsigned char D.10744;
  int D.10745;
  unsigned char D.10746;
  int D.10747;
  const unsigned char * D.10752;
  unsigned char D.10753;
  int D.10754;
  const unsigned char * D.10755;
  unsigned char D.10756;
  int D.10757;
  const unsigned char * D.10762;
  unsigned char D.10763;
  int D.10764;
  const unsigned char * D.10765;
  unsigned char D.10766;
  int D.10767;
  const unsigned char * D.10772;
  unsigned char D.10773;
  int D.10774;
  const unsigned char * D.10775;
  unsigned char D.10776;
  int D.10777;
  int D.10784;
  int num_tracked_objects.35;
  const char * reports.36;
  struct ProfContext * ctx;
  int i;

  stdout.14 = stdout;
  outfile = stdout.14;
  i = 1;
  goto <D.10220>;
  <D.10219>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 7;
    if (__s1_len <= 3) goto <D.10335>; else goto <D.10336>;
    <D.10335>:
    {
      const unsigned char * __s2;
      int __result;

      D.10337 = (long unsigned int) i;
      D.10338 = D.10337 * 8;
      D.10339 = argv + D.10338;
      __s2 = *D.10339;
      D.10340 = "--debug";
      D.10341 = MEM[(const unsigned char *)D.10340];
      D.10342 = (int) D.10341;
      D.10343 = *__s2;
      D.10344 = (int) D.10343;
      __result = D.10342 - D.10344;
      {
        if (__s1_len != 0) goto <D.10345>; else goto <D.10346>;
        <D.10345>:
        if (__result == 0) goto <D.10347>; else goto <D.10348>;
        <D.10347>:
        D.10349 = &MEM[(void *)"--debug" + 1B];
        D.10350 = *D.10349;
        D.10351 = (int) D.10350;
        D.10352 = __s2 + 1;
        D.10353 = *D.10352;
        D.10354 = (int) D.10353;
        __result = D.10351 - D.10354;
        if (__s1_len > 1) goto <D.10355>; else goto <D.10356>;
        <D.10355>:
        if (__result == 0) goto <D.10357>; else goto <D.10358>;
        <D.10357>:
        D.10359 = &MEM[(void *)"--debug" + 2B];
        D.10360 = *D.10359;
        D.10361 = (int) D.10360;
        D.10362 = __s2 + 2;
        D.10363 = *D.10362;
        D.10364 = (int) D.10363;
        __result = D.10361 - D.10364;
        if (__s1_len > 2) goto <D.10365>; else goto <D.10366>;
        <D.10365>:
        if (__result == 0) goto <D.10367>; else goto <D.10368>;
        <D.10367>:
        D.10369 = &MEM[(void *)"--debug" + 3B];
        D.10370 = *D.10369;
        D.10371 = (int) D.10370;
        D.10372 = __s2 + 3;
        D.10373 = *D.10372;
        D.10374 = (int) D.10373;
        __result = D.10371 - D.10374;
        <D.10368>:
        <D.10366>:
        <D.10358>:
        <D.10356>:
        <D.10348>:
        <D.10346>:
      }
      D.10041 = __result;
    }
    iftmp.15 = D.10041;
    goto <D.10375>;
    <D.10336>:
    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    iftmp.15 = __builtin_strcmp ("--debug", D.10376);
    <D.10375>:
    D.10045 = iftmp.15;
  }
  if (D.10045 == 0) goto <D.10377>; else goto <D.10378>;
  <D.10377>:
  debug.16 = debug;
  debug.17 = debug.16 + 1;
  debug = debug.17;
  goto <D.10381>;
  <D.10378>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 6;
    if (__s1_len <= 3) goto <D.10383>; else goto <D.10384>;
    <D.10383>:
    {
      const unsigned char * __s2;
      int __result;

      D.10337 = (long unsigned int) i;
      D.10338 = D.10337 * 8;
      D.10339 = argv + D.10338;
      __s2 = *D.10339;
      D.10385 = "--help";
      D.10386 = MEM[(const unsigned char *)D.10385];
      D.10387 = (int) D.10386;
      D.10388 = *__s2;
      D.10389 = (int) D.10388;
      __result = D.10387 - D.10389;
      {
        if (__s1_len != 0) goto <D.10390>; else goto <D.10391>;
        <D.10390>:
        if (__result == 0) goto <D.10392>; else goto <D.10393>;
        <D.10392>:
        D.10394 = &MEM[(void *)"--help" + 1B];
        D.10395 = *D.10394;
        D.10396 = (int) D.10395;
        D.10397 = __s2 + 1;
        D.10398 = *D.10397;
        D.10399 = (int) D.10398;
        __result = D.10396 - D.10399;
        if (__s1_len > 1) goto <D.10400>; else goto <D.10401>;
        <D.10400>:
        if (__result == 0) goto <D.10402>; else goto <D.10403>;
        <D.10402>:
        D.10404 = &MEM[(void *)"--help" + 2B];
        D.10405 = *D.10404;
        D.10406 = (int) D.10405;
        D.10407 = __s2 + 2;
        D.10408 = *D.10407;
        D.10409 = (int) D.10408;
        __result = D.10406 - D.10409;
        if (__s1_len > 2) goto <D.10410>; else goto <D.10411>;
        <D.10410>:
        if (__result == 0) goto <D.10412>; else goto <D.10413>;
        <D.10412>:
        D.10414 = &MEM[(void *)"--help" + 3B];
        D.10415 = *D.10414;
        D.10416 = (int) D.10415;
        D.10417 = __s2 + 3;
        D.10418 = *D.10417;
        D.10419 = (int) D.10418;
        __result = D.10416 - D.10419;
        <D.10413>:
        <D.10411>:
        <D.10403>:
        <D.10401>:
        <D.10393>:
        <D.10391>:
      }
      D.10050 = __result;
    }
    iftmp.18 = D.10050;
    goto <D.10420>;
    <D.10384>:
    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    iftmp.18 = __builtin_strcmp ("--help", D.10376);
    <D.10420>:
    D.10054 = iftmp.18;
  }
  if (D.10054 == 0) goto <D.10421>; else goto <D.10422>;
  <D.10421>:
  usage ();
  D.10423 = 0;
  return D.10423;
  <D.10422>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  D.10424 = strncmp ("--alloc-sort=", D.10376, 13);
  if (D.10424 == 0) goto <D.10425>; else goto <D.10426>;
  <D.10425>:
  {
    const char * val;

    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    val = D.10376 + 13;
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 5;
      if (__s2_len <= 3) goto <D.10428>; else goto <D.10429>;
      <D.10428>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = val;
        D.10430 = "bytes";
        D.10431 = MEM[(const unsigned char *)D.10430];
        D.10432 = (int) D.10431;
        D.10433 = *__s2;
        D.10434 = (int) D.10433;
        __result = D.10432 - D.10434;
        {
          if (__s2_len != 0) goto <D.10435>; else goto <D.10436>;
          <D.10435>:
          if (__result == 0) goto <D.10437>; else goto <D.10438>;
          <D.10437>:
          D.10439 = &MEM[(void *)"bytes" + 1B];
          D.10440 = *D.10439;
          D.10441 = (int) D.10440;
          D.10442 = __s2 + 1;
          D.10443 = *D.10442;
          D.10444 = (int) D.10443;
          __result = D.10441 - D.10444;
          if (__s2_len > 1) goto <D.10445>; else goto <D.10446>;
          <D.10445>:
          if (__result == 0) goto <D.10447>; else goto <D.10448>;
          <D.10447>:
          D.10449 = &MEM[(void *)"bytes" + 2B];
          D.10450 = *D.10449;
          D.10451 = (int) D.10450;
          D.10452 = __s2 + 2;
          D.10453 = *D.10452;
          D.10454 = (int) D.10453;
          __result = D.10451 - D.10454;
          if (__s2_len > 2) goto <D.10455>; else goto <D.10456>;
          <D.10455>:
          if (__result == 0) goto <D.10457>; else goto <D.10458>;
          <D.10457>:
          D.10459 = &MEM[(void *)"bytes" + 3B];
          D.10460 = *D.10459;
          D.10461 = (int) D.10460;
          D.10462 = __s2 + 3;
          D.10463 = *D.10462;
          D.10464 = (int) D.10463;
          __result = D.10461 - D.10464;
          <D.10458>:
          <D.10456>:
          <D.10448>:
          <D.10446>:
          <D.10438>:
          <D.10436>:
        }
        D.10072 = __result;
      }
      iftmp.19 = -D.10072;
      goto <D.10465>;
      <D.10429>:
      iftmp.19 = __builtin_strcmp (val, "bytes");
      <D.10465>:
      D.10073 = iftmp.19;
    }
    if (D.10073 == 0) goto <D.10466>; else goto <D.10467>;
    <D.10466>:
    alloc_sort_mode = 0;
    goto <D.10468>;
    <D.10467>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 5;
      if (__s2_len <= 3) goto <D.10470>; else goto <D.10471>;
      <D.10470>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = val;
        D.10472 = "count";
        D.10473 = MEM[(const unsigned char *)D.10472];
        D.10474 = (int) D.10473;
        D.10475 = *__s2;
        D.10476 = (int) D.10475;
        __result = D.10474 - D.10476;
        {
          if (__s2_len != 0) goto <D.10477>; else goto <D.10478>;
          <D.10477>:
          if (__result == 0) goto <D.10479>; else goto <D.10480>;
          <D.10479>:
          D.10481 = &MEM[(void *)"count" + 1B];
          D.10482 = *D.10481;
          D.10483 = (int) D.10482;
          D.10484 = __s2 + 1;
          D.10485 = *D.10484;
          D.10486 = (int) D.10485;
          __result = D.10483 - D.10486;
          if (__s2_len > 1) goto <D.10487>; else goto <D.10488>;
          <D.10487>:
          if (__result == 0) goto <D.10489>; else goto <D.10490>;
          <D.10489>:
          D.10491 = &MEM[(void *)"count" + 2B];
          D.10492 = *D.10491;
          D.10493 = (int) D.10492;
          D.10494 = __s2 + 2;
          D.10495 = *D.10494;
          D.10496 = (int) D.10495;
          __result = D.10493 - D.10496;
          if (__s2_len > 2) goto <D.10497>; else goto <D.10498>;
          <D.10497>:
          if (__result == 0) goto <D.10499>; else goto <D.10500>;
          <D.10499>:
          D.10501 = &MEM[(void *)"count" + 3B];
          D.10502 = *D.10501;
          D.10503 = (int) D.10502;
          D.10504 = __s2 + 3;
          D.10505 = *D.10504;
          D.10506 = (int) D.10505;
          __result = D.10503 - D.10506;
          <D.10500>:
          <D.10498>:
          <D.10490>:
          <D.10488>:
          <D.10480>:
          <D.10478>:
        }
        D.10081 = __result;
      }
      iftmp.20 = -D.10081;
      goto <D.10507>;
      <D.10471>:
      iftmp.20 = __builtin_strcmp (val, "count");
      <D.10507>:
      D.10082 = iftmp.20;
    }
    if (D.10082 == 0) goto <D.10508>; else goto <D.10509>;
    <D.10508>:
    alloc_sort_mode = 1;
    goto <D.10510>;
    <D.10509>:
    usage ();
    D.10423 = 1;
    return D.10423;
    <D.10510>:
    <D.10468>:
  }
  goto <D.10511>;
  <D.10426>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  D.10512 = strncmp ("--method-sort=", D.10376, 14);
  if (D.10512 == 0) goto <D.10513>; else goto <D.10514>;
  <D.10513>:
  {
    const char * val;

    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    val = D.10376 + 14;
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 5;
      if (__s2_len <= 3) goto <D.10516>; else goto <D.10517>;
      <D.10516>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = val;
        D.10518 = "total";
        D.10519 = MEM[(const unsigned char *)D.10518];
        D.10520 = (int) D.10519;
        D.10521 = *__s2;
        D.10522 = (int) D.10521;
        __result = D.10520 - D.10522;
        {
          if (__s2_len != 0) goto <D.10523>; else goto <D.10524>;
          <D.10523>:
          if (__result == 0) goto <D.10525>; else goto <D.10526>;
          <D.10525>:
          D.10527 = &MEM[(void *)"total" + 1B];
          D.10528 = *D.10527;
          D.10529 = (int) D.10528;
          D.10530 = __s2 + 1;
          D.10531 = *D.10530;
          D.10532 = (int) D.10531;
          __result = D.10529 - D.10532;
          if (__s2_len > 1) goto <D.10533>; else goto <D.10534>;
          <D.10533>:
          if (__result == 0) goto <D.10535>; else goto <D.10536>;
          <D.10535>:
          D.10537 = &MEM[(void *)"total" + 2B];
          D.10538 = *D.10537;
          D.10539 = (int) D.10538;
          D.10540 = __s2 + 2;
          D.10541 = *D.10540;
          D.10542 = (int) D.10541;
          __result = D.10539 - D.10542;
          if (__s2_len > 2) goto <D.10543>; else goto <D.10544>;
          <D.10543>:
          if (__result == 0) goto <D.10545>; else goto <D.10546>;
          <D.10545>:
          D.10547 = &MEM[(void *)"total" + 3B];
          D.10548 = *D.10547;
          D.10549 = (int) D.10548;
          D.10550 = __s2 + 3;
          D.10551 = *D.10550;
          D.10552 = (int) D.10551;
          __result = D.10549 - D.10552;
          <D.10546>:
          <D.10544>:
          <D.10536>:
          <D.10534>:
          <D.10526>:
          <D.10524>:
        }
        D.10100 = __result;
      }
      iftmp.21 = -D.10100;
      goto <D.10553>;
      <D.10517>:
      iftmp.21 = __builtin_strcmp (val, "total");
      <D.10553>:
      D.10101 = iftmp.21;
    }
    if (D.10101 == 0) goto <D.10554>; else goto <D.10555>;
    <D.10554>:
    method_sort_mode = 0;
    goto <D.10556>;
    <D.10555>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 4;
      if (__s2_len <= 3) goto <D.10558>; else goto <D.10559>;
      <D.10558>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = val;
        D.10560 = "self";
        D.10561 = MEM[(const unsigned char *)D.10560];
        D.10562 = (int) D.10561;
        D.10563 = *__s2;
        D.10564 = (int) D.10563;
        __result = D.10562 - D.10564;
        {
          if (__s2_len != 0) goto <D.10565>; else goto <D.10566>;
          <D.10565>:
          if (__result == 0) goto <D.10567>; else goto <D.10568>;
          <D.10567>:
          D.10569 = &MEM[(void *)"self" + 1B];
          D.10570 = *D.10569;
          D.10571 = (int) D.10570;
          D.10572 = __s2 + 1;
          D.10573 = *D.10572;
          D.10574 = (int) D.10573;
          __result = D.10571 - D.10574;
          if (__s2_len > 1) goto <D.10575>; else goto <D.10576>;
          <D.10575>:
          if (__result == 0) goto <D.10577>; else goto <D.10578>;
          <D.10577>:
          D.10579 = &MEM[(void *)"self" + 2B];
          D.10580 = *D.10579;
          D.10581 = (int) D.10580;
          D.10582 = __s2 + 2;
          D.10583 = *D.10582;
          D.10584 = (int) D.10583;
          __result = D.10581 - D.10584;
          if (__s2_len > 2) goto <D.10585>; else goto <D.10586>;
          <D.10585>:
          if (__result == 0) goto <D.10587>; else goto <D.10588>;
          <D.10587>:
          D.10589 = &MEM[(void *)"self" + 3B];
          D.10590 = *D.10589;
          D.10591 = (int) D.10590;
          D.10592 = __s2 + 3;
          D.10593 = *D.10592;
          D.10594 = (int) D.10593;
          __result = D.10591 - D.10594;
          <D.10588>:
          <D.10586>:
          <D.10578>:
          <D.10576>:
          <D.10568>:
          <D.10566>:
        }
        D.10109 = __result;
      }
      iftmp.22 = -D.10109;
      goto <D.10595>;
      <D.10559>:
      iftmp.22 = __builtin_strcmp (val, "self");
      <D.10595>:
      D.10110 = iftmp.22;
    }
    if (D.10110 == 0) goto <D.10596>; else goto <D.10597>;
    <D.10596>:
    method_sort_mode = 1;
    goto <D.10598>;
    <D.10597>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 5;
      if (__s2_len <= 3) goto <D.10600>; else goto <D.10601>;
      <D.10600>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = val;
        D.10602 = "calls";
        D.10603 = MEM[(const unsigned char *)D.10602];
        D.10604 = (int) D.10603;
        D.10605 = *__s2;
        D.10606 = (int) D.10605;
        __result = D.10604 - D.10606;
        {
          if (__s2_len != 0) goto <D.10607>; else goto <D.10608>;
          <D.10607>:
          if (__result == 0) goto <D.10609>; else goto <D.10610>;
          <D.10609>:
          D.10611 = &MEM[(void *)"calls" + 1B];
          D.10612 = *D.10611;
          D.10613 = (int) D.10612;
          D.10614 = __s2 + 1;
          D.10615 = *D.10614;
          D.10616 = (int) D.10615;
          __result = D.10613 - D.10616;
          if (__s2_len > 1) goto <D.10617>; else goto <D.10618>;
          <D.10617>:
          if (__result == 0) goto <D.10619>; else goto <D.10620>;
          <D.10619>:
          D.10621 = &MEM[(void *)"calls" + 2B];
          D.10622 = *D.10621;
          D.10623 = (int) D.10622;
          D.10624 = __s2 + 2;
          D.10625 = *D.10624;
          D.10626 = (int) D.10625;
          __result = D.10623 - D.10626;
          if (__s2_len > 2) goto <D.10627>; else goto <D.10628>;
          <D.10627>:
          if (__result == 0) goto <D.10629>; else goto <D.10630>;
          <D.10629>:
          D.10631 = &MEM[(void *)"calls" + 3B];
          D.10632 = *D.10631;
          D.10633 = (int) D.10632;
          D.10634 = __s2 + 3;
          D.10635 = *D.10634;
          D.10636 = (int) D.10635;
          __result = D.10633 - D.10636;
          <D.10630>:
          <D.10628>:
          <D.10620>:
          <D.10618>:
          <D.10610>:
          <D.10608>:
        }
        D.10118 = __result;
      }
      iftmp.23 = -D.10118;
      goto <D.10637>;
      <D.10601>:
      iftmp.23 = __builtin_strcmp (val, "calls");
      <D.10637>:
      D.10119 = iftmp.23;
    }
    if (D.10119 == 0) goto <D.10638>; else goto <D.10639>;
    <D.10638>:
    method_sort_mode = 2;
    goto <D.10640>;
    <D.10639>:
    usage ();
    D.10423 = 1;
    return D.10423;
    <D.10640>:
    <D.10598>:
    <D.10556>:
  }
  goto <D.10641>;
  <D.10514>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  D.10642 = strncmp ("--reports=", D.10376, 10);
  if (D.10642 == 0) goto <D.10643>; else goto <D.10644>;
  <D.10643>:
  {
    const char * val;

    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    val = D.10376 + 10;
    D.10645 = print_reports (0B, val, 1);
    if (D.10645 == 0) goto <D.10646>; else goto <D.10647>;
    <D.10646>:
    usage ();
    D.10423 = 1;
    return D.10423;
    <D.10647>:
    reports = val;
  }
  goto <D.10648>;
  <D.10644>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  D.10649 = strncmp ("--out=", D.10376, 6);
  if (D.10649 == 0) goto <D.10650>; else goto <D.10651>;
  <D.10650>:
  {
    const char * val;

    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    val = D.10376 + 6;
    outfile.24 = fopen (val, "w");
    outfile = outfile.24;
    outfile.25 = outfile;
    if (outfile.25 == 0B) goto <D.10654>; else goto <D.10655>;
    <D.10654>:
    printf ("Cannot open output file: %s\n", val);
    D.10423 = 1;
    return D.10423;
    <D.10655>:
  }
  goto <D.10656>;
  <D.10651>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  D.10657 = strncmp ("--maxframes=", D.10376, 12);
  if (D.10657 == 0) goto <D.10658>; else goto <D.10659>;
  <D.10658>:
  {
    const char * val;
    char * vale;

    try
      {
        D.10337 = (long unsigned int) i;
        D.10338 = D.10337 * 8;
        D.10339 = argv + D.10338;
        D.10376 = *D.10339;
        val = D.10376 + 12;
        D.10660 = strtoul (val, &vale, 10);
        trace_max.26 = (int) D.10660;
        trace_max = trace_max.26;
      }
    finally
      {
        vale = {CLOBBER};
      }
  }
  goto <D.10662>;
  <D.10659>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  D.10663 = strncmp ("--find=", D.10376, 7);
  if (D.10663 == 0) goto <D.10664>; else goto <D.10665>;
  <D.10664>:
  {
    const char * val;

    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    val = D.10376 + 7;
    D.10666 = add_find_spec (val);
    if (D.10666 == 0) goto <D.10667>; else goto <D.10668>;
    <D.10667>:
    usage ();
    D.10423 = 1;
    return D.10423;
    <D.10668>:
  }
  goto <D.10669>;
  <D.10665>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  D.10670 = strncmp ("--track=", D.10376, 8);
  if (D.10670 == 0) goto <D.10671>; else goto <D.10672>;
  <D.10671>:
  {
    const char * val;
    char * vale;

    try
      {
        D.10337 = (long unsigned int) i;
        D.10338 = D.10337 * 8;
        D.10339 = argv + D.10338;
        D.10376 = *D.10339;
        val = D.10376 + 8;
        goto <D.10173>;
        <D.10174>:
        {
          uintptr_t tracked_obj;

          D.10673 = *val;
          if (D.10673 == 44) goto <D.10674>; else goto <D.10675>;
          <D.10674>:
          val = val + 1;
          // predicted unlikely by continue predictor.
          goto <D.10173>;
          <D.10675>:
          tracked_obj = strtoul (val, &vale, 0);
          found_object (tracked_obj);
          val = vale;
        }
        <D.10173>:
        D.10673 = *val;
        if (D.10673 != 0) goto <D.10174>; else goto <D.10175>;
        <D.10175>:
      }
    finally
      {
        vale = {CLOBBER};
      }
  }
  goto <D.10676>;
  <D.10672>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  D.10677 = strncmp ("--thread=", D.10376, 9);
  if (D.10677 == 0) goto <D.10678>; else goto <D.10679>;
  <D.10678>:
  {
    const char * val;
    char * vale;

    try
      {
        D.10337 = (long unsigned int) i;
        D.10338 = D.10337 * 8;
        D.10339 = argv + D.10338;
        D.10376 = *D.10339;
        val = D.10376 + 9;
        thread_filter.27 = strtoul (val, &vale, 0);
        thread_filter = thread_filter.27;
      }
    finally
      {
        vale = {CLOBBER};
      }
  }
  goto <D.10681>;
  <D.10679>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  D.10682 = strncmp ("--time=", D.10376, 7);
  if (D.10682 == 0) goto <D.10683>; else goto <D.10684>;
  <D.10683>:
  {
    char * val;
    double from_secs;
    double to_secs;
    char * top;

    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    D.10685 = D.10376 + 7;
    val = pstrdup (D.10685);
    top = __builtin_strchr (val, 45);
    if (top == 0B) goto <D.10686>; else goto <D.10687>;
    <D.10686>:
    usage ();
    D.10423 = 1;
    return D.10423;
    <D.10687>:
    top.28 = top;
    top = top.28 + 1;
    *top.28 = 0;
    from_secs = atof (val);
    to_secs = atof (top);
    free (val);
    if (from_secs > to_secs) goto <D.10689>; else goto <D.10690>;
    <D.10689>:
    usage ();
    D.10423 = 1;
    return D.10423;
    <D.10690>:
    D.10691 = from_secs * 1.0e+9;
    time_from.29 = (long unsigned int) D.10691;
    time_from = time_from.29;
    D.10693 = to_secs * 1.0e+9;
    time_to.30 = (long unsigned int) D.10693;
    time_to = time_to.30;
  }
  goto <D.10695>;
  <D.10684>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.10697>; else goto <D.10698>;
    <D.10697>:
    {
      const unsigned char * __s2;
      int __result;

      D.10337 = (long unsigned int) i;
      D.10338 = D.10337 * 8;
      D.10339 = argv + D.10338;
      __s2 = *D.10339;
      D.10699 = "--verbose";
      D.10700 = MEM[(const unsigned char *)D.10699];
      D.10701 = (int) D.10700;
      D.10702 = *__s2;
      D.10703 = (int) D.10702;
      __result = D.10701 - D.10703;
      {
        if (__s1_len != 0) goto <D.10704>; else goto <D.10705>;
        <D.10704>:
        if (__result == 0) goto <D.10706>; else goto <D.10707>;
        <D.10706>:
        D.10708 = &MEM[(void *)"--verbose" + 1B];
        D.10709 = *D.10708;
        D.10710 = (int) D.10709;
        D.10711 = __s2 + 1;
        D.10712 = *D.10711;
        D.10713 = (int) D.10712;
        __result = D.10710 - D.10713;
        if (__s1_len > 1) goto <D.10714>; else goto <D.10715>;
        <D.10714>:
        if (__result == 0) goto <D.10716>; else goto <D.10717>;
        <D.10716>:
        D.10718 = &MEM[(void *)"--verbose" + 2B];
        D.10719 = *D.10718;
        D.10720 = (int) D.10719;
        D.10721 = __s2 + 2;
        D.10722 = *D.10721;
        D.10723 = (int) D.10722;
        __result = D.10720 - D.10723;
        if (__s1_len > 2) goto <D.10724>; else goto <D.10725>;
        <D.10724>:
        if (__result == 0) goto <D.10726>; else goto <D.10727>;
        <D.10726>:
        D.10728 = &MEM[(void *)"--verbose" + 3B];
        D.10729 = *D.10728;
        D.10730 = (int) D.10729;
        D.10731 = __s2 + 3;
        D.10732 = *D.10731;
        D.10733 = (int) D.10732;
        __result = D.10730 - D.10733;
        <D.10727>:
        <D.10725>:
        <D.10717>:
        <D.10715>:
        <D.10707>:
        <D.10705>:
      }
      D.10204 = __result;
    }
    iftmp.31 = D.10204;
    goto <D.10734>;
    <D.10698>:
    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    iftmp.31 = __builtin_strcmp ("--verbose", D.10376);
    <D.10734>:
    D.10208 = iftmp.31;
  }
  if (D.10208 == 0) goto <D.10735>; else goto <D.10736>;
  <D.10735>:
  verbose.32 = verbose;
  verbose.33 = verbose.32 + 1;
  verbose = verbose.33;
  goto <D.10739>;
  <D.10736>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.10741>; else goto <D.10742>;
    <D.10741>:
    {
      const unsigned char * __s2;
      int __result;

      D.10337 = (long unsigned int) i;
      D.10338 = D.10337 * 8;
      D.10339 = argv + D.10338;
      __s2 = *D.10339;
      D.10743 = "--traces";
      D.10744 = MEM[(const unsigned char *)D.10743];
      D.10745 = (int) D.10744;
      D.10746 = *__s2;
      D.10747 = (int) D.10746;
      __result = D.10745 - D.10747;
      {
        if (__s1_len != 0) goto <D.10748>; else goto <D.10749>;
        <D.10748>:
        if (__result == 0) goto <D.10750>; else goto <D.10751>;
        <D.10750>:
        D.10752 = &MEM[(void *)"--traces" + 1B];
        D.10753 = *D.10752;
        D.10754 = (int) D.10753;
        D.10755 = __s2 + 1;
        D.10756 = *D.10755;
        D.10757 = (int) D.10756;
        __result = D.10754 - D.10757;
        if (__s1_len > 1) goto <D.10758>; else goto <D.10759>;
        <D.10758>:
        if (__result == 0) goto <D.10760>; else goto <D.10761>;
        <D.10760>:
        D.10762 = &MEM[(void *)"--traces" + 2B];
        D.10763 = *D.10762;
        D.10764 = (int) D.10763;
        D.10765 = __s2 + 2;
        D.10766 = *D.10765;
        D.10767 = (int) D.10766;
        __result = D.10764 - D.10767;
        if (__s1_len > 2) goto <D.10768>; else goto <D.10769>;
        <D.10768>:
        if (__result == 0) goto <D.10770>; else goto <D.10771>;
        <D.10770>:
        D.10772 = &MEM[(void *)"--traces" + 3B];
        D.10773 = *D.10772;
        D.10774 = (int) D.10773;
        D.10775 = __s2 + 3;
        D.10776 = *D.10775;
        D.10777 = (int) D.10776;
        __result = D.10774 - D.10777;
        <D.10771>:
        <D.10769>:
        <D.10761>:
        <D.10759>:
        <D.10751>:
        <D.10749>:
      }
      D.10213 = __result;
    }
    iftmp.34 = D.10213;
    goto <D.10778>;
    <D.10742>:
    D.10337 = (long unsigned int) i;
    D.10338 = D.10337 * 8;
    D.10339 = argv + D.10338;
    D.10376 = *D.10339;
    iftmp.34 = __builtin_strcmp ("--traces", D.10376);
    <D.10778>:
    D.10217 = iftmp.34;
  }
  if (D.10217 == 0) goto <D.10779>; else goto <D.10218>;
  <D.10779>:
  show_traces = 1;
  collect_traces = 1;
  <D.10739>:
  <D.10695>:
  <D.10681>:
  <D.10676>:
  <D.10669>:
  <D.10662>:
  <D.10656>:
  <D.10648>:
  <D.10641>:
  <D.10511>:
  <D.10381>:
  i = i + 1;
  <D.10220>:
  if (i < argc) goto <D.10219>; else goto <D.10218>;
  <D.10218>:
  if (i >= argc) goto <D.10780>; else goto <D.10781>;
  <D.10780>:
  usage ();
  D.10423 = 2;
  return D.10423;
  <D.10781>:
  D.10337 = (long unsigned int) i;
  D.10338 = D.10337 * 8;
  D.10339 = argv + D.10338;
  D.10376 = *D.10339;
  ctx = load_file (D.10376);
  if (ctx == 0B) goto <D.10782>; else goto <D.10783>;
  <D.10782>:
  printf ("Not a log profiler data file (or unsupported version).\n");
  D.10423 = 1;
  return D.10423;
  <D.10783>:
  goto <D.10222>;
  <D.10221>:
  <D.10222>:
  D.10784 = decode_buffer (ctx);
  if (D.10784 != 0) goto <D.10221>; else goto <D.10223>;
  <D.10223>:
  flush_context (ctx);
  num_tracked_objects.35 = num_tracked_objects;
  if (num_tracked_objects.35 != 0) goto <D.10786>; else goto <D.10787>;
  <D.10786>:
  D.10423 = 0;
  return D.10423;
  <D.10787>:
  reports.36 = reports;
  print_reports (ctx, reports.36, 0);
  D.10423 = 0;
  return D.10423;
}


add_find_spec (const char * p)
{
  char D.10799;
  const char * D.10801;
  char D.10802;
  const char * find_name.38;
  long unsigned int find_size.37;
  int D.10806;

  D.10799 = *p;
  if (D.10799 == 83) goto <D.10800>; else goto <D.10798>;
  <D.10800>:
  D.10801 = p + 1;
  D.10802 = *D.10801;
  if (D.10802 == 58) goto <D.10803>; else goto <D.10798>;
  <D.10803>:
  {
    char * vale;

    try
      {
        find_name.38 = p + 2;
        find_size.37 = strtoul (find_name.38, &vale, 10);
        find_size = find_size.37;
        D.10806 = 1;
        return D.10806;
      }
    finally
      {
        vale = {CLOBBER};
      }
  }
  <D.10798>:
  D.10799 = *p;
  if (D.10799 == 84) goto <D.10807>; else goto <D.10808>;
  <D.10807>:
  D.10801 = p + 1;
  D.10802 = *D.10801;
  if (D.10802 == 58) goto <D.10809>; else goto <D.10810>;
  <D.10809>:
  find_name.38 = p + 2;
  find_name = find_name.38;
  D.10806 = 1;
  return D.10806;
  <D.10810>:
  <D.10808>:
  D.10806 = 0;
  return D.10806;
}


found_object (uintptr_t obj)
{
  int num_tracked_objects.39;
  int num_tracked_objects.40;
  uintptr_t * tracked_objects.41;
  long unsigned int D.10816;
  long unsigned int D.10817;
  void * tracked_objects.42;
  sizetype D.10819;
  uintptr_t * D.10820;

  num_tracked_objects.39 = num_tracked_objects;
  num_tracked_objects.40 = num_tracked_objects.39 + 1;
  num_tracked_objects = num_tracked_objects.40;
  tracked_objects.41 = tracked_objects;
  num_tracked_objects.39 = num_tracked_objects;
  D.10816 = (long unsigned int) num_tracked_objects.39;
  D.10817 = D.10816 * 8;
  tracked_objects.42 = realloc (tracked_objects.41, D.10817);
  tracked_objects = tracked_objects.42;
  tracked_objects.41 = tracked_objects;
  num_tracked_objects.39 = num_tracked_objects;
  D.10816 = (long unsigned int) num_tracked_objects.39;
  D.10817 = D.10816 * 8;
  D.10819 = D.10817 + 18446744073709551608;
  D.10820 = tracked_objects.41 + D.10819;
  *D.10820 = obj;
}


pstrdup (const char * s)
{
  long unsigned int D.10821;
  unsigned int D.10822;
  unsigned int D.10823;
  long unsigned int D.10824;
  char * D.10825;
  int len;
  char * p;

  D.10821 = strlen (s);
  D.10822 = (unsigned int) D.10821;
  D.10823 = D.10822 + 1;
  len = (int) D.10823;
  D.10824 = (long unsigned int) len;
  p = malloc (D.10824);
  D.10824 = (long unsigned int) len;
  memcpy (p, s, D.10824);
  D.10825 = p;
  return D.10825;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.10827;
  long unsigned int D.10828;

  D.10828 = __builtin_object_size (__dest, 0);
  D.10827 = __builtin___memcpy_chk (__dest, __src, __len, D.10828);
  return D.10827;
}


atof (const char * __nptr)
{
  double D.10830;

  D.10830 = strtod (__nptr, 0B);
  return D.10830;
}


usage ()
{
  const char * reports.43;

  printf ("Mono log profiler report version %d.%d\n", 0, 4);
  printf ("Usage: mprof-report [OPTIONS] FILENAME\n");
  printf ("FILENAME can be \'-\' to read from standard input.\n");
  printf ("Options:\n");
  printf ("\t--help               display this help\n");
  printf ("\t--out=FILE           write to FILE instead of stdout\n");
  printf ("\t--traces             collect and show backtraces\n");
  printf ("\t--maxframes=NUM      limit backtraces to NUM entries\n");
  printf ("\t--reports=R1[,R2...] print the specified reports. Defaults are:\n");
  reports.43 = reports;
  printf ("\t                     %s\n", reports.43);
  printf ("\t--method-sort=MODE   sort methods according to MODE: total, self, calls\n");
  printf ("\t--alloc-sort=MODE    sort allocations according to MODE: bytes, count\n");
  printf ("\t--track=OB1[,OB2...] track what happens to objects OBJ1, O2 etc.\n");
  printf ("\t--find=FINDSPEC      find and track objects matching FINFSPEC, where FINDSPEC is:\n");
  printf ("\t                     S:minimum_size or T:partial_name\n");
  printf ("\t--thread=THREADID    consider just the data for thread THREADID\n");
  printf ("\t--time=FROM-TO       consider data FROM seconds from startup up to TO seconds\n");
  printf ("\t--verbose            increase verbosity level\n");
  printf ("\t--debug              display decoding debug info for mprof-report devs\n");
}


load_file (char * name)
{
  int D.9756;
  int iftmp.44;
  int D.9755;
  const char[2] * D.10836;
  unsigned char D.10837;
  int D.10838;
  unsigned char D.10839;
  int D.10840;
  const unsigned char * D.10845;
  unsigned char D.10846;
  int D.10847;
  const unsigned char * D.10848;
  unsigned char D.10849;
  int D.10850;
  const unsigned char * D.10855;
  unsigned char D.10856;
  int D.10857;
  const unsigned char * D.10858;
  unsigned char D.10859;
  int D.10860;
  const unsigned char * D.10865;
  unsigned char D.10866;
  int D.10867;
  const unsigned char * D.10868;
  unsigned char D.10869;
  int D.10870;
  struct _IO_FILE * stdin.45;
  struct FILE * D.10876;
  struct FILE * D.10877;
  int D.10882;
  struct gzFile_s * D.10883;
  int D.10884;
  struct ProfContext * D.10887;
  int D.10890;
  unsigned char * D.10892;
  unsigned char D.10893;
  unsigned char * D.10894;
  unsigned char D.10895;
  int D.10896;
  unsigned char * D.10897;
  unsigned char D.10898;
  int D.10899;
  int D.10900;
  unsigned char * D.10901;
  unsigned char D.10902;
  unsigned char * D.10905;
  int D.10906;
  unsigned char * D.10909;
  long int D.10910;
  long unsigned int D.10911;
  unsigned char * D.10912;
  int D.10913;
  unsigned char * D.10914;
  int D.10915;
  unsigned char * D.10916;
  int D.10917;
  unsigned char * p;
  struct ProfContext * ctx;

  ctx = calloc (80, 1);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.10834>; else goto <D.10835>;
    <D.10834>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.10836 = "-";
      D.10837 = MEM[(const unsigned char *)D.10836];
      D.10838 = (int) D.10837;
      D.10839 = *__s2;
      D.10840 = (int) D.10839;
      __result = D.10838 - D.10840;
      {
        if (__s2_len != 0) goto <D.10841>; else goto <D.10842>;
        <D.10841>:
        if (__result == 0) goto <D.10843>; else goto <D.10844>;
        <D.10843>:
        D.10845 = &MEM[(void *)"-" + 1B];
        D.10846 = *D.10845;
        D.10847 = (int) D.10846;
        D.10848 = __s2 + 1;
        D.10849 = *D.10848;
        D.10850 = (int) D.10849;
        __result = D.10847 - D.10850;
        if (__s2_len > 1) goto <D.10851>; else goto <D.10852>;
        <D.10851>:
        if (__result == 0) goto <D.10853>; else goto <D.10854>;
        <D.10853>:
        D.10855 = &MEM[(void *)"-" + 2B];
        D.10856 = *D.10855;
        D.10857 = (int) D.10856;
        D.10858 = __s2 + 2;
        D.10859 = *D.10858;
        D.10860 = (int) D.10859;
        __result = D.10857 - D.10860;
        if (__s2_len > 2) goto <D.10861>; else goto <D.10862>;
        <D.10861>:
        if (__result == 0) goto <D.10863>; else goto <D.10864>;
        <D.10863>:
        D.10865 = &MEM[(void *)"-" + 3B];
        D.10866 = *D.10865;
        D.10867 = (int) D.10866;
        D.10868 = __s2 + 3;
        D.10869 = *D.10868;
        D.10870 = (int) D.10869;
        __result = D.10867 - D.10870;
        <D.10864>:
        <D.10862>:
        <D.10854>:
        <D.10852>:
        <D.10844>:
        <D.10842>:
      }
      D.9755 = __result;
    }
    iftmp.44 = -D.9755;
    goto <D.10871>;
    <D.10835>:
    iftmp.44 = __builtin_strcmp (name, "-");
    <D.10871>:
    D.9756 = iftmp.44;
  }
  if (D.9756 == 0) goto <D.10872>; else goto <D.10873>;
  <D.10872>:
  stdin.45 = stdin;
  ctx->file = stdin.45;
  goto <D.10875>;
  <D.10873>:
  D.10876 = fopen (name, "rb");
  ctx->file = D.10876;
  <D.10875>:
  D.10877 = ctx->file;
  if (D.10877 == 0B) goto <D.10878>; else goto <D.10879>;
  <D.10878>:
  printf ("Cannot open file: %s\n", name);
  exit (1);
  <D.10879>:
  D.10877 = ctx->file;
  stdin.45 = stdin;
  if (D.10877 != stdin.45) goto <D.10880>; else goto <D.10881>;
  <D.10880>:
  D.10877 = ctx->file;
  D.10882 = fileno (D.10877);
  D.10883 = gzdopen (D.10882, "rb");
  ctx->gzfile = D.10883;
  <D.10881>:
  D.10884 = load_data (ctx, 32);
  if (D.10884 == 0) goto <D.10885>; else goto <D.10886>;
  <D.10885>:
  D.10887 = 0B;
  return D.10887;
  <D.10886>:
  p = ctx->buf;
  D.10890 = read_int32 (p);
  if (D.10890 != 1297111553) goto <D.10888>; else goto <D.10891>;
  <D.10891>:
  D.10892 = p + 6;
  D.10893 = *D.10892;
  if (D.10893 > 4) goto <D.10888>; else goto <D.10889>;
  <D.10888>:
  D.10887 = 0B;
  return D.10887;
  <D.10889>:
  D.10894 = p + 4;
  D.10895 = *D.10894;
  D.10896 = (int) D.10895;
  ctx->version_major = D.10896;
  D.10897 = p + 5;
  D.10898 = *D.10897;
  D.10899 = (int) D.10898;
  ctx->version_minor = D.10899;
  D.10892 = p + 6;
  D.10893 = *D.10892;
  D.10900 = (int) D.10893;
  ctx->data_version = D.10900;
  D.10901 = p + 7;
  D.10902 = *D.10901;
  if (D.10902 > 8) goto <D.10903>; else goto <D.10904>;
  <D.10903>:
  D.10887 = 0B;
  return D.10887;
  <D.10904>:
  D.10905 = p + 20;
  D.10906 = read_int32 (D.10905);
  if (D.10906 != 0) goto <D.10907>; else goto <D.10908>;
  <D.10907>:
  D.10887 = 0B;
  return D.10887;
  <D.10908>:
  D.10909 = p + 8;
  D.10910 = read_int64 (D.10909);
  D.10911 = (long unsigned int) D.10910;
  ctx->startup_time = D.10911;
  D.10912 = p + 16;
  D.10913 = read_int32 (D.10912);
  ctx->timer_overhead = D.10913;
  D.10914 = p + 24;
  D.10915 = read_int32 (D.10914);
  ctx->pid = D.10915;
  D.10916 = p + 28;
  D.10917 = read_int16 (D.10916);
  ctx->port = D.10917;
  D.10887 = ctx;
  return D.10887;
}


load_data (struct ProfContext * ctx, int size)
{
  struct gzFile_s * * D.10928;
  unsigned char * D.10931;
  unsigned int size.46;
  int D.10935;
  _Bool D.10936;
  _Bool D.10937;
  long unsigned int D.10938;
  struct FILE * D.10939;
  long unsigned int D.10940;

  ensure_buffer (ctx, size);
  D.10928 = ctx->gzfile;
  if (D.10928 != 0B) goto <D.10929>; else goto <D.10930>;
  <D.10929>:
  {
    int r;

    D.10928 = ctx->gzfile;
    D.10931 = ctx->buf;
    size.46 = (unsigned int) size;
    r = gzread (D.10928, D.10931, size.46);
    if (r == 0) goto <D.10933>; else goto <D.10934>;
    <D.10933>:
    D.10936 = size == 0;
    D.10935 = (int) D.10936;
    return D.10935;
    <D.10934>:
    D.10937 = r == size;
    D.10935 = (int) D.10937;
    return D.10935;
  }
  <D.10930>:
  {
    int r;

    D.10931 = ctx->buf;
    D.10938 = (long unsigned int) size;
    D.10939 = ctx->file;
    D.10940 = fread (D.10931, D.10938, 1, D.10939);
    r = (int) D.10940;
    if (r == 0) goto <D.10941>; else goto <D.10942>;
    <D.10941>:
    D.10936 = size == 0;
    D.10935 = (int) D.10936;
    return D.10935;
    <D.10942>:
    D.10935 = r;
    return D.10935;
  }
}


ensure_buffer (struct ProfContext * ctx, int size)
{
  int D.10946;
  unsigned char * D.10949;
  long unsigned int D.10950;
  void * D.10951;

  D.10946 = ctx->size;
  if (D.10946 < size) goto <D.10947>; else goto <D.10948>;
  <D.10947>:
  D.10949 = ctx->buf;
  D.10950 = (long unsigned int) size;
  D.10951 = realloc (D.10949, D.10950);
  ctx->buf = D.10951;
  ctx->size = size;
  <D.10948>:
}


fread (void * restrict __ptr, size_t __size, size_t __n, struct FILE * restrict __stream)
{
  long unsigned int D.10952;
  int D.10957;
  int D.10959;
  long unsigned int D.10961;
  size_t D.10962;
  long unsigned int D.10963;
  long unsigned int D.10964;
  long unsigned int D.10965;
  long unsigned int D.10968;

  D.10952 = __builtin_object_size (__ptr, 0);
  if (D.10952 != 18446744073709551615) goto <D.10953>; else goto <D.10954>;
  <D.10953>:
  D.10957 = __builtin_constant_p (__size);
  if (D.10957 == 0) goto <D.10955>; else goto <D.10958>;
  <D.10958>:
  D.10959 = __builtin_constant_p (__n);
  if (D.10959 == 0) goto <D.10955>; else goto <D.10960>;
  <D.10960>:
  D.10961 = __size | __n;
  if (D.10961 > 4294967295) goto <D.10955>; else goto <D.10956>;
  <D.10955>:
  D.10963 = __builtin_object_size (__ptr, 0);
  D.10962 = __fread_chk (__ptr, D.10963, __size, __n, __stream);
  return D.10962;
  <D.10956>:
  D.10964 = __size * __n;
  D.10965 = __builtin_object_size (__ptr, 0);
  if (D.10964 > D.10965) goto <D.10966>; else goto <D.10967>;
  <D.10966>:
  D.10968 = __builtin_object_size (__ptr, 0);
  D.10962 = __fread_chk_warn (__ptr, D.10968, __size, __n, __stream);
  return D.10962;
  <D.10967>:
  <D.10954>:
  D.10962 = __fread_alias (__ptr, __size, __n, __stream);
  return D.10962;
}


read_int64 (unsigned char * p)
{
  unsigned char * p.47;
  unsigned char D.10974;
  unsigned char * p.48;
  unsigned char D.10976;
  int D.10977;
  int D.10978;
  long unsigned int D.10979;
  unsigned char * p.49;
  unsigned char D.10981;
  int D.10982;
  int D.10983;
  long unsigned int D.10984;
  unsigned char * p.50;
  unsigned char D.10986;
  long unsigned int D.10987;
  long unsigned int D.10988;
  unsigned char * p.51;
  unsigned char D.10990;
  long unsigned int D.10991;
  long unsigned int D.10992;
  unsigned char * p.52;
  unsigned char D.10994;
  long unsigned int D.10995;
  long unsigned int D.10996;
  unsigned char * p.53;
  unsigned char D.10998;
  long unsigned int D.10999;
  long unsigned int D.11000;
  unsigned char * p.54;
  unsigned char D.11002;
  long unsigned int D.11003;
  long unsigned int D.11004;
  int64_t D.11005;
  uint64_t value;

  p.47 = p;
  p = p.47 + 1;
  D.10974 = *p.47;
  value = (uint64_t) D.10974;
  p.48 = p;
  p = p.48 + 1;
  D.10976 = *p.48;
  D.10977 = (int) D.10976;
  D.10978 = D.10977 << 8;
  D.10979 = (long unsigned int) D.10978;
  value = D.10979 | value;
  p.49 = p;
  p = p.49 + 1;
  D.10981 = *p.49;
  D.10982 = (int) D.10981;
  D.10983 = D.10982 << 16;
  D.10984 = (long unsigned int) D.10983;
  value = D.10984 | value;
  p.50 = p;
  p = p.50 + 1;
  D.10986 = *p.50;
  D.10987 = (long unsigned int) D.10986;
  D.10988 = D.10987 << 24;
  value = D.10988 | value;
  p.51 = p;
  p = p.51 + 1;
  D.10990 = *p.51;
  D.10991 = (long unsigned int) D.10990;
  D.10992 = D.10991 << 32;
  value = D.10992 | value;
  p.52 = p;
  p = p.52 + 1;
  D.10994 = *p.52;
  D.10995 = (long unsigned int) D.10994;
  D.10996 = D.10995 << 40;
  value = D.10996 | value;
  p.53 = p;
  p = p.53 + 1;
  D.10998 = *p.53;
  D.10999 = (long unsigned int) D.10998;
  D.11000 = D.10999 << 48;
  value = D.11000 | value;
  p.54 = p;
  p = p.54 + 1;
  D.11002 = *p.54;
  D.11003 = (long unsigned int) D.11002;
  D.11004 = D.11003 << 54;
  value = D.11004 | value;
  D.11005 = (int64_t) value;
  return D.11005;
}


read_int32 (unsigned char * p)
{
  unsigned char * p.55;
  unsigned char D.11008;
  unsigned char * p.56;
  unsigned char D.11010;
  int D.11011;
  int D.11012;
  unsigned char * p.57;
  unsigned char D.11014;
  int D.11015;
  int D.11016;
  unsigned char * p.58;
  unsigned char D.11018;
  unsigned int D.11019;
  unsigned int D.11020;
  unsigned int value.59;
  unsigned int D.11022;
  int32_t D.11023;
  int32_t value;

  p.55 = p;
  p = p.55 + 1;
  D.11008 = *p.55;
  value = (int32_t) D.11008;
  p.56 = p;
  p = p.56 + 1;
  D.11010 = *p.56;
  D.11011 = (int) D.11010;
  D.11012 = D.11011 << 8;
  value = D.11012 | value;
  p.57 = p;
  p = p.57 + 1;
  D.11014 = *p.57;
  D.11015 = (int) D.11014;
  D.11016 = D.11015 << 16;
  value = D.11016 | value;
  p.58 = p;
  p = p.58 + 1;
  D.11018 = *p.58;
  D.11019 = (unsigned int) D.11018;
  D.11020 = D.11019 << 24;
  value.59 = (unsigned int) value;
  D.11022 = D.11020 | value.59;
  value = (int32_t) D.11022;
  D.11023 = value;
  return D.11023;
}


read_int16 (unsigned char * p)
{
  unsigned char * p.60;
  unsigned char D.11026;
  unsigned char * p.61;
  unsigned char D.11028;
  int D.11029;
  int D.11030;
  int32_t D.11031;
  int32_t value;

  p.60 = p;
  p = p.60 + 1;
  D.11026 = *p.60;
  value = (int32_t) D.11026;
  p.61 = p;
  p = p.61 + 1;
  D.11028 = *p.61;
  D.11029 = (int) D.11028;
  D.11030 = D.11029 << 8;
  value = D.11030 | value;
  D.11031 = value;
  return D.11031;
}


printf (const char * restrict __fmt)
{
  int D.11033;

  D.11033 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.11033;
}


decode_buffer (struct ProfContext * ctx)
{
  struct gzFile_s * * D.11036;
  long int D.11039;
  struct FILE * D.11041;
  long int D.11042;
  int D.11043;
  int D.11046;
  unsigned char * p.62;
  unsigned char * p.63;
  int D.11049;
  struct FILE * outfile.64;
  int D.11053;
  sizetype D.11054;
  unsigned char * D.11055;
  unsigned char D.11056;
  int D.11057;
  const char * iftmp.65;
  unsigned int i.66;
  unsigned int D.11060;
  unsigned char * D.11064;
  unsigned char * D.11065;
  long int D.11066;
  unsigned char * D.11067;
  unsigned char * D.11068;
  unsigned char * D.11069;
  unsigned char * D.11070;
  int debug.67;
  int D.11074;
  long unsigned int startup_time.68;
  long unsigned int time_from.69;
  long unsigned int time_from.70;
  long unsigned int time_to.71;
  long unsigned int time_to.72;
  char * D.11086;
  char * D.11089;
  struct MethodDesc * * D.11090;
  long unsigned int D.11091;
  long unsigned int D.11092;
  struct MethodDesc * * D.11093;
  struct MethodDesc * D.11094;
  int D.11095;
  int D.11096;
  int D.11097;
  sizetype D.11098;
  unsigned char D.11099;
  int D.11100;
  int D.11101;
  uint8_t * D.11102;
  int gc_resizes.73;
  int gc_resizes.74;
  long unsigned int max_heap_size.75;
  long unsigned int D.11115;
  int D.11118;
  const char * D.11119;
  long int D.11120;
  int D.11125;
  int D.11126;
  long unsigned int D.11130;
  long unsigned int D.11131;
  long unsigned int D.11132;
  long unsigned int D.11133;
  long unsigned int D.11139;
  int D.11140;
  long unsigned int D.11141;
  long unsigned int gc_object_moves.76;
  long unsigned int gc_object_moves.77;
  int num_tracked_objects.78;
  long int D.11147;
  long int D.11148;
  long unsigned int D.11149;
  long int D.11150;
  long int D.11151;
  long unsigned int D.11152;
  void * D.11155;
  void * D.11156;
  long unsigned int D.11160;
  long unsigned int D.11161;
  long unsigned int D.11164;
  long unsigned int D.11165;
  long unsigned int D.11166;
  long unsigned int D.11167;
  struct TraceDesc * D.11168;
  long unsigned int D.11169;
  long int D.11174;
  long int D.11175;
  long unsigned int D.11176;
  const char * D.11179;
  void * D.11180;
  long unsigned int D.11184;
  long unsigned int D.11185;
  long unsigned int D.11188;
  long unsigned int D.11189;
  long unsigned int D.11190;
  long unsigned int D.11191;
  const char * D.11194;
  unsigned char * p.79;
  unsigned char * p.80;
  unsigned char D.11197;
  long int D.11204;
  void * D.11205;
  long int D.11206;
  void * D.11207;
  unsigned char * p.81;
  long int D.11225;
  char * D.11226;
  long int D.11229;
  long int D.11232;
  long int D.11233;
  void * D.11234;
  struct ClassDesc * D.11235;
  char * D.11236;
  long unsigned int thread_filter.82;
  long unsigned int D.11246;
  long int D.11248;
  long int D.11249;
  long unsigned int D.11250;
  long unsigned int D.11251;
  int num_bt.83;
  struct TraceDesc * D.11255;
  long unsigned int find_size.84;
  const char * find_name.85;
  char * D.11266;
  char * D.11267;
  long unsigned int D.11268;
  char * D.11273;
  long unsigned int D.11282;
  void * method_base.86;
  long int D.11286;
  void * D.11287;
  struct TraceDesc * D.11294;
  const char * iftmp.87;
  const char * iftmp.88;
  char * D.11306;
  long int D.11309;
  struct HeapShot * D.11312;
  int collect_traces.89;
  long int D.11316;
  long int D.11317;
  long unsigned int D.11318;
  long unsigned int iftmp.90;
  int D.11323;
  long unsigned int D.11326;
  long unsigned int D.11330;
  long unsigned int ref_offset.91;
  long unsigned int D.11332;
  long int D.11333;
  long int D.11334;
  long unsigned int D.11335;
  void * D.11342;
  char * D.11343;
  long unsigned int D.11347;
  long int D.11350;
  long int D.11351;
  void * D.11352;
  const char * D.11353;
  long unsigned int D.11356;
  long unsigned int D.11357;
  long unsigned int D.11368;
  uintptr_t * D.11370;
  uintptr_t * D.11371;
  int * D.11372;
  struct HeapShot * D.11378;
  unsigned char D.11379;
  int D.11380;
  int iftmp.92;
  long int D.11388;
  long int D.11389;
  long unsigned int D.11390;
  long unsigned int monitor_contention.93;
  long unsigned int monitor_contention.94;
  long unsigned int D.11395;
  long unsigned int D.11396;
  int num_bt.95;
  struct TraceDesc * D.11404;
  long unsigned int monitor_failed.96;
  long unsigned int monitor_failed.97;
  struct MonitorDesc * D.11415;
  long unsigned int D.11418;
  long unsigned int D.11421;
  long unsigned int D.11424;
  long unsigned int D.11425;
  long unsigned int monitor_acquired.98;
  long unsigned int monitor_acquired.99;
  long unsigned int D.11439;
  const char * D.11442;
  void * D.11443;
  int has_bt.100;
  int iftmp.101;
  long unsigned int D.11454;
  long unsigned int D.11455;
  long unsigned int D.11458;
  long unsigned int D.11459;
  const char * D.11462;
  struct MethodDesc * D.11463;
  char * D.11464;
  long unsigned int throw_count.102;
  long unsigned int throw_count.103;
  int has_bt.104;
  long int D.11484;
  long int D.11485;
  void * D.11486;
  long unsigned int D.11489;
  long unsigned int D.11490;
  long int D.11491;
  long int D.11492;
  void * ip.105;
  long int D.11499;
  long int D.11500;
  void * addr.106;
  long int D.11507;
  void * addr.107;
  long int p.108;
  long int p.109;
  long int D.11514;
  unsigned char * p;
  unsigned char * end;
  intptr_t thread_id;
  intptr_t ptr_base;
  intptr_t obj_base;
  intptr_t method_base;
  uint64_t time_base;
  uint64_t file_offset;
  int len;
  int i;
  struct ThreadContext * thread;

  try
    {
      D.11036 = ctx->gzfile;
      if (D.11036 != 0B) goto <D.11037>; else goto <D.11038>;
      <D.11037>:
      D.11036 = ctx->gzfile;
      D.11039 = gztell (D.11036);
      file_offset = (uint64_t) D.11039;
      goto <D.11040>;
      <D.11038>:
      D.11041 = ctx->file;
      D.11042 = ftell (D.11041);
      file_offset = (uint64_t) D.11042;
      <D.11040>:
      D.11043 = load_data (ctx, 48);
      if (D.11043 == 0) goto <D.11044>; else goto <D.11045>;
      <D.11044>:
      D.11046 = 0;
      return D.11046;
      <D.11045>:
      p.62 = ctx->buf;
      p = p.62;
      p.63 = p;
      D.11049 = read_int32 (p.63);
      if (D.11049 != 1297107969) goto <D.11050>; else goto <D.11051>;
      <D.11050>:
      outfile.64 = outfile;
      p.63 = p;
      D.11053 = read_int32 (p.63);
      fprintf (outfile.64, "Incorrect buffer id: 0x%x\n", D.11053);
      i = 0;
      goto <D.9596>;
      <D.9595>:
      outfile.64 = outfile;
      p.63 = p;
      D.11054 = (sizetype) i;
      D.11055 = p.63 + D.11054;
      D.11056 = *D.11055;
      D.11057 = (int) D.11056;
      i.66 = (unsigned int) i;
      D.11060 = i.66 & 7;
      if (D.11060 != 0) goto <D.11061>; else goto <D.11062>;
      <D.11061>:
      iftmp.65 = " ";
      goto <D.11063>;
      <D.11062>:
      iftmp.65 = "\n";
      <D.11063>:
      fprintf (outfile.64, "0x%x%s", D.11057, iftmp.65);
      i = i + 1;
      <D.9596>:
      if (i <= 47) goto <D.9595>; else goto <D.9597>;
      <D.9597>:
      D.11046 = 0;
      return D.11046;
      <D.11051>:
      p.63 = p;
      D.11064 = p.63 + 4;
      len = read_int32 (D.11064);
      p.63 = p;
      D.11065 = p.63 + 8;
      D.11066 = read_int64 (D.11065);
      time_base = (uint64_t) D.11066;
      p.63 = p;
      D.11067 = p.63 + 16;
      ptr_base = read_int64 (D.11067);
      p.63 = p;
      D.11068 = p.63 + 24;
      obj_base = read_int64 (D.11068);
      p.63 = p;
      D.11069 = p.63 + 32;
      thread_id = read_int64 (D.11069);
      p.63 = p;
      D.11070 = p.63 + 40;
      method_base = read_int64 (D.11070);
      debug.67 = debug;
      if (debug.67 != 0) goto <D.11072>; else goto <D.11073>;
      <D.11072>:
      outfile.64 = outfile;
      fprintf (outfile.64, "buf: thread:%x, len: %d, time: %llu, file offset: %llu\n", thread_id, len, time_base, file_offset);
      <D.11073>:
      thread = load_thread (ctx, thread_id);
      D.11074 = load_data (ctx, len);
      if (D.11074 == 0) goto <D.11075>; else goto <D.11076>;
      <D.11075>:
      D.11046 = 0;
      return D.11046;
      <D.11076>:
      startup_time.68 = startup_time;
      if (startup_time.68 == 0) goto <D.11078>; else goto <D.11079>;
      <D.11078>:
      startup_time = time_base;
      time_from.69 = time_from;
      if (time_from.69 != 0) goto <D.11081>; else goto <D.11082>;
      <D.11081>:
      time_from.69 = time_from;
      startup_time.68 = startup_time;
      time_from.70 = time_from.69 + startup_time.68;
      time_from = time_from.70;
      time_to.71 = time_to;
      startup_time.68 = startup_time;
      time_to.72 = time_to.71 + startup_time.68;
      time_to = time_to.72;
      <D.11082>:
      D.11086 = thread->name;
      if (D.11086 == 0B) goto <D.11087>; else goto <D.11088>;
      <D.11087>:
      D.11089 = pstrdup ("Main");
      thread->name = D.11089;
      <D.11088>:
      <D.11079>:
      i = 0;
      goto <D.9599>;
      <D.9598>:
      D.11090 = thread->stack;
      D.11091 = (long unsigned int) i;
      D.11092 = D.11091 * 8;
      D.11093 = D.11090 + D.11092;
      D.11094 = *D.11093;
      D.11095 = D.11094->recurse_count;
      D.11096 = D.11095 + 1;
      D.11094->recurse_count = D.11096;
      i = i + 1;
      <D.9599>:
      D.11097 = thread->stack_id;
      if (D.11097 > i) goto <D.9598>; else goto <D.9600>;
      <D.9600>:
      p.62 = ctx->buf;
      p = p.62;
      p.63 = p;
      D.11098 = (sizetype) len;
      end = p.63 + D.11098;
      goto <D.9738>;
      <D.9737>:
      p.63 = p;
      D.11099 = *p.63;
      D.11100 = (int) D.11099;
      D.11101 = D.11100 & 15;
      switch (D.11101) <default: <D.9736>, case 0: <D.9639>, case 1: <D.9601>, case 2: <D.9620>, case 3: <D.9650>, case 4: <D.9701>, case 5: <D.9689>, case 6: <D.9660>, case 7: <D.9712>>
      <D.9601>:
      {
        int subtype;
        uint64_t tdiff;

        p.63 = p;
        D.11099 = *p.63;
        D.11100 = (int) D.11099;
        subtype = D.11100 & 240;
        p.63 = p;
        D.11102 = p.63 + 1;
        tdiff = decode_uleb128 (D.11102, &p);
        time_base = time_base + tdiff;
        if (subtype == 32) goto <D.11103>; else goto <D.11104>;
        <D.11103>:
        {
          uint64_t new_size;

          p.63 = p;
          new_size = decode_uleb128 (p.63, &p);
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11105>; else goto <D.11106>;
          <D.11105>:
          outfile.64 = outfile;
          fprintf (outfile.64, "gc heap resized to %llu\n", new_size);
          <D.11106>:
          gc_resizes.73 = gc_resizes;
          gc_resizes.74 = gc_resizes.73 + 1;
          gc_resizes = gc_resizes.74;
          max_heap_size.75 = max_heap_size;
          if (new_size > max_heap_size.75) goto <D.11110>; else goto <D.11111>;
          <D.11110>:
          max_heap_size = new_size;
          <D.11111>:
        }
        goto <D.11112>;
        <D.11104>:
        if (subtype == 16) goto <D.11113>; else goto <D.11114>;
        <D.11113>:
        {
          uint64_t ev;
          int gen;

          p.63 = p;
          ev = decode_uleb128 (p.63, &p);
          p.63 = p;
          D.11115 = decode_uleb128 (p.63, &p);
          gen = (int) D.11115;
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11116>; else goto <D.11117>;
          <D.11116>:
          outfile.64 = outfile;
          D.11118 = (int) ev;
          D.11119 = gc_event_name (D.11118);
          D.11120 = thread->thread_id;
          fprintf (outfile.64, "gc event for gen%d: %s at %llu (thread: 0x%x)\n", gen, D.11119, time_base, D.11120);
          <D.11117>:
          if (gen > 2) goto <D.11121>; else goto <D.11122>;
          <D.11121>:
          outfile.64 = outfile;
          fprintf (outfile.64, "incorrect gc gen: %d\n", gen);
          goto <D.9607>;
          <D.11122>:
          if (ev == 0) goto <D.11123>; else goto <D.11124>;
          <D.11123>:
          thread->gc_start_times[gen] = time_base;
          D.11125 = gc_info[gen].count;
          D.11126 = D.11125 + 1;
          gc_info[gen].count = D.11126;
          goto <D.11127>;
          <D.11124>:
          if (ev == 5) goto <D.11128>; else goto <D.11129>;
          <D.11128>:
          D.11130 = thread->gc_start_times[gen];
          tdiff = time_base - D.11130;
          D.11131 = gc_info[gen].total_time;
          D.11132 = D.11131 + tdiff;
          gc_info[gen].total_time = D.11132;
          D.11133 = gc_info[gen].max_time;
          if (D.11133 < tdiff) goto <D.11134>; else goto <D.11135>;
          <D.11134>:
          gc_info[gen].max_time = tdiff;
          <D.11135>:
          <D.11129>:
          <D.11127>:
        }
        goto <D.11136>;
        <D.11114>:
        if (subtype == 48) goto <D.11137>; else goto <D.11138>;
        <D.11137>:
        {
          int j;
          int num;

          p.63 = p;
          D.11139 = decode_uleb128 (p.63, &p);
          num = (int) D.11139;
          D.11140 = num / 2;
          D.11141 = (long unsigned int) D.11140;
          gc_object_moves.76 = gc_object_moves;
          gc_object_moves.77 = D.11141 + gc_object_moves.76;
          gc_object_moves = gc_object_moves.77;
          j = 0;
          goto <D.9613>;
          <D.9612>:
          {
            intptr_t obj1diff;
            intptr_t obj2diff;

            p.63 = p;
            obj1diff = decode_sleb128 (p.63, &p);
            p.63 = p;
            obj2diff = decode_sleb128 (p.63, &p);
            num_tracked_objects.78 = num_tracked_objects;
            if (num_tracked_objects.78 != 0) goto <D.11145>; else goto <D.11146>;
            <D.11145>:
            D.11147 = obj_base + obj1diff;
            D.11148 = D.11147 << 3;
            D.11149 = (long unsigned int) D.11148;
            D.11150 = obj_base + obj2diff;
            D.11151 = D.11150 << 3;
            D.11152 = (long unsigned int) D.11151;
            track_move (D.11149, D.11152);
            <D.11146>:
            debug.67 = debug;
            if (debug.67 != 0) goto <D.11153>; else goto <D.11154>;
            <D.11153>:
            outfile.64 = outfile;
            D.11147 = obj_base + obj1diff;
            D.11148 = D.11147 << 3;
            D.11155 = (void *) D.11148;
            D.11150 = obj_base + obj2diff;
            D.11151 = D.11150 << 3;
            D.11156 = (void *) D.11151;
            fprintf (outfile.64, "moved obj %p to %p\n", D.11155, D.11156);
            <D.11154>:
          }
          j = j + 2;
          <D.9613>:
          if (j < num) goto <D.9612>; else goto <D.9614>;
          <D.9614>:
        }
        goto <D.11157>;
        <D.11138>:
        if (subtype == 64) goto <D.11158>; else goto <D.11159>;
        <D.11158>:
        {
          int htype;
          uint32_t handle;
          intptr_t objdiff;

          p.63 = p;
          D.11160 = decode_uleb128 (p.63, &p);
          htype = (int) D.11160;
          p.63 = p;
          D.11161 = decode_uleb128 (p.63, &p);
          handle = (uint32_t) D.11161;
          p.63 = p;
          objdiff = decode_sleb128 (p.63, &p);
          if (htype > 3) goto <D.11162>; else goto <D.11163>;
          <D.11162>:
          D.11046 = 0;
          return D.11046;
          <D.11163>:
          D.11164 = handle_info[htype].created;
          D.11165 = D.11164 + 1;
          handle_info[htype].created = D.11165;
          D.11166 = handle_info[htype].live;
          D.11167 = D.11166 + 1;
          handle_info[htype].live = D.11167;
          D.11168 = &handle_info[htype].traces;
          add_trace_thread (thread, D.11168, 1);
          D.11166 = handle_info[htype].live;
          D.11169 = handle_info[htype].max_live;
          if (D.11166 > D.11169) goto <D.11170>; else goto <D.11171>;
          <D.11170>:
          D.11166 = handle_info[htype].live;
          handle_info[htype].max_live = D.11166;
          <D.11171>:
          num_tracked_objects.78 = num_tracked_objects;
          if (num_tracked_objects.78 != 0) goto <D.11172>; else goto <D.11173>;
          <D.11172>:
          D.11174 = obj_base + objdiff;
          D.11175 = D.11174 << 3;
          D.11176 = (long unsigned int) D.11175;
          track_handle (D.11176, htype, handle);
          <D.11173>:
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11177>; else goto <D.11178>;
          <D.11177>:
          outfile.64 = outfile;
          D.11179 = get_handle_name (htype);
          D.11174 = obj_base + objdiff;
          D.11175 = D.11174 << 3;
          D.11180 = (void *) D.11175;
          fprintf (outfile.64, "handle (%s) %u created for object %p\n", D.11179, handle, D.11180);
          <D.11178>:
        }
        goto <D.11181>;
        <D.11159>:
        if (subtype == 80) goto <D.11182>; else goto <D.11183>;
        <D.11182>:
        {
          int htype;
          uint32_t handle;

          p.63 = p;
          D.11184 = decode_uleb128 (p.63, &p);
          htype = (int) D.11184;
          p.63 = p;
          D.11185 = decode_uleb128 (p.63, &p);
          handle = (uint32_t) D.11185;
          if (htype > 3) goto <D.11186>; else goto <D.11187>;
          <D.11186>:
          D.11046 = 0;
          return D.11046;
          <D.11187>:
          D.11188 = handle_info[htype].destroyed;
          D.11189 = D.11188 + 1;
          handle_info[htype].destroyed = D.11189;
          D.11190 = handle_info[htype].live;
          D.11191 = D.11190 + 18446744073709551615;
          handle_info[htype].live = D.11191;
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11192>; else goto <D.11193>;
          <D.11192>:
          outfile.64 = outfile;
          D.11194 = get_handle_name (htype);
          fprintf (outfile.64, "handle (%s) %u destroyed\n", D.11194, handle);
          <D.11193>:
        }
        <D.11183>:
        <D.11181>:
        <D.11157>:
        <D.11136>:
        <D.11112>:
        goto <D.9607>;
      }
      <D.9620>:
      {
        int error;
        uint64_t tdiff;
        int mtype;
        intptr_t ptrdiff;

        p.63 = p;
        D.11099 = *p.63;
        D.11100 = (int) D.11099;
        error = D.11100 & 128;
        p.63 = p;
        D.11102 = p.63 + 1;
        tdiff = decode_uleb128 (D.11102, &p);
        p.63 = p;
        p.79 = p.63;
        p.80 = p.79 + 1;
        p = p.80;
        D.11197 = *p.79;
        mtype = (int) D.11197;
        p.63 = p;
        ptrdiff = decode_sleb128 (p.63, &p);
        time_base = time_base + tdiff;
        if (mtype == 1) goto <D.11198>; else goto <D.11199>;
        <D.11198>:
        {
          intptr_t imptrdiff;
          uint64_t flags;

          p.63 = p;
          imptrdiff = decode_sleb128 (p.63, &p);
          p.63 = p;
          flags = decode_uleb128 (p.63, &p);
          if (flags != 0) goto <D.11200>; else goto <D.11201>;
          <D.11200>:
          outfile.64 = outfile;
          fprintf (outfile.64, "non-zero flags in class\n");
          D.11046 = 0;
          return D.11046;
          <D.11201>:
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11202>; else goto <D.11203>;
          <D.11202>:
          outfile.64 = outfile;
          D.11204 = ptr_base + ptrdiff;
          D.11205 = (void *) D.11204;
          p.63 = p;
          D.11206 = ptr_base + imptrdiff;
          D.11207 = (void *) D.11206;
          fprintf (outfile.64, "loaded class %p (%s in %p) at %llu\n", D.11205, p.63, D.11207, time_base);
          <D.11203>:
          if (error == 0) goto <D.11208>; else goto <D.11209>;
          <D.11208>:
          D.11204 = ptr_base + ptrdiff;
          p.63 = p;
          add_class (D.11204, p.63);
          <D.11209>:
          goto <D.9628>;
          <D.9627>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
          <D.9628>:
          p.63 = p;
          D.11099 = *p.63;
          if (D.11099 != 0) goto <D.9627>; else goto <D.9629>;
          <D.9629>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
        }
        goto <D.11211>;
        <D.11199>:
        if (mtype == 2) goto <D.11212>; else goto <D.11213>;
        <D.11212>:
        {
          uint64_t flags;

          p.63 = p;
          flags = decode_uleb128 (p.63, &p);
          if (flags != 0) goto <D.11214>; else goto <D.11215>;
          <D.11214>:
          outfile.64 = outfile;
          fprintf (outfile.64, "non-zero flags in image\n");
          D.11046 = 0;
          return D.11046;
          <D.11215>:
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11216>; else goto <D.11217>;
          <D.11216>:
          outfile.64 = outfile;
          D.11204 = ptr_base + ptrdiff;
          D.11205 = (void *) D.11204;
          p.63 = p;
          fprintf (outfile.64, "loaded image %p (%s) at %llu\n", D.11205, p.63, time_base);
          <D.11217>:
          if (error == 0) goto <D.11218>; else goto <D.11219>;
          <D.11218>:
          D.11204 = ptr_base + ptrdiff;
          p.63 = p;
          add_image (D.11204, p.63);
          <D.11219>:
          goto <D.9632>;
          <D.9631>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
          <D.9632>:
          p.63 = p;
          D.11099 = *p.63;
          if (D.11099 != 0) goto <D.9631>; else goto <D.9633>;
          <D.9633>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
        }
        goto <D.11220>;
        <D.11213>:
        if (mtype == 5) goto <D.11221>; else goto <D.11222>;
        <D.11221>:
        {
          struct ThreadContext * nt;
          uint64_t flags;

          p.63 = p;
          flags = decode_uleb128 (p.63, &p);
          if (flags != 0) goto <D.11223>; else goto <D.11224>;
          <D.11223>:
          outfile.64 = outfile;
          fprintf (outfile.64, "non-zero flags in thread\n");
          D.11046 = 0;
          return D.11046;
          <D.11224>:
          D.11225 = ptr_base * ptrdiff;
          nt = get_thread (ctx, D.11225);
          p.63 = p;
          D.11226 = pstrdup (p.63);
          nt->name = D.11226;
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11227>; else goto <D.11228>;
          <D.11227>:
          outfile.64 = outfile;
          D.11204 = ptr_base + ptrdiff;
          D.11205 = (void *) D.11204;
          p.63 = p;
          fprintf (outfile.64, "thread %p named: %s\n", D.11205, p.63);
          <D.11228>:
          goto <D.9637>;
          <D.9636>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
          <D.9637>:
          p.63 = p;
          D.11099 = *p.63;
          if (D.11099 != 0) goto <D.9636>; else goto <D.9638>;
          <D.9638>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
        }
        <D.11222>:
        <D.11220>:
        <D.11211>:
        goto <D.9607>;
      }
      <D.9639>:
      {
        int has_bt;
        uint64_t tdiff;
        intptr_t ptrdiff;
        intptr_t objdiff;
        uint64_t len;
        int num_bt;
        struct MethodDesc * sframes[8];
        struct MethodDesc * * frames;
        struct ClassDesc * cd;

        try
          {
            p.63 = p;
            D.11099 = *p.63;
            D.11100 = (int) D.11099;
            has_bt = D.11100 & 16;
            p.63 = p;
            D.11102 = p.63 + 1;
            tdiff = decode_uleb128 (D.11102, &p);
            p.63 = p;
            ptrdiff = decode_sleb128 (p.63, &p);
            p.63 = p;
            objdiff = decode_sleb128 (p.63, &p);
            num_bt = 0;
            frames = &sframes;
            D.11229 = ptr_base + ptrdiff;
            cd = lookup_class (D.11229);
            p.63 = p;
            len = decode_uleb128 (p.63, &p);
            time_base = time_base + tdiff;
            debug.67 = debug;
            if (debug.67 != 0) goto <D.11230>; else goto <D.11231>;
            <D.11230>:
            outfile.64 = outfile;
            D.11232 = obj_base + objdiff;
            D.11233 = D.11232 << 3;
            D.11234 = (void *) D.11233;
            D.11229 = ptr_base + ptrdiff;
            D.11235 = lookup_class (D.11229);
            D.11236 = D.11235->name;
            fprintf (outfile.64, "alloced object %p, size %llu (%s) at %llu\n", D.11234, len, D.11236, time_base);
            <D.11231>:
            if (has_bt != 0) goto <D.11237>; else goto <D.11238>;
            <D.11237>:
            num_bt = 8;
            p.63 = p;
            frames = decode_bt (&sframes, &num_bt, p.63, &p, ptr_base);
            if (frames == 0B) goto <D.11239>; else goto <D.11240>;
            <D.11239>:
            outfile.64 = outfile;
            fprintf (outfile.64, "Cannot load backtrace\n");
            D.11046 = 0;
            return D.11046;
            <D.11240>:
            <D.11238>:
            thread_filter.82 = thread_filter;
            if (thread_filter.82 != 0) goto <D.11245>; else goto <D.11241>;
            <D.11245>:
            D.11120 = thread->thread_id;
            D.11246 = (long unsigned int) D.11120;
            thread_filter.82 = thread_filter;
            if (D.11246 == thread_filter.82) goto <D.11242>; else goto <D.11241>;
            <D.11241>:
            time_from.69 = time_from;
            if (time_base >= time_from.69) goto <D.11247>; else goto <D.11243>;
            <D.11247>:
            time_to.71 = time_to;
            if (time_base < time_to.71) goto <D.11242>; else goto <D.11243>;
            <D.11242>:
            {
              struct BackTrace * bt;

              D.11248 = cd->allocs;
              D.11249 = D.11248 + 1;
              cd->allocs = D.11249;
              D.11250 = cd->alloc_size;
              D.11251 = D.11250 + len;
              cd->alloc_size = D.11251;
              if (has_bt != 0) goto <D.11252>; else goto <D.11253>;
              <D.11252>:
              num_bt.83 = num_bt;
              D.11255 = &cd->traces;
              bt = add_trace_methods (frames, num_bt.83, D.11255, len);
              goto <D.11256>;
              <D.11253>:
              D.11255 = &cd->traces;
              bt = add_trace_thread (thread, D.11255, len);
              <D.11256>:
              find_size.84 = find_size;
              if (find_size.84 != 0) goto <D.11260>; else goto <D.11257>;
              <D.11260>:
              find_size.84 = find_size;
              if (len >= find_size.84) goto <D.11261>; else goto <D.11257>;
              <D.11261>:
              find_name.85 = find_name;
              if (find_name.85 == 0B) goto <D.11262>; else goto <D.11265>;
              <D.11265>:
              D.11266 = cd->name;
              find_name.85 = find_name;
              D.11267 = strstr (D.11266, find_name.85);
              if (D.11267 != 0B) goto <D.11262>; else goto <D.11263>;
              <D.11262>:
              D.11232 = obj_base + objdiff;
              D.11233 = D.11232 << 3;
              D.11268 = (long unsigned int) D.11233;
              found_object (D.11268);
              <D.11263>:
              goto <D.11258>;
              <D.11257>:
              find_size.84 = find_size;
              if (find_size.84 == 0) goto <D.11269>; else goto <D.11270>;
              <D.11269>:
              find_name.85 = find_name;
              if (find_name.85 != 0B) goto <D.11271>; else goto <D.11272>;
              <D.11271>:
              D.11266 = cd->name;
              find_name.85 = find_name;
              D.11273 = strstr (D.11266, find_name.85);
              if (D.11273 != 0B) goto <D.11274>; else goto <D.11275>;
              <D.11274>:
              D.11232 = obj_base + objdiff;
              D.11233 = D.11232 << 3;
              D.11268 = (long unsigned int) D.11233;
              found_object (D.11268);
              <D.11275>:
              <D.11272>:
              <D.11270>:
              <D.11258>:
              num_tracked_objects.78 = num_tracked_objects;
              if (num_tracked_objects.78 != 0) goto <D.11276>; else goto <D.11277>;
              <D.11276>:
              D.11232 = obj_base + objdiff;
              D.11233 = D.11232 << 3;
              D.11268 = (long unsigned int) D.11233;
              tracked_creation (D.11268, cd, len, bt, time_base);
              <D.11277>:
            }
            <D.11243>:
            if (&sframes != frames) goto <D.11278>; else goto <D.11279>;
            <D.11278>:
            free (frames);
            <D.11279>:
            goto <D.9607>;
          }
        finally
          {
            num_bt = {CLOBBER};
            sframes = {CLOBBER};
          }
      }
      <D.9650>:
      {
        int subtype;
        uint64_t tdiff;
        int64_t ptrdiff;

        p.63 = p;
        D.11099 = *p.63;
        D.11100 = (int) D.11099;
        subtype = D.11100 & 240;
        p.63 = p;
        D.11102 = p.63 + 1;
        tdiff = decode_uleb128 (D.11102, &p);
        p.63 = p;
        ptrdiff = decode_sleb128 (p.63, &p);
        time_base = time_base + tdiff;
        method_base = method_base + ptrdiff;
        if (subtype == 64) goto <D.11280>; else goto <D.11281>;
        <D.11280>:
        {
          intptr_t codediff;
          int codelen;

          p.63 = p;
          codediff = decode_sleb128 (p.63, &p);
          p.63 = p;
          D.11282 = decode_uleb128 (p.63, &p);
          codelen = (int) D.11282;
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11283>; else goto <D.11284>;
          <D.11283>:
          outfile.64 = outfile;
          method_base.86 = (void *) method_base;
          p.63 = p;
          D.11286 = ptr_base + codediff;
          D.11287 = (void *) D.11286;
          fprintf (outfile.64, "jitted method %p (%s), size: %d, code: %p\n", method_base.86, p.63, codelen, D.11287);
          <D.11284>:
          p.63 = p;
          D.11286 = ptr_base + codediff;
          add_method (method_base, p.63, D.11286, codelen);
          goto <D.9657>;
          <D.9656>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
          <D.9657>:
          p.63 = p;
          D.11099 = *p.63;
          if (D.11099 != 0) goto <D.9656>; else goto <D.9658>;
          <D.9658>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
        }
        goto <D.11288>;
        <D.11281>:
        {
          struct MethodDesc * method;

          thread_filter.82 = thread_filter;
          if (thread_filter.82 != 0) goto <D.11289>; else goto <D.11290>;
          <D.11289>:
          D.11120 = thread->thread_id;
          D.11246 = (long unsigned int) D.11120;
          thread_filter.82 = thread_filter;
          if (D.11246 != thread_filter.82) goto <D.9607>; else goto <D.11291>;
          <D.11291>:
          <D.11290>:
          method = lookup_method (method_base);
          if (subtype == 32) goto <D.11292>; else goto <D.11293>;
          <D.11292>:
          D.11294 = &method->traces;
          add_trace_thread (thread, D.11294, 1);
          push_method (thread, method, time_base);
          goto <D.11295>;
          <D.11293>:
          pop_method (thread, method, time_base);
          <D.11295>:
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11296>; else goto <D.11297>;
          <D.11296>:
          outfile.64 = outfile;
          if (subtype != 32) goto <D.11299>; else goto <D.11300>;
          <D.11299>:
          if (subtype == 48) goto <D.11302>; else goto <D.11303>;
          <D.11302>:
          iftmp.88 = "exleave";
          goto <D.11304>;
          <D.11303>:
          iftmp.88 = "leave";
          <D.11304>:
          iftmp.87 = iftmp.88;
          goto <D.11305>;
          <D.11300>:
          iftmp.87 = "enter";
          <D.11305>:
          D.11306 = method->name;
          fprintf (outfile.64, "%s method %s\n", iftmp.87, D.11306);
          <D.11297>:
        }
        <D.11288>:
        goto <D.9607>;
      }
      <D.9660>:
      {
        int subtype;

        p.63 = p;
        D.11099 = *p.63;
        D.11100 = (int) D.11099;
        subtype = D.11100 & 240;
        if (subtype == 32) goto <D.11307>; else goto <D.11308>;
        <D.11307>:
        {
          struct HeapObjectDesc * ho;
          int i;
          intptr_t objdiff;
          intptr_t ptrdiff;
          uint64_t size;
          uintptr_t num;
          uintptr_t ref_offset;
          uintptr_t last_obj_offset;
          struct ClassDesc * cd;

          try
            {
              p.63 = p;
              D.11102 = p.63 + 1;
              objdiff = decode_sleb128 (D.11102, &p);
              p.63 = p;
              ptrdiff = decode_sleb128 (p.63, &p);
              p.63 = p;
              size = decode_uleb128 (p.63, &p);
              p.63 = p;
              num = decode_uleb128 (p.63, &p);
              last_obj_offset = 0;
              D.11309 = ptr_base + ptrdiff;
              cd = lookup_class (D.11309);
              if (size != 0) goto <D.11310>; else goto <D.11311>;
              <D.11310>:
              {
                struct HeapClassDesc * hcd;

                D.11312 = thread->current_heap_shot;
                hcd = add_heap_shot_class (D.11312, cd, size);
                collect_traces.89 = collect_traces;
                if (collect_traces.89 != 0) goto <D.11314>; else goto <D.11315>;
                <D.11314>:
                D.11316 = obj_base + objdiff;
                D.11317 = D.11316 << 3;
                D.11318 = (long unsigned int) D.11317;
                ho = alloc_heap_obj (D.11318, hcd, num);
                D.11312 = thread->current_heap_shot;
                add_heap_shot_obj (D.11312, ho);
                ref_offset = 0;
                <D.11315>:
              }
              goto <D.11319>;
              <D.11311>:
              collect_traces.89 = collect_traces;
              if (collect_traces.89 != 0) goto <D.11320>; else goto <D.11321>;
              <D.11320>:
              D.11312 = thread->current_heap_shot;
              D.11316 = obj_base + objdiff;
              D.11317 = D.11316 << 3;
              D.11318 = (long unsigned int) D.11317;
              ho = heap_shot_obj_add_refs (D.11312, D.11318, num, &ref_offset);
              <D.11321>:
              <D.11319>:
              i = 0;
              goto <D.9675>;
              <D.9674>:
              {
                uintptr_t offset;
                intptr_t obj1diff;

                D.11323 = ctx->data_version;
                if (D.11323 > 1) goto <D.11324>; else goto <D.11325>;
                <D.11324>:
                p.63 = p;
                D.11326 = decode_uleb128 (p.63, &p);
                iftmp.90 = D.11326 + last_obj_offset;
                goto <D.11327>;
                <D.11325>:
                iftmp.90 = 18446744073709551615;
                <D.11327>:
                offset = iftmp.90;
                p.63 = p;
                obj1diff = decode_sleb128 (p.63, &p);
                last_obj_offset = offset;
                collect_traces.89 = collect_traces;
                if (collect_traces.89 != 0) goto <D.11328>; else goto <D.11329>;
                <D.11328>:
                D.11330 = (long unsigned int) i;
                ref_offset.91 = ref_offset;
                D.11332 = D.11330 + ref_offset.91;
                D.11333 = obj_base + obj1diff;
                D.11334 = D.11333 << 3;
                D.11335 = (long unsigned int) D.11334;
                ho->refs[D.11332] = D.11335;
                <D.11329>:
                num_tracked_objects.78 = num_tracked_objects;
                if (num_tracked_objects.78 != 0) goto <D.11336>; else goto <D.11337>;
                <D.11336>:
                D.11333 = obj_base + obj1diff;
                D.11334 = D.11333 << 3;
                D.11335 = (long unsigned int) D.11334;
                D.11316 = obj_base + objdiff;
                D.11317 = D.11316 << 3;
                D.11318 = (long unsigned int) D.11317;
                track_obj_reference (D.11335, D.11318, cd);
                <D.11337>:
              }
              i = i + 1;
              <D.9675>:
              D.11330 = (long unsigned int) i;
              if (D.11330 < num) goto <D.9674>; else goto <D.9676>;
              <D.9676>:
              debug.67 = debug;
              if (debug.67 != 0) goto <D.11338>; else goto <D.11339>;
              <D.11338>:
              if (size != 0) goto <D.11340>; else goto <D.11341>;
              <D.11340>:
              outfile.64 = outfile;
              D.11316 = obj_base + objdiff;
              D.11317 = D.11316 << 3;
              D.11342 = (void *) D.11317;
              D.11343 = cd->name;
              fprintf (outfile.64, "traced object %p, size %llu (%s), refs: %d\n", D.11342, size, D.11343, num);
              <D.11341>:
              <D.11339>:
            }
          finally
            {
              ref_offset = {CLOBBER};
            }
        }
        goto <D.11344>;
        <D.11308>:
        if (subtype == 48) goto <D.11345>; else goto <D.11346>;
        <D.11345>:
        {
          uintptr_t num;
          uintptr_t gc_num;
          int i;

          p.63 = p;
          D.11102 = p.63 + 1;
          num = decode_uleb128 (D.11102, &p);
          p.63 = p;
          gc_num = decode_uleb128 (p.63, &p);
          i = 0;
          goto <D.9684>;
          <D.9683>:
          {
            intptr_t objdiff;
            int root_type;
            uintptr_t extra_info;

            p.63 = p;
            objdiff = decode_sleb128 (p.63, &p);
            p.63 = p;
            D.11347 = decode_uleb128 (p.63, &p);
            root_type = (int) D.11347;
            p.63 = p;
            extra_info = decode_uleb128 (p.63, &p);
            debug.67 = debug;
            if (debug.67 != 0) goto <D.11348>; else goto <D.11349>;
            <D.11348>:
            outfile.64 = outfile;
            D.11350 = obj_base + objdiff;
            D.11351 = D.11350 << 3;
            D.11352 = (void *) D.11351;
            D.11353 = get_root_name (root_type);
            fprintf (outfile.64, "object %p is a %s root\n", D.11352, D.11353);
            <D.11349>:
            collect_traces.89 = collect_traces;
            if (collect_traces.89 != 0) goto <D.11354>; else goto <D.11355>;
            <D.11354>:
            D.11350 = obj_base + objdiff;
            D.11351 = D.11350 << 3;
            D.11356 = (long unsigned int) D.11351;
            thread_add_root (thread, D.11356, root_type, extra_info);
            <D.11355>:
          }
          i = i + 1;
          <D.9684>:
          D.11357 = (long unsigned int) i;
          if (D.11357 < num) goto <D.9683>; else goto <D.9685>;
          <D.9685>:
        }
        goto <D.11358>;
        <D.11346>:
        if (subtype == 16) goto <D.11359>; else goto <D.11360>;
        <D.11359>:
        {
          uint64_t tdiff;

          p.63 = p;
          D.11102 = p.63 + 1;
          tdiff = decode_uleb128 (D.11102, &p);
          time_base = time_base + tdiff;
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11361>; else goto <D.11362>;
          <D.11361>:
          outfile.64 = outfile;
          fprintf (outfile.64, "heap shot end\n");
          <D.11362>:
          collect_traces.89 = collect_traces;
          if (collect_traces.89 != 0) goto <D.11363>; else goto <D.11364>;
          <D.11363>:
          {
            struct HeapShot * hs;

            hs = thread->current_heap_shot;
            if (hs != 0B) goto <D.11367>; else goto <D.11365>;
            <D.11367>:
            D.11368 = thread->num_roots;
            if (D.11368 != 0) goto <D.11369>; else goto <D.11365>;
            <D.11369>:
            D.11368 = thread->num_roots;
            hs->num_roots = D.11368;
            D.11370 = thread->roots;
            hs->roots = D.11370;
            D.11371 = thread->roots_extra;
            hs->roots_extra = D.11371;
            D.11372 = thread->roots_types;
            hs->roots_types = D.11372;
            goto <D.11366>;
            <D.11365>:
            D.11370 = thread->roots;
            free (D.11370);
            D.11371 = thread->roots_extra;
            free (D.11371);
            D.11372 = thread->roots_types;
            free (D.11372);
            <D.11366>:
            thread->num_roots = 0;
            thread->size_roots = 0;
            thread->roots = 0B;
            thread->roots_extra = 0B;
            thread->roots_types = 0B;
            heap_shot_resolve_reverse_refs (hs);
            heap_shot_mark_objects (hs);
            heap_shot_free_objects (hs);
          }
          <D.11364>:
          thread->current_heap_shot = 0B;
        }
        goto <D.11373>;
        <D.11360>:
        if (subtype == 0) goto <D.11374>; else goto <D.11375>;
        <D.11374>:
        {
          uint64_t tdiff;

          p.63 = p;
          D.11102 = p.63 + 1;
          tdiff = decode_uleb128 (D.11102, &p);
          time_base = time_base + tdiff;
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11376>; else goto <D.11377>;
          <D.11376>:
          outfile.64 = outfile;
          fprintf (outfile.64, "heap shot start\n");
          <D.11377>:
          D.11378 = new_heap_shot (time_base);
          thread->current_heap_shot = D.11378;
        }
        <D.11375>:
        <D.11373>:
        <D.11358>:
        <D.11344>:
        goto <D.9607>;
      }
      <D.9689>:
      {
        int event;
        int has_bt;
        uint64_t tdiff;
        intptr_t objdiff;
        struct MethodDesc * sframes[8];
        struct MethodDesc * * frames;
        int record;
        int num_bt;

        try
          {
            p.63 = p;
            D.11099 = *p.63;
            D.11379 = D.11099 >> 4;
            D.11380 = (int) D.11379;
            event = D.11380 & 3;
            p.63 = p;
            D.11099 = *p.63;
            D.11100 = (int) D.11099;
            has_bt = D.11100 & 128;
            p.63 = p;
            D.11102 = p.63 + 1;
            tdiff = decode_uleb128 (D.11102, &p);
            p.63 = p;
            objdiff = decode_sleb128 (p.63, &p);
            frames = &sframes;
            num_bt = 0;
            time_base = time_base + tdiff;
            thread_filter.82 = thread_filter;
            if (thread_filter.82 == 0) goto <D.11382>; else goto <D.11385>;
            <D.11385>:
            D.11120 = thread->thread_id;
            D.11246 = (long unsigned int) D.11120;
            thread_filter.82 = thread_filter;
            if (D.11246 == thread_filter.82) goto <D.11382>; else goto <D.11383>;
            <D.11382>:
            iftmp.92 = 1;
            goto <D.11384>;
            <D.11383>:
            iftmp.92 = 0;
            <D.11384>:
            record = iftmp.92;
            if (event == 1) goto <D.11386>; else goto <D.11387>;
            <D.11386>:
            {
              struct MonitorDesc * mdesc;

              D.11388 = obj_base + objdiff;
              D.11389 = D.11388 << 3;
              D.11390 = (long unsigned int) D.11389;
              mdesc = lookup_monitor (D.11390);
              if (record != 0) goto <D.11391>; else goto <D.11392>;
              <D.11391>:
              monitor_contention.93 = monitor_contention;
              monitor_contention.94 = monitor_contention.93 + 1;
              monitor_contention = monitor_contention.94;
              D.11395 = mdesc->contentions;
              D.11396 = D.11395 + 1;
              mdesc->contentions = D.11396;
              thread->monitor = mdesc;
              thread->contention_start = time_base;
              <D.11392>:
              if (has_bt != 0) goto <D.11397>; else goto <D.11398>;
              <D.11397>:
              num_bt = 8;
              p.63 = p;
              frames = decode_bt (&sframes, &num_bt, p.63, &p, ptr_base);
              if (frames == 0B) goto <D.11399>; else goto <D.11400>;
              <D.11399>:
              outfile.64 = outfile;
              fprintf (outfile.64, "Cannot load backtrace\n");
              D.11046 = 0;
              return D.11046;
              <D.11400>:
              if (record != 0) goto <D.11401>; else goto <D.11402>;
              <D.11401>:
              num_bt.95 = num_bt;
              D.11404 = &mdesc->traces;
              add_trace_methods (frames, num_bt.95, D.11404, 1);
              <D.11402>:
              goto <D.11405>;
              <D.11398>:
              if (record != 0) goto <D.11406>; else goto <D.11407>;
              <D.11406>:
              D.11404 = &mdesc->traces;
              add_trace_thread (thread, D.11404, 1);
              <D.11407>:
              <D.11405>:
            }
            goto <D.11408>;
            <D.11387>:
            if (event == 3) goto <D.11409>; else goto <D.11410>;
            <D.11409>:
            if (record != 0) goto <D.11411>; else goto <D.11412>;
            <D.11411>:
            monitor_failed.96 = monitor_failed;
            monitor_failed.97 = monitor_failed.96 + 1;
            monitor_failed = monitor_failed.97;
            D.11415 = thread->monitor;
            if (D.11415 != 0B) goto <D.11416>; else goto <D.11417>;
            <D.11416>:
            D.11418 = thread->contention_start;
            if (D.11418 != 0) goto <D.11419>; else goto <D.11420>;
            <D.11419>:
            {
              uint64_t wait_time;

              D.11418 = thread->contention_start;
              wait_time = time_base - D.11418;
              D.11415 = thread->monitor;
              D.11421 = D.11415->max_wait_time;
              if (D.11421 < wait_time) goto <D.11422>; else goto <D.11423>;
              <D.11422>:
              D.11415 = thread->monitor;
              D.11415->max_wait_time = wait_time;
              <D.11423>:
              D.11415 = thread->monitor;
              D.11415 = thread->monitor;
              D.11424 = D.11415->wait_time;
              D.11425 = D.11424 + wait_time;
              D.11415->wait_time = D.11425;
              thread->monitor = 0B;
              thread->contention_start = 0;
            }
            <D.11420>:
            <D.11417>:
            <D.11412>:
            goto <D.11426>;
            <D.11410>:
            if (event == 2) goto <D.11427>; else goto <D.11428>;
            <D.11427>:
            if (record != 0) goto <D.11429>; else goto <D.11430>;
            <D.11429>:
            monitor_acquired.98 = monitor_acquired;
            monitor_acquired.99 = monitor_acquired.98 + 1;
            monitor_acquired = monitor_acquired.99;
            D.11415 = thread->monitor;
            if (D.11415 != 0B) goto <D.11433>; else goto <D.11434>;
            <D.11433>:
            D.11418 = thread->contention_start;
            if (D.11418 != 0) goto <D.11435>; else goto <D.11436>;
            <D.11435>:
            {
              uint64_t wait_time;

              D.11418 = thread->contention_start;
              wait_time = time_base - D.11418;
              D.11415 = thread->monitor;
              D.11421 = D.11415->max_wait_time;
              if (D.11421 < wait_time) goto <D.11437>; else goto <D.11438>;
              <D.11437>:
              D.11415 = thread->monitor;
              D.11415->max_wait_time = wait_time;
              <D.11438>:
              D.11415 = thread->monitor;
              D.11415 = thread->monitor;
              D.11424 = D.11415->wait_time;
              D.11439 = D.11424 + wait_time;
              D.11415->wait_time = D.11439;
              thread->monitor = 0B;
              thread->contention_start = 0;
            }
            <D.11436>:
            <D.11434>:
            <D.11430>:
            <D.11428>:
            <D.11426>:
            <D.11408>:
            debug.67 = debug;
            if (debug.67 != 0) goto <D.11440>; else goto <D.11441>;
            <D.11440>:
            outfile.64 = outfile;
            D.11442 = monitor_ev_name (event);
            D.11388 = obj_base + objdiff;
            D.11389 = D.11388 << 3;
            D.11443 = (void *) D.11389;
            fprintf (outfile.64, "monitor %s for object %p\n", D.11442, D.11443);
            <D.11441>:
            if (&sframes != frames) goto <D.11444>; else goto <D.11445>;
            <D.11444>:
            free (frames);
            <D.11445>:
            goto <D.9607>;
          }
        finally
          {
            sframes = {CLOBBER};
            num_bt = {CLOBBER};
          }
      }
      <D.9701>:
      {
        int subtype;
        int has_bt;
        uint64_t tdiff;
        struct MethodDesc * sframes[8];
        struct MethodDesc * * frames;
        int record;

        try
          {
            p.63 = p;
            D.11099 = *p.63;
            D.11100 = (int) D.11099;
            subtype = D.11100 & 112;
            p.63 = p;
            D.11099 = *p.63;
            D.11100 = (int) D.11099;
            has_bt.100 = D.11100 & 128;
            has_bt = has_bt.100;
            p.63 = p;
            D.11102 = p.63 + 1;
            tdiff = decode_uleb128 (D.11102, &p);
            frames = &sframes;
            time_base = time_base + tdiff;
            thread_filter.82 = thread_filter;
            if (thread_filter.82 == 0) goto <D.11448>; else goto <D.11451>;
            <D.11451>:
            D.11120 = thread->thread_id;
            D.11246 = (long unsigned int) D.11120;
            thread_filter.82 = thread_filter;
            if (D.11246 == thread_filter.82) goto <D.11448>; else goto <D.11449>;
            <D.11448>:
            iftmp.101 = 1;
            goto <D.11450>;
            <D.11449>:
            iftmp.101 = 0;
            <D.11450>:
            record = iftmp.101;
            if (subtype == 16) goto <D.11452>; else goto <D.11453>;
            <D.11452>:
            {
              int clause_type;
              int clause_num;
              int64_t ptrdiff;

              p.63 = p;
              D.11454 = decode_uleb128 (p.63, &p);
              clause_type = (int) D.11454;
              p.63 = p;
              D.11455 = decode_uleb128 (p.63, &p);
              clause_num = (int) D.11455;
              p.63 = p;
              ptrdiff = decode_sleb128 (p.63, &p);
              method_base = method_base + ptrdiff;
              if (record != 0) goto <D.11456>; else goto <D.11457>;
              <D.11456>:
              D.11458 = clause_summary[clause_type];
              D.11459 = D.11458 + 1;
              clause_summary[clause_type] = D.11459;
              <D.11457>:
              debug.67 = debug;
              if (debug.67 != 0) goto <D.11460>; else goto <D.11461>;
              <D.11460>:
              outfile.64 = outfile;
              D.11462 = clause_name (clause_type);
              D.11463 = lookup_method (method_base);
              D.11464 = D.11463->name;
              fprintf (outfile.64, "clause %s (%d) in method %s\n", D.11462, clause_num, D.11464);
              <D.11461>:
            }
            goto <D.11465>;
            <D.11453>:
            {
              intptr_t objdiff;

              p.63 = p;
              objdiff = decode_sleb128 (p.63, &p);
              if (record != 0) goto <D.11466>; else goto <D.11467>;
              <D.11466>:
              throw_count.102 = throw_count;
              throw_count.103 = throw_count.102 + 1;
              throw_count = throw_count.103;
              <D.11467>:
              has_bt.104 = has_bt;
              if (has_bt.104 != 0) goto <D.11471>; else goto <D.11472>;
              <D.11471>:
              has_bt = 8;
              p.63 = p;
              frames = decode_bt (&sframes, &has_bt, p.63, &p, ptr_base);
              if (frames == 0B) goto <D.11473>; else goto <D.11474>;
              <D.11473>:
              outfile.64 = outfile;
              fprintf (outfile.64, "Cannot load backtrace\n");
              D.11046 = 0;
              return D.11046;
              <D.11474>:
              if (record != 0) goto <D.11475>; else goto <D.11476>;
              <D.11475>:
              has_bt.104 = has_bt;
              add_trace_methods (frames, has_bt.104, &exc_traces, 1);
              <D.11476>:
              goto <D.11477>;
              <D.11472>:
              if (record != 0) goto <D.11478>; else goto <D.11479>;
              <D.11478>:
              add_trace_thread (thread, &exc_traces, 1);
              <D.11479>:
              <D.11477>:
              if (&sframes != frames) goto <D.11480>; else goto <D.11481>;
              <D.11480>:
              free (frames);
              <D.11481>:
              debug.67 = debug;
              if (debug.67 != 0) goto <D.11482>; else goto <D.11483>;
              <D.11482>:
              outfile.64 = outfile;
              D.11484 = obj_base + objdiff;
              D.11485 = D.11484 << 3;
              D.11486 = (void *) D.11485;
              fprintf (outfile.64, "throw %p\n", D.11486);
              <D.11483>:
            }
            <D.11465>:
            goto <D.9607>;
          }
        finally
          {
            has_bt = {CLOBBER};
            sframes = {CLOBBER};
          }
      }
      <D.9712>:
      {
        int subtype;

        p.63 = p;
        D.11099 = *p.63;
        D.11100 = (int) D.11099;
        subtype = D.11100 & 240;
        if (subtype == 0) goto <D.11487>; else goto <D.11488>;
        <D.11487>:
        {
          int i;
          int sample_type;
          uint64_t tstamp;
          int count;

          p.63 = p;
          D.11102 = p.63 + 1;
          D.11489 = decode_uleb128 (D.11102, &p);
          sample_type = (int) D.11489;
          p.63 = p;
          tstamp = decode_uleb128 (p.63, &p);
          p.63 = p;
          D.11490 = decode_uleb128 (p.63, &p);
          count = (int) D.11490;
          i = 0;
          goto <D.9720>;
          <D.9719>:
          {
            uintptr_t ip;

            p.63 = p;
            D.11491 = decode_sleb128 (p.63, &p);
            D.11492 = D.11491 + ptr_base;
            ip = (uintptr_t) D.11492;
            add_stat_sample (sample_type, ip);
            debug.67 = debug;
            if (debug.67 != 0) goto <D.11493>; else goto <D.11494>;
            <D.11493>:
            outfile.64 = outfile;
            ip.105 = (void *) ip;
            fprintf (outfile.64, "sample hit, type: %d at %p\n", sample_type, ip.105);
            <D.11494>:
          }
          i = i + 1;
          <D.9720>:
          if (i < count) goto <D.9719>; else goto <D.9721>;
          <D.9721>:
        }
        goto <D.11496>;
        <D.11488>:
        if (subtype == 16) goto <D.11497>; else goto <D.11498>;
        <D.11497>:
        {
          uintptr_t addr;
          uintptr_t size;
          char * name;

          p.63 = p;
          D.11102 = p.63 + 1;
          D.11499 = decode_sleb128 (D.11102, &p);
          D.11500 = D.11499 + ptr_base;
          addr = (uintptr_t) D.11500;
          p.63 = p;
          size = decode_uleb128 (p.63, &p);
          p.63 = p;
          name = pstrdup (p.63);
          add_unmanaged_symbol (addr, name, size);
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11501>; else goto <D.11502>;
          <D.11501>:
          outfile.64 = outfile;
          addr.106 = (void *) addr;
          fprintf (outfile.64, "unmanaged symbol %s at %p\n", name, addr.106);
          <D.11502>:
          goto <D.9726>;
          <D.9725>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
          <D.9726>:
          p.63 = p;
          D.11099 = *p.63;
          if (D.11099 != 0) goto <D.9725>; else goto <D.9727>;
          <D.9727>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
        }
        goto <D.11504>;
        <D.11498>:
        if (subtype == 32) goto <D.11505>; else goto <D.11506>;
        <D.11505>:
        {
          uint64_t tdiff;
          uintptr_t addr;
          uint64_t offset;
          uintptr_t size;
          char * name;

          p.63 = p;
          D.11102 = p.63 + 1;
          tdiff = decode_uleb128 (D.11102, &p);
          p.63 = p;
          D.11507 = decode_sleb128 (p.63, &p);
          addr = (uintptr_t) D.11507;
          p.63 = p;
          offset = decode_uleb128 (p.63, &p);
          p.63 = p;
          size = decode_uleb128 (p.63, &p);
          time_base = time_base + tdiff;
          p.63 = p;
          name = pstrdup (p.63);
          add_unmanaged_binary (addr, name, size);
          debug.67 = debug;
          if (debug.67 != 0) goto <D.11508>; else goto <D.11509>;
          <D.11508>:
          outfile.64 = outfile;
          addr.107 = (void *) addr;
          fprintf (outfile.64, "unmanaged binary %s at %p\n", name, addr.107);
          <D.11509>:
          goto <D.9734>;
          <D.9733>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
          <D.9734>:
          p.63 = p;
          D.11099 = *p.63;
          if (D.11099 != 0) goto <D.9733>; else goto <D.9735>;
          <D.9735>:
          p.63 = p;
          p.81 = p.63 + 1;
          p = p.81;
        }
        goto <D.11511>;
        <D.11506>:
        D.11046 = 0;
        return D.11046;
        <D.11511>:
        <D.11504>:
        <D.11496>:
        goto <D.9607>;
      }
      <D.9736>:
      outfile.64 = outfile;
      p.63 = p;
      D.11099 = *p.63;
      D.11100 = (int) D.11099;
      p.63 = p;
      p.108 = (long int) p.63;
      p.62 = ctx->buf;
      p.109 = (long int) p.62;
      D.11514 = p.108 - p.109;
      fprintf (outfile.64, "unhandled profiler event: 0x%x at file offset: %llu + %d (len: %d\n)\n", D.11100, file_offset, D.11514, len);
      exit (1);
      <D.9607>:
      <D.9738>:
      p.63 = p;
      if (p.63 < end) goto <D.9737>; else goto <D.9739>;
      <D.9739>:
      thread->last_time = time_base;
      i = 0;
      goto <D.9741>;
      <D.9740>:
      D.11090 = thread->stack;
      D.11091 = (long unsigned int) i;
      D.11092 = D.11091 * 8;
      D.11093 = D.11090 + D.11092;
      D.11094 = *D.11093;
      D.11094->recurse_count = 0;
      i = i + 1;
      <D.9741>:
      D.11097 = thread->stack_id;
      if (D.11097 > i) goto <D.9740>; else goto <D.9742>;
      <D.9742>:
      D.11046 = 1;
      return D.11046;
    }
  finally
    {
      p = {CLOBBER};
    }
}


load_thread (struct ProfContext * ctx, intptr_t thread_id)
{
  struct ThreadContext * D.11624;
  struct ThreadContext * thread;

  thread = get_thread (ctx, thread_id);
  ctx->current = thread;
  D.11624 = thread;
  return D.11624;
}


gc_event_name (int ev)
{
  const char * D.11627;

  switch (ev) <default: <D.9466>, case 0: <D.9456>, case 1: <D.9457>, case 2: <D.9458>, case 3: <D.9459>, case 4: <D.9460>, case 5: <D.9461>, case 6: <D.9462>, case 7: <D.9463>, case 8: <D.9464>, case 9: <D.9465>>
  <D.9456>:
  D.11627 = "start";
  return D.11627;
  <D.9457>:
  D.11627 = "mark start";
  return D.11627;
  <D.9458>:
  D.11627 = "mark end";
  return D.11627;
  <D.9459>:
  D.11627 = "reclaim start";
  return D.11627;
  <D.9460>:
  D.11627 = "reclaim end";
  return D.11627;
  <D.9461>:
  D.11627 = "end";
  return D.11627;
  <D.9462>:
  D.11627 = "pre stop";
  return D.11627;
  <D.9463>:
  D.11627 = "post stop";
  return D.11627;
  <D.9464>:
  D.11627 = "pre start";
  return D.11627;
  <D.9465>:
  D.11627 = "post start";
  return D.11627;
  <D.9466>:
  D.11627 = "unknown";
  return D.11627;
}


track_move (uintptr_t src, uintptr_t dst)
{
  uintptr_t * tracked_objects.110;
  long unsigned int D.11630;
  long unsigned int D.11631;
  uintptr_t * D.11632;
  long unsigned int D.11633;
  struct FILE * outfile.111;
  void * src.112;
  void * dst.113;
  int num_tracked_objects.114;
  int i;

  i = 0;
  goto <D.9567>;
  <D.9566>:
  tracked_objects.110 = tracked_objects;
  D.11630 = (long unsigned int) i;
  D.11631 = D.11630 * 8;
  D.11632 = tracked_objects.110 + D.11631;
  D.11633 = *D.11632;
  if (D.11633 == src) goto <D.11634>; else goto <D.11635>;
  <D.11634>:
  outfile.111 = outfile;
  src.112 = (void *) src;
  dst.113 = (void *) dst;
  fprintf (outfile.111, "Object %p moved to %p\n", src.112, dst.113);
  goto <D.11639>;
  <D.11635>:
  tracked_objects.110 = tracked_objects;
  D.11630 = (long unsigned int) i;
  D.11631 = D.11630 * 8;
  D.11632 = tracked_objects.110 + D.11631;
  D.11633 = *D.11632;
  if (D.11633 == dst) goto <D.11640>; else goto <D.11641>;
  <D.11640>:
  outfile.111 = outfile;
  dst.113 = (void *) dst;
  src.112 = (void *) src;
  fprintf (outfile.111, "Object %p moved from %p\n", dst.113, src.112);
  <D.11641>:
  <D.11639>:
  i = i + 1;
  <D.9567>:
  num_tracked_objects.114 = num_tracked_objects;
  if (i < num_tracked_objects.114) goto <D.9566>; else goto <D.9568>;
  <D.9568>:
}


track_handle (uintptr_t obj, int htype, uint32_t handle)
{
  uintptr_t * tracked_objects.115;
  long unsigned int D.11644;
  long unsigned int D.11645;
  uintptr_t * D.11646;
  long unsigned int D.11647;
  struct FILE * outfile.116;
  void * obj.117;
  int num_tracked_objects.118;
  int i;

  i = 0;
  goto <D.9559>;
  <D.9558>:
  tracked_objects.115 = tracked_objects;
  D.11644 = (long unsigned int) i;
  D.11645 = D.11644 * 8;
  D.11646 = tracked_objects.115 + D.11645;
  D.11647 = *D.11646;
  if (D.11647 == obj) goto <D.11648>; else goto <D.11649>;
  <D.11648>:
  outfile.116 = outfile;
  obj.117 = (void *) obj;
  fprintf (outfile.116, "Object %p referenced from handle %u\n", obj.117, handle);
  <D.11649>:
  i = i + 1;
  <D.9559>:
  num_tracked_objects.118 = num_tracked_objects;
  if (i < num_tracked_objects.118) goto <D.9558>; else goto <D.9560>;
  <D.9560>:
}


get_handle_name (int htype)
{
  const char * D.11653;

  switch (htype) <default: <D.9511>, case 0: <D.9507>, case 1: <D.9508>, case 2: <D.9509>, case 3: <D.9510>>
  <D.9507>:
  D.11653 = "weak";
  return D.11653;
  <D.9508>:
  D.11653 = "weaktrack";
  return D.11653;
  <D.9509>:
  D.11653 = "normal";
  return D.11653;
  <D.9510>:
  D.11653 = "pinned";
  return D.11653;
  <D.9511>:
  D.11653 = "unknown";
  return D.11653;
}


add_class (intptr_t klass, const char * name)
{
  long int D.11655;
  long int D.11656;
  long int D.11657;
  long int D.11659;
  char * D.11662;
  char * D.11663;
  struct ClassDesc * D.11664;
  char * D.11665;
  struct ClassDesc * D.11666;
  int num_classes.119;
  int num_classes.120;
  int slot;
  struct ClassDesc * cd;

  D.11655 = klass >> 2;
  D.11656 = D.11655 & 65535;
  D.11657 = D.11656 % 9371;
  slot = (int) D.11657;
  cd = class_hash[slot];
  goto <D.8887>;
  <D.8886>:
  cd = cd->next;
  <D.8887>:
  if (cd != 0B) goto <D.11658>; else goto <D.8888>;
  <D.11658>:
  D.11659 = cd->klass;
  if (D.11659 != klass) goto <D.8886>; else goto <D.8888>;
  <D.8888>:
  if (cd != 0B) goto <D.11660>; else goto <D.11661>;
  <D.11660>:
  D.11662 = cd->name;
  free (D.11662);
  D.11663 = pstrdup (name);
  cd->name = D.11663;
  D.11664 = cd;
  return D.11664;
  <D.11661>:
  cd = calloc (56, 1);
  cd->klass = klass;
  D.11665 = pstrdup (name);
  cd->name = D.11665;
  D.11666 = class_hash[slot];
  cd->next = D.11666;
  cd->allocs = 0;
  cd->alloc_size = 0;
  cd->traces.count = 0;
  cd->traces.size = 0;
  cd->traces.traces = 0B;
  class_hash[slot] = cd;
  num_classes.119 = num_classes;
  num_classes.120 = num_classes.119 + 1;
  num_classes = num_classes.120;
  D.11664 = cd;
  return D.11664;
}


add_image (intptr_t image, char * name)
{
  long int D.11672;
  long int D.11673;
  long int D.11674;
  char * D.11675;
  struct ImageDesc * D.11676;
  int num_images.121;
  int num_images.122;
  int slot;
  struct ImageDesc * cd;

  D.11672 = image >> 2;
  D.11673 = D.11672 & 65535;
  D.11674 = D.11673 % 31;
  slot = (int) D.11674;
  cd = malloc (24);
  cd->image = image;
  D.11675 = pstrdup (name);
  cd->filename = D.11675;
  D.11676 = image_hash[slot];
  cd->next = D.11676;
  image_hash[slot] = cd;
  num_images.121 = num_images;
  num_images.122 = num_images.121 + 1;
  num_images = num_images.122;
}


get_thread (struct ProfContext * ctx, intptr_t thread_id)
{
  struct ThreadContext * D.11680;
  long int D.11683;
  struct ThreadContext * D.11686;
  long int D.11687;
  struct ThreadContext * D.11690;
  int D.11691;
  long unsigned int D.11692;
  long unsigned int D.11693;
  void * D.11694;
  void * D.11695;
  void * D.11696;
  struct ThreadContext * thread;

  D.11680 = ctx->current;
  if (D.11680 != 0B) goto <D.11681>; else goto <D.11682>;
  <D.11681>:
  D.11680 = ctx->current;
  D.11683 = D.11680->thread_id;
  if (D.11683 == thread_id) goto <D.11684>; else goto <D.11685>;
  <D.11684>:
  D.11686 = ctx->current;
  return D.11686;
  <D.11685>:
  <D.11682>:
  thread = ctx->threads;
  goto <D.9359>;
  <D.9358>:
  D.11687 = thread->thread_id;
  if (D.11687 == thread_id) goto <D.11688>; else goto <D.11689>;
  <D.11688>:
  D.11686 = thread;
  return D.11686;
  <D.11689>:
  thread = thread->next;
  <D.9359>:
  if (thread != 0B) goto <D.9358>; else goto <D.9360>;
  <D.9360>:
  thread = calloc (152, 1);
  D.11690 = ctx->threads;
  thread->next = D.11690;
  ctx->threads = thread;
  thread->thread_id = thread_id;
  thread->last_time = 0;
  thread->stack_id = 0;
  thread->stack_size = 32;
  D.11691 = thread->stack_size;
  D.11692 = (long unsigned int) D.11691;
  D.11693 = D.11692 * 8;
  D.11694 = malloc (D.11693);
  thread->stack = D.11694;
  D.11691 = thread->stack_size;
  D.11692 = (long unsigned int) D.11691;
  D.11693 = D.11692 * 8;
  D.11695 = malloc (D.11693);
  thread->time_stack = D.11695;
  D.11691 = thread->stack_size;
  D.11692 = (long unsigned int) D.11691;
  D.11693 = D.11692 * 8;
  D.11696 = malloc (D.11693);
  thread->callee_time_stack = D.11696;
  D.11686 = thread;
  return D.11686;
}


tracked_creation (uintptr_t obj, struct ClassDesc * cd, uint64_t size, struct BackTrace * bt, uint64_t timestamp)
{
  uintptr_t * tracked_objects.123;
  long unsigned int D.11699;
  long unsigned int D.11700;
  uintptr_t * D.11701;
  long unsigned int D.11702;
  struct FILE * outfile.124;
  void * obj.125;
  char * D.11707;
  long unsigned int startup_time.126;
  long unsigned int D.11709;
  double D.11710;
  double D.11711;
  int D.11714;
  struct MethodDesc * D.11717;
  char * D.11718;
  int num_tracked_objects.127;
  int i;

  i = 0;
  goto <D.9550>;
  <D.9549>:
  tracked_objects.123 = tracked_objects;
  D.11699 = (long unsigned int) i;
  D.11700 = D.11699 * 8;
  D.11701 = tracked_objects.123 + D.11700;
  D.11702 = *D.11701;
  if (D.11702 != obj) goto <D.11703>; else goto <D.11704>;
  <D.11703>:
  // predicted unlikely by continue predictor.
  goto <D.9544>;
  <D.11704>:
  outfile.124 = outfile;
  obj.125 = (void *) obj;
  D.11707 = cd->name;
  startup_time.126 = startup_time;
  D.11709 = timestamp - startup_time.126;
  D.11710 = (double) D.11709;
  D.11711 = D.11710 / 1.0e+9;
  fprintf (outfile.124, "Object %p created (%s, %llu bytes) at %.3f secs.\n", obj.125, D.11707, size, D.11711);
  if (bt != 0B) goto <D.11712>; else goto <D.11713>;
  <D.11712>:
  D.11714 = bt->count;
  if (D.11714 != 0) goto <D.11715>; else goto <D.11716>;
  <D.11715>:
  {
    int k;

    k = 0;
    goto <D.9547>;
    <D.9546>:
    outfile.124 = outfile;
    D.11717 = bt->methods[k];
    D.11718 = D.11717->name;
    fprintf (outfile.124, "\t%s\n", D.11718);
    k = k + 1;
    <D.9547>:
    D.11714 = bt->count;
    if (D.11714 > k) goto <D.9546>; else goto <D.9548>;
    <D.9548>:
  }
  <D.11716>:
  <D.11713>:
  <D.9544>:
  i = i + 1;
  <D.9550>:
  num_tracked_objects.127 = num_tracked_objects;
  if (i < num_tracked_objects.127) goto <D.9549>; else goto <D.9551>;
  <D.9551>:
}


add_method (intptr_t method, const char * name, intptr_t code, int len)
{
  long int D.11720;
  long int D.11721;
  long int D.11722;
  long int D.11724;
  char * D.11727;
  char * D.11728;
  struct MethodDesc * D.11729;
  char * D.11730;
  struct MethodDesc * D.11731;
  int num_methods.128;
  int num_methods.129;
  int slot;
  struct MethodDesc * cd;

  D.11720 = method >> 2;
  D.11721 = D.11720 & 65535;
  D.11722 = D.11721 % 9371;
  slot = (int) D.11722;
  cd = method_hash[slot];
  goto <D.8923>;
  <D.8922>:
  cd = cd->next;
  <D.8923>:
  if (cd != 0B) goto <D.11723>; else goto <D.8924>;
  <D.11723>:
  D.11724 = cd->method;
  if (D.11724 != method) goto <D.8922>; else goto <D.8924>;
  <D.8924>:
  if (cd != 0B) goto <D.11725>; else goto <D.11726>;
  <D.11725>:
  cd->code = code;
  cd->len = len;
  D.11727 = cd->name;
  free (D.11727);
  D.11728 = pstrdup (name);
  cd->name = D.11728;
  D.11729 = cd;
  return D.11729;
  <D.11726>:
  cd = calloc (96, 1);
  cd->method = method;
  D.11730 = pstrdup (name);
  cd->name = D.11730;
  cd->code = code;
  cd->len = len;
  cd->calls = 0;
  cd->total_time = 0;
  cd->traces.count = 0;
  cd->traces.size = 0;
  cd->traces.traces = 0B;
  D.11731 = method_hash[slot];
  cd->next = D.11731;
  method_hash[slot] = cd;
  num_methods.128 = num_methods;
  num_methods.129 = num_methods.128 + 1;
  num_methods = num_methods.129;
  D.11729 = cd;
  return D.11729;
}


push_method (struct ThreadContext * thread, struct MethodDesc * method, uint64_t timestamp)
{
  uint64_t * D.11737;
  int D.11738;
  long unsigned int D.11739;
  long unsigned int D.11740;
  uint64_t * D.11741;
  uint64_t * D.11742;
  uint64_t * D.11743;
  struct MethodDesc * * D.11744;
  int D.11745;
  int D.11746;
  long unsigned int D.11747;
  long unsigned int D.11748;
  struct MethodDesc * * D.11749;
  int D.11750;
  int D.11751;

  ensure_thread_stack (thread);
  D.11737 = thread->time_stack;
  D.11738 = thread->stack_id;
  D.11739 = (long unsigned int) D.11738;
  D.11740 = D.11739 * 8;
  D.11741 = D.11737 + D.11740;
  *D.11741 = timestamp;
  D.11742 = thread->callee_time_stack;
  D.11738 = thread->stack_id;
  D.11739 = (long unsigned int) D.11738;
  D.11740 = D.11739 * 8;
  D.11743 = D.11742 + D.11740;
  *D.11743 = 0;
  D.11744 = thread->stack;
  D.11738 = thread->stack_id;
  D.11745 = D.11738;
  D.11746 = D.11745 + 1;
  thread->stack_id = D.11746;
  D.11747 = (long unsigned int) D.11745;
  D.11748 = D.11747 * 8;
  D.11749 = D.11744 + D.11748;
  *D.11749 = method;
  D.11750 = method->recurse_count;
  D.11751 = D.11750 + 1;
  method->recurse_count = D.11751;
}


ensure_thread_stack (struct ThreadContext * thread)
{
  int D.11752;
  int D.11753;
  int D.11756;
  struct MethodDesc * * D.11757;
  long unsigned int D.11758;
  long unsigned int D.11759;
  void * D.11760;
  uint64_t * D.11761;
  void * D.11762;
  uint64_t * D.11763;
  void * D.11764;

  D.11752 = thread->stack_id;
  D.11753 = thread->stack_size;
  if (D.11752 == D.11753) goto <D.11754>; else goto <D.11755>;
  <D.11754>:
  D.11753 = thread->stack_size;
  D.11756 = D.11753 * 2;
  thread->stack_size = D.11756;
  D.11757 = thread->stack;
  D.11753 = thread->stack_size;
  D.11758 = (long unsigned int) D.11753;
  D.11759 = D.11758 * 8;
  D.11760 = realloc (D.11757, D.11759);
  thread->stack = D.11760;
  D.11761 = thread->time_stack;
  D.11753 = thread->stack_size;
  D.11758 = (long unsigned int) D.11753;
  D.11759 = D.11758 * 8;
  D.11762 = realloc (D.11761, D.11759);
  thread->time_stack = D.11762;
  D.11763 = thread->callee_time_stack;
  D.11753 = thread->stack_size;
  D.11758 = (long unsigned int) D.11753;
  D.11759 = D.11758 * 8;
  D.11764 = realloc (D.11763, D.11759);
  thread->callee_time_stack = D.11764;
  <D.11755>:
}


pop_method (struct ThreadContext * thread, struct MethodDesc * method, uint64_t timestamp)
{
  int D.11765;
  int D.11766;
  int D.11769;
  struct MethodDesc * * D.11771;
  long unsigned int D.11772;
  long unsigned int D.11773;
  sizetype D.11774;
  struct MethodDesc * * D.11775;
  struct MethodDesc * D.11776;
  int D.11778;
  long unsigned int D.11779;
  long unsigned int D.11780;
  uint64_t * D.11781;
  uint64_t * D.11782;
  long unsigned int D.11783;
  struct FILE * outfile.130;
  char * D.11787;
  uint64_t * D.11788;
  uint64_t * D.11789;
  long unsigned int D.11790;
  long unsigned int D.11793;
  long unsigned int D.11794;
  long unsigned int D.11795;
  long unsigned int D.11796;
  long unsigned int D.11797;
  uint64_t * D.11800;
  long unsigned int D.11801;
  long unsigned int D.11802;

  D.11765 = method->recurse_count;
  D.11766 = D.11765 + -1;
  method->recurse_count = D.11766;
  D.11769 = thread->stack_id;
  if (D.11769 > 0) goto <D.11770>; else goto <D.11767>;
  <D.11770>:
  D.11771 = thread->stack;
  D.11769 = thread->stack_id;
  D.11772 = (long unsigned int) D.11769;
  D.11773 = D.11772 * 8;
  D.11774 = D.11773 + 18446744073709551608;
  D.11775 = D.11771 + D.11774;
  D.11776 = *D.11775;
  if (D.11776 == method) goto <D.11777>; else goto <D.11767>;
  <D.11777>:
  {
    uint64_t tdiff;

    D.11769 = thread->stack_id;
    D.11778 = D.11769 + -1;
    thread->stack_id = D.11778;
    D.11779 = method->calls;
    D.11780 = D.11779 + 1;
    method->calls = D.11780;
    D.11781 = thread->time_stack;
    D.11769 = thread->stack_id;
    D.11772 = (long unsigned int) D.11769;
    D.11773 = D.11772 * 8;
    D.11782 = D.11781 + D.11773;
    D.11783 = *D.11782;
    if (D.11783 > timestamp) goto <D.11784>; else goto <D.11785>;
    <D.11784>:
    outfile.130 = outfile;
    D.11787 = method->name;
    fprintf (outfile.130, "time went backwards for %s\n", D.11787);
    <D.11785>:
    D.11781 = thread->time_stack;
    D.11769 = thread->stack_id;
    D.11772 = (long unsigned int) D.11769;
    D.11773 = D.11772 * 8;
    D.11782 = D.11781 + D.11773;
    D.11783 = *D.11782;
    tdiff = timestamp - D.11783;
    D.11788 = thread->callee_time_stack;
    D.11769 = thread->stack_id;
    D.11772 = (long unsigned int) D.11769;
    D.11773 = D.11772 * 8;
    D.11789 = D.11788 + D.11773;
    D.11790 = *D.11789;
    if (D.11790 > tdiff) goto <D.11791>; else goto <D.11792>;
    <D.11791>:
    outfile.130 = outfile;
    D.11787 = method->name;
    fprintf (outfile.130, "callee time bigger for %s\n", D.11787);
    <D.11792>:
    D.11793 = method->self_time;
    D.11788 = thread->callee_time_stack;
    D.11769 = thread->stack_id;
    D.11772 = (long unsigned int) D.11769;
    D.11773 = D.11772 * 8;
    D.11789 = D.11788 + D.11773;
    D.11790 = *D.11789;
    D.11794 = tdiff - D.11790;
    D.11795 = D.11793 + D.11794;
    method->self_time = D.11795;
    D.11796 = method->callee_time;
    D.11788 = thread->callee_time_stack;
    D.11769 = thread->stack_id;
    D.11772 = (long unsigned int) D.11769;
    D.11773 = D.11772 * 8;
    D.11789 = D.11788 + D.11773;
    D.11790 = *D.11789;
    D.11797 = D.11796 + D.11790;
    method->callee_time = D.11797;
    D.11769 = thread->stack_id;
    if (D.11769 != 0) goto <D.11798>; else goto <D.11799>;
    <D.11798>:
    D.11788 = thread->callee_time_stack;
    D.11769 = thread->stack_id;
    D.11772 = (long unsigned int) D.11769;
    D.11773 = D.11772 * 8;
    D.11774 = D.11773 + 18446744073709551608;
    D.11800 = D.11788 + D.11774;
    D.11788 = thread->callee_time_stack;
    D.11769 = thread->stack_id;
    D.11772 = (long unsigned int) D.11769;
    D.11773 = D.11772 * 8;
    D.11774 = D.11773 + 18446744073709551608;
    D.11800 = D.11788 + D.11774;
    D.11801 = *D.11800;
    D.11802 = D.11801 + tdiff;
    *D.11800 = D.11802;
    <D.11799>:
  }
  goto <D.11768>;
  <D.11767>:
  outfile.130 = outfile;
  D.11769 = thread->stack_id;
  D.11787 = method->name;
  fprintf (outfile.130, "unmatched leave at stack pos: %d for method %s\n", D.11769, D.11787);
  <D.11768>:
}


lookup_class (intptr_t klass)
{
  long int D.11803;
  long int D.11804;
  long int D.11805;
  long int D.11807;
  void * klass.131;
  struct ClassDesc * D.11811;
  int slot;
  struct ClassDesc * cd;

  D.11803 = klass >> 2;
  D.11804 = D.11803 & 65535;
  D.11805 = D.11804 % 9371;
  slot = (int) D.11805;
  cd = class_hash[slot];
  goto <D.8895>;
  <D.8894>:
  cd = cd->next;
  <D.8895>:
  if (cd != 0B) goto <D.11806>; else goto <D.8896>;
  <D.11806>:
  D.11807 = cd->klass;
  if (D.11807 != klass) goto <D.8894>; else goto <D.8896>;
  <D.8896>:
  if (cd == 0B) goto <D.11808>; else goto <D.11809>;
  <D.11808>:
  {
    char buf[128];

    try
      {
        klass.131 = (void *) klass;
        snprintf (&buf, 128, "unresolved class %p", klass.131);
        D.11811 = add_class (klass, &buf);
        return D.11811;
      }
    finally
      {
        buf = {CLOBBER};
      }
  }
  <D.11809>:
  D.11811 = cd;
  return D.11811;
}


snprintf (char * restrict __s, size_t __n, const char * restrict __fmt)
{
  int D.11816;
  long unsigned int D.11817;

  D.11817 = __builtin_object_size (__s, 1);
  D.11816 = __builtin___snprintf_chk (__s, __n, 1, D.11817, __fmt, __builtin_va_arg_pack ());
  return D.11816;
}


add_heap_shot_class (struct HeapShot * hs, struct ClassDesc * klass, uint64_t size)
{
  int D.11819;
  int D.11820;
  int D.11821;
  int D.11824;
  long unsigned int D.11827;
  long unsigned int D.11828;
  struct HeapClassDesc * * D.11829;
  long unsigned int D.11830;
  long unsigned int D.11831;
  struct HeapClassDesc * * D.11832;
  struct HeapClassDesc * res.132;
  long unsigned int D.11836;
  struct ClassDesc * D.11837;
  long int D.11838;
  long unsigned int D.11839;
  long int D.11840;
  long unsigned int D.11841;
  int D.11844;
  int D.11845;
  struct HeapClassDesc * D.11846;
  struct HeapClassDesc * res;
  int i;

  try
    {
      D.11819 = hs->class_count;
      D.11820 = D.11819 * 2;
      D.11821 = hs->hash_size;
      if (D.11820 >= D.11821) goto <D.11822>; else goto <D.11823>;
      <D.11822>:
      {
        struct HeapClassDesc * * n;
        int old_size;

        old_size = hs->hash_size;
        D.11821 = hs->hash_size;
        D.11824 = D.11821 * 2;
        hs->hash_size = D.11824;
        D.11821 = hs->hash_size;
        if (D.11821 == 0) goto <D.11825>; else goto <D.11826>;
        <D.11825>:
        hs->hash_size = 4;
        <D.11826>:
        D.11821 = hs->hash_size;
        D.11827 = (long unsigned int) D.11821;
        D.11828 = D.11827 * 8;
        n = calloc (D.11828, 1);
        i = 0;
        goto <D.9164>;
        <D.9163>:
        D.11829 = hs->class_hash;
        D.11830 = (long unsigned int) i;
        D.11831 = D.11830 * 8;
        D.11832 = D.11829 + D.11831;
        res.132 = *D.11832;
        res = res.132;
        D.11829 = hs->class_hash;
        D.11830 = (long unsigned int) i;
        D.11831 = D.11830 * 8;
        D.11832 = D.11829 + D.11831;
        res.132 = *D.11832;
        if (res.132 != 0B) goto <D.11834>; else goto <D.11835>;
        <D.11834>:
        D.11821 = hs->hash_size;
        D.11836 = (long unsigned int) D.11821;
        D.11829 = hs->class_hash;
        D.11830 = (long unsigned int) i;
        D.11831 = D.11830 * 8;
        D.11832 = D.11829 + D.11831;
        res.132 = *D.11832;
        D.11837 = res.132->klass;
        D.11829 = hs->class_hash;
        D.11830 = (long unsigned int) i;
        D.11831 = D.11830 * 8;
        D.11832 = D.11829 + D.11831;
        res.132 = *D.11832;
        D.11838 = res.132->total_size;
        D.11839 = (long unsigned int) D.11838;
        D.11829 = hs->class_hash;
        D.11830 = (long unsigned int) i;
        D.11831 = D.11830 * 8;
        D.11832 = D.11829 + D.11831;
        res.132 = *D.11832;
        D.11840 = res.132->count;
        D.11841 = (long unsigned int) D.11840;
        add_heap_hashed (n, &res, D.11836, D.11837, D.11839, D.11841);
        <D.11835>:
        i = i + 1;
        <D.9164>:
        if (i < old_size) goto <D.9163>; else goto <D.9165>;
        <D.9165>:
        D.11829 = hs->class_hash;
        if (D.11829 != 0B) goto <D.11842>; else goto <D.11843>;
        <D.11842>:
        D.11829 = hs->class_hash;
        free (D.11829);
        <D.11843>:
        hs->class_hash = n;
      }
      <D.11823>:
      res = 0B;
      D.11829 = hs->class_hash;
      D.11821 = hs->hash_size;
      D.11836 = (long unsigned int) D.11821;
      D.11844 = add_heap_hashed (D.11829, &res, D.11836, klass, size, 1);
      D.11819 = hs->class_count;
      D.11845 = D.11819 + D.11844;
      hs->class_count = D.11845;
      D.11846 = res;
      return D.11846;
    }
  finally
    {
      res = {CLOBBER};
    }
}


add_heap_hashed (struct HeapClassDesc * * hash, struct HeapClassDesc * * retv, uintptr_t hsize, struct ClassDesc * klass, uint64_t size, uint64_t count)
{
  long int D.11851;
  long unsigned int D.11852;
  long unsigned int D.11853;
  long unsigned int D.11855;
  struct HeapClassDesc * * D.11856;
  struct HeapClassDesc * D.11857;
  struct ClassDesc * D.11859;
  long int D.11861;
  long unsigned int D.11862;
  long unsigned int D.11863;
  long int D.11864;
  long int D.11865;
  long unsigned int D.11866;
  long unsigned int D.11867;
  long int D.11868;
  int D.11869;
  struct HeapClassDesc * D.11872;
  void * D.11875;
  uintptr_t i;
  uintptr_t start_pos;

  D.11851 = klass->klass;
  D.11852 = (long unsigned int) D.11851;
  D.11853 = D.11852 >> 2;
  start_pos = D.11853 % hsize;
  i = start_pos;
  <D.9152>:
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  if (D.11857 != 0B) goto <D.11858>; else goto <D.11854>;
  <D.11858>:
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11859 = D.11857->klass;
  if (D.11859 == klass) goto <D.11860>; else goto <D.11854>;
  <D.11860>:
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11861 = D.11857->total_size;
  D.11862 = (long unsigned int) D.11861;
  D.11863 = D.11862 + size;
  D.11864 = (long int) D.11863;
  D.11857->total_size = D.11864;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11865 = D.11857->count;
  D.11866 = (long unsigned int) D.11865;
  D.11867 = D.11866 + count;
  D.11868 = (long int) D.11867;
  D.11857->count = D.11868;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  *retv = D.11857;
  D.11869 = 0;
  return D.11869;
  <D.11854>:
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  if (D.11857 == 0B) goto <D.11870>; else goto <D.11871>;
  <D.11870>:
  D.11872 = *retv;
  if (D.11872 != 0B) goto <D.11873>; else goto <D.11874>;
  <D.11873>:
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11872 = *retv;
  *D.11856 = D.11872;
  D.11869 = 1;
  return D.11869;
  <D.11874>:
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11875 = calloc (56, 1);
  *D.11856 = D.11875;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11857->klass = klass;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11861 = D.11857->total_size;
  D.11862 = (long unsigned int) D.11861;
  D.11863 = D.11862 + size;
  D.11864 = (long int) D.11863;
  D.11857->total_size = D.11864;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  D.11865 = D.11857->count;
  D.11866 = (long unsigned int) D.11865;
  D.11867 = D.11866 + count;
  D.11868 = (long int) D.11867;
  D.11857->count = D.11868;
  D.11855 = i * 8;
  D.11856 = hash + D.11855;
  D.11857 = *D.11856;
  *retv = D.11857;
  D.11869 = 1;
  return D.11869;
  <D.11871>:
  i = i + 1;
  if (i == hsize) goto <D.11876>; else goto <D.11877>;
  <D.11876>:
  i = 0;
  <D.11877>:
  if (i != start_pos) goto <D.9152>; else goto <D.9153>;
  <D.9153>:
  printf ("failed heap class store\n");
  D.11869 = 0;
  return D.11869;
}


alloc_heap_obj (uintptr_t objaddr, struct HeapClassDesc * hklass, uintptr_t num_refs)
{
  long unsigned int D.11879;
  long unsigned int D.11880;
  struct HeapObjectDesc * D.11881;
  struct HeapObjectDesc * ho;

  D.11879 = num_refs + 3;
  D.11880 = D.11879 * 8;
  ho = calloc (D.11880, 1);
  ho->objaddr = objaddr;
  ho->hklass = hklass;
  ho->num_refs = num_refs;
  D.11881 = ho;
  return D.11881;
}


add_heap_shot_obj (struct HeapShot * hs, struct HeapObjectDesc * obj)
{
  long unsigned int D.11883;
  long unsigned int D.11884;
  long unsigned int D.11885;
  long unsigned int D.11888;
  long unsigned int D.11891;
  struct HeapObjectDesc * * D.11892;
  long unsigned int D.11893;
  struct HeapObjectDesc * * D.11894;
  struct HeapObjectDesc * D.11895;
  long unsigned int D.11900;
  long unsigned int D.11901;
  uintptr_t i;

  D.11883 = hs->objects_count;
  D.11884 = D.11883 * 2;
  D.11885 = hs->objects_hash_size;
  if (D.11884 >= D.11885) goto <D.11886>; else goto <D.11887>;
  <D.11886>:
  {
    struct HeapObjectDesc * * n;
    uintptr_t old_size;

    old_size = hs->objects_hash_size;
    D.11885 = hs->objects_hash_size;
    D.11888 = D.11885 * 2;
    hs->objects_hash_size = D.11888;
    D.11885 = hs->objects_hash_size;
    if (D.11885 == 0) goto <D.11889>; else goto <D.11890>;
    <D.11889>:
    hs->objects_hash_size = 4;
    <D.11890>:
    D.11885 = hs->objects_hash_size;
    D.11891 = D.11885 * 8;
    n = calloc (D.11891, 1);
    i = 0;
    goto <D.9207>;
    <D.9206>:
    D.11892 = hs->objects_hash;
    D.11893 = i * 8;
    D.11894 = D.11892 + D.11893;
    D.11895 = *D.11894;
    if (D.11895 != 0B) goto <D.11896>; else goto <D.11897>;
    <D.11896>:
    D.11885 = hs->objects_hash_size;
    D.11892 = hs->objects_hash;
    D.11893 = i * 8;
    D.11894 = D.11892 + D.11893;
    D.11895 = *D.11894;
    add_heap_hashed_obj (n, D.11885, D.11895);
    <D.11897>:
    i = i + 1;
    <D.9207>:
    if (i < old_size) goto <D.9206>; else goto <D.9208>;
    <D.9208>:
    D.11892 = hs->objects_hash;
    if (D.11892 != 0B) goto <D.11898>; else goto <D.11899>;
    <D.11898>:
    D.11892 = hs->objects_hash;
    free (D.11892);
    <D.11899>:
    hs->objects_hash = n;
  }
  <D.11887>:
  D.11892 = hs->objects_hash;
  D.11885 = hs->objects_hash_size;
  D.11900 = add_heap_hashed_obj (D.11892, D.11885, obj);
  D.11883 = hs->objects_count;
  D.11901 = D.11883 + D.11900;
  hs->objects_count = D.11901;
}


add_heap_hashed_obj (struct HeapObjectDesc * * hash, uintptr_t hsize, struct HeapObjectDesc * obj)
{
  long unsigned int D.11903;
  long unsigned int D.11904;
  long unsigned int D.11906;
  struct HeapObjectDesc * * D.11907;
  struct HeapObjectDesc * D.11908;
  long unsigned int D.11910;
  uintptr_t D.11912;
  uintptr_t i;
  uintptr_t start_pos;

  D.11903 = obj->objaddr;
  D.11904 = D.11903 >> 3;
  start_pos = D.11904 % hsize;
  i = start_pos;
  <D.9197>:
  D.11906 = i * 8;
  D.11907 = hash + D.11906;
  D.11908 = *D.11907;
  if (D.11908 != 0B) goto <D.11909>; else goto <D.11905>;
  <D.11909>:
  D.11906 = i * 8;
  D.11907 = hash + D.11906;
  D.11908 = *D.11907;
  D.11910 = D.11908->objaddr;
  D.11903 = obj->objaddr;
  if (D.11910 == D.11903) goto <D.11911>; else goto <D.11905>;
  <D.11911>:
  printf ("duplicate object!\n");
  D.11912 = 0;
  return D.11912;
  <D.11905>:
  D.11906 = i * 8;
  D.11907 = hash + D.11906;
  D.11908 = *D.11907;
  if (D.11908 == 0B) goto <D.11913>; else goto <D.11914>;
  <D.11913>:
  D.11906 = i * 8;
  D.11907 = hash + D.11906;
  *D.11907 = obj;
  D.11912 = 1;
  return D.11912;
  <D.11914>:
  i = i + 1;
  if (i == hsize) goto <D.11915>; else goto <D.11916>;
  <D.11915>:
  i = 0;
  <D.11916>:
  if (i != start_pos) goto <D.9197>; else goto <D.9198>;
  <D.9198>:
  printf ("failed heap obj store\n");
  D.11912 = 0;
  return D.11912;
}


heap_shot_obj_add_refs (struct HeapShot * hs, uintptr_t objaddr, uintptr_t num, uintptr_t * ref_offset)
{
  long unsigned int D.11920;
  struct HeapObjectDesc * * D.11921;
  struct HeapObjectDesc * D.11922;
  struct HeapClassDesc * D.11923;
  long unsigned int D.11924;
  long unsigned int D.11925;
  uintptr_t[0:] * D.11926;
  uintptr_t[0:] * D.11927;
  long unsigned int D.11928;
  struct HeapObjectDesc * D.11929;
  struct HeapObjectDesc * * hash;
  uintptr_t i;

  hash = hs->objects_hash;
  i = heap_shot_find_obj_slot (hs, objaddr);
  if (1 != 0) goto <D.11918>; else goto <D.11919>;
  <D.11918>:
  {
    struct HeapObjectDesc * ho;

    D.11920 = i * 8;
    D.11921 = hash + D.11920;
    D.11922 = *D.11921;
    D.11923 = D.11922->hklass;
    D.11920 = i * 8;
    D.11921 = hash + D.11920;
    D.11922 = *D.11921;
    D.11924 = D.11922->num_refs;
    D.11925 = D.11924 + num;
    ho = alloc_heap_obj (objaddr, D.11923, D.11925);
    D.11920 = i * 8;
    D.11921 = hash + D.11920;
    D.11922 = *D.11921;
    D.11924 = D.11922->num_refs;
    *ref_offset = D.11924;
    D.11926 = &ho->refs;
    D.11920 = i * 8;
    D.11921 = hash + D.11920;
    D.11922 = *D.11921;
    D.11927 = &D.11922->refs;
    D.11920 = i * 8;
    D.11921 = hash + D.11920;
    D.11922 = *D.11921;
    D.11924 = D.11922->num_refs;
    D.11928 = D.11924 * 8;
    memcpy (D.11926, D.11927, D.11928);
    D.11920 = i * 8;
    D.11921 = hash + D.11920;
    D.11922 = *D.11921;
    free (D.11922);
    D.11920 = i * 8;
    D.11921 = hash + D.11920;
    *D.11921 = ho;
    D.11929 = ho;
    return D.11929;
  }
  <D.11919>:
  printf ("failed heap obj update\n");
  D.11929 = 0B;
  return D.11929;
}


heap_shot_find_obj_slot (struct HeapShot * hs, uintptr_t objaddr)
{
  long unsigned int D.11933;
  long unsigned int D.11934;
  long unsigned int D.11936;
  struct HeapObjectDesc * * D.11937;
  struct HeapObjectDesc * D.11938;
  long unsigned int D.11940;
  uintptr_t D.11942;
  uintptr_t i;
  uintptr_t start_pos;
  struct HeapObjectDesc * * hash;

  hash = hs->objects_hash;
  D.11933 = objaddr >> 3;
  D.11934 = hs->objects_hash_size;
  start_pos = D.11933 % D.11934;
  i = start_pos;
  <D.9180>:
  D.11936 = i * 8;
  D.11937 = hash + D.11936;
  D.11938 = *D.11937;
  if (D.11938 != 0B) goto <D.11939>; else goto <D.11935>;
  <D.11939>:
  D.11936 = i * 8;
  D.11937 = hash + D.11936;
  D.11938 = *D.11937;
  D.11940 = D.11938->objaddr;
  if (D.11940 == objaddr) goto <D.11941>; else goto <D.11935>;
  <D.11941>:
  D.11942 = i;
  return D.11942;
  <D.11935>:
  D.11936 = i * 8;
  D.11937 = hash + D.11936;
  D.11938 = *D.11937;
  if (D.11938 == 0B) goto <D.9179>; else goto <D.11943>;
  <D.11943>:
  i = i + 1;
  D.11934 = hs->objects_hash_size;
  if (i == D.11934) goto <D.11944>; else goto <D.11945>;
  <D.11944>:
  i = 0;
  <D.11945>:
  if (i != start_pos) goto <D.9180>; else goto <D.9179>;
  <D.9179>:
  D.11942 = 18446744073709551615;
  return D.11942;
}


track_obj_reference (uintptr_t obj, uintptr_t parent, struct ClassDesc * cd)
{
  uintptr_t * tracked_objects.133;
  long unsigned int D.11948;
  long unsigned int D.11949;
  uintptr_t * D.11950;
  long unsigned int D.11951;
  struct FILE * outfile.134;
  void * obj.135;
  void * parent.136;
  char * D.11957;
  int num_tracked_objects.137;
  int i;

  i = 0;
  goto <D.9576>;
  <D.9575>:
  tracked_objects.133 = tracked_objects;
  D.11948 = (long unsigned int) i;
  D.11949 = D.11948 * 8;
  D.11950 = tracked_objects.133 + D.11949;
  D.11951 = *D.11950;
  if (D.11951 == obj) goto <D.11952>; else goto <D.11953>;
  <D.11952>:
  outfile.134 = outfile;
  obj.135 = (void *) obj;
  parent.136 = (void *) parent;
  D.11957 = cd->name;
  fprintf (outfile.134, "Object %p referenced from %p (%s).\n", obj.135, parent.136, D.11957);
  <D.11953>:
  i = i + 1;
  <D.9576>:
  num_tracked_objects.137 = num_tracked_objects;
  if (i < num_tracked_objects.137) goto <D.9575>; else goto <D.9577>;
  <D.9577>:
}


get_root_name (int rtype)
{
  int D.11959;
  const char * D.11960;

  D.11959 = rtype & 255;
  switch (D.11959) <default: <D.9520>, case 0: <D.9515>, case 1: <D.9516>, case 2: <D.9517>, case 3: <D.9518>, case 4: <D.9519>>
  <D.9515>:
  D.11960 = "stack";
  return D.11960;
  <D.9516>:
  D.11960 = "finalizer";
  return D.11960;
  <D.9517>:
  D.11960 = "handle";
  return D.11960;
  <D.9518>:
  D.11960 = "other";
  return D.11960;
  <D.9519>:
  D.11960 = "misc";
  return D.11960;
  <D.9520>:
  D.11960 = "unknown";
  return D.11960;
}


thread_add_root (struct ThreadContext * ctx, uintptr_t obj, int root_type, uintptr_t extra_info)
{
  long unsigned int D.11962;
  long unsigned int D.11963;
  unsigned int D.11966;
  unsigned int D.11967;
  uintptr_t * D.11970;
  long unsigned int D.11971;
  long unsigned int D.11972;
  void * D.11973;
  uintptr_t * D.11974;
  void * D.11975;
  int * D.11976;
  long unsigned int D.11977;
  void * D.11978;
  long unsigned int D.11979;
  long unsigned int D.11980;
  int * D.11981;
  long unsigned int D.11982;
  uintptr_t * D.11983;
  long unsigned int D.11984;
  long unsigned int D.11985;
  long unsigned int D.11986;
  uintptr_t * D.11987;

  D.11962 = ctx->num_roots;
  D.11963 = ctx->size_roots;
  if (D.11962 == D.11963) goto <D.11964>; else goto <D.11965>;
  <D.11964>:
  {
    int new_size;

    D.11963 = ctx->size_roots;
    D.11966 = (unsigned int) D.11963;
    D.11967 = D.11966 * 2;
    new_size = (int) D.11967;
    if (new_size == 0) goto <D.11968>; else goto <D.11969>;
    <D.11968>:
    new_size = 4;
    <D.11969>:
    D.11970 = ctx->roots;
    D.11971 = (long unsigned int) new_size;
    D.11972 = D.11971 * 8;
    D.11973 = realloc (D.11970, D.11972);
    ctx->roots = D.11973;
    D.11974 = ctx->roots_extra;
    D.11971 = (long unsigned int) new_size;
    D.11972 = D.11971 * 8;
    D.11975 = realloc (D.11974, D.11972);
    ctx->roots_extra = D.11975;
    D.11976 = ctx->roots_types;
    D.11971 = (long unsigned int) new_size;
    D.11977 = D.11971 * 4;
    D.11978 = realloc (D.11976, D.11977);
    ctx->roots_types = D.11978;
    D.11979 = (long unsigned int) new_size;
    ctx->size_roots = D.11979;
  }
  <D.11965>:
  D.11976 = ctx->roots_types;
  D.11962 = ctx->num_roots;
  D.11980 = D.11962 * 4;
  D.11981 = D.11976 + D.11980;
  *D.11981 = root_type;
  D.11974 = ctx->roots_extra;
  D.11962 = ctx->num_roots;
  D.11982 = D.11962 * 8;
  D.11983 = D.11974 + D.11982;
  *D.11983 = extra_info;
  D.11970 = ctx->roots;
  D.11962 = ctx->num_roots;
  D.11984 = D.11962;
  D.11985 = D.11984 + 1;
  ctx->num_roots = D.11985;
  D.11986 = D.11984 * 8;
  D.11987 = D.11970 + D.11986;
  *D.11987 = obj;
}


heap_shot_resolve_reverse_refs (struct HeapShot * hs)
{
  struct HeapObjectDesc * * D.11988;
  long unsigned int D.11989;
  struct HeapObjectDesc * * D.11990;
  long unsigned int D.11993;
  struct HeapClassDesc * D.11994;
  long unsigned int D.11995;
  struct HeapObjectDesc * * D.11996;
  struct HeapObjectDesc * D.11997;
  struct HeapClassDesc * D.11998;
  long unsigned int D.11999;
  long unsigned int D.12000;
  uintptr_t i;

  i = 0;
  goto <D.9221>;
  <D.9220>:
  {
    uintptr_t r;
    struct HeapObjectDesc * ho;

    D.11988 = hs->objects_hash;
    D.11989 = i * 8;
    D.11990 = D.11988 + D.11989;
    ho = *D.11990;
    if (ho == 0B) goto <D.11991>; else goto <D.11992>;
    <D.11991>:
    // predicted unlikely by continue predictor.
    goto <D.9215>;
    <D.11992>:
    r = 0;
    goto <D.9218>;
    <D.9217>:
    {
      uintptr_t oi;

      D.11993 = ho->refs[r];
      oi = heap_shot_find_obj_slot (hs, D.11993);
      D.11994 = ho->hklass;
      D.11988 = hs->objects_hash;
      D.11995 = oi * 8;
      D.11996 = D.11988 + D.11995;
      D.11997 = *D.11996;
      D.11998 = D.11997->hklass;
      add_heap_class_rev (D.11994, D.11998);
    }
    r = r + 1;
    <D.9218>:
    D.11999 = ho->num_refs;
    if (D.11999 > r) goto <D.9217>; else goto <D.9219>;
    <D.9219>:
  }
  <D.9215>:
  i = i + 1;
  <D.9221>:
  D.12000 = hs->objects_hash_size;
  if (D.12000 > i) goto <D.9220>; else goto <D.9222>;
  <D.9222>:
}


add_heap_class_rev (struct HeapClassDesc * from, struct HeapClassDesc * to)
{
  int D.12002;
  int D.12003;
  int D.12004;
  int D.12007;
  long unsigned int D.12010;
  long unsigned int D.12011;
  struct HeapClassRevRef * D.12012;
  long unsigned int D.12013;
  struct HeapClassRevRef * D.12014;
  struct HeapClassDesc * D.12015;
  long unsigned int D.12018;
  long unsigned int D.12019;
  int D.12022;
  int D.12023;
  uintptr_t i;

  D.12002 = to->rev_count;
  D.12003 = D.12002 * 2;
  D.12004 = to->rev_hash_size;
  if (D.12003 >= D.12004) goto <D.12005>; else goto <D.12006>;
  <D.12005>:
  {
    struct HeapClassRevRef * n;
    uintptr_t old_size;

    D.12004 = to->rev_hash_size;
    old_size = (uintptr_t) D.12004;
    D.12004 = to->rev_hash_size;
    D.12007 = D.12004 * 2;
    to->rev_hash_size = D.12007;
    D.12004 = to->rev_hash_size;
    if (D.12004 == 0) goto <D.12008>; else goto <D.12009>;
    <D.12008>:
    to->rev_hash_size = 4;
    <D.12009>:
    D.12004 = to->rev_hash_size;
    D.12010 = (long unsigned int) D.12004;
    D.12011 = D.12010 * 16;
    n = calloc (D.12011, 1);
    i = 0;
    goto <D.9104>;
    <D.9103>:
    D.12012 = to->rev_hash;
    D.12013 = i * 16;
    D.12014 = D.12012 + D.12013;
    D.12015 = D.12014->klass;
    if (D.12015 != 0B) goto <D.12016>; else goto <D.12017>;
    <D.12016>:
    D.12004 = to->rev_hash_size;
    D.12018 = (long unsigned int) D.12004;
    D.12012 = to->rev_hash;
    D.12013 = i * 16;
    D.12014 = D.12012 + D.12013;
    D.12015 = D.12014->klass;
    D.12012 = to->rev_hash;
    D.12013 = i * 16;
    D.12014 = D.12012 + D.12013;
    D.12019 = D.12014->count;
    add_rev_class_hashed (n, D.12018, D.12015, D.12019);
    <D.12017>:
    i = i + 1;
    <D.9104>:
    if (i < old_size) goto <D.9103>; else goto <D.9105>;
    <D.9105>:
    D.12012 = to->rev_hash;
    if (D.12012 != 0B) goto <D.12020>; else goto <D.12021>;
    <D.12020>:
    D.12012 = to->rev_hash;
    free (D.12012);
    <D.12021>:
    to->rev_hash = n;
  }
  <D.12006>:
  D.12012 = to->rev_hash;
  D.12004 = to->rev_hash_size;
  D.12018 = (long unsigned int) D.12004;
  D.12022 = add_rev_class_hashed (D.12012, D.12018, from, 1);
  D.12002 = to->rev_count;
  D.12023 = D.12002 + D.12022;
  to->rev_count = D.12023;
}


add_rev_class_hashed (struct HeapClassRevRef * rev_hash, uintptr_t size, struct HeapClassDesc * hklass, uint64_t value)
{
  struct ClassDesc * D.12025;
  long int D.12026;
  long int D.12027;
  long unsigned int D.12028;
  long unsigned int D.12031;
  struct HeapClassRevRef * D.12032;
  struct HeapClassDesc * D.12033;
  long unsigned int D.12036;
  long unsigned int D.12037;
  int D.12038;
  struct ClassDesc * D.12043;
  uintptr_t i;
  uintptr_t start_pos;
  static const char __PRETTY_FUNCTION__[21] = "add_rev_class_hashed";

  D.12025 = hklass->klass;
  D.12026 = D.12025->klass;
  D.12027 = D.12026 >> 2;
  D.12028 = (long unsigned int) D.12027;
  start_pos = D.12028 % size;
  if (start_pos >= size) goto <D.12029>; else goto <D.12030>;
  <D.12029>:
  __assert_fail ("start_pos < size", "decode.c", 573, &__PRETTY_FUNCTION__);
  <D.12030>:
  i = start_pos;
  <D.9094>:
  D.12031 = i * 16;
  D.12032 = rev_hash + D.12031;
  D.12033 = D.12032->klass;
  if (D.12033 == hklass) goto <D.12034>; else goto <D.12035>;
  <D.12034>:
  D.12031 = i * 16;
  D.12032 = rev_hash + D.12031;
  D.12031 = i * 16;
  D.12032 = rev_hash + D.12031;
  D.12036 = D.12032->count;
  D.12037 = D.12036 + value;
  D.12032->count = D.12037;
  D.12038 = 0;
  return D.12038;
  <D.12035>:
  D.12031 = i * 16;
  D.12032 = rev_hash + D.12031;
  D.12033 = D.12032->klass;
  if (D.12033 == 0B) goto <D.12039>; else goto <D.12040>;
  <D.12039>:
  D.12031 = i * 16;
  D.12032 = rev_hash + D.12031;
  D.12032->klass = hklass;
  D.12031 = i * 16;
  D.12032 = rev_hash + D.12031;
  D.12031 = i * 16;
  D.12032 = rev_hash + D.12031;
  D.12036 = D.12032->count;
  D.12037 = D.12036 + value;
  D.12032->count = D.12037;
  start_pos = 0;
  i = 0;
  goto <D.9092>;
  <D.9091>:
  D.12031 = i * 16;
  D.12032 = rev_hash + D.12031;
  D.12033 = D.12032->klass;
  if (D.12033 != 0B) goto <D.12041>; else goto <D.12042>;
  <D.12041>:
  D.12031 = i * 16;
  D.12032 = rev_hash + D.12031;
  D.12033 = D.12032->klass;
  D.12043 = D.12033->klass;
  D.12025 = hklass->klass;
  if (D.12043 == D.12025) goto <D.12044>; else goto <D.12045>;
  <D.12044>:
  start_pos = start_pos + 1;
  <D.12045>:
  <D.12042>:
  i = i + 1;
  <D.9092>:
  if (i < size) goto <D.9091>; else goto <D.9093>;
  <D.9093>:
  if (start_pos != 1) goto <D.12046>; else goto <D.12047>;
  <D.12046>:
  __assert_fail ("start_pos == 1", "decode.c", 586, &__PRETTY_FUNCTION__);
  <D.12047>:
  D.12038 = 1;
  return D.12038;
  <D.12040>:
  i = i + 1;
  if (i == size) goto <D.12048>; else goto <D.12049>;
  <D.12048>:
  i = 0;
  <D.12049>:
  if (i != start_pos) goto <D.9094>; else goto <D.9095>;
  <D.9095>:
  printf ("failed revref store\n");
  D.12038 = 0;
  return D.12038;
}


heap_shot_mark_objects (struct HeapShot * hs)
{
  uintptr_t * D.12051;
  long unsigned int D.12052;
  uintptr_t * D.12053;
  long unsigned int D.12054;
  struct HeapObjectDesc * * D.12057;
  long unsigned int D.12058;
  struct HeapObjectDesc * * D.12059;
  int * D.12060;
  long unsigned int D.12061;
  int * D.12062;
  int D.12063;
  int D.12064;
  long unsigned int D.12067;
  long unsigned int D.12068;
  long unsigned int D.12069;
  long unsigned int D.12070;
  long unsigned int D.12071;
  int debug.138;
  long unsigned int D.12075;
  struct FILE * outfile.139;
  void * D.12081;
  uintptr_t * D.12082;
  uintptr_t * D.12083;
  long unsigned int D.12084;
  long int D.12085;
  struct ClassDesc * D.12086;
  char * D.12087;
  unsigned char * D.12088;
  unsigned char D.12089;
  unsigned char iftmp.140;
  long unsigned int D.12093;
  unsigned char * D.12097;
  unsigned char D.12098;
  struct HeapObjectDesc * * D.12101;
  long unsigned int D.12102;
  void * D.12105;
  unsigned char iftmp.141;
  long unsigned int D.12109;
  struct HeapObjectDesc * D.12113;
  struct HeapClassDesc * D.12118;
  struct ClassDesc * D.12119;
  char * D.12120;
  long unsigned int D.12121;
  uintptr_t i;
  uintptr_t oi;
  uintptr_t r;
  unsigned char * marks;
  struct HeapObjectDesc * obj;
  struct HeapObjectDesc * ref;
  int marked_some;
  uintptr_t num_marked;
  uintptr_t num_unmarked;

  num_marked = 0;
  i = 0;
  goto <D.9238>;
  <D.9237>:
  {
    struct HeapClassDesc * cd;

    D.12051 = hs->roots;
    D.12052 = i * 8;
    D.12053 = D.12051 + D.12052;
    D.12054 = *D.12053;
    oi = heap_shot_find_obj_slot (hs, D.12054);
    if (oi == 18446744073709551615) goto <D.12055>; else goto <D.12056>;
    <D.12055>:
    // predicted unlikely by continue predictor.
    goto <D.9236>;
    <D.12056>:
    D.12057 = hs->objects_hash;
    D.12058 = oi * 8;
    D.12059 = D.12057 + D.12058;
    obj = *D.12059;
    cd = obj->hklass;
    D.12060 = hs->roots_types;
    D.12061 = i * 4;
    D.12062 = D.12060 + D.12061;
    D.12063 = *D.12062;
    D.12064 = D.12063 & 256;
    if (D.12064 != 0) goto <D.12065>; else goto <D.12066>;
    <D.12065>:
    D.12067 = cd->pinned_references;
    D.12068 = D.12067 + 1;
    cd->pinned_references = D.12068;
    <D.12066>:
    D.12069 = cd->root_references;
    D.12070 = D.12069 + 1;
    cd->root_references = D.12070;
  }
  <D.9236>:
  i = i + 1;
  <D.9238>:
  D.12071 = hs->num_roots;
  if (D.12071 > i) goto <D.9237>; else goto <D.9239>;
  <D.9239>:
  debug.138 = debug;
  if (debug.138 == 0) goto <D.12073>; else goto <D.12074>;
  <D.12073>:
  return;
  <D.12074>:
  D.12075 = hs->objects_hash_size;
  marks = calloc (D.12075, 1);
  if (marks == 0B) goto <D.12076>; else goto <D.12077>;
  <D.12076>:
  return;
  <D.12077>:
  i = 0;
  goto <D.9242>;
  <D.9241>:
  D.12051 = hs->roots;
  D.12052 = i * 8;
  D.12053 = D.12051 + D.12052;
  D.12054 = *D.12053;
  oi = heap_shot_find_obj_slot (hs, D.12054);
  if (oi == 18446744073709551615) goto <D.12078>; else goto <D.12079>;
  <D.12078>:
  outfile.139 = outfile;
  D.12060 = hs->roots_types;
  D.12061 = i * 4;
  D.12062 = D.12060 + D.12061;
  D.12063 = *D.12062;
  D.12051 = hs->roots;
  D.12052 = i * 8;
  D.12053 = D.12051 + D.12052;
  D.12054 = *D.12053;
  D.12081 = (void *) D.12054;
  D.12082 = hs->roots_extra;
  D.12052 = i * 8;
  D.12083 = D.12082 + D.12052;
  D.12084 = *D.12083;
  D.12085 = (long int) D.12084;
  D.12086 = lookup_class (D.12085);
  D.12087 = D.12086->name;
  fprintf (outfile.139, "root type 0x%x for obj %p (%s) not found in heap\n", D.12063, D.12081, D.12087);
  // predicted unlikely by continue predictor.
  goto <D.9240>;
  <D.12079>:
  D.12057 = hs->objects_hash;
  D.12058 = oi * 8;
  D.12059 = D.12057 + D.12058;
  obj = *D.12059;
  D.12088 = marks + oi;
  D.12089 = *D.12088;
  if (D.12089 == 0) goto <D.12090>; else goto <D.12091>;
  <D.12090>:
  D.12088 = marks + oi;
  D.12093 = obj->num_refs;
  if (D.12093 != 0) goto <D.12094>; else goto <D.12095>;
  <D.12094>:
  iftmp.140 = 1;
  goto <D.12096>;
  <D.12095>:
  iftmp.140 = 2;
  <D.12096>:
  *D.12088 = iftmp.140;
  num_marked = num_marked + 1;
  <D.12091>:
  <D.9240>:
  i = i + 1;
  <D.9242>:
  D.12071 = hs->num_roots;
  if (D.12071 > i) goto <D.9241>; else goto <D.9243>;
  <D.9243>:
  marked_some = 1;
  goto <D.9253>;
  <D.9252>:
  marked_some = 0;
  i = 0;
  goto <D.9250>;
  <D.9249>:
  D.12097 = marks + i;
  D.12098 = *D.12097;
  if (D.12098 != 1) goto <D.12099>; else goto <D.12100>;
  <D.12099>:
  // predicted unlikely by continue predictor.
  goto <D.9244>;
  <D.12100>:
  D.12097 = marks + i;
  *D.12097 = 2;
  D.12057 = hs->objects_hash;
  D.12052 = i * 8;
  D.12101 = D.12057 + D.12052;
  obj = *D.12101;
  r = 0;
  goto <D.9247>;
  <D.9246>:
  D.12102 = obj->refs[r];
  oi = heap_shot_find_obj_slot (hs, D.12102);
  if (oi == 18446744073709551615) goto <D.12103>; else goto <D.12104>;
  <D.12103>:
  outfile.139 = outfile;
  D.12102 = obj->refs[r];
  D.12105 = (void *) D.12102;
  fprintf (outfile.139, "referenced obj %p not found in heap\n", D.12105);
  // predicted unlikely by continue predictor.
  goto <D.9245>;
  <D.12104>:
  D.12057 = hs->objects_hash;
  D.12058 = oi * 8;
  D.12059 = D.12057 + D.12058;
  ref = *D.12059;
  D.12088 = marks + oi;
  D.12089 = *D.12088;
  if (D.12089 == 0) goto <D.12106>; else goto <D.12107>;
  <D.12106>:
  D.12088 = marks + oi;
  D.12109 = ref->num_refs;
  if (D.12109 != 0) goto <D.12110>; else goto <D.12111>;
  <D.12110>:
  iftmp.141 = 1;
  goto <D.12112>;
  <D.12111>:
  iftmp.141 = 2;
  <D.12112>:
  *D.12088 = iftmp.141;
  <D.12107>:
  <D.9245>:
  r = r + 1;
  <D.9247>:
  D.12093 = obj->num_refs;
  if (D.12093 > r) goto <D.9246>; else goto <D.9248>;
  <D.9248>:
  marked_some = marked_some + 1;
  <D.9244>:
  i = i + 1;
  <D.9250>:
  D.12075 = hs->objects_hash_size;
  if (D.12075 > i) goto <D.9249>; else goto <D.9251>;
  <D.9251>:
  <D.9253>:
  if (marked_some != 0) goto <D.9252>; else goto <D.9254>;
  <D.9254>:
  num_unmarked = 0;
  i = 0;
  goto <D.9256>;
  <D.9255>:
  D.12057 = hs->objects_hash;
  D.12052 = i * 8;
  D.12101 = D.12057 + D.12052;
  D.12113 = *D.12101;
  if (D.12113 != 0B) goto <D.12114>; else goto <D.12115>;
  <D.12114>:
  D.12097 = marks + i;
  D.12098 = *D.12097;
  if (D.12098 == 0) goto <D.12116>; else goto <D.12117>;
  <D.12116>:
  num_unmarked = num_unmarked + 1;
  outfile.139 = outfile;
  D.12057 = hs->objects_hash;
  D.12052 = i * 8;
  D.12101 = D.12057 + D.12052;
  D.12113 = *D.12101;
  D.12057 = hs->objects_hash;
  D.12052 = i * 8;
  D.12101 = D.12057 + D.12052;
  D.12113 = *D.12101;
  D.12118 = D.12113->hklass;
  D.12119 = D.12118->klass;
  D.12120 = D.12119->name;
  fprintf (outfile.139, "object %p (%s) unmarked\n", D.12113, D.12120);
  <D.12117>:
  <D.12115>:
  i = i + 1;
  <D.9256>:
  D.12075 = hs->objects_hash_size;
  if (D.12075 > i) goto <D.9255>; else goto <D.9257>;
  <D.9257>:
  outfile.139 = outfile;
  D.12121 = hs->objects_count;
  fprintf (outfile.139, "Total unmarked: %d/%d\n", num_unmarked, D.12121);
  free (marks);
}


heap_shot_free_objects (struct HeapShot * hs)
{
  struct HeapObjectDesc * * D.12127;
  long unsigned int D.12128;
  struct HeapObjectDesc * * D.12129;
  long unsigned int D.12132;
  uintptr_t i;

  i = 0;
  goto <D.9264>;
  <D.9263>:
  {
    struct HeapObjectDesc * ho;

    D.12127 = hs->objects_hash;
    D.12128 = i * 8;
    D.12129 = D.12127 + D.12128;
    ho = *D.12129;
    if (ho != 0B) goto <D.12130>; else goto <D.12131>;
    <D.12130>:
    free (ho);
    <D.12131>:
  }
  i = i + 1;
  <D.9264>:
  D.12132 = hs->objects_hash_size;
  if (D.12132 > i) goto <D.9263>; else goto <D.9265>;
  <D.9265>:
  D.12127 = hs->objects_hash;
  if (D.12127 != 0B) goto <D.12133>; else goto <D.12134>;
  <D.12133>:
  D.12127 = hs->objects_hash;
  free (D.12127);
  <D.12134>:
  hs->objects_hash = 0B;
  hs->objects_hash_size = 0;
  hs->objects_count = 0;
}


new_heap_shot (uint64_t timestamp)
{
  int D.12135;
  long unsigned int D.12136;
  void * D.12137;
  int num_heap_shots.142;
  int num_heap_shots.143;
  struct HeapShot * heap_shots.144;
  struct HeapShot * D.12141;
  struct HeapShot * hs;

  hs = calloc (96, 1);
  hs->hash_size = 4;
  D.12135 = hs->hash_size;
  D.12136 = (long unsigned int) D.12135;
  D.12137 = calloc (8, D.12136);
  hs->class_hash = D.12137;
  hs->timestamp = timestamp;
  num_heap_shots.142 = num_heap_shots;
  num_heap_shots.143 = num_heap_shots.142 + 1;
  num_heap_shots = num_heap_shots.143;
  heap_shots.144 = heap_shots;
  hs->next = heap_shots.144;
  heap_shots = hs;
  D.12141 = hs;
  return D.12141;
}


lookup_monitor (uintptr_t objid)
{
  long unsigned int D.12143;
  long unsigned int D.12144;
  long unsigned int D.12145;
  long unsigned int D.12147;
  struct MonitorDesc * D.12150;
  int num_monitors.145;
  int num_monitors.146;
  struct MonitorDesc * D.12153;
  int slot;
  struct MonitorDesc * cd;

  D.12143 = objid >> 3;
  D.12144 = D.12143 & 65535;
  D.12145 = D.12144 % 31;
  slot = (int) D.12145;
  cd = monitor_hash[slot];
  goto <D.9495>;
  <D.9494>:
  cd = cd->next;
  <D.9495>:
  if (cd != 0B) goto <D.12146>; else goto <D.9496>;
  <D.12146>:
  D.12147 = cd->objid;
  if (D.12147 != objid) goto <D.9494>; else goto <D.9496>;
  <D.9496>:
  if (cd == 0B) goto <D.12148>; else goto <D.12149>;
  <D.12148>:
  cd = calloc (56, 1);
  cd->objid = objid;
  D.12150 = monitor_hash[slot];
  cd->next = D.12150;
  monitor_hash[slot] = cd;
  num_monitors.145 = num_monitors;
  num_monitors.146 = num_monitors.145 + 1;
  num_monitors = num_monitors.146;
  <D.12149>:
  D.12153 = cd;
  return D.12153;
}


monitor_ev_name (int ev)
{
  const char * D.12155;

  switch (ev) <default: <D.9503>, case 1: <D.9500>, case 2: <D.9501>, case 3: <D.9502>>
  <D.9500>:
  D.12155 = "contended";
  return D.12155;
  <D.9501>:
  D.12155 = "acquired";
  return D.12155;
  <D.9502>:
  D.12155 = "not taken";
  return D.12155;
  <D.9503>:
  D.12155 = "invalid";
  return D.12155;
}


clause_name (int type)
{
  const char * D.12157;

  switch (type) <default: <D.9477>, case 0: <D.9473>, case 1: <D.9474>, case 2: <D.9475>, case 4: <D.9476>>
  <D.9473>:
  D.12157 = "catch";
  return D.12157;
  <D.9474>:
  D.12157 = "filter";
  return D.12157;
  <D.9475>:
  D.12157 = "finally";
  return D.12157;
  <D.9476>:
  D.12157 = "fault";
  return D.12157;
  <D.9477>:
  D.12157 = "invalid";
  return D.12157;
}


lookup_method (intptr_t method)
{
  long int D.12159;
  long int D.12160;
  long int D.12161;
  long int D.12163;
  void * method.147;
  struct MethodDesc * D.12167;
  int slot;
  struct MethodDesc * cd;

  D.12159 = method >> 2;
  D.12160 = D.12159 & 65535;
  D.12161 = D.12160 % 9371;
  slot = (int) D.12161;
  cd = method_hash[slot];
  goto <D.8931>;
  <D.8930>:
  cd = cd->next;
  <D.8931>:
  if (cd != 0B) goto <D.12162>; else goto <D.8932>;
  <D.12162>:
  D.12163 = cd->method;
  if (D.12163 != method) goto <D.8930>; else goto <D.8932>;
  <D.8932>:
  if (cd == 0B) goto <D.12164>; else goto <D.12165>;
  <D.12164>:
  {
    char buf[128];

    try
      {
        method.147 = (void *) method;
        snprintf (&buf, 128, "unknown method %p", method.147);
        D.12167 = add_method (method, &buf, 0, 0);
        return D.12167;
      }
    finally
      {
        buf = {CLOBBER};
      }
  }
  <D.12165>:
  D.12167 = cd;
  return D.12167;
}


decode_bt (struct MethodDesc * * sframes, int * size, unsigned char * p, unsigned char * * endp, intptr_t ptr_base)
{
  unsigned char * p.148;
  long unsigned int D.12173;
  long unsigned int D.12174;
  struct MethodDesc * * D.12177;
  int D.12178;
  long unsigned int D.12181;
  long unsigned int D.12182;
  long unsigned int D.12184;
  long unsigned int D.12185;
  struct MethodDesc * * D.12186;
  long int D.12187;
  struct MethodDesc * D.12188;
  struct MethodDesc * * frames;
  int i;
  int flags;
  int count;

  p.148 = p;
  D.12173 = decode_uleb128 (p.148, &p);
  flags = (int) D.12173;
  p.148 = p;
  D.12174 = decode_uleb128 (p.148, &p);
  count = (int) D.12174;
  if (flags != 0) goto <D.12175>; else goto <D.12176>;
  <D.12175>:
  D.12177 = 0B;
  return D.12177;
  <D.12176>:
  D.12178 = *size;
  if (D.12178 < count) goto <D.12179>; else goto <D.12180>;
  <D.12179>:
  D.12181 = (long unsigned int) count;
  D.12182 = D.12181 * 8;
  frames = malloc (D.12182);
  goto <D.12183>;
  <D.12180>:
  frames = sframes;
  <D.12183>:
  i = 0;
  goto <D.9534>;
  <D.9533>:
  {
    intptr_t ptrdiff;

    p.148 = p;
    ptrdiff = decode_sleb128 (p.148, &p);
    D.12184 = (long unsigned int) i;
    D.12185 = D.12184 * 8;
    D.12186 = frames + D.12185;
    D.12187 = ptr_base + ptrdiff;
    D.12188 = lookup_method (D.12187);
    *D.12186 = D.12188;
  }
  i = i + 1;
  <D.9534>:
  if (i < count) goto <D.9533>; else goto <D.9535>;
  <D.9535>:
  *size = count;
  p.148 = p;
  *endp = p.148;
  D.12177 = frames;
  return D.12177;
}


add_trace_methods (struct MethodDesc * * methods, int count, struct TraceDesc * trace, uint64_t value)
{
  int collect_traces.149;
  struct BackTrace * D.12197;
  int trace_max.150;
  struct BackTrace * bt;

  collect_traces.149 = collect_traces;
  if (collect_traces.149 == 0) goto <D.12195>; else goto <D.12196>;
  <D.12195>:
  D.12197 = 0B;
  return D.12197;
  <D.12196>:
  trace_max.150 = trace_max;
  if (count > trace_max.150) goto <D.12199>; else goto <D.12200>;
  <D.12199>:
  count = trace_max;
  <D.12200>:
  bt = add_backtrace (count, methods);
  add_trace_bt (bt, trace, value);
  D.12197 = bt;
  return D.12197;
}


add_backtrace (int count, struct MethodDesc * * methods)
{
  int D.12203;
  unsigned int D.12204;
  unsigned int hash.151;
  int D.12208;
  struct BackTrace * D.12211;
  int D.12212;
  long unsigned int D.12213;
  long unsigned int D.12214;
  long unsigned int D.12215;
  struct BackTrace * D.12216;
  int next_backtrace.152;
  int num_backtraces.153;
  int num_backtraces.154;
  struct BackTrace * * backtraces.155;
  long unsigned int D.12225;
  long unsigned int D.12226;
  void * backtraces.156;
  int next_backtrace.157;
  int next_backtrace.158;
  int D.12230;
  long unsigned int D.12231;
  long unsigned int D.12232;
  struct BackTrace * * D.12233;
  long unsigned int D.12234;
  long unsigned int D.12235;
  struct MethodDesc * * D.12236;
  struct MethodDesc * D.12237;
  int hash;
  int slot;
  struct BackTrace * bt;

  hash = hash_backtrace (count, methods);
  D.12203 = hash & 65535;
  slot = D.12203 % 9371;
  bt = backtrace_hash[slot];
  goto <D.9301>;
  <D.9300>:
  D.12204 = bt->hash;
  hash.151 = (unsigned int) hash;
  if (D.12204 == hash.151) goto <D.12206>; else goto <D.12207>;
  <D.12206>:
  D.12208 = compare_backtrace (bt, count, methods);
  if (D.12208 != 0) goto <D.12209>; else goto <D.12210>;
  <D.12209>:
  D.12211 = bt;
  return D.12211;
  <D.12210>:
  <D.12207>:
  bt = bt->next;
  <D.9301>:
  if (bt != 0B) goto <D.9300>; else goto <D.9302>;
  <D.9302>:
  D.12212 = count + -1;
  D.12213 = (long unsigned int) D.12212;
  D.12214 = D.12213 + 4;
  D.12215 = D.12214 * 8;
  bt = malloc (D.12215);
  D.12216 = backtrace_hash[slot];
  bt->next = D.12216;
  backtrace_hash[slot] = bt;
  next_backtrace.152 = next_backtrace;
  num_backtraces.153 = num_backtraces;
  if (next_backtrace.152 == num_backtraces.153) goto <D.12219>; else goto <D.12220>;
  <D.12219>:
  num_backtraces.153 = num_backtraces;
  num_backtraces.154 = num_backtraces.153 * 2;
  num_backtraces = num_backtraces.154;
  num_backtraces.153 = num_backtraces;
  if (num_backtraces.153 == 0) goto <D.12222>; else goto <D.12223>;
  <D.12222>:
  num_backtraces = 16;
  <D.12223>:
  backtraces.155 = backtraces;
  num_backtraces.153 = num_backtraces;
  D.12225 = (long unsigned int) num_backtraces.153;
  D.12226 = D.12225 * 8;
  backtraces.156 = realloc (backtraces.155, D.12226);
  backtraces = backtraces.156;
  <D.12220>:
  next_backtrace.152 = next_backtrace;
  next_backtrace.157 = next_backtrace.152;
  next_backtrace.158 = next_backtrace.157 + 1;
  next_backtrace = next_backtrace.158;
  bt->id = next_backtrace.157;
  backtraces.155 = backtraces;
  D.12230 = bt->id;
  D.12231 = (long unsigned int) D.12230;
  D.12232 = D.12231 * 8;
  D.12233 = backtraces.155 + D.12232;
  *D.12233 = bt;
  bt->count = count;
  hash.151 = (unsigned int) hash;
  bt->hash = hash.151;
  slot = 0;
  goto <D.9304>;
  <D.9303>:
  D.12234 = (long unsigned int) slot;
  D.12235 = D.12234 * 8;
  D.12236 = methods + D.12235;
  D.12237 = *D.12236;
  bt->methods[slot] = D.12237;
  slot = slot + 1;
  <D.9304>:
  if (slot < count) goto <D.9303>; else goto <D.9305>;
  <D.9305>:
  D.12211 = bt;
  return D.12211;
}


hash_backtrace (int count, struct MethodDesc * * methods)
{
  int D.12241;
  int D.12242;
  unsigned int D.12243;
  long unsigned int D.12244;
  long unsigned int D.12245;
  struct MethodDesc * * D.12246;
  struct MethodDesc * D.12247;
  long int D.12248;
  unsigned int D.12249;
  unsigned int D.12250;
  int D.12251;
  int hash;
  int i;

  hash = count;
  i = 0;
  goto <D.9282>;
  <D.9281>:
  D.12241 = hash << 5;
  D.12242 = D.12241 - hash;
  D.12243 = (unsigned int) D.12242;
  D.12244 = (long unsigned int) i;
  D.12245 = D.12244 * 8;
  D.12246 = methods + D.12245;
  D.12247 = *D.12246;
  D.12248 = D.12247->method;
  D.12249 = (unsigned int) D.12248;
  D.12250 = D.12243 + D.12249;
  hash = (int) D.12250;
  i = i + 1;
  <D.9282>:
  if (i < count) goto <D.9281>; else goto <D.9283>;
  <D.9283>:
  D.12251 = hash;
  return D.12251;
}


compare_backtrace (struct BackTrace * bt, int count, struct MethodDesc * * methods)
{
  int D.12253;
  int D.12256;
  long unsigned int D.12257;
  long unsigned int D.12258;
  struct MethodDesc * * D.12259;
  struct MethodDesc * D.12260;
  struct MethodDesc * D.12261;
  int i;

  D.12253 = bt->count;
  if (D.12253 != count) goto <D.12254>; else goto <D.12255>;
  <D.12254>:
  D.12256 = 0;
  return D.12256;
  <D.12255>:
  i = 0;
  goto <D.9291>;
  <D.9290>:
  D.12257 = (long unsigned int) i;
  D.12258 = D.12257 * 8;
  D.12259 = methods + D.12258;
  D.12260 = *D.12259;
  D.12261 = bt->methods[i];
  if (D.12260 != D.12261) goto <D.12262>; else goto <D.12263>;
  <D.12262>:
  D.12256 = 0;
  return D.12256;
  <D.12263>:
  i = i + 1;
  <D.9291>:
  if (i < count) goto <D.9290>; else goto <D.9292>;
  <D.9292>:
  D.12256 = 1;
  return D.12256;
}


add_trace_bt (struct BackTrace * bt, struct TraceDesc * trace, uint64_t value)
{
  int collect_traces.159;
  int D.12268;
  int D.12269;
  int D.12270;
  int D.12273;
  long unsigned int D.12276;
  long unsigned int D.12277;
  struct CallContext * D.12278;
  long unsigned int D.12279;
  long unsigned int D.12280;
  struct CallContext * D.12281;
  struct BackTrace * D.12282;
  long unsigned int D.12285;
  int D.12288;
  int D.12289;
  int i;

  collect_traces.159 = collect_traces;
  if (collect_traces.159 == 0) goto <D.12266>; else goto <D.12267>;
  <D.12266>:
  return;
  <D.12267>:
  D.12268 = trace->count;
  D.12269 = D.12268 * 2;
  D.12270 = trace->size;
  if (D.12269 >= D.12270) goto <D.12271>; else goto <D.12272>;
  <D.12271>:
  {
    struct CallContext * n;
    int old_size;

    old_size = trace->size;
    D.12270 = trace->size;
    D.12273 = D.12270 * 2;
    trace->size = D.12273;
    D.12270 = trace->size;
    if (D.12270 == 0) goto <D.12274>; else goto <D.12275>;
    <D.12274>:
    trace->size = 4;
    <D.12275>:
    D.12270 = trace->size;
    D.12276 = (long unsigned int) D.12270;
    D.12277 = D.12276 * 16;
    n = calloc (D.12277, 1);
    i = 0;
    goto <D.9388>;
    <D.9387>:
    D.12278 = trace->traces;
    D.12279 = (long unsigned int) i;
    D.12280 = D.12279 * 16;
    D.12281 = D.12278 + D.12280;
    D.12282 = D.12281->bt;
    if (D.12282 != 0B) goto <D.12283>; else goto <D.12284>;
    <D.12283>:
    D.12270 = trace->size;
    D.12278 = trace->traces;
    D.12279 = (long unsigned int) i;
    D.12280 = D.12279 * 16;
    D.12281 = D.12278 + D.12280;
    D.12282 = D.12281->bt;
    D.12278 = trace->traces;
    D.12279 = (long unsigned int) i;
    D.12280 = D.12279 * 16;
    D.12281 = D.12278 + D.12280;
    D.12285 = D.12281->count;
    add_trace_hashed (n, D.12270, D.12282, D.12285);
    <D.12284>:
    i = i + 1;
    <D.9388>:
    if (i < old_size) goto <D.9387>; else goto <D.9389>;
    <D.9389>:
    D.12278 = trace->traces;
    if (D.12278 != 0B) goto <D.12286>; else goto <D.12287>;
    <D.12286>:
    D.12278 = trace->traces;
    free (D.12278);
    <D.12287>:
    trace->traces = n;
  }
  <D.12272>:
  D.12278 = trace->traces;
  D.12270 = trace->size;
  D.12288 = add_trace_hashed (D.12278, D.12270, bt, value);
  D.12268 = trace->count;
  D.12289 = D.12268 + D.12288;
  trace->count = D.12289;
}


add_trace_hashed (struct CallContext * traces, int size, struct BackTrace * bt, uint64_t value)
{
  unsigned int D.12292;
  unsigned int size.160;
  long unsigned int D.12294;
  long unsigned int D.12295;
  struct CallContext * D.12296;
  struct BackTrace * D.12297;
  long unsigned int D.12300;
  long unsigned int D.12301;
  int D.12302;
  unsigned int i.161;
  int i;
  unsigned int start_pos;

  D.12292 = bt->hash;
  size.160 = (unsigned int) size;
  start_pos = D.12292 % size.160;
  i = (int) start_pos;
  <D.9377>:
  D.12294 = (long unsigned int) i;
  D.12295 = D.12294 * 16;
  D.12296 = traces + D.12295;
  D.12297 = D.12296->bt;
  if (D.12297 == bt) goto <D.12298>; else goto <D.12299>;
  <D.12298>:
  D.12294 = (long unsigned int) i;
  D.12295 = D.12294 * 16;
  D.12296 = traces + D.12295;
  D.12294 = (long unsigned int) i;
  D.12295 = D.12294 * 16;
  D.12296 = traces + D.12295;
  D.12300 = D.12296->count;
  D.12301 = D.12300 + value;
  D.12296->count = D.12301;
  D.12302 = 0;
  return D.12302;
  <D.12299>:
  D.12294 = (long unsigned int) i;
  D.12295 = D.12294 * 16;
  D.12296 = traces + D.12295;
  D.12297 = D.12296->bt;
  if (D.12297 == 0B) goto <D.12303>; else goto <D.12304>;
  <D.12303>:
  D.12294 = (long unsigned int) i;
  D.12295 = D.12294 * 16;
  D.12296 = traces + D.12295;
  D.12296->bt = bt;
  D.12294 = (long unsigned int) i;
  D.12295 = D.12294 * 16;
  D.12296 = traces + D.12295;
  D.12294 = (long unsigned int) i;
  D.12295 = D.12294 * 16;
  D.12296 = traces + D.12295;
  D.12300 = D.12296->count;
  D.12301 = D.12300 + value;
  D.12296->count = D.12301;
  D.12302 = 1;
  return D.12302;
  <D.12304>:
  i = i + 1;
  if (i == size) goto <D.12305>; else goto <D.12306>;
  <D.12305>:
  i = 0;
  <D.12306>:
  i.161 = (unsigned int) i;
  if (i.161 != start_pos) goto <D.9377>; else goto <D.9378>;
  <D.9378>:
  printf ("failed trace store\n");
  D.12302 = 0;
  return D.12302;
}


add_trace_thread (struct ThreadContext * thread, struct TraceDesc * trace, uint64_t value)
{
  int collect_traces.162;
  struct BackTrace * D.12312;
  int trace_max.163;
  struct MethodDesc * * D.12316;
  int D.12317;
  sizetype D.12318;
  sizetype D.12319;
  sizetype D.12320;
  sizetype D.12321;
  struct MethodDesc * * D.12322;
  struct BackTrace * bt;
  int count;

  count = thread->stack_id;
  collect_traces.162 = collect_traces;
  if (collect_traces.162 == 0) goto <D.12310>; else goto <D.12311>;
  <D.12310>:
  D.12312 = 0B;
  return D.12312;
  <D.12311>:
  trace_max.163 = trace_max;
  if (count > trace_max.163) goto <D.12314>; else goto <D.12315>;
  <D.12314>:
  count = trace_max;
  <D.12315>:
  D.12316 = thread->stack;
  D.12317 = thread->stack_id;
  D.12318 = (sizetype) D.12317;
  D.12319 = (sizetype) count;
  D.12320 = D.12318 - D.12319;
  D.12321 = D.12320 * 8;
  D.12322 = D.12316 + D.12321;
  bt = add_backtrace (count, D.12322);
  add_trace_bt (bt, trace, value);
  D.12312 = bt;
  return D.12312;
}


add_stat_sample (int type, uintptr_t ip)
{
  int num_stat_samples.164;
  int size_stat_samples.165;
  int size_stat_samples.166;
  uintptr_t * stat_samples.167;
  long unsigned int D.12333;
  long unsigned int D.12334;
  void * stat_samples.168;
  int * stat_sample_desc.169;
  long unsigned int D.12337;
  void * stat_sample_desc.170;
  long unsigned int D.12339;
  long unsigned int D.12340;
  uintptr_t * D.12341;
  int num_stat_samples.171;
  int num_stat_samples.172;
  long unsigned int D.12344;
  long unsigned int D.12345;
  int * D.12346;

  num_stat_samples.164 = num_stat_samples;
  size_stat_samples.165 = size_stat_samples;
  if (num_stat_samples.164 == size_stat_samples.165) goto <D.12327>; else goto <D.12328>;
  <D.12327>:
  size_stat_samples.165 = size_stat_samples;
  size_stat_samples.166 = size_stat_samples.165 * 2;
  size_stat_samples = size_stat_samples.166;
  size_stat_samples.165 = size_stat_samples;
  if (size_stat_samples.165 == 0) goto <D.12330>; else goto <D.12331>;
  <D.12330>:
  size_stat_samples = 32;
  <D.12331>:
  stat_samples.167 = stat_samples;
  size_stat_samples.165 = size_stat_samples;
  D.12333 = (long unsigned int) size_stat_samples.165;
  D.12334 = D.12333 * 8;
  stat_samples.168 = realloc (stat_samples.167, D.12334);
  stat_samples = stat_samples.168;
  stat_sample_desc.169 = stat_sample_desc;
  size_stat_samples.165 = size_stat_samples;
  D.12333 = (long unsigned int) size_stat_samples.165;
  D.12337 = D.12333 * 4;
  stat_sample_desc.170 = realloc (stat_sample_desc.169, D.12337);
  stat_sample_desc = stat_sample_desc.170;
  <D.12328>:
  stat_samples.167 = stat_samples;
  num_stat_samples.164 = num_stat_samples;
  D.12339 = (long unsigned int) num_stat_samples.164;
  D.12340 = D.12339 * 8;
  D.12341 = stat_samples.167 + D.12340;
  *D.12341 = ip;
  stat_sample_desc.169 = stat_sample_desc;
  num_stat_samples.164 = num_stat_samples;
  num_stat_samples.171 = num_stat_samples.164;
  num_stat_samples.172 = num_stat_samples.171 + 1;
  num_stat_samples = num_stat_samples.172;
  D.12344 = (long unsigned int) num_stat_samples.171;
  D.12345 = D.12344 * 4;
  D.12346 = stat_sample_desc.169 + D.12345;
  *D.12346 = type;
}


add_unmanaged_symbol (uintptr_t addr, char * name, uintptr_t size)
{
  int usymbols_num.173;
  int usymbols_size.174;
  struct UnmanagedSymbol * * usymbols.175;
  long unsigned int D.12354;
  long unsigned int D.12355;
  void * usymbols.176;
  int usymbols_num.177;
  int usymbols_num.178;
  long unsigned int D.12359;
  long unsigned int D.12360;
  struct UnmanagedSymbol * * D.12361;
  struct UnmanagedSymbol * sym;

  usymbols_num.173 = usymbols_num;
  usymbols_size.174 = usymbols_size;
  if (usymbols_num.173 == usymbols_size.174) goto <D.12349>; else goto <D.12350>;
  <D.12349>:
  {
    int new_size;

    usymbols_size.174 = usymbols_size;
    new_size = usymbols_size.174 * 2;
    if (new_size == 0) goto <D.12351>; else goto <D.12352>;
    <D.12351>:
    new_size = 16;
    <D.12352>:
    usymbols.175 = usymbols;
    D.12354 = (long unsigned int) new_size;
    D.12355 = D.12354 * 8;
    usymbols.176 = realloc (usymbols.175, D.12355);
    usymbols = usymbols.176;
    usymbols_size = new_size;
  }
  <D.12350>:
  sym = calloc (48, 1);
  sym->addr = addr;
  sym->name = name;
  sym->size = size;
  usymbols.175 = usymbols;
  usymbols_num.173 = usymbols_num;
  usymbols_num.177 = usymbols_num.173;
  usymbols_num.178 = usymbols_num.177 + 1;
  usymbols_num = usymbols_num.178;
  D.12359 = (long unsigned int) usymbols_num.177;
  D.12360 = D.12359 * 8;
  D.12361 = usymbols.175 + D.12360;
  *D.12361 = sym;
}


add_unmanaged_binary (uintptr_t addr, char * name, uintptr_t size)
{
  int ubinaries_num.179;
  int ubinaries_size.180;
  struct UnmanagedSymbol * * ubinaries.181;
  long unsigned int D.12369;
  long unsigned int D.12370;
  void * ubinaries.182;
  int ubinaries_num.183;
  int ubinaries_num.184;
  long unsigned int D.12374;
  long unsigned int D.12375;
  struct UnmanagedSymbol * * D.12376;
  struct UnmanagedSymbol * sym;

  ubinaries_num.179 = ubinaries_num;
  ubinaries_size.180 = ubinaries_size;
  if (ubinaries_num.179 == ubinaries_size.180) goto <D.12364>; else goto <D.12365>;
  <D.12364>:
  {
    int new_size;

    ubinaries_size.180 = ubinaries_size;
    new_size = ubinaries_size.180 * 2;
    if (new_size == 0) goto <D.12366>; else goto <D.12367>;
    <D.12366>:
    new_size = 16;
    <D.12367>:
    ubinaries.181 = ubinaries;
    D.12369 = (long unsigned int) new_size;
    D.12370 = D.12369 * 8;
    ubinaries.182 = realloc (ubinaries.181, D.12370);
    ubinaries = ubinaries.182;
    ubinaries_size = new_size;
  }
  <D.12365>:
  sym = calloc (48, 1);
  sym->addr = addr;
  sym->name = name;
  sym->size = size;
  sym->is_binary = 1;
  ubinaries.181 = ubinaries;
  ubinaries_num.179 = ubinaries_num;
  ubinaries_num.183 = ubinaries_num.179;
  ubinaries_num.184 = ubinaries_num.183 + 1;
  ubinaries_num = ubinaries_num.184;
  D.12374 = (long unsigned int) ubinaries_num.183;
  D.12375 = D.12374 * 8;
  D.12376 = ubinaries.181 + D.12375;
  *D.12376 = sym;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.12377;

  D.12377 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.12377;
}


flush_context (struct ProfContext * ctx)
{
  int debug.185;
  struct FILE * outfile.186;
  long int D.12384;
  void * D.12385;
  int D.12386;
  struct MethodDesc * * D.12387;
  long unsigned int D.12388;
  long unsigned int D.12389;
  sizetype D.12390;
  struct MethodDesc * * D.12391;
  struct MethodDesc * D.12392;
  long unsigned int D.12393;
  struct ThreadContext * thread;

  thread = ctx->threads;
  goto <D.9996>;
  <D.9995>:
  goto <D.9993>;
  <D.9992>:
  debug.185 = debug;
  if (debug.185 != 0) goto <D.12381>; else goto <D.12382>;
  <D.12381>:
  outfile.186 = outfile;
  D.12384 = thread->thread_id;
  D.12385 = (void *) D.12384;
  D.12386 = thread->stack_id;
  fprintf (outfile.186, "thread %p has %d items on stack\n", D.12385, D.12386);
  <D.12382>:
  D.12387 = thread->stack;
  D.12386 = thread->stack_id;
  D.12388 = (long unsigned int) D.12386;
  D.12389 = D.12388 * 8;
  D.12390 = D.12389 + 18446744073709551608;
  D.12391 = D.12387 + D.12390;
  D.12392 = *D.12391;
  D.12393 = thread->last_time;
  pop_method (thread, D.12392, D.12393);
  <D.9993>:
  D.12386 = thread->stack_id;
  if (D.12386 != 0) goto <D.9992>; else goto <D.9994>;
  <D.9994>:
  thread = thread->next;
  <D.9996>:
  if (thread != 0B) goto <D.9995>; else goto <D.9997>;
  <D.9997>:
}


print_reports (struct ProfContext * ctx, const char * reps, int parse_only)
{
  int D.12438;
  char D.12439;
  const char * opt;
  const char * p;

  p = reps;
  goto <D.10022>;
  <D.10021>:
  opt = match_option (p, "header");
  if (opt != p) goto <D.12394>; else goto <D.12395>;
  <D.12394>:
  if (parse_only == 0) goto <D.12396>; else goto <D.12397>;
  <D.12396>:
  dump_header (ctx);
  <D.12397>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12395>:
  opt = match_option (p, "thread");
  if (opt != p) goto <D.12398>; else goto <D.12399>;
  <D.12398>:
  if (parse_only == 0) goto <D.12400>; else goto <D.12401>;
  <D.12400>:
  dump_threads (ctx);
  <D.12401>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12399>:
  opt = match_option (p, "gc");
  if (opt != p) goto <D.12402>; else goto <D.12403>;
  <D.12402>:
  if (parse_only == 0) goto <D.12404>; else goto <D.12405>;
  <D.12404>:
  dump_gcs ();
  <D.12405>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12403>:
  opt = match_option (p, "jit");
  if (opt != p) goto <D.12406>; else goto <D.12407>;
  <D.12406>:
  if (parse_only == 0) goto <D.12408>; else goto <D.12409>;
  <D.12408>:
  dump_jit ();
  <D.12409>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12407>:
  opt = match_option (p, "alloc");
  if (opt != p) goto <D.12410>; else goto <D.12411>;
  <D.12410>:
  if (parse_only == 0) goto <D.12412>; else goto <D.12413>;
  <D.12412>:
  dump_allocations ();
  <D.12413>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12411>:
  opt = match_option (p, "call");
  if (opt != p) goto <D.12414>; else goto <D.12415>;
  <D.12414>:
  if (parse_only == 0) goto <D.12416>; else goto <D.12417>;
  <D.12416>:
  dump_methods ();
  <D.12417>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12415>:
  opt = match_option (p, "metadata");
  if (opt != p) goto <D.12418>; else goto <D.12419>;
  <D.12418>:
  if (parse_only == 0) goto <D.12420>; else goto <D.12421>;
  <D.12420>:
  dump_metadata ();
  <D.12421>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12419>:
  opt = match_option (p, "exception");
  if (opt != p) goto <D.12422>; else goto <D.12423>;
  <D.12422>:
  if (parse_only == 0) goto <D.12424>; else goto <D.12425>;
  <D.12424>:
  dump_exceptions ();
  <D.12425>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12423>:
  opt = match_option (p, "monitor");
  if (opt != p) goto <D.12426>; else goto <D.12427>;
  <D.12426>:
  if (parse_only == 0) goto <D.12428>; else goto <D.12429>;
  <D.12428>:
  dump_monitors ();
  <D.12429>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12427>:
  opt = match_option (p, "heapshot");
  if (opt != p) goto <D.12430>; else goto <D.12431>;
  <D.12430>:
  if (parse_only == 0) goto <D.12432>; else goto <D.12433>;
  <D.12432>:
  dump_heap_shots ();
  <D.12433>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12431>:
  opt = match_option (p, "sample");
  if (opt != p) goto <D.12434>; else goto <D.12435>;
  <D.12434>:
  if (parse_only == 0) goto <D.12436>; else goto <D.12437>;
  <D.12436>:
  dump_samples ();
  <D.12437>:
  // predicted unlikely by continue predictor.
  goto <D.10020>;
  <D.12435>:
  D.12438 = 0;
  return D.12438;
  <D.10020>:
  p = opt;
  <D.10022>:
  D.12439 = *p;
  if (D.12439 != 0) goto <D.10021>; else goto <D.10023>;
  <D.10023>:
  D.12438 = 1;
  return D.12438;
}


dump_header (struct ProfContext * ctx)
{
  long unsigned int D.12452;
  long unsigned int D.12453;
  long int st.187;
  struct FILE * outfile.188;
  int D.12456;
  int D.12457;
  int D.12458;
  int D.12459;
  int D.12460;
  int D.12463;
  time_t st;
  char * t;

  try
    {
      D.12452 = ctx->startup_time;
      D.12453 = D.12452 / 1000;
      st.187 = (long int) D.12453;
      st = st.187;
      t = ctime (&st);
      outfile.188 = outfile;
      fprintf (outfile.188, "\nMono log profiler data\n");
      outfile.188 = outfile;
      D.12456 = ctx->version_major;
      D.12457 = ctx->version_minor;
      fprintf (outfile.188, "\tProfiler version: %d.%d\n", D.12456, D.12457);
      outfile.188 = outfile;
      D.12458 = ctx->data_version;
      fprintf (outfile.188, "\tData version: %d\n", D.12458);
      outfile.188 = outfile;
      D.12459 = ctx->timer_overhead;
      fprintf (outfile.188, "\tMean timer overhead: %d nanoseconds\n", D.12459);
      outfile.188 = outfile;
      fprintf (outfile.188, "\tProgram startup: %s", t);
      D.12460 = ctx->pid;
      if (D.12460 != 0) goto <D.12461>; else goto <D.12462>;
      <D.12461>:
      outfile.188 = outfile;
      D.12460 = ctx->pid;
      fprintf (outfile.188, "\tProgram ID: %d\n", D.12460);
      <D.12462>:
      D.12463 = ctx->port;
      if (D.12463 != 0) goto <D.12464>; else goto <D.12465>;
      <D.12464>:
      outfile.188 = outfile;
      D.12463 = ctx->port;
      fprintf (outfile.188, "\tServer listening on: %d\n", D.12463);
      <D.12465>:
    }
  finally
    {
      st = {CLOBBER};
    }
}


dump_threads (struct ProfContext * ctx)
{
  struct FILE * outfile.189;
  long int D.12469;
  void * D.12470;
  const char * iftmp.190;
  char * D.12472;
  struct ThreadContext * thread;

  outfile.189 = outfile;
  fprintf (outfile.189, "\nThread summary\n");
  thread = ctx->threads;
  goto <D.9793>;
  <D.9792>:
  outfile.189 = outfile;
  D.12469 = thread->thread_id;
  D.12470 = (void *) D.12469;
  D.12472 = thread->name;
  if (D.12472 != 0B) goto <D.12473>; else goto <D.12474>;
  <D.12473>:
  iftmp.190 = thread->name;
  goto <D.12475>;
  <D.12474>:
  iftmp.190 = "";
  <D.12475>:
  fprintf (outfile.189, "\tThread: %p, name: \"%s\"\n", D.12470, iftmp.190);
  thread = thread->next;
  <D.9793>:
  if (thread != 0B) goto <D.9792>; else goto <D.9794>;
  <D.9794>:
}


dump_gcs ()
{
  struct FILE * outfile.191;
  int gc_resizes.192;
  long unsigned int max_heap_size.193;
  long unsigned int gc_object_moves.194;
  int D.12480;
  long unsigned int D.12483;
  long unsigned int D.12484;
  long unsigned int D.12485;
  long unsigned int D.12486;
  long unsigned int D.12487;
  long unsigned int D.12488;
  long unsigned int D.12489;
  long unsigned int D.12490;
  const char * D.12493;
  long unsigned int D.12494;
  long unsigned int D.12495;
  struct TraceDesc * D.12496;
  int i;

  outfile.191 = outfile;
  fprintf (outfile.191, "\nGC summary\n");
  outfile.191 = outfile;
  gc_resizes.192 = gc_resizes;
  fprintf (outfile.191, "\tGC resizes: %d\n", gc_resizes.192);
  outfile.191 = outfile;
  max_heap_size.193 = max_heap_size;
  fprintf (outfile.191, "\tMax heap size: %llu\n", max_heap_size.193);
  outfile.191 = outfile;
  gc_object_moves.194 = gc_object_moves;
  fprintf (outfile.191, "\tObject moves: %llu\n", gc_object_moves.194);
  i = 0;
  goto <D.9832>;
  <D.9831>:
  D.12480 = gc_info[i].count;
  if (D.12480 == 0) goto <D.12481>; else goto <D.12482>;
  <D.12481>:
  // predicted unlikely by continue predictor.
  goto <D.9830>;
  <D.12482>:
  outfile.191 = outfile;
  D.12480 = gc_info[i].count;
  D.12483 = gc_info[i].max_time;
  D.12484 = D.12483 / 1000;
  D.12485 = gc_info[i].total_time;
  D.12486 = D.12485 / 1000;
  D.12485 = gc_info[i].total_time;
  D.12480 = gc_info[i].count;
  D.12487 = (long unsigned int) D.12480;
  D.12488 = D.12485 / D.12487;
  D.12489 = D.12488 / 1000;
  fprintf (outfile.191, "\tGen%d collections: %d, max time: %lluus, total time: %lluus, average: %lluus\n", i, D.12480, D.12484, D.12486, D.12489);
  <D.9830>:
  i = i + 1;
  <D.9832>:
  if (i <= 2) goto <D.9831>; else goto <D.9833>;
  <D.9833>:
  i = 0;
  goto <D.9836>;
  <D.9835>:
  D.12490 = handle_info[i].max_live;
  if (D.12490 == 0) goto <D.12491>; else goto <D.12492>;
  <D.12491>:
  // predicted unlikely by continue predictor.
  goto <D.9834>;
  <D.12492>:
  outfile.191 = outfile;
  D.12493 = get_handle_name (i);
  D.12494 = handle_info[i].created;
  D.12495 = handle_info[i].destroyed;
  D.12490 = handle_info[i].max_live;
  fprintf (outfile.191, "\tGC handles %s: created: %llu, destroyed: %llu, max: %llu\n", D.12493, D.12494, D.12495, D.12490);
  D.12496 = &handle_info[i].traces;
  dump_traces (D.12496, "created");
  <D.9834>:
  i = i + 1;
  <D.9836>:
  if (i <= 2) goto <D.9835>; else goto <D.9837>;
  <D.9837>:
}


dump_traces (struct TraceDesc * traces, const char * desc)
{
  int show_traces.195;
  int D.12501;
  struct CallContext * D.12504;
  long unsigned int D.12505;
  long unsigned int D.12506;
  struct CallContext * D.12507;
  int D.12508;
  struct FILE * outfile.196;
  long unsigned int D.12512;
  struct MethodDesc * D.12513;
  char * D.12514;
  int j;

  show_traces.195 = show_traces;
  if (show_traces.195 == 0) goto <D.12499>; else goto <D.12500>;
  <D.12499>:
  return;
  <D.12500>:
  D.12501 = traces->count;
  if (D.12501 == 0) goto <D.12502>; else goto <D.12503>;
  <D.12502>:
  return;
  <D.12503>:
  sort_context_array (traces);
  j = 0;
  goto <D.9786>;
  <D.9785>:
  {
    int k;
    struct BackTrace * bt;

    D.12504 = traces->traces;
    D.12505 = (long unsigned int) j;
    D.12506 = D.12505 * 16;
    D.12507 = D.12504 + D.12506;
    bt = D.12507->bt;
    D.12508 = bt->count;
    if (D.12508 == 0) goto <D.12509>; else goto <D.12510>;
    <D.12509>:
    // predicted unlikely by continue predictor.
    goto <D.9781>;
    <D.12510>:
    outfile.196 = outfile;
    D.12504 = traces->traces;
    D.12505 = (long unsigned int) j;
    D.12506 = D.12505 * 16;
    D.12507 = D.12504 + D.12506;
    D.12512 = D.12507->count;
    fprintf (outfile.196, "\t%llu %s from:\n", D.12512, desc);
    k = 0;
    goto <D.9783>;
    <D.9782>:
    outfile.196 = outfile;
    D.12513 = bt->methods[k];
    D.12514 = D.12513->name;
    fprintf (outfile.196, "\t\t%s\n", D.12514);
    k = k + 1;
    <D.9783>:
    D.12508 = bt->count;
    if (D.12508 > k) goto <D.9782>; else goto <D.9784>;
    <D.9784>:
  }
  <D.9781>:
  j = j + 1;
  <D.9786>:
  D.12501 = traces->count;
  if (D.12501 > j) goto <D.9785>; else goto <D.9787>;
  <D.9787>:
}


sort_context_array (struct TraceDesc * traces)
{
  struct CallContext * D.12516;
  long unsigned int D.12517;
  long unsigned int D.12518;
  struct CallContext * D.12519;
  struct BackTrace * D.12520;
  long unsigned int D.12523;
  long unsigned int D.12524;
  struct CallContext * D.12525;
  long unsigned int D.12526;
  int D.12527;
  int D.12528;
  long unsigned int D.12529;
  int i;
  int j;

  i = 0;
  j = 0;
  goto <D.9423>;
  <D.9422>:
  D.12516 = traces->traces;
  D.12517 = (long unsigned int) i;
  D.12518 = D.12517 * 16;
  D.12519 = D.12516 + D.12518;
  D.12520 = D.12519->bt;
  if (D.12520 != 0B) goto <D.12521>; else goto <D.12522>;
  <D.12521>:
  D.12516 = traces->traces;
  D.12523 = (long unsigned int) j;
  D.12524 = D.12523 * 16;
  D.12525 = D.12516 + D.12524;
  D.12516 = traces->traces;
  D.12517 = (long unsigned int) i;
  D.12518 = D.12517 * 16;
  D.12519 = D.12516 + D.12518;
  D.12520 = D.12519->bt;
  D.12525->bt = D.12520;
  D.12516 = traces->traces;
  D.12523 = (long unsigned int) j;
  D.12524 = D.12523 * 16;
  D.12525 = D.12516 + D.12524;
  D.12516 = traces->traces;
  D.12517 = (long unsigned int) i;
  D.12518 = D.12517 * 16;
  D.12519 = D.12516 + D.12518;
  D.12526 = D.12519->count;
  D.12525->count = D.12526;
  j = j + 1;
  <D.12522>:
  i = i + 1;
  <D.9423>:
  D.12527 = traces->size;
  if (D.12527 > i) goto <D.9422>; else goto <D.9424>;
  <D.9424>:
  D.12516 = traces->traces;
  D.12528 = traces->count;
  D.12529 = (long unsigned int) D.12528;
  qsort (D.12516, D.12529, 16, compare_callc);
}


compare_callc (const void * a, const void * b)
{
  long unsigned int D.12530;
  long unsigned int D.12531;
  int D.12534;
  const struct CallContext * A;
  const struct CallContext * B;

  A = a;
  B = b;
  D.12530 = B->count;
  D.12531 = A->count;
  if (D.12530 == D.12531) goto <D.12532>; else goto <D.12533>;
  <D.12532>:
  D.12534 = 0;
  return D.12534;
  <D.12533>:
  D.12530 = B->count;
  D.12531 = A->count;
  if (D.12530 < D.12531) goto <D.12535>; else goto <D.12536>;
  <D.12535>:
  D.12534 = -1;
  return D.12534;
  <D.12536>:
  D.12534 = 1;
  return D.12534;
}


dump_jit ()
{
  struct FILE * outfile.197;
  long int D.12539;
  int D.12542;
  int i;
  int code_size;
  int compiled_methods;
  struct MethodDesc * m;

  code_size = 0;
  compiled_methods = 0;
  outfile.197 = outfile;
  fprintf (outfile.197, "\nJIT summary\n");
  i = 0;
  goto <D.9850>;
  <D.9849>:
  m = method_hash[i];
  m = method_hash[i];
  goto <D.9847>;
  <D.9846>:
  D.12539 = m->code;
  if (D.12539 == 0) goto <D.12540>; else goto <D.12541>;
  <D.12540>:
  // predicted unlikely by continue predictor.
  goto <D.9845>;
  <D.12541>:
  compiled_methods = compiled_methods + 1;
  D.12542 = m->len;
  code_size = D.12542 + code_size;
  <D.9845>:
  m = m->next;
  <D.9847>:
  if (m != 0B) goto <D.9846>; else goto <D.9848>;
  <D.9848>:
  i = i + 1;
  <D.9850>:
  if (i <= 9370) goto <D.9849>; else goto <D.9851>;
  <D.9851>:
  outfile.197 = outfile;
  fprintf (outfile.197, "\tCompiled methods: %d\n", compiled_methods);
  outfile.197 = outfile;
  fprintf (outfile.197, "\tGenerated code size: %d\n", code_size);
}


dump_allocations ()
{
  int num_classes.198;
  long unsigned int D.12544;
  long unsigned int D.12545;
  int c.199;
  long unsigned int D.12547;
  long unsigned int D.12548;
  struct ClassDesc * * D.12549;
  long unsigned int D.12550;
  long unsigned int D.12551;
  long unsigned int D.12552;
  struct ClassDesc * * D.12553;
  long int D.12554;
  long unsigned int D.12557;
  int header_done.200;
  struct FILE * outfile.201;
  long unsigned int D.12562;
  long unsigned int D.12563;
  char * D.12564;
  struct TraceDesc * D.12565;
  int i;
  int c;
  intptr_t allocs;
  uint64_t size;
  int header_done;
  struct ClassDesc * * classes;
  struct ClassDesc * cd;

  allocs = 0;
  size = 0;
  header_done = 0;
  num_classes.198 = num_classes;
  D.12544 = (long unsigned int) num_classes.198;
  D.12545 = D.12544 * 8;
  classes = malloc (D.12545);
  c = 0;
  i = 0;
  goto <D.9866>;
  <D.9865>:
  cd = class_hash[i];
  goto <D.9863>;
  <D.9862>:
  c.199 = c;
  c = c.199 + 1;
  D.12547 = (long unsigned int) c.199;
  D.12548 = D.12547 * 8;
  D.12549 = classes + D.12548;
  *D.12549 = cd;
  cd = cd->next;
  <D.9863>:
  if (cd != 0B) goto <D.9862>; else goto <D.9864>;
  <D.9864>:
  i = i + 1;
  <D.9866>:
  if (i <= 9370) goto <D.9865>; else goto <D.9867>;
  <D.9867>:
  num_classes.198 = num_classes;
  D.12550 = (long unsigned int) num_classes.198;
  qsort (classes, D.12550, 8, compare_class);
  i = 0;
  goto <D.9870>;
  <D.9869>:
  D.12551 = (long unsigned int) i;
  D.12552 = D.12551 * 8;
  D.12553 = classes + D.12552;
  cd = *D.12553;
  D.12554 = cd->allocs;
  if (D.12554 == 0) goto <D.12555>; else goto <D.12556>;
  <D.12555>:
  // predicted unlikely by continue predictor.
  goto <D.9868>;
  <D.12556>:
  D.12554 = cd->allocs;
  allocs = D.12554 + allocs;
  D.12557 = cd->alloc_size;
  size = D.12557 + size;
  header_done.200 = header_done;
  header_done = header_done.200 + 1;
  if (header_done.200 == 0) goto <D.12559>; else goto <D.12560>;
  <D.12559>:
  outfile.201 = outfile;
  fprintf (outfile.201, "\nAllocation summary\n");
  outfile.201 = outfile;
  fprintf (outfile.201, "%10s %10s %8s Type name\n", "Bytes", "Count", "Average");
  <D.12560>:
  outfile.201 = outfile;
  D.12557 = cd->alloc_size;
  D.12554 = cd->allocs;
  D.12557 = cd->alloc_size;
  D.12554 = cd->allocs;
  D.12562 = (long unsigned int) D.12554;
  D.12563 = D.12557 / D.12562;
  D.12564 = cd->name;
  fprintf (outfile.201, "%10llu %10d %8llu %s\n", D.12557, D.12554, D.12563, D.12564);
  D.12565 = &cd->traces;
  dump_traces (D.12565, "bytes");
  <D.9868>:
  i = i + 1;
  <D.9870>:
  num_classes.198 = num_classes;
  if (i < num_classes.198) goto <D.9869>; else goto <D.9871>;
  <D.9871>:
  if (allocs != 0) goto <D.12566>; else goto <D.12567>;
  <D.12566>:
  outfile.201 = outfile;
  fprintf (outfile.201, "Total memory allocated: %llu bytes in %d objects\n", size, allocs);
  <D.12567>:
}


compare_class (const void * a, const void * b)
{
  int alloc_sort_mode.202;
  struct ClassDesc * D.12571;
  struct ClassDesc * D.12572;
  long int D.12574;
  long int D.12575;
  int D.12578;
  struct ClassDesc * const * A;
  struct ClassDesc * const * B;
  uint64_t vala;
  uint64_t valb;

  A = a;
  B = b;
  alloc_sort_mode.202 = alloc_sort_mode;
  if (alloc_sort_mode.202 == 0) goto <D.12569>; else goto <D.12570>;
  <D.12569>:
  D.12571 = *A;
  vala = D.12571->alloc_size;
  D.12572 = *B;
  valb = D.12572->alloc_size;
  goto <D.12573>;
  <D.12570>:
  D.12571 = *A;
  D.12574 = D.12571->allocs;
  vala = (uint64_t) D.12574;
  D.12572 = *B;
  D.12575 = D.12572->allocs;
  valb = (uint64_t) D.12575;
  <D.12573>:
  if (valb == vala) goto <D.12576>; else goto <D.12577>;
  <D.12576>:
  D.12578 = 0;
  return D.12578;
  <D.12577>:
  if (valb < vala) goto <D.12579>; else goto <D.12580>;
  <D.12579>:
  D.12578 = -1;
  return D.12578;
  <D.12580>:
  D.12578 = 1;
  return D.12578;
}


dump_methods ()
{
  int num_methods.203;
  long unsigned int D.12583;
  long unsigned int D.12584;
  long unsigned int D.12585;
  long unsigned int D.12586;
  long unsigned int D.12587;
  int c.204;
  long unsigned int D.12589;
  long unsigned int D.12590;
  struct MethodDesc * * D.12591;
  long unsigned int D.12592;
  long unsigned int D.12593;
  long unsigned int D.12594;
  struct MethodDesc * * D.12595;
  long unsigned int D.12596;
  long unsigned int D.12599;
  long unsigned int D.12600;
  int verbose.205;
  int header_done.206;
  struct FILE * outfile.207;
  char * D.12610;
  struct TraceDesc * D.12611;
  int i;
  int c;
  uint64_t calls;
  int header_done;
  struct MethodDesc * * methods;
  struct MethodDesc * cd;

  calls = 0;
  header_done = 0;
  num_methods.203 = num_methods;
  D.12583 = (long unsigned int) num_methods.203;
  D.12584 = D.12583 * 8;
  methods = malloc (D.12584);
  c = 0;
  i = 0;
  goto <D.9909>;
  <D.9908>:
  cd = method_hash[i];
  goto <D.9906>;
  <D.9905>:
  D.12585 = cd->self_time;
  D.12586 = cd->callee_time;
  D.12587 = D.12585 + D.12586;
  cd->total_time = D.12587;
  c.204 = c;
  c = c.204 + 1;
  D.12589 = (long unsigned int) c.204;
  D.12590 = D.12589 * 8;
  D.12591 = methods + D.12590;
  *D.12591 = cd;
  cd = cd->next;
  <D.9906>:
  if (cd != 0B) goto <D.9905>; else goto <D.9907>;
  <D.9907>:
  i = i + 1;
  <D.9909>:
  if (i <= 9370) goto <D.9908>; else goto <D.9910>;
  <D.9910>:
  num_methods.203 = num_methods;
  D.12592 = (long unsigned int) num_methods.203;
  qsort (methods, D.12592, 8, compare_method);
  i = 0;
  goto <D.9915>;
  <D.9914>:
  {
    uint64_t msecs;
    uint64_t smsecs;

    D.12593 = (long unsigned int) i;
    D.12594 = D.12593 * 8;
    D.12595 = methods + D.12594;
    cd = *D.12595;
    D.12596 = cd->calls;
    if (D.12596 == 0) goto <D.12597>; else goto <D.12598>;
    <D.12597>:
    // predicted unlikely by continue predictor.
    goto <D.9913>;
    <D.12598>:
    D.12596 = cd->calls;
    calls = D.12596 + calls;
    D.12599 = cd->total_time;
    msecs = D.12599 / 1000000;
    D.12599 = cd->total_time;
    D.12586 = cd->callee_time;
    D.12600 = D.12599 - D.12586;
    smsecs = D.12600 / 1000000;
    if (msecs == 0) goto <D.12601>; else goto <D.12602>;
    <D.12601>:
    verbose.205 = verbose;
    if (verbose.205 == 0) goto <D.12604>; else goto <D.12605>;
    <D.12604>:
    // predicted unlikely by continue predictor.
    goto <D.9913>;
    <D.12605>:
    <D.12602>:
    header_done.206 = header_done;
    header_done = header_done.206 + 1;
    if (header_done.206 == 0) goto <D.12607>; else goto <D.12608>;
    <D.12607>:
    outfile.207 = outfile;
    fprintf (outfile.207, "\nMethod call summary\n");
    outfile.207 = outfile;
    fprintf (outfile.207, "%8s %8s %10s Method name\n", "Total(ms)", "Self(ms)", "Calls");
    <D.12608>:
    outfile.207 = outfile;
    D.12596 = cd->calls;
    D.12610 = cd->name;
    fprintf (outfile.207, "%8llu %8llu %10llu %s\n", msecs, smsecs, D.12596, D.12610);
    D.12611 = &cd->traces;
    dump_traces (D.12611, "calls");
  }
  <D.9913>:
  i = i + 1;
  <D.9915>:
  num_methods.203 = num_methods;
  if (i < num_methods.203) goto <D.9914>; else goto <D.9916>;
  <D.9916>:
  if (calls != 0) goto <D.12612>; else goto <D.12613>;
  <D.12612>:
  outfile.207 = outfile;
  fprintf (outfile.207, "Total calls: %llu\n", calls);
  <D.12613>:
}


compare_method (const void * a, const void * b)
{
  int method_sort_mode.208;
  struct MethodDesc * D.12617;
  struct MethodDesc * D.12618;
  int D.12625;
  struct MethodDesc * const * A;
  struct MethodDesc * const * B;
  uint64_t vala;
  uint64_t valb;

  A = a;
  B = b;
  method_sort_mode.208 = method_sort_mode;
  if (method_sort_mode.208 == 1) goto <D.12615>; else goto <D.12616>;
  <D.12615>:
  D.12617 = *A;
  vala = D.12617->self_time;
  D.12618 = *B;
  valb = D.12618->self_time;
  goto <D.12619>;
  <D.12616>:
  method_sort_mode.208 = method_sort_mode;
  if (method_sort_mode.208 == 2) goto <D.12620>; else goto <D.12621>;
  <D.12620>:
  D.12617 = *A;
  vala = D.12617->calls;
  D.12618 = *B;
  valb = D.12618->calls;
  goto <D.12622>;
  <D.12621>:
  D.12617 = *A;
  vala = D.12617->total_time;
  D.12618 = *B;
  valb = D.12618->total_time;
  <D.12622>:
  <D.12619>:
  if (vala == valb) goto <D.12623>; else goto <D.12624>;
  <D.12623>:
  D.12625 = 0;
  return D.12625;
  <D.12624>:
  if (valb < vala) goto <D.12626>; else goto <D.12627>;
  <D.12626>:
  D.12625 = -1;
  return D.12625;
  <D.12627>:
  D.12625 = 1;
  return D.12625;
}


dump_metadata ()
{
  struct FILE * outfile.209;
  int num_images.210;
  int verbose.211;
  char * D.12634;

  outfile.209 = outfile;
  fprintf (outfile.209, "\nMetadata summary\n");
  outfile.209 = outfile;
  num_images.210 = num_images;
  fprintf (outfile.209, "\tLoaded images: %d\n", num_images.210);
  verbose.211 = verbose;
  if (verbose.211 != 0) goto <D.12632>; else goto <D.12633>;
  <D.12632>:
  {
    struct ImageDesc * image;
    int i;

    i = 0;
    goto <D.9894>;
    <D.9893>:
    image = image_hash[i];
    goto <D.9891>;
    <D.9890>:
    outfile.209 = outfile;
    D.12634 = image->filename;
    fprintf (outfile.209, "\t\t%s\n", D.12634);
    image = image->next;
    <D.9891>:
    if (image != 0B) goto <D.9890>; else goto <D.9892>;
    <D.9892>:
    i = i + 1;
    <D.9894>:
    if (i <= 30) goto <D.9893>; else goto <D.9895>;
    <D.9895>:
  }
  <D.12633>:
}


dump_exceptions ()
{
  struct FILE * outfile.212;
  long unsigned int throw_count.213;
  long unsigned int D.12637;
  const char * D.12640;
  int i;

  outfile.212 = outfile;
  fprintf (outfile.212, "\nException summary\n");
  outfile.212 = outfile;
  throw_count.213 = throw_count;
  fprintf (outfile.212, "\tThrows: %llu\n", throw_count.213);
  dump_traces (&exc_traces, "throws");
  i = 0;
  goto <D.9801>;
  <D.9800>:
  D.12637 = clause_summary[i];
  if (D.12637 == 0) goto <D.12638>; else goto <D.12639>;
  <D.12638>:
  // predicted unlikely by continue predictor.
  goto <D.9799>;
  <D.12639>:
  outfile.212 = outfile;
  D.12640 = clause_name (i);
  D.12637 = clause_summary[i];
  fprintf (outfile.212, "\tExecuted %s clauses: %llu\n", D.12640, D.12637);
  <D.9799>:
  i = i + 1;
  <D.9801>:
  if (i <= 4) goto <D.9800>; else goto <D.9802>;
  <D.9802>:
}


dump_monitors ()
{
  int num_monitors.214;
  long unsigned int D.12645;
  long unsigned int D.12646;
  int j.215;
  long unsigned int D.12648;
  long unsigned int D.12649;
  struct MonitorDesc * * D.12650;
  long unsigned int D.12651;
  struct FILE * outfile.216;
  long unsigned int D.12653;
  long unsigned int D.12654;
  struct MonitorDesc * * D.12655;
  long unsigned int D.12656;
  void * D.12657;
  long unsigned int D.12658;
  int D.12659;
  long unsigned int D.12660;
  double D.12661;
  double D.12662;
  long unsigned int D.12663;
  double D.12664;
  double D.12665;
  double D.12666;
  double D.12667;
  struct TraceDesc * D.12668;
  long unsigned int monitor_contention.217;
  long unsigned int monitor_acquired.218;
  long unsigned int monitor_failed.219;
  struct MonitorDesc * * monitors;
  int i;
  int j;

  num_monitors.214 = num_monitors;
  if (num_monitors.214 == 0) goto <D.12643>; else goto <D.12644>;
  <D.12643>:
  return;
  <D.12644>:
  num_monitors.214 = num_monitors;
  D.12645 = (long unsigned int) num_monitors.214;
  D.12646 = D.12645 * 8;
  monitors = malloc (D.12646);
  i = 0;
  j = 0;
  goto <D.9820>;
  <D.9819>:
  {
    struct MonitorDesc * mdesc;

    mdesc = monitor_hash[i];
    goto <D.9817>;
    <D.9816>:
    j.215 = j;
    j = j.215 + 1;
    D.12648 = (long unsigned int) j.215;
    D.12649 = D.12648 * 8;
    D.12650 = monitors + D.12649;
    *D.12650 = mdesc;
    mdesc = mdesc->next;
    <D.9817>:
    if (mdesc != 0B) goto <D.9816>; else goto <D.9818>;
    <D.9818>:
  }
  i = i + 1;
  <D.9820>:
  if (i <= 30) goto <D.9819>; else goto <D.9821>;
  <D.9821>:
  num_monitors.214 = num_monitors;
  D.12651 = (long unsigned int) num_monitors.214;
  qsort (monitors, D.12651, 8, compare_monitor);
  outfile.216 = outfile;
  fprintf (outfile.216, "\nMonitor lock summary\n");
  i = 0;
  goto <D.9824>;
  <D.9823>:
  {
    struct MonitorDesc * mdesc;

    D.12653 = (long unsigned int) i;
    D.12654 = D.12653 * 8;
    D.12655 = monitors + D.12654;
    mdesc = *D.12655;
    outfile.216 = outfile;
    D.12656 = mdesc->objid;
    D.12657 = (void *) D.12656;
    D.12658 = mdesc->contentions;
    D.12659 = (int) D.12658;
    fprintf (outfile.216, "\tLock object %p: %d contentions\n", D.12657, D.12659);
    outfile.216 = outfile;
    D.12660 = mdesc->wait_time;
    D.12661 = (double) D.12660;
    D.12662 = D.12661 / 1.0e+9;
    D.12663 = mdesc->max_wait_time;
    D.12664 = (double) D.12663;
    D.12665 = D.12664 / 1.0e+9;
    D.12660 = mdesc->wait_time;
    D.12661 = (double) D.12660;
    D.12662 = D.12661 / 1.0e+9;
    D.12658 = mdesc->contentions;
    D.12666 = (double) D.12658;
    D.12667 = D.12662 / D.12666;
    fprintf (outfile.216, "\t\t%.6f secs total wait time, %.6f max, %.6f average\n", D.12662, D.12665, D.12667);
    D.12668 = &mdesc->traces;
    dump_traces (D.12668, "contentions");
  }
  i = i + 1;
  <D.9824>:
  num_monitors.214 = num_monitors;
  if (i < num_monitors.214) goto <D.9823>; else goto <D.9825>;
  <D.9825>:
  outfile.216 = outfile;
  monitor_contention.217 = monitor_contention;
  fprintf (outfile.216, "\tLock contentions: %llu\n", monitor_contention.217);
  outfile.216 = outfile;
  monitor_acquired.218 = monitor_acquired;
  fprintf (outfile.216, "\tLock acquired: %llu\n", monitor_acquired.218);
  outfile.216 = outfile;
  monitor_failed.219 = monitor_failed;
  fprintf (outfile.216, "\tLock failures: %llu\n", monitor_failed.219);
}


compare_monitor (const void * a, const void * b)
{
  struct MonitorDesc * D.12673;
  long unsigned int D.12674;
  struct MonitorDesc * D.12675;
  long unsigned int D.12676;
  int D.12679;
  struct MonitorDesc * const * A;
  struct MonitorDesc * const * B;

  A = a;
  B = b;
  D.12673 = *B;
  D.12674 = D.12673->wait_time;
  D.12675 = *A;
  D.12676 = D.12675->wait_time;
  if (D.12674 == D.12676) goto <D.12677>; else goto <D.12678>;
  <D.12677>:
  D.12679 = 0;
  return D.12679;
  <D.12678>:
  D.12673 = *B;
  D.12674 = D.12673->wait_time;
  D.12675 = *A;
  D.12676 = D.12675->wait_time;
  if (D.12674 < D.12676) goto <D.12680>; else goto <D.12681>;
  <D.12680>:
  D.12679 = -1;
  return D.12679;
  <D.12681>:
  D.12679 = 1;
  return D.12679;
}


dump_heap_shots ()
{
  struct HeapShot * heap_shots.220;
  int num_heap_shots.221;
  long unsigned int D.12687;
  long unsigned int D.12688;
  struct FILE * outfile.222;
  int i.223;
  long unsigned int D.12691;
  long unsigned int D.12692;
  struct HeapShot * * D.12693;
  long unsigned int D.12694;
  long unsigned int D.12695;
  long unsigned int D.12696;
  struct HeapShot * * D.12697;
  struct HeapShot * * hs_sorted;
  struct HeapShot * hs;
  struct HeapShot * last_hs;
  int i;

  last_hs = 0B;
  heap_shots.220 = heap_shots;
  if (heap_shots.220 == 0B) goto <D.12684>; else goto <D.12685>;
  <D.12684>:
  return;
  <D.12685>:
  num_heap_shots.221 = num_heap_shots;
  D.12687 = (long unsigned int) num_heap_shots.221;
  D.12688 = D.12687 * 8;
  hs_sorted = malloc (D.12688);
  outfile.222 = outfile;
  fprintf (outfile.222, "\nHeap shot summary\n");
  i = 0;
  hs = heap_shots;
  goto <D.9983>;
  <D.9982>:
  i.223 = i;
  i = i.223 + 1;
  D.12691 = (long unsigned int) i.223;
  D.12692 = D.12691 * 8;
  D.12693 = hs_sorted + D.12692;
  *D.12693 = hs;
  hs = hs->next;
  <D.9983>:
  if (hs != 0B) goto <D.9982>; else goto <D.9984>;
  <D.9984>:
  num_heap_shots.221 = num_heap_shots;
  D.12694 = (long unsigned int) num_heap_shots.221;
  qsort (hs_sorted, D.12694, 8, compare_heap_shots);
  i = 0;
  goto <D.9986>;
  <D.9985>:
  D.12695 = (long unsigned int) i;
  D.12696 = D.12695 * 8;
  D.12697 = hs_sorted + D.12696;
  hs = *D.12697;
  heap_shot_summary (hs, i, last_hs);
  last_hs = hs;
  i = i + 1;
  <D.9986>:
  num_heap_shots.221 = num_heap_shots;
  if (i < num_heap_shots.221) goto <D.9985>; else goto <D.9987>;
  <D.9987>:
}


compare_heap_shots (const void * a, const void * b)
{
  struct HeapShot * D.12699;
  long unsigned int D.12700;
  struct HeapShot * D.12701;
  long unsigned int D.12702;
  int D.12705;
  struct HeapShot * const * A;
  struct HeapShot * const * B;

  A = a;
  B = b;
  D.12699 = *B;
  D.12700 = D.12699->timestamp;
  D.12701 = *A;
  D.12702 = D.12701->timestamp;
  if (D.12700 == D.12702) goto <D.12703>; else goto <D.12704>;
  <D.12703>:
  D.12705 = 0;
  return D.12705;
  <D.12704>:
  D.12699 = *B;
  D.12700 = D.12699->timestamp;
  D.12701 = *A;
  D.12702 = D.12701->timestamp;
  if (D.12700 > D.12702) goto <D.12706>; else goto <D.12707>;
  <D.12706>:
  D.12705 = -1;
  return D.12705;
  <D.12707>:
  D.12705 = 1;
  return D.12705;
}


heap_shot_summary (struct HeapShot * hs, int hs_num, struct HeapShot * last_hs)
{
  int D.12709;
  long unsigned int D.12710;
  long unsigned int D.12711;
  struct HeapClassDesc * * D.12712;
  long unsigned int D.12713;
  long unsigned int D.12714;
  struct HeapClassDesc * * D.12715;
  long int D.12718;
  long unsigned int D.12719;
  long int D.12720;
  long unsigned int D.12721;
  int ccount.224;
  long unsigned int D.12723;
  long unsigned int D.12724;
  struct HeapClassDesc * * D.12725;
  int D.12726;
  long unsigned int D.12727;
  struct FILE * outfile.225;
  long unsigned int D.12729;
  long unsigned int startup_time.226;
  long unsigned int D.12731;
  double D.12732;
  double D.12733;
  long unsigned int D.12734;
  int verbose.227;
  struct HeapClassDesc * * D.12740;
  struct ClassDesc * D.12743;
  long int D.12744;
  char * D.12745;
  long int D.12748;
  long int D.12749;
  int collect_traces.228;
  int D.12754;
  long unsigned int D.12755;
  long unsigned int D.12756;
  struct HeapClassRevRef * D.12757;
  long unsigned int D.12758;
  long unsigned int D.12759;
  struct HeapClassRevRef * D.12760;
  struct HeapClassDesc * D.12761;
  int k.229;
  long unsigned int D.12765;
  long unsigned int D.12766;
  struct HeapClassRevRef * D.12767;
  int D.12768;
  long unsigned int D.12771;
  long unsigned int D.12772;
  long unsigned int D.12775;
  uint64_t size;
  uint64_t count;
  int ccount;
  int i;
  struct HeapClassDesc * cd;
  struct HeapClassDesc * * sorted;
  static const char __PRETTY_FUNCTION__[18] = "heap_shot_summary";

  size = 0;
  count = 0;
  ccount = 0;
  D.12709 = hs->class_count;
  D.12710 = (long unsigned int) D.12709;
  D.12711 = D.12710 * 8;
  sorted = malloc (D.12711);
  i = 0;
  goto <D.9953>;
  <D.9952>:
  D.12712 = hs->class_hash;
  D.12713 = (long unsigned int) i;
  D.12714 = D.12713 * 8;
  D.12715 = D.12712 + D.12714;
  cd = *D.12715;
  if (cd == 0B) goto <D.12716>; else goto <D.12717>;
  <D.12716>:
  // predicted unlikely by continue predictor.
  goto <D.9951>;
  <D.12717>:
  D.12718 = cd->count;
  D.12719 = (long unsigned int) D.12718;
  count = D.12719 + count;
  D.12720 = cd->total_size;
  D.12721 = (long unsigned int) D.12720;
  size = D.12721 + size;
  ccount.224 = ccount;
  ccount = ccount.224 + 1;
  D.12723 = (long unsigned int) ccount.224;
  D.12724 = D.12723 * 8;
  D.12725 = sorted + D.12724;
  *D.12725 = cd;
  <D.9951>:
  i = i + 1;
  <D.9953>:
  D.12726 = hs->hash_size;
  if (D.12726 > i) goto <D.9952>; else goto <D.9954>;
  <D.9954>:
  hs->sorted = sorted;
  D.12727 = (long unsigned int) ccount;
  qsort (sorted, D.12727, 8, compare_heap_class);
  outfile.225 = outfile;
  D.12729 = hs->timestamp;
  startup_time.226 = startup_time;
  D.12731 = D.12729 - startup_time.226;
  D.12732 = (double) D.12731;
  D.12733 = D.12732 / 1.0e+9;
  D.12734 = hs->num_roots;
  fprintf (outfile.225, "\n\tHeap shot %d at %.3f secs: size: %llu, object count: %llu, class count: %d, roots: %d\n", hs_num, D.12733, size, count, ccount, D.12734);
  verbose.227 = verbose;
  if (verbose.227 == 0) goto <D.12736>; else goto <D.12737>;
  <D.12736>:
  if (ccount > 30) goto <D.12738>; else goto <D.12739>;
  <D.12738>:
  ccount = 30;
  <D.12739>:
  <D.12737>:
  outfile.225 = outfile;
  fprintf (outfile.225, "\t%10s %10s %8s Class name\n", "Bytes", "Count", "Average");
  i = 0;
  goto <D.9967>;
  <D.9966>:
  {
    struct HeapClassRevRef * rev_sorted;
    int j;
    int k;
    struct HeapClassDesc * ocd;

    ocd = 0B;
    D.12713 = (long unsigned int) i;
    D.12714 = D.12713 * 8;
    D.12740 = sorted + D.12714;
    cd = *D.12740;
    if (last_hs != 0B) goto <D.12741>; else goto <D.12742>;
    <D.12741>:
    D.12743 = cd->klass;
    ocd = heap_class_lookup (last_hs, D.12743);
    <D.12742>:
    outfile.225 = outfile;
    D.12720 = cd->total_size;
    D.12718 = cd->count;
    D.12720 = cd->total_size;
    D.12718 = cd->count;
    D.12744 = D.12720 / D.12718;
    D.12743 = cd->klass;
    D.12745 = D.12743->name;
    fprintf (outfile.225, "\t%10llu %10llu %8llu %s", D.12720, D.12718, D.12744, D.12745);
    if (ocd != 0B) goto <D.12746>; else goto <D.12747>;
    <D.12746>:
    {
      int64_t bdiff;
      int64_t cdiff;

      D.12720 = cd->total_size;
      D.12748 = ocd->total_size;
      bdiff = D.12720 - D.12748;
      D.12718 = cd->count;
      D.12749 = ocd->count;
      cdiff = D.12718 - D.12749;
      outfile.225 = outfile;
      fprintf (outfile.225, " (bytes: %+lld, count: %+lld)\n", bdiff, cdiff);
    }
    goto <D.12750>;
    <D.12747>:
    outfile.225 = outfile;
    fprintf (outfile.225, "\n");
    <D.12750>:
    collect_traces.228 = collect_traces;
    if (collect_traces.228 == 0) goto <D.12752>; else goto <D.12753>;
    <D.12752>:
    // predicted unlikely by continue predictor.
    goto <D.9961>;
    <D.12753>:
    D.12754 = cd->rev_count;
    D.12755 = (long unsigned int) D.12754;
    D.12756 = D.12755 * 16;
    rev_sorted = malloc (D.12756);
    k = 0;
    j = 0;
    goto <D.9963>;
    <D.9962>:
    D.12757 = cd->rev_hash;
    D.12758 = (long unsigned int) j;
    D.12759 = D.12758 * 16;
    D.12760 = D.12757 + D.12759;
    D.12761 = D.12760->klass;
    if (D.12761 != 0B) goto <D.12762>; else goto <D.12763>;
    <D.12762>:
    k.229 = k;
    k = k.229 + 1;
    D.12765 = (long unsigned int) k.229;
    D.12766 = D.12765 * 16;
    D.12767 = rev_sorted + D.12766;
    D.12757 = cd->rev_hash;
    D.12758 = (long unsigned int) j;
    D.12759 = D.12758 * 16;
    D.12760 = D.12757 + D.12759;
    *D.12767 = *D.12760;
    <D.12763>:
    j = j + 1;
    <D.9963>:
    D.12768 = cd->rev_hash_size;
    if (D.12768 > j) goto <D.9962>; else goto <D.9964>;
    <D.9964>:
    D.12754 = cd->rev_count;
    if (D.12754 != k) goto <D.12769>; else goto <D.12770>;
    <D.12769>:
    __assert_fail ("cd->rev_count == k", "decode.c", 2416, &__PRETTY_FUNCTION__);
    <D.12770>:
    D.12754 = cd->rev_count;
    D.12771 = (long unsigned int) D.12754;
    qsort (rev_sorted, D.12771, 16, compare_rev_class);
    D.12772 = cd->root_references;
    if (D.12772 != 0) goto <D.12773>; else goto <D.12774>;
    <D.12773>:
    outfile.225 = outfile;
    D.12772 = cd->root_references;
    D.12775 = cd->pinned_references;
    fprintf (outfile.225, "\t\t%d root references (%d pinning)\n", D.12772, D.12775);
    <D.12774>:
    D.12754 = cd->rev_count;
    dump_rev_claases (rev_sorted, D.12754);
    free (rev_sorted);
  }
  <D.9961>:
  i = i + 1;
  <D.9967>:
  if (i < ccount) goto <D.9966>; else goto <D.9968>;
  <D.9968>:
  free (sorted);
}


compare_rev_class (const void * a, const void * b)
{
  long unsigned int D.12777;
  long unsigned int D.12778;
  int D.12781;
  const struct HeapClassRevRef * A;
  const struct HeapClassRevRef * B;

  A = a;
  B = b;
  D.12777 = B->count;
  D.12778 = A->count;
  if (D.12777 == D.12778) goto <D.12779>; else goto <D.12780>;
  <D.12779>:
  D.12781 = 0;
  return D.12781;
  <D.12780>:
  D.12777 = B->count;
  D.12778 = A->count;
  if (D.12777 < D.12778) goto <D.12782>; else goto <D.12783>;
  <D.12782>:
  D.12781 = -1;
  return D.12781;
  <D.12783>:
  D.12781 = 1;
  return D.12781;
}


compare_heap_class (const void * a, const void * b)
{
  int alloc_sort_mode.230;
  struct HeapClassDesc * D.12788;
  long int D.12789;
  struct HeapClassDesc * D.12790;
  long int D.12791;
  long int D.12793;
  long int D.12794;
  int D.12797;
  struct HeapClassDesc * const * A;
  struct HeapClassDesc * const * B;
  uint64_t vala;
  uint64_t valb;

  A = a;
  B = b;
  alloc_sort_mode.230 = alloc_sort_mode;
  if (alloc_sort_mode.230 == 0) goto <D.12786>; else goto <D.12787>;
  <D.12786>:
  D.12788 = *A;
  D.12789 = D.12788->total_size;
  vala = (uint64_t) D.12789;
  D.12790 = *B;
  D.12791 = D.12790->total_size;
  valb = (uint64_t) D.12791;
  goto <D.12792>;
  <D.12787>:
  D.12788 = *A;
  D.12793 = D.12788->count;
  vala = (uint64_t) D.12793;
  D.12790 = *B;
  D.12794 = D.12790->count;
  valb = (uint64_t) D.12794;
  <D.12792>:
  if (valb == vala) goto <D.12795>; else goto <D.12796>;
  <D.12795>:
  D.12797 = 0;
  return D.12797;
  <D.12796>:
  if (valb < vala) goto <D.12798>; else goto <D.12799>;
  <D.12798>:
  D.12797 = -1;
  return D.12797;
  <D.12799>:
  D.12797 = 1;
  return D.12797;
}


heap_class_lookup (struct HeapShot * hs, struct ClassDesc * klass)
{
  long int D.12801;
  long unsigned int D.12802;
  long unsigned int D.12803;
  int D.12804;
  long unsigned int D.12805;
  long unsigned int D.12806;
  struct HeapClassDesc * * D.12807;
  long unsigned int D.12808;
  long unsigned int D.12809;
  struct HeapClassDesc * * D.12810;
  struct HeapClassDesc * D.12813;
  struct ClassDesc * D.12814;
  unsigned int i.231;
  int i;
  unsigned int start_pos;

  D.12801 = klass->klass;
  D.12802 = (long unsigned int) D.12801;
  D.12803 = D.12802 >> 2;
  D.12804 = hs->hash_size;
  D.12805 = (long unsigned int) D.12804;
  D.12806 = D.12803 % D.12805;
  start_pos = (unsigned int) D.12806;
  i = (int) start_pos;
  <D.9140>:
  {
    struct HeapClassDesc * cd;

    D.12807 = hs->class_hash;
    D.12808 = (long unsigned int) i;
    D.12809 = D.12808 * 8;
    D.12810 = D.12807 + D.12809;
    cd = *D.12810;
    if (cd == 0B) goto <D.12811>; else goto <D.12812>;
    <D.12811>:
    D.12813 = 0B;
    return D.12813;
    <D.12812>:
    D.12814 = cd->klass;
    if (D.12814 == klass) goto <D.12815>; else goto <D.12816>;
    <D.12815>:
    D.12813 = cd;
    return D.12813;
    <D.12816>:
    i = i + 1;
    D.12804 = hs->hash_size;
    if (i == D.12804) goto <D.12817>; else goto <D.12818>;
    <D.12817>:
    i = 0;
    <D.12818>:
  }
  i.231 = (unsigned int) i;
  if (i.231 != start_pos) goto <D.9140>; else goto <D.9141>;
  <D.9141>:
  D.12813 = 0B;
  return D.12813;
}


dump_rev_claases (struct HeapClassRevRef * revs, int count)
{
  int show_traces.232;
  long unsigned int D.12826;
  long unsigned int D.12827;
  struct HeapClassRevRef * D.12828;
  struct FILE * outfile.233;
  long unsigned int D.12830;
  struct ClassDesc * D.12831;
  char * D.12832;
  int j;

  show_traces.232 = show_traces;
  if (show_traces.232 == 0) goto <D.12822>; else goto <D.12823>;
  <D.12822>:
  return;
  <D.12823>:
  if (count == 0) goto <D.12824>; else goto <D.12825>;
  <D.12824>:
  return;
  <D.12825>:
  j = 0;
  goto <D.9938>;
  <D.9937>:
  {
    struct HeapClassDesc * cd;

    D.12826 = (long unsigned int) j;
    D.12827 = D.12826 * 16;
    D.12828 = revs + D.12827;
    cd = D.12828->klass;
    outfile.233 = outfile;
    D.12826 = (long unsigned int) j;
    D.12827 = D.12826 * 16;
    D.12828 = revs + D.12827;
    D.12830 = D.12828->count;
    D.12831 = cd->klass;
    D.12832 = D.12831->name;
    fprintf (outfile.233, "\t\t%llu references from: %s\n", D.12830, D.12832);
  }
  j = j + 1;
  <D.9938>:
  if (j < count) goto <D.9937>; else goto <D.9939>;
  <D.9939>:
}


match_option (const char * p, const char * opt)
{
  long unsigned int D.12834;
  long unsigned int D.12835;
  int D.12836;
  sizetype D.12839;
  const char * D.12840;
  char D.12841;
  const char * D.12844;
  int len;

  D.12834 = strlen (opt);
  len = (int) D.12834;
  D.12835 = (long unsigned int) len;
  D.12836 = strncmp (p, opt, D.12835);
  if (D.12836 == 0) goto <D.12837>; else goto <D.12838>;
  <D.12837>:
  D.12839 = (sizetype) len;
  D.12840 = p + D.12839;
  D.12841 = *D.12840;
  if (D.12841 == 44) goto <D.12842>; else goto <D.12843>;
  <D.12842>:
  len = len + 1;
  <D.12843>:
  D.12839 = (sizetype) len;
  D.12844 = p + D.12839;
  return D.12844;
  <D.12838>:
  D.12844 = p;
  return D.12844;
}


dump_samples ()
{
  int num_stat_samples.234;
  struct UnmanagedSymbol * * usymbols.235;
  int usymbols_num.236;
  long unsigned int D.12851;
  uintptr_t * stat_samples.237;
  long unsigned int D.12853;
  long unsigned int D.12854;
  uintptr_t * D.12855;
  long unsigned int D.12856;
  int D.12859;
  long unsigned int D.12866;
  long unsigned int D.12867;
  int count.238;
  long unsigned int D.12869;
  long unsigned int D.12870;
  struct MethodDesc * * D.12871;
  int D.12872;
  long unsigned int D.12878;
  long unsigned int D.12885;
  long unsigned int D.12886;
  int ucount.239;
  long unsigned int D.12888;
  long unsigned int D.12889;
  struct UnmanagedSymbol * * D.12890;
  long unsigned int D.12891;
  long unsigned int D.12892;
  long unsigned int D.12893;
  struct FILE * outfile.240;
  int * stat_sample_desc.241;
  int D.12896;
  const char * D.12897;
  double D.12898;
  double D.12899;
  double D.12900;
  double D.12901;
  int D.12902;
  double D.12903;
  double D.12904;
  double D.12905;
  double D.12906;
  double D.12907;
  double D.12908;
  struct MethodDesc * * D.12911;
  long unsigned int D.12914;
  long unsigned int D.12915;
  struct UnmanagedSymbol * * D.12916;
  long unsigned int D.12917;
  int D.12918;
  long unsigned int D.12919;
  int D.12922;
  int D.12924;
  double D.12926;
  double D.12927;
  double D.12928;
  char * D.12929;
  long unsigned int D.12932;
  int D.12933;
  int i;
  int u;
  int count;
  int msize;
  int unmanaged_hits;
  int unresolved_hits;
  struct MethodDesc * * cachedm;
  int ucount;
  int usize;
  struct UnmanagedSymbol * * cachedus;

  count = 0;
  msize = 0;
  unmanaged_hits = 0;
  unresolved_hits = 0;
  cachedm = 0B;
  ucount = 0;
  usize = 0;
  cachedus = 0B;
  num_stat_samples.234 = num_stat_samples;
  if (num_stat_samples.234 == 0) goto <D.12847>; else goto <D.12848>;
  <D.12847>:
  return;
  <D.12848>:
  usymbols.235 = usymbols;
  usymbols_num.236 = usymbols_num;
  D.12851 = (long unsigned int) usymbols_num.236;
  qsort (usymbols.235, D.12851, 8, compare_usymbol_addr);
  i = 0;
  goto <D.9060>;
  <D.9059>:
  {
    struct MethodDesc * m;

    stat_samples.237 = stat_samples;
    D.12853 = (long unsigned int) i;
    D.12854 = D.12853 * 8;
    D.12855 = stat_samples.237 + D.12854;
    D.12856 = *D.12855;
    m = lookup_method_by_ip (D.12856);
    if (m != 0B) goto <D.12857>; else goto <D.12858>;
    <D.12857>:
    D.12859 = m->sample_hits;
    if (D.12859 == 0) goto <D.12860>; else goto <D.12861>;
    <D.12860>:
    if (count == msize) goto <D.12862>; else goto <D.12863>;
    <D.12862>:
    msize = msize * 2;
    if (msize == 0) goto <D.12864>; else goto <D.12865>;
    <D.12864>:
    msize = 4;
    <D.12865>:
    D.12866 = (long unsigned int) msize;
    D.12867 = D.12866 * 8;
    cachedm = realloc (cachedm, D.12867);
    <D.12863>:
    count.238 = count;
    count = count.238 + 1;
    D.12869 = (long unsigned int) count.238;
    D.12870 = D.12869 * 8;
    D.12871 = cachedm + D.12870;
    *D.12871 = m;
    <D.12861>:
    D.12859 = m->sample_hits;
    D.12872 = D.12859 + 1;
    m->sample_hits = D.12872;
    goto <D.12873>;
    <D.12858>:
    {
      struct UnmanagedSymbol * usym;

      stat_samples.237 = stat_samples;
      D.12853 = (long unsigned int) i;
      D.12854 = D.12853 * 8;
      D.12855 = stat_samples.237 + D.12854;
      D.12856 = *D.12855;
      usym = lookup_unmanaged_symbol (D.12856);
      if (usym == 0B) goto <D.12874>; else goto <D.12875>;
      <D.12874>:
      unresolved_hits = unresolved_hits + 1;
      stat_samples.237 = stat_samples;
      D.12853 = (long unsigned int) i;
      D.12854 = D.12853 * 8;
      D.12855 = stat_samples.237 + D.12854;
      D.12856 = *D.12855;
      usym = lookup_unmanaged_binary (D.12856);
      <D.12875>:
      if (usym != 0B) goto <D.12876>; else goto <D.12877>;
      <D.12876>:
      D.12878 = usym->sample_hits;
      if (D.12878 == 0) goto <D.12879>; else goto <D.12880>;
      <D.12879>:
      if (ucount == usize) goto <D.12881>; else goto <D.12882>;
      <D.12881>:
      usize = usize * 2;
      if (usize == 0) goto <D.12883>; else goto <D.12884>;
      <D.12883>:
      usize = 4;
      <D.12884>:
      D.12885 = (long unsigned int) usize;
      D.12886 = D.12885 * 8;
      cachedus = realloc (cachedus, D.12886);
      <D.12882>:
      ucount.239 = ucount;
      ucount = ucount.239 + 1;
      D.12888 = (long unsigned int) ucount.239;
      D.12889 = D.12888 * 8;
      D.12890 = cachedus + D.12889;
      *D.12890 = usym;
      <D.12880>:
      D.12878 = usym->sample_hits;
      D.12891 = D.12878 + 1;
      usym->sample_hits = D.12891;
      <D.12877>:
      unmanaged_hits = unmanaged_hits + 1;
    }
    <D.12873>:
  }
  i = i + 1;
  <D.9060>:
  num_stat_samples.234 = num_stat_samples;
  if (i < num_stat_samples.234) goto <D.9059>; else goto <D.9061>;
  <D.9061>:
  D.12892 = (long unsigned int) count;
  qsort (cachedm, D.12892, 8, compare_method_samples);
  D.12893 = (long unsigned int) ucount;
  qsort (cachedus, D.12893, 8, compare_usymbol_samples);
  set_usym_parent (cachedus, ucount);
  outfile.240 = outfile;
  fprintf (outfile.240, "\nStatistical samples summary\n");
  outfile.240 = outfile;
  stat_sample_desc.241 = stat_sample_desc;
  D.12896 = *stat_sample_desc.241;
  D.12897 = sample_type_name (D.12896);
  fprintf (outfile.240, "\tSample type: %s\n", D.12897);
  outfile.240 = outfile;
  D.12898 = (double) unmanaged_hits;
  D.12899 = D.12898 * 1.0e+2;
  num_stat_samples.234 = num_stat_samples;
  D.12900 = (double) num_stat_samples.234;
  D.12901 = D.12899 / D.12900;
  fprintf (outfile.240, "\tUnmanaged hits:  %6d (%4.1f%%)\n", unmanaged_hits, D.12901);
  outfile.240 = outfile;
  num_stat_samples.234 = num_stat_samples;
  D.12902 = num_stat_samples.234 - unmanaged_hits;
  num_stat_samples.234 = num_stat_samples;
  D.12902 = num_stat_samples.234 - unmanaged_hits;
  D.12903 = (double) D.12902;
  D.12904 = D.12903 * 1.0e+2;
  num_stat_samples.234 = num_stat_samples;
  D.12900 = (double) num_stat_samples.234;
  D.12905 = D.12904 / D.12900;
  fprintf (outfile.240, "\tManaged hits:    %6d (%4.1f%%)\n", D.12902, D.12905);
  outfile.240 = outfile;
  D.12906 = (double) unresolved_hits;
  D.12907 = D.12906 * 1.0e+2;
  num_stat_samples.234 = num_stat_samples;
  D.12900 = (double) num_stat_samples.234;
  D.12908 = D.12907 / D.12900;
  fprintf (outfile.240, "\tUnresolved hits: %6d (%4.1f%%)\n", unresolved_hits, D.12908);
  outfile.240 = outfile;
  fprintf (outfile.240, "\t%6s %6s %s\n", "Hits", "%", "Method name");
  i = 0;
  u = 0;
  goto <D.9065>;
  <D.9067>:
  if (i < count) goto <D.12909>; else goto <D.12910>;
  <D.12909>:
  {
    struct MethodDesc * m;

    D.12853 = (long unsigned int) i;
    D.12854 = D.12853 * 8;
    D.12911 = cachedm + D.12854;
    m = *D.12911;
    if (u < ucount) goto <D.12912>; else goto <D.12913>;
    <D.12912>:
    {
      struct UnmanagedSymbol * um;

      D.12914 = (long unsigned int) u;
      D.12915 = D.12914 * 8;
      D.12916 = cachedus + D.12915;
      um = *D.12916;
      D.12917 = um->sample_hits;
      D.12918 = m->sample_hits;
      D.12919 = (long unsigned int) D.12918;
      if (D.12917 > D.12919) goto <D.12920>; else goto <D.12921>;
      <D.12920>:
      D.12917 = um->sample_hits;
      D.12922 = sym_percent (D.12917);
      if (D.12922 == 0) goto <D.9064>; else goto <D.12923>;
      <D.12923>:
      print_usym (um);
      u = u + 1;
      // predicted unlikely by continue predictor.
      goto <D.9065>;
      <D.12921>:
    }
    <D.12913>:
    D.12918 = m->sample_hits;
    D.12919 = (long unsigned int) D.12918;
    D.12924 = sym_percent (D.12919);
    if (D.12924 == 0) goto <D.9064>; else goto <D.12925>;
    <D.12925>:
    outfile.240 = outfile;
    D.12918 = m->sample_hits;
    D.12918 = m->sample_hits;
    D.12926 = (double) D.12918;
    D.12927 = D.12926 * 1.0e+2;
    num_stat_samples.234 = num_stat_samples;
    D.12900 = (double) num_stat_samples.234;
    D.12928 = D.12927 / D.12900;
    D.12929 = m->name;
    fprintf (outfile.240, "\t%6d %6.2f %s\n", D.12918, D.12928, D.12929);
    i = i + 1;
    // predicted unlikely by continue predictor.
    goto <D.9065>;
  }
  <D.12910>:
  if (u < ucount) goto <D.12930>; else goto <D.12931>;
  <D.12930>:
  {
    struct UnmanagedSymbol * um;

    D.12914 = (long unsigned int) u;
    D.12915 = D.12914 * 8;
    D.12916 = cachedus + D.12915;
    um = *D.12916;
    D.12932 = um->sample_hits;
    D.12933 = sym_percent (D.12932);
    if (D.12933 == 0) goto <D.9064>; else goto <D.12934>;
    <D.12934>:
    print_usym (um);
    u = u + 1;
    // predicted unlikely by continue predictor.
    goto <D.9065>;
  }
  <D.12931>:
  <D.9065>:
  if (i < count) goto <D.9067>; else goto <D.12935>;
  <D.12935>:
  if (u < ucount) goto <D.9067>; else goto <D.9064>;
  <D.9064>:
}


compare_usymbol_samples (const void * a, const void * b)
{
  struct UnmanagedSymbol * D.12944;
  long unsigned int D.12945;
  struct UnmanagedSymbol * D.12946;
  long unsigned int D.12947;
  int D.12950;
  struct UnmanagedSymbol * const * A;
  struct UnmanagedSymbol * const * B;

  A = a;
  B = b;
  D.12944 = *B;
  D.12945 = D.12944->sample_hits;
  D.12946 = *A;
  D.12947 = D.12946->sample_hits;
  if (D.12945 == D.12947) goto <D.12948>; else goto <D.12949>;
  <D.12948>:
  D.12950 = 0;
  return D.12950;
  <D.12949>:
  D.12944 = *B;
  D.12945 = D.12944->sample_hits;
  D.12946 = *A;
  D.12947 = D.12946->sample_hits;
  if (D.12945 < D.12947) goto <D.12951>; else goto <D.12952>;
  <D.12951>:
  D.12950 = -1;
  return D.12950;
  <D.12952>:
  D.12950 = 1;
  return D.12950;
}


compare_method_samples (const void * a, const void * b)
{
  struct MethodDesc * D.12954;
  int D.12955;
  struct MethodDesc * D.12956;
  int D.12957;
  int D.12960;
  struct MethodDesc * const * A;
  struct MethodDesc * const * B;

  A = a;
  B = b;
  D.12954 = *A;
  D.12955 = D.12954->sample_hits;
  D.12956 = *B;
  D.12957 = D.12956->sample_hits;
  if (D.12955 == D.12957) goto <D.12958>; else goto <D.12959>;
  <D.12958>:
  D.12960 = 0;
  return D.12960;
  <D.12959>:
  D.12956 = *B;
  D.12957 = D.12956->sample_hits;
  D.12954 = *A;
  D.12955 = D.12954->sample_hits;
  if (D.12957 < D.12955) goto <D.12961>; else goto <D.12962>;
  <D.12961>:
  D.12960 = -1;
  return D.12960;
  <D.12962>:
  D.12960 = 1;
  return D.12960;
}


compare_usymbol_addr (const void * a, const void * b)
{
  struct UnmanagedSymbol * D.12964;
  long unsigned int D.12965;
  struct UnmanagedSymbol * D.12966;
  long unsigned int D.12967;
  int D.12970;
  struct UnmanagedSymbol * const * A;
  struct UnmanagedSymbol * const * B;

  A = a;
  B = b;
  D.12964 = *B;
  D.12965 = D.12964->addr;
  D.12966 = *A;
  D.12967 = D.12966->addr;
  if (D.12965 == D.12967) goto <D.12968>; else goto <D.12969>;
  <D.12968>:
  D.12970 = 0;
  return D.12970;
  <D.12969>:
  D.12964 = *B;
  D.12965 = D.12964->addr;
  D.12966 = *A;
  D.12967 = D.12966->addr;
  if (D.12965 > D.12967) goto <D.12971>; else goto <D.12972>;
  <D.12971>:
  D.12970 = -1;
  return D.12970;
  <D.12972>:
  D.12970 = 1;
  return D.12970;
}


lookup_method_by_ip (uintptr_t ip)
{
  long int D.12974;
  long unsigned int D.12975;
  int D.12978;
  long unsigned int D.12979;
  long unsigned int D.12980;
  struct MethodDesc * D.12983;
  int i;
  struct MethodDesc * m;

  i = 0;
  goto <D.8951>;
  <D.8950>:
  m = method_hash[i];
  goto <D.8948>;
  <D.8947>:
  D.12974 = m->code;
  D.12975 = (long unsigned int) D.12974;
  if (D.12975 <= ip) goto <D.12976>; else goto <D.12977>;
  <D.12976>:
  D.12974 = m->code;
  D.12975 = (long unsigned int) D.12974;
  D.12978 = m->len;
  D.12979 = (long unsigned int) D.12978;
  D.12980 = D.12975 + D.12979;
  if (D.12980 > ip) goto <D.12981>; else goto <D.12982>;
  <D.12981>:
  D.12983 = m;
  return D.12983;
  <D.12982>:
  <D.12977>:
  m = m->next;
  <D.8948>:
  if (m != 0B) goto <D.8947>; else goto <D.8949>;
  <D.8949>:
  i = i + 1;
  <D.8951>:
  if (i <= 9370) goto <D.8950>; else goto <D.8952>;
  <D.8952>:
  D.12983 = 0B;
  return D.12983;
}


lookup_unmanaged_symbol (uintptr_t addr)
{
  int usymbols_num.242;
  int D.12986;
  struct UnmanagedSymbol * * usymbols.243;
  long unsigned int D.12988;
  long unsigned int D.12989;
  struct UnmanagedSymbol * * D.12990;
  long unsigned int D.12991;
  struct UnmanagedSymbol * D.12994;
  long unsigned int D.13002;
  long unsigned int D.13003;
  struct UnmanagedSymbol * * D.13004;
  struct UnmanagedSymbol * D.13005;
  long unsigned int D.13006;
  long unsigned int D.13007;
  int r;
  int l;
  struct UnmanagedSymbol * sym;
  int last_best;

  usymbols_num.242 = usymbols_num;
  r = usymbols_num.242 + -1;
  l = 0;
  last_best = -1;
  goto <D.8998>;
  <D.8997>:
  {
    int m;

    D.12986 = l + r;
    m = D.12986 / 2;
    usymbols.243 = usymbols;
    D.12988 = (long unsigned int) m;
    D.12989 = D.12988 * 8;
    D.12990 = usymbols.243 + D.12989;
    sym = *D.12990;
    D.12991 = sym->addr;
    if (D.12991 == addr) goto <D.12992>; else goto <D.12993>;
    <D.12992>:
    D.12994 = sym;
    return D.12994;
    <D.12993>:
    D.12991 = sym->addr;
    if (D.12991 > addr) goto <D.12995>; else goto <D.12996>;
    <D.12995>:
    r = m + -1;
    goto <D.12997>;
    <D.12996>:
    D.12991 = sym->addr;
    if (D.12991 < addr) goto <D.12998>; else goto <D.12999>;
    <D.12998>:
    l = m + 1;
    last_best = m;
    <D.12999>:
    <D.12997>:
  }
  <D.8998>:
  if (r >= l) goto <D.8997>; else goto <D.8999>;
  <D.8999>:
  if (last_best >= 0) goto <D.13000>; else goto <D.13001>;
  <D.13000>:
  usymbols.243 = usymbols;
  D.13002 = (long unsigned int) last_best;
  D.13003 = D.13002 * 8;
  D.13004 = usymbols.243 + D.13003;
  D.13005 = *D.13004;
  D.13006 = D.13005->addr;
  D.13007 = addr - D.13006;
  if (D.13007 <= 4095) goto <D.13008>; else goto <D.13009>;
  <D.13008>:
  usymbols.243 = usymbols;
  D.13002 = (long unsigned int) last_best;
  D.13003 = D.13002 * 8;
  D.13004 = usymbols.243 + D.13003;
  D.12994 = *D.13004;
  return D.12994;
  <D.13009>:
  <D.13001>:
  D.12994 = 0B;
  return D.12994;
}


lookup_unmanaged_binary (uintptr_t addr)
{
  struct UnmanagedSymbol * * ubinaries.244;
  long unsigned int D.13012;
  long unsigned int D.13013;
  struct UnmanagedSymbol * * D.13014;
  long unsigned int D.13015;
  long unsigned int D.13018;
  long unsigned int D.13019;
  struct UnmanagedSymbol * D.13022;
  int ubinaries_num.245;
  int i;

  i = 0;
  goto <D.9016>;
  <D.9015>:
  {
    struct UnmanagedSymbol * ubin;

    ubinaries.244 = ubinaries;
    D.13012 = (long unsigned int) i;
    D.13013 = D.13012 * 8;
    D.13014 = ubinaries.244 + D.13013;
    ubin = *D.13014;
    D.13015 = ubin->addr;
    if (D.13015 <= addr) goto <D.13016>; else goto <D.13017>;
    <D.13016>:
    D.13015 = ubin->addr;
    D.13018 = ubin->size;
    D.13019 = D.13015 + D.13018;
    if (D.13019 > addr) goto <D.13020>; else goto <D.13021>;
    <D.13020>:
    D.13022 = ubin;
    return D.13022;
    <D.13021>:
    <D.13017>:
  }
  i = i + 1;
  <D.9016>:
  ubinaries_num.245 = ubinaries_num;
  if (i < ubinaries_num.245) goto <D.9015>; else goto <D.9017>;
  <D.9017>:
  D.13022 = 0B;
  return D.13022;
}


set_usym_parent (struct UnmanagedSymbol * * cachedus, int count)
{
  long unsigned int D.13025;
  long unsigned int D.13026;
  struct UnmanagedSymbol * * D.13027;
  struct UnmanagedSymbol * D.13028;
  long unsigned int D.13029;
  int i;

  i = 0;
  goto <D.9035>;
  <D.9034>:
  {
    struct UnmanagedSymbol * ubin;

    D.13025 = (long unsigned int) i;
    D.13026 = D.13025 * 8;
    D.13027 = cachedus + D.13026;
    D.13028 = *D.13027;
    D.13029 = D.13028->addr;
    ubin = lookup_unmanaged_binary (D.13029);
    D.13025 = (long unsigned int) i;
    D.13026 = D.13025 * 8;
    D.13027 = cachedus + D.13026;
    D.13028 = *D.13027;
    if (D.13028 == ubin) goto <D.13030>; else goto <D.13031>;
    <D.13030>:
    // predicted unlikely by continue predictor.
    goto <D.9033>;
    <D.13031>:
    D.13025 = (long unsigned int) i;
    D.13026 = D.13025 * 8;
    D.13027 = cachedus + D.13026;
    D.13028 = *D.13027;
    D.13028->parent = ubin;
  }
  <D.9033>:
  i = i + 1;
  <D.9035>:
  if (i < count) goto <D.9034>; else goto <D.9036>;
  <D.9036>:
}


sample_type_name (int type)
{
  const char * D.13033;

  switch (type) <default: <D.13034>, case 1: <D.9021>, case 2: <D.9022>, case 3: <D.9023>, case 4: <D.9024>, case 5: <D.9025>, case 6: <D.9026>>
  <D.9021>:
  D.13033 = "cycles";
  return D.13033;
  <D.9022>:
  D.13033 = "instructions retired";
  return D.13033;
  <D.9023>:
  D.13033 = "cache misses";
  return D.13033;
  <D.9024>:
  D.13033 = "cache references";
  return D.13033;
  <D.9025>:
  D.13033 = "executed branches";
  return D.13033;
  <D.9026>:
  D.13033 = "unpredicted branches";
  return D.13033;
  <D.13034>:
  D.13033 = "unknown";
  return D.13033;
}


sym_percent (uintptr_t sample_hits)
{
  int verbose.246;
  int D.13039;
  double D.13040;
  double D.13041;
  int num_stat_samples.247;
  double D.13043;
  _Bool D.13044;
  double pc;

  verbose.246 = verbose;
  if (verbose.246 != 0) goto <D.13037>; else goto <D.13038>;
  <D.13037>:
  D.13039 = 1;
  return D.13039;
  <D.13038>:
  D.13040 = (double) sample_hits;
  D.13041 = D.13040 * 1.0e+2;
  num_stat_samples.247 = num_stat_samples;
  D.13043 = (double) num_stat_samples.247;
  pc = D.13041 / D.13043;
  D.13044 = pc >= 1.000000000000000055511151231257827021181583404541015625e-1;
  D.13039 = (int) D.13044;
  return D.13039;
}


print_usym (struct UnmanagedSymbol * um)
{
  struct UnmanagedSymbol * D.13046;
  struct FILE * outfile.248;
  long unsigned int D.13050;
  double D.13051;
  double D.13052;
  int num_stat_samples.249;
  double D.13054;
  double D.13055;
  char * D.13056;
  char * D.13057;

  D.13046 = um->parent;
  if (D.13046 != 0B) goto <D.13047>; else goto <D.13048>;
  <D.13047>:
  outfile.248 = outfile;
  D.13050 = um->sample_hits;
  D.13050 = um->sample_hits;
  D.13051 = (double) D.13050;
  D.13052 = D.13051 * 1.0e+2;
  num_stat_samples.249 = num_stat_samples;
  D.13054 = (double) num_stat_samples.249;
  D.13055 = D.13052 / D.13054;
  D.13056 = um->name;
  D.13046 = um->parent;
  D.13057 = D.13046->name;
  fprintf (outfile.248, "\t%6d %6.2f %-36s in %s\n", D.13050, D.13055, D.13056, D.13057);
  goto <D.13058>;
  <D.13048>:
  outfile.248 = outfile;
  D.13050 = um->sample_hits;
  D.13050 = um->sample_hits;
  D.13051 = (double) D.13050;
  D.13052 = D.13051 * 1.0e+2;
  num_stat_samples.249 = num_stat_samples;
  D.13054 = (double) num_stat_samples.249;
  D.13055 = D.13052 / D.13054;
  D.13056 = um->name;
  fprintf (outfile.248, "\t%6d %6.2f %s\n", D.13050, D.13055, D.13056);
  <D.13058>:
}