utils_init (int fast_time)
{
  long long unsigned int D.9085;
  long long unsigned int time_inc.0;
  int D.9087;
  uint64_t (*<Tfdd>) (void) time_func.1;
  long long unsigned int D.9093;
  long long unsigned int D.9094;
  int timer_overhead.2;
  int i;
  uint64_t time_start;
  uint64_t time_end;

  if (fast_time > 1) goto <D.9080>; else goto <D.9081>;
  <D.9080>:
  time_func = null_time;
  goto <D.9082>;
  <D.9081>:
  if (fast_time != 0) goto <D.9083>; else goto <D.9084>;
  <D.9083>:
  {
    uint64_t timea;
    uint64_t timeb;

    clock_time ();
    timea = clock_time ();
    timeb = clock_time ();
    D.9085 = timeb - timea;
    time_inc.0 = D.9085 / 8;
    time_inc = time_inc.0;
    D.9087 = have_rdtsc ();
    if (D.9087 != 0) goto <D.9088>; else goto <D.9089>;
    <D.9088>:
    time_func = rdtsc_current_time;
    goto <D.9090>;
    <D.9089>:
    time_func = fast_current_time;
    <D.9090>:
  }
  goto <D.9091>;
  <D.9084>:
  time_func = clock_time;
  <D.9091>:
  <D.9082>:
  time_func.1 = time_func;
  time_start = time_func.1 ();
  i = 0;
  goto <D.5108>;
  <D.5107>:
  time_func.1 = time_func;
  time_func.1 ();
  i = i + 1;
  <D.5108>:
  if (i <= 255) goto <D.5107>; else goto <D.5109>;
  <D.5109>:
  time_func.1 = time_func;
  time_end = time_func.1 ();
  D.9093 = time_end - time_start;
  D.9094 = D.9093 / 256;
  timer_overhead.2 = (int) D.9094;
  timer_overhead = timer_overhead.2;
}


fast_current_time ()
{
  unsigned int D.9101;
  unsigned int D.9102;
  unsigned int D.9103;
  unsigned int D.9104;
  long long unsigned int D.9107;
  long long unsigned int time_inc.3;
  long long unsigned int D.9109;
  uint64_t D.9110;
  long long unsigned int D.9111;
  struct TlsData * tls;

  tls = &tls_data;
  D.9101 = tls->timer_count;
  D.9102 = D.9101;
  D.9103 = D.9102 + 1;
  tls->timer_count = D.9103;
  D.9104 = D.9102 & 7;
  if (D.9104 != 0) goto <D.9105>; else goto <D.9106>;
  <D.9105>:
  D.9107 = tls->last_time;
  time_inc.3 = time_inc;
  D.9109 = D.9107 + time_inc.3;
  tls->last_time = D.9109;
  D.9110 = tls->last_time;
  return D.9110;
  <D.9106>:
  D.9111 = clock_time ();
  tls->last_time = D.9111;
  D.9110 = tls->last_time;
  return D.9110;
}


rdtsc_current_time ()
{
  unsigned int D.9114;
  unsigned int D.9115;
  unsigned int D.9116;
  unsigned int D.9117;
  int cpu.4;
  int D.9123;
  long long unsigned int D.9126;
  long long unsigned int D.9127;
  double D.9130;
  double cpu_freq.5;
  double D.9132;
  uint64_t D.9133;
  long long unsigned int D.9134;
  long long unsigned int D.9136;
  int * D.9137;
  long long unsigned int D.9138;
  struct TlsData * tls;

  tls = &tls_data;
  D.9114 = tls->timer_count;
  D.9115 = D.9114;
  D.9116 = D.9115 + 1;
  tls->timer_count = D.9116;
  D.9117 = D.9115 & 63;
  if (D.9117 != 0) goto <D.9118>; else goto <D.9119>;
  <D.9118>:
  {
    int cpu;
    uint64_t tsc;

    try
      {
        tsc = safe_rdtsc (&cpu);
        cpu.4 = cpu;
        if (cpu.4 != -1) goto <D.9121>; else goto <D.9122>;
        <D.9121>:
        D.9123 = tls->last_cpu;
        cpu.4 = cpu;
        if (D.9123 == cpu.4) goto <D.9124>; else goto <D.9125>;
        <D.9124>:
        {
          int64_t diff;
          uint64_t nsecs;

          D.9126 = tls->last_rdtsc;
          D.9127 = tsc - D.9126;
          diff = (int64_t) D.9127;
          if (diff > 0) goto <D.9128>; else goto <D.9129>;
          <D.9128>:
          D.9130 = (double) diff;
          cpu_freq.5 = cpu_freq;
          D.9132 = D.9130 / cpu_freq.5;
          nsecs = (uint64_t) D.9132;
          D.9134 = tls->last_time;
          D.9133 = D.9134 + nsecs;
          return D.9133;
          <D.9129>:
          printf ("tsc went backwards\n");
        }
        goto <D.9135>;
        <D.9125>:
        <D.9135>:
        <D.9122>:
      }
    finally
      {
        cpu = {CLOBBER};
      }
  }
  <D.9119>:
  D.9136 = clock_time ();
  tls->last_time = D.9136;
  D.9137 = &tls->last_cpu;
  D.9138 = safe_rdtsc (D.9137);
  tls->last_rdtsc = D.9138;
  D.9133 = tls->last_time;
  return D.9133;
}


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

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


safe_rdtsc (int * cpu)
{
  uint64_t D.9151;
  long long unsigned int D.9152;
  long long unsigned int D.9153;
  long long unsigned int D.9154;
  unsigned int low;
  unsigned int high;
  int c1;
  int c2;

  c1 = sched_getcpu ();
  __asm__ __volatile__("rdtsc" : "=a" low, "=d" high);
  c2 = sched_getcpu ();
  if (c1 != c2) goto <D.9149>; else goto <D.9150>;
  <D.9149>:
  *cpu = -1;
  D.9151 = 0;
  return D.9151;
  <D.9150>:
  *cpu = c1;
  D.9152 = (long long unsigned int) high;
  D.9153 = D.9152 << 32;
  D.9154 = (long long unsigned int) low;
  D.9151 = D.9153 + D.9154;
  return D.9151;
}


null_time ()
{
  uint64_t D.9156;
  long long unsigned int timer.6;
  long long unsigned int timer.7;
  long long unsigned int timer.8;
  static uint64_t timer = 0;

  timer.6 = timer;
  timer.7 = timer.6;
  timer.8 = timer.7 + 1;
  timer = timer.8;
  D.9156 = timer.7;
  return D.9156;
}


clock_time ()
{
  uint64_t D.9161;
  long int D.9162;
  long long unsigned int D.9163;
  long long unsigned int D.9164;
  long int D.9165;
  long long unsigned int D.9166;
  struct timespec tspec;

  try
    {
      clock_gettime (1, &tspec);
      D.9162 = tspec.tv_sec;
      D.9163 = (long long unsigned int) D.9162;
      D.9164 = D.9163 * 1000000000;
      D.9165 = tspec.tv_nsec;
      D.9166 = (long long unsigned int) D.9165;
      D.9161 = D.9164 + D.9166;
      return D.9161;
    }
  finally
    {
      tspec = {CLOBBER};
    }
}


have_rdtsc ()
{
  int D.9171;
  int D.9174;
  float val.9;
  float D.9178;
  double cpu_freq.10;
  int D.9180;
  char * D.9183;
  char * D.9186;
  int iftmp.11;
  char buf[256];
  int have_freq;
  int have_flag;
  float val;
  struct FILE * cpuinfo;
  int cpu;

  try
    {
      have_freq = 0;
      have_flag = 0;
      cpu = sched_getcpu ();
      if (cpu < 0) goto <D.9169>; else goto <D.9170>;
      <D.9169>:
      D.9171 = 0;
      return D.9171;
      <D.9170>:
      cpuinfo = fopen ("/proc/cpuinfo", "r");
      if (cpuinfo == 0B) goto <D.9172>; else goto <D.9173>;
      <D.9172>:
      D.9171 = 0;
      return D.9171;
      <D.9173>:
      goto <D.5085>;
      <D.5084>:
      D.9174 = sscanf (&buf, "cpu MHz : %f", &val);
      if (D.9174 == 1) goto <D.9175>; else goto <D.9176>;
      <D.9175>:
      have_freq = 1;
      val.9 = val;
      D.9178 = val.9 * 1.0e+6;
      cpu_freq.10 = (double) D.9178;
      cpu_freq = cpu_freq.10;
      <D.9176>:
      D.9180 = strncmp (&buf, "flags :", 5);
      if (D.9180 == 0) goto <D.9181>; else goto <D.9182>;
      <D.9181>:
      D.9183 = strstr (&buf, "constant_tsc");
      if (D.9183 != 0B) goto <D.9184>; else goto <D.9185>;
      <D.9184>:
      have_flag = 1;
      <D.9185>:
      <D.9182>:
      <D.5085>:
      D.9186 = fgets (&buf, 256, cpuinfo);
      if (D.9186 != 0B) goto <D.5084>; else goto <D.5086>;
      <D.5086>:
      fclose (cpuinfo);
      if (have_flag != 0) goto <D.9188>; else goto <D.9189>;
      <D.9188>:
      iftmp.11 = have_freq;
      goto <D.9190>;
      <D.9189>:
      iftmp.11 = 0;
      <D.9190>:
      D.9171 = iftmp.11;
      return D.9171;
    }
  finally
    {
      buf = {CLOBBER};
      val = {CLOBBER};
    }
}


fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  unsigned int D.9196;
  int D.9201;
  char * D.9203;
  unsigned int D.9204;
  unsigned int __n.12;
  unsigned int D.9206;
  unsigned int D.9209;

  D.9196 = __builtin_object_size (__s, 1);
  if (D.9196 != 4294967295) goto <D.9197>; else goto <D.9198>;
  <D.9197>:
  D.9201 = __builtin_constant_p (__n);
  if (D.9201 == 0) goto <D.9199>; else goto <D.9202>;
  <D.9202>:
  if (__n <= 0) goto <D.9199>; else goto <D.9200>;
  <D.9199>:
  D.9204 = __builtin_object_size (__s, 1);
  D.9203 = __fgets_chk (__s, D.9204, __n, __stream);
  return D.9203;
  <D.9200>:
  __n.12 = (unsigned int) __n;
  D.9206 = __builtin_object_size (__s, 1);
  if (__n.12 > D.9206) goto <D.9207>; else goto <D.9208>;
  <D.9207>:
  D.9209 = __builtin_object_size (__s, 1);
  D.9203 = __fgets_chk_warn (__s, D.9209, __n, __stream);
  return D.9203;
  <D.9208>:
  <D.9198>:
  D.9203 = __fgets_alias (__s, __n, __stream);
  return D.9203;
}


get_timer_overhead ()
{
  int D.9214;

  D.9214 = timer_overhead;
  return D.9214;
}


current_time ()
{
  uint64_t D.9216;
  uint64_t (*<Tfdd>) (void) time_func.13;

  time_func.13 = time_func;
  D.9216 = time_func.13 ();
  return D.9216;
}


alloc_buffer (int size)
{
  unsigned int size.14;
  void * D.9223;
  void * ptr;

  size.14 = (unsigned int) size;
  ptr = mmap (0B, size.14, 3, 34, -1, 0);
  if (ptr == 4294967295B) goto <D.9221>; else goto <D.9222>;
  <D.9221>:
  D.9223 = 0B;
  return D.9223;
  <D.9222>:
  D.9223 = ptr;
  return D.9223;
}


free_buffer (void * buf, int size)
{
  unsigned int size.15;

  size.15 = (unsigned int) size;
  munmap (buf, size.15);
}


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.9226;
  uint8_t * p.16;
  uint8_t * p;

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

    D.9226 = (unsigned char) value;
    b = D.9226 & 127;
    value = value >> 7;
    if (value != 0) goto <D.9227>; else goto <D.9228>;
    <D.9227>:
    b = b | 128;
    <D.9228>:
    p.16 = p;
    p = p.16 + 1;
    *p.16 = b;
  }
  if (value != 0) goto <D.5137>; else goto <D.5138>;
  <D.5138>:
  *endbuf = p;
}


encode_sleb128 (intptr_t value, uint8_t * buf, uint8_t * * endbuf)
{
  _Bool D.9230;
  unsigned char D.9231;
  unsigned int D.9234;
  int D.9235;
  int D.9236;
  int D.9237;
  int D.9243;
  int D.9244;
  uint8_t * p.17;
  int more;
  int negative;
  unsigned int size;
  uint8_t byte;
  uint8_t * p;

  more = 1;
  D.9230 = value < 0;
  negative = (int) D.9230;
  size = 32;
  p = buf;
  goto <D.5150>;
  <D.5149>:
  D.9231 = (unsigned char) value;
  byte = D.9231 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.9232>; else goto <D.9233>;
  <D.9232>:
  D.9234 = size + 4294967289;
  D.9235 = (int) D.9234;
  D.9236 = 1 << D.9235;
  D.9237 = -D.9236;
  value = D.9237 | value;
  <D.9233>:
  if (value == 0) goto <D.9242>; else goto <D.9238>;
  <D.9242>:
  D.9243 = (int) byte;
  D.9244 = D.9243 & 64;
  if (D.9244 == 0) goto <D.9239>; else goto <D.9238>;
  <D.9238>:
  if (value == -1) goto <D.9245>; else goto <D.9240>;
  <D.9245>:
  D.9243 = (int) byte;
  D.9244 = D.9243 & 64;
  if (D.9244 != 0) goto <D.9239>; else goto <D.9240>;
  <D.9239>:
  more = 0;
  goto <D.9241>;
  <D.9240>:
  byte = byte | 128;
  <D.9241>:
  p.17 = p;
  p = p.17 + 1;
  *p.17 = byte;
  <D.5150>:
  if (more != 0) goto <D.5149>; else goto <D.5151>;
  <D.5151>:
  *endbuf = p;
}


decode_uleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  uint8_t * buf.18;
  long long unsigned int D.9248;
  long long unsigned int D.9249;
  long long unsigned int D.9250;
  signed char b.19;
  uint64_t D.9253;
  uint64_t res;
  int shift;

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

    buf.18 = buf;
    buf = buf.18 + 1;
    b = *buf.18;
    D.9248 = (long long unsigned int) b;
    D.9249 = D.9248 & 127;
    D.9250 = D.9249 << shift;
    res = D.9250 | res;
    b.19 = (signed char) b;
    if (b.19 >= 0) goto <D.5159>; else goto <D.9252>;
    <D.9252>:
    shift = shift + 7;
  }
  goto <D.5160>;
  <D.5159>:
  *endbuf = buf;
  D.9253 = res;
  return D.9253;
}


decode_sleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  int D.9255;
  int D.9256;
  int D.9257;
  signed char b.20;
  unsigned int shift.21;
  int D.9264;
  int D.9267;
  int D.9268;
  intptr_t D.9269;
  uint8_t * p;
  intptr_t res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.9255 = (int) b;
    D.9256 = D.9255 & 127;
    D.9257 = D.9256 << shift;
    res = D.9257 | res;
    shift = shift + 7;
    b.20 = (signed char) b;
    if (b.20 >= 0) goto <D.9259>; else goto <D.9260>;
    <D.9259>:
    shift.21 = (unsigned int) shift;
    if (shift.21 <= 31) goto <D.9262>; else goto <D.9263>;
    <D.9262>:
    D.9255 = (int) b;
    D.9264 = D.9255 & 64;
    if (D.9264 != 0) goto <D.9265>; else goto <D.9266>;
    <D.9265>:
    D.9267 = 1 << shift;
    D.9268 = -D.9267;
    res = D.9268 | res;
    <D.9266>:
    <D.9263>:
    goto <D.5169>;
    <D.9260>:
  }
  goto <D.5170>;
  <D.5169>:
  *endbuf = p;
  D.9269 = res;
  return D.9269;
}


thread_id ()
{
  uintptr_t D.9271;

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


process_id ()
{
  uintptr_t D.9273;
  int D.9274;

  D.9274 = getpid ();
  D.9273 = (uintptr_t) D.9274;
  return D.9273;
}


main (int argc, char * * argv)
{
  struct _IO_FILE * stdout.22;
  int D.8900;
  int iftmp.23;
  int D.8896;
  unsigned int i.24;
  unsigned int D.9281;
  char * * D.9282;
  const char[8] * D.9283;
  unsigned char D.9284;
  int D.9285;
  unsigned char D.9286;
  int D.9287;
  _Bool D.9288;
  _Bool D.9289;
  _Bool D.9290;
  const unsigned char * D.9293;
  unsigned char D.9294;
  int D.9295;
  const unsigned char * D.9296;
  unsigned char D.9297;
  int D.9298;
  _Bool D.9299;
  _Bool D.9300;
  const unsigned char * D.9303;
  unsigned char D.9304;
  int D.9305;
  const unsigned char * D.9306;
  unsigned char D.9307;
  int D.9308;
  _Bool D.9309;
  _Bool D.9310;
  const unsigned char * D.9313;
  unsigned char D.9314;
  int D.9315;
  const unsigned char * D.9316;
  unsigned char D.9317;
  int D.9318;
  char * D.9320;
  int debug.25;
  int debug.26;
  int D.8909;
  int iftmp.27;
  int D.8905;
  const char[7] * D.9329;
  unsigned char D.9330;
  int D.9331;
  unsigned char D.9332;
  int D.9333;
  _Bool D.9334;
  _Bool D.9335;
  _Bool D.9336;
  const unsigned char * D.9339;
  unsigned char D.9340;
  int D.9341;
  const unsigned char * D.9342;
  unsigned char D.9343;
  int D.9344;
  _Bool D.9345;
  _Bool D.9346;
  const unsigned char * D.9349;
  unsigned char D.9350;
  int D.9351;
  const unsigned char * D.9352;
  unsigned char D.9353;
  int D.9354;
  _Bool D.9355;
  _Bool D.9356;
  const unsigned char * D.9359;
  unsigned char D.9360;
  int D.9361;
  const unsigned char * D.9362;
  unsigned char D.9363;
  int D.9364;
  int D.9368;
  int D.9369;
  int D.8928;
  int iftmp.28;
  int D.8927;
  const char[6] * D.9375;
  unsigned char D.9376;
  int D.9377;
  unsigned char D.9378;
  int D.9379;
  _Bool D.9380;
  _Bool D.9381;
  _Bool D.9382;
  const unsigned char * D.9385;
  unsigned char D.9386;
  int D.9387;
  const unsigned char * D.9388;
  unsigned char D.9389;
  int D.9390;
  _Bool D.9391;
  _Bool D.9392;
  const unsigned char * D.9395;
  unsigned char D.9396;
  int D.9397;
  const unsigned char * D.9398;
  unsigned char D.9399;
  int D.9400;
  _Bool D.9401;
  _Bool D.9402;
  const unsigned char * D.9405;
  unsigned char D.9406;
  int D.9407;
  const unsigned char * D.9408;
  unsigned char D.9409;
  int D.9410;
  int D.8937;
  int iftmp.29;
  int D.8936;
  const char[6] * D.9418;
  unsigned char D.9419;
  int D.9420;
  unsigned char D.9421;
  int D.9422;
  _Bool D.9423;
  _Bool D.9424;
  _Bool D.9425;
  const unsigned char * D.9428;
  unsigned char D.9429;
  int D.9430;
  const unsigned char * D.9431;
  unsigned char D.9432;
  int D.9433;
  _Bool D.9434;
  _Bool D.9435;
  const unsigned char * D.9438;
  unsigned char D.9439;
  int D.9440;
  const unsigned char * D.9441;
  unsigned char D.9442;
  int D.9443;
  _Bool D.9444;
  _Bool D.9445;
  const unsigned char * D.9448;
  unsigned char D.9449;
  int D.9450;
  const unsigned char * D.9451;
  unsigned char D.9452;
  int D.9453;
  int D.9459;
  int D.8956;
  int iftmp.30;
  int D.8955;
  const char[6] * D.9465;
  unsigned char D.9466;
  int D.9467;
  unsigned char D.9468;
  int D.9469;
  _Bool D.9470;
  _Bool D.9471;
  _Bool D.9472;
  const unsigned char * D.9475;
  unsigned char D.9476;
  int D.9477;
  const unsigned char * D.9478;
  unsigned char D.9479;
  int D.9480;
  _Bool D.9481;
  _Bool D.9482;
  const unsigned char * D.9485;
  unsigned char D.9486;
  int D.9487;
  const unsigned char * D.9488;
  unsigned char D.9489;
  int D.9490;
  _Bool D.9491;
  _Bool D.9492;
  const unsigned char * D.9495;
  unsigned char D.9496;
  int D.9497;
  const unsigned char * D.9498;
  unsigned char D.9499;
  int D.9500;
  int D.8965;
  int iftmp.31;
  int D.8964;
  const char[5] * D.9508;
  unsigned char D.9509;
  int D.9510;
  unsigned char D.9511;
  int D.9512;
  _Bool D.9513;
  _Bool D.9514;
  _Bool D.9515;
  const unsigned char * D.9518;
  unsigned char D.9519;
  int D.9520;
  const unsigned char * D.9521;
  unsigned char D.9522;
  int D.9523;
  _Bool D.9524;
  _Bool D.9525;
  const unsigned char * D.9528;
  unsigned char D.9529;
  int D.9530;
  const unsigned char * D.9531;
  unsigned char D.9532;
  int D.9533;
  _Bool D.9534;
  _Bool D.9535;
  const unsigned char * D.9538;
  unsigned char D.9539;
  int D.9540;
  const unsigned char * D.9541;
  unsigned char D.9542;
  int D.9543;
  int D.8974;
  int iftmp.32;
  int D.8973;
  const char[6] * D.9551;
  unsigned char D.9552;
  int D.9553;
  unsigned char D.9554;
  int D.9555;
  _Bool D.9556;
  _Bool D.9557;
  _Bool D.9558;
  const unsigned char * D.9561;
  unsigned char D.9562;
  int D.9563;
  const unsigned char * D.9564;
  unsigned char D.9565;
  int D.9566;
  _Bool D.9567;
  _Bool D.9568;
  const unsigned char * D.9571;
  unsigned char D.9572;
  int D.9573;
  const unsigned char * D.9574;
  unsigned char D.9575;
  int D.9576;
  _Bool D.9577;
  _Bool D.9578;
  const unsigned char * D.9581;
  unsigned char D.9582;
  int D.9583;
  const unsigned char * D.9584;
  unsigned char D.9585;
  int D.9586;
  int D.9592;
  int D.9595;
  int D.9599;
  struct FILE * outfile.33;
  struct FILE * outfile.34;
  int D.9607;
  long unsigned int D.9610;
  int trace_max.35;
  int D.9613;
  int D.9616;
  int D.9620;
  char D.9623;
  int D.9627;
  long unsigned int thread_filter.36;
  int D.9632;
  const char * D.9635;
  char * top.37;
  double D.9641;
  long long unsigned int time_from.38;
  double D.9643;
  long long unsigned int time_to.39;
  int D.9063;
  int iftmp.40;
  int D.9059;
  const char[10] * D.9649;
  unsigned char D.9650;
  int D.9651;
  unsigned char D.9652;
  int D.9653;
  _Bool D.9654;
  _Bool D.9655;
  _Bool D.9656;
  const unsigned char * D.9659;
  unsigned char D.9660;
  int D.9661;
  const unsigned char * D.9662;
  unsigned char D.9663;
  int D.9664;
  _Bool D.9665;
  _Bool D.9666;
  const unsigned char * D.9669;
  unsigned char D.9670;
  int D.9671;
  const unsigned char * D.9672;
  unsigned char D.9673;
  int D.9674;
  _Bool D.9675;
  _Bool D.9676;
  const unsigned char * D.9679;
  unsigned char D.9680;
  int D.9681;
  const unsigned char * D.9682;
  unsigned char D.9683;
  int D.9684;
  int verbose.41;
  int verbose.42;
  int D.9072;
  int iftmp.43;
  int D.9068;
  const char[9] * D.9694;
  unsigned char D.9695;
  int D.9696;
  unsigned char D.9697;
  int D.9698;
  _Bool D.9699;
  _Bool D.9700;
  _Bool D.9701;
  const unsigned char * D.9704;
  unsigned char D.9705;
  int D.9706;
  const unsigned char * D.9707;
  unsigned char D.9708;
  int D.9709;
  _Bool D.9710;
  _Bool D.9711;
  const unsigned char * D.9714;
  unsigned char D.9715;
  int D.9716;
  const unsigned char * D.9717;
  unsigned char D.9718;
  int D.9719;
  _Bool D.9720;
  _Bool D.9721;
  const unsigned char * D.9724;
  unsigned char D.9725;
  int D.9726;
  const unsigned char * D.9727;
  unsigned char D.9728;
  int D.9729;
  int D.9736;
  int num_tracked_objects.44;
  const char * reports.45;
  struct ProfContext * ctx;
  int i;

  stdout.22 = stdout;
  outfile = stdout.22;
  i = 1;
  goto <D.9075>;
  <D.9074>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      i.24 = (unsigned int) i;
      D.9281 = i.24 * 4;
      D.9282 = argv + D.9281;
      __s2 = *D.9282;
      D.9283 = "--debug";
      D.9284 = MEM[(const unsigned char *)D.9283];
      D.9285 = (int) D.9284;
      D.9286 = *__s2;
      D.9287 = (int) D.9286;
      __result = D.9285 - D.9287;
      {
        D.9288 = __s1_len != 0;
        D.9289 = __result == 0;
        D.9290 = D.9288 & D.9289;
        if (D.9290 != 0) goto <D.9291>; else goto <D.9292>;
        <D.9291>:
        D.9293 = &MEM[(void *)"--debug" + 1B];
        D.9294 = *D.9293;
        D.9295 = (int) D.9294;
        D.9296 = __s2 + 1;
        D.9297 = *D.9296;
        D.9298 = (int) D.9297;
        __result = D.9295 - D.9298;
        D.9299 = __s1_len > 1;
        D.9289 = __result == 0;
        D.9300 = D.9299 & D.9289;
        if (D.9300 != 0) goto <D.9301>; else goto <D.9302>;
        <D.9301>:
        D.9303 = &MEM[(void *)"--debug" + 2B];
        D.9304 = *D.9303;
        D.9305 = (int) D.9304;
        D.9306 = __s2 + 2;
        D.9307 = *D.9306;
        D.9308 = (int) D.9307;
        __result = D.9305 - D.9308;
        D.9309 = __s1_len > 2;
        D.9289 = __result == 0;
        D.9310 = D.9309 & D.9289;
        if (D.9310 != 0) goto <D.9311>; else goto <D.9312>;
        <D.9311>:
        D.9313 = &MEM[(void *)"--debug" + 3B];
        D.9314 = *D.9313;
        D.9315 = (int) D.9314;
        D.9316 = __s2 + 3;
        D.9317 = *D.9316;
        D.9318 = (int) D.9317;
        __result = D.9315 - D.9318;
        <D.9312>:
        <D.9302>:
        <D.9292>:
      }
      D.8896 = __result;
    }
    iftmp.23 = D.8896;
    goto <D.9319>;
    <D.9279>:
    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    iftmp.23 = __builtin_strcmp ("--debug", D.9320);
    <D.9319>:
    D.8900 = iftmp.23;
  }
  if (D.8900 == 0) goto <D.9321>; else goto <D.9322>;
  <D.9321>:
  debug.25 = debug;
  debug.26 = debug.25 + 1;
  debug = debug.26;
  goto <D.9325>;
  <D.9322>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      i.24 = (unsigned int) i;
      D.9281 = i.24 * 4;
      D.9282 = argv + D.9281;
      __s2 = *D.9282;
      D.9329 = "--help";
      D.9330 = MEM[(const unsigned char *)D.9329];
      D.9331 = (int) D.9330;
      D.9332 = *__s2;
      D.9333 = (int) D.9332;
      __result = D.9331 - D.9333;
      {
        D.9334 = __s1_len != 0;
        D.9335 = __result == 0;
        D.9336 = D.9334 & D.9335;
        if (D.9336 != 0) goto <D.9337>; else goto <D.9338>;
        <D.9337>:
        D.9339 = &MEM[(void *)"--help" + 1B];
        D.9340 = *D.9339;
        D.9341 = (int) D.9340;
        D.9342 = __s2 + 1;
        D.9343 = *D.9342;
        D.9344 = (int) D.9343;
        __result = D.9341 - D.9344;
        D.9345 = __s1_len > 1;
        D.9335 = __result == 0;
        D.9346 = D.9345 & D.9335;
        if (D.9346 != 0) goto <D.9347>; else goto <D.9348>;
        <D.9347>:
        D.9349 = &MEM[(void *)"--help" + 2B];
        D.9350 = *D.9349;
        D.9351 = (int) D.9350;
        D.9352 = __s2 + 2;
        D.9353 = *D.9352;
        D.9354 = (int) D.9353;
        __result = D.9351 - D.9354;
        D.9355 = __s1_len > 2;
        D.9335 = __result == 0;
        D.9356 = D.9355 & D.9335;
        if (D.9356 != 0) goto <D.9357>; else goto <D.9358>;
        <D.9357>:
        D.9359 = &MEM[(void *)"--help" + 3B];
        D.9360 = *D.9359;
        D.9361 = (int) D.9360;
        D.9362 = __s2 + 3;
        D.9363 = *D.9362;
        D.9364 = (int) D.9363;
        __result = D.9361 - D.9364;
        <D.9358>:
        <D.9348>:
        <D.9338>:
      }
      D.8905 = __result;
    }
    iftmp.27 = D.8905;
    goto <D.9365>;
    <D.9328>:
    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    iftmp.27 = __builtin_strcmp ("--help", D.9320);
    <D.9365>:
    D.8909 = iftmp.27;
  }
  if (D.8909 == 0) goto <D.9366>; else goto <D.9367>;
  <D.9366>:
  usage ();
  D.9368 = 0;
  return D.9368;
  <D.9367>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  D.9369 = strncmp ("--alloc-sort=", D.9320, 13);
  if (D.9369 == 0) goto <D.9370>; else goto <D.9371>;
  <D.9370>:
  {
    const char * val;

    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    val = D.9320 + 13;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = val;
        D.9375 = "bytes";
        D.9376 = MEM[(const unsigned char *)D.9375];
        D.9377 = (int) D.9376;
        D.9378 = *__s2;
        D.9379 = (int) D.9378;
        __result = D.9377 - D.9379;
        {
          D.9380 = __s2_len != 0;
          D.9381 = __result == 0;
          D.9382 = D.9380 & D.9381;
          if (D.9382 != 0) goto <D.9383>; else goto <D.9384>;
          <D.9383>:
          D.9385 = &MEM[(void *)"bytes" + 1B];
          D.9386 = *D.9385;
          D.9387 = (int) D.9386;
          D.9388 = __s2 + 1;
          D.9389 = *D.9388;
          D.9390 = (int) D.9389;
          __result = D.9387 - D.9390;
          D.9391 = __s2_len > 1;
          D.9381 = __result == 0;
          D.9392 = D.9391 & D.9381;
          if (D.9392 != 0) goto <D.9393>; else goto <D.9394>;
          <D.9393>:
          D.9395 = &MEM[(void *)"bytes" + 2B];
          D.9396 = *D.9395;
          D.9397 = (int) D.9396;
          D.9398 = __s2 + 2;
          D.9399 = *D.9398;
          D.9400 = (int) D.9399;
          __result = D.9397 - D.9400;
          D.9401 = __s2_len > 2;
          D.9381 = __result == 0;
          D.9402 = D.9401 & D.9381;
          if (D.9402 != 0) goto <D.9403>; else goto <D.9404>;
          <D.9403>:
          D.9405 = &MEM[(void *)"bytes" + 3B];
          D.9406 = *D.9405;
          D.9407 = (int) D.9406;
          D.9408 = __s2 + 3;
          D.9409 = *D.9408;
          D.9410 = (int) D.9409;
          __result = D.9407 - D.9410;
          <D.9404>:
          <D.9394>:
          <D.9384>:
        }
        D.8927 = __result;
      }
      iftmp.28 = -D.8927;
      goto <D.9411>;
      <D.9374>:
      iftmp.28 = __builtin_strcmp (val, "bytes");
      <D.9411>:
      D.8928 = iftmp.28;
    }
    if (D.8928 == 0) goto <D.9412>; else goto <D.9413>;
    <D.9412>:
    alloc_sort_mode = 0;
    goto <D.9414>;
    <D.9413>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = val;
        D.9418 = "count";
        D.9419 = MEM[(const unsigned char *)D.9418];
        D.9420 = (int) D.9419;
        D.9421 = *__s2;
        D.9422 = (int) D.9421;
        __result = D.9420 - D.9422;
        {
          D.9423 = __s2_len != 0;
          D.9424 = __result == 0;
          D.9425 = D.9423 & D.9424;
          if (D.9425 != 0) goto <D.9426>; else goto <D.9427>;
          <D.9426>:
          D.9428 = &MEM[(void *)"count" + 1B];
          D.9429 = *D.9428;
          D.9430 = (int) D.9429;
          D.9431 = __s2 + 1;
          D.9432 = *D.9431;
          D.9433 = (int) D.9432;
          __result = D.9430 - D.9433;
          D.9434 = __s2_len > 1;
          D.9424 = __result == 0;
          D.9435 = D.9434 & D.9424;
          if (D.9435 != 0) goto <D.9436>; else goto <D.9437>;
          <D.9436>:
          D.9438 = &MEM[(void *)"count" + 2B];
          D.9439 = *D.9438;
          D.9440 = (int) D.9439;
          D.9441 = __s2 + 2;
          D.9442 = *D.9441;
          D.9443 = (int) D.9442;
          __result = D.9440 - D.9443;
          D.9444 = __s2_len > 2;
          D.9424 = __result == 0;
          D.9445 = D.9444 & D.9424;
          if (D.9445 != 0) goto <D.9446>; else goto <D.9447>;
          <D.9446>:
          D.9448 = &MEM[(void *)"count" + 3B];
          D.9449 = *D.9448;
          D.9450 = (int) D.9449;
          D.9451 = __s2 + 3;
          D.9452 = *D.9451;
          D.9453 = (int) D.9452;
          __result = D.9450 - D.9453;
          <D.9447>:
          <D.9437>:
          <D.9427>:
        }
        D.8936 = __result;
      }
      iftmp.29 = -D.8936;
      goto <D.9454>;
      <D.9417>:
      iftmp.29 = __builtin_strcmp (val, "count");
      <D.9454>:
      D.8937 = iftmp.29;
    }
    if (D.8937 == 0) goto <D.9455>; else goto <D.9456>;
    <D.9455>:
    alloc_sort_mode = 1;
    goto <D.9457>;
    <D.9456>:
    usage ();
    D.9368 = 1;
    return D.9368;
    <D.9457>:
    <D.9414>:
  }
  goto <D.9458>;
  <D.9371>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  D.9459 = strncmp ("--method-sort=", D.9320, 14);
  if (D.9459 == 0) goto <D.9460>; else goto <D.9461>;
  <D.9460>:
  {
    const char * val;

    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    val = D.9320 + 14;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = val;
        D.9465 = "total";
        D.9466 = MEM[(const unsigned char *)D.9465];
        D.9467 = (int) D.9466;
        D.9468 = *__s2;
        D.9469 = (int) D.9468;
        __result = D.9467 - D.9469;
        {
          D.9470 = __s2_len != 0;
          D.9471 = __result == 0;
          D.9472 = D.9470 & D.9471;
          if (D.9472 != 0) goto <D.9473>; else goto <D.9474>;
          <D.9473>:
          D.9475 = &MEM[(void *)"total" + 1B];
          D.9476 = *D.9475;
          D.9477 = (int) D.9476;
          D.9478 = __s2 + 1;
          D.9479 = *D.9478;
          D.9480 = (int) D.9479;
          __result = D.9477 - D.9480;
          D.9481 = __s2_len > 1;
          D.9471 = __result == 0;
          D.9482 = D.9481 & D.9471;
          if (D.9482 != 0) goto <D.9483>; else goto <D.9484>;
          <D.9483>:
          D.9485 = &MEM[(void *)"total" + 2B];
          D.9486 = *D.9485;
          D.9487 = (int) D.9486;
          D.9488 = __s2 + 2;
          D.9489 = *D.9488;
          D.9490 = (int) D.9489;
          __result = D.9487 - D.9490;
          D.9491 = __s2_len > 2;
          D.9471 = __result == 0;
          D.9492 = D.9491 & D.9471;
          if (D.9492 != 0) goto <D.9493>; else goto <D.9494>;
          <D.9493>:
          D.9495 = &MEM[(void *)"total" + 3B];
          D.9496 = *D.9495;
          D.9497 = (int) D.9496;
          D.9498 = __s2 + 3;
          D.9499 = *D.9498;
          D.9500 = (int) D.9499;
          __result = D.9497 - D.9500;
          <D.9494>:
          <D.9484>:
          <D.9474>:
        }
        D.8955 = __result;
      }
      iftmp.30 = -D.8955;
      goto <D.9501>;
      <D.9464>:
      iftmp.30 = __builtin_strcmp (val, "total");
      <D.9501>:
      D.8956 = iftmp.30;
    }
    if (D.8956 == 0) goto <D.9502>; else goto <D.9503>;
    <D.9502>:
    method_sort_mode = 0;
    goto <D.9504>;
    <D.9503>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = val;
        D.9508 = "self";
        D.9509 = MEM[(const unsigned char *)D.9508];
        D.9510 = (int) D.9509;
        D.9511 = *__s2;
        D.9512 = (int) D.9511;
        __result = D.9510 - D.9512;
        {
          D.9513 = __s2_len != 0;
          D.9514 = __result == 0;
          D.9515 = D.9513 & D.9514;
          if (D.9515 != 0) goto <D.9516>; else goto <D.9517>;
          <D.9516>:
          D.9518 = &MEM[(void *)"self" + 1B];
          D.9519 = *D.9518;
          D.9520 = (int) D.9519;
          D.9521 = __s2 + 1;
          D.9522 = *D.9521;
          D.9523 = (int) D.9522;
          __result = D.9520 - D.9523;
          D.9524 = __s2_len > 1;
          D.9514 = __result == 0;
          D.9525 = D.9524 & D.9514;
          if (D.9525 != 0) goto <D.9526>; else goto <D.9527>;
          <D.9526>:
          D.9528 = &MEM[(void *)"self" + 2B];
          D.9529 = *D.9528;
          D.9530 = (int) D.9529;
          D.9531 = __s2 + 2;
          D.9532 = *D.9531;
          D.9533 = (int) D.9532;
          __result = D.9530 - D.9533;
          D.9534 = __s2_len > 2;
          D.9514 = __result == 0;
          D.9535 = D.9534 & D.9514;
          if (D.9535 != 0) goto <D.9536>; else goto <D.9537>;
          <D.9536>:
          D.9538 = &MEM[(void *)"self" + 3B];
          D.9539 = *D.9538;
          D.9540 = (int) D.9539;
          D.9541 = __s2 + 3;
          D.9542 = *D.9541;
          D.9543 = (int) D.9542;
          __result = D.9540 - D.9543;
          <D.9537>:
          <D.9527>:
          <D.9517>:
        }
        D.8964 = __result;
      }
      iftmp.31 = -D.8964;
      goto <D.9544>;
      <D.9507>:
      iftmp.31 = __builtin_strcmp (val, "self");
      <D.9544>:
      D.8965 = iftmp.31;
    }
    if (D.8965 == 0) goto <D.9545>; else goto <D.9546>;
    <D.9545>:
    method_sort_mode = 1;
    goto <D.9547>;
    <D.9546>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = val;
        D.9551 = "calls";
        D.9552 = MEM[(const unsigned char *)D.9551];
        D.9553 = (int) D.9552;
        D.9554 = *__s2;
        D.9555 = (int) D.9554;
        __result = D.9553 - D.9555;
        {
          D.9556 = __s2_len != 0;
          D.9557 = __result == 0;
          D.9558 = D.9556 & D.9557;
          if (D.9558 != 0) goto <D.9559>; else goto <D.9560>;
          <D.9559>:
          D.9561 = &MEM[(void *)"calls" + 1B];
          D.9562 = *D.9561;
          D.9563 = (int) D.9562;
          D.9564 = __s2 + 1;
          D.9565 = *D.9564;
          D.9566 = (int) D.9565;
          __result = D.9563 - D.9566;
          D.9567 = __s2_len > 1;
          D.9557 = __result == 0;
          D.9568 = D.9567 & D.9557;
          if (D.9568 != 0) goto <D.9569>; else goto <D.9570>;
          <D.9569>:
          D.9571 = &MEM[(void *)"calls" + 2B];
          D.9572 = *D.9571;
          D.9573 = (int) D.9572;
          D.9574 = __s2 + 2;
          D.9575 = *D.9574;
          D.9576 = (int) D.9575;
          __result = D.9573 - D.9576;
          D.9577 = __s2_len > 2;
          D.9557 = __result == 0;
          D.9578 = D.9577 & D.9557;
          if (D.9578 != 0) goto <D.9579>; else goto <D.9580>;
          <D.9579>:
          D.9581 = &MEM[(void *)"calls" + 3B];
          D.9582 = *D.9581;
          D.9583 = (int) D.9582;
          D.9584 = __s2 + 3;
          D.9585 = *D.9584;
          D.9586 = (int) D.9585;
          __result = D.9583 - D.9586;
          <D.9580>:
          <D.9570>:
          <D.9560>:
        }
        D.8973 = __result;
      }
      iftmp.32 = -D.8973;
      goto <D.9587>;
      <D.9550>:
      iftmp.32 = __builtin_strcmp (val, "calls");
      <D.9587>:
      D.8974 = iftmp.32;
    }
    if (D.8974 == 0) goto <D.9588>; else goto <D.9589>;
    <D.9588>:
    method_sort_mode = 2;
    goto <D.9590>;
    <D.9589>:
    usage ();
    D.9368 = 1;
    return D.9368;
    <D.9590>:
    <D.9547>:
    <D.9504>:
  }
  goto <D.9591>;
  <D.9461>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  D.9592 = strncmp ("--reports=", D.9320, 10);
  if (D.9592 == 0) goto <D.9593>; else goto <D.9594>;
  <D.9593>:
  {
    const char * val;

    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    val = D.9320 + 10;
    D.9595 = print_reports (0B, val, 1);
    if (D.9595 == 0) goto <D.9596>; else goto <D.9597>;
    <D.9596>:
    usage ();
    D.9368 = 1;
    return D.9368;
    <D.9597>:
    reports = val;
  }
  goto <D.9598>;
  <D.9594>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  D.9599 = strncmp ("--out=", D.9320, 6);
  if (D.9599 == 0) goto <D.9600>; else goto <D.9601>;
  <D.9600>:
  {
    const char * val;

    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    val = D.9320 + 6;
    outfile.33 = fopen (val, "w");
    outfile = outfile.33;
    outfile.34 = outfile;
    if (outfile.34 == 0B) goto <D.9604>; else goto <D.9605>;
    <D.9604>:
    printf ("Cannot open output file: %s\n", val);
    D.9368 = 1;
    return D.9368;
    <D.9605>:
  }
  goto <D.9606>;
  <D.9601>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  D.9607 = strncmp ("--maxframes=", D.9320, 12);
  if (D.9607 == 0) goto <D.9608>; else goto <D.9609>;
  <D.9608>:
  {
    const char * val;
    char * vale;

    try
      {
        i.24 = (unsigned int) i;
        D.9281 = i.24 * 4;
        D.9282 = argv + D.9281;
        D.9320 = *D.9282;
        val = D.9320 + 12;
        D.9610 = strtoul (val, &vale, 10);
        trace_max.35 = (int) D.9610;
        trace_max = trace_max.35;
      }
    finally
      {
        vale = {CLOBBER};
      }
  }
  goto <D.9612>;
  <D.9609>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  D.9613 = strncmp ("--find=", D.9320, 7);
  if (D.9613 == 0) goto <D.9614>; else goto <D.9615>;
  <D.9614>:
  {
    const char * val;

    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    val = D.9320 + 7;
    D.9616 = add_find_spec (val);
    if (D.9616 == 0) goto <D.9617>; else goto <D.9618>;
    <D.9617>:
    usage ();
    D.9368 = 1;
    return D.9368;
    <D.9618>:
  }
  goto <D.9619>;
  <D.9615>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  D.9620 = strncmp ("--track=", D.9320, 8);
  if (D.9620 == 0) goto <D.9621>; else goto <D.9622>;
  <D.9621>:
  {
    const char * val;
    char * vale;

    try
      {
        i.24 = (unsigned int) i;
        D.9281 = i.24 * 4;
        D.9282 = argv + D.9281;
        D.9320 = *D.9282;
        val = D.9320 + 8;
        goto <D.9028>;
        <D.9029>:
        {
          uintptr_t tracked_obj;

          D.9623 = *val;
          if (D.9623 == 44) goto <D.9624>; else goto <D.9625>;
          <D.9624>:
          val = val + 1;
          // predicted unlikely by continue predictor.
          goto <D.9028>;
          <D.9625>:
          tracked_obj = strtoul (val, &vale, 0);
          found_object (tracked_obj);
          val = vale;
        }
        <D.9028>:
        D.9623 = *val;
        if (D.9623 != 0) goto <D.9029>; else goto <D.9030>;
        <D.9030>:
      }
    finally
      {
        vale = {CLOBBER};
      }
  }
  goto <D.9626>;
  <D.9622>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  D.9627 = strncmp ("--thread=", D.9320, 9);
  if (D.9627 == 0) goto <D.9628>; else goto <D.9629>;
  <D.9628>:
  {
    const char * val;
    char * vale;

    try
      {
        i.24 = (unsigned int) i;
        D.9281 = i.24 * 4;
        D.9282 = argv + D.9281;
        D.9320 = *D.9282;
        val = D.9320 + 9;
        thread_filter.36 = strtoul (val, &vale, 0);
        thread_filter = thread_filter.36;
      }
    finally
      {
        vale = {CLOBBER};
      }
  }
  goto <D.9631>;
  <D.9629>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  D.9632 = strncmp ("--time=", D.9320, 7);
  if (D.9632 == 0) goto <D.9633>; else goto <D.9634>;
  <D.9633>:
  {
    char * val;
    double from_secs;
    double to_secs;
    char * top;

    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    D.9635 = D.9320 + 7;
    val = pstrdup (D.9635);
    top = __builtin_strchr (val, 45);
    if (top == 0B) goto <D.9636>; else goto <D.9637>;
    <D.9636>:
    usage ();
    D.9368 = 1;
    return D.9368;
    <D.9637>:
    top.37 = top;
    top = top.37 + 1;
    *top.37 = 0;
    from_secs = atof (val);
    to_secs = atof (top);
    free (val);
    if (from_secs > to_secs) goto <D.9639>; else goto <D.9640>;
    <D.9639>:
    usage ();
    D.9368 = 1;
    return D.9368;
    <D.9640>:
    D.9641 = from_secs * 1.0e+9;
    time_from.38 = (long long unsigned int) D.9641;
    time_from = time_from.38;
    D.9643 = to_secs * 1.0e+9;
    time_to.39 = (long long unsigned int) D.9643;
    time_to = time_to.39;
  }
  goto <D.9645>;
  <D.9634>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      i.24 = (unsigned int) i;
      D.9281 = i.24 * 4;
      D.9282 = argv + D.9281;
      __s2 = *D.9282;
      D.9649 = "--verbose";
      D.9650 = MEM[(const unsigned char *)D.9649];
      D.9651 = (int) D.9650;
      D.9652 = *__s2;
      D.9653 = (int) D.9652;
      __result = D.9651 - D.9653;
      {
        D.9654 = __s1_len != 0;
        D.9655 = __result == 0;
        D.9656 = D.9654 & D.9655;
        if (D.9656 != 0) goto <D.9657>; else goto <D.9658>;
        <D.9657>:
        D.9659 = &MEM[(void *)"--verbose" + 1B];
        D.9660 = *D.9659;
        D.9661 = (int) D.9660;
        D.9662 = __s2 + 1;
        D.9663 = *D.9662;
        D.9664 = (int) D.9663;
        __result = D.9661 - D.9664;
        D.9665 = __s1_len > 1;
        D.9655 = __result == 0;
        D.9666 = D.9665 & D.9655;
        if (D.9666 != 0) goto <D.9667>; else goto <D.9668>;
        <D.9667>:
        D.9669 = &MEM[(void *)"--verbose" + 2B];
        D.9670 = *D.9669;
        D.9671 = (int) D.9670;
        D.9672 = __s2 + 2;
        D.9673 = *D.9672;
        D.9674 = (int) D.9673;
        __result = D.9671 - D.9674;
        D.9675 = __s1_len > 2;
        D.9655 = __result == 0;
        D.9676 = D.9675 & D.9655;
        if (D.9676 != 0) goto <D.9677>; else goto <D.9678>;
        <D.9677>:
        D.9679 = &MEM[(void *)"--verbose" + 3B];
        D.9680 = *D.9679;
        D.9681 = (int) D.9680;
        D.9682 = __s2 + 3;
        D.9683 = *D.9682;
        D.9684 = (int) D.9683;
        __result = D.9681 - D.9684;
        <D.9678>:
        <D.9668>:
        <D.9658>:
      }
      D.9059 = __result;
    }
    iftmp.40 = D.9059;
    goto <D.9685>;
    <D.9648>:
    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    iftmp.40 = __builtin_strcmp ("--verbose", D.9320);
    <D.9685>:
    D.9063 = iftmp.40;
  }
  if (D.9063 == 0) goto <D.9686>; else goto <D.9687>;
  <D.9686>:
  verbose.41 = verbose;
  verbose.42 = verbose.41 + 1;
  verbose = verbose.42;
  goto <D.9690>;
  <D.9687>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      i.24 = (unsigned int) i;
      D.9281 = i.24 * 4;
      D.9282 = argv + D.9281;
      __s2 = *D.9282;
      D.9694 = "--traces";
      D.9695 = MEM[(const unsigned char *)D.9694];
      D.9696 = (int) D.9695;
      D.9697 = *__s2;
      D.9698 = (int) D.9697;
      __result = D.9696 - D.9698;
      {
        D.9699 = __s1_len != 0;
        D.9700 = __result == 0;
        D.9701 = D.9699 & D.9700;
        if (D.9701 != 0) goto <D.9702>; else goto <D.9703>;
        <D.9702>:
        D.9704 = &MEM[(void *)"--traces" + 1B];
        D.9705 = *D.9704;
        D.9706 = (int) D.9705;
        D.9707 = __s2 + 1;
        D.9708 = *D.9707;
        D.9709 = (int) D.9708;
        __result = D.9706 - D.9709;
        D.9710 = __s1_len > 1;
        D.9700 = __result == 0;
        D.9711 = D.9710 & D.9700;
        if (D.9711 != 0) goto <D.9712>; else goto <D.9713>;
        <D.9712>:
        D.9714 = &MEM[(void *)"--traces" + 2B];
        D.9715 = *D.9714;
        D.9716 = (int) D.9715;
        D.9717 = __s2 + 2;
        D.9718 = *D.9717;
        D.9719 = (int) D.9718;
        __result = D.9716 - D.9719;
        D.9720 = __s1_len > 2;
        D.9700 = __result == 0;
        D.9721 = D.9720 & D.9700;
        if (D.9721 != 0) goto <D.9722>; else goto <D.9723>;
        <D.9722>:
        D.9724 = &MEM[(void *)"--traces" + 3B];
        D.9725 = *D.9724;
        D.9726 = (int) D.9725;
        D.9727 = __s2 + 3;
        D.9728 = *D.9727;
        D.9729 = (int) D.9728;
        __result = D.9726 - D.9729;
        <D.9723>:
        <D.9713>:
        <D.9703>:
      }
      D.9068 = __result;
    }
    iftmp.43 = D.9068;
    goto <D.9730>;
    <D.9693>:
    i.24 = (unsigned int) i;
    D.9281 = i.24 * 4;
    D.9282 = argv + D.9281;
    D.9320 = *D.9282;
    iftmp.43 = __builtin_strcmp ("--traces", D.9320);
    <D.9730>:
    D.9072 = iftmp.43;
  }
  if (D.9072 == 0) goto <D.9731>; else goto <D.9073>;
  <D.9731>:
  show_traces = 1;
  collect_traces = 1;
  <D.9690>:
  <D.9645>:
  <D.9631>:
  <D.9626>:
  <D.9619>:
  <D.9612>:
  <D.9606>:
  <D.9598>:
  <D.9591>:
  <D.9458>:
  <D.9325>:
  i = i + 1;
  <D.9075>:
  if (i < argc) goto <D.9074>; else goto <D.9073>;
  <D.9073>:
  if (i >= argc) goto <D.9732>; else goto <D.9733>;
  <D.9732>:
  usage ();
  D.9368 = 2;
  return D.9368;
  <D.9733>:
  i.24 = (unsigned int) i;
  D.9281 = i.24 * 4;
  D.9282 = argv + D.9281;
  D.9320 = *D.9282;
  ctx = load_file (D.9320);
  if (ctx == 0B) goto <D.9734>; else goto <D.9735>;
  <D.9734>:
  printf ("Not a log profiler data file (or unsupported version).\n");
  D.9368 = 1;
  return D.9368;
  <D.9735>:
  goto <D.9077>;
  <D.9076>:
  <D.9077>:
  D.9736 = decode_buffer (ctx);
  if (D.9736 != 0) goto <D.9076>; else goto <D.9078>;
  <D.9078>:
  flush_context (ctx);
  num_tracked_objects.44 = num_tracked_objects;
  if (num_tracked_objects.44 != 0) goto <D.9738>; else goto <D.9739>;
  <D.9738>:
  D.9368 = 0;
  return D.9368;
  <D.9739>:
  reports.45 = reports;
  print_reports (ctx, reports.45, 0);
  D.9368 = 0;
  return D.9368;
}


add_find_spec (const char * p)
{
  char D.9751;
  const char * D.9753;
  char D.9754;
  const char * find_name.47;
  long unsigned int D.9757;
  long long unsigned int find_size.46;
  int D.9759;

  D.9751 = *p;
  if (D.9751 == 83) goto <D.9752>; else goto <D.9750>;
  <D.9752>:
  D.9753 = p + 1;
  D.9754 = *D.9753;
  if (D.9754 == 58) goto <D.9755>; else goto <D.9750>;
  <D.9755>:
  {
    char * vale;

    try
      {
        find_name.47 = p + 2;
        D.9757 = strtoul (find_name.47, &vale, 10);
        find_size.46 = (long long unsigned int) D.9757;
        find_size = find_size.46;
        D.9759 = 1;
        return D.9759;
      }
    finally
      {
        vale = {CLOBBER};
      }
  }
  <D.9750>:
  D.9751 = *p;
  if (D.9751 == 84) goto <D.9760>; else goto <D.9761>;
  <D.9760>:
  D.9753 = p + 1;
  D.9754 = *D.9753;
  if (D.9754 == 58) goto <D.9762>; else goto <D.9763>;
  <D.9762>:
  find_name.47 = p + 2;
  find_name = find_name.47;
  D.9759 = 1;
  return D.9759;
  <D.9763>:
  <D.9761>:
  D.9759 = 0;
  return D.9759;
}


found_object (uintptr_t obj)
{
  int num_tracked_objects.48;
  int num_tracked_objects.49;
  unsigned int num_tracked_objects.50;
  unsigned int D.9769;
  uintptr_t * tracked_objects.51;
  void * tracked_objects.52;
  sizetype num_tracked_objects.53;
  sizetype D.9773;
  sizetype D.9774;
  uintptr_t * D.9775;

  num_tracked_objects.48 = num_tracked_objects;
  num_tracked_objects.49 = num_tracked_objects.48 + 1;
  num_tracked_objects = num_tracked_objects.49;
  num_tracked_objects.48 = num_tracked_objects;
  num_tracked_objects.50 = (unsigned int) num_tracked_objects.48;
  D.9769 = num_tracked_objects.50 * 4;
  tracked_objects.51 = tracked_objects;
  tracked_objects.52 = realloc (tracked_objects.51, D.9769);
  tracked_objects = tracked_objects.52;
  tracked_objects.51 = tracked_objects;
  num_tracked_objects.48 = num_tracked_objects;
  num_tracked_objects.53 = (sizetype) num_tracked_objects.48;
  D.9773 = num_tracked_objects.53 + 1073741823;
  D.9774 = D.9773 * 4;
  D.9775 = tracked_objects.51 + D.9774;
  *D.9775 = obj;
}


pstrdup (const char * s)
{
  unsigned int D.9776;
  unsigned int D.9777;
  unsigned int len.54;
  char * D.9779;
  int len;
  char * p;

  D.9776 = strlen (s);
  D.9777 = D.9776 + 1;
  len = (int) D.9777;
  len.54 = (unsigned int) len;
  p = malloc (len.54);
  len.54 = (unsigned int) len;
  memcpy (p, s, len.54);
  D.9779 = p;
  return D.9779;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.9781;
  unsigned int D.9782;

  D.9782 = __builtin_object_size (__dest, 0);
  D.9781 = __builtin___memcpy_chk (__dest, __src, __len, D.9782);
  return D.9781;
}


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

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


usage ()
{
  const char * reports.55;

  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.55 = reports;
  printf ("\t                     %s\n", reports.55);
  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.8611;
  int iftmp.56;
  int D.8610;
  const char[2] * D.9790;
  unsigned char D.9791;
  int D.9792;
  unsigned char D.9793;
  int D.9794;
  _Bool D.9795;
  _Bool D.9796;
  _Bool D.9797;
  const unsigned char * D.9800;
  unsigned char D.9801;
  int D.9802;
  const unsigned char * D.9803;
  unsigned char D.9804;
  int D.9805;
  _Bool D.9806;
  _Bool D.9807;
  const unsigned char * D.9810;
  unsigned char D.9811;
  int D.9812;
  const unsigned char * D.9813;
  unsigned char D.9814;
  int D.9815;
  _Bool D.9816;
  _Bool D.9817;
  const unsigned char * D.9820;
  unsigned char D.9821;
  int D.9822;
  const unsigned char * D.9823;
  unsigned char D.9824;
  int D.9825;
  struct _IO_FILE * stdin.57;
  struct FILE * D.9831;
  struct FILE * D.9832;
  int D.9835;
  struct ProfContext * D.9838;
  int D.9841;
  unsigned char * D.9843;
  unsigned char D.9844;
  unsigned char * D.9845;
  unsigned char D.9846;
  int D.9847;
  unsigned char * D.9848;
  unsigned char D.9849;
  int D.9850;
  int D.9851;
  unsigned char * D.9852;
  unsigned char D.9853;
  unsigned char * D.9856;
  int D.9857;
  unsigned char * D.9860;
  long long int D.9861;
  long long unsigned int D.9862;
  unsigned char * D.9863;
  int D.9864;
  unsigned char * D.9865;
  int D.9866;
  unsigned char * D.9867;
  int D.9868;
  unsigned char * p;
  struct ProfContext * ctx;

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

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

      __s2 = name;
      D.9790 = "-";
      D.9791 = MEM[(const unsigned char *)D.9790];
      D.9792 = (int) D.9791;
      D.9793 = *__s2;
      D.9794 = (int) D.9793;
      __result = D.9792 - D.9794;
      {
        D.9795 = __s2_len != 0;
        D.9796 = __result == 0;
        D.9797 = D.9795 & D.9796;
        if (D.9797 != 0) goto <D.9798>; else goto <D.9799>;
        <D.9798>:
        D.9800 = &MEM[(void *)"-" + 1B];
        D.9801 = *D.9800;
        D.9802 = (int) D.9801;
        D.9803 = __s2 + 1;
        D.9804 = *D.9803;
        D.9805 = (int) D.9804;
        __result = D.9802 - D.9805;
        D.9806 = __s2_len > 1;
        D.9796 = __result == 0;
        D.9807 = D.9806 & D.9796;
        if (D.9807 != 0) goto <D.9808>; else goto <D.9809>;
        <D.9808>:
        D.9810 = &MEM[(void *)"-" + 2B];
        D.9811 = *D.9810;
        D.9812 = (int) D.9811;
        D.9813 = __s2 + 2;
        D.9814 = *D.9813;
        D.9815 = (int) D.9814;
        __result = D.9812 - D.9815;
        D.9816 = __s2_len > 2;
        D.9796 = __result == 0;
        D.9817 = D.9816 & D.9796;
        if (D.9817 != 0) goto <D.9818>; else goto <D.9819>;
        <D.9818>:
        D.9820 = &MEM[(void *)"-" + 3B];
        D.9821 = *D.9820;
        D.9822 = (int) D.9821;
        D.9823 = __s2 + 3;
        D.9824 = *D.9823;
        D.9825 = (int) D.9824;
        __result = D.9822 - D.9825;
        <D.9819>:
        <D.9809>:
        <D.9799>:
      }
      D.8610 = __result;
    }
    iftmp.56 = -D.8610;
    goto <D.9826>;
    <D.9789>:
    iftmp.56 = __builtin_strcmp (name, "-");
    <D.9826>:
    D.8611 = iftmp.56;
  }
  if (D.8611 == 0) goto <D.9827>; else goto <D.9828>;
  <D.9827>:
  stdin.57 = stdin;
  ctx->file = stdin.57;
  goto <D.9830>;
  <D.9828>:
  D.9831 = fopen (name, "rb");
  ctx->file = D.9831;
  <D.9830>:
  D.9832 = ctx->file;
  if (D.9832 == 0B) goto <D.9833>; else goto <D.9834>;
  <D.9833>:
  printf ("Cannot open file: %s\n", name);
  exit (1);
  <D.9834>:
  D.9835 = load_data (ctx, 32);
  if (D.9835 == 0) goto <D.9836>; else goto <D.9837>;
  <D.9836>:
  D.9838 = 0B;
  return D.9838;
  <D.9837>:
  p = ctx->buf;
  D.9841 = read_int32 (p);
  if (D.9841 != 1297111553) goto <D.9839>; else goto <D.9842>;
  <D.9842>:
  D.9843 = p + 6;
  D.9844 = *D.9843;
  if (D.9844 > 4) goto <D.9839>; else goto <D.9840>;
  <D.9839>:
  D.9838 = 0B;
  return D.9838;
  <D.9840>:
  D.9845 = p + 4;
  D.9846 = *D.9845;
  D.9847 = (int) D.9846;
  ctx->version_major = D.9847;
  D.9848 = p + 5;
  D.9849 = *D.9848;
  D.9850 = (int) D.9849;
  ctx->version_minor = D.9850;
  D.9843 = p + 6;
  D.9844 = *D.9843;
  D.9851 = (int) D.9844;
  ctx->data_version = D.9851;
  D.9852 = p + 7;
  D.9853 = *D.9852;
  if (D.9853 > 4) goto <D.9854>; else goto <D.9855>;
  <D.9854>:
  D.9838 = 0B;
  return D.9838;
  <D.9855>:
  D.9856 = p + 20;
  D.9857 = read_int32 (D.9856);
  if (D.9857 != 0) goto <D.9858>; else goto <D.9859>;
  <D.9858>:
  D.9838 = 0B;
  return D.9838;
  <D.9859>:
  D.9860 = p + 8;
  D.9861 = read_int64 (D.9860);
  D.9862 = (long long unsigned int) D.9861;
  ctx->startup_time = D.9862;
  D.9863 = p + 16;
  D.9864 = read_int32 (D.9863);
  ctx->timer_overhead = D.9864;
  D.9865 = p + 24;
  D.9866 = read_int32 (D.9865);
  ctx->pid = D.9866;
  D.9867 = p + 28;
  D.9868 = read_int16 (D.9867);
  ctx->port = D.9868;
  D.9838 = ctx;
  return D.9838;
}


load_data (struct ProfContext * ctx, int size)
{
  struct FILE * D.9878;
  unsigned int size.58;
  unsigned char * D.9880;
  unsigned int D.9881;
  int D.9884;
  _Bool D.9885;

  ensure_buffer (ctx, size);
  {
    int r;

    D.9878 = ctx->file;
    size.58 = (unsigned int) size;
    D.9880 = ctx->buf;
    D.9881 = fread (D.9880, size.58, 1, D.9878);
    r = (int) D.9881;
    if (r == 0) goto <D.9882>; else goto <D.9883>;
    <D.9882>:
    D.9885 = size == 0;
    D.9884 = (int) D.9885;
    return D.9884;
    <D.9883>:
    D.9884 = r;
    return D.9884;
  }
}


ensure_buffer (struct ProfContext * ctx, int size)
{
  int D.9888;
  unsigned int size.59;
  unsigned char * D.9892;
  void * D.9893;

  D.9888 = ctx->size;
  if (D.9888 < size) goto <D.9889>; else goto <D.9890>;
  <D.9889>:
  size.59 = (unsigned int) size;
  D.9892 = ctx->buf;
  D.9893 = realloc (D.9892, size.59);
  ctx->buf = D.9893;
  ctx->size = size;
  <D.9890>:
}


fread (void * restrict __ptr, size_t __size, size_t __n, struct FILE * restrict __stream)
{
  unsigned int D.9894;
  int D.9899;
  int D.9901;
  unsigned int D.9903;
  size_t D.9904;
  unsigned int D.9905;
  unsigned int D.9906;
  unsigned int D.9907;
  unsigned int D.9910;

  D.9894 = __builtin_object_size (__ptr, 0);
  if (D.9894 != 4294967295) goto <D.9895>; else goto <D.9896>;
  <D.9895>:
  D.9899 = __builtin_constant_p (__size);
  if (D.9899 == 0) goto <D.9897>; else goto <D.9900>;
  <D.9900>:
  D.9901 = __builtin_constant_p (__n);
  if (D.9901 == 0) goto <D.9897>; else goto <D.9902>;
  <D.9902>:
  D.9903 = __size | __n;
  if (D.9903 > 65535) goto <D.9897>; else goto <D.9898>;
  <D.9897>:
  D.9905 = __builtin_object_size (__ptr, 0);
  D.9904 = __fread_chk (__ptr, D.9905, __size, __n, __stream);
  return D.9904;
  <D.9898>:
  D.9906 = __size * __n;
  D.9907 = __builtin_object_size (__ptr, 0);
  if (D.9906 > D.9907) goto <D.9908>; else goto <D.9909>;
  <D.9908>:
  D.9910 = __builtin_object_size (__ptr, 0);
  D.9904 = __fread_chk_warn (__ptr, D.9910, __size, __n, __stream);
  return D.9904;
  <D.9909>:
  <D.9896>:
  D.9904 = __fread_alias (__ptr, __size, __n, __stream);
  return D.9904;
}


read_int64 (unsigned char * p)
{
  unsigned char * p.60;
  unsigned char D.9916;
  unsigned char * p.61;
  unsigned char D.9918;
  int D.9919;
  int D.9920;
  long long unsigned int D.9921;
  unsigned char * p.62;
  unsigned char D.9923;
  int D.9924;
  int D.9925;
  long long unsigned int D.9926;
  unsigned char * p.63;
  unsigned char D.9928;
  long long unsigned int D.9929;
  long long unsigned int D.9930;
  unsigned char * p.64;
  unsigned char D.9932;
  long long unsigned int D.9933;
  long long unsigned int D.9934;
  unsigned char * p.65;
  unsigned char D.9936;
  long long unsigned int D.9937;
  long long unsigned int D.9938;
  unsigned char * p.66;
  unsigned char D.9940;
  long long unsigned int D.9941;
  long long unsigned int D.9942;
  unsigned char * p.67;
  unsigned char D.9944;
  long long unsigned int D.9945;
  long long unsigned int D.9946;
  int64_t D.9947;
  uint64_t value;

  p.60 = p;
  p = p.60 + 1;
  D.9916 = *p.60;
  value = (uint64_t) D.9916;
  p.61 = p;
  p = p.61 + 1;
  D.9918 = *p.61;
  D.9919 = (int) D.9918;
  D.9920 = D.9919 << 8;
  D.9921 = (long long unsigned int) D.9920;
  value = D.9921 | value;
  p.62 = p;
  p = p.62 + 1;
  D.9923 = *p.62;
  D.9924 = (int) D.9923;
  D.9925 = D.9924 << 16;
  D.9926 = (long long unsigned int) D.9925;
  value = D.9926 | value;
  p.63 = p;
  p = p.63 + 1;
  D.9928 = *p.63;
  D.9929 = (long long unsigned int) D.9928;
  D.9930 = D.9929 << 24;
  value = D.9930 | value;
  p.64 = p;
  p = p.64 + 1;
  D.9932 = *p.64;
  D.9933 = (long long unsigned int) D.9932;
  D.9934 = D.9933 << 32;
  value = D.9934 | value;
  p.65 = p;
  p = p.65 + 1;
  D.9936 = *p.65;
  D.9937 = (long long unsigned int) D.9936;
  D.9938 = D.9937 << 40;
  value = D.9938 | value;
  p.66 = p;
  p = p.66 + 1;
  D.9940 = *p.66;
  D.9941 = (long long unsigned int) D.9940;
  D.9942 = D.9941 << 48;
  value = D.9942 | value;
  p.67 = p;
  p = p.67 + 1;
  D.9944 = *p.67;
  D.9945 = (long long unsigned int) D.9944;
  D.9946 = D.9945 << 54;
  value = D.9946 | value;
  D.9947 = (int64_t) value;
  return D.9947;
}


read_int32 (unsigned char * p)
{
  unsigned char * p.68;
  unsigned char D.9950;
  unsigned char * p.69;
  unsigned char D.9952;
  int D.9953;
  int D.9954;
  unsigned char * p.70;
  unsigned char D.9956;
  int D.9957;
  int D.9958;
  unsigned char * p.71;
  unsigned char D.9960;
  unsigned int D.9961;
  unsigned int D.9962;
  unsigned int value.72;
  unsigned int D.9964;
  int32_t D.9965;
  int32_t value;

  p.68 = p;
  p = p.68 + 1;
  D.9950 = *p.68;
  value = (int32_t) D.9950;
  p.69 = p;
  p = p.69 + 1;
  D.9952 = *p.69;
  D.9953 = (int) D.9952;
  D.9954 = D.9953 << 8;
  value = D.9954 | value;
  p.70 = p;
  p = p.70 + 1;
  D.9956 = *p.70;
  D.9957 = (int) D.9956;
  D.9958 = D.9957 << 16;
  value = D.9958 | value;
  p.71 = p;
  p = p.71 + 1;
  D.9960 = *p.71;
  D.9961 = (unsigned int) D.9960;
  D.9962 = D.9961 << 24;
  value.72 = (unsigned int) value;
  D.9964 = D.9962 | value.72;
  value = (int32_t) D.9964;
  D.9965 = value;
  return D.9965;
}


read_int16 (unsigned char * p)
{
  unsigned char * p.73;
  unsigned char D.9968;
  unsigned char * p.74;
  unsigned char D.9970;
  int D.9971;
  int D.9972;
  int32_t D.9973;
  int32_t value;

  p.73 = p;
  p = p.73 + 1;
  D.9968 = *p.73;
  value = (int32_t) D.9968;
  p.74 = p;
  p = p.74 + 1;
  D.9970 = *p.74;
  D.9971 = (int) D.9970;
  D.9972 = D.9971 << 8;
  value = D.9972 | value;
  D.9973 = value;
  return D.9973;
}


decode_buffer (struct ProfContext * ctx)
{
  struct FILE * D.9975;
  long int D.9976;
  int D.9977;
  int D.9980;
  unsigned char * p.75;
  unsigned char * p.76;
  int D.9983;
  int D.9986;
  struct FILE * outfile.77;
  const char * iftmp.78;
  unsigned int i.79;
  unsigned int D.9990;
  sizetype i.80;
  unsigned char * D.9995;
  unsigned char D.9996;
  int D.9997;
  unsigned char * D.9998;
  unsigned char * D.9999;
  long long int D.10000;
  unsigned char * D.10001;
  long long int D.10002;
  unsigned char * D.10003;
  long long int D.10004;
  unsigned char * D.10005;
  long long int D.10006;
  unsigned char * D.10007;
  long long int D.10008;
  int debug.81;
  int D.10012;
  long long unsigned int startup_time.82;
  long long unsigned int time_from.83;
  long long unsigned int time_from.84;
  long long unsigned int time_to.85;
  long long unsigned int time_to.86;
  char * D.10024;
  char * D.10027;
  struct MethodDesc * * D.10028;
  unsigned int i.87;
  unsigned int D.10030;
  struct MethodDesc * * D.10031;
  struct MethodDesc * D.10032;
  int D.10033;
  int D.10034;
  int D.10035;
  sizetype len.88;
  unsigned char D.10037;
  int D.10038;
  int D.10039;
  uint8_t * D.10040;
  int gc_resizes.89;
  int gc_resizes.90;
  long long unsigned int max_heap_size.91;
  long long unsigned int D.10053;
  int D.10056;
  int D.10057;
  const char * D.10058;
  int D.10063;
  int D.10064;
  long long unsigned int D.10068;
  long long unsigned int D.10069;
  long long unsigned int D.10070;
  long long unsigned int D.10071;
  long long unsigned int D.10077;
  int D.10078;
  long long unsigned int D.10079;
  long long unsigned int gc_object_moves.92;
  long long unsigned int gc_object_moves.93;
  int num_tracked_objects.94;
  int D.10085;
  int D.10086;
  unsigned int D.10087;
  int D.10088;
  int D.10089;
  unsigned int D.10090;
  void * D.10093;
  void * D.10094;
  long long unsigned int D.10098;
  long long unsigned int D.10099;
  long long unsigned int D.10102;
  long long unsigned int D.10103;
  long long unsigned int D.10104;
  long long unsigned int D.10105;
  struct TraceDesc * D.10106;
  long long unsigned int D.10107;
  int D.10112;
  int D.10113;
  unsigned int D.10114;
  void * D.10117;
  const char * D.10118;
  long long unsigned int D.10122;
  long long unsigned int D.10123;
  long long unsigned int D.10126;
  long long unsigned int D.10127;
  long long unsigned int D.10128;
  long long unsigned int D.10129;
  const char * D.10132;
  unsigned char * p.95;
  unsigned char * p.96;
  unsigned char D.10135;
  int D.10142;
  void * D.10143;
  int D.10144;
  void * D.10145;
  unsigned char * p.97;
  int D.10163;
  char * D.10164;
  int D.10167;
  struct ClassDesc * D.10170;
  char * D.10171;
  int D.10172;
  int D.10173;
  void * D.10174;
  unsigned int thread_filter.98;
  unsigned int D.10184;
  int D.10186;
  int D.10187;
  long long unsigned int D.10188;
  long long unsigned int D.10189;
  struct TraceDesc * D.10192;
  int num_bt.99;
  long long unsigned int find_size.100;
  const char * find_name.101;
  char * D.10204;
  char * D.10205;
  unsigned int D.10206;
  char * D.10211;
  int D.10218;
  unsigned int D.10219;
  unsigned int method_base.102;
  unsigned int D.10221;
  long long unsigned int D.10224;
  int D.10227;
  void * D.10228;
  void * method_base.103;
  struct TraceDesc * D.10236;
  char * D.10240;
  const char * iftmp.104;
  const char * iftmp.105;
  long long unsigned int D.10251;
  int D.10252;
  struct HeapShot * D.10255;
  int collect_traces.106;
  int D.10259;
  int D.10260;
  unsigned int D.10261;
  uintptr_t iftmp.107;
  int D.10266;
  long long unsigned int D.10269;
  unsigned int D.10270;
  unsigned int ref_offset.108;
  unsigned int i.109;
  unsigned int D.10276;
  int D.10277;
  int D.10278;
  unsigned int D.10279;
  char * D.10286;
  void * D.10287;
  long long unsigned int D.10291;
  long long unsigned int D.10292;
  long long unsigned int D.10293;
  long long unsigned int D.10294;
  const char * D.10297;
  int D.10298;
  int D.10299;
  void * D.10300;
  unsigned int D.10303;
  unsigned int i.110;
  unsigned int D.10315;
  uintptr_t * D.10317;
  uintptr_t * D.10318;
  int * D.10319;
  struct HeapShot * D.10325;
  unsigned char D.10326;
  int D.10327;
  int iftmp.111;
  int D.10335;
  int D.10336;
  unsigned int D.10337;
  long long unsigned int monitor_contention.112;
  long long unsigned int monitor_contention.113;
  unsigned int D.10342;
  unsigned int D.10343;
  struct TraceDesc * D.10350;
  int num_bt.114;
  long long unsigned int monitor_failed.115;
  long long unsigned int monitor_failed.116;
  struct MonitorDesc * D.10362;
  long long unsigned int D.10365;
  long long unsigned int D.10368;
  long long unsigned int D.10371;
  long long unsigned int D.10372;
  long long unsigned int monitor_acquired.117;
  long long unsigned int monitor_acquired.118;
  long long unsigned int D.10386;
  void * D.10389;
  const char * D.10390;
  int has_bt.119;
  int iftmp.120;
  long long unsigned int D.10401;
  long long unsigned int D.10402;
  int D.10403;
  unsigned int D.10404;
  unsigned int D.10405;
  long long unsigned int D.10408;
  long long unsigned int D.10409;
  struct MethodDesc * D.10412;
  char * D.10413;
  const char * D.10414;
  long long unsigned int throw_count.121;
  long long unsigned int throw_count.122;
  int has_bt.123;
  int D.10434;
  int D.10435;
  void * D.10436;
  long long unsigned int D.10439;
  long long unsigned int D.10440;
  int D.10441;
  int D.10442;
  void * ip.124;
  int D.10449;
  int D.10450;
  long long unsigned int D.10451;
  void * addr.125;
  int D.10458;
  long long unsigned int D.10459;
  void * addr.126;
  int p.127;
  int p.128;
  int D.10466;
  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.9975 = ctx->file;
      D.9976 = ftell (D.9975);
      file_offset = (uint64_t) D.9976;
      D.9977 = load_data (ctx, 48);
      if (D.9977 == 0) goto <D.9978>; else goto <D.9979>;
      <D.9978>:
      D.9980 = 0;
      return D.9980;
      <D.9979>:
      p.75 = ctx->buf;
      p = p.75;
      p.76 = p;
      D.9983 = read_int32 (p.76);
      if (D.9983 != 1297107969) goto <D.9984>; else goto <D.9985>;
      <D.9984>:
      p.76 = p;
      D.9986 = read_int32 (p.76);
      outfile.77 = outfile;
      fprintf (outfile.77, "Incorrect buffer id: 0x%x\n", D.9986);
      i = 0;
      goto <D.8451>;
      <D.8450>:
      i.79 = (unsigned int) i;
      D.9990 = i.79 & 7;
      if (D.9990 != 0) goto <D.9991>; else goto <D.9992>;
      <D.9991>:
      iftmp.78 = " ";
      goto <D.9993>;
      <D.9992>:
      iftmp.78 = "\n";
      <D.9993>:
      p.76 = p;
      i.80 = (sizetype) i;
      D.9995 = p.76 + i.80;
      D.9996 = *D.9995;
      D.9997 = (int) D.9996;
      outfile.77 = outfile;
      fprintf (outfile.77, "0x%x%s", D.9997, iftmp.78);
      i = i + 1;
      <D.8451>:
      if (i <= 47) goto <D.8450>; else goto <D.8452>;
      <D.8452>:
      D.9980 = 0;
      return D.9980;
      <D.9985>:
      p.76 = p;
      D.9998 = p.76 + 4;
      len = read_int32 (D.9998);
      p.76 = p;
      D.9999 = p.76 + 8;
      D.10000 = read_int64 (D.9999);
      time_base = (uint64_t) D.10000;
      p.76 = p;
      D.10001 = p.76 + 16;
      D.10002 = read_int64 (D.10001);
      ptr_base = (intptr_t) D.10002;
      p.76 = p;
      D.10003 = p.76 + 24;
      D.10004 = read_int64 (D.10003);
      obj_base = (intptr_t) D.10004;
      p.76 = p;
      D.10005 = p.76 + 32;
      D.10006 = read_int64 (D.10005);
      thread_id = (intptr_t) D.10006;
      p.76 = p;
      D.10007 = p.76 + 40;
      D.10008 = read_int64 (D.10007);
      method_base = (intptr_t) D.10008;
      debug.81 = debug;
      if (debug.81 != 0) goto <D.10010>; else goto <D.10011>;
      <D.10010>:
      outfile.77 = outfile;
      fprintf (outfile.77, "buf: thread:%x, len: %d, time: %llu, file offset: %llu\n", thread_id, len, time_base, file_offset);
      <D.10011>:
      thread = load_thread (ctx, thread_id);
      D.10012 = load_data (ctx, len);
      if (D.10012 == 0) goto <D.10013>; else goto <D.10014>;
      <D.10013>:
      D.9980 = 0;
      return D.9980;
      <D.10014>:
      startup_time.82 = startup_time;
      if (startup_time.82 == 0) goto <D.10016>; else goto <D.10017>;
      <D.10016>:
      startup_time = time_base;
      time_from.83 = time_from;
      if (time_from.83 != 0) goto <D.10019>; else goto <D.10020>;
      <D.10019>:
      time_from.83 = time_from;
      startup_time.82 = startup_time;
      time_from.84 = time_from.83 + startup_time.82;
      time_from = time_from.84;
      time_to.85 = time_to;
      startup_time.82 = startup_time;
      time_to.86 = time_to.85 + startup_time.82;
      time_to = time_to.86;
      <D.10020>:
      D.10024 = thread->name;
      if (D.10024 == 0B) goto <D.10025>; else goto <D.10026>;
      <D.10025>:
      D.10027 = pstrdup ("Main");
      thread->name = D.10027;
      <D.10026>:
      <D.10017>:
      i = 0;
      goto <D.8454>;
      <D.8453>:
      D.10028 = thread->stack;
      i.87 = (unsigned int) i;
      D.10030 = i.87 * 4;
      D.10031 = D.10028 + D.10030;
      D.10032 = *D.10031;
      D.10033 = D.10032->recurse_count;
      D.10034 = D.10033 + 1;
      D.10032->recurse_count = D.10034;
      i = i + 1;
      <D.8454>:
      D.10035 = thread->stack_id;
      if (D.10035 > i) goto <D.8453>; else goto <D.8455>;
      <D.8455>:
      p.75 = ctx->buf;
      p = p.75;
      p.76 = p;
      len.88 = (sizetype) len;
      end = p.76 + len.88;
      goto <D.8593>;
      <D.8592>:
      p.76 = p;
      D.10037 = *p.76;
      D.10038 = (int) D.10037;
      D.10039 = D.10038 & 15;
      switch (D.10039) <default: <D.8591>, case 0: <D.8494>, case 1: <D.8456>, case 2: <D.8475>, case 3: <D.8505>, case 4: <D.8556>, case 5: <D.8544>, case 6: <D.8515>, case 7: <D.8567>>
      <D.8456>:
      {
        int subtype;
        uint64_t tdiff;

        p.76 = p;
        D.10037 = *p.76;
        D.10038 = (int) D.10037;
        subtype = D.10038 & 240;
        p.76 = p;
        D.10040 = p.76 + 1;
        tdiff = decode_uleb128 (D.10040, &p);
        time_base = time_base + tdiff;
        if (subtype == 32) goto <D.10041>; else goto <D.10042>;
        <D.10041>:
        {
          uint64_t new_size;

          p.76 = p;
          new_size = decode_uleb128 (p.76, &p);
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10043>; else goto <D.10044>;
          <D.10043>:
          outfile.77 = outfile;
          fprintf (outfile.77, "gc heap resized to %llu\n", new_size);
          <D.10044>:
          gc_resizes.89 = gc_resizes;
          gc_resizes.90 = gc_resizes.89 + 1;
          gc_resizes = gc_resizes.90;
          max_heap_size.91 = max_heap_size;
          if (new_size > max_heap_size.91) goto <D.10048>; else goto <D.10049>;
          <D.10048>:
          max_heap_size = new_size;
          <D.10049>:
        }
        goto <D.10050>;
        <D.10042>:
        if (subtype == 16) goto <D.10051>; else goto <D.10052>;
        <D.10051>:
        {
          uint64_t ev;
          int gen;

          p.76 = p;
          ev = decode_uleb128 (p.76, &p);
          p.76 = p;
          D.10053 = decode_uleb128 (p.76, &p);
          gen = (int) D.10053;
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10054>; else goto <D.10055>;
          <D.10054>:
          D.10056 = thread->thread_id;
          D.10057 = (int) ev;
          D.10058 = gc_event_name (D.10057);
          outfile.77 = outfile;
          fprintf (outfile.77, "gc event for gen%d: %s at %llu (thread: 0x%x)\n", gen, D.10058, time_base, D.10056);
          <D.10055>:
          if (gen > 2) goto <D.10059>; else goto <D.10060>;
          <D.10059>:
          outfile.77 = outfile;
          fprintf (outfile.77, "incorrect gc gen: %d\n", gen);
          goto <D.8462>;
          <D.10060>:
          if (ev == 0) goto <D.10061>; else goto <D.10062>;
          <D.10061>:
          thread->gc_start_times[gen] = time_base;
          D.10063 = gc_info[gen].count;
          D.10064 = D.10063 + 1;
          gc_info[gen].count = D.10064;
          goto <D.10065>;
          <D.10062>:
          if (ev == 5) goto <D.10066>; else goto <D.10067>;
          <D.10066>:
          D.10068 = thread->gc_start_times[gen];
          tdiff = time_base - D.10068;
          D.10069 = gc_info[gen].total_time;
          D.10070 = D.10069 + tdiff;
          gc_info[gen].total_time = D.10070;
          D.10071 = gc_info[gen].max_time;
          if (D.10071 < tdiff) goto <D.10072>; else goto <D.10073>;
          <D.10072>:
          gc_info[gen].max_time = tdiff;
          <D.10073>:
          <D.10067>:
          <D.10065>:
        }
        goto <D.10074>;
        <D.10052>:
        if (subtype == 48) goto <D.10075>; else goto <D.10076>;
        <D.10075>:
        {
          int j;
          int num;

          p.76 = p;
          D.10077 = decode_uleb128 (p.76, &p);
          num = (int) D.10077;
          D.10078 = num / 2;
          D.10079 = (long long unsigned int) D.10078;
          gc_object_moves.92 = gc_object_moves;
          gc_object_moves.93 = D.10079 + gc_object_moves.92;
          gc_object_moves = gc_object_moves.93;
          j = 0;
          goto <D.8468>;
          <D.8467>:
          {
            intptr_t obj1diff;
            intptr_t obj2diff;

            p.76 = p;
            obj1diff = decode_sleb128 (p.76, &p);
            p.76 = p;
            obj2diff = decode_sleb128 (p.76, &p);
            num_tracked_objects.94 = num_tracked_objects;
            if (num_tracked_objects.94 != 0) goto <D.10083>; else goto <D.10084>;
            <D.10083>:
            D.10085 = obj_base + obj2diff;
            D.10086 = D.10085 << 3;
            D.10087 = (unsigned int) D.10086;
            D.10088 = obj_base + obj1diff;
            D.10089 = D.10088 << 3;
            D.10090 = (unsigned int) D.10089;
            track_move (D.10090, D.10087);
            <D.10084>:
            debug.81 = debug;
            if (debug.81 != 0) goto <D.10091>; else goto <D.10092>;
            <D.10091>:
            D.10085 = obj_base + obj2diff;
            D.10086 = D.10085 << 3;
            D.10093 = (void *) D.10086;
            D.10088 = obj_base + obj1diff;
            D.10089 = D.10088 << 3;
            D.10094 = (void *) D.10089;
            outfile.77 = outfile;
            fprintf (outfile.77, "moved obj %p to %p\n", D.10094, D.10093);
            <D.10092>:
          }
          j = j + 2;
          <D.8468>:
          if (j < num) goto <D.8467>; else goto <D.8469>;
          <D.8469>:
        }
        goto <D.10095>;
        <D.10076>:
        if (subtype == 64) goto <D.10096>; else goto <D.10097>;
        <D.10096>:
        {
          int htype;
          uint32_t handle;
          intptr_t objdiff;

          p.76 = p;
          D.10098 = decode_uleb128 (p.76, &p);
          htype = (int) D.10098;
          p.76 = p;
          D.10099 = decode_uleb128 (p.76, &p);
          handle = (uint32_t) D.10099;
          p.76 = p;
          objdiff = decode_sleb128 (p.76, &p);
          if (htype > 3) goto <D.10100>; else goto <D.10101>;
          <D.10100>:
          D.9980 = 0;
          return D.9980;
          <D.10101>:
          D.10102 = handle_info[htype].created;
          D.10103 = D.10102 + 1;
          handle_info[htype].created = D.10103;
          D.10104 = handle_info[htype].live;
          D.10105 = D.10104 + 1;
          handle_info[htype].live = D.10105;
          D.10106 = &handle_info[htype].traces;
          add_trace_thread (thread, D.10106, 1);
          D.10104 = handle_info[htype].live;
          D.10107 = handle_info[htype].max_live;
          if (D.10104 > D.10107) goto <D.10108>; else goto <D.10109>;
          <D.10108>:
          D.10104 = handle_info[htype].live;
          handle_info[htype].max_live = D.10104;
          <D.10109>:
          num_tracked_objects.94 = num_tracked_objects;
          if (num_tracked_objects.94 != 0) goto <D.10110>; else goto <D.10111>;
          <D.10110>:
          D.10112 = obj_base + objdiff;
          D.10113 = D.10112 << 3;
          D.10114 = (unsigned int) D.10113;
          track_handle (D.10114, htype, handle);
          <D.10111>:
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10115>; else goto <D.10116>;
          <D.10115>:
          D.10112 = obj_base + objdiff;
          D.10113 = D.10112 << 3;
          D.10117 = (void *) D.10113;
          D.10118 = get_handle_name (htype);
          outfile.77 = outfile;
          fprintf (outfile.77, "handle (%s) %u created for object %p\n", D.10118, handle, D.10117);
          <D.10116>:
        }
        goto <D.10119>;
        <D.10097>:
        if (subtype == 80) goto <D.10120>; else goto <D.10121>;
        <D.10120>:
        {
          int htype;
          uint32_t handle;

          p.76 = p;
          D.10122 = decode_uleb128 (p.76, &p);
          htype = (int) D.10122;
          p.76 = p;
          D.10123 = decode_uleb128 (p.76, &p);
          handle = (uint32_t) D.10123;
          if (htype > 3) goto <D.10124>; else goto <D.10125>;
          <D.10124>:
          D.9980 = 0;
          return D.9980;
          <D.10125>:
          D.10126 = handle_info[htype].destroyed;
          D.10127 = D.10126 + 1;
          handle_info[htype].destroyed = D.10127;
          D.10128 = handle_info[htype].live;
          D.10129 = D.10128 + 18446744073709551615;
          handle_info[htype].live = D.10129;
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10130>; else goto <D.10131>;
          <D.10130>:
          D.10132 = get_handle_name (htype);
          outfile.77 = outfile;
          fprintf (outfile.77, "handle (%s) %u destroyed\n", D.10132, handle);
          <D.10131>:
        }
        <D.10121>:
        <D.10119>:
        <D.10095>:
        <D.10074>:
        <D.10050>:
        goto <D.8462>;
      }
      <D.8475>:
      {
        int error;
        uint64_t tdiff;
        int mtype;
        intptr_t ptrdiff;

        p.76 = p;
        D.10037 = *p.76;
        D.10038 = (int) D.10037;
        error = D.10038 & 128;
        p.76 = p;
        D.10040 = p.76 + 1;
        tdiff = decode_uleb128 (D.10040, &p);
        p.76 = p;
        p.95 = p.76;
        p.96 = p.95 + 1;
        p = p.96;
        D.10135 = *p.95;
        mtype = (int) D.10135;
        p.76 = p;
        ptrdiff = decode_sleb128 (p.76, &p);
        time_base = time_base + tdiff;
        if (mtype == 1) goto <D.10136>; else goto <D.10137>;
        <D.10136>:
        {
          intptr_t imptrdiff;
          uint64_t flags;

          p.76 = p;
          imptrdiff = decode_sleb128 (p.76, &p);
          p.76 = p;
          flags = decode_uleb128 (p.76, &p);
          if (flags != 0) goto <D.10138>; else goto <D.10139>;
          <D.10138>:
          outfile.77 = outfile;
          fprintf (outfile.77, "non-zero flags in class\n");
          D.9980 = 0;
          return D.9980;
          <D.10139>:
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10140>; else goto <D.10141>;
          <D.10140>:
          D.10142 = ptr_base + imptrdiff;
          D.10143 = (void *) D.10142;
          p.76 = p;
          D.10144 = ptr_base + ptrdiff;
          D.10145 = (void *) D.10144;
          outfile.77 = outfile;
          fprintf (outfile.77, "loaded class %p (%s in %p) at %llu\n", D.10145, p.76, D.10143, time_base);
          <D.10141>:
          if (error == 0) goto <D.10146>; else goto <D.10147>;
          <D.10146>:
          p.76 = p;
          D.10144 = ptr_base + ptrdiff;
          add_class (D.10144, p.76);
          <D.10147>:
          goto <D.8483>;
          <D.8482>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
          <D.8483>:
          p.76 = p;
          D.10037 = *p.76;
          if (D.10037 != 0) goto <D.8482>; else goto <D.8484>;
          <D.8484>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
        }
        goto <D.10149>;
        <D.10137>:
        if (mtype == 2) goto <D.10150>; else goto <D.10151>;
        <D.10150>:
        {
          uint64_t flags;

          p.76 = p;
          flags = decode_uleb128 (p.76, &p);
          if (flags != 0) goto <D.10152>; else goto <D.10153>;
          <D.10152>:
          outfile.77 = outfile;
          fprintf (outfile.77, "non-zero flags in image\n");
          D.9980 = 0;
          return D.9980;
          <D.10153>:
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10154>; else goto <D.10155>;
          <D.10154>:
          p.76 = p;
          D.10144 = ptr_base + ptrdiff;
          D.10145 = (void *) D.10144;
          outfile.77 = outfile;
          fprintf (outfile.77, "loaded image %p (%s) at %llu\n", D.10145, p.76, time_base);
          <D.10155>:
          if (error == 0) goto <D.10156>; else goto <D.10157>;
          <D.10156>:
          p.76 = p;
          D.10144 = ptr_base + ptrdiff;
          add_image (D.10144, p.76);
          <D.10157>:
          goto <D.8487>;
          <D.8486>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
          <D.8487>:
          p.76 = p;
          D.10037 = *p.76;
          if (D.10037 != 0) goto <D.8486>; else goto <D.8488>;
          <D.8488>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
        }
        goto <D.10158>;
        <D.10151>:
        if (mtype == 5) goto <D.10159>; else goto <D.10160>;
        <D.10159>:
        {
          struct ThreadContext * nt;
          uint64_t flags;

          p.76 = p;
          flags = decode_uleb128 (p.76, &p);
          if (flags != 0) goto <D.10161>; else goto <D.10162>;
          <D.10161>:
          outfile.77 = outfile;
          fprintf (outfile.77, "non-zero flags in thread\n");
          D.9980 = 0;
          return D.9980;
          <D.10162>:
          D.10163 = ptr_base * ptrdiff;
          nt = get_thread (ctx, D.10163);
          p.76 = p;
          D.10164 = pstrdup (p.76);
          nt->name = D.10164;
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10165>; else goto <D.10166>;
          <D.10165>:
          p.76 = p;
          D.10144 = ptr_base + ptrdiff;
          D.10145 = (void *) D.10144;
          outfile.77 = outfile;
          fprintf (outfile.77, "thread %p named: %s\n", D.10145, p.76);
          <D.10166>:
          goto <D.8492>;
          <D.8491>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
          <D.8492>:
          p.76 = p;
          D.10037 = *p.76;
          if (D.10037 != 0) goto <D.8491>; else goto <D.8493>;
          <D.8493>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
        }
        <D.10160>:
        <D.10158>:
        <D.10149>:
        goto <D.8462>;
      }
      <D.8494>:
      {
        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.76 = p;
            D.10037 = *p.76;
            D.10038 = (int) D.10037;
            has_bt = D.10038 & 16;
            p.76 = p;
            D.10040 = p.76 + 1;
            tdiff = decode_uleb128 (D.10040, &p);
            p.76 = p;
            ptrdiff = decode_sleb128 (p.76, &p);
            p.76 = p;
            objdiff = decode_sleb128 (p.76, &p);
            num_bt = 0;
            frames = &sframes;
            D.10167 = ptr_base + ptrdiff;
            cd = lookup_class (D.10167);
            p.76 = p;
            len = decode_uleb128 (p.76, &p);
            time_base = time_base + tdiff;
            debug.81 = debug;
            if (debug.81 != 0) goto <D.10168>; else goto <D.10169>;
            <D.10168>:
            D.10167 = ptr_base + ptrdiff;
            D.10170 = lookup_class (D.10167);
            D.10171 = D.10170->name;
            D.10172 = obj_base + objdiff;
            D.10173 = D.10172 << 3;
            D.10174 = (void *) D.10173;
            outfile.77 = outfile;
            fprintf (outfile.77, "alloced object %p, size %llu (%s) at %llu\n", D.10174, len, D.10171, time_base);
            <D.10169>:
            if (has_bt != 0) goto <D.10175>; else goto <D.10176>;
            <D.10175>:
            num_bt = 8;
            p.76 = p;
            frames = decode_bt (&sframes, &num_bt, p.76, &p, ptr_base);
            if (frames == 0B) goto <D.10177>; else goto <D.10178>;
            <D.10177>:
            outfile.77 = outfile;
            fprintf (outfile.77, "Cannot load backtrace\n");
            D.9980 = 0;
            return D.9980;
            <D.10178>:
            <D.10176>:
            thread_filter.98 = thread_filter;
            if (thread_filter.98 != 0) goto <D.10183>; else goto <D.10179>;
            <D.10183>:
            D.10056 = thread->thread_id;
            D.10184 = (unsigned int) D.10056;
            thread_filter.98 = thread_filter;
            if (D.10184 == thread_filter.98) goto <D.10180>; else goto <D.10179>;
            <D.10179>:
            time_from.83 = time_from;
            if (time_base >= time_from.83) goto <D.10185>; else goto <D.10181>;
            <D.10185>:
            time_to.85 = time_to;
            if (time_base < time_to.85) goto <D.10180>; else goto <D.10181>;
            <D.10180>:
            {
              struct BackTrace * bt;

              D.10186 = cd->allocs;
              D.10187 = D.10186 + 1;
              cd->allocs = D.10187;
              D.10188 = cd->alloc_size;
              D.10189 = D.10188 + len;
              cd->alloc_size = D.10189;
              if (has_bt != 0) goto <D.10190>; else goto <D.10191>;
              <D.10190>:
              D.10192 = &cd->traces;
              num_bt.99 = num_bt;
              bt = add_trace_methods (frames, num_bt.99, D.10192, len);
              goto <D.10194>;
              <D.10191>:
              D.10192 = &cd->traces;
              bt = add_trace_thread (thread, D.10192, len);
              <D.10194>:
              find_size.100 = find_size;
              if (find_size.100 != 0) goto <D.10198>; else goto <D.10195>;
              <D.10198>:
              find_size.100 = find_size;
              if (len >= find_size.100) goto <D.10199>; else goto <D.10195>;
              <D.10199>:
              find_name.101 = find_name;
              if (find_name.101 == 0B) goto <D.10200>; else goto <D.10203>;
              <D.10203>:
              find_name.101 = find_name;
              D.10204 = cd->name;
              D.10205 = strstr (D.10204, find_name.101);
              if (D.10205 != 0B) goto <D.10200>; else goto <D.10201>;
              <D.10200>:
              D.10172 = obj_base + objdiff;
              D.10173 = D.10172 << 3;
              D.10206 = (unsigned int) D.10173;
              found_object (D.10206);
              <D.10201>:
              goto <D.10196>;
              <D.10195>:
              find_size.100 = find_size;
              if (find_size.100 == 0) goto <D.10207>; else goto <D.10208>;
              <D.10207>:
              find_name.101 = find_name;
              if (find_name.101 != 0B) goto <D.10209>; else goto <D.10210>;
              <D.10209>:
              find_name.101 = find_name;
              D.10204 = cd->name;
              D.10211 = strstr (D.10204, find_name.101);
              if (D.10211 != 0B) goto <D.10212>; else goto <D.10213>;
              <D.10212>:
              D.10172 = obj_base + objdiff;
              D.10173 = D.10172 << 3;
              D.10206 = (unsigned int) D.10173;
              found_object (D.10206);
              <D.10213>:
              <D.10210>:
              <D.10208>:
              <D.10196>:
              num_tracked_objects.94 = num_tracked_objects;
              if (num_tracked_objects.94 != 0) goto <D.10214>; else goto <D.10215>;
              <D.10214>:
              D.10172 = obj_base + objdiff;
              D.10173 = D.10172 << 3;
              D.10206 = (unsigned int) D.10173;
              tracked_creation (D.10206, cd, len, bt, time_base);
              <D.10215>:
            }
            <D.10181>:
            if (&sframes != frames) goto <D.10216>; else goto <D.10217>;
            <D.10216>:
            free (frames);
            <D.10217>:
            goto <D.8462>;
          }
        finally
          {
            num_bt = {CLOBBER};
            sframes = {CLOBBER};
          }
      }
      <D.8505>:
      {
        int subtype;
        uint64_t tdiff;
        int64_t ptrdiff;

        p.76 = p;
        D.10037 = *p.76;
        D.10038 = (int) D.10037;
        subtype = D.10038 & 240;
        p.76 = p;
        D.10040 = p.76 + 1;
        tdiff = decode_uleb128 (D.10040, &p);
        p.76 = p;
        D.10218 = decode_sleb128 (p.76, &p);
        ptrdiff = (int64_t) D.10218;
        time_base = time_base + tdiff;
        D.10219 = (unsigned int) ptrdiff;
        method_base.102 = (unsigned int) method_base;
        D.10221 = D.10219 + method_base.102;
        method_base = (intptr_t) D.10221;
        if (subtype == 64) goto <D.10222>; else goto <D.10223>;
        <D.10222>:
        {
          intptr_t codediff;
          int codelen;

          p.76 = p;
          codediff = decode_sleb128 (p.76, &p);
          p.76 = p;
          D.10224 = decode_uleb128 (p.76, &p);
          codelen = (int) D.10224;
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10225>; else goto <D.10226>;
          <D.10225>:
          D.10227 = ptr_base + codediff;
          D.10228 = (void *) D.10227;
          p.76 = p;
          method_base.103 = (void *) method_base;
          outfile.77 = outfile;
          fprintf (outfile.77, "jitted method %p (%s), size: %d, code: %p\n", method_base.103, p.76, codelen, D.10228);
          <D.10226>:
          D.10227 = ptr_base + codediff;
          p.76 = p;
          add_method (method_base, p.76, D.10227, codelen);
          goto <D.8512>;
          <D.8511>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
          <D.8512>:
          p.76 = p;
          D.10037 = *p.76;
          if (D.10037 != 0) goto <D.8511>; else goto <D.8513>;
          <D.8513>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
        }
        goto <D.10230>;
        <D.10223>:
        {
          struct MethodDesc * method;

          thread_filter.98 = thread_filter;
          if (thread_filter.98 != 0) goto <D.10231>; else goto <D.10232>;
          <D.10231>:
          D.10056 = thread->thread_id;
          D.10184 = (unsigned int) D.10056;
          thread_filter.98 = thread_filter;
          if (D.10184 != thread_filter.98) goto <D.8462>; else goto <D.10233>;
          <D.10233>:
          <D.10232>:
          method = lookup_method (method_base);
          if (subtype == 32) goto <D.10234>; else goto <D.10235>;
          <D.10234>:
          D.10236 = &method->traces;
          add_trace_thread (thread, D.10236, 1);
          push_method (thread, method, time_base);
          goto <D.10237>;
          <D.10235>:
          pop_method (thread, method, time_base);
          <D.10237>:
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10238>; else goto <D.10239>;
          <D.10238>:
          D.10240 = method->name;
          if (subtype != 32) goto <D.10242>; else goto <D.10243>;
          <D.10242>:
          if (subtype == 48) goto <D.10245>; else goto <D.10246>;
          <D.10245>:
          iftmp.105 = "exleave";
          goto <D.10247>;
          <D.10246>:
          iftmp.105 = "leave";
          <D.10247>:
          iftmp.104 = iftmp.105;
          goto <D.10248>;
          <D.10243>:
          iftmp.104 = "enter";
          <D.10248>:
          outfile.77 = outfile;
          fprintf (outfile.77, "%s method %s\n", iftmp.104, D.10240);
          <D.10239>:
        }
        <D.10230>:
        goto <D.8462>;
      }
      <D.8515>:
      {
        int subtype;

        p.76 = p;
        D.10037 = *p.76;
        D.10038 = (int) D.10037;
        subtype = D.10038 & 240;
        if (subtype == 32) goto <D.10249>; else goto <D.10250>;
        <D.10249>:
        {
          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.76 = p;
              D.10040 = p.76 + 1;
              objdiff = decode_sleb128 (D.10040, &p);
              p.76 = p;
              ptrdiff = decode_sleb128 (p.76, &p);
              p.76 = p;
              size = decode_uleb128 (p.76, &p);
              p.76 = p;
              D.10251 = decode_uleb128 (p.76, &p);
              num = (uintptr_t) D.10251;
              last_obj_offset = 0;
              D.10252 = ptr_base + ptrdiff;
              cd = lookup_class (D.10252);
              if (size != 0) goto <D.10253>; else goto <D.10254>;
              <D.10253>:
              {
                struct HeapClassDesc * hcd;

                D.10255 = thread->current_heap_shot;
                hcd = add_heap_shot_class (D.10255, cd, size);
                collect_traces.106 = collect_traces;
                if (collect_traces.106 != 0) goto <D.10257>; else goto <D.10258>;
                <D.10257>:
                D.10259 = obj_base + objdiff;
                D.10260 = D.10259 << 3;
                D.10261 = (unsigned int) D.10260;
                ho = alloc_heap_obj (D.10261, hcd, num);
                D.10255 = thread->current_heap_shot;
                add_heap_shot_obj (D.10255, ho);
                ref_offset = 0;
                <D.10258>:
              }
              goto <D.10262>;
              <D.10254>:
              collect_traces.106 = collect_traces;
              if (collect_traces.106 != 0) goto <D.10263>; else goto <D.10264>;
              <D.10263>:
              D.10259 = obj_base + objdiff;
              D.10260 = D.10259 << 3;
              D.10261 = (unsigned int) D.10260;
              D.10255 = thread->current_heap_shot;
              ho = heap_shot_obj_add_refs (D.10255, D.10261, num, &ref_offset);
              <D.10264>:
              <D.10262>:
              i = 0;
              goto <D.8530>;
              <D.8529>:
              {
                uintptr_t offset;
                intptr_t obj1diff;

                D.10266 = ctx->data_version;
                if (D.10266 > 1) goto <D.10267>; else goto <D.10268>;
                <D.10267>:
                p.76 = p;
                D.10269 = decode_uleb128 (p.76, &p);
                D.10270 = (unsigned int) D.10269;
                iftmp.107 = D.10270 + last_obj_offset;
                goto <D.10271>;
                <D.10268>:
                iftmp.107 = 4294967295;
                <D.10271>:
                offset = iftmp.107;
                p.76 = p;
                obj1diff = decode_sleb128 (p.76, &p);
                last_obj_offset = offset;
                collect_traces.106 = collect_traces;
                if (collect_traces.106 != 0) goto <D.10272>; else goto <D.10273>;
                <D.10272>:
                ref_offset.108 = ref_offset;
                i.109 = (unsigned int) i;
                D.10276 = ref_offset.108 + i.109;
                D.10277 = obj_base + obj1diff;
                D.10278 = D.10277 << 3;
                D.10279 = (unsigned int) D.10278;
                ho->refs[D.10276] = D.10279;
                <D.10273>:
                num_tracked_objects.94 = num_tracked_objects;
                if (num_tracked_objects.94 != 0) goto <D.10280>; else goto <D.10281>;
                <D.10280>:
                D.10259 = obj_base + objdiff;
                D.10260 = D.10259 << 3;
                D.10261 = (unsigned int) D.10260;
                D.10277 = obj_base + obj1diff;
                D.10278 = D.10277 << 3;
                D.10279 = (unsigned int) D.10278;
                track_obj_reference (D.10279, D.10261, cd);
                <D.10281>:
              }
              i = i + 1;
              <D.8530>:
              i.109 = (unsigned int) i;
              if (i.109 < num) goto <D.8529>; else goto <D.8531>;
              <D.8531>:
              debug.81 = debug;
              if (debug.81 != 0) goto <D.10282>; else goto <D.10283>;
              <D.10282>:
              if (size != 0) goto <D.10284>; else goto <D.10285>;
              <D.10284>:
              D.10286 = cd->name;
              D.10259 = obj_base + objdiff;
              D.10260 = D.10259 << 3;
              D.10287 = (void *) D.10260;
              outfile.77 = outfile;
              fprintf (outfile.77, "traced object %p, size %llu (%s), refs: %d\n", D.10287, size, D.10286, num);
              <D.10285>:
              <D.10283>:
            }
          finally
            {
              ref_offset = {CLOBBER};
            }
        }
        goto <D.10288>;
        <D.10250>:
        if (subtype == 48) goto <D.10289>; else goto <D.10290>;
        <D.10289>:
        {
          uintptr_t num;
          uintptr_t gc_num;
          int i;

          p.76 = p;
          D.10040 = p.76 + 1;
          D.10291 = decode_uleb128 (D.10040, &p);
          num = (uintptr_t) D.10291;
          p.76 = p;
          D.10292 = decode_uleb128 (p.76, &p);
          gc_num = (uintptr_t) D.10292;
          i = 0;
          goto <D.8539>;
          <D.8538>:
          {
            intptr_t objdiff;
            int root_type;
            uintptr_t extra_info;

            p.76 = p;
            objdiff = decode_sleb128 (p.76, &p);
            p.76 = p;
            D.10293 = decode_uleb128 (p.76, &p);
            root_type = (int) D.10293;
            p.76 = p;
            D.10294 = decode_uleb128 (p.76, &p);
            extra_info = (uintptr_t) D.10294;
            debug.81 = debug;
            if (debug.81 != 0) goto <D.10295>; else goto <D.10296>;
            <D.10295>:
            D.10297 = get_root_name (root_type);
            D.10298 = obj_base + objdiff;
            D.10299 = D.10298 << 3;
            D.10300 = (void *) D.10299;
            outfile.77 = outfile;
            fprintf (outfile.77, "object %p is a %s root\n", D.10300, D.10297);
            <D.10296>:
            collect_traces.106 = collect_traces;
            if (collect_traces.106 != 0) goto <D.10301>; else goto <D.10302>;
            <D.10301>:
            D.10298 = obj_base + objdiff;
            D.10299 = D.10298 << 3;
            D.10303 = (unsigned int) D.10299;
            thread_add_root (thread, D.10303, root_type, extra_info);
            <D.10302>:
          }
          i = i + 1;
          <D.8539>:
          i.110 = (unsigned int) i;
          if (i.110 < num) goto <D.8538>; else goto <D.8540>;
          <D.8540>:
        }
        goto <D.10305>;
        <D.10290>:
        if (subtype == 16) goto <D.10306>; else goto <D.10307>;
        <D.10306>:
        {
          uint64_t tdiff;

          p.76 = p;
          D.10040 = p.76 + 1;
          tdiff = decode_uleb128 (D.10040, &p);
          time_base = time_base + tdiff;
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10308>; else goto <D.10309>;
          <D.10308>:
          outfile.77 = outfile;
          fprintf (outfile.77, "heap shot end\n");
          <D.10309>:
          collect_traces.106 = collect_traces;
          if (collect_traces.106 != 0) goto <D.10310>; else goto <D.10311>;
          <D.10310>:
          {
            struct HeapShot * hs;

            hs = thread->current_heap_shot;
            if (hs != 0B) goto <D.10314>; else goto <D.10312>;
            <D.10314>:
            D.10315 = thread->num_roots;
            if (D.10315 != 0) goto <D.10316>; else goto <D.10312>;
            <D.10316>:
            D.10315 = thread->num_roots;
            hs->num_roots = D.10315;
            D.10317 = thread->roots;
            hs->roots = D.10317;
            D.10318 = thread->roots_extra;
            hs->roots_extra = D.10318;
            D.10319 = thread->roots_types;
            hs->roots_types = D.10319;
            goto <D.10313>;
            <D.10312>:
            D.10317 = thread->roots;
            free (D.10317);
            D.10318 = thread->roots_extra;
            free (D.10318);
            D.10319 = thread->roots_types;
            free (D.10319);
            <D.10313>:
            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.10311>:
          thread->current_heap_shot = 0B;
        }
        goto <D.10320>;
        <D.10307>:
        if (subtype == 0) goto <D.10321>; else goto <D.10322>;
        <D.10321>:
        {
          uint64_t tdiff;

          p.76 = p;
          D.10040 = p.76 + 1;
          tdiff = decode_uleb128 (D.10040, &p);
          time_base = time_base + tdiff;
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10323>; else goto <D.10324>;
          <D.10323>:
          outfile.77 = outfile;
          fprintf (outfile.77, "heap shot start\n");
          <D.10324>:
          D.10325 = new_heap_shot (time_base);
          thread->current_heap_shot = D.10325;
        }
        <D.10322>:
        <D.10320>:
        <D.10305>:
        <D.10288>:
        goto <D.8462>;
      }
      <D.8544>:
      {
        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.76 = p;
            D.10037 = *p.76;
            D.10326 = D.10037 >> 4;
            D.10327 = (int) D.10326;
            event = D.10327 & 3;
            p.76 = p;
            D.10037 = *p.76;
            D.10038 = (int) D.10037;
            has_bt = D.10038 & 128;
            p.76 = p;
            D.10040 = p.76 + 1;
            tdiff = decode_uleb128 (D.10040, &p);
            p.76 = p;
            objdiff = decode_sleb128 (p.76, &p);
            frames = &sframes;
            num_bt = 0;
            time_base = time_base + tdiff;
            thread_filter.98 = thread_filter;
            if (thread_filter.98 == 0) goto <D.10329>; else goto <D.10332>;
            <D.10332>:
            D.10056 = thread->thread_id;
            D.10184 = (unsigned int) D.10056;
            thread_filter.98 = thread_filter;
            if (D.10184 == thread_filter.98) goto <D.10329>; else goto <D.10330>;
            <D.10329>:
            iftmp.111 = 1;
            goto <D.10331>;
            <D.10330>:
            iftmp.111 = 0;
            <D.10331>:
            record = iftmp.111;
            if (event == 1) goto <D.10333>; else goto <D.10334>;
            <D.10333>:
            {
              struct MonitorDesc * mdesc;

              D.10335 = obj_base + objdiff;
              D.10336 = D.10335 << 3;
              D.10337 = (unsigned int) D.10336;
              mdesc = lookup_monitor (D.10337);
              if (record != 0) goto <D.10338>; else goto <D.10339>;
              <D.10338>:
              monitor_contention.112 = monitor_contention;
              monitor_contention.113 = monitor_contention.112 + 1;
              monitor_contention = monitor_contention.113;
              D.10342 = mdesc->contentions;
              D.10343 = D.10342 + 1;
              mdesc->contentions = D.10343;
              thread->monitor = mdesc;
              thread->contention_start = time_base;
              <D.10339>:
              if (has_bt != 0) goto <D.10344>; else goto <D.10345>;
              <D.10344>:
              num_bt = 8;
              p.76 = p;
              frames = decode_bt (&sframes, &num_bt, p.76, &p, ptr_base);
              if (frames == 0B) goto <D.10346>; else goto <D.10347>;
              <D.10346>:
              outfile.77 = outfile;
              fprintf (outfile.77, "Cannot load backtrace\n");
              D.9980 = 0;
              return D.9980;
              <D.10347>:
              if (record != 0) goto <D.10348>; else goto <D.10349>;
              <D.10348>:
              D.10350 = &mdesc->traces;
              num_bt.114 = num_bt;
              add_trace_methods (frames, num_bt.114, D.10350, 1);
              <D.10349>:
              goto <D.10352>;
              <D.10345>:
              if (record != 0) goto <D.10353>; else goto <D.10354>;
              <D.10353>:
              D.10350 = &mdesc->traces;
              add_trace_thread (thread, D.10350, 1);
              <D.10354>:
              <D.10352>:
            }
            goto <D.10355>;
            <D.10334>:
            if (event == 3) goto <D.10356>; else goto <D.10357>;
            <D.10356>:
            if (record != 0) goto <D.10358>; else goto <D.10359>;
            <D.10358>:
            monitor_failed.115 = monitor_failed;
            monitor_failed.116 = monitor_failed.115 + 1;
            monitor_failed = monitor_failed.116;
            D.10362 = thread->monitor;
            if (D.10362 != 0B) goto <D.10363>; else goto <D.10364>;
            <D.10363>:
            D.10365 = thread->contention_start;
            if (D.10365 != 0) goto <D.10366>; else goto <D.10367>;
            <D.10366>:
            {
              uint64_t wait_time;

              D.10365 = thread->contention_start;
              wait_time = time_base - D.10365;
              D.10362 = thread->monitor;
              D.10368 = D.10362->max_wait_time;
              if (D.10368 < wait_time) goto <D.10369>; else goto <D.10370>;
              <D.10369>:
              D.10362 = thread->monitor;
              D.10362->max_wait_time = wait_time;
              <D.10370>:
              D.10362 = thread->monitor;
              D.10362 = thread->monitor;
              D.10371 = D.10362->wait_time;
              D.10372 = D.10371 + wait_time;
              D.10362->wait_time = D.10372;
              thread->monitor = 0B;
              thread->contention_start = 0;
            }
            <D.10367>:
            <D.10364>:
            <D.10359>:
            goto <D.10373>;
            <D.10357>:
            if (event == 2) goto <D.10374>; else goto <D.10375>;
            <D.10374>:
            if (record != 0) goto <D.10376>; else goto <D.10377>;
            <D.10376>:
            monitor_acquired.117 = monitor_acquired;
            monitor_acquired.118 = monitor_acquired.117 + 1;
            monitor_acquired = monitor_acquired.118;
            D.10362 = thread->monitor;
            if (D.10362 != 0B) goto <D.10380>; else goto <D.10381>;
            <D.10380>:
            D.10365 = thread->contention_start;
            if (D.10365 != 0) goto <D.10382>; else goto <D.10383>;
            <D.10382>:
            {
              uint64_t wait_time;

              D.10365 = thread->contention_start;
              wait_time = time_base - D.10365;
              D.10362 = thread->monitor;
              D.10368 = D.10362->max_wait_time;
              if (D.10368 < wait_time) goto <D.10384>; else goto <D.10385>;
              <D.10384>:
              D.10362 = thread->monitor;
              D.10362->max_wait_time = wait_time;
              <D.10385>:
              D.10362 = thread->monitor;
              D.10362 = thread->monitor;
              D.10371 = D.10362->wait_time;
              D.10386 = D.10371 + wait_time;
              D.10362->wait_time = D.10386;
              thread->monitor = 0B;
              thread->contention_start = 0;
            }
            <D.10383>:
            <D.10381>:
            <D.10377>:
            <D.10375>:
            <D.10373>:
            <D.10355>:
            debug.81 = debug;
            if (debug.81 != 0) goto <D.10387>; else goto <D.10388>;
            <D.10387>:
            D.10335 = obj_base + objdiff;
            D.10336 = D.10335 << 3;
            D.10389 = (void *) D.10336;
            D.10390 = monitor_ev_name (event);
            outfile.77 = outfile;
            fprintf (outfile.77, "monitor %s for object %p\n", D.10390, D.10389);
            <D.10388>:
            if (&sframes != frames) goto <D.10391>; else goto <D.10392>;
            <D.10391>:
            free (frames);
            <D.10392>:
            goto <D.8462>;
          }
        finally
          {
            sframes = {CLOBBER};
            num_bt = {CLOBBER};
          }
      }
      <D.8556>:
      {
        int subtype;
        int has_bt;
        uint64_t tdiff;
        struct MethodDesc * sframes[8];
        struct MethodDesc * * frames;
        int record;

        try
          {
            p.76 = p;
            D.10037 = *p.76;
            D.10038 = (int) D.10037;
            subtype = D.10038 & 112;
            p.76 = p;
            D.10037 = *p.76;
            D.10038 = (int) D.10037;
            has_bt.119 = D.10038 & 128;
            has_bt = has_bt.119;
            p.76 = p;
            D.10040 = p.76 + 1;
            tdiff = decode_uleb128 (D.10040, &p);
            frames = &sframes;
            time_base = time_base + tdiff;
            thread_filter.98 = thread_filter;
            if (thread_filter.98 == 0) goto <D.10395>; else goto <D.10398>;
            <D.10398>:
            D.10056 = thread->thread_id;
            D.10184 = (unsigned int) D.10056;
            thread_filter.98 = thread_filter;
            if (D.10184 == thread_filter.98) goto <D.10395>; else goto <D.10396>;
            <D.10395>:
            iftmp.120 = 1;
            goto <D.10397>;
            <D.10396>:
            iftmp.120 = 0;
            <D.10397>:
            record = iftmp.120;
            if (subtype == 16) goto <D.10399>; else goto <D.10400>;
            <D.10399>:
            {
              int clause_type;
              int clause_num;
              int64_t ptrdiff;

              p.76 = p;
              D.10401 = decode_uleb128 (p.76, &p);
              clause_type = (int) D.10401;
              p.76 = p;
              D.10402 = decode_uleb128 (p.76, &p);
              clause_num = (int) D.10402;
              p.76 = p;
              D.10403 = decode_sleb128 (p.76, &p);
              ptrdiff = (int64_t) D.10403;
              D.10404 = (unsigned int) ptrdiff;
              method_base.102 = (unsigned int) method_base;
              D.10405 = D.10404 + method_base.102;
              method_base = (intptr_t) D.10405;
              if (record != 0) goto <D.10406>; else goto <D.10407>;
              <D.10406>:
              D.10408 = clause_summary[clause_type];
              D.10409 = D.10408 + 1;
              clause_summary[clause_type] = D.10409;
              <D.10407>:
              debug.81 = debug;
              if (debug.81 != 0) goto <D.10410>; else goto <D.10411>;
              <D.10410>:
              D.10412 = lookup_method (method_base);
              D.10413 = D.10412->name;
              D.10414 = clause_name (clause_type);
              outfile.77 = outfile;
              fprintf (outfile.77, "clause %s (%d) in method %s\n", D.10414, clause_num, D.10413);
              <D.10411>:
            }
            goto <D.10415>;
            <D.10400>:
            {
              intptr_t objdiff;

              p.76 = p;
              objdiff = decode_sleb128 (p.76, &p);
              if (record != 0) goto <D.10416>; else goto <D.10417>;
              <D.10416>:
              throw_count.121 = throw_count;
              throw_count.122 = throw_count.121 + 1;
              throw_count = throw_count.122;
              <D.10417>:
              has_bt.123 = has_bt;
              if (has_bt.123 != 0) goto <D.10421>; else goto <D.10422>;
              <D.10421>:
              has_bt = 8;
              p.76 = p;
              frames = decode_bt (&sframes, &has_bt, p.76, &p, ptr_base);
              if (frames == 0B) goto <D.10423>; else goto <D.10424>;
              <D.10423>:
              outfile.77 = outfile;
              fprintf (outfile.77, "Cannot load backtrace\n");
              D.9980 = 0;
              return D.9980;
              <D.10424>:
              if (record != 0) goto <D.10425>; else goto <D.10426>;
              <D.10425>:
              has_bt.123 = has_bt;
              add_trace_methods (frames, has_bt.123, &exc_traces, 1);
              <D.10426>:
              goto <D.10427>;
              <D.10422>:
              if (record != 0) goto <D.10428>; else goto <D.10429>;
              <D.10428>:
              add_trace_thread (thread, &exc_traces, 1);
              <D.10429>:
              <D.10427>:
              if (&sframes != frames) goto <D.10430>; else goto <D.10431>;
              <D.10430>:
              free (frames);
              <D.10431>:
              debug.81 = debug;
              if (debug.81 != 0) goto <D.10432>; else goto <D.10433>;
              <D.10432>:
              D.10434 = obj_base + objdiff;
              D.10435 = D.10434 << 3;
              D.10436 = (void *) D.10435;
              outfile.77 = outfile;
              fprintf (outfile.77, "throw %p\n", D.10436);
              <D.10433>:
            }
            <D.10415>:
            goto <D.8462>;
          }
        finally
          {
            has_bt = {CLOBBER};
            sframes = {CLOBBER};
          }
      }
      <D.8567>:
      {
        int subtype;

        p.76 = p;
        D.10037 = *p.76;
        D.10038 = (int) D.10037;
        subtype = D.10038 & 240;
        if (subtype == 0) goto <D.10437>; else goto <D.10438>;
        <D.10437>:
        {
          int i;
          int sample_type;
          uint64_t tstamp;
          int count;

          p.76 = p;
          D.10040 = p.76 + 1;
          D.10439 = decode_uleb128 (D.10040, &p);
          sample_type = (int) D.10439;
          p.76 = p;
          tstamp = decode_uleb128 (p.76, &p);
          p.76 = p;
          D.10440 = decode_uleb128 (p.76, &p);
          count = (int) D.10440;
          i = 0;
          goto <D.8575>;
          <D.8574>:
          {
            uintptr_t ip;

            p.76 = p;
            D.10441 = decode_sleb128 (p.76, &p);
            D.10442 = D.10441 + ptr_base;
            ip = (uintptr_t) D.10442;
            add_stat_sample (sample_type, ip);
            debug.81 = debug;
            if (debug.81 != 0) goto <D.10443>; else goto <D.10444>;
            <D.10443>:
            ip.124 = (void *) ip;
            outfile.77 = outfile;
            fprintf (outfile.77, "sample hit, type: %d at %p\n", sample_type, ip.124);
            <D.10444>:
          }
          i = i + 1;
          <D.8575>:
          if (i < count) goto <D.8574>; else goto <D.8576>;
          <D.8576>:
        }
        goto <D.10446>;
        <D.10438>:
        if (subtype == 16) goto <D.10447>; else goto <D.10448>;
        <D.10447>:
        {
          uintptr_t addr;
          uintptr_t size;
          char * name;

          p.76 = p;
          D.10040 = p.76 + 1;
          D.10449 = decode_sleb128 (D.10040, &p);
          D.10450 = D.10449 + ptr_base;
          addr = (uintptr_t) D.10450;
          p.76 = p;
          D.10451 = decode_uleb128 (p.76, &p);
          size = (uintptr_t) D.10451;
          p.76 = p;
          name = pstrdup (p.76);
          add_unmanaged_symbol (addr, name, size);
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10452>; else goto <D.10453>;
          <D.10452>:
          addr.125 = (void *) addr;
          outfile.77 = outfile;
          fprintf (outfile.77, "unmanaged symbol %s at %p\n", name, addr.125);
          <D.10453>:
          goto <D.8581>;
          <D.8580>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
          <D.8581>:
          p.76 = p;
          D.10037 = *p.76;
          if (D.10037 != 0) goto <D.8580>; else goto <D.8582>;
          <D.8582>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
        }
        goto <D.10455>;
        <D.10448>:
        if (subtype == 32) goto <D.10456>; else goto <D.10457>;
        <D.10456>:
        {
          uint64_t tdiff;
          uintptr_t addr;
          uint64_t offset;
          uintptr_t size;
          char * name;

          p.76 = p;
          D.10040 = p.76 + 1;
          tdiff = decode_uleb128 (D.10040, &p);
          p.76 = p;
          D.10458 = decode_sleb128 (p.76, &p);
          addr = (uintptr_t) D.10458;
          p.76 = p;
          offset = decode_uleb128 (p.76, &p);
          p.76 = p;
          D.10459 = decode_uleb128 (p.76, &p);
          size = (uintptr_t) D.10459;
          time_base = time_base + tdiff;
          p.76 = p;
          name = pstrdup (p.76);
          add_unmanaged_binary (addr, name, size);
          debug.81 = debug;
          if (debug.81 != 0) goto <D.10460>; else goto <D.10461>;
          <D.10460>:
          addr.126 = (void *) addr;
          outfile.77 = outfile;
          fprintf (outfile.77, "unmanaged binary %s at %p\n", name, addr.126);
          <D.10461>:
          goto <D.8589>;
          <D.8588>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
          <D.8589>:
          p.76 = p;
          D.10037 = *p.76;
          if (D.10037 != 0) goto <D.8588>; else goto <D.8590>;
          <D.8590>:
          p.76 = p;
          p.97 = p.76 + 1;
          p = p.97;
        }
        goto <D.10463>;
        <D.10457>:
        D.9980 = 0;
        return D.9980;
        <D.10463>:
        <D.10455>:
        <D.10446>:
        goto <D.8462>;
      }
      <D.8591>:
      p.76 = p;
      p.127 = (int) p.76;
      p.75 = ctx->buf;
      p.128 = (int) p.75;
      D.10466 = p.127 - p.128;
      p.76 = p;
      D.10037 = *p.76;
      D.10038 = (int) D.10037;
      outfile.77 = outfile;
      fprintf (outfile.77, "unhandled profiler event: 0x%x at file offset: %llu + %d (len: %d\n)\n", D.10038, file_offset, D.10466, len);
      exit (1);
      <D.8462>:
      <D.8593>:
      p.76 = p;
      if (p.76 < end) goto <D.8592>; else goto <D.8594>;
      <D.8594>:
      thread->last_time = time_base;
      i = 0;
      goto <D.8596>;
      <D.8595>:
      D.10028 = thread->stack;
      i.87 = (unsigned int) i;
      D.10030 = i.87 * 4;
      D.10031 = D.10028 + D.10030;
      D.10032 = *D.10031;
      D.10032->recurse_count = 0;
      i = i + 1;
      <D.8596>:
      D.10035 = thread->stack_id;
      if (D.10035 > i) goto <D.8595>; else goto <D.8597>;
      <D.8597>:
      D.9980 = 1;
      return D.9980;
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

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


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

  switch (ev) <default: <D.8321>, case 0: <D.8311>, case 1: <D.8312>, case 2: <D.8313>, case 3: <D.8314>, case 4: <D.8315>, case 5: <D.8316>, case 6: <D.8317>, case 7: <D.8318>, case 8: <D.8319>, case 9: <D.8320>>
  <D.8311>:
  D.10578 = "start";
  return D.10578;
  <D.8312>:
  D.10578 = "mark start";
  return D.10578;
  <D.8313>:
  D.10578 = "mark end";
  return D.10578;
  <D.8314>:
  D.10578 = "reclaim start";
  return D.10578;
  <D.8315>:
  D.10578 = "reclaim end";
  return D.10578;
  <D.8316>:
  D.10578 = "end";
  return D.10578;
  <D.8317>:
  D.10578 = "pre stop";
  return D.10578;
  <D.8318>:
  D.10578 = "post stop";
  return D.10578;
  <D.8319>:
  D.10578 = "pre start";
  return D.10578;
  <D.8320>:
  D.10578 = "post start";
  return D.10578;
  <D.8321>:
  D.10578 = "unknown";
  return D.10578;
}


track_move (uintptr_t src, uintptr_t dst)
{
  uintptr_t * tracked_objects.129;
  unsigned int i.130;
  unsigned int D.10582;
  uintptr_t * D.10583;
  unsigned int D.10584;
  void * dst.131;
  void * src.132;
  struct FILE * outfile.133;
  int num_tracked_objects.134;
  int i;

  i = 0;
  goto <D.8422>;
  <D.8421>:
  tracked_objects.129 = tracked_objects;
  i.130 = (unsigned int) i;
  D.10582 = i.130 * 4;
  D.10583 = tracked_objects.129 + D.10582;
  D.10584 = *D.10583;
  if (D.10584 == src) goto <D.10585>; else goto <D.10586>;
  <D.10585>:
  dst.131 = (void *) dst;
  src.132 = (void *) src;
  outfile.133 = outfile;
  fprintf (outfile.133, "Object %p moved to %p\n", src.132, dst.131);
  goto <D.10590>;
  <D.10586>:
  tracked_objects.129 = tracked_objects;
  i.130 = (unsigned int) i;
  D.10582 = i.130 * 4;
  D.10583 = tracked_objects.129 + D.10582;
  D.10584 = *D.10583;
  if (D.10584 == dst) goto <D.10591>; else goto <D.10592>;
  <D.10591>:
  src.132 = (void *) src;
  dst.131 = (void *) dst;
  outfile.133 = outfile;
  fprintf (outfile.133, "Object %p moved from %p\n", dst.131, src.132);
  <D.10592>:
  <D.10590>:
  i = i + 1;
  <D.8422>:
  num_tracked_objects.134 = num_tracked_objects;
  if (i < num_tracked_objects.134) goto <D.8421>; else goto <D.8423>;
  <D.8423>:
}


track_handle (uintptr_t obj, int htype, uint32_t handle)
{
  uintptr_t * tracked_objects.135;
  unsigned int i.136;
  unsigned int D.10596;
  uintptr_t * D.10597;
  unsigned int D.10598;
  void * obj.137;
  struct FILE * outfile.138;
  int num_tracked_objects.139;
  int i;

  i = 0;
  goto <D.8414>;
  <D.8413>:
  tracked_objects.135 = tracked_objects;
  i.136 = (unsigned int) i;
  D.10596 = i.136 * 4;
  D.10597 = tracked_objects.135 + D.10596;
  D.10598 = *D.10597;
  if (D.10598 == obj) goto <D.10599>; else goto <D.10600>;
  <D.10599>:
  obj.137 = (void *) obj;
  outfile.138 = outfile;
  fprintf (outfile.138, "Object %p referenced from handle %u\n", obj.137, handle);
  <D.10600>:
  i = i + 1;
  <D.8414>:
  num_tracked_objects.139 = num_tracked_objects;
  if (i < num_tracked_objects.139) goto <D.8413>; else goto <D.8415>;
  <D.8415>:
}


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

  switch (htype) <default: <D.8366>, case 0: <D.8362>, case 1: <D.8363>, case 2: <D.8364>, case 3: <D.8365>>
  <D.8362>:
  D.10604 = "weak";
  return D.10604;
  <D.8363>:
  D.10604 = "weaktrack";
  return D.10604;
  <D.8364>:
  D.10604 = "normal";
  return D.10604;
  <D.8365>:
  D.10604 = "pinned";
  return D.10604;
  <D.8366>:
  D.10604 = "unknown";
  return D.10604;
}


add_class (intptr_t klass, const char * name)
{
  int D.10606;
  int D.10607;
  int D.10609;
  char * D.10612;
  char * D.10613;
  struct ClassDesc * D.10614;
  char * D.10615;
  struct ClassDesc * D.10616;
  int num_classes.140;
  int num_classes.141;
  int slot;
  struct ClassDesc * cd;

  D.10606 = klass >> 2;
  D.10607 = D.10606 & 65535;
  slot = D.10607 % 9371;
  cd = class_hash[slot];
  goto <D.7744>;
  <D.7743>:
  cd = cd->next;
  <D.7744>:
  if (cd != 0B) goto <D.10608>; else goto <D.7745>;
  <D.10608>:
  D.10609 = cd->klass;
  if (D.10609 != klass) goto <D.7743>; else goto <D.7745>;
  <D.7745>:
  if (cd != 0B) goto <D.10610>; else goto <D.10611>;
  <D.10610>:
  D.10612 = cd->name;
  free (D.10612);
  D.10613 = pstrdup (name);
  cd->name = D.10613;
  D.10614 = cd;
  return D.10614;
  <D.10611>:
  cd = calloc (36, 1);
  cd->klass = klass;
  D.10615 = pstrdup (name);
  cd->name = D.10615;
  D.10616 = class_hash[slot];
  cd->next = D.10616;
  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.140 = num_classes;
  num_classes.141 = num_classes.140 + 1;
  num_classes = num_classes.141;
  D.10614 = cd;
  return D.10614;
}


add_image (intptr_t image, char * name)
{
  int D.10622;
  int D.10623;
  char * D.10624;
  struct ImageDesc * D.10625;
  int num_images.142;
  int num_images.143;
  int slot;
  struct ImageDesc * cd;

  D.10622 = image >> 2;
  D.10623 = D.10622 & 65535;
  slot = D.10623 % 31;
  cd = malloc (12);
  cd->image = image;
  D.10624 = pstrdup (name);
  cd->filename = D.10624;
  D.10625 = image_hash[slot];
  cd->next = D.10625;
  image_hash[slot] = cd;
  num_images.142 = num_images;
  num_images.143 = num_images.142 + 1;
  num_images = num_images.143;
}


get_thread (struct ProfContext * ctx, intptr_t thread_id)
{
  struct ThreadContext * D.10629;
  int D.10632;
  struct ThreadContext * D.10635;
  int D.10636;
  struct ThreadContext * D.10639;
  int D.10640;
  unsigned int D.10641;
  unsigned int D.10642;
  void * D.10643;
  unsigned int D.10644;
  void * D.10645;
  void * D.10646;
  struct ThreadContext * thread;

  D.10629 = ctx->current;
  if (D.10629 != 0B) goto <D.10630>; else goto <D.10631>;
  <D.10630>:
  D.10629 = ctx->current;
  D.10632 = D.10629->thread_id;
  if (D.10632 == thread_id) goto <D.10633>; else goto <D.10634>;
  <D.10633>:
  D.10635 = ctx->current;
  return D.10635;
  <D.10634>:
  <D.10631>:
  thread = ctx->threads;
  goto <D.8214>;
  <D.8213>:
  D.10636 = thread->thread_id;
  if (D.10636 == thread_id) goto <D.10637>; else goto <D.10638>;
  <D.10637>:
  D.10635 = thread;
  return D.10635;
  <D.10638>:
  thread = thread->next;
  <D.8214>:
  if (thread != 0B) goto <D.8213>; else goto <D.8215>;
  <D.8215>:
  thread = calloc (100, 1);
  D.10639 = ctx->threads;
  thread->next = D.10639;
  ctx->threads = thread;
  thread->thread_id = thread_id;
  thread->last_time = 0;
  thread->stack_id = 0;
  thread->stack_size = 32;
  D.10640 = thread->stack_size;
  D.10641 = (unsigned int) D.10640;
  D.10642 = D.10641 * 4;
  D.10643 = malloc (D.10642);
  thread->stack = D.10643;
  D.10640 = thread->stack_size;
  D.10641 = (unsigned int) D.10640;
  D.10644 = D.10641 * 8;
  D.10645 = malloc (D.10644);
  thread->time_stack = D.10645;
  D.10640 = thread->stack_size;
  D.10641 = (unsigned int) D.10640;
  D.10644 = D.10641 * 8;
  D.10646 = malloc (D.10644);
  thread->callee_time_stack = D.10646;
  D.10635 = thread;
  return D.10635;
}


tracked_creation (uintptr_t obj, struct ClassDesc * cd, uint64_t size, struct BackTrace * bt, uint64_t timestamp)
{
  uintptr_t * tracked_objects.144;
  unsigned int i.145;
  unsigned int D.10650;
  uintptr_t * D.10651;
  unsigned int D.10652;
  long long unsigned int startup_time.146;
  long long unsigned int D.10656;
  double D.10657;
  double D.10658;
  char * D.10659;
  void * obj.147;
  struct FILE * outfile.148;
  int D.10664;
  struct MethodDesc * D.10667;
  char * D.10668;
  int num_tracked_objects.149;
  int i;

  i = 0;
  goto <D.8405>;
  <D.8404>:
  tracked_objects.144 = tracked_objects;
  i.145 = (unsigned int) i;
  D.10650 = i.145 * 4;
  D.10651 = tracked_objects.144 + D.10650;
  D.10652 = *D.10651;
  if (D.10652 != obj) goto <D.10653>; else goto <D.10654>;
  <D.10653>:
  // predicted unlikely by continue predictor.
  goto <D.8399>;
  <D.10654>:
  startup_time.146 = startup_time;
  D.10656 = timestamp - startup_time.146;
  D.10657 = (double) D.10656;
  D.10658 = D.10657 / 1.0e+9;
  D.10659 = cd->name;
  obj.147 = (void *) obj;
  outfile.148 = outfile;
  fprintf (outfile.148, "Object %p created (%s, %llu bytes) at %.3f secs.\n", obj.147, D.10659, size, D.10658);
  if (bt != 0B) goto <D.10662>; else goto <D.10663>;
  <D.10662>:
  D.10664 = bt->count;
  if (D.10664 != 0) goto <D.10665>; else goto <D.10666>;
  <D.10665>:
  {
    int k;

    k = 0;
    goto <D.8402>;
    <D.8401>:
    D.10667 = bt->methods[k];
    D.10668 = D.10667->name;
    outfile.148 = outfile;
    fprintf (outfile.148, "\t%s\n", D.10668);
    k = k + 1;
    <D.8402>:
    D.10664 = bt->count;
    if (D.10664 > k) goto <D.8401>; else goto <D.8403>;
    <D.8403>:
  }
  <D.10666>:
  <D.10663>:
  <D.8399>:
  i = i + 1;
  <D.8405>:
  num_tracked_objects.149 = num_tracked_objects;
  if (i < num_tracked_objects.149) goto <D.8404>; else goto <D.8406>;
  <D.8406>:
}


add_method (intptr_t method, const char * name, intptr_t code, int len)
{
  int D.10670;
  int D.10671;
  int D.10673;
  char * D.10676;
  char * D.10677;
  struct MethodDesc * D.10678;
  char * D.10679;
  struct MethodDesc * D.10680;
  int num_methods.150;
  int num_methods.151;
  int slot;
  struct MethodDesc * cd;

  D.10670 = method >> 2;
  D.10671 = D.10670 & 65535;
  slot = D.10671 % 9371;
  cd = method_hash[slot];
  goto <D.7780>;
  <D.7779>:
  cd = cd->next;
  <D.7780>:
  if (cd != 0B) goto <D.10672>; else goto <D.7781>;
  <D.10672>:
  D.10673 = cd->method;
  if (D.10673 != method) goto <D.7779>; else goto <D.7781>;
  <D.7781>:
  if (cd != 0B) goto <D.10674>; else goto <D.10675>;
  <D.10674>:
  cd->code = code;
  cd->len = len;
  D.10676 = cd->name;
  free (D.10676);
  D.10677 = pstrdup (name);
  cd->name = D.10677;
  D.10678 = cd;
  return D.10678;
  <D.10675>:
  cd = calloc (72, 1);
  cd->method = method;
  D.10679 = pstrdup (name);
  cd->name = D.10679;
  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.10680 = method_hash[slot];
  cd->next = D.10680;
  method_hash[slot] = cd;
  num_methods.150 = num_methods;
  num_methods.151 = num_methods.150 + 1;
  num_methods = num_methods.151;
  D.10678 = cd;
  return D.10678;
}


push_method (struct ThreadContext * thread, struct MethodDesc * method, uint64_t timestamp)
{
  uint64_t * D.10686;
  int D.10687;
  unsigned int D.10688;
  unsigned int D.10689;
  uint64_t * D.10690;
  uint64_t * D.10691;
  uint64_t * D.10692;
  struct MethodDesc * * D.10693;
  int D.10694;
  int D.10695;
  unsigned int D.10696;
  unsigned int D.10697;
  struct MethodDesc * * D.10698;
  int D.10699;
  int D.10700;

  ensure_thread_stack (thread);
  D.10686 = thread->time_stack;
  D.10687 = thread->stack_id;
  D.10688 = (unsigned int) D.10687;
  D.10689 = D.10688 * 8;
  D.10690 = D.10686 + D.10689;
  *D.10690 = timestamp;
  D.10691 = thread->callee_time_stack;
  D.10687 = thread->stack_id;
  D.10688 = (unsigned int) D.10687;
  D.10689 = D.10688 * 8;
  D.10692 = D.10691 + D.10689;
  *D.10692 = 0;
  D.10693 = thread->stack;
  D.10687 = thread->stack_id;
  D.10694 = D.10687;
  D.10695 = D.10694 + 1;
  thread->stack_id = D.10695;
  D.10696 = (unsigned int) D.10694;
  D.10697 = D.10696 * 4;
  D.10698 = D.10693 + D.10697;
  *D.10698 = method;
  D.10699 = method->recurse_count;
  D.10700 = D.10699 + 1;
  method->recurse_count = D.10700;
}


ensure_thread_stack (struct ThreadContext * thread)
{
  int D.10701;
  int D.10702;
  int D.10705;
  unsigned int D.10706;
  unsigned int D.10707;
  struct MethodDesc * * D.10708;
  void * D.10709;
  unsigned int D.10710;
  uint64_t * D.10711;
  void * D.10712;
  uint64_t * D.10713;
  void * D.10714;

  D.10701 = thread->stack_id;
  D.10702 = thread->stack_size;
  if (D.10701 == D.10702) goto <D.10703>; else goto <D.10704>;
  <D.10703>:
  D.10702 = thread->stack_size;
  D.10705 = D.10702 * 2;
  thread->stack_size = D.10705;
  D.10702 = thread->stack_size;
  D.10706 = (unsigned int) D.10702;
  D.10707 = D.10706 * 4;
  D.10708 = thread->stack;
  D.10709 = realloc (D.10708, D.10707);
  thread->stack = D.10709;
  D.10702 = thread->stack_size;
  D.10706 = (unsigned int) D.10702;
  D.10710 = D.10706 * 8;
  D.10711 = thread->time_stack;
  D.10712 = realloc (D.10711, D.10710);
  thread->time_stack = D.10712;
  D.10702 = thread->stack_size;
  D.10706 = (unsigned int) D.10702;
  D.10710 = D.10706 * 8;
  D.10713 = thread->callee_time_stack;
  D.10714 = realloc (D.10713, D.10710);
  thread->callee_time_stack = D.10714;
  <D.10704>:
}


pop_method (struct ThreadContext * thread, struct MethodDesc * method, uint64_t timestamp)
{
  int D.10715;
  int D.10716;
  int D.10719;
  struct MethodDesc * * D.10721;
  sizetype D.10722;
  sizetype D.10723;
  sizetype D.10724;
  struct MethodDesc * * D.10725;
  struct MethodDesc * D.10726;
  int D.10728;
  long long unsigned int D.10729;
  long long unsigned int D.10730;
  uint64_t * D.10731;
  unsigned int D.10732;
  unsigned int D.10733;
  uint64_t * D.10734;
  long long unsigned int D.10735;
  char * D.10738;
  struct FILE * outfile.152;
  uint64_t * D.10740;
  uint64_t * D.10741;
  long long unsigned int D.10742;
  long long unsigned int D.10745;
  long long unsigned int D.10746;
  long long unsigned int D.10747;
  long long unsigned int D.10748;
  long long unsigned int D.10749;
  sizetype D.10752;
  sizetype D.10753;
  uint64_t * D.10754;
  long long unsigned int D.10755;
  long long unsigned int D.10756;

  D.10715 = method->recurse_count;
  D.10716 = D.10715 + -1;
  method->recurse_count = D.10716;
  D.10719 = thread->stack_id;
  if (D.10719 > 0) goto <D.10720>; else goto <D.10717>;
  <D.10720>:
  D.10721 = thread->stack;
  D.10719 = thread->stack_id;
  D.10722 = (sizetype) D.10719;
  D.10723 = D.10722 + 1073741823;
  D.10724 = D.10723 * 4;
  D.10725 = D.10721 + D.10724;
  D.10726 = *D.10725;
  if (D.10726 == method) goto <D.10727>; else goto <D.10717>;
  <D.10727>:
  {
    uint64_t tdiff;

    D.10719 = thread->stack_id;
    D.10728 = D.10719 + -1;
    thread->stack_id = D.10728;
    D.10729 = method->calls;
    D.10730 = D.10729 + 1;
    method->calls = D.10730;
    D.10731 = thread->time_stack;
    D.10719 = thread->stack_id;
    D.10732 = (unsigned int) D.10719;
    D.10733 = D.10732 * 8;
    D.10734 = D.10731 + D.10733;
    D.10735 = *D.10734;
    if (D.10735 > timestamp) goto <D.10736>; else goto <D.10737>;
    <D.10736>:
    D.10738 = method->name;
    outfile.152 = outfile;
    fprintf (outfile.152, "time went backwards for %s\n", D.10738);
    <D.10737>:
    D.10731 = thread->time_stack;
    D.10719 = thread->stack_id;
    D.10732 = (unsigned int) D.10719;
    D.10733 = D.10732 * 8;
    D.10734 = D.10731 + D.10733;
    D.10735 = *D.10734;
    tdiff = timestamp - D.10735;
    D.10740 = thread->callee_time_stack;
    D.10719 = thread->stack_id;
    D.10732 = (unsigned int) D.10719;
    D.10733 = D.10732 * 8;
    D.10741 = D.10740 + D.10733;
    D.10742 = *D.10741;
    if (D.10742 > tdiff) goto <D.10743>; else goto <D.10744>;
    <D.10743>:
    D.10738 = method->name;
    outfile.152 = outfile;
    fprintf (outfile.152, "callee time bigger for %s\n", D.10738);
    <D.10744>:
    D.10745 = method->self_time;
    D.10740 = thread->callee_time_stack;
    D.10719 = thread->stack_id;
    D.10732 = (unsigned int) D.10719;
    D.10733 = D.10732 * 8;
    D.10741 = D.10740 + D.10733;
    D.10742 = *D.10741;
    D.10746 = tdiff - D.10742;
    D.10747 = D.10745 + D.10746;
    method->self_time = D.10747;
    D.10748 = method->callee_time;
    D.10740 = thread->callee_time_stack;
    D.10719 = thread->stack_id;
    D.10732 = (unsigned int) D.10719;
    D.10733 = D.10732 * 8;
    D.10741 = D.10740 + D.10733;
    D.10742 = *D.10741;
    D.10749 = D.10748 + D.10742;
    method->callee_time = D.10749;
    D.10719 = thread->stack_id;
    if (D.10719 != 0) goto <D.10750>; else goto <D.10751>;
    <D.10750>:
    D.10740 = thread->callee_time_stack;
    D.10719 = thread->stack_id;
    D.10722 = (sizetype) D.10719;
    D.10752 = D.10722 + 536870911;
    D.10753 = D.10752 * 8;
    D.10754 = D.10740 + D.10753;
    D.10740 = thread->callee_time_stack;
    D.10719 = thread->stack_id;
    D.10722 = (sizetype) D.10719;
    D.10752 = D.10722 + 536870911;
    D.10753 = D.10752 * 8;
    D.10754 = D.10740 + D.10753;
    D.10755 = *D.10754;
    D.10756 = D.10755 + tdiff;
    *D.10754 = D.10756;
    <D.10751>:
  }
  goto <D.10718>;
  <D.10717>:
  D.10738 = method->name;
  D.10719 = thread->stack_id;
  outfile.152 = outfile;
  fprintf (outfile.152, "unmatched leave at stack pos: %d for method %s\n", D.10719, D.10738);
  <D.10718>:
}


lookup_class (intptr_t klass)
{
  int D.10757;
  int D.10758;
  int D.10760;
  void * klass.153;
  struct ClassDesc * D.10764;
  int slot;
  struct ClassDesc * cd;

  D.10757 = klass >> 2;
  D.10758 = D.10757 & 65535;
  slot = D.10758 % 9371;
  cd = class_hash[slot];
  goto <D.7752>;
  <D.7751>:
  cd = cd->next;
  <D.7752>:
  if (cd != 0B) goto <D.10759>; else goto <D.7753>;
  <D.10759>:
  D.10760 = cd->klass;
  if (D.10760 != klass) goto <D.7751>; else goto <D.7753>;
  <D.7753>:
  if (cd == 0B) goto <D.10761>; else goto <D.10762>;
  <D.10761>:
  {
    char buf[128];

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


snprintf (char * restrict __s, size_t __n, const char * restrict __fmt)
{
  int D.10769;
  unsigned int D.10770;

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


add_heap_shot_class (struct HeapShot * hs, struct ClassDesc * klass, uint64_t size)
{
  int D.10772;
  int D.10773;
  int D.10774;
  int D.10777;
  unsigned int D.10780;
  unsigned int D.10781;
  struct HeapClassDesc * * D.10782;
  unsigned int i.154;
  unsigned int D.10784;
  struct HeapClassDesc * * D.10785;
  struct HeapClassDesc * res.155;
  long long int D.10789;
  long long unsigned int D.10790;
  long long int D.10791;
  long long unsigned int D.10792;
  struct ClassDesc * D.10793;
  unsigned int D.10794;
  int D.10797;
  int D.10798;
  struct HeapClassDesc * D.10799;
  struct HeapClassDesc * res;
  int i;

  try
    {
      D.10772 = hs->class_count;
      D.10773 = D.10772 * 2;
      D.10774 = hs->hash_size;
      if (D.10773 >= D.10774) goto <D.10775>; else goto <D.10776>;
      <D.10775>:
      {
        struct HeapClassDesc * * n;
        int old_size;

        old_size = hs->hash_size;
        D.10774 = hs->hash_size;
        D.10777 = D.10774 * 2;
        hs->hash_size = D.10777;
        D.10774 = hs->hash_size;
        if (D.10774 == 0) goto <D.10778>; else goto <D.10779>;
        <D.10778>:
        hs->hash_size = 4;
        <D.10779>:
        D.10774 = hs->hash_size;
        D.10780 = (unsigned int) D.10774;
        D.10781 = D.10780 * 4;
        n = calloc (D.10781, 1);
        i = 0;
        goto <D.8021>;
        <D.8020>:
        D.10782 = hs->class_hash;
        i.154 = (unsigned int) i;
        D.10784 = i.154 * 4;
        D.10785 = D.10782 + D.10784;
        res.155 = *D.10785;
        res = res.155;
        D.10782 = hs->class_hash;
        i.154 = (unsigned int) i;
        D.10784 = i.154 * 4;
        D.10785 = D.10782 + D.10784;
        res.155 = *D.10785;
        if (res.155 != 0B) goto <D.10787>; else goto <D.10788>;
        <D.10787>:
        D.10782 = hs->class_hash;
        i.154 = (unsigned int) i;
        D.10784 = i.154 * 4;
        D.10785 = D.10782 + D.10784;
        res.155 = *D.10785;
        D.10789 = res.155->count;
        D.10790 = (long long unsigned int) D.10789;
        D.10782 = hs->class_hash;
        i.154 = (unsigned int) i;
        D.10784 = i.154 * 4;
        D.10785 = D.10782 + D.10784;
        res.155 = *D.10785;
        D.10791 = res.155->total_size;
        D.10792 = (long long unsigned int) D.10791;
        D.10782 = hs->class_hash;
        i.154 = (unsigned int) i;
        D.10784 = i.154 * 4;
        D.10785 = D.10782 + D.10784;
        res.155 = *D.10785;
        D.10793 = res.155->klass;
        D.10774 = hs->hash_size;
        D.10794 = (unsigned int) D.10774;
        add_heap_hashed (n, &res, D.10794, D.10793, D.10792, D.10790);
        <D.10788>:
        i = i + 1;
        <D.8021>:
        if (i < old_size) goto <D.8020>; else goto <D.8022>;
        <D.8022>:
        D.10782 = hs->class_hash;
        if (D.10782 != 0B) goto <D.10795>; else goto <D.10796>;
        <D.10795>:
        D.10782 = hs->class_hash;
        free (D.10782);
        <D.10796>:
        hs->class_hash = n;
      }
      <D.10776>:
      res = 0B;
      D.10774 = hs->hash_size;
      D.10794 = (unsigned int) D.10774;
      D.10782 = hs->class_hash;
      D.10797 = add_heap_hashed (D.10782, &res, D.10794, klass, size, 1);
      D.10772 = hs->class_count;
      D.10798 = D.10772 + D.10797;
      hs->class_count = D.10798;
      D.10799 = res;
      return D.10799;
    }
  finally
    {
      res = {CLOBBER};
    }
}


add_heap_hashed (struct HeapClassDesc * * hash, struct HeapClassDesc * * retv, uintptr_t hsize, struct ClassDesc * klass, uint64_t size, uint64_t count)
{
  int D.10804;
  unsigned int D.10805;
  unsigned int D.10806;
  unsigned int D.10808;
  struct HeapClassDesc * * D.10809;
  struct HeapClassDesc * D.10810;
  struct ClassDesc * D.10812;
  long long int D.10814;
  long long unsigned int D.10815;
  long long unsigned int D.10816;
  long long int D.10817;
  long long int D.10818;
  long long unsigned int D.10819;
  long long unsigned int D.10820;
  long long int D.10821;
  int D.10822;
  struct HeapClassDesc * D.10825;
  void * D.10828;
  uintptr_t i;
  uintptr_t start_pos;

  D.10804 = klass->klass;
  D.10805 = (unsigned int) D.10804;
  D.10806 = D.10805 >> 2;
  start_pos = D.10806 % hsize;
  i = start_pos;
  <D.8009>:
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  if (D.10810 != 0B) goto <D.10811>; else goto <D.10807>;
  <D.10811>:
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10812 = D.10810->klass;
  if (D.10812 == klass) goto <D.10813>; else goto <D.10807>;
  <D.10813>:
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10814 = D.10810->total_size;
  D.10815 = (long long unsigned int) D.10814;
  D.10816 = D.10815 + size;
  D.10817 = (long long int) D.10816;
  D.10810->total_size = D.10817;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10818 = D.10810->count;
  D.10819 = (long long unsigned int) D.10818;
  D.10820 = D.10819 + count;
  D.10821 = (long long int) D.10820;
  D.10810->count = D.10821;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  *retv = D.10810;
  D.10822 = 0;
  return D.10822;
  <D.10807>:
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  if (D.10810 == 0B) goto <D.10823>; else goto <D.10824>;
  <D.10823>:
  D.10825 = *retv;
  if (D.10825 != 0B) goto <D.10826>; else goto <D.10827>;
  <D.10826>:
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10825 = *retv;
  *D.10809 = D.10825;
  D.10822 = 1;
  return D.10822;
  <D.10827>:
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10828 = calloc (40, 1);
  *D.10809 = D.10828;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10810->klass = klass;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10814 = D.10810->total_size;
  D.10815 = (long long unsigned int) D.10814;
  D.10816 = D.10815 + size;
  D.10817 = (long long int) D.10816;
  D.10810->total_size = D.10817;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  D.10818 = D.10810->count;
  D.10819 = (long long unsigned int) D.10818;
  D.10820 = D.10819 + count;
  D.10821 = (long long int) D.10820;
  D.10810->count = D.10821;
  D.10808 = i * 4;
  D.10809 = hash + D.10808;
  D.10810 = *D.10809;
  *retv = D.10810;
  D.10822 = 1;
  return D.10822;
  <D.10824>:
  i = i + 1;
  if (i == hsize) goto <D.10829>; else goto <D.10830>;
  <D.10829>:
  i = 0;
  <D.10830>:
  if (i != start_pos) goto <D.8009>; else goto <D.8010>;
  <D.8010>:
  printf ("failed heap class store\n");
  D.10822 = 0;
  return D.10822;
}


alloc_heap_obj (uintptr_t objaddr, struct HeapClassDesc * hklass, uintptr_t num_refs)
{
  unsigned int D.10832;
  unsigned int D.10833;
  struct HeapObjectDesc * D.10834;
  struct HeapObjectDesc * ho;

  D.10832 = num_refs + 3;
  D.10833 = D.10832 * 4;
  ho = calloc (D.10833, 1);
  ho->objaddr = objaddr;
  ho->hklass = hklass;
  ho->num_refs = num_refs;
  D.10834 = ho;
  return D.10834;
}


add_heap_shot_obj (struct HeapShot * hs, struct HeapObjectDesc * obj)
{
  unsigned int D.10836;
  unsigned int D.10837;
  unsigned int D.10838;
  unsigned int D.10841;
  unsigned int D.10844;
  struct HeapObjectDesc * * D.10845;
  unsigned int D.10846;
  struct HeapObjectDesc * * D.10847;
  struct HeapObjectDesc * D.10848;
  unsigned int D.10853;
  unsigned int D.10854;
  uintptr_t i;

  D.10836 = hs->objects_count;
  D.10837 = D.10836 * 2;
  D.10838 = hs->objects_hash_size;
  if (D.10837 >= D.10838) goto <D.10839>; else goto <D.10840>;
  <D.10839>:
  {
    struct HeapObjectDesc * * n;
    uintptr_t old_size;

    old_size = hs->objects_hash_size;
    D.10838 = hs->objects_hash_size;
    D.10841 = D.10838 * 2;
    hs->objects_hash_size = D.10841;
    D.10838 = hs->objects_hash_size;
    if (D.10838 == 0) goto <D.10842>; else goto <D.10843>;
    <D.10842>:
    hs->objects_hash_size = 4;
    <D.10843>:
    D.10838 = hs->objects_hash_size;
    D.10844 = D.10838 * 4;
    n = calloc (D.10844, 1);
    i = 0;
    goto <D.8064>;
    <D.8063>:
    D.10845 = hs->objects_hash;
    D.10846 = i * 4;
    D.10847 = D.10845 + D.10846;
    D.10848 = *D.10847;
    if (D.10848 != 0B) goto <D.10849>; else goto <D.10850>;
    <D.10849>:
    D.10845 = hs->objects_hash;
    D.10846 = i * 4;
    D.10847 = D.10845 + D.10846;
    D.10848 = *D.10847;
    D.10838 = hs->objects_hash_size;
    add_heap_hashed_obj (n, D.10838, D.10848);
    <D.10850>:
    i = i + 1;
    <D.8064>:
    if (i < old_size) goto <D.8063>; else goto <D.8065>;
    <D.8065>:
    D.10845 = hs->objects_hash;
    if (D.10845 != 0B) goto <D.10851>; else goto <D.10852>;
    <D.10851>:
    D.10845 = hs->objects_hash;
    free (D.10845);
    <D.10852>:
    hs->objects_hash = n;
  }
  <D.10840>:
  D.10838 = hs->objects_hash_size;
  D.10845 = hs->objects_hash;
  D.10853 = add_heap_hashed_obj (D.10845, D.10838, obj);
  D.10836 = hs->objects_count;
  D.10854 = D.10836 + D.10853;
  hs->objects_count = D.10854;
}


add_heap_hashed_obj (struct HeapObjectDesc * * hash, uintptr_t hsize, struct HeapObjectDesc * obj)
{
  unsigned int D.10856;
  unsigned int D.10857;
  unsigned int D.10859;
  struct HeapObjectDesc * * D.10860;
  struct HeapObjectDesc * D.10861;
  unsigned int D.10863;
  uintptr_t D.10865;
  uintptr_t i;
  uintptr_t start_pos;

  D.10856 = obj->objaddr;
  D.10857 = D.10856 >> 3;
  start_pos = D.10857 % hsize;
  i = start_pos;
  <D.8054>:
  D.10859 = i * 4;
  D.10860 = hash + D.10859;
  D.10861 = *D.10860;
  if (D.10861 != 0B) goto <D.10862>; else goto <D.10858>;
  <D.10862>:
  D.10859 = i * 4;
  D.10860 = hash + D.10859;
  D.10861 = *D.10860;
  D.10863 = D.10861->objaddr;
  D.10856 = obj->objaddr;
  if (D.10863 == D.10856) goto <D.10864>; else goto <D.10858>;
  <D.10864>:
  printf ("duplicate object!\n");
  D.10865 = 0;
  return D.10865;
  <D.10858>:
  D.10859 = i * 4;
  D.10860 = hash + D.10859;
  D.10861 = *D.10860;
  if (D.10861 == 0B) goto <D.10866>; else goto <D.10867>;
  <D.10866>:
  D.10859 = i * 4;
  D.10860 = hash + D.10859;
  *D.10860 = obj;
  D.10865 = 1;
  return D.10865;
  <D.10867>:
  i = i + 1;
  if (i == hsize) goto <D.10868>; else goto <D.10869>;
  <D.10868>:
  i = 0;
  <D.10869>:
  if (i != start_pos) goto <D.8054>; else goto <D.8055>;
  <D.8055>:
  printf ("failed heap obj store\n");
  D.10865 = 0;
  return D.10865;
}


heap_shot_obj_add_refs (struct HeapShot * hs, uintptr_t objaddr, uintptr_t num, uintptr_t * ref_offset)
{
  unsigned int D.10873;
  struct HeapObjectDesc * * D.10874;
  struct HeapObjectDesc * D.10875;
  unsigned int D.10876;
  unsigned int D.10877;
  struct HeapClassDesc * D.10878;
  unsigned int D.10879;
  uintptr_t[0:] * D.10880;
  uintptr_t[0:] * D.10881;
  struct HeapObjectDesc * D.10882;
  struct HeapObjectDesc * * hash;
  uintptr_t i;

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

    D.10873 = i * 4;
    D.10874 = hash + D.10873;
    D.10875 = *D.10874;
    D.10876 = D.10875->num_refs;
    D.10877 = D.10876 + num;
    D.10873 = i * 4;
    D.10874 = hash + D.10873;
    D.10875 = *D.10874;
    D.10878 = D.10875->hklass;
    ho = alloc_heap_obj (objaddr, D.10878, D.10877);
    D.10873 = i * 4;
    D.10874 = hash + D.10873;
    D.10875 = *D.10874;
    D.10876 = D.10875->num_refs;
    *ref_offset = D.10876;
    D.10873 = i * 4;
    D.10874 = hash + D.10873;
    D.10875 = *D.10874;
    D.10876 = D.10875->num_refs;
    D.10879 = D.10876 * 4;
    D.10873 = i * 4;
    D.10874 = hash + D.10873;
    D.10875 = *D.10874;
    D.10880 = &D.10875->refs;
    D.10881 = &ho->refs;
    memcpy (D.10881, D.10880, D.10879);
    D.10873 = i * 4;
    D.10874 = hash + D.10873;
    D.10875 = *D.10874;
    free (D.10875);
    D.10873 = i * 4;
    D.10874 = hash + D.10873;
    *D.10874 = ho;
    D.10882 = ho;
    return D.10882;
  }
  <D.10872>:
  printf ("failed heap obj update\n");
  D.10882 = 0B;
  return D.10882;
}


heap_shot_find_obj_slot (struct HeapShot * hs, uintptr_t objaddr)
{
  unsigned int D.10886;
  unsigned int D.10887;
  unsigned int D.10889;
  struct HeapObjectDesc * * D.10890;
  struct HeapObjectDesc * D.10891;
  unsigned int D.10893;
  uintptr_t D.10895;
  uintptr_t i;
  uintptr_t start_pos;
  struct HeapObjectDesc * * hash;

  hash = hs->objects_hash;
  D.10886 = objaddr >> 3;
  D.10887 = hs->objects_hash_size;
  start_pos = D.10886 % D.10887;
  i = start_pos;
  <D.8037>:
  D.10889 = i * 4;
  D.10890 = hash + D.10889;
  D.10891 = *D.10890;
  if (D.10891 != 0B) goto <D.10892>; else goto <D.10888>;
  <D.10892>:
  D.10889 = i * 4;
  D.10890 = hash + D.10889;
  D.10891 = *D.10890;
  D.10893 = D.10891->objaddr;
  if (D.10893 == objaddr) goto <D.10894>; else goto <D.10888>;
  <D.10894>:
  D.10895 = i;
  return D.10895;
  <D.10888>:
  D.10889 = i * 4;
  D.10890 = hash + D.10889;
  D.10891 = *D.10890;
  if (D.10891 == 0B) goto <D.8036>; else goto <D.10896>;
  <D.10896>:
  i = i + 1;
  D.10887 = hs->objects_hash_size;
  if (i == D.10887) goto <D.10897>; else goto <D.10898>;
  <D.10897>:
  i = 0;
  <D.10898>:
  if (i != start_pos) goto <D.8037>; else goto <D.8036>;
  <D.8036>:
  D.10895 = 4294967295;
  return D.10895;
}


track_obj_reference (uintptr_t obj, uintptr_t parent, struct ClassDesc * cd)
{
  uintptr_t * tracked_objects.156;
  unsigned int i.157;
  unsigned int D.10902;
  uintptr_t * D.10903;
  unsigned int D.10904;
  char * D.10907;
  void * parent.158;
  void * obj.159;
  struct FILE * outfile.160;
  int num_tracked_objects.161;
  int i;

  i = 0;
  goto <D.8431>;
  <D.8430>:
  tracked_objects.156 = tracked_objects;
  i.157 = (unsigned int) i;
  D.10902 = i.157 * 4;
  D.10903 = tracked_objects.156 + D.10902;
  D.10904 = *D.10903;
  if (D.10904 == obj) goto <D.10905>; else goto <D.10906>;
  <D.10905>:
  D.10907 = cd->name;
  parent.158 = (void *) parent;
  obj.159 = (void *) obj;
  outfile.160 = outfile;
  fprintf (outfile.160, "Object %p referenced from %p (%s).\n", obj.159, parent.158, D.10907);
  <D.10906>:
  i = i + 1;
  <D.8431>:
  num_tracked_objects.161 = num_tracked_objects;
  if (i < num_tracked_objects.161) goto <D.8430>; else goto <D.8432>;
  <D.8432>:
}


get_root_name (int rtype)
{
  int D.10912;
  const char * D.10913;

  D.10912 = rtype & 255;
  switch (D.10912) <default: <D.8375>, case 0: <D.8370>, case 1: <D.8371>, case 2: <D.8372>, case 3: <D.8373>, case 4: <D.8374>>
  <D.8370>:
  D.10913 = "stack";
  return D.10913;
  <D.8371>:
  D.10913 = "finalizer";
  return D.10913;
  <D.8372>:
  D.10913 = "handle";
  return D.10913;
  <D.8373>:
  D.10913 = "other";
  return D.10913;
  <D.8374>:
  D.10913 = "misc";
  return D.10913;
  <D.8375>:
  D.10913 = "unknown";
  return D.10913;
}


thread_add_root (struct ThreadContext * ctx, uintptr_t obj, int root_type, uintptr_t extra_info)
{
  unsigned int D.10915;
  unsigned int D.10916;
  unsigned int D.10919;
  unsigned int new_size.162;
  unsigned int D.10923;
  uintptr_t * D.10924;
  void * D.10925;
  uintptr_t * D.10926;
  void * D.10927;
  int * D.10928;
  void * D.10929;
  unsigned int new_size.163;
  unsigned int D.10931;
  int * D.10932;
  uintptr_t * D.10933;
  unsigned int D.10934;
  unsigned int D.10935;
  unsigned int D.10936;
  uintptr_t * D.10937;

  D.10915 = ctx->num_roots;
  D.10916 = ctx->size_roots;
  if (D.10915 == D.10916) goto <D.10917>; else goto <D.10918>;
  <D.10917>:
  {
    int new_size;

    D.10916 = ctx->size_roots;
    D.10919 = D.10916 * 2;
    new_size = (int) D.10919;
    if (new_size == 0) goto <D.10920>; else goto <D.10921>;
    <D.10920>:
    new_size = 4;
    <D.10921>:
    new_size.162 = (unsigned int) new_size;
    D.10923 = new_size.162 * 4;
    D.10924 = ctx->roots;
    D.10925 = realloc (D.10924, D.10923);
    ctx->roots = D.10925;
    new_size.162 = (unsigned int) new_size;
    D.10923 = new_size.162 * 4;
    D.10926 = ctx->roots_extra;
    D.10927 = realloc (D.10926, D.10923);
    ctx->roots_extra = D.10927;
    new_size.162 = (unsigned int) new_size;
    D.10923 = new_size.162 * 4;
    D.10928 = ctx->roots_types;
    D.10929 = realloc (D.10928, D.10923);
    ctx->roots_types = D.10929;
    new_size.163 = (unsigned int) new_size;
    ctx->size_roots = new_size.163;
  }
  <D.10918>:
  D.10928 = ctx->roots_types;
  D.10915 = ctx->num_roots;
  D.10931 = D.10915 * 4;
  D.10932 = D.10928 + D.10931;
  *D.10932 = root_type;
  D.10926 = ctx->roots_extra;
  D.10915 = ctx->num_roots;
  D.10931 = D.10915 * 4;
  D.10933 = D.10926 + D.10931;
  *D.10933 = extra_info;
  D.10924 = ctx->roots;
  D.10915 = ctx->num_roots;
  D.10934 = D.10915;
  D.10935 = D.10934 + 1;
  ctx->num_roots = D.10935;
  D.10936 = D.10934 * 4;
  D.10937 = D.10924 + D.10936;
  *D.10937 = obj;
}


heap_shot_resolve_reverse_refs (struct HeapShot * hs)
{
  struct HeapObjectDesc * * D.10938;
  unsigned int D.10939;
  struct HeapObjectDesc * * D.10940;
  unsigned int D.10943;
  unsigned int D.10944;
  struct HeapObjectDesc * * D.10945;
  struct HeapObjectDesc * D.10946;
  struct HeapClassDesc * D.10947;
  struct HeapClassDesc * D.10948;
  unsigned int D.10949;
  unsigned int D.10950;
  uintptr_t i;

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

    D.10938 = hs->objects_hash;
    D.10939 = i * 4;
    D.10940 = D.10938 + D.10939;
    ho = *D.10940;
    if (ho == 0B) goto <D.10941>; else goto <D.10942>;
    <D.10941>:
    // predicted unlikely by continue predictor.
    goto <D.8072>;
    <D.10942>:
    r = 0;
    goto <D.8075>;
    <D.8074>:
    {
      uintptr_t oi;

      D.10943 = ho->refs[r];
      oi = heap_shot_find_obj_slot (hs, D.10943);
      D.10938 = hs->objects_hash;
      D.10944 = oi * 4;
      D.10945 = D.10938 + D.10944;
      D.10946 = *D.10945;
      D.10947 = D.10946->hklass;
      D.10948 = ho->hklass;
      add_heap_class_rev (D.10948, D.10947);
    }
    r = r + 1;
    <D.8075>:
    D.10949 = ho->num_refs;
    if (D.10949 > r) goto <D.8074>; else goto <D.8076>;
    <D.8076>:
  }
  <D.8072>:
  i = i + 1;
  <D.8078>:
  D.10950 = hs->objects_hash_size;
  if (D.10950 > i) goto <D.8077>; else goto <D.8079>;
  <D.8079>:
}


add_heap_class_rev (struct HeapClassDesc * from, struct HeapClassDesc * to)
{
  int D.10952;
  int D.10953;
  int D.10954;
  int D.10957;
  unsigned int D.10960;
  unsigned int D.10961;
  struct HeapClassRevRef * D.10962;
  unsigned int D.10963;
  struct HeapClassRevRef * D.10964;
  struct HeapClassDesc * D.10965;
  long long unsigned int D.10968;
  unsigned int D.10969;
  int D.10972;
  int D.10973;
  uintptr_t i;

  D.10952 = to->rev_count;
  D.10953 = D.10952 * 2;
  D.10954 = to->rev_hash_size;
  if (D.10953 >= D.10954) goto <D.10955>; else goto <D.10956>;
  <D.10955>:
  {
    struct HeapClassRevRef * n;
    uintptr_t old_size;

    D.10954 = to->rev_hash_size;
    old_size = (uintptr_t) D.10954;
    D.10954 = to->rev_hash_size;
    D.10957 = D.10954 * 2;
    to->rev_hash_size = D.10957;
    D.10954 = to->rev_hash_size;
    if (D.10954 == 0) goto <D.10958>; else goto <D.10959>;
    <D.10958>:
    to->rev_hash_size = 4;
    <D.10959>:
    D.10954 = to->rev_hash_size;
    D.10960 = (unsigned int) D.10954;
    D.10961 = D.10960 * 12;
    n = calloc (D.10961, 1);
    i = 0;
    goto <D.7961>;
    <D.7960>:
    D.10962 = to->rev_hash;
    D.10963 = i * 12;
    D.10964 = D.10962 + D.10963;
    D.10965 = D.10964->klass;
    if (D.10965 != 0B) goto <D.10966>; else goto <D.10967>;
    <D.10966>:
    D.10962 = to->rev_hash;
    D.10963 = i * 12;
    D.10964 = D.10962 + D.10963;
    D.10968 = D.10964->count;
    D.10962 = to->rev_hash;
    D.10963 = i * 12;
    D.10964 = D.10962 + D.10963;
    D.10965 = D.10964->klass;
    D.10954 = to->rev_hash_size;
    D.10969 = (unsigned int) D.10954;
    add_rev_class_hashed (n, D.10969, D.10965, D.10968);
    <D.10967>:
    i = i + 1;
    <D.7961>:
    if (i < old_size) goto <D.7960>; else goto <D.7962>;
    <D.7962>:
    D.10962 = to->rev_hash;
    if (D.10962 != 0B) goto <D.10970>; else goto <D.10971>;
    <D.10970>:
    D.10962 = to->rev_hash;
    free (D.10962);
    <D.10971>:
    to->rev_hash = n;
  }
  <D.10956>:
  D.10954 = to->rev_hash_size;
  D.10969 = (unsigned int) D.10954;
  D.10962 = to->rev_hash;
  D.10972 = add_rev_class_hashed (D.10962, D.10969, from, 1);
  D.10952 = to->rev_count;
  D.10973 = D.10952 + D.10972;
  to->rev_count = D.10973;
}


add_rev_class_hashed (struct HeapClassRevRef * rev_hash, uintptr_t size, struct HeapClassDesc * hklass, uint64_t value)
{
  struct ClassDesc * D.10975;
  int D.10976;
  int D.10977;
  unsigned int D.10978;
  unsigned int D.10981;
  struct HeapClassRevRef * D.10982;
  struct HeapClassDesc * D.10983;
  long long unsigned int D.10986;
  long long unsigned int D.10987;
  int D.10988;
  struct ClassDesc * D.10993;
  uintptr_t i;
  uintptr_t start_pos;
  static const char __PRETTY_FUNCTION__[21] = "add_rev_class_hashed";

  D.10975 = hklass->klass;
  D.10976 = D.10975->klass;
  D.10977 = D.10976 >> 2;
  D.10978 = (unsigned int) D.10977;
  start_pos = D.10978 % size;
  if (start_pos >= size) goto <D.10979>; else goto <D.10980>;
  <D.10979>:
  __assert_fail ("start_pos < size", "decode.c", 573, &__PRETTY_FUNCTION__);
  <D.10980>:
  i = start_pos;
  <D.7951>:
  D.10981 = i * 12;
  D.10982 = rev_hash + D.10981;
  D.10983 = D.10982->klass;
  if (D.10983 == hklass) goto <D.10984>; else goto <D.10985>;
  <D.10984>:
  D.10981 = i * 12;
  D.10982 = rev_hash + D.10981;
  D.10981 = i * 12;
  D.10982 = rev_hash + D.10981;
  D.10986 = D.10982->count;
  D.10987 = D.10986 + value;
  D.10982->count = D.10987;
  D.10988 = 0;
  return D.10988;
  <D.10985>:
  D.10981 = i * 12;
  D.10982 = rev_hash + D.10981;
  D.10983 = D.10982->klass;
  if (D.10983 == 0B) goto <D.10989>; else goto <D.10990>;
  <D.10989>:
  D.10981 = i * 12;
  D.10982 = rev_hash + D.10981;
  D.10982->klass = hklass;
  D.10981 = i * 12;
  D.10982 = rev_hash + D.10981;
  D.10981 = i * 12;
  D.10982 = rev_hash + D.10981;
  D.10986 = D.10982->count;
  D.10987 = D.10986 + value;
  D.10982->count = D.10987;
  start_pos = 0;
  i = 0;
  goto <D.7949>;
  <D.7948>:
  D.10981 = i * 12;
  D.10982 = rev_hash + D.10981;
  D.10983 = D.10982->klass;
  if (D.10983 != 0B) goto <D.10991>; else goto <D.10992>;
  <D.10991>:
  D.10981 = i * 12;
  D.10982 = rev_hash + D.10981;
  D.10983 = D.10982->klass;
  D.10993 = D.10983->klass;
  D.10975 = hklass->klass;
  if (D.10993 == D.10975) goto <D.10994>; else goto <D.10995>;
  <D.10994>:
  start_pos = start_pos + 1;
  <D.10995>:
  <D.10992>:
  i = i + 1;
  <D.7949>:
  if (i < size) goto <D.7948>; else goto <D.7950>;
  <D.7950>:
  if (start_pos != 1) goto <D.10996>; else goto <D.10997>;
  <D.10996>:
  __assert_fail ("start_pos == 1", "decode.c", 586, &__PRETTY_FUNCTION__);
  <D.10997>:
  D.10988 = 1;
  return D.10988;
  <D.10990>:
  i = i + 1;
  if (i == size) goto <D.10998>; else goto <D.10999>;
  <D.10998>:
  i = 0;
  <D.10999>:
  if (i != start_pos) goto <D.7951>; else goto <D.7952>;
  <D.7952>:
  printf ("failed revref store\n");
  D.10988 = 0;
  return D.10988;
}


heap_shot_mark_objects (struct HeapShot * hs)
{
  uintptr_t * D.11001;
  unsigned int D.11002;
  uintptr_t * D.11003;
  unsigned int D.11004;
  struct HeapObjectDesc * * D.11007;
  unsigned int D.11008;
  struct HeapObjectDesc * * D.11009;
  int * D.11010;
  int * D.11011;
  int D.11012;
  int D.11013;
  unsigned int D.11016;
  unsigned int D.11017;
  unsigned int D.11018;
  unsigned int D.11019;
  unsigned int D.11020;
  int debug.164;
  unsigned int D.11024;
  uintptr_t * D.11029;
  uintptr_t * D.11030;
  unsigned int D.11031;
  int D.11032;
  struct ClassDesc * D.11033;
  char * D.11034;
  void * D.11035;
  struct FILE * outfile.165;
  unsigned char * D.11037;
  unsigned char D.11038;
  unsigned char iftmp.166;
  unsigned int D.11042;
  unsigned char * D.11046;
  unsigned char D.11047;
  struct HeapObjectDesc * * D.11050;
  unsigned int D.11051;
  void * D.11054;
  unsigned char iftmp.167;
  unsigned int D.11058;
  struct HeapObjectDesc * D.11062;
  struct HeapClassDesc * D.11067;
  struct ClassDesc * D.11068;
  char * D.11069;
  unsigned int D.11070;
  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.8095>;
  <D.8094>:
  {
    struct HeapClassDesc * cd;

    D.11001 = hs->roots;
    D.11002 = i * 4;
    D.11003 = D.11001 + D.11002;
    D.11004 = *D.11003;
    oi = heap_shot_find_obj_slot (hs, D.11004);
    if (oi == 4294967295) goto <D.11005>; else goto <D.11006>;
    <D.11005>:
    // predicted unlikely by continue predictor.
    goto <D.8093>;
    <D.11006>:
    D.11007 = hs->objects_hash;
    D.11008 = oi * 4;
    D.11009 = D.11007 + D.11008;
    obj = *D.11009;
    cd = obj->hklass;
    D.11010 = hs->roots_types;
    D.11002 = i * 4;
    D.11011 = D.11010 + D.11002;
    D.11012 = *D.11011;
    D.11013 = D.11012 & 256;
    if (D.11013 != 0) goto <D.11014>; else goto <D.11015>;
    <D.11014>:
    D.11016 = cd->pinned_references;
    D.11017 = D.11016 + 1;
    cd->pinned_references = D.11017;
    <D.11015>:
    D.11018 = cd->root_references;
    D.11019 = D.11018 + 1;
    cd->root_references = D.11019;
  }
  <D.8093>:
  i = i + 1;
  <D.8095>:
  D.11020 = hs->num_roots;
  if (D.11020 > i) goto <D.8094>; else goto <D.8096>;
  <D.8096>:
  debug.164 = debug;
  if (debug.164 == 0) goto <D.11022>; else goto <D.11023>;
  <D.11022>:
  return;
  <D.11023>:
  D.11024 = hs->objects_hash_size;
  marks = calloc (D.11024, 1);
  if (marks == 0B) goto <D.11025>; else goto <D.11026>;
  <D.11025>:
  return;
  <D.11026>:
  i = 0;
  goto <D.8099>;
  <D.8098>:
  D.11001 = hs->roots;
  D.11002 = i * 4;
  D.11003 = D.11001 + D.11002;
  D.11004 = *D.11003;
  oi = heap_shot_find_obj_slot (hs, D.11004);
  if (oi == 4294967295) goto <D.11027>; else goto <D.11028>;
  <D.11027>:
  D.11029 = hs->roots_extra;
  D.11002 = i * 4;
  D.11030 = D.11029 + D.11002;
  D.11031 = *D.11030;
  D.11032 = (int) D.11031;
  D.11033 = lookup_class (D.11032);
  D.11034 = D.11033->name;
  D.11001 = hs->roots;
  D.11002 = i * 4;
  D.11003 = D.11001 + D.11002;
  D.11004 = *D.11003;
  D.11035 = (void *) D.11004;
  D.11010 = hs->roots_types;
  D.11002 = i * 4;
  D.11011 = D.11010 + D.11002;
  D.11012 = *D.11011;
  outfile.165 = outfile;
  fprintf (outfile.165, "root type 0x%x for obj %p (%s) not found in heap\n", D.11012, D.11035, D.11034);
  // predicted unlikely by continue predictor.
  goto <D.8097>;
  <D.11028>:
  D.11007 = hs->objects_hash;
  D.11008 = oi * 4;
  D.11009 = D.11007 + D.11008;
  obj = *D.11009;
  D.11037 = marks + oi;
  D.11038 = *D.11037;
  if (D.11038 == 0) goto <D.11039>; else goto <D.11040>;
  <D.11039>:
  D.11037 = marks + oi;
  D.11042 = obj->num_refs;
  if (D.11042 != 0) goto <D.11043>; else goto <D.11044>;
  <D.11043>:
  iftmp.166 = 1;
  goto <D.11045>;
  <D.11044>:
  iftmp.166 = 2;
  <D.11045>:
  *D.11037 = iftmp.166;
  num_marked = num_marked + 1;
  <D.11040>:
  <D.8097>:
  i = i + 1;
  <D.8099>:
  D.11020 = hs->num_roots;
  if (D.11020 > i) goto <D.8098>; else goto <D.8100>;
  <D.8100>:
  marked_some = 1;
  goto <D.8110>;
  <D.8109>:
  marked_some = 0;
  i = 0;
  goto <D.8107>;
  <D.8106>:
  D.11046 = marks + i;
  D.11047 = *D.11046;
  if (D.11047 != 1) goto <D.11048>; else goto <D.11049>;
  <D.11048>:
  // predicted unlikely by continue predictor.
  goto <D.8101>;
  <D.11049>:
  D.11046 = marks + i;
  *D.11046 = 2;
  D.11007 = hs->objects_hash;
  D.11002 = i * 4;
  D.11050 = D.11007 + D.11002;
  obj = *D.11050;
  r = 0;
  goto <D.8104>;
  <D.8103>:
  D.11051 = obj->refs[r];
  oi = heap_shot_find_obj_slot (hs, D.11051);
  if (oi == 4294967295) goto <D.11052>; else goto <D.11053>;
  <D.11052>:
  D.11051 = obj->refs[r];
  D.11054 = (void *) D.11051;
  outfile.165 = outfile;
  fprintf (outfile.165, "referenced obj %p not found in heap\n", D.11054);
  // predicted unlikely by continue predictor.
  goto <D.8102>;
  <D.11053>:
  D.11007 = hs->objects_hash;
  D.11008 = oi * 4;
  D.11009 = D.11007 + D.11008;
  ref = *D.11009;
  D.11037 = marks + oi;
  D.11038 = *D.11037;
  if (D.11038 == 0) goto <D.11055>; else goto <D.11056>;
  <D.11055>:
  D.11037 = marks + oi;
  D.11058 = ref->num_refs;
  if (D.11058 != 0) goto <D.11059>; else goto <D.11060>;
  <D.11059>:
  iftmp.167 = 1;
  goto <D.11061>;
  <D.11060>:
  iftmp.167 = 2;
  <D.11061>:
  *D.11037 = iftmp.167;
  <D.11056>:
  <D.8102>:
  r = r + 1;
  <D.8104>:
  D.11042 = obj->num_refs;
  if (D.11042 > r) goto <D.8103>; else goto <D.8105>;
  <D.8105>:
  marked_some = marked_some + 1;
  <D.8101>:
  i = i + 1;
  <D.8107>:
  D.11024 = hs->objects_hash_size;
  if (D.11024 > i) goto <D.8106>; else goto <D.8108>;
  <D.8108>:
  <D.8110>:
  if (marked_some != 0) goto <D.8109>; else goto <D.8111>;
  <D.8111>:
  num_unmarked = 0;
  i = 0;
  goto <D.8113>;
  <D.8112>:
  D.11007 = hs->objects_hash;
  D.11002 = i * 4;
  D.11050 = D.11007 + D.11002;
  D.11062 = *D.11050;
  if (D.11062 != 0B) goto <D.11063>; else goto <D.11064>;
  <D.11063>:
  D.11046 = marks + i;
  D.11047 = *D.11046;
  if (D.11047 == 0) goto <D.11065>; else goto <D.11066>;
  <D.11065>:
  num_unmarked = num_unmarked + 1;
  D.11007 = hs->objects_hash;
  D.11002 = i * 4;
  D.11050 = D.11007 + D.11002;
  D.11062 = *D.11050;
  D.11067 = D.11062->hklass;
  D.11068 = D.11067->klass;
  D.11069 = D.11068->name;
  D.11007 = hs->objects_hash;
  D.11002 = i * 4;
  D.11050 = D.11007 + D.11002;
  D.11062 = *D.11050;
  outfile.165 = outfile;
  fprintf (outfile.165, "object %p (%s) unmarked\n", D.11062, D.11069);
  <D.11066>:
  <D.11064>:
  i = i + 1;
  <D.8113>:
  D.11024 = hs->objects_hash_size;
  if (D.11024 > i) goto <D.8112>; else goto <D.8114>;
  <D.8114>:
  D.11070 = hs->objects_count;
  outfile.165 = outfile;
  fprintf (outfile.165, "Total unmarked: %d/%d\n", num_unmarked, D.11070);
  free (marks);
}


heap_shot_free_objects (struct HeapShot * hs)
{
  struct HeapObjectDesc * * D.11076;
  unsigned int D.11077;
  struct HeapObjectDesc * * D.11078;
  unsigned int D.11081;
  uintptr_t i;

  i = 0;
  goto <D.8121>;
  <D.8120>:
  {
    struct HeapObjectDesc * ho;

    D.11076 = hs->objects_hash;
    D.11077 = i * 4;
    D.11078 = D.11076 + D.11077;
    ho = *D.11078;
    if (ho != 0B) goto <D.11079>; else goto <D.11080>;
    <D.11079>:
    free (ho);
    <D.11080>:
  }
  i = i + 1;
  <D.8121>:
  D.11081 = hs->objects_hash_size;
  if (D.11081 > i) goto <D.8120>; else goto <D.8122>;
  <D.8122>:
  D.11076 = hs->objects_hash;
  if (D.11076 != 0B) goto <D.11082>; else goto <D.11083>;
  <D.11082>:
  D.11076 = hs->objects_hash;
  free (D.11076);
  <D.11083>:
  hs->objects_hash = 0B;
  hs->objects_hash_size = 0;
  hs->objects_count = 0;
}


new_heap_shot (uint64_t timestamp)
{
  int D.11084;
  unsigned int D.11085;
  void * D.11086;
  int num_heap_shots.168;
  int num_heap_shots.169;
  struct HeapShot * heap_shots.170;
  struct HeapShot * D.11090;
  struct HeapShot * hs;

  hs = calloc (56, 1);
  hs->hash_size = 4;
  D.11084 = hs->hash_size;
  D.11085 = (unsigned int) D.11084;
  D.11086 = calloc (4, D.11085);
  hs->class_hash = D.11086;
  hs->timestamp = timestamp;
  num_heap_shots.168 = num_heap_shots;
  num_heap_shots.169 = num_heap_shots.168 + 1;
  num_heap_shots = num_heap_shots.169;
  heap_shots.170 = heap_shots;
  hs->next = heap_shots.170;
  heap_shots = hs;
  D.11090 = hs;
  return D.11090;
}


lookup_monitor (uintptr_t objid)
{
  unsigned int D.11092;
  unsigned int D.11093;
  unsigned int D.11094;
  unsigned int D.11096;
  struct MonitorDesc * D.11099;
  int num_monitors.171;
  int num_monitors.172;
  struct MonitorDesc * D.11102;
  int slot;
  struct MonitorDesc * cd;

  D.11092 = objid >> 3;
  D.11093 = D.11092 & 65535;
  D.11094 = D.11093 % 31;
  slot = (int) D.11094;
  cd = monitor_hash[slot];
  goto <D.8350>;
  <D.8349>:
  cd = cd->next;
  <D.8350>:
  if (cd != 0B) goto <D.11095>; else goto <D.8351>;
  <D.11095>:
  D.11096 = cd->objid;
  if (D.11096 != objid) goto <D.8349>; else goto <D.8351>;
  <D.8351>:
  if (cd == 0B) goto <D.11097>; else goto <D.11098>;
  <D.11097>:
  cd = calloc (40, 1);
  cd->objid = objid;
  D.11099 = monitor_hash[slot];
  cd->next = D.11099;
  monitor_hash[slot] = cd;
  num_monitors.171 = num_monitors;
  num_monitors.172 = num_monitors.171 + 1;
  num_monitors = num_monitors.172;
  <D.11098>:
  D.11102 = cd;
  return D.11102;
}


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

  switch (ev) <default: <D.8358>, case 1: <D.8355>, case 2: <D.8356>, case 3: <D.8357>>
  <D.8355>:
  D.11104 = "contended";
  return D.11104;
  <D.8356>:
  D.11104 = "acquired";
  return D.11104;
  <D.8357>:
  D.11104 = "not taken";
  return D.11104;
  <D.8358>:
  D.11104 = "invalid";
  return D.11104;
}


lookup_method (intptr_t method)
{
  int D.11106;
  int D.11107;
  int D.11109;
  void * method.173;
  struct MethodDesc * D.11113;
  int slot;
  struct MethodDesc * cd;

  D.11106 = method >> 2;
  D.11107 = D.11106 & 65535;
  slot = D.11107 % 9371;
  cd = method_hash[slot];
  goto <D.7788>;
  <D.7787>:
  cd = cd->next;
  <D.7788>:
  if (cd != 0B) goto <D.11108>; else goto <D.7789>;
  <D.11108>:
  D.11109 = cd->method;
  if (D.11109 != method) goto <D.7787>; else goto <D.7789>;
  <D.7789>:
  if (cd == 0B) goto <D.11110>; else goto <D.11111>;
  <D.11110>:
  {
    char buf[128];

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


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

  switch (type) <default: <D.8332>, case 0: <D.8328>, case 1: <D.8329>, case 2: <D.8330>, case 4: <D.8331>>
  <D.8328>:
  D.11118 = "catch";
  return D.11118;
  <D.8329>:
  D.11118 = "filter";
  return D.11118;
  <D.8330>:
  D.11118 = "finally";
  return D.11118;
  <D.8331>:
  D.11118 = "fault";
  return D.11118;
  <D.8332>:
  D.11118 = "invalid";
  return D.11118;
}


decode_bt (struct MethodDesc * * sframes, int * size, unsigned char * p, unsigned char * * endp, intptr_t ptr_base)
{
  unsigned char * p.174;
  long long unsigned int D.11121;
  long long unsigned int D.11122;
  struct MethodDesc * * D.11125;
  int D.11126;
  unsigned int count.175;
  unsigned int D.11130;
  unsigned int i.176;
  unsigned int D.11133;
  struct MethodDesc * * D.11134;
  int D.11135;
  struct MethodDesc * D.11136;
  struct MethodDesc * * frames;
  int i;
  int flags;
  int count;

  p.174 = p;
  D.11121 = decode_uleb128 (p.174, &p);
  flags = (int) D.11121;
  p.174 = p;
  D.11122 = decode_uleb128 (p.174, &p);
  count = (int) D.11122;
  if (flags != 0) goto <D.11123>; else goto <D.11124>;
  <D.11123>:
  D.11125 = 0B;
  return D.11125;
  <D.11124>:
  D.11126 = *size;
  if (D.11126 < count) goto <D.11127>; else goto <D.11128>;
  <D.11127>:
  count.175 = (unsigned int) count;
  D.11130 = count.175 * 4;
  frames = malloc (D.11130);
  goto <D.11131>;
  <D.11128>:
  frames = sframes;
  <D.11131>:
  i = 0;
  goto <D.8389>;
  <D.8388>:
  {
    intptr_t ptrdiff;

    p.174 = p;
    ptrdiff = decode_sleb128 (p.174, &p);
    i.176 = (unsigned int) i;
    D.11133 = i.176 * 4;
    D.11134 = frames + D.11133;
    D.11135 = ptr_base + ptrdiff;
    D.11136 = lookup_method (D.11135);
    *D.11134 = D.11136;
  }
  i = i + 1;
  <D.8389>:
  if (i < count) goto <D.8388>; else goto <D.8390>;
  <D.8390>:
  *size = count;
  p.174 = p;
  *endp = p.174;
  D.11125 = frames;
  return D.11125;
}


add_trace_methods (struct MethodDesc * * methods, int count, struct TraceDesc * trace, uint64_t value)
{
  int collect_traces.177;
  struct BackTrace * D.11145;
  int trace_max.178;
  struct BackTrace * bt;

  collect_traces.177 = collect_traces;
  if (collect_traces.177 == 0) goto <D.11143>; else goto <D.11144>;
  <D.11143>:
  D.11145 = 0B;
  return D.11145;
  <D.11144>:
  trace_max.178 = trace_max;
  if (count > trace_max.178) goto <D.11147>; else goto <D.11148>;
  <D.11147>:
  count = trace_max;
  <D.11148>:
  bt = add_backtrace (count, methods);
  add_trace_bt (bt, trace, value);
  D.11145 = bt;
  return D.11145;
}


add_backtrace (int count, struct MethodDesc * * methods)
{
  int D.11151;
  unsigned int D.11152;
  unsigned int hash.179;
  int D.11156;
  struct BackTrace * D.11159;
  unsigned int count.180;
  unsigned int D.11161;
  unsigned int D.11162;
  struct BackTrace * D.11163;
  int next_backtrace.181;
  int num_backtraces.182;
  int num_backtraces.183;
  unsigned int num_backtraces.184;
  unsigned int D.11172;
  struct BackTrace * * backtraces.185;
  void * backtraces.186;
  int next_backtrace.187;
  int next_backtrace.188;
  int D.11177;
  unsigned int D.11178;
  unsigned int D.11179;
  struct BackTrace * * D.11180;
  unsigned int slot.189;
  unsigned int D.11182;
  struct MethodDesc * * D.11183;
  struct MethodDesc * D.11184;
  int hash;
  int slot;
  struct BackTrace * bt;

  hash = hash_backtrace (count, methods);
  D.11151 = hash & 65535;
  slot = D.11151 % 9371;
  bt = backtrace_hash[slot];
  goto <D.8158>;
  <D.8157>:
  D.11152 = bt->hash;
  hash.179 = (unsigned int) hash;
  if (D.11152 == hash.179) goto <D.11154>; else goto <D.11155>;
  <D.11154>:
  D.11156 = compare_backtrace (bt, count, methods);
  if (D.11156 != 0) goto <D.11157>; else goto <D.11158>;
  <D.11157>:
  D.11159 = bt;
  return D.11159;
  <D.11158>:
  <D.11155>:
  bt = bt->next;
  <D.8158>:
  if (bt != 0B) goto <D.8157>; else goto <D.8159>;
  <D.8159>:
  count.180 = (unsigned int) count;
  D.11161 = count.180 + 4;
  D.11162 = D.11161 * 4;
  bt = malloc (D.11162);
  D.11163 = backtrace_hash[slot];
  bt->next = D.11163;
  backtrace_hash[slot] = bt;
  next_backtrace.181 = next_backtrace;
  num_backtraces.182 = num_backtraces;
  if (next_backtrace.181 == num_backtraces.182) goto <D.11166>; else goto <D.11167>;
  <D.11166>:
  num_backtraces.182 = num_backtraces;
  num_backtraces.183 = num_backtraces.182 * 2;
  num_backtraces = num_backtraces.183;
  num_backtraces.182 = num_backtraces;
  if (num_backtraces.182 == 0) goto <D.11169>; else goto <D.11170>;
  <D.11169>:
  num_backtraces = 16;
  <D.11170>:
  num_backtraces.182 = num_backtraces;
  num_backtraces.184 = (unsigned int) num_backtraces.182;
  D.11172 = num_backtraces.184 * 4;
  backtraces.185 = backtraces;
  backtraces.186 = realloc (backtraces.185, D.11172);
  backtraces = backtraces.186;
  <D.11167>:
  next_backtrace.181 = next_backtrace;
  next_backtrace.187 = next_backtrace.181;
  next_backtrace.188 = next_backtrace.187 + 1;
  next_backtrace = next_backtrace.188;
  bt->id = next_backtrace.187;
  backtraces.185 = backtraces;
  D.11177 = bt->id;
  D.11178 = (unsigned int) D.11177;
  D.11179 = D.11178 * 4;
  D.11180 = backtraces.185 + D.11179;
  *D.11180 = bt;
  bt->count = count;
  hash.179 = (unsigned int) hash;
  bt->hash = hash.179;
  slot = 0;
  goto <D.8161>;
  <D.8160>:
  slot.189 = (unsigned int) slot;
  D.11182 = slot.189 * 4;
  D.11183 = methods + D.11182;
  D.11184 = *D.11183;
  bt->methods[slot] = D.11184;
  slot = slot + 1;
  <D.8161>:
  if (slot < count) goto <D.8160>; else goto <D.8162>;
  <D.8162>:
  D.11159 = bt;
  return D.11159;
}


hash_backtrace (int count, struct MethodDesc * * methods)
{
  int D.11188;
  int D.11189;
  unsigned int i.190;
  unsigned int D.11191;
  struct MethodDesc * * D.11192;
  struct MethodDesc * D.11193;
  int D.11194;
  int D.11195;
  int hash;
  int i;

  hash = count;
  i = 0;
  goto <D.8139>;
  <D.8138>:
  D.11188 = hash << 5;
  D.11189 = D.11188 - hash;
  i.190 = (unsigned int) i;
  D.11191 = i.190 * 4;
  D.11192 = methods + D.11191;
  D.11193 = *D.11192;
  D.11194 = D.11193->method;
  hash = D.11189 + D.11194;
  i = i + 1;
  <D.8139>:
  if (i < count) goto <D.8138>; else goto <D.8140>;
  <D.8140>:
  D.11195 = hash;
  return D.11195;
}


compare_backtrace (struct BackTrace * bt, int count, struct MethodDesc * * methods)
{
  int D.11197;
  int D.11200;
  unsigned int i.191;
  unsigned int D.11202;
  struct MethodDesc * * D.11203;
  struct MethodDesc * D.11204;
  struct MethodDesc * D.11205;
  int i;

  D.11197 = bt->count;
  if (D.11197 != count) goto <D.11198>; else goto <D.11199>;
  <D.11198>:
  D.11200 = 0;
  return D.11200;
  <D.11199>:
  i = 0;
  goto <D.8148>;
  <D.8147>:
  i.191 = (unsigned int) i;
  D.11202 = i.191 * 4;
  D.11203 = methods + D.11202;
  D.11204 = *D.11203;
  D.11205 = bt->methods[i];
  if (D.11204 != D.11205) goto <D.11206>; else goto <D.11207>;
  <D.11206>:
  D.11200 = 0;
  return D.11200;
  <D.11207>:
  i = i + 1;
  <D.8148>:
  if (i < count) goto <D.8147>; else goto <D.8149>;
  <D.8149>:
  D.11200 = 1;
  return D.11200;
}


add_trace_bt (struct BackTrace * bt, struct TraceDesc * trace, uint64_t value)
{
  int collect_traces.192;
  int D.11212;
  int D.11213;
  int D.11214;
  int D.11217;
  unsigned int D.11220;
  unsigned int D.11221;
  struct CallContext * D.11222;
  unsigned int i.193;
  unsigned int D.11224;
  struct CallContext * D.11225;
  struct BackTrace * D.11226;
  long long unsigned int D.11229;
  int D.11232;
  int D.11233;
  int i;

  collect_traces.192 = collect_traces;
  if (collect_traces.192 == 0) goto <D.11210>; else goto <D.11211>;
  <D.11210>:
  return;
  <D.11211>:
  D.11212 = trace->count;
  D.11213 = D.11212 * 2;
  D.11214 = trace->size;
  if (D.11213 >= D.11214) goto <D.11215>; else goto <D.11216>;
  <D.11215>:
  {
    struct CallContext * n;
    int old_size;

    old_size = trace->size;
    D.11214 = trace->size;
    D.11217 = D.11214 * 2;
    trace->size = D.11217;
    D.11214 = trace->size;
    if (D.11214 == 0) goto <D.11218>; else goto <D.11219>;
    <D.11218>:
    trace->size = 4;
    <D.11219>:
    D.11214 = trace->size;
    D.11220 = (unsigned int) D.11214;
    D.11221 = D.11220 * 12;
    n = calloc (D.11221, 1);
    i = 0;
    goto <D.8243>;
    <D.8242>:
    D.11222 = trace->traces;
    i.193 = (unsigned int) i;
    D.11224 = i.193 * 12;
    D.11225 = D.11222 + D.11224;
    D.11226 = D.11225->bt;
    if (D.11226 != 0B) goto <D.11227>; else goto <D.11228>;
    <D.11227>:
    D.11222 = trace->traces;
    i.193 = (unsigned int) i;
    D.11224 = i.193 * 12;
    D.11225 = D.11222 + D.11224;
    D.11229 = D.11225->count;
    D.11222 = trace->traces;
    i.193 = (unsigned int) i;
    D.11224 = i.193 * 12;
    D.11225 = D.11222 + D.11224;
    D.11226 = D.11225->bt;
    D.11214 = trace->size;
    add_trace_hashed (n, D.11214, D.11226, D.11229);
    <D.11228>:
    i = i + 1;
    <D.8243>:
    if (i < old_size) goto <D.8242>; else goto <D.8244>;
    <D.8244>:
    D.11222 = trace->traces;
    if (D.11222 != 0B) goto <D.11230>; else goto <D.11231>;
    <D.11230>:
    D.11222 = trace->traces;
    free (D.11222);
    <D.11231>:
    trace->traces = n;
  }
  <D.11216>:
  D.11214 = trace->size;
  D.11222 = trace->traces;
  D.11232 = add_trace_hashed (D.11222, D.11214, bt, value);
  D.11212 = trace->count;
  D.11233 = D.11212 + D.11232;
  trace->count = D.11233;
}


add_trace_hashed (struct CallContext * traces, int size, struct BackTrace * bt, uint64_t value)
{
  unsigned int D.11236;
  unsigned int size.194;
  unsigned int i.195;
  unsigned int D.11239;
  struct CallContext * D.11240;
  struct BackTrace * D.11241;
  long long unsigned int D.11244;
  long long unsigned int D.11245;
  int D.11246;
  int i;
  unsigned int start_pos;

  D.11236 = bt->hash;
  size.194 = (unsigned int) size;
  start_pos = D.11236 % size.194;
  i = (int) start_pos;
  <D.8232>:
  i.195 = (unsigned int) i;
  D.11239 = i.195 * 12;
  D.11240 = traces + D.11239;
  D.11241 = D.11240->bt;
  if (D.11241 == bt) goto <D.11242>; else goto <D.11243>;
  <D.11242>:
  i.195 = (unsigned int) i;
  D.11239 = i.195 * 12;
  D.11240 = traces + D.11239;
  i.195 = (unsigned int) i;
  D.11239 = i.195 * 12;
  D.11240 = traces + D.11239;
  D.11244 = D.11240->count;
  D.11245 = D.11244 + value;
  D.11240->count = D.11245;
  D.11246 = 0;
  return D.11246;
  <D.11243>:
  i.195 = (unsigned int) i;
  D.11239 = i.195 * 12;
  D.11240 = traces + D.11239;
  D.11241 = D.11240->bt;
  if (D.11241 == 0B) goto <D.11247>; else goto <D.11248>;
  <D.11247>:
  i.195 = (unsigned int) i;
  D.11239 = i.195 * 12;
  D.11240 = traces + D.11239;
  D.11240->bt = bt;
  i.195 = (unsigned int) i;
  D.11239 = i.195 * 12;
  D.11240 = traces + D.11239;
  i.195 = (unsigned int) i;
  D.11239 = i.195 * 12;
  D.11240 = traces + D.11239;
  D.11244 = D.11240->count;
  D.11245 = D.11244 + value;
  D.11240->count = D.11245;
  D.11246 = 1;
  return D.11246;
  <D.11248>:
  i = i + 1;
  if (i == size) goto <D.11249>; else goto <D.11250>;
  <D.11249>:
  i = 0;
  <D.11250>:
  i.195 = (unsigned int) i;
  if (i.195 != start_pos) goto <D.8232>; else goto <D.8233>;
  <D.8233>:
  printf ("failed trace store\n");
  D.11246 = 0;
  return D.11246;
}


add_trace_thread (struct ThreadContext * thread, struct TraceDesc * trace, uint64_t value)
{
  int collect_traces.196;
  struct BackTrace * D.11255;
  int trace_max.197;
  struct MethodDesc * * D.11259;
  int D.11260;
  sizetype D.11261;
  sizetype count.198;
  sizetype D.11263;
  sizetype D.11264;
  struct MethodDesc * * D.11265;
  struct BackTrace * bt;
  int count;

  count = thread->stack_id;
  collect_traces.196 = collect_traces;
  if (collect_traces.196 == 0) goto <D.11253>; else goto <D.11254>;
  <D.11253>:
  D.11255 = 0B;
  return D.11255;
  <D.11254>:
  trace_max.197 = trace_max;
  if (count > trace_max.197) goto <D.11257>; else goto <D.11258>;
  <D.11257>:
  count = trace_max;
  <D.11258>:
  D.11259 = thread->stack;
  D.11260 = thread->stack_id;
  D.11261 = (sizetype) D.11260;
  count.198 = (sizetype) count;
  D.11263 = D.11261 - count.198;
  D.11264 = D.11263 * 4;
  D.11265 = D.11259 + D.11264;
  bt = add_backtrace (count, D.11265);
  add_trace_bt (bt, trace, value);
  D.11255 = bt;
  return D.11255;
}


add_stat_sample (int type, uintptr_t ip)
{
  int num_stat_samples.199;
  int size_stat_samples.200;
  int size_stat_samples.201;
  unsigned int size_stat_samples.202;
  unsigned int D.11276;
  uintptr_t * stat_samples.203;
  void * stat_samples.204;
  int * stat_sample_desc.205;
  void * stat_sample_desc.206;
  unsigned int num_stat_samples.207;
  unsigned int D.11282;
  uintptr_t * D.11283;
  int num_stat_samples.208;
  int num_stat_samples.209;
  unsigned int num_stat_samples.210;
  unsigned int D.11287;
  int * D.11288;

  num_stat_samples.199 = num_stat_samples;
  size_stat_samples.200 = size_stat_samples;
  if (num_stat_samples.199 == size_stat_samples.200) goto <D.11270>; else goto <D.11271>;
  <D.11270>:
  size_stat_samples.200 = size_stat_samples;
  size_stat_samples.201 = size_stat_samples.200 * 2;
  size_stat_samples = size_stat_samples.201;
  size_stat_samples.200 = size_stat_samples;
  if (size_stat_samples.200 == 0) goto <D.11273>; else goto <D.11274>;
  <D.11273>:
  size_stat_samples = 32;
  <D.11274>:
  size_stat_samples.200 = size_stat_samples;
  size_stat_samples.202 = (unsigned int) size_stat_samples.200;
  D.11276 = size_stat_samples.202 * 4;
  stat_samples.203 = stat_samples;
  stat_samples.204 = realloc (stat_samples.203, D.11276);
  stat_samples = stat_samples.204;
  size_stat_samples.200 = size_stat_samples;
  size_stat_samples.202 = (unsigned int) size_stat_samples.200;
  D.11276 = size_stat_samples.202 * 4;
  stat_sample_desc.205 = stat_sample_desc;
  stat_sample_desc.206 = realloc (stat_sample_desc.205, D.11276);
  stat_sample_desc = stat_sample_desc.206;
  <D.11271>:
  stat_samples.203 = stat_samples;
  num_stat_samples.199 = num_stat_samples;
  num_stat_samples.207 = (unsigned int) num_stat_samples.199;
  D.11282 = num_stat_samples.207 * 4;
  D.11283 = stat_samples.203 + D.11282;
  *D.11283 = ip;
  stat_sample_desc.205 = stat_sample_desc;
  num_stat_samples.199 = num_stat_samples;
  num_stat_samples.208 = num_stat_samples.199;
  num_stat_samples.209 = num_stat_samples.208 + 1;
  num_stat_samples = num_stat_samples.209;
  num_stat_samples.210 = (unsigned int) num_stat_samples.208;
  D.11287 = num_stat_samples.210 * 4;
  D.11288 = stat_sample_desc.205 + D.11287;
  *D.11288 = type;
}


add_unmanaged_symbol (uintptr_t addr, char * name, uintptr_t size)
{
  int usymbols_num.211;
  int usymbols_size.212;
  unsigned int new_size.213;
  unsigned int D.11296;
  struct UnmanagedSymbol * * usymbols.214;
  void * usymbols.215;
  int usymbols_num.216;
  int usymbols_num.217;
  unsigned int usymbols_num.218;
  unsigned int D.11302;
  struct UnmanagedSymbol * * D.11303;
  struct UnmanagedSymbol * sym;

  usymbols_num.211 = usymbols_num;
  usymbols_size.212 = usymbols_size;
  if (usymbols_num.211 == usymbols_size.212) goto <D.11291>; else goto <D.11292>;
  <D.11291>:
  {
    int new_size;

    usymbols_size.212 = usymbols_size;
    new_size = usymbols_size.212 * 2;
    if (new_size == 0) goto <D.11293>; else goto <D.11294>;
    <D.11293>:
    new_size = 16;
    <D.11294>:
    new_size.213 = (unsigned int) new_size;
    D.11296 = new_size.213 * 4;
    usymbols.214 = usymbols;
    usymbols.215 = realloc (usymbols.214, D.11296);
    usymbols = usymbols.215;
    usymbols_size = new_size;
  }
  <D.11292>:
  sym = calloc (24, 1);
  sym->addr = addr;
  sym->name = name;
  sym->size = size;
  usymbols.214 = usymbols;
  usymbols_num.211 = usymbols_num;
  usymbols_num.216 = usymbols_num.211;
  usymbols_num.217 = usymbols_num.216 + 1;
  usymbols_num = usymbols_num.217;
  usymbols_num.218 = (unsigned int) usymbols_num.216;
  D.11302 = usymbols_num.218 * 4;
  D.11303 = usymbols.214 + D.11302;
  *D.11303 = sym;
}


add_unmanaged_binary (uintptr_t addr, char * name, uintptr_t size)
{
  int ubinaries_num.219;
  int ubinaries_size.220;
  unsigned int new_size.221;
  unsigned int D.11311;
  struct UnmanagedSymbol * * ubinaries.222;
  void * ubinaries.223;
  int ubinaries_num.224;
  int ubinaries_num.225;
  unsigned int ubinaries_num.226;
  unsigned int D.11317;
  struct UnmanagedSymbol * * D.11318;
  struct UnmanagedSymbol * sym;

  ubinaries_num.219 = ubinaries_num;
  ubinaries_size.220 = ubinaries_size;
  if (ubinaries_num.219 == ubinaries_size.220) goto <D.11306>; else goto <D.11307>;
  <D.11306>:
  {
    int new_size;

    ubinaries_size.220 = ubinaries_size;
    new_size = ubinaries_size.220 * 2;
    if (new_size == 0) goto <D.11308>; else goto <D.11309>;
    <D.11308>:
    new_size = 16;
    <D.11309>:
    new_size.221 = (unsigned int) new_size;
    D.11311 = new_size.221 * 4;
    ubinaries.222 = ubinaries;
    ubinaries.223 = realloc (ubinaries.222, D.11311);
    ubinaries = ubinaries.223;
    ubinaries_size = new_size;
  }
  <D.11307>:
  sym = calloc (24, 1);
  sym->addr = addr;
  sym->name = name;
  sym->size = size;
  sym->is_binary = 1;
  ubinaries.222 = ubinaries;
  ubinaries_num.219 = ubinaries_num;
  ubinaries_num.224 = ubinaries_num.219;
  ubinaries_num.225 = ubinaries_num.224 + 1;
  ubinaries_num = ubinaries_num.225;
  ubinaries_num.226 = (unsigned int) ubinaries_num.224;
  D.11317 = ubinaries_num.226 * 4;
  D.11318 = ubinaries.222 + D.11317;
  *D.11318 = sym;
}


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

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


flush_context (struct ProfContext * ctx)
{
  int debug.227;
  int D.11325;
  int D.11326;
  void * D.11327;
  struct FILE * outfile.228;
  long long unsigned int D.11329;
  struct MethodDesc * * D.11330;
  sizetype D.11331;
  sizetype D.11332;
  sizetype D.11333;
  struct MethodDesc * * D.11334;
  struct MethodDesc * D.11335;
  struct ThreadContext * thread;

  thread = ctx->threads;
  goto <D.8851>;
  <D.8850>:
  goto <D.8848>;
  <D.8847>:
  debug.227 = debug;
  if (debug.227 != 0) goto <D.11323>; else goto <D.11324>;
  <D.11323>:
  D.11325 = thread->stack_id;
  D.11326 = thread->thread_id;
  D.11327 = (void *) D.11326;
  outfile.228 = outfile;
  fprintf (outfile.228, "thread %p has %d items on stack\n", D.11327, D.11325);
  <D.11324>:
  D.11329 = thread->last_time;
  D.11330 = thread->stack;
  D.11325 = thread->stack_id;
  D.11331 = (sizetype) D.11325;
  D.11332 = D.11331 + 1073741823;
  D.11333 = D.11332 * 4;
  D.11334 = D.11330 + D.11333;
  D.11335 = *D.11334;
  pop_method (thread, D.11335, D.11329);
  <D.8848>:
  D.11325 = thread->stack_id;
  if (D.11325 != 0) goto <D.8847>; else goto <D.8849>;
  <D.8849>:
  thread = thread->next;
  <D.8851>:
  if (thread != 0B) goto <D.8850>; else goto <D.8852>;
  <D.8852>:
}


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

  p = reps;
  goto <D.8877>;
  <D.8876>:
  opt = match_option (p, "header");
  if (opt != p) goto <D.11336>; else goto <D.11337>;
  <D.11336>:
  if (parse_only == 0) goto <D.11338>; else goto <D.11339>;
  <D.11338>:
  dump_header (ctx);
  <D.11339>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11337>:
  opt = match_option (p, "thread");
  if (opt != p) goto <D.11340>; else goto <D.11341>;
  <D.11340>:
  if (parse_only == 0) goto <D.11342>; else goto <D.11343>;
  <D.11342>:
  dump_threads (ctx);
  <D.11343>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11341>:
  opt = match_option (p, "gc");
  if (opt != p) goto <D.11344>; else goto <D.11345>;
  <D.11344>:
  if (parse_only == 0) goto <D.11346>; else goto <D.11347>;
  <D.11346>:
  dump_gcs ();
  <D.11347>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11345>:
  opt = match_option (p, "jit");
  if (opt != p) goto <D.11348>; else goto <D.11349>;
  <D.11348>:
  if (parse_only == 0) goto <D.11350>; else goto <D.11351>;
  <D.11350>:
  dump_jit ();
  <D.11351>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11349>:
  opt = match_option (p, "alloc");
  if (opt != p) goto <D.11352>; else goto <D.11353>;
  <D.11352>:
  if (parse_only == 0) goto <D.11354>; else goto <D.11355>;
  <D.11354>:
  dump_allocations ();
  <D.11355>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11353>:
  opt = match_option (p, "call");
  if (opt != p) goto <D.11356>; else goto <D.11357>;
  <D.11356>:
  if (parse_only == 0) goto <D.11358>; else goto <D.11359>;
  <D.11358>:
  dump_methods ();
  <D.11359>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11357>:
  opt = match_option (p, "metadata");
  if (opt != p) goto <D.11360>; else goto <D.11361>;
  <D.11360>:
  if (parse_only == 0) goto <D.11362>; else goto <D.11363>;
  <D.11362>:
  dump_metadata ();
  <D.11363>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11361>:
  opt = match_option (p, "exception");
  if (opt != p) goto <D.11364>; else goto <D.11365>;
  <D.11364>:
  if (parse_only == 0) goto <D.11366>; else goto <D.11367>;
  <D.11366>:
  dump_exceptions ();
  <D.11367>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11365>:
  opt = match_option (p, "monitor");
  if (opt != p) goto <D.11368>; else goto <D.11369>;
  <D.11368>:
  if (parse_only == 0) goto <D.11370>; else goto <D.11371>;
  <D.11370>:
  dump_monitors ();
  <D.11371>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11369>:
  opt = match_option (p, "heapshot");
  if (opt != p) goto <D.11372>; else goto <D.11373>;
  <D.11372>:
  if (parse_only == 0) goto <D.11374>; else goto <D.11375>;
  <D.11374>:
  dump_heap_shots ();
  <D.11375>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11373>:
  opt = match_option (p, "sample");
  if (opt != p) goto <D.11376>; else goto <D.11377>;
  <D.11376>:
  if (parse_only == 0) goto <D.11378>; else goto <D.11379>;
  <D.11378>:
  dump_samples ();
  <D.11379>:
  // predicted unlikely by continue predictor.
  goto <D.8875>;
  <D.11377>:
  D.11380 = 0;
  return D.11380;
  <D.8875>:
  p = opt;
  <D.8877>:
  D.11381 = *p;
  if (D.11381 != 0) goto <D.8876>; else goto <D.8878>;
  <D.8878>:
  D.11380 = 1;
  return D.11380;
}


dump_header (struct ProfContext * ctx)
{
  long long unsigned int D.11394;
  long long unsigned int D.11395;
  long int st.229;
  struct FILE * outfile.230;
  int D.11398;
  int D.11399;
  int D.11400;
  int D.11401;
  int D.11402;
  int D.11405;
  time_t st;
  char * t;

  try
    {
      D.11394 = ctx->startup_time;
      D.11395 = D.11394 / 1000;
      st.229 = (long int) D.11395;
      st = st.229;
      t = ctime (&st);
      outfile.230 = outfile;
      fprintf (outfile.230, "\nMono log profiler data\n");
      D.11398 = ctx->version_minor;
      D.11399 = ctx->version_major;
      outfile.230 = outfile;
      fprintf (outfile.230, "\tProfiler version: %d.%d\n", D.11399, D.11398);
      D.11400 = ctx->data_version;
      outfile.230 = outfile;
      fprintf (outfile.230, "\tData version: %d\n", D.11400);
      D.11401 = ctx->timer_overhead;
      outfile.230 = outfile;
      fprintf (outfile.230, "\tMean timer overhead: %d nanoseconds\n", D.11401);
      outfile.230 = outfile;
      fprintf (outfile.230, "\tProgram startup: %s", t);
      D.11402 = ctx->pid;
      if (D.11402 != 0) goto <D.11403>; else goto <D.11404>;
      <D.11403>:
      D.11402 = ctx->pid;
      outfile.230 = outfile;
      fprintf (outfile.230, "\tProgram ID: %d\n", D.11402);
      <D.11404>:
      D.11405 = ctx->port;
      if (D.11405 != 0) goto <D.11406>; else goto <D.11407>;
      <D.11406>:
      D.11405 = ctx->port;
      outfile.230 = outfile;
      fprintf (outfile.230, "\tServer listening on: %d\n", D.11405);
      <D.11407>:
    }
  finally
    {
      st = {CLOBBER};
    }
}


dump_threads (struct ProfContext * ctx)
{
  struct FILE * outfile.231;
  const char * iftmp.232;
  char * D.11412;
  int D.11416;
  void * D.11417;
  struct ThreadContext * thread;

  outfile.231 = outfile;
  fprintf (outfile.231, "\nThread summary\n");
  thread = ctx->threads;
  goto <D.8648>;
  <D.8647>:
  D.11412 = thread->name;
  if (D.11412 != 0B) goto <D.11413>; else goto <D.11414>;
  <D.11413>:
  iftmp.232 = thread->name;
  goto <D.11415>;
  <D.11414>:
  iftmp.232 = "";
  <D.11415>:
  D.11416 = thread->thread_id;
  D.11417 = (void *) D.11416;
  outfile.231 = outfile;
  fprintf (outfile.231, "\tThread: %p, name: \"%s\"\n", D.11417, iftmp.232);
  thread = thread->next;
  <D.8648>:
  if (thread != 0B) goto <D.8647>; else goto <D.8649>;
  <D.8649>:
}


dump_gcs ()
{
  struct FILE * outfile.233;
  int gc_resizes.234;
  long long unsigned int max_heap_size.235;
  long long unsigned int gc_object_moves.236;
  int D.11422;
  long long unsigned int D.11425;
  long long unsigned int D.11426;
  long long unsigned int D.11427;
  long long unsigned int D.11428;
  long long unsigned int D.11429;
  long long unsigned int D.11430;
  long long unsigned int D.11431;
  long long unsigned int D.11432;
  long long unsigned int D.11435;
  long long unsigned int D.11436;
  const char * D.11437;
  struct TraceDesc * D.11438;
  int i;

  outfile.233 = outfile;
  fprintf (outfile.233, "\nGC summary\n");
  gc_resizes.234 = gc_resizes;
  outfile.233 = outfile;
  fprintf (outfile.233, "\tGC resizes: %d\n", gc_resizes.234);
  max_heap_size.235 = max_heap_size;
  outfile.233 = outfile;
  fprintf (outfile.233, "\tMax heap size: %llu\n", max_heap_size.235);
  gc_object_moves.236 = gc_object_moves;
  outfile.233 = outfile;
  fprintf (outfile.233, "\tObject moves: %llu\n", gc_object_moves.236);
  i = 0;
  goto <D.8687>;
  <D.8686>:
  D.11422 = gc_info[i].count;
  if (D.11422 == 0) goto <D.11423>; else goto <D.11424>;
  <D.11423>:
  // predicted unlikely by continue predictor.
  goto <D.8685>;
  <D.11424>:
  D.11425 = gc_info[i].total_time;
  D.11422 = gc_info[i].count;
  D.11426 = (long long unsigned int) D.11422;
  D.11427 = D.11425 / D.11426;
  D.11428 = D.11427 / 1000;
  D.11425 = gc_info[i].total_time;
  D.11429 = D.11425 / 1000;
  D.11430 = gc_info[i].max_time;
  D.11431 = D.11430 / 1000;
  D.11422 = gc_info[i].count;
  outfile.233 = outfile;
  fprintf (outfile.233, "\tGen%d collections: %d, max time: %lluus, total time: %lluus, average: %lluus\n", i, D.11422, D.11431, D.11429, D.11428);
  <D.8685>:
  i = i + 1;
  <D.8687>:
  if (i <= 2) goto <D.8686>; else goto <D.8688>;
  <D.8688>:
  i = 0;
  goto <D.8691>;
  <D.8690>:
  D.11432 = handle_info[i].max_live;
  if (D.11432 == 0) goto <D.11433>; else goto <D.11434>;
  <D.11433>:
  // predicted unlikely by continue predictor.
  goto <D.8689>;
  <D.11434>:
  D.11432 = handle_info[i].max_live;
  D.11435 = handle_info[i].destroyed;
  D.11436 = handle_info[i].created;
  D.11437 = get_handle_name (i);
  outfile.233 = outfile;
  fprintf (outfile.233, "\tGC handles %s: created: %llu, destroyed: %llu, max: %llu\n", D.11437, D.11436, D.11435, D.11432);
  D.11438 = &handle_info[i].traces;
  dump_traces (D.11438, "created");
  <D.8689>:
  i = i + 1;
  <D.8691>:
  if (i <= 2) goto <D.8690>; else goto <D.8692>;
  <D.8692>:
}


dump_traces (struct TraceDesc * traces, const char * desc)
{
  int show_traces.237;
  int D.11443;
  struct CallContext * D.11446;
  unsigned int j.238;
  unsigned int D.11448;
  struct CallContext * D.11449;
  int D.11450;
  long long unsigned int D.11453;
  struct FILE * outfile.239;
  struct MethodDesc * D.11455;
  char * D.11456;
  int j;

  show_traces.237 = show_traces;
  if (show_traces.237 == 0) goto <D.11441>; else goto <D.11442>;
  <D.11441>:
  return;
  <D.11442>:
  D.11443 = traces->count;
  if (D.11443 == 0) goto <D.11444>; else goto <D.11445>;
  <D.11444>:
  return;
  <D.11445>:
  sort_context_array (traces);
  j = 0;
  goto <D.8641>;
  <D.8640>:
  {
    int k;
    struct BackTrace * bt;

    D.11446 = traces->traces;
    j.238 = (unsigned int) j;
    D.11448 = j.238 * 12;
    D.11449 = D.11446 + D.11448;
    bt = D.11449->bt;
    D.11450 = bt->count;
    if (D.11450 == 0) goto <D.11451>; else goto <D.11452>;
    <D.11451>:
    // predicted unlikely by continue predictor.
    goto <D.8636>;
    <D.11452>:
    D.11446 = traces->traces;
    j.238 = (unsigned int) j;
    D.11448 = j.238 * 12;
    D.11449 = D.11446 + D.11448;
    D.11453 = D.11449->count;
    outfile.239 = outfile;
    fprintf (outfile.239, "\t%llu %s from:\n", D.11453, desc);
    k = 0;
    goto <D.8638>;
    <D.8637>:
    D.11455 = bt->methods[k];
    D.11456 = D.11455->name;
    outfile.239 = outfile;
    fprintf (outfile.239, "\t\t%s\n", D.11456);
    k = k + 1;
    <D.8638>:
    D.11450 = bt->count;
    if (D.11450 > k) goto <D.8637>; else goto <D.8639>;
    <D.8639>:
  }
  <D.8636>:
  j = j + 1;
  <D.8641>:
  D.11443 = traces->count;
  if (D.11443 > j) goto <D.8640>; else goto <D.8642>;
  <D.8642>:
}


sort_context_array (struct TraceDesc * traces)
{
  struct CallContext * D.11458;
  unsigned int i.240;
  unsigned int D.11460;
  struct CallContext * D.11461;
  struct BackTrace * D.11462;
  unsigned int j.241;
  unsigned int D.11466;
  struct CallContext * D.11467;
  long long unsigned int D.11468;
  int D.11469;
  int D.11470;
  unsigned int D.11471;
  int i;
  int j;

  i = 0;
  j = 0;
  goto <D.8278>;
  <D.8277>:
  D.11458 = traces->traces;
  i.240 = (unsigned int) i;
  D.11460 = i.240 * 12;
  D.11461 = D.11458 + D.11460;
  D.11462 = D.11461->bt;
  if (D.11462 != 0B) goto <D.11463>; else goto <D.11464>;
  <D.11463>:
  D.11458 = traces->traces;
  j.241 = (unsigned int) j;
  D.11466 = j.241 * 12;
  D.11467 = D.11458 + D.11466;
  D.11458 = traces->traces;
  i.240 = (unsigned int) i;
  D.11460 = i.240 * 12;
  D.11461 = D.11458 + D.11460;
  D.11462 = D.11461->bt;
  D.11467->bt = D.11462;
  D.11458 = traces->traces;
  j.241 = (unsigned int) j;
  D.11466 = j.241 * 12;
  D.11467 = D.11458 + D.11466;
  D.11458 = traces->traces;
  i.240 = (unsigned int) i;
  D.11460 = i.240 * 12;
  D.11461 = D.11458 + D.11460;
  D.11468 = D.11461->count;
  D.11467->count = D.11468;
  j = j + 1;
  <D.11464>:
  i = i + 1;
  <D.8278>:
  D.11469 = traces->size;
  if (D.11469 > i) goto <D.8277>; else goto <D.8279>;
  <D.8279>:
  D.11470 = traces->count;
  D.11471 = (unsigned int) D.11470;
  D.11458 = traces->traces;
  qsort (D.11458, D.11471, 12, compare_callc);
}


compare_callc (const void * a, const void * b)
{
  long long unsigned int D.11472;
  long long unsigned int D.11473;
  int D.11476;
  const struct CallContext * A;
  const struct CallContext * B;

  A = a;
  B = b;
  D.11472 = B->count;
  D.11473 = A->count;
  if (D.11472 == D.11473) goto <D.11474>; else goto <D.11475>;
  <D.11474>:
  D.11476 = 0;
  return D.11476;
  <D.11475>:
  D.11472 = B->count;
  D.11473 = A->count;
  if (D.11472 < D.11473) goto <D.11477>; else goto <D.11478>;
  <D.11477>:
  D.11476 = -1;
  return D.11476;
  <D.11478>:
  D.11476 = 1;
  return D.11476;
}


dump_jit ()
{
  struct FILE * outfile.242;
  int D.11481;
  int D.11484;
  int i;
  int code_size;
  int compiled_methods;
  struct MethodDesc * m;

  code_size = 0;
  compiled_methods = 0;
  outfile.242 = outfile;
  fprintf (outfile.242, "\nJIT summary\n");
  i = 0;
  goto <D.8705>;
  <D.8704>:
  m = method_hash[i];
  m = method_hash[i];
  goto <D.8702>;
  <D.8701>:
  D.11481 = m->code;
  if (D.11481 == 0) goto <D.11482>; else goto <D.11483>;
  <D.11482>:
  // predicted unlikely by continue predictor.
  goto <D.8700>;
  <D.11483>:
  compiled_methods = compiled_methods + 1;
  D.11484 = m->len;
  code_size = D.11484 + code_size;
  <D.8700>:
  m = m->next;
  <D.8702>:
  if (m != 0B) goto <D.8701>; else goto <D.8703>;
  <D.8703>:
  i = i + 1;
  <D.8705>:
  if (i <= 9370) goto <D.8704>; else goto <D.8706>;
  <D.8706>:
  outfile.242 = outfile;
  fprintf (outfile.242, "\tCompiled methods: %d\n", compiled_methods);
  outfile.242 = outfile;
  fprintf (outfile.242, "\tGenerated code size: %d\n", code_size);
}


dump_allocations ()
{
  int num_classes.243;
  unsigned int num_classes.244;
  unsigned int D.11487;
  int c.245;
  unsigned int c.246;
  unsigned int D.11490;
  struct ClassDesc * * D.11491;
  unsigned int num_classes.247;
  unsigned int i.248;
  unsigned int D.11494;
  struct ClassDesc * * D.11495;
  int D.11496;
  long long unsigned int D.11499;
  int header_done.249;
  struct FILE * outfile.250;
  char * D.11504;
  long long unsigned int D.11505;
  long long unsigned int D.11506;
  struct TraceDesc * D.11507;
  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.243 = num_classes;
  num_classes.244 = (unsigned int) num_classes.243;
  D.11487 = num_classes.244 * 4;
  classes = malloc (D.11487);
  c = 0;
  i = 0;
  goto <D.8721>;
  <D.8720>:
  cd = class_hash[i];
  goto <D.8718>;
  <D.8717>:
  c.245 = c;
  c = c.245 + 1;
  c.246 = (unsigned int) c.245;
  D.11490 = c.246 * 4;
  D.11491 = classes + D.11490;
  *D.11491 = cd;
  cd = cd->next;
  <D.8718>:
  if (cd != 0B) goto <D.8717>; else goto <D.8719>;
  <D.8719>:
  i = i + 1;
  <D.8721>:
  if (i <= 9370) goto <D.8720>; else goto <D.8722>;
  <D.8722>:
  num_classes.243 = num_classes;
  num_classes.247 = (unsigned int) num_classes.243;
  qsort (classes, num_classes.247, 4, compare_class);
  i = 0;
  goto <D.8725>;
  <D.8724>:
  i.248 = (unsigned int) i;
  D.11494 = i.248 * 4;
  D.11495 = classes + D.11494;
  cd = *D.11495;
  D.11496 = cd->allocs;
  if (D.11496 == 0) goto <D.11497>; else goto <D.11498>;
  <D.11497>:
  // predicted unlikely by continue predictor.
  goto <D.8723>;
  <D.11498>:
  D.11496 = cd->allocs;
  allocs = D.11496 + allocs;
  D.11499 = cd->alloc_size;
  size = D.11499 + size;
  header_done.249 = header_done;
  header_done = header_done.249 + 1;
  if (header_done.249 == 0) goto <D.11501>; else goto <D.11502>;
  <D.11501>:
  outfile.250 = outfile;
  fprintf (outfile.250, "\nAllocation summary\n");
  outfile.250 = outfile;
  fprintf (outfile.250, "%10s %10s %8s Type name\n", "Bytes", "Count", "Average");
  <D.11502>:
  D.11504 = cd->name;
  D.11499 = cd->alloc_size;
  D.11496 = cd->allocs;
  D.11505 = (long long unsigned int) D.11496;
  D.11506 = D.11499 / D.11505;
  D.11496 = cd->allocs;
  D.11499 = cd->alloc_size;
  outfile.250 = outfile;
  fprintf (outfile.250, "%10llu %10d %8llu %s\n", D.11499, D.11496, D.11506, D.11504);
  D.11507 = &cd->traces;
  dump_traces (D.11507, "bytes");
  <D.8723>:
  i = i + 1;
  <D.8725>:
  num_classes.243 = num_classes;
  if (i < num_classes.243) goto <D.8724>; else goto <D.8726>;
  <D.8726>:
  if (allocs != 0) goto <D.11508>; else goto <D.11509>;
  <D.11508>:
  outfile.250 = outfile;
  fprintf (outfile.250, "Total memory allocated: %llu bytes in %d objects\n", size, allocs);
  <D.11509>:
}


compare_class (const void * a, const void * b)
{
  int alloc_sort_mode.251;
  struct ClassDesc * D.11513;
  struct ClassDesc * D.11514;
  int D.11516;
  int D.11517;
  int D.11520;
  struct ClassDesc * const * A;
  struct ClassDesc * const * B;
  uint64_t vala;
  uint64_t valb;

  A = a;
  B = b;
  alloc_sort_mode.251 = alloc_sort_mode;
  if (alloc_sort_mode.251 == 0) goto <D.11511>; else goto <D.11512>;
  <D.11511>:
  D.11513 = *A;
  vala = D.11513->alloc_size;
  D.11514 = *B;
  valb = D.11514->alloc_size;
  goto <D.11515>;
  <D.11512>:
  D.11513 = *A;
  D.11516 = D.11513->allocs;
  vala = (uint64_t) D.11516;
  D.11514 = *B;
  D.11517 = D.11514->allocs;
  valb = (uint64_t) D.11517;
  <D.11515>:
  if (valb == vala) goto <D.11518>; else goto <D.11519>;
  <D.11518>:
  D.11520 = 0;
  return D.11520;
  <D.11519>:
  if (valb < vala) goto <D.11521>; else goto <D.11522>;
  <D.11521>:
  D.11520 = -1;
  return D.11520;
  <D.11522>:
  D.11520 = 1;
  return D.11520;
}


dump_methods ()
{
  int num_methods.252;
  unsigned int num_methods.253;
  unsigned int D.11526;
  long long unsigned int D.11527;
  long long unsigned int D.11528;
  long long unsigned int D.11529;
  int c.254;
  unsigned int c.255;
  unsigned int D.11532;
  struct MethodDesc * * D.11533;
  unsigned int num_methods.256;
  unsigned int i.257;
  unsigned int D.11536;
  struct MethodDesc * * D.11537;
  long long unsigned int D.11538;
  long long unsigned int D.11541;
  long long unsigned int D.11542;
  int verbose.258;
  int header_done.259;
  struct FILE * outfile.260;
  char * D.11552;
  struct TraceDesc * D.11553;
  int i;
  int c;
  uint64_t calls;
  int header_done;
  struct MethodDesc * * methods;
  struct MethodDesc * cd;

  calls = 0;
  header_done = 0;
  num_methods.252 = num_methods;
  num_methods.253 = (unsigned int) num_methods.252;
  D.11526 = num_methods.253 * 4;
  methods = malloc (D.11526);
  c = 0;
  i = 0;
  goto <D.8764>;
  <D.8763>:
  cd = method_hash[i];
  goto <D.8761>;
  <D.8760>:
  D.11527 = cd->self_time;
  D.11528 = cd->callee_time;
  D.11529 = D.11527 + D.11528;
  cd->total_time = D.11529;
  c.254 = c;
  c = c.254 + 1;
  c.255 = (unsigned int) c.254;
  D.11532 = c.255 * 4;
  D.11533 = methods + D.11532;
  *D.11533 = cd;
  cd = cd->next;
  <D.8761>:
  if (cd != 0B) goto <D.8760>; else goto <D.8762>;
  <D.8762>:
  i = i + 1;
  <D.8764>:
  if (i <= 9370) goto <D.8763>; else goto <D.8765>;
  <D.8765>:
  num_methods.252 = num_methods;
  num_methods.256 = (unsigned int) num_methods.252;
  qsort (methods, num_methods.256, 4, compare_method);
  i = 0;
  goto <D.8770>;
  <D.8769>:
  {
    uint64_t msecs;
    uint64_t smsecs;

    i.257 = (unsigned int) i;
    D.11536 = i.257 * 4;
    D.11537 = methods + D.11536;
    cd = *D.11537;
    D.11538 = cd->calls;
    if (D.11538 == 0) goto <D.11539>; else goto <D.11540>;
    <D.11539>:
    // predicted unlikely by continue predictor.
    goto <D.8768>;
    <D.11540>:
    D.11538 = cd->calls;
    calls = D.11538 + calls;
    D.11541 = cd->total_time;
    msecs = D.11541 / 1000000;
    D.11541 = cd->total_time;
    D.11528 = cd->callee_time;
    D.11542 = D.11541 - D.11528;
    smsecs = D.11542 / 1000000;
    if (msecs == 0) goto <D.11543>; else goto <D.11544>;
    <D.11543>:
    verbose.258 = verbose;
    if (verbose.258 == 0) goto <D.11546>; else goto <D.11547>;
    <D.11546>:
    // predicted unlikely by continue predictor.
    goto <D.8768>;
    <D.11547>:
    <D.11544>:
    header_done.259 = header_done;
    header_done = header_done.259 + 1;
    if (header_done.259 == 0) goto <D.11549>; else goto <D.11550>;
    <D.11549>:
    outfile.260 = outfile;
    fprintf (outfile.260, "\nMethod call summary\n");
    outfile.260 = outfile;
    fprintf (outfile.260, "%8s %8s %10s Method name\n", "Total(ms)", "Self(ms)", "Calls");
    <D.11550>:
    D.11552 = cd->name;
    D.11538 = cd->calls;
    outfile.260 = outfile;
    fprintf (outfile.260, "%8llu %8llu %10llu %s\n", msecs, smsecs, D.11538, D.11552);
    D.11553 = &cd->traces;
    dump_traces (D.11553, "calls");
  }
  <D.8768>:
  i = i + 1;
  <D.8770>:
  num_methods.252 = num_methods;
  if (i < num_methods.252) goto <D.8769>; else goto <D.8771>;
  <D.8771>:
  if (calls != 0) goto <D.11554>; else goto <D.11555>;
  <D.11554>:
  outfile.260 = outfile;
  fprintf (outfile.260, "Total calls: %llu\n", calls);
  <D.11555>:
}


compare_method (const void * a, const void * b)
{
  int method_sort_mode.261;
  struct MethodDesc * D.11559;
  struct MethodDesc * D.11560;
  int D.11567;
  struct MethodDesc * const * A;
  struct MethodDesc * const * B;
  uint64_t vala;
  uint64_t valb;

  A = a;
  B = b;
  method_sort_mode.261 = method_sort_mode;
  if (method_sort_mode.261 == 1) goto <D.11557>; else goto <D.11558>;
  <D.11557>:
  D.11559 = *A;
  vala = D.11559->self_time;
  D.11560 = *B;
  valb = D.11560->self_time;
  goto <D.11561>;
  <D.11558>:
  method_sort_mode.261 = method_sort_mode;
  if (method_sort_mode.261 == 2) goto <D.11562>; else goto <D.11563>;
  <D.11562>:
  D.11559 = *A;
  vala = D.11559->calls;
  D.11560 = *B;
  valb = D.11560->calls;
  goto <D.11564>;
  <D.11563>:
  D.11559 = *A;
  vala = D.11559->total_time;
  D.11560 = *B;
  valb = D.11560->total_time;
  <D.11564>:
  <D.11561>:
  if (vala == valb) goto <D.11565>; else goto <D.11566>;
  <D.11565>:
  D.11567 = 0;
  return D.11567;
  <D.11566>:
  if (valb < vala) goto <D.11568>; else goto <D.11569>;
  <D.11568>:
  D.11567 = -1;
  return D.11567;
  <D.11569>:
  D.11567 = 1;
  return D.11567;
}


dump_metadata ()
{
  struct FILE * outfile.262;
  int num_images.263;
  int verbose.264;
  char * D.11576;

  outfile.262 = outfile;
  fprintf (outfile.262, "\nMetadata summary\n");
  num_images.263 = num_images;
  outfile.262 = outfile;
  fprintf (outfile.262, "\tLoaded images: %d\n", num_images.263);
  verbose.264 = verbose;
  if (verbose.264 != 0) goto <D.11574>; else goto <D.11575>;
  <D.11574>:
  {
    struct ImageDesc * image;
    int i;

    i = 0;
    goto <D.8749>;
    <D.8748>:
    image = image_hash[i];
    goto <D.8746>;
    <D.8745>:
    D.11576 = image->filename;
    outfile.262 = outfile;
    fprintf (outfile.262, "\t\t%s\n", D.11576);
    image = image->next;
    <D.8746>:
    if (image != 0B) goto <D.8745>; else goto <D.8747>;
    <D.8747>:
    i = i + 1;
    <D.8749>:
    if (i <= 30) goto <D.8748>; else goto <D.8750>;
    <D.8750>:
  }
  <D.11575>:
}


dump_exceptions ()
{
  struct FILE * outfile.265;
  long long unsigned int throw_count.266;
  long long unsigned int D.11579;
  const char * D.11582;
  int i;

  outfile.265 = outfile;
  fprintf (outfile.265, "\nException summary\n");
  throw_count.266 = throw_count;
  outfile.265 = outfile;
  fprintf (outfile.265, "\tThrows: %llu\n", throw_count.266);
  dump_traces (&exc_traces, "throws");
  i = 0;
  goto <D.8656>;
  <D.8655>:
  D.11579 = clause_summary[i];
  if (D.11579 == 0) goto <D.11580>; else goto <D.11581>;
  <D.11580>:
  // predicted unlikely by continue predictor.
  goto <D.8654>;
  <D.11581>:
  D.11579 = clause_summary[i];
  D.11582 = clause_name (i);
  outfile.265 = outfile;
  fprintf (outfile.265, "\tExecuted %s clauses: %llu\n", D.11582, D.11579);
  <D.8654>:
  i = i + 1;
  <D.8656>:
  if (i <= 4) goto <D.8655>; else goto <D.8657>;
  <D.8657>:
}


dump_monitors ()
{
  int num_monitors.267;
  unsigned int num_monitors.268;
  unsigned int D.11588;
  int j.269;
  unsigned int j.270;
  unsigned int D.11591;
  struct MonitorDesc * * D.11592;
  unsigned int num_monitors.271;
  struct FILE * outfile.272;
  unsigned int i.273;
  unsigned int D.11596;
  struct MonitorDesc * * D.11597;
  unsigned int D.11598;
  int D.11599;
  unsigned int D.11600;
  void * D.11601;
  long long unsigned int D.11602;
  double D.11603;
  double D.11604;
  double D.11605;
  double D.11606;
  long long unsigned int D.11607;
  double D.11608;
  double D.11609;
  struct TraceDesc * D.11610;
  long long unsigned int monitor_contention.274;
  long long unsigned int monitor_acquired.275;
  long long unsigned int monitor_failed.276;
  struct MonitorDesc * * monitors;
  int i;
  int j;

  num_monitors.267 = num_monitors;
  if (num_monitors.267 == 0) goto <D.11585>; else goto <D.11586>;
  <D.11585>:
  return;
  <D.11586>:
  num_monitors.267 = num_monitors;
  num_monitors.268 = (unsigned int) num_monitors.267;
  D.11588 = num_monitors.268 * 4;
  monitors = malloc (D.11588);
  i = 0;
  j = 0;
  goto <D.8675>;
  <D.8674>:
  {
    struct MonitorDesc * mdesc;

    mdesc = monitor_hash[i];
    goto <D.8672>;
    <D.8671>:
    j.269 = j;
    j = j.269 + 1;
    j.270 = (unsigned int) j.269;
    D.11591 = j.270 * 4;
    D.11592 = monitors + D.11591;
    *D.11592 = mdesc;
    mdesc = mdesc->next;
    <D.8672>:
    if (mdesc != 0B) goto <D.8671>; else goto <D.8673>;
    <D.8673>:
  }
  i = i + 1;
  <D.8675>:
  if (i <= 30) goto <D.8674>; else goto <D.8676>;
  <D.8676>:
  num_monitors.267 = num_monitors;
  num_monitors.271 = (unsigned int) num_monitors.267;
  qsort (monitors, num_monitors.271, 4, compare_monitor);
  outfile.272 = outfile;
  fprintf (outfile.272, "\nMonitor lock summary\n");
  i = 0;
  goto <D.8679>;
  <D.8678>:
  {
    struct MonitorDesc * mdesc;

    i.273 = (unsigned int) i;
    D.11596 = i.273 * 4;
    D.11597 = monitors + D.11596;
    mdesc = *D.11597;
    D.11598 = mdesc->contentions;
    D.11599 = (int) D.11598;
    D.11600 = mdesc->objid;
    D.11601 = (void *) D.11600;
    outfile.272 = outfile;
    fprintf (outfile.272, "\tLock object %p: %d contentions\n", D.11601, D.11599);
    D.11602 = mdesc->wait_time;
    D.11603 = (double) D.11602;
    D.11604 = D.11603 / 1.0e+9;
    D.11598 = mdesc->contentions;
    D.11605 = (double) D.11598;
    D.11606 = D.11604 / D.11605;
    D.11607 = mdesc->max_wait_time;
    D.11608 = (double) D.11607;
    D.11609 = D.11608 / 1.0e+9;
    D.11602 = mdesc->wait_time;
    D.11603 = (double) D.11602;
    D.11604 = D.11603 / 1.0e+9;
    outfile.272 = outfile;
    fprintf (outfile.272, "\t\t%.6f secs total wait time, %.6f max, %.6f average\n", D.11604, D.11609, D.11606);
    D.11610 = &mdesc->traces;
    dump_traces (D.11610, "contentions");
  }
  i = i + 1;
  <D.8679>:
  num_monitors.267 = num_monitors;
  if (i < num_monitors.267) goto <D.8678>; else goto <D.8680>;
  <D.8680>:
  monitor_contention.274 = monitor_contention;
  outfile.272 = outfile;
  fprintf (outfile.272, "\tLock contentions: %llu\n", monitor_contention.274);
  monitor_acquired.275 = monitor_acquired;
  outfile.272 = outfile;
  fprintf (outfile.272, "\tLock acquired: %llu\n", monitor_acquired.275);
  monitor_failed.276 = monitor_failed;
  outfile.272 = outfile;
  fprintf (outfile.272, "\tLock failures: %llu\n", monitor_failed.276);
}


compare_monitor (const void * a, const void * b)
{
  struct MonitorDesc * D.11615;
  long long unsigned int D.11616;
  struct MonitorDesc * D.11617;
  long long unsigned int D.11618;
  int D.11621;
  struct MonitorDesc * const * A;
  struct MonitorDesc * const * B;

  A = a;
  B = b;
  D.11615 = *B;
  D.11616 = D.11615->wait_time;
  D.11617 = *A;
  D.11618 = D.11617->wait_time;
  if (D.11616 == D.11618) goto <D.11619>; else goto <D.11620>;
  <D.11619>:
  D.11621 = 0;
  return D.11621;
  <D.11620>:
  D.11615 = *B;
  D.11616 = D.11615->wait_time;
  D.11617 = *A;
  D.11618 = D.11617->wait_time;
  if (D.11616 < D.11618) goto <D.11622>; else goto <D.11623>;
  <D.11622>:
  D.11621 = -1;
  return D.11621;
  <D.11623>:
  D.11621 = 1;
  return D.11621;
}


dump_heap_shots ()
{
  struct HeapShot * heap_shots.277;
  int num_heap_shots.278;
  unsigned int num_heap_shots.279;
  unsigned int D.11630;
  struct FILE * outfile.280;
  int i.281;
  unsigned int i.282;
  unsigned int D.11634;
  struct HeapShot * * D.11635;
  unsigned int num_heap_shots.283;
  unsigned int i.284;
  unsigned int D.11638;
  struct HeapShot * * D.11639;
  struct HeapShot * * hs_sorted;
  struct HeapShot * hs;
  struct HeapShot * last_hs;
  int i;

  last_hs = 0B;
  heap_shots.277 = heap_shots;
  if (heap_shots.277 == 0B) goto <D.11626>; else goto <D.11627>;
  <D.11626>:
  return;
  <D.11627>:
  num_heap_shots.278 = num_heap_shots;
  num_heap_shots.279 = (unsigned int) num_heap_shots.278;
  D.11630 = num_heap_shots.279 * 4;
  hs_sorted = malloc (D.11630);
  outfile.280 = outfile;
  fprintf (outfile.280, "\nHeap shot summary\n");
  i = 0;
  hs = heap_shots;
  goto <D.8838>;
  <D.8837>:
  i.281 = i;
  i = i.281 + 1;
  i.282 = (unsigned int) i.281;
  D.11634 = i.282 * 4;
  D.11635 = hs_sorted + D.11634;
  *D.11635 = hs;
  hs = hs->next;
  <D.8838>:
  if (hs != 0B) goto <D.8837>; else goto <D.8839>;
  <D.8839>:
  num_heap_shots.278 = num_heap_shots;
  num_heap_shots.283 = (unsigned int) num_heap_shots.278;
  qsort (hs_sorted, num_heap_shots.283, 4, compare_heap_shots);
  i = 0;
  goto <D.8841>;
  <D.8840>:
  i.284 = (unsigned int) i;
  D.11638 = i.284 * 4;
  D.11639 = hs_sorted + D.11638;
  hs = *D.11639;
  heap_shot_summary (hs, i, last_hs);
  last_hs = hs;
  i = i + 1;
  <D.8841>:
  num_heap_shots.278 = num_heap_shots;
  if (i < num_heap_shots.278) goto <D.8840>; else goto <D.8842>;
  <D.8842>:
}


compare_heap_shots (const void * a, const void * b)
{
  struct HeapShot * D.11641;
  long long unsigned int D.11642;
  struct HeapShot * D.11643;
  long long unsigned int D.11644;
  int D.11647;
  struct HeapShot * const * A;
  struct HeapShot * const * B;

  A = a;
  B = b;
  D.11641 = *B;
  D.11642 = D.11641->timestamp;
  D.11643 = *A;
  D.11644 = D.11643->timestamp;
  if (D.11642 == D.11644) goto <D.11645>; else goto <D.11646>;
  <D.11645>:
  D.11647 = 0;
  return D.11647;
  <D.11646>:
  D.11641 = *B;
  D.11642 = D.11641->timestamp;
  D.11643 = *A;
  D.11644 = D.11643->timestamp;
  if (D.11642 > D.11644) goto <D.11648>; else goto <D.11649>;
  <D.11648>:
  D.11647 = -1;
  return D.11647;
  <D.11649>:
  D.11647 = 1;
  return D.11647;
}


heap_shot_summary (struct HeapShot * hs, int hs_num, struct HeapShot * last_hs)
{
  int D.11651;
  unsigned int D.11652;
  unsigned int D.11653;
  struct HeapClassDesc * * D.11654;
  unsigned int i.285;
  unsigned int D.11656;
  struct HeapClassDesc * * D.11657;
  long long int D.11660;
  long long unsigned int D.11661;
  long long int D.11662;
  long long unsigned int D.11663;
  int ccount.286;
  unsigned int ccount.287;
  unsigned int D.11666;
  struct HeapClassDesc * * D.11667;
  int D.11668;
  unsigned int ccount.288;
  unsigned int D.11670;
  long long unsigned int D.11671;
  long long unsigned int startup_time.289;
  long long unsigned int D.11673;
  double D.11674;
  double D.11675;
  struct FILE * outfile.290;
  int verbose.291;
  struct HeapClassDesc * * D.11682;
  struct ClassDesc * D.11685;
  char * D.11686;
  long long int D.11687;
  long long int D.11690;
  long long int D.11691;
  int collect_traces.292;
  int D.11696;
  unsigned int D.11697;
  unsigned int D.11698;
  struct HeapClassRevRef * D.11699;
  unsigned int j.293;
  unsigned int D.11701;
  struct HeapClassRevRef * D.11702;
  struct HeapClassDesc * D.11703;
  int k.294;
  unsigned int k.295;
  unsigned int D.11708;
  struct HeapClassRevRef * D.11709;
  int D.11710;
  unsigned int D.11713;
  unsigned int D.11714;
  unsigned int D.11717;
  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.11651 = hs->class_count;
  D.11652 = (unsigned int) D.11651;
  D.11653 = D.11652 * 4;
  sorted = malloc (D.11653);
  i = 0;
  goto <D.8808>;
  <D.8807>:
  D.11654 = hs->class_hash;
  i.285 = (unsigned int) i;
  D.11656 = i.285 * 4;
  D.11657 = D.11654 + D.11656;
  cd = *D.11657;
  if (cd == 0B) goto <D.11658>; else goto <D.11659>;
  <D.11658>:
  // predicted unlikely by continue predictor.
  goto <D.8806>;
  <D.11659>:
  D.11660 = cd->count;
  D.11661 = (long long unsigned int) D.11660;
  count = D.11661 + count;
  D.11662 = cd->total_size;
  D.11663 = (long long unsigned int) D.11662;
  size = D.11663 + size;
  ccount.286 = ccount;
  ccount = ccount.286 + 1;
  ccount.287 = (unsigned int) ccount.286;
  D.11666 = ccount.287 * 4;
  D.11667 = sorted + D.11666;
  *D.11667 = cd;
  <D.8806>:
  i = i + 1;
  <D.8808>:
  D.11668 = hs->hash_size;
  if (D.11668 > i) goto <D.8807>; else goto <D.8809>;
  <D.8809>:
  hs->sorted = sorted;
  ccount.288 = (unsigned int) ccount;
  qsort (sorted, ccount.288, 4, compare_heap_class);
  D.11670 = hs->num_roots;
  D.11671 = hs->timestamp;
  startup_time.289 = startup_time;
  D.11673 = D.11671 - startup_time.289;
  D.11674 = (double) D.11673;
  D.11675 = D.11674 / 1.0e+9;
  outfile.290 = outfile;
  fprintf (outfile.290, "\n\tHeap shot %d at %.3f secs: size: %llu, object count: %llu, class count: %d, roots: %d\n", hs_num, D.11675, size, count, ccount, D.11670);
  verbose.291 = verbose;
  if (verbose.291 == 0) goto <D.11678>; else goto <D.11679>;
  <D.11678>:
  if (ccount > 30) goto <D.11680>; else goto <D.11681>;
  <D.11680>:
  ccount = 30;
  <D.11681>:
  <D.11679>:
  outfile.290 = outfile;
  fprintf (outfile.290, "\t%10s %10s %8s Class name\n", "Bytes", "Count", "Average");
  i = 0;
  goto <D.8822>;
  <D.8821>:
  {
    struct HeapClassRevRef * rev_sorted;
    int j;
    int k;
    struct HeapClassDesc * ocd;

    ocd = 0B;
    i.285 = (unsigned int) i;
    D.11656 = i.285 * 4;
    D.11682 = sorted + D.11656;
    cd = *D.11682;
    if (last_hs != 0B) goto <D.11683>; else goto <D.11684>;
    <D.11683>:
    D.11685 = cd->klass;
    ocd = heap_class_lookup (last_hs, D.11685);
    <D.11684>:
    D.11685 = cd->klass;
    D.11686 = D.11685->name;
    D.11662 = cd->total_size;
    D.11660 = cd->count;
    D.11687 = D.11662 / D.11660;
    D.11660 = cd->count;
    D.11662 = cd->total_size;
    outfile.290 = outfile;
    fprintf (outfile.290, "\t%10llu %10llu %8llu %s", D.11662, D.11660, D.11687, D.11686);
    if (ocd != 0B) goto <D.11688>; else goto <D.11689>;
    <D.11688>:
    {
      int64_t bdiff;
      int64_t cdiff;

      D.11662 = cd->total_size;
      D.11690 = ocd->total_size;
      bdiff = D.11662 - D.11690;
      D.11660 = cd->count;
      D.11691 = ocd->count;
      cdiff = D.11660 - D.11691;
      outfile.290 = outfile;
      fprintf (outfile.290, " (bytes: %+lld, count: %+lld)\n", bdiff, cdiff);
    }
    goto <D.11692>;
    <D.11689>:
    outfile.290 = outfile;
    fprintf (outfile.290, "\n");
    <D.11692>:
    collect_traces.292 = collect_traces;
    if (collect_traces.292 == 0) goto <D.11694>; else goto <D.11695>;
    <D.11694>:
    // predicted unlikely by continue predictor.
    goto <D.8816>;
    <D.11695>:
    D.11696 = cd->rev_count;
    D.11697 = (unsigned int) D.11696;
    D.11698 = D.11697 * 12;
    rev_sorted = malloc (D.11698);
    k = 0;
    j = 0;
    goto <D.8818>;
    <D.8817>:
    D.11699 = cd->rev_hash;
    j.293 = (unsigned int) j;
    D.11701 = j.293 * 12;
    D.11702 = D.11699 + D.11701;
    D.11703 = D.11702->klass;
    if (D.11703 != 0B) goto <D.11704>; else goto <D.11705>;
    <D.11704>:
    k.294 = k;
    k = k.294 + 1;
    k.295 = (unsigned int) k.294;
    D.11708 = k.295 * 12;
    D.11709 = rev_sorted + D.11708;
    D.11699 = cd->rev_hash;
    j.293 = (unsigned int) j;
    D.11701 = j.293 * 12;
    D.11702 = D.11699 + D.11701;
    *D.11709 = *D.11702;
    <D.11705>:
    j = j + 1;
    <D.8818>:
    D.11710 = cd->rev_hash_size;
    if (D.11710 > j) goto <D.8817>; else goto <D.8819>;
    <D.8819>:
    D.11696 = cd->rev_count;
    if (D.11696 != k) goto <D.11711>; else goto <D.11712>;
    <D.11711>:
    __assert_fail ("cd->rev_count == k", "decode.c", 2416, &__PRETTY_FUNCTION__);
    <D.11712>:
    D.11696 = cd->rev_count;
    D.11713 = (unsigned int) D.11696;
    qsort (rev_sorted, D.11713, 12, compare_rev_class);
    D.11714 = cd->root_references;
    if (D.11714 != 0) goto <D.11715>; else goto <D.11716>;
    <D.11715>:
    D.11717 = cd->pinned_references;
    D.11714 = cd->root_references;
    outfile.290 = outfile;
    fprintf (outfile.290, "\t\t%d root references (%d pinning)\n", D.11714, D.11717);
    <D.11716>:
    D.11696 = cd->rev_count;
    dump_rev_claases (rev_sorted, D.11696);
    free (rev_sorted);
  }
  <D.8816>:
  i = i + 1;
  <D.8822>:
  if (i < ccount) goto <D.8821>; else goto <D.8823>;
  <D.8823>:
  free (sorted);
}


compare_rev_class (const void * a, const void * b)
{
  long long unsigned int D.11719;
  long long unsigned int D.11720;
  int D.11723;
  const struct HeapClassRevRef * A;
  const struct HeapClassRevRef * B;

  A = a;
  B = b;
  D.11719 = B->count;
  D.11720 = A->count;
  if (D.11719 == D.11720) goto <D.11721>; else goto <D.11722>;
  <D.11721>:
  D.11723 = 0;
  return D.11723;
  <D.11722>:
  D.11719 = B->count;
  D.11720 = A->count;
  if (D.11719 < D.11720) goto <D.11724>; else goto <D.11725>;
  <D.11724>:
  D.11723 = -1;
  return D.11723;
  <D.11725>:
  D.11723 = 1;
  return D.11723;
}


compare_heap_class (const void * a, const void * b)
{
  int alloc_sort_mode.296;
  struct HeapClassDesc * D.11730;
  long long int D.11731;
  struct HeapClassDesc * D.11732;
  long long int D.11733;
  long long int D.11735;
  long long int D.11736;
  int D.11739;
  struct HeapClassDesc * const * A;
  struct HeapClassDesc * const * B;
  uint64_t vala;
  uint64_t valb;

  A = a;
  B = b;
  alloc_sort_mode.296 = alloc_sort_mode;
  if (alloc_sort_mode.296 == 0) goto <D.11728>; else goto <D.11729>;
  <D.11728>:
  D.11730 = *A;
  D.11731 = D.11730->total_size;
  vala = (uint64_t) D.11731;
  D.11732 = *B;
  D.11733 = D.11732->total_size;
  valb = (uint64_t) D.11733;
  goto <D.11734>;
  <D.11729>:
  D.11730 = *A;
  D.11735 = D.11730->count;
  vala = (uint64_t) D.11735;
  D.11732 = *B;
  D.11736 = D.11732->count;
  valb = (uint64_t) D.11736;
  <D.11734>:
  if (valb == vala) goto <D.11737>; else goto <D.11738>;
  <D.11737>:
  D.11739 = 0;
  return D.11739;
  <D.11738>:
  if (valb < vala) goto <D.11740>; else goto <D.11741>;
  <D.11740>:
  D.11739 = -1;
  return D.11739;
  <D.11741>:
  D.11739 = 1;
  return D.11739;
}


heap_class_lookup (struct HeapShot * hs, struct ClassDesc * klass)
{
  int D.11743;
  unsigned int D.11744;
  unsigned int D.11745;
  int D.11746;
  unsigned int D.11747;
  struct HeapClassDesc * * D.11748;
  unsigned int i.297;
  unsigned int D.11750;
  struct HeapClassDesc * * D.11751;
  struct HeapClassDesc * D.11754;
  struct ClassDesc * D.11755;
  int i;
  unsigned int start_pos;

  D.11743 = klass->klass;
  D.11744 = (unsigned int) D.11743;
  D.11745 = D.11744 >> 2;
  D.11746 = hs->hash_size;
  D.11747 = (unsigned int) D.11746;
  start_pos = D.11745 % D.11747;
  i = (int) start_pos;
  <D.7997>:
  {
    struct HeapClassDesc * cd;

    D.11748 = hs->class_hash;
    i.297 = (unsigned int) i;
    D.11750 = i.297 * 4;
    D.11751 = D.11748 + D.11750;
    cd = *D.11751;
    if (cd == 0B) goto <D.11752>; else goto <D.11753>;
    <D.11752>:
    D.11754 = 0B;
    return D.11754;
    <D.11753>:
    D.11755 = cd->klass;
    if (D.11755 == klass) goto <D.11756>; else goto <D.11757>;
    <D.11756>:
    D.11754 = cd;
    return D.11754;
    <D.11757>:
    i = i + 1;
    D.11746 = hs->hash_size;
    if (i == D.11746) goto <D.11758>; else goto <D.11759>;
    <D.11758>:
    i = 0;
    <D.11759>:
  }
  i.297 = (unsigned int) i;
  if (i.297 != start_pos) goto <D.7997>; else goto <D.7998>;
  <D.7998>:
  D.11754 = 0B;
  return D.11754;
}


dump_rev_claases (struct HeapClassRevRef * revs, int count)
{
  int show_traces.298;
  unsigned int j.299;
  unsigned int D.11767;
  struct HeapClassRevRef * D.11768;
  struct ClassDesc * D.11769;
  char * D.11770;
  long long unsigned int D.11771;
  struct FILE * outfile.300;
  int j;

  show_traces.298 = show_traces;
  if (show_traces.298 == 0) goto <D.11762>; else goto <D.11763>;
  <D.11762>:
  return;
  <D.11763>:
  if (count == 0) goto <D.11764>; else goto <D.11765>;
  <D.11764>:
  return;
  <D.11765>:
  j = 0;
  goto <D.8793>;
  <D.8792>:
  {
    struct HeapClassDesc * cd;

    j.299 = (unsigned int) j;
    D.11767 = j.299 * 12;
    D.11768 = revs + D.11767;
    cd = D.11768->klass;
    D.11769 = cd->klass;
    D.11770 = D.11769->name;
    j.299 = (unsigned int) j;
    D.11767 = j.299 * 12;
    D.11768 = revs + D.11767;
    D.11771 = D.11768->count;
    outfile.300 = outfile;
    fprintf (outfile.300, "\t\t%llu references from: %s\n", D.11771, D.11770);
  }
  j = j + 1;
  <D.8793>:
  if (j < count) goto <D.8792>; else goto <D.8794>;
  <D.8794>:
}


match_option (const char * p, const char * opt)
{
  unsigned int D.11774;
  unsigned int len.301;
  int D.11776;
  sizetype len.302;
  const char * D.11780;
  char D.11781;
  const char * D.11784;
  int len;

  D.11774 = strlen (opt);
  len = (int) D.11774;
  len.301 = (unsigned int) len;
  D.11776 = strncmp (p, opt, len.301);
  if (D.11776 == 0) goto <D.11777>; else goto <D.11778>;
  <D.11777>:
  len.302 = (sizetype) len;
  D.11780 = p + len.302;
  D.11781 = *D.11780;
  if (D.11781 == 44) goto <D.11782>; else goto <D.11783>;
  <D.11782>:
  len = len + 1;
  <D.11783>:
  len.302 = (sizetype) len;
  D.11784 = p + len.302;
  return D.11784;
  <D.11778>:
  D.11784 = p;
  return D.11784;
}


dump_samples ()
{
  int num_stat_samples.303;
  int usymbols_num.304;
  unsigned int usymbols_num.305;
  struct UnmanagedSymbol * * usymbols.306;
  uintptr_t * stat_samples.307;
  unsigned int i.308;
  unsigned int D.11794;
  uintptr_t * D.11795;
  unsigned int D.11796;
  int D.11799;
  unsigned int msize.309;
  unsigned int D.11807;
  int count.310;
  unsigned int count.311;
  unsigned int D.11810;
  struct MethodDesc * * D.11811;
  int D.11812;
  unsigned int D.11818;
  unsigned int usize.312;
  unsigned int D.11826;
  int ucount.313;
  unsigned int ucount.314;
  unsigned int D.11829;
  struct UnmanagedSymbol * * D.11830;
  unsigned int D.11831;
  unsigned int count.315;
  unsigned int ucount.316;
  struct FILE * outfile.317;
  int * stat_sample_desc.318;
  int D.11836;
  const char * D.11837;
  double D.11838;
  double D.11839;
  double D.11840;
  double D.11841;
  int D.11842;
  double D.11843;
  double D.11844;
  double D.11845;
  double D.11846;
  double D.11847;
  double D.11848;
  struct MethodDesc * * D.11851;
  unsigned int u.319;
  unsigned int D.11855;
  struct UnmanagedSymbol * * D.11856;
  unsigned int D.11857;
  int D.11858;
  unsigned int D.11859;
  int D.11862;
  int D.11864;
  char * D.11866;
  double D.11867;
  double D.11868;
  double D.11869;
  unsigned int D.11872;
  int D.11873;
  _Bool D.11875;
  _Bool D.11876;
  _Bool D.11877;
  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.303 = num_stat_samples;
  if (num_stat_samples.303 == 0) goto <D.11787>; else goto <D.11788>;
  <D.11787>:
  return;
  <D.11788>:
  usymbols_num.304 = usymbols_num;
  usymbols_num.305 = (unsigned int) usymbols_num.304;
  usymbols.306 = usymbols;
  qsort (usymbols.306, usymbols_num.305, 4, compare_usymbol_addr);
  i = 0;
  goto <D.7917>;
  <D.7916>:
  {
    struct MethodDesc * m;

    stat_samples.307 = stat_samples;
    i.308 = (unsigned int) i;
    D.11794 = i.308 * 4;
    D.11795 = stat_samples.307 + D.11794;
    D.11796 = *D.11795;
    m = lookup_method_by_ip (D.11796);
    if (m != 0B) goto <D.11797>; else goto <D.11798>;
    <D.11797>:
    D.11799 = m->sample_hits;
    if (D.11799 == 0) goto <D.11800>; else goto <D.11801>;
    <D.11800>:
    if (count == msize) goto <D.11802>; else goto <D.11803>;
    <D.11802>:
    msize = msize * 2;
    if (msize == 0) goto <D.11804>; else goto <D.11805>;
    <D.11804>:
    msize = 4;
    <D.11805>:
    msize.309 = (unsigned int) msize;
    D.11807 = msize.309 * 4;
    cachedm = realloc (cachedm, D.11807);
    <D.11803>:
    count.310 = count;
    count = count.310 + 1;
    count.311 = (unsigned int) count.310;
    D.11810 = count.311 * 4;
    D.11811 = cachedm + D.11810;
    *D.11811 = m;
    <D.11801>:
    D.11799 = m->sample_hits;
    D.11812 = D.11799 + 1;
    m->sample_hits = D.11812;
    goto <D.11813>;
    <D.11798>:
    {
      struct UnmanagedSymbol * usym;

      stat_samples.307 = stat_samples;
      i.308 = (unsigned int) i;
      D.11794 = i.308 * 4;
      D.11795 = stat_samples.307 + D.11794;
      D.11796 = *D.11795;
      usym = lookup_unmanaged_symbol (D.11796);
      if (usym == 0B) goto <D.11814>; else goto <D.11815>;
      <D.11814>:
      unresolved_hits = unresolved_hits + 1;
      stat_samples.307 = stat_samples;
      i.308 = (unsigned int) i;
      D.11794 = i.308 * 4;
      D.11795 = stat_samples.307 + D.11794;
      D.11796 = *D.11795;
      usym = lookup_unmanaged_binary (D.11796);
      <D.11815>:
      if (usym != 0B) goto <D.11816>; else goto <D.11817>;
      <D.11816>:
      D.11818 = usym->sample_hits;
      if (D.11818 == 0) goto <D.11819>; else goto <D.11820>;
      <D.11819>:
      if (ucount == usize) goto <D.11821>; else goto <D.11822>;
      <D.11821>:
      usize = usize * 2;
      if (usize == 0) goto <D.11823>; else goto <D.11824>;
      <D.11823>:
      usize = 4;
      <D.11824>:
      usize.312 = (unsigned int) usize;
      D.11826 = usize.312 * 4;
      cachedus = realloc (cachedus, D.11826);
      <D.11822>:
      ucount.313 = ucount;
      ucount = ucount.313 + 1;
      ucount.314 = (unsigned int) ucount.313;
      D.11829 = ucount.314 * 4;
      D.11830 = cachedus + D.11829;
      *D.11830 = usym;
      <D.11820>:
      D.11818 = usym->sample_hits;
      D.11831 = D.11818 + 1;
      usym->sample_hits = D.11831;
      <D.11817>:
      unmanaged_hits = unmanaged_hits + 1;
    }
    <D.11813>:
  }
  i = i + 1;
  <D.7917>:
  num_stat_samples.303 = num_stat_samples;
  if (i < num_stat_samples.303) goto <D.7916>; else goto <D.7918>;
  <D.7918>:
  count.315 = (unsigned int) count;
  qsort (cachedm, count.315, 4, compare_method_samples);
  ucount.316 = (unsigned int) ucount;
  qsort (cachedus, ucount.316, 4, compare_usymbol_samples);
  set_usym_parent (cachedus, ucount);
  outfile.317 = outfile;
  fprintf (outfile.317, "\nStatistical samples summary\n");
  stat_sample_desc.318 = stat_sample_desc;
  D.11836 = *stat_sample_desc.318;
  D.11837 = sample_type_name (D.11836);
  outfile.317 = outfile;
  fprintf (outfile.317, "\tSample type: %s\n", D.11837);
  D.11838 = (double) unmanaged_hits;
  D.11839 = D.11838 * 1.0e+2;
  num_stat_samples.303 = num_stat_samples;
  D.11840 = (double) num_stat_samples.303;
  D.11841 = D.11839 / D.11840;
  outfile.317 = outfile;
  fprintf (outfile.317, "\tUnmanaged hits:  %6d (%4.1f%%)\n", unmanaged_hits, D.11841);
  num_stat_samples.303 = num_stat_samples;
  D.11842 = num_stat_samples.303 - unmanaged_hits;
  D.11843 = (double) D.11842;
  D.11844 = D.11843 * 1.0e+2;
  num_stat_samples.303 = num_stat_samples;
  D.11840 = (double) num_stat_samples.303;
  D.11845 = D.11844 / D.11840;
  num_stat_samples.303 = num_stat_samples;
  D.11842 = num_stat_samples.303 - unmanaged_hits;
  outfile.317 = outfile;
  fprintf (outfile.317, "\tManaged hits:    %6d (%4.1f%%)\n", D.11842, D.11845);
  D.11846 = (double) unresolved_hits;
  D.11847 = D.11846 * 1.0e+2;
  num_stat_samples.303 = num_stat_samples;
  D.11840 = (double) num_stat_samples.303;
  D.11848 = D.11847 / D.11840;
  outfile.317 = outfile;
  fprintf (outfile.317, "\tUnresolved hits: %6d (%4.1f%%)\n", unresolved_hits, D.11848);
  outfile.317 = outfile;
  fprintf (outfile.317, "\t%6s %6s %s\n", "Hits", "%", "Method name");
  i = 0;
  u = 0;
  goto <D.7922>;
  <D.7924>:
  if (i < count) goto <D.11849>; else goto <D.11850>;
  <D.11849>:
  {
    struct MethodDesc * m;

    i.308 = (unsigned int) i;
    D.11794 = i.308 * 4;
    D.11851 = cachedm + D.11794;
    m = *D.11851;
    if (u < ucount) goto <D.11852>; else goto <D.11853>;
    <D.11852>:
    {
      struct UnmanagedSymbol * um;

      u.319 = (unsigned int) u;
      D.11855 = u.319 * 4;
      D.11856 = cachedus + D.11855;
      um = *D.11856;
      D.11857 = um->sample_hits;
      D.11858 = m->sample_hits;
      D.11859 = (unsigned int) D.11858;
      if (D.11857 > D.11859) goto <D.11860>; else goto <D.11861>;
      <D.11860>:
      D.11857 = um->sample_hits;
      D.11862 = sym_percent (D.11857);
      if (D.11862 == 0) goto <D.7921>; else goto <D.11863>;
      <D.11863>:
      print_usym (um);
      u = u + 1;
      // predicted unlikely by continue predictor.
      goto <D.7922>;
      <D.11861>:
    }
    <D.11853>:
    D.11858 = m->sample_hits;
    D.11859 = (unsigned int) D.11858;
    D.11864 = sym_percent (D.11859);
    if (D.11864 == 0) goto <D.7921>; else goto <D.11865>;
    <D.11865>:
    D.11866 = m->name;
    D.11858 = m->sample_hits;
    D.11867 = (double) D.11858;
    D.11868 = D.11867 * 1.0e+2;
    num_stat_samples.303 = num_stat_samples;
    D.11840 = (double) num_stat_samples.303;
    D.11869 = D.11868 / D.11840;
    D.11858 = m->sample_hits;
    outfile.317 = outfile;
    fprintf (outfile.317, "\t%6d %6.2f %s\n", D.11858, D.11869, D.11866);
    i = i + 1;
    // predicted unlikely by continue predictor.
    goto <D.7922>;
  }
  <D.11850>:
  if (u < ucount) goto <D.11870>; else goto <D.11871>;
  <D.11870>:
  {
    struct UnmanagedSymbol * um;

    u.319 = (unsigned int) u;
    D.11855 = u.319 * 4;
    D.11856 = cachedus + D.11855;
    um = *D.11856;
    D.11872 = um->sample_hits;
    D.11873 = sym_percent (D.11872);
    if (D.11873 == 0) goto <D.7921>; else goto <D.11874>;
    <D.11874>:
    print_usym (um);
    u = u + 1;
    // predicted unlikely by continue predictor.
    goto <D.7922>;
  }
  <D.11871>:
  <D.7922>:
  D.11875 = i < count;
  D.11876 = u < ucount;
  D.11877 = D.11875 | D.11876;
  if (D.11877 != 0) goto <D.7924>; else goto <D.7921>;
  <D.7921>:
}


compare_usymbol_samples (const void * a, const void * b)
{
  struct UnmanagedSymbol * D.11886;
  unsigned int D.11887;
  struct UnmanagedSymbol * D.11888;
  unsigned int D.11889;
  int D.11892;
  struct UnmanagedSymbol * const * A;
  struct UnmanagedSymbol * const * B;

  A = a;
  B = b;
  D.11886 = *B;
  D.11887 = D.11886->sample_hits;
  D.11888 = *A;
  D.11889 = D.11888->sample_hits;
  if (D.11887 == D.11889) goto <D.11890>; else goto <D.11891>;
  <D.11890>:
  D.11892 = 0;
  return D.11892;
  <D.11891>:
  D.11886 = *B;
  D.11887 = D.11886->sample_hits;
  D.11888 = *A;
  D.11889 = D.11888->sample_hits;
  if (D.11887 < D.11889) goto <D.11893>; else goto <D.11894>;
  <D.11893>:
  D.11892 = -1;
  return D.11892;
  <D.11894>:
  D.11892 = 1;
  return D.11892;
}


compare_method_samples (const void * a, const void * b)
{
  struct MethodDesc * D.11896;
  int D.11897;
  struct MethodDesc * D.11898;
  int D.11899;
  int D.11902;
  struct MethodDesc * const * A;
  struct MethodDesc * const * B;

  A = a;
  B = b;
  D.11896 = *A;
  D.11897 = D.11896->sample_hits;
  D.11898 = *B;
  D.11899 = D.11898->sample_hits;
  if (D.11897 == D.11899) goto <D.11900>; else goto <D.11901>;
  <D.11900>:
  D.11902 = 0;
  return D.11902;
  <D.11901>:
  D.11898 = *B;
  D.11899 = D.11898->sample_hits;
  D.11896 = *A;
  D.11897 = D.11896->sample_hits;
  if (D.11899 < D.11897) goto <D.11903>; else goto <D.11904>;
  <D.11903>:
  D.11902 = -1;
  return D.11902;
  <D.11904>:
  D.11902 = 1;
  return D.11902;
}


compare_usymbol_addr (const void * a, const void * b)
{
  struct UnmanagedSymbol * D.11906;
  unsigned int D.11907;
  struct UnmanagedSymbol * D.11908;
  unsigned int D.11909;
  int D.11912;
  struct UnmanagedSymbol * const * A;
  struct UnmanagedSymbol * const * B;

  A = a;
  B = b;
  D.11906 = *B;
  D.11907 = D.11906->addr;
  D.11908 = *A;
  D.11909 = D.11908->addr;
  if (D.11907 == D.11909) goto <D.11910>; else goto <D.11911>;
  <D.11910>:
  D.11912 = 0;
  return D.11912;
  <D.11911>:
  D.11906 = *B;
  D.11907 = D.11906->addr;
  D.11908 = *A;
  D.11909 = D.11908->addr;
  if (D.11907 > D.11909) goto <D.11913>; else goto <D.11914>;
  <D.11913>:
  D.11912 = -1;
  return D.11912;
  <D.11914>:
  D.11912 = 1;
  return D.11912;
}


lookup_method_by_ip (uintptr_t ip)
{
  int D.11916;
  unsigned int D.11917;
  unsigned int D.11920;
  int D.11921;
  unsigned int D.11922;
  unsigned int D.11923;
  struct MethodDesc * D.11926;
  int i;
  struct MethodDesc * m;

  i = 0;
  goto <D.7808>;
  <D.7807>:
  m = method_hash[i];
  goto <D.7805>;
  <D.7804>:
  D.11916 = m->code;
  D.11917 = (unsigned int) D.11916;
  if (D.11917 <= ip) goto <D.11918>; else goto <D.11919>;
  <D.11918>:
  D.11916 = m->code;
  D.11920 = (unsigned int) D.11916;
  D.11921 = m->len;
  D.11922 = (unsigned int) D.11921;
  D.11923 = D.11920 + D.11922;
  if (D.11923 > ip) goto <D.11924>; else goto <D.11925>;
  <D.11924>:
  D.11926 = m;
  return D.11926;
  <D.11925>:
  <D.11919>:
  m = m->next;
  <D.7805>:
  if (m != 0B) goto <D.7804>; else goto <D.7806>;
  <D.7806>:
  i = i + 1;
  <D.7808>:
  if (i <= 9370) goto <D.7807>; else goto <D.7809>;
  <D.7809>:
  D.11926 = 0B;
  return D.11926;
}


lookup_unmanaged_symbol (uintptr_t addr)
{
  int usymbols_num.320;
  int D.11929;
  struct UnmanagedSymbol * * usymbols.321;
  unsigned int m.322;
  unsigned int D.11932;
  struct UnmanagedSymbol * * D.11933;
  unsigned int D.11934;
  struct UnmanagedSymbol * D.11937;
  unsigned int last_best.323;
  unsigned int D.11946;
  struct UnmanagedSymbol * * D.11947;
  struct UnmanagedSymbol * D.11948;
  unsigned int D.11949;
  unsigned int D.11950;
  int r;
  int l;
  struct UnmanagedSymbol * sym;
  int last_best;

  usymbols_num.320 = usymbols_num;
  r = usymbols_num.320 + -1;
  l = 0;
  last_best = -1;
  goto <D.7855>;
  <D.7854>:
  {
    int m;

    D.11929 = l + r;
    m = D.11929 / 2;
    usymbols.321 = usymbols;
    m.322 = (unsigned int) m;
    D.11932 = m.322 * 4;
    D.11933 = usymbols.321 + D.11932;
    sym = *D.11933;
    D.11934 = sym->addr;
    if (D.11934 == addr) goto <D.11935>; else goto <D.11936>;
    <D.11935>:
    D.11937 = sym;
    return D.11937;
    <D.11936>:
    D.11934 = sym->addr;
    if (D.11934 > addr) goto <D.11938>; else goto <D.11939>;
    <D.11938>:
    r = m + -1;
    goto <D.11940>;
    <D.11939>:
    D.11934 = sym->addr;
    if (D.11934 < addr) goto <D.11941>; else goto <D.11942>;
    <D.11941>:
    l = m + 1;
    last_best = m;
    <D.11942>:
    <D.11940>:
  }
  <D.7855>:
  if (r >= l) goto <D.7854>; else goto <D.7856>;
  <D.7856>:
  if (last_best >= 0) goto <D.11943>; else goto <D.11944>;
  <D.11943>:
  usymbols.321 = usymbols;
  last_best.323 = (unsigned int) last_best;
  D.11946 = last_best.323 * 4;
  D.11947 = usymbols.321 + D.11946;
  D.11948 = *D.11947;
  D.11949 = D.11948->addr;
  D.11950 = addr - D.11949;
  if (D.11950 <= 4095) goto <D.11951>; else goto <D.11952>;
  <D.11951>:
  usymbols.321 = usymbols;
  last_best.323 = (unsigned int) last_best;
  D.11946 = last_best.323 * 4;
  D.11947 = usymbols.321 + D.11946;
  D.11937 = *D.11947;
  return D.11937;
  <D.11952>:
  <D.11944>:
  D.11937 = 0B;
  return D.11937;
}


lookup_unmanaged_binary (uintptr_t addr)
{
  struct UnmanagedSymbol * * ubinaries.324;
  unsigned int i.325;
  unsigned int D.11956;
  struct UnmanagedSymbol * * D.11957;
  unsigned int D.11958;
  unsigned int D.11961;
  unsigned int D.11962;
  struct UnmanagedSymbol * D.11965;
  int ubinaries_num.326;
  int i;

  i = 0;
  goto <D.7873>;
  <D.7872>:
  {
    struct UnmanagedSymbol * ubin;

    ubinaries.324 = ubinaries;
    i.325 = (unsigned int) i;
    D.11956 = i.325 * 4;
    D.11957 = ubinaries.324 + D.11956;
    ubin = *D.11957;
    D.11958 = ubin->addr;
    if (D.11958 <= addr) goto <D.11959>; else goto <D.11960>;
    <D.11959>:
    D.11958 = ubin->addr;
    D.11961 = ubin->size;
    D.11962 = D.11958 + D.11961;
    if (D.11962 > addr) goto <D.11963>; else goto <D.11964>;
    <D.11963>:
    D.11965 = ubin;
    return D.11965;
    <D.11964>:
    <D.11960>:
  }
  i = i + 1;
  <D.7873>:
  ubinaries_num.326 = ubinaries_num;
  if (i < ubinaries_num.326) goto <D.7872>; else goto <D.7874>;
  <D.7874>:
  D.11965 = 0B;
  return D.11965;
}


set_usym_parent (struct UnmanagedSymbol * * cachedus, int count)
{
  unsigned int i.327;
  unsigned int D.11969;
  struct UnmanagedSymbol * * D.11970;
  struct UnmanagedSymbol * D.11971;
  unsigned int D.11972;
  int i;

  i = 0;
  goto <D.7892>;
  <D.7891>:
  {
    struct UnmanagedSymbol * ubin;

    i.327 = (unsigned int) i;
    D.11969 = i.327 * 4;
    D.11970 = cachedus + D.11969;
    D.11971 = *D.11970;
    D.11972 = D.11971->addr;
    ubin = lookup_unmanaged_binary (D.11972);
    i.327 = (unsigned int) i;
    D.11969 = i.327 * 4;
    D.11970 = cachedus + D.11969;
    D.11971 = *D.11970;
    if (D.11971 == ubin) goto <D.11973>; else goto <D.11974>;
    <D.11973>:
    // predicted unlikely by continue predictor.
    goto <D.7890>;
    <D.11974>:
    i.327 = (unsigned int) i;
    D.11969 = i.327 * 4;
    D.11970 = cachedus + D.11969;
    D.11971 = *D.11970;
    D.11971->parent = ubin;
  }
  <D.7890>:
  i = i + 1;
  <D.7892>:
  if (i < count) goto <D.7891>; else goto <D.7893>;
  <D.7893>:
}


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

  switch (type) <default: <D.11977>, case 1: <D.7878>, case 2: <D.7879>, case 3: <D.7880>, case 4: <D.7881>, case 5: <D.7882>, case 6: <D.7883>>
  <D.7878>:
  D.11976 = "cycles";
  return D.11976;
  <D.7879>:
  D.11976 = "instructions retired";
  return D.11976;
  <D.7880>:
  D.11976 = "cache misses";
  return D.11976;
  <D.7881>:
  D.11976 = "cache references";
  return D.11976;
  <D.7882>:
  D.11976 = "executed branches";
  return D.11976;
  <D.7883>:
  D.11976 = "unpredicted branches";
  return D.11976;
  <D.11977>:
  D.11976 = "unknown";
  return D.11976;
}


sym_percent (uintptr_t sample_hits)
{
  int verbose.328;
  int D.11982;
  double D.11983;
  double D.11984;
  int num_stat_samples.329;
  double D.11986;
  _Bool D.11987;
  double pc;

  verbose.328 = verbose;
  if (verbose.328 != 0) goto <D.11980>; else goto <D.11981>;
  <D.11980>:
  D.11982 = 1;
  return D.11982;
  <D.11981>:
  D.11983 = (double) sample_hits;
  D.11984 = D.11983 * 1.0e+2;
  num_stat_samples.329 = num_stat_samples;
  D.11986 = (double) num_stat_samples.329;
  pc = D.11984 / D.11986;
  D.11987 = pc >= 1.000000000000000055511151231257827021181583404541015625e-1;
  D.11982 = (int) D.11987;
  return D.11982;
}


print_usym (struct UnmanagedSymbol * um)
{
  struct UnmanagedSymbol * D.11989;
  char * D.11992;
  char * D.11993;
  unsigned int D.11994;
  double D.11995;
  double D.11996;
  int num_stat_samples.330;
  double D.11998;
  double D.11999;
  struct FILE * outfile.331;

  D.11989 = um->parent;
  if (D.11989 != 0B) goto <D.11990>; else goto <D.11991>;
  <D.11990>:
  D.11989 = um->parent;
  D.11992 = D.11989->name;
  D.11993 = um->name;
  D.11994 = um->sample_hits;
  D.11995 = (double) D.11994;
  D.11996 = D.11995 * 1.0e+2;
  num_stat_samples.330 = num_stat_samples;
  D.11998 = (double) num_stat_samples.330;
  D.11999 = D.11996 / D.11998;
  D.11994 = um->sample_hits;
  outfile.331 = outfile;
  fprintf (outfile.331, "\t%6d %6.2f %-36s in %s\n", D.11994, D.11999, D.11993, D.11992);
  goto <D.12001>;
  <D.11991>:
  D.11993 = um->name;
  D.11994 = um->sample_hits;
  D.11995 = (double) D.11994;
  D.11996 = D.11995 * 1.0e+2;
  num_stat_samples.330 = num_stat_samples;
  D.11998 = (double) num_stat_samples.330;
  D.11999 = D.11996 / D.11998;
  D.11994 = um->sample_hits;
  outfile.331 = outfile;
  fprintf (outfile.331, "\t%6d %6.2f %s\n", D.11994, D.11999, D.11993);
  <D.12001>:
}