utils_init (int fast_time)
{
  long long unsigned int D.11579;
  long long unsigned int time_inc.0;
  int D.11581;
  uint64_t (*<T1cc9>) (void) time_func.1;
  long long unsigned int D.11587;
  long long unsigned int D.11588;
  int timer_overhead.2;
  int i;
  uint64_t time_start;
  uint64_t time_end;

  if (fast_time > 1) goto <D.11574>; else goto <D.11575>;
  <D.11574>:
  time_func = null_time;
  goto <D.11576>;
  <D.11575>:
  if (fast_time != 0) goto <D.11577>; else goto <D.11578>;
  <D.11577>:
  {
    uint64_t timea;
    uint64_t timeb;

    clock_time ();
    timea = clock_time ();
    timeb = clock_time ();
    D.11579 = timeb - timea;
    time_inc.0 = D.11579 / 8;
    time_inc = time_inc.0;
    D.11581 = have_rdtsc ();
    if (D.11581 != 0) goto <D.11582>; else goto <D.11583>;
    <D.11582>:
    time_func = rdtsc_current_time;
    goto <D.11584>;
    <D.11583>:
    time_func = fast_current_time;
    <D.11584>:
  }
  goto <D.11585>;
  <D.11578>:
  time_func = clock_time;
  <D.11585>:
  <D.11576>:
  time_func.1 = time_func;
  time_start = time_func.1 ();
  i = 0;
  goto <D.10314>;
  <D.10313>:
  time_func.1 = time_func;
  time_func.1 ();
  i = i + 1;
  <D.10314>:
  if (i <= 255) goto <D.10313>; else goto <D.10315>;
  <D.10315>:
  time_func.1 = time_func;
  time_end = time_func.1 ();
  D.11587 = time_end - time_start;
  D.11588 = D.11587 / 256;
  timer_overhead.2 = (int) D.11588;
  timer_overhead = timer_overhead.2;
}


fast_current_time ()
{
  unsigned int D.11595;
  unsigned int D.11596;
  unsigned int D.11597;
  unsigned int D.11598;
  long long unsigned int D.11601;
  long long unsigned int time_inc.3;
  long long unsigned int D.11603;
  uint64_t D.11604;
  long long unsigned int D.11605;
  struct TlsData * tls;

  tls = &tls_data;
  D.11595 = tls->timer_count;
  D.11596 = D.11595;
  D.11597 = D.11596 + 1;
  tls->timer_count = D.11597;
  D.11598 = D.11596 & 7;
  if (D.11598 != 0) goto <D.11599>; else goto <D.11600>;
  <D.11599>:
  D.11601 = tls->last_time;
  time_inc.3 = time_inc;
  D.11603 = D.11601 + time_inc.3;
  tls->last_time = D.11603;
  D.11604 = tls->last_time;
  return D.11604;
  <D.11600>:
  D.11605 = clock_time ();
  tls->last_time = D.11605;
  D.11604 = tls->last_time;
  return D.11604;
}


rdtsc_current_time ()
{
  unsigned int D.11608;
  unsigned int D.11609;
  unsigned int D.11610;
  unsigned int D.11611;
  int cpu.4;
  int D.11617;
  long long unsigned int D.11620;
  long long unsigned int D.11621;
  double D.11624;
  double cpu_freq.5;
  double D.11626;
  uint64_t D.11627;
  long long unsigned int D.11628;
  long long unsigned int D.11630;
  int * D.11631;
  long long unsigned int D.11632;
  struct TlsData * tls;

  tls = &tls_data;
  D.11608 = tls->timer_count;
  D.11609 = D.11608;
  D.11610 = D.11609 + 1;
  tls->timer_count = D.11610;
  D.11611 = D.11609 & 63;
  if (D.11611 != 0) goto <D.11612>; else goto <D.11613>;
  <D.11612>:
  {
    int cpu;
    uint64_t tsc;

    try
      {
        tsc = safe_rdtsc (&cpu);
        cpu.4 = cpu;
        if (cpu.4 != -1) goto <D.11615>; else goto <D.11616>;
        <D.11615>:
        D.11617 = tls->last_cpu;
        cpu.4 = cpu;
        if (D.11617 == cpu.4) goto <D.11618>; else goto <D.11619>;
        <D.11618>:
        {
          int64_t diff;
          uint64_t nsecs;

          D.11620 = tls->last_rdtsc;
          D.11621 = tsc - D.11620;
          diff = (int64_t) D.11621;
          if (diff > 0) goto <D.11622>; else goto <D.11623>;
          <D.11622>:
          D.11624 = (double) diff;
          cpu_freq.5 = cpu_freq;
          D.11626 = D.11624 / cpu_freq.5;
          nsecs = (uint64_t) D.11626;
          D.11628 = tls->last_time;
          D.11627 = D.11628 + nsecs;
          return D.11627;
          <D.11623>:
          printf ("tsc went backwards\n");
        }
        goto <D.11629>;
        <D.11619>:
        <D.11629>:
        <D.11616>:
      }
    finally
      {
        cpu = {CLOBBER};
      }
  }
  <D.11613>:
  D.11630 = clock_time ();
  tls->last_time = D.11630;
  D.11631 = &tls->last_cpu;
  D.11632 = safe_rdtsc (D.11631);
  tls->last_rdtsc = D.11632;
  D.11627 = tls->last_time;
  return D.11627;
}


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

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


safe_rdtsc (int * cpu)
{
  uint64_t D.11645;
  long long unsigned int D.11646;
  long long unsigned int D.11647;
  long long unsigned int D.11648;
  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.11643>; else goto <D.11644>;
  <D.11643>:
  *cpu = -1;
  D.11645 = 0;
  return D.11645;
  <D.11644>:
  *cpu = c1;
  D.11646 = (long long unsigned int) high;
  D.11647 = D.11646 << 32;
  D.11648 = (long long unsigned int) low;
  D.11645 = D.11647 + D.11648;
  return D.11645;
}


null_time ()
{
  uint64_t D.11650;
  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.11650 = timer.7;
  return D.11650;
}


clock_time ()
{
  uint64_t D.11655;
  long int D.11656;
  long long unsigned int D.11657;
  long long unsigned int D.11658;
  long int D.11659;
  long long unsigned int D.11660;
  struct timespec tspec;

  try
    {
      clock_gettime (1, &tspec);
      D.11656 = tspec.tv_sec;
      D.11657 = (long long unsigned int) D.11656;
      D.11658 = D.11657 * 1000000000;
      D.11659 = tspec.tv_nsec;
      D.11660 = (long long unsigned int) D.11659;
      D.11655 = D.11658 + D.11660;
      return D.11655;
    }
  finally
    {
      tspec = {CLOBBER};
    }
}


have_rdtsc ()
{
  int D.11665;
  int D.11668;
  float val.9;
  float D.11672;
  double cpu_freq.10;
  int D.11674;
  char * D.11677;
  char * D.11680;
  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.11663>; else goto <D.11664>;
      <D.11663>:
      D.11665 = 0;
      return D.11665;
      <D.11664>:
      cpuinfo = fopen ("/proc/cpuinfo", "r");
      if (cpuinfo == 0B) goto <D.11666>; else goto <D.11667>;
      <D.11666>:
      D.11665 = 0;
      return D.11665;
      <D.11667>:
      goto <D.10291>;
      <D.10290>:
      D.11668 = sscanf (&buf, "cpu MHz : %f", &val);
      if (D.11668 == 1) goto <D.11669>; else goto <D.11670>;
      <D.11669>:
      have_freq = 1;
      val.9 = val;
      D.11672 = val.9 * 1.0e+6;
      cpu_freq.10 = (double) D.11672;
      cpu_freq = cpu_freq.10;
      <D.11670>:
      D.11674 = strncmp (&buf, "flags :", 5);
      if (D.11674 == 0) goto <D.11675>; else goto <D.11676>;
      <D.11675>:
      D.11677 = strstr (&buf, "constant_tsc");
      if (D.11677 != 0B) goto <D.11678>; else goto <D.11679>;
      <D.11678>:
      have_flag = 1;
      <D.11679>:
      <D.11676>:
      <D.10291>:
      D.11680 = fgets (&buf, 256, cpuinfo);
      if (D.11680 != 0B) goto <D.10290>; else goto <D.10292>;
      <D.10292>:
      fclose (cpuinfo);
      if (have_flag != 0) goto <D.11682>; else goto <D.11683>;
      <D.11682>:
      iftmp.11 = have_freq;
      goto <D.11684>;
      <D.11683>:
      iftmp.11 = 0;
      <D.11684>:
      D.11665 = iftmp.11;
      return D.11665;
    }
  finally
    {
      buf = {CLOBBER};
      val = {CLOBBER};
    }
}


fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  unsigned int D.11690;
  int D.11695;
  char * D.11697;
  unsigned int D.11698;
  unsigned int __n.12;
  unsigned int D.11700;
  unsigned int D.11703;

  D.11690 = __builtin_object_size (__s, 1);
  if (D.11690 != 4294967295) goto <D.11691>; else goto <D.11692>;
  <D.11691>:
  D.11695 = __builtin_constant_p (__n);
  if (D.11695 == 0) goto <D.11693>; else goto <D.11696>;
  <D.11696>:
  if (__n <= 0) goto <D.11693>; else goto <D.11694>;
  <D.11693>:
  D.11698 = __builtin_object_size (__s, 1);
  D.11697 = __fgets_chk (__s, D.11698, __n, __stream);
  return D.11697;
  <D.11694>:
  __n.12 = (unsigned int) __n;
  D.11700 = __builtin_object_size (__s, 1);
  if (__n.12 > D.11700) goto <D.11701>; else goto <D.11702>;
  <D.11701>:
  D.11703 = __builtin_object_size (__s, 1);
  D.11697 = __fgets_chk_warn (__s, D.11703, __n, __stream);
  return D.11697;
  <D.11702>:
  <D.11692>:
  D.11697 = __fgets_alias (__s, __n, __stream);
  return D.11697;
}


get_timer_overhead ()
{
  int D.11708;

  D.11708 = timer_overhead;
  return D.11708;
}


current_time ()
{
  uint64_t D.11710;
  uint64_t (*<T1cc9>) (void) time_func.13;

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


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

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


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

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

    D.11720 = (unsigned char) value;
    b = D.11720 & 127;
    value = value >> 7;
    if (value != 0) goto <D.11721>; else goto <D.11722>;
    <D.11721>:
    b = b | 128;
    <D.11722>:
    p.16 = p;
    p = p.16 + 1;
    *p.16 = b;
  }
  if (value != 0) goto <D.10343>; else goto <D.10344>;
  <D.10344>:
  *endbuf = p;
}


encode_sleb128 (intptr_t value, uint8_t * buf, uint8_t * * endbuf)
{
  _Bool D.11724;
  unsigned char D.11725;
  unsigned int D.11728;
  int D.11729;
  int D.11730;
  int D.11731;
  int D.11737;
  int D.11738;
  uint8_t * p.17;
  int more;
  int negative;
  unsigned int size;
  uint8_t byte;
  uint8_t * p;

  more = 1;
  D.11724 = value < 0;
  negative = (int) D.11724;
  size = 32;
  p = buf;
  goto <D.10356>;
  <D.10355>:
  D.11725 = (unsigned char) value;
  byte = D.11725 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.11726>; else goto <D.11727>;
  <D.11726>:
  D.11728 = size + 4294967289;
  D.11729 = (int) D.11728;
  D.11730 = 1 << D.11729;
  D.11731 = -D.11730;
  value = D.11731 | value;
  <D.11727>:
  if (value == 0) goto <D.11736>; else goto <D.11732>;
  <D.11736>:
  D.11737 = (int) byte;
  D.11738 = D.11737 & 64;
  if (D.11738 == 0) goto <D.11733>; else goto <D.11732>;
  <D.11732>:
  if (value == -1) goto <D.11739>; else goto <D.11734>;
  <D.11739>:
  D.11737 = (int) byte;
  D.11738 = D.11737 & 64;
  if (D.11738 != 0) goto <D.11733>; else goto <D.11734>;
  <D.11733>:
  more = 0;
  goto <D.11735>;
  <D.11734>:
  byte = byte | 128;
  <D.11735>:
  p.17 = p;
  p = p.17 + 1;
  *p.17 = byte;
  <D.10356>:
  if (more != 0) goto <D.10355>; else goto <D.10357>;
  <D.10357>:
  *endbuf = p;
}


decode_uleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  uint8_t * buf.18;
  long long unsigned int D.11742;
  long long unsigned int D.11743;
  long long unsigned int D.11744;
  signed char b.19;
  uint64_t D.11747;
  uint64_t res;
  int shift;

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

    buf.18 = buf;
    buf = buf.18 + 1;
    b = *buf.18;
    D.11742 = (long long unsigned int) b;
    D.11743 = D.11742 & 127;
    D.11744 = D.11743 << shift;
    res = D.11744 | res;
    b.19 = (signed char) b;
    if (b.19 >= 0) goto <D.10365>; else goto <D.11746>;
    <D.11746>:
    shift = shift + 7;
  }
  goto <D.10366>;
  <D.10365>:
  *endbuf = buf;
  D.11747 = res;
  return D.11747;
}


decode_sleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  int D.11749;
  int D.11750;
  int D.11751;
  signed char b.20;
  unsigned int shift.21;
  int D.11758;
  int D.11761;
  int D.11762;
  intptr_t D.11763;
  uint8_t * p;
  intptr_t res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.11749 = (int) b;
    D.11750 = D.11749 & 127;
    D.11751 = D.11750 << shift;
    res = D.11751 | res;
    shift = shift + 7;
    b.20 = (signed char) b;
    if (b.20 >= 0) goto <D.11753>; else goto <D.11754>;
    <D.11753>:
    shift.21 = (unsigned int) shift;
    if (shift.21 <= 31) goto <D.11756>; else goto <D.11757>;
    <D.11756>:
    D.11749 = (int) b;
    D.11758 = D.11749 & 64;
    if (D.11758 != 0) goto <D.11759>; else goto <D.11760>;
    <D.11759>:
    D.11761 = 1 << shift;
    D.11762 = -D.11761;
    res = D.11762 | res;
    <D.11760>:
    <D.11757>:
    goto <D.10375>;
    <D.11754>:
  }
  goto <D.10376>;
  <D.10375>:
  *endbuf = p;
  D.11763 = res;
  return D.11763;
}


thread_id ()
{
  uintptr_t D.11765;

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


process_id ()
{
  uintptr_t D.11767;
  int D.11768;

  D.11768 = getpid ();
  D.11767 = (uintptr_t) D.11768;
  return D.11767;
}


mono_profiler_startup_log (const char * desc)
{
  mono_profiler_startup (desc);
}


mono_profiler_startup (const char * desc)
{
  int D.11770;
  char D.11773;
  int D.11557;
  int iftmp.22;
  int D.11556;
  const char[5] * D.11793;
  unsigned char D.11794;
  int D.11795;
  unsigned char D.11796;
  int D.11797;
  _Bool D.11798;
  _Bool D.11799;
  _Bool D.11800;
  const unsigned char * D.11803;
  unsigned char D.11804;
  int D.11805;
  const unsigned char * D.11806;
  unsigned char D.11807;
  int D.11808;
  _Bool D.11809;
  _Bool D.11810;
  const unsigned char * D.11813;
  unsigned char D.11814;
  int D.11815;
  const unsigned char * D.11816;
  unsigned char D.11817;
  int D.11818;
  _Bool D.11819;
  _Bool D.11820;
  const unsigned char * D.11823;
  unsigned char D.11824;
  int D.11825;
  const unsigned char * D.11826;
  unsigned char D.11827;
  int D.11828;
  char * val.23;
  int D.11566;
  int iftmp.24;
  int D.11565;
  const char[5] * D.11837;
  unsigned char D.11838;
  int D.11839;
  unsigned char D.11840;
  int D.11841;
  _Bool D.11842;
  _Bool D.11843;
  _Bool D.11844;
  const unsigned char * D.11847;
  unsigned char D.11848;
  int D.11849;
  const unsigned char * D.11850;
  unsigned char D.11851;
  int D.11852;
  _Bool D.11853;
  _Bool D.11854;
  const unsigned char * D.11857;
  unsigned char D.11858;
  int D.11859;
  const unsigned char * D.11860;
  unsigned char D.11861;
  int D.11862;
  _Bool D.11863;
  _Bool D.11864;
  const unsigned char * D.11867;
  unsigned char D.11868;
  int D.11869;
  const unsigned char * D.11870;
  unsigned char D.11871;
  int D.11872;
  struct _IO_FILE * stderr.25;
  long unsigned int D.11894;
  int command_port.26;
  long unsigned int D.11898;
  int num_frames.27;
  int num_frames.28;
  _Bool D.11903;
  int notraces.29;
  long unsigned int D.11907;
  int max_call_depth.30;
  int do_mono_sample.31;
  int sample_type.32;
  <unnamed type> events.33;
  struct MonoProfiler * prof;
  char * filename;
  const char * p;
  const char * opt;
  int fast_time;
  int calls_enabled;
  int allocs_enabled;
  int events;

  filename = 0B;
  fast_time = 0;
  calls_enabled = 0;
  allocs_enabled = 0;
  events = 1709020;
  p = desc;
  D.11770 = strncmp (p, "log", 3);
  if (D.11770 != 0) goto <D.11771>; else goto <D.11772>;
  <D.11771>:
  usage (1);
  <D.11772>:
  p = p + 3;
  D.11773 = *p;
  if (D.11773 == 58) goto <D.11774>; else goto <D.11775>;
  <D.11774>:
  p = p + 1;
  <D.11775>:
  goto <D.11571>;
  <D.11570>:
  {
    char * val;

    try
      {
        D.11773 = *p;
        if (D.11773 == 44) goto <D.11776>; else goto <D.11777>;
        <D.11776>:
        opt = p + 1;
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11777>:
        opt = match_option (p, "help", 0B);
        if (opt != p) goto <D.11778>; else goto <D.11779>;
        <D.11778>:
        usage (0);
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11779>:
        opt = match_option (p, "calls", 0B);
        if (opt != p) goto <D.11780>; else goto <D.11781>;
        <D.11780>:
        calls_enabled = 1;
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11781>:
        opt = match_option (p, "nocalls", 0B);
        if (opt != p) goto <D.11782>; else goto <D.11783>;
        <D.11782>:
        events = events & -4097;
        nocalls = 1;
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11783>:
        opt = match_option (p, "alloc", 0B);
        if (opt != p) goto <D.11784>; else goto <D.11785>;
        <D.11784>:
        allocs_enabled = 1;
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11785>:
        opt = match_option (p, "noalloc", 0B);
        if (opt != p) goto <D.11786>; else goto <D.11787>;
        <D.11786>:
        events = events & -129;
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11787>:
        opt = match_option (p, "time", &val);
        if (opt != p) goto <D.11788>; else goto <D.11789>;
        <D.11788>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = val;
            D.11793 = "fast";
            D.11794 = MEM[(const unsigned char *)D.11793];
            D.11795 = (int) D.11794;
            D.11796 = *__s2;
            D.11797 = (int) D.11796;
            __result = D.11795 - D.11797;
            {
              D.11798 = __s2_len != 0;
              D.11799 = __result == 0;
              D.11800 = D.11798 & D.11799;
              if (D.11800 != 0) goto <D.11801>; else goto <D.11802>;
              <D.11801>:
              D.11803 = &MEM[(void *)"fast" + 1B];
              D.11804 = *D.11803;
              D.11805 = (int) D.11804;
              D.11806 = __s2 + 1;
              D.11807 = *D.11806;
              D.11808 = (int) D.11807;
              __result = D.11805 - D.11808;
              D.11809 = __s2_len > 1;
              D.11799 = __result == 0;
              D.11810 = D.11809 & D.11799;
              if (D.11810 != 0) goto <D.11811>; else goto <D.11812>;
              <D.11811>:
              D.11813 = &MEM[(void *)"fast" + 2B];
              D.11814 = *D.11813;
              D.11815 = (int) D.11814;
              D.11816 = __s2 + 2;
              D.11817 = *D.11816;
              D.11818 = (int) D.11817;
              __result = D.11815 - D.11818;
              D.11819 = __s2_len > 2;
              D.11799 = __result == 0;
              D.11820 = D.11819 & D.11799;
              if (D.11820 != 0) goto <D.11821>; else goto <D.11822>;
              <D.11821>:
              D.11823 = &MEM[(void *)"fast" + 3B];
              D.11824 = *D.11823;
              D.11825 = (int) D.11824;
              D.11826 = __s2 + 3;
              D.11827 = *D.11826;
              D.11828 = (int) D.11827;
              __result = D.11825 - D.11828;
              <D.11822>:
              <D.11812>:
              <D.11802>:
            }
            D.11556 = __result;
          }
          iftmp.22 = -D.11556;
          goto <D.11829>;
          <D.11792>:
          val.23 = val;
          iftmp.22 = __builtin_strcmp (val.23, "fast");
          <D.11829>:
          D.11557 = iftmp.22;
        }
        if (D.11557 == 0) goto <D.11831>; else goto <D.11832>;
        <D.11831>:
        fast_time = 1;
        goto <D.11833>;
        <D.11832>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = val;
            D.11837 = "null";
            D.11838 = MEM[(const unsigned char *)D.11837];
            D.11839 = (int) D.11838;
            D.11840 = *__s2;
            D.11841 = (int) D.11840;
            __result = D.11839 - D.11841;
            {
              D.11842 = __s2_len != 0;
              D.11843 = __result == 0;
              D.11844 = D.11842 & D.11843;
              if (D.11844 != 0) goto <D.11845>; else goto <D.11846>;
              <D.11845>:
              D.11847 = &MEM[(void *)"null" + 1B];
              D.11848 = *D.11847;
              D.11849 = (int) D.11848;
              D.11850 = __s2 + 1;
              D.11851 = *D.11850;
              D.11852 = (int) D.11851;
              __result = D.11849 - D.11852;
              D.11853 = __s2_len > 1;
              D.11843 = __result == 0;
              D.11854 = D.11853 & D.11843;
              if (D.11854 != 0) goto <D.11855>; else goto <D.11856>;
              <D.11855>:
              D.11857 = &MEM[(void *)"null" + 2B];
              D.11858 = *D.11857;
              D.11859 = (int) D.11858;
              D.11860 = __s2 + 2;
              D.11861 = *D.11860;
              D.11862 = (int) D.11861;
              __result = D.11859 - D.11862;
              D.11863 = __s2_len > 2;
              D.11843 = __result == 0;
              D.11864 = D.11863 & D.11843;
              if (D.11864 != 0) goto <D.11865>; else goto <D.11866>;
              <D.11865>:
              D.11867 = &MEM[(void *)"null" + 3B];
              D.11868 = *D.11867;
              D.11869 = (int) D.11868;
              D.11870 = __s2 + 3;
              D.11871 = *D.11870;
              D.11872 = (int) D.11871;
              __result = D.11869 - D.11872;
              <D.11866>:
              <D.11856>:
              <D.11846>:
            }
            D.11565 = __result;
          }
          iftmp.24 = -D.11565;
          goto <D.11873>;
          <D.11836>:
          val.23 = val;
          iftmp.24 = __builtin_strcmp (val.23, "null");
          <D.11873>:
          D.11566 = iftmp.24;
        }
        if (D.11566 == 0) goto <D.11874>; else goto <D.11875>;
        <D.11874>:
        fast_time = 2;
        goto <D.11876>;
        <D.11875>:
        usage (1);
        <D.11876>:
        <D.11833>:
        val.23 = val;
        free (val.23);
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11789>:
        opt = match_option (p, "report", 0B);
        if (opt != p) goto <D.11877>; else goto <D.11878>;
        <D.11877>:
        do_report = 1;
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11878>:
        opt = match_option (p, "debug", 0B);
        if (opt != p) goto <D.11879>; else goto <D.11880>;
        <D.11879>:
        do_debug = 1;
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11880>:
        opt = match_option (p, "heapshot", &val);
        if (opt != p) goto <D.11881>; else goto <D.11882>;
        <D.11881>:
        events = events & -129;
        events = events & -4097;
        nocalls = 1;
        do_heap_shot = 1;
        val.23 = val;
        set_hsmode (val.23, 1);
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11882>:
        opt = match_option (p, "sample", &val);
        if (opt != p) goto <D.11883>; else goto <D.11884>;
        <D.11883>:
        events = events & -129;
        events = events & -4097;
        nocalls = 1;
        val.23 = val;
        set_sample_mode (val.23, 1);
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11884>:
        opt = match_option (p, "hsmode", &val);
        if (opt != p) goto <D.11885>; else goto <D.11886>;
        <D.11885>:
        stderr.25 = stderr;
        fprintf (stderr.25, "The hsmode profiler option is obsolete, use heapshot=MODE.\n");
        val.23 = val;
        set_hsmode (val.23, 0);
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11886>:
        opt = match_option (p, "zip", 0B);
        if (opt != p) goto <D.11888>; else goto <D.11889>;
        <D.11888>:
        use_zip = 1;
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11889>:
        opt = match_option (p, "output", &val);
        if (opt != p) goto <D.11890>; else goto <D.11891>;
        <D.11890>:
        filename = val;
        // predicted unlikely by continue predictor.
        goto <D.11548>;
        <D.11891>:
        opt = match_option (p, "port", &val);
        if (opt != p) goto <D.11892>; else goto <D.11893>;
        <D.11892>:
        {
          char * end;

          try
            {
              val.23 = val;
              D.11894 = strtoul (val.23, &end, 10);
              command_port.26 = (int) D.11894;
              command_port = command_port.26;
              val.23 = val;
              free (val.23);
              // predicted unlikely by continue predictor.
              goto <D.11548>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.11893>:
        opt = match_option (p, "maxframes", &val);
        if (opt != p) goto <D.11896>; else goto <D.11897>;
        <D.11896>:
        {
          char * end;

          try
            {
              val.23 = val;
              D.11898 = strtoul (val.23, &end, 10);
              num_frames.27 = (int) D.11898;
              num_frames = num_frames.27;
              num_frames.28 = num_frames;
              if (num_frames.28 > 16) goto <D.11901>; else goto <D.11902>;
              <D.11901>:
              num_frames = 16;
              <D.11902>:
              val.23 = val;
              free (val.23);
              num_frames.28 = num_frames;
              D.11903 = num_frames.28 == 0;
              notraces.29 = (int) D.11903;
              notraces = notraces.29;
              // predicted unlikely by continue predictor.
              goto <D.11548>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.11897>:
        opt = match_option (p, "calldepth", &val);
        if (opt != p) goto <D.11905>; else goto <D.11906>;
        <D.11905>:
        {
          char * end;

          try
            {
              val.23 = val;
              D.11907 = strtoul (val.23, &end, 10);
              max_call_depth.30 = (int) D.11907;
              max_call_depth = max_call_depth.30;
              val.23 = val;
              free (val.23);
              // predicted unlikely by continue predictor.
              goto <D.11548>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.11906>:
        if (opt == p) goto <D.11909>; else goto <D.11910>;
        <D.11909>:
        usage (0);
        exit (0);
        <D.11910>:
      }
    finally
      {
        val = {CLOBBER};
      }
  }
  <D.11548>:
  p = opt;
  <D.11571>:
  D.11773 = *p;
  if (D.11773 != 0) goto <D.11570>; else goto <D.11572>;
  <D.11572>:
  if (calls_enabled != 0) goto <D.11911>; else goto <D.11912>;
  <D.11911>:
  events = events | 4096;
  nocalls = 0;
  <D.11912>:
  if (allocs_enabled != 0) goto <D.11913>; else goto <D.11914>;
  <D.11913>:
  events = events | 128;
  <D.11914>:
  utils_init (fast_time);
  prof = create_profiler (filename);
  if (prof == 0B) goto <D.11915>; else goto <D.11916>;
  <D.11915>:
  return;
  <D.11916>:
  init_thread ();
  mono_profiler_install (prof, log_shutdown);
  mono_profiler_install_gc (gc_event, gc_resize);
  mono_profiler_install_allocation (gc_alloc);
  mono_profiler_install_gc_moves (gc_moves);
  mono_profiler_install_gc_roots (gc_handle, gc_roots);
  mono_profiler_install_class (0B, class_loaded, 0B, 0B);
  mono_profiler_install_module (0B, image_loaded, 0B, 0B);
  mono_profiler_install_thread (thread_start, thread_end);
  mono_profiler_install_thread_name (thread_name);
  mono_profiler_install_enter_leave (method_enter, method_leave);
  mono_profiler_install_jit_end (method_jitted);
  mono_profiler_install_exception (throw_exc, method_exc_leave, clause_exc);
  mono_profiler_install_monitor (monitor_event);
  mono_profiler_install_runtime_initialized (runtime_initialized);
  do_mono_sample.31 = do_mono_sample;
  if (do_mono_sample.31 != 0) goto <D.11918>; else goto <D.11919>;
  <D.11918>:
  sample_type.32 = sample_type;
  if (sample_type.32 == 1) goto <D.11921>; else goto <D.11922>;
  <D.11921>:
  events = events | 32768;
  mono_profiler_install_statistical (mono_sample_hit);
  <D.11922>:
  <D.11919>:
  events.33 = (<unnamed type>) events;
  mono_profiler_set_events (events.33);
}


mono_sample_hit (struct MonoProfiler * profiler, unsigned char * ip, void * context)
{
  int in_shutdown.34;
  int do_debug.35;
  unsigned int D.11954;
  void * D.11955;
  unsigned int D.11956;
  unsigned int len.36;
  uintptr_t * D.11960;
  uintptr_t * D.11961;
  uintptr_t * D.11962;
  struct StatBuffer * D.11965;
  struct StatBuffer * D.11968;
  struct StatBuffer * D.11969;
  int D.11972;
  uintptr_t * * D.11975;
  int sample_type.37;
  int D.11979;
  int D.11980;
  unsigned int D.11981;
  uintptr_t * D.11982;
  unsigned int D.11983;
  uintptr_t * D.11984;
  long long unsigned int D.11985;
  long long unsigned int D.11986;
  long long unsigned int D.11987;
  unsigned int D.11988;
  uintptr_t * D.11989;
  unsigned int ip.38;
  struct StatBuffer * sbuf;
  uint64_t now;
  uintptr_t * data;
  uintptr_t * new_data;
  uintptr_t * old_data;

  in_shutdown.34 = in_shutdown;
  if (in_shutdown.34 != 0) goto <D.11949>; else goto <D.11950>;
  <D.11949>:
  return;
  <D.11950>:
  now = current_time ();
  do_debug.35 = do_debug;
  if (do_debug.35 != 0) goto <D.11952>; else goto <D.11953>;
  <D.11952>:
  {
    int len;
    char buf[256];

    try
      {
        D.11954 = thread_id ();
        D.11955 = (void *) D.11954;
        snprintf (&buf, 256, "hit at %p in thread %p at %llu\n", ip, D.11955, now);
        D.11956 = strlen (&buf);
        len = (int) D.11956;
        len.36 = (unsigned int) len;
        write (2, &buf, len.36);
      }
    finally
      {
        buf = {CLOBBER};
      }
  }
  <D.11953>:
  sbuf = profiler->stat_buffers;
  if (sbuf == 0B) goto <D.11958>; else goto <D.11959>;
  <D.11958>:
  return;
  <D.11959>:
  D.11960 = sbuf->data;
  D.11961 = D.11960 + 1600;
  D.11962 = sbuf->data_end;
  if (D.11961 >= D.11962) goto <D.11963>; else goto <D.11964>;
  <D.11963>:
  sbuf = create_stat_buffer ();
  D.11965 = profiler->stat_buffers;
  sbuf->next = D.11965;
  profiler->stat_buffers = sbuf;
  do_debug.35 = do_debug;
  if (do_debug.35 != 0) goto <D.11966>; else goto <D.11967>;
  <D.11966>:
  write (2, "overflow\n", 9);
  <D.11967>:
  D.11968 = sbuf->next;
  D.11969 = D.11968->next;
  if (D.11969 != 0B) goto <D.11970>; else goto <D.11971>;
  <D.11970>:
  {
    char c;

    try
      {
        c = 0;
        D.11972 = profiler->pipes[1];
        write (D.11972, &c, 1);
        do_debug.35 = do_debug;
        if (do_debug.35 != 0) goto <D.11973>; else goto <D.11974>;
        <D.11973>:
        write (2, "notify\n", 7);
        <D.11974>:
      }
    finally
      {
        c = {CLOBBER};
      }
  }
  <D.11971>:
  <D.11964>:
  <D.11098>:
  old_data = sbuf->data;
  new_data = old_data + 16;
  D.11975 = &sbuf->data;
  data = InterlockedCompareExchangePointer (D.11975, new_data, old_data);
  if (data != old_data) goto <D.11098>; else goto <D.11099>;
  <D.11099>:
  D.11962 = sbuf->data_end;
  if (D.11962 <= old_data) goto <D.11976>; else goto <D.11977>;
  <D.11976>:
  return;
  <D.11977>:
  sample_type.37 = sample_type;
  D.11979 = sample_type.37 << 16;
  D.11980 = D.11979 | 1;
  D.11981 = (unsigned int) D.11980;
  *old_data = D.11981;
  D.11982 = old_data + 4;
  D.11983 = thread_id ();
  *D.11982 = D.11983;
  D.11984 = old_data + 8;
  D.11985 = profiler->startup_time;
  D.11986 = now - D.11985;
  D.11987 = D.11986 / 10000;
  D.11988 = (unsigned int) D.11987;
  *D.11984 = D.11988;
  D.11989 = old_data + 12;
  ip.38 = (unsigned int) ip;
  *D.11989 = ip.38;
}


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

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


create_stat_buffer ()
{
  unsigned int D.12004;
  uintptr_t * D.12005;
  uintptr_t[1] * D.12006;
  struct StatBuffer * D.12007;
  struct StatBuffer * buf;

  buf = alloc_buffer (65536);
  buf->size = 65536;
  D.12004 = buf->size;
  D.12005 = buf + D.12004;
  buf->data_end = D.12005;
  D.12006 = &buf->buf;
  buf->data = D.12006;
  D.12007 = buf;
  return D.12007;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.12010;
  unsigned int exch.39;
  unsigned int comp.40;
  unsigned int D.12013;

  exch.39 = (unsigned int) exch;
  comp.40 = (unsigned int) comp;
  D.12013 = __sync_val_compare_and_swap_4 (dest, comp.40, exch.39);
  D.12010 = (void *) D.12013;
  return D.12010;
}


runtime_initialized (struct MonoProfiler * profiler)
{
  runtime_inited = 1;
}


monitor_event (struct MonoProfiler * profiler, struct MonoObject * object, MonoProfilerMonitorEvent event)
{
  int iftmp.41;
  int nocalls.42;
  int runtime_inited.43;
  int notraces.44;
  int D.12027;
  int D.12030;
  unsigned int D.12031;
  unsigned int do_bt.45;
  unsigned int D.12033;
  unsigned int D.12034;
  int D.12035;
  int D.12038;
  int do_bt;
  uint64_t now;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.42 = nocalls;
      if (nocalls.42 != 0) goto <D.12019>; else goto <D.12016>;
      <D.12019>:
      runtime_inited.43 = runtime_inited;
      if (runtime_inited.43 != 0) goto <D.12021>; else goto <D.12016>;
      <D.12021>:
      notraces.44 = notraces;
      if (notraces.44 == 0) goto <D.12023>; else goto <D.12016>;
      <D.12023>:
      if (event == 1) goto <D.12024>; else goto <D.12016>;
      <D.12024>:
      iftmp.41 = 128;
      goto <D.12017>;
      <D.12016>:
      iftmp.41 = 0;
      <D.12017>:
      do_bt = iftmp.41;
      if (do_bt != 0) goto <D.12025>; else goto <D.12026>;
      <D.12025>:
      collect_bt (&data);
      <D.12026>:
      logbuffer = ensure_logbuf (144);
      now = current_time ();
      D.12027 = logbuffer->locked;
      if (D.12027 != 0) goto <D.12028>; else goto <D.12029>;
      <D.12028>:
      write (2, "monitor", 7);
      write (2, "\n", 1);
      return;
      <D.12029>:
      D.12027 = logbuffer->locked;
      D.12030 = D.12027 + 1;
      logbuffer->locked = D.12030;
      D.12031 = event << 4;
      do_bt.45 = (unsigned int) do_bt;
      D.12033 = D.12031 | do_bt.45;
      D.12034 = D.12033 | 5;
      D.12035 = (int) D.12034;
      emit_byte (logbuffer, D.12035);
      emit_time (logbuffer, now);
      emit_obj (logbuffer, object);
      if (do_bt != 0) goto <D.12036>; else goto <D.12037>;
      <D.12036>:
      emit_bt (logbuffer, &data);
      <D.12037>:
      D.12027 = logbuffer->locked;
      D.12038 = D.12027 + -1;
      logbuffer->locked = D.12038;
      process_requests (profiler);
    }
  finally
    {
      data = {CLOBBER};
    }
}


collect_bt (struct FrameData * data)
{
  data->count = 0;
  mono_stack_walk_no_il (walk_stack, data);
}


walk_stack (struct MonoMethod * method, int32_t native_offset, int32_t il_offset, mono_bool managed, void * data)
{
  int D.12047;
  int num_frames.46;
  int D.12051;
  int D.12052;
  mono_bool D.12053;
  _Bool D.12054;
  struct FrameData * frame;

  frame = data;
  if (method != 0B) goto <D.12045>; else goto <D.12046>;
  <D.12045>:
  D.12047 = frame->count;
  num_frames.46 = num_frames;
  if (D.12047 < num_frames.46) goto <D.12049>; else goto <D.12050>;
  <D.12049>:
  D.12047 = frame->count;
  D.12051 = D.12047;
  D.12052 = D.12051 + 1;
  frame->count = D.12052;
  frame->methods[D.12051] = method;
  <D.12050>:
  <D.12046>:
  D.12047 = frame->count;
  num_frames.46 = num_frames;
  D.12054 = D.12047 == num_frames.46;
  D.12053 = (mono_bool) D.12054;
  return D.12053;
}


ensure_logbuf (int bytes)
{
  unsigned char * D.12058;
  sizetype bytes.47;
  sizetype D.12060;
  unsigned char * D.12061;
  unsigned char * D.12062;
  struct LogBuffer * D.12065;
  struct LogBuffer * tlsbuffer.48;
  int D.12069;
  struct LogBuffer * old;

  old = tlsbuffer;
  if (old != 0B) goto <D.12056>; else goto <D.12057>;
  <D.12056>:
  D.12058 = old->data;
  bytes.47 = (sizetype) bytes;
  D.12060 = bytes.47 + 100;
  D.12061 = D.12058 + D.12060;
  D.12062 = old->data_end;
  if (D.12061 < D.12062) goto <D.12063>; else goto <D.12064>;
  <D.12063>:
  D.12065 = old;
  return D.12065;
  <D.12064>:
  <D.12057>:
  tlsbuffer = 0B;
  init_thread ();
  tlsbuffer.48 = tlsbuffer;
  tlsbuffer.48->next = old;
  if (old != 0B) goto <D.12067>; else goto <D.12068>;
  <D.12067>:
  tlsbuffer.48 = tlsbuffer;
  D.12069 = old->call_depth;
  tlsbuffer.48->call_depth = D.12069;
  <D.12068>:
  D.12065 = tlsbuffer;
  return D.12065;
}


emit_byte (struct LogBuffer * logbuffer, int value)
{
  unsigned char * D.12071;
  unsigned char D.12072;
  unsigned char * D.12073;
  unsigned char * D.12074;
  static const char __PRETTY_FUNCTION__[10] = "emit_byte";

  D.12071 = logbuffer->data;
  D.12072 = (unsigned char) value;
  *D.12071 = D.12072;
  D.12071 = logbuffer->data;
  D.12073 = D.12071 + 1;
  logbuffer->data = D.12073;
  D.12071 = logbuffer->data;
  D.12074 = logbuffer->data_end;
  if (D.12071 > D.12074) goto <D.12075>; else goto <D.12076>;
  <D.12075>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 443, &__PRETTY_FUNCTION__);
  <D.12076>:
}


emit_time (struct LogBuffer * logbuffer, uint64_t value)
{
  long long unsigned int D.12077;
  unsigned char * * D.12080;
  unsigned char * D.12081;
  unsigned char * D.12082;
  uint64_t tdiff;
  unsigned char * p;
  static const char __PRETTY_FUNCTION__[10] = "emit_time";

  D.12077 = logbuffer->last_time;
  tdiff = value - D.12077;
  D.12077 = logbuffer->last_time;
  if (D.12077 > value) goto <D.12078>; else goto <D.12079>;
  <D.12078>:
  printf ("time went backwards\n");
  <D.12079>:
  p = logbuffer->data;
  D.12080 = &logbuffer->data;
  D.12081 = logbuffer->data;
  encode_uleb128 (tdiff, D.12081, D.12080);
  logbuffer->last_time = value;
  D.12081 = logbuffer->data;
  D.12082 = logbuffer->data_end;
  if (D.12081 > D.12082) goto <D.12083>; else goto <D.12084>;
  <D.12083>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 467, &__PRETTY_FUNCTION__);
  <D.12084>:
}


emit_obj (struct LogBuffer * logbuffer, void * ptr)
{
  unsigned int D.12085;
  unsigned int ptr.49;
  unsigned int D.12089;
  unsigned int D.12090;
  long long int D.12091;
  unsigned char * D.12092;
  unsigned char * D.12093;
  static const char __PRETTY_FUNCTION__[9] = "emit_obj";

  D.12085 = logbuffer->obj_base;
  if (D.12085 == 0) goto <D.12086>; else goto <D.12087>;
  <D.12086>:
  ptr.49 = (unsigned int) ptr;
  D.12089 = ptr.49 >> 3;
  logbuffer->obj_base = D.12089;
  <D.12087>:
  ptr.49 = (unsigned int) ptr;
  D.12089 = ptr.49 >> 3;
  D.12085 = logbuffer->obj_base;
  D.12090 = D.12089 - D.12085;
  D.12091 = (long long int) D.12090;
  emit_svalue (logbuffer, D.12091);
  D.12092 = logbuffer->data;
  D.12093 = logbuffer->data_end;
  if (D.12092 > D.12093) goto <D.12094>; else goto <D.12095>;
  <D.12094>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 511, &__PRETTY_FUNCTION__);
  <D.12095>:
}


emit_svalue (struct LogBuffer * logbuffer, int64_t value)
{
  unsigned char * * D.12096;
  unsigned char * D.12097;
  int D.12098;
  unsigned char * D.12099;
  static const char __PRETTY_FUNCTION__[12] = "emit_svalue";

  D.12096 = &logbuffer->data;
  D.12097 = logbuffer->data;
  D.12098 = (int) value;
  encode_sleb128 (D.12098, D.12097, D.12096);
  D.12097 = logbuffer->data;
  D.12099 = logbuffer->data_end;
  if (D.12097 > D.12099) goto <D.12100>; else goto <D.12101>;
  <D.12100>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 474, &__PRETTY_FUNCTION__);
  <D.12101>:
}


emit_bt (struct LogBuffer * logbuffer, struct FrameData * data)
{
  int D.12102;
  int num_frames.50;
  int D.12106;
  struct MonoMethod * D.12107;

  D.12102 = data->count;
  num_frames.50 = num_frames;
  if (D.12102 > num_frames.50) goto <D.12104>; else goto <D.12105>;
  <D.12104>:
  D.12102 = data->count;
  printf ("bad num frames: %d\n", D.12102);
  <D.12105>:
  emit_value (logbuffer, 0);
  D.12102 = data->count;
  emit_value (logbuffer, D.12102);
  goto <D.10941>;
  <D.10940>:
  D.12102 = data->count;
  D.12106 = D.12102 + -1;
  data->count = D.12106;
  D.12102 = data->count;
  D.12107 = data->methods[D.12102];
  emit_ptr (logbuffer, D.12107);
  <D.10941>:
  D.12102 = data->count;
  if (D.12102 != 0) goto <D.10940>; else goto <D.10942>;
  <D.10942>:
}


emit_value (struct LogBuffer * logbuffer, int value)
{
  unsigned char * * D.12108;
  unsigned char * D.12109;
  long long unsigned int D.12110;
  unsigned char * D.12111;
  static const char __PRETTY_FUNCTION__[11] = "emit_value";

  D.12108 = &logbuffer->data;
  D.12109 = logbuffer->data;
  D.12110 = (long long unsigned int) value;
  encode_uleb128 (D.12110, D.12109, D.12108);
  D.12109 = logbuffer->data;
  D.12111 = logbuffer->data_end;
  if (D.12109 > D.12111) goto <D.12112>; else goto <D.12113>;
  <D.12112>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 450, &__PRETTY_FUNCTION__);
  <D.12113>:
}


emit_ptr (struct LogBuffer * logbuffer, void * ptr)
{
  unsigned int D.12114;
  unsigned int ptr.51;
  unsigned int ptr.52;
  unsigned int D.12119;
  long long int D.12120;
  unsigned char * D.12121;
  unsigned char * D.12122;
  static const char __PRETTY_FUNCTION__[9] = "emit_ptr";

  D.12114 = logbuffer->ptr_base;
  if (D.12114 == 0) goto <D.12115>; else goto <D.12116>;
  <D.12115>:
  ptr.51 = (unsigned int) ptr;
  logbuffer->ptr_base = ptr.51;
  <D.12116>:
  ptr.52 = (unsigned int) ptr;
  D.12114 = logbuffer->ptr_base;
  D.12119 = ptr.52 - D.12114;
  D.12120 = (long long int) D.12119;
  emit_svalue (logbuffer, D.12120);
  D.12121 = logbuffer->data;
  D.12122 = logbuffer->data_end;
  if (D.12121 > D.12122) goto <D.12123>; else goto <D.12124>;
  <D.12123>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 490, &__PRETTY_FUNCTION__);
  <D.12124>:
}


process_requests (struct MonoProfiler * profiler)
{
  int heapshot_requested.53;
  int D.12128;

  heapshot_requested.53 = heapshot_requested;
  if (heapshot_requested.53 != 0) goto <D.12126>; else goto <D.12127>;
  <D.12126>:
  D.12128 = mono_gc_max_generation ();
  mono_gc_collect (D.12128);
  <D.12127>:
}


clause_exc (struct MonoProfiler * prof, struct MonoMethod * method, int clause_type, int clause_num)
{
  int D.12130;
  int D.12133;
  int D.12134;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  now = current_time ();
  D.12130 = logbuffer->locked;
  if (D.12130 != 0) goto <D.12131>; else goto <D.12132>;
  <D.12131>:
  write (2, "clause", 6);
  write (2, "\n", 1);
  return;
  <D.12132>:
  D.12130 = logbuffer->locked;
  D.12133 = D.12130 + 1;
  logbuffer->locked = D.12133;
  emit_byte (logbuffer, 20);
  emit_time (logbuffer, now);
  emit_value (logbuffer, clause_type);
  emit_value (logbuffer, clause_num);
  emit_method (logbuffer, method);
  D.12130 = logbuffer->locked;
  D.12134 = D.12130 + -1;
  logbuffer->locked = D.12134;
}


emit_method (struct LogBuffer * logbuffer, void * method)
{
  unsigned int D.12138;
  unsigned int method.54;
  unsigned char * * D.12142;
  unsigned char * D.12143;
  int method.55;
  unsigned int D.12145;
  int D.12146;
  int D.12147;
  unsigned char * D.12148;
  static const char __PRETTY_FUNCTION__[12] = "emit_method";

  D.12138 = logbuffer->method_base;
  if (D.12138 == 0) goto <D.12139>; else goto <D.12140>;
  <D.12139>:
  method.54 = (unsigned int) method;
  logbuffer->method_base = method.54;
  method.54 = (unsigned int) method;
  logbuffer->last_method = method.54;
  <D.12140>:
  D.12142 = &logbuffer->data;
  D.12143 = logbuffer->data;
  method.55 = (int) method;
  D.12145 = logbuffer->last_method;
  D.12146 = (int) D.12145;
  D.12147 = method.55 - D.12146;
  encode_sleb128 (D.12147, D.12143, D.12142);
  method.54 = (unsigned int) method;
  logbuffer->last_method = method.54;
  D.12143 = logbuffer->data;
  D.12148 = logbuffer->data_end;
  if (D.12143 > D.12148) goto <D.12149>; else goto <D.12150>;
  <D.12149>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 502, &__PRETTY_FUNCTION__);
  <D.12150>:
}


method_exc_leave (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int nocalls.56;
  int D.12154;
  int D.12155;
  int max_call_depth.57;
  int D.12159;
  int D.12162;
  int D.12163;
  uint64_t now;
  struct LogBuffer * logbuffer;

  nocalls.56 = nocalls;
  if (nocalls.56 != 0) goto <D.12152>; else goto <D.12153>;
  <D.12152>:
  return;
  <D.12153>:
  logbuffer = ensure_logbuf (16);
  D.12154 = logbuffer->call_depth;
  D.12155 = D.12154 + -1;
  logbuffer->call_depth = D.12155;
  D.12154 = logbuffer->call_depth;
  max_call_depth.57 = max_call_depth;
  if (D.12154 > max_call_depth.57) goto <D.12157>; else goto <D.12158>;
  <D.12157>:
  return;
  <D.12158>:
  now = current_time ();
  D.12159 = logbuffer->locked;
  if (D.12159 != 0) goto <D.12160>; else goto <D.12161>;
  <D.12160>:
  write (2, "eleave", 6);
  write (2, "\n", 1);
  return;
  <D.12161>:
  D.12159 = logbuffer->locked;
  D.12162 = D.12159 + 1;
  logbuffer->locked = D.12162;
  emit_byte (logbuffer, 51);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12159 = logbuffer->locked;
  D.12163 = D.12159 + -1;
  logbuffer->locked = D.12163;
  process_requests (prof);
}


throw_exc (struct MonoProfiler * prof, struct MonoObject * object)
{
  int iftmp.58;
  int nocalls.59;
  int runtime_inited.60;
  int notraces.61;
  int D.12178;
  int D.12181;
  int D.12182;
  int D.12185;
  int do_bt;
  uint64_t now;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.59 = nocalls;
      if (nocalls.59 != 0) goto <D.12171>; else goto <D.12168>;
      <D.12171>:
      runtime_inited.60 = runtime_inited;
      if (runtime_inited.60 != 0) goto <D.12173>; else goto <D.12168>;
      <D.12173>:
      notraces.61 = notraces;
      if (notraces.61 == 0) goto <D.12175>; else goto <D.12168>;
      <D.12175>:
      iftmp.58 = 128;
      goto <D.12169>;
      <D.12168>:
      iftmp.58 = 0;
      <D.12169>:
      do_bt = iftmp.58;
      if (do_bt != 0) goto <D.12176>; else goto <D.12177>;
      <D.12176>:
      collect_bt (&data);
      <D.12177>:
      logbuffer = ensure_logbuf (144);
      now = current_time ();
      D.12178 = logbuffer->locked;
      if (D.12178 != 0) goto <D.12179>; else goto <D.12180>;
      <D.12179>:
      write (2, "throw", 5);
      write (2, "\n", 1);
      return;
      <D.12180>:
      D.12178 = logbuffer->locked;
      D.12181 = D.12178 + 1;
      logbuffer->locked = D.12181;
      D.12182 = do_bt | 4;
      emit_byte (logbuffer, D.12182);
      emit_time (logbuffer, now);
      emit_obj (logbuffer, object);
      if (do_bt != 0) goto <D.12183>; else goto <D.12184>;
      <D.12183>:
      emit_bt (logbuffer, &data);
      <D.12184>:
      D.12178 = logbuffer->locked;
      D.12185 = D.12178 + -1;
      logbuffer->locked = D.12185;
      process_requests (prof);
    }
  finally
    {
      data = {CLOBBER};
    }
}


method_jitted (struct MonoProfiler * prof, struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  unsigned int D.12194;
  unsigned int D.12195;
  int D.12196;
  int D.12197;
  int D.12200;
  void * D.12201;
  int D.12202;
  unsigned int nlen.62;
  unsigned char * D.12204;
  sizetype nlen.63;
  unsigned char * D.12206;
  int D.12207;
  struct LogBuffer * D.12208;
  uint64_t now;
  char * name;
  int nlen;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.12192>; else goto <D.12193>;
  <D.12192>:
  return;
  <D.12193>:
  name = mono_method_full_name (method, 1);
  D.12194 = strlen (name);
  D.12195 = D.12194 + 1;
  nlen = (int) D.12195;
  D.12196 = nlen + 32;
  logbuffer = ensure_logbuf (D.12196);
  now = current_time ();
  D.12197 = logbuffer->locked;
  if (D.12197 != 0) goto <D.12198>; else goto <D.12199>;
  <D.12198>:
  write (2, "jit", 3);
  write (2, "\n", 1);
  return;
  <D.12199>:
  D.12197 = logbuffer->locked;
  D.12200 = D.12197 + 1;
  logbuffer->locked = D.12200;
  emit_byte (logbuffer, 67);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12201 = mono_jit_info_get_code_start (jinfo);
  emit_ptr (logbuffer, D.12201);
  D.12202 = mono_jit_info_get_code_size (jinfo);
  emit_value (logbuffer, D.12202);
  nlen.62 = (unsigned int) nlen;
  D.12204 = logbuffer->data;
  memcpy (D.12204, name, nlen.62);
  D.12204 = logbuffer->data;
  nlen.63 = (sizetype) nlen;
  D.12206 = D.12204 + nlen.63;
  logbuffer->data = D.12206;
  mono_free (name);
  D.12197 = logbuffer->locked;
  D.12207 = D.12197 + -1;
  logbuffer->locked = D.12207;
  D.12208 = logbuffer->next;
  if (D.12208 != 0B) goto <D.12209>; else goto <D.12210>;
  <D.12209>:
  safe_dump (prof, logbuffer);
  <D.12210>:
  process_requests (prof);
}


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

  D.12218 = __builtin_object_size (__dest, 0);
  D.12217 = __builtin___memcpy_chk (__dest, __src, __len, D.12218);
  return D.12217;
}


safe_dump (struct MonoProfiler * profiler, struct LogBuffer * logbuffer)
{
  struct LogBuffer * tlsbuffer.64;
  int cd;

  cd = logbuffer->call_depth;
  take_lock ();
  tlsbuffer.64 = tlsbuffer;
  dump_buffer (profiler, tlsbuffer.64);
  release_lock ();
  tlsbuffer = 0B;
  init_thread ();
  tlsbuffer.64 = tlsbuffer;
  tlsbuffer.64->call_depth = cd;
}


dump_buffer (struct MonoProfiler * profiler, struct LogBuffer * buf)
{
  struct LogBuffer * D.12221;
  unsigned char * D.12224;
  int D.12225;
  unsigned char[1] * D.12226;
  int D.12227;
  int D.12228;
  long long unsigned int D.12229;
  long long int D.12230;
  unsigned int D.12231;
  long long int D.12232;
  unsigned int D.12233;
  long long int D.12234;
  unsigned int D.12235;
  long long int D.12236;
  unsigned int D.12237;
  long long int D.12238;
  struct FILE * D.12239;
  int p.65;
  int hbuf.66;
  int D.12242;
  unsigned int D.12243;
  unsigned int D.12244;
  int D.12245;
  char hbuf[128];
  char * p;

  try
    {
      p = &hbuf;
      D.12221 = buf->next;
      if (D.12221 != 0B) goto <D.12222>; else goto <D.12223>;
      <D.12222>:
      D.12221 = buf->next;
      dump_buffer (profiler, D.12221);
      <D.12223>:
      p = write_int32 (p, 1297107969);
      D.12224 = buf->data;
      D.12225 = (int) D.12224;
      D.12226 = &buf->buf;
      D.12227 = (int) D.12226;
      D.12228 = D.12225 - D.12227;
      p = write_int32 (p, D.12228);
      D.12229 = buf->time_base;
      D.12230 = (long long int) D.12229;
      p = write_int64 (p, D.12230);
      D.12231 = buf->ptr_base;
      D.12232 = (long long int) D.12231;
      p = write_int64 (p, D.12232);
      D.12233 = buf->obj_base;
      D.12234 = (long long int) D.12233;
      p = write_int64 (p, D.12234);
      D.12235 = buf->thread_id;
      D.12236 = (long long int) D.12235;
      p = write_int64 (p, D.12236);
      D.12237 = buf->method_base;
      D.12238 = (long long int) D.12237;
      p = write_int64 (p, D.12238);
      D.12239 = profiler->file;
      p.65 = (int) p;
      hbuf.66 = (int) &hbuf;
      D.12242 = p.65 - hbuf.66;
      D.12243 = (unsigned int) D.12242;
      fwrite (&hbuf, D.12243, 1, D.12239);
      D.12239 = profiler->file;
      D.12224 = buf->data;
      D.12225 = (int) D.12224;
      D.12226 = &buf->buf;
      D.12227 = (int) D.12226;
      D.12228 = D.12225 - D.12227;
      D.12244 = (unsigned int) D.12228;
      D.12226 = &buf->buf;
      fwrite (D.12226, D.12244, 1, D.12239);
      D.12239 = profiler->file;
      fflush (D.12239);
      D.12245 = buf->size;
      free_buffer (buf, D.12245);
    }
  finally
    {
      hbuf = {CLOBBER};
    }
}


write_int32 (char * buf, int32_t value)
{
  sizetype i.67;
  char * D.12256;
  char D.12257;
  char * D.12258;
  int i;

  i = 0;
  goto <D.10849>;
  <D.10848>:
  i.67 = (sizetype) i;
  D.12256 = buf + i.67;
  D.12257 = (char) value;
  *D.12256 = D.12257;
  value = value >> 8;
  i = i + 1;
  <D.10849>:
  if (i <= 3) goto <D.10848>; else goto <D.10850>;
  <D.10850>:
  D.12258 = buf + 4;
  return D.12258;
}


write_int64 (char * buf, int64_t value)
{
  sizetype i.68;
  char * D.12261;
  char D.12262;
  char * D.12263;
  int i;

  i = 0;
  goto <D.10857>;
  <D.10856>:
  i.68 = (sizetype) i;
  D.12261 = buf + i.68;
  D.12262 = (char) value;
  *D.12261 = D.12262;
  value = value >> 8;
  i = i + 1;
  <D.10857>:
  if (i <= 7) goto <D.10856>; else goto <D.10858>;
  <D.10858>:
  D.12263 = buf + 8;
  return D.12263;
}


method_leave (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int D.12265;
  int D.12266;
  int max_call_depth.69;
  int D.12270;
  int D.12273;
  int D.12274;
  struct LogBuffer * D.12275;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  D.12265 = logbuffer->call_depth;
  D.12266 = D.12265 + -1;
  logbuffer->call_depth = D.12266;
  D.12265 = logbuffer->call_depth;
  max_call_depth.69 = max_call_depth;
  if (D.12265 > max_call_depth.69) goto <D.12268>; else goto <D.12269>;
  <D.12268>:
  return;
  <D.12269>:
  now = current_time ();
  D.12270 = logbuffer->locked;
  if (D.12270 != 0) goto <D.12271>; else goto <D.12272>;
  <D.12271>:
  write (2, "leave", 5);
  write (2, "\n", 1);
  return;
  <D.12272>:
  D.12270 = logbuffer->locked;
  D.12273 = D.12270 + 1;
  logbuffer->locked = D.12273;
  emit_byte (logbuffer, 19);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12270 = logbuffer->locked;
  D.12274 = D.12270 + -1;
  logbuffer->locked = D.12274;
  D.12275 = logbuffer->next;
  if (D.12275 != 0B) goto <D.12276>; else goto <D.12277>;
  <D.12276>:
  safe_dump (prof, logbuffer);
  <D.12277>:
  process_requests (prof);
}


method_enter (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int D.12281;
  int D.12282;
  int D.12283;
  int max_call_depth.70;
  int D.12287;
  int D.12290;
  int D.12291;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  D.12281 = logbuffer->call_depth;
  D.12282 = D.12281;
  D.12283 = D.12282 + 1;
  logbuffer->call_depth = D.12283;
  max_call_depth.70 = max_call_depth;
  if (D.12282 > max_call_depth.70) goto <D.12285>; else goto <D.12286>;
  <D.12285>:
  return;
  <D.12286>:
  now = current_time ();
  D.12287 = logbuffer->locked;
  if (D.12287 != 0) goto <D.12288>; else goto <D.12289>;
  <D.12288>:
  write (2, "enter", 5);
  write (2, "\n", 1);
  return;
  <D.12289>:
  D.12287 = logbuffer->locked;
  D.12290 = D.12287 + 1;
  logbuffer->locked = D.12290;
  emit_byte (logbuffer, 35);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12287 = logbuffer->locked;
  D.12291 = D.12287 + -1;
  logbuffer->locked = D.12291;
  process_requests (prof);
}


thread_name (struct MonoProfiler * prof, uintptr_t tid, const char * name)
{
  unsigned int D.12295;
  unsigned int D.12296;
  int D.12297;
  int D.12298;
  int D.12301;
  void * tid.71;
  unsigned int len.72;
  unsigned char * D.12304;
  sizetype len.73;
  unsigned char * D.12306;
  int D.12307;
  int len;
  uint64_t now;
  struct LogBuffer * logbuffer;

  D.12295 = strlen (name);
  D.12296 = D.12295 + 1;
  len = (int) D.12296;
  D.12297 = len + 10;
  logbuffer = ensure_logbuf (D.12297);
  now = current_time ();
  D.12298 = logbuffer->locked;
  if (D.12298 != 0) goto <D.12299>; else goto <D.12300>;
  <D.12299>:
  write (2, "tname", 5);
  write (2, "\n", 1);
  return;
  <D.12300>:
  D.12298 = logbuffer->locked;
  D.12301 = D.12298 + 1;
  logbuffer->locked = D.12301;
  emit_byte (logbuffer, 2);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 5);
  tid.71 = (void *) tid;
  emit_ptr (logbuffer, tid.71);
  emit_value (logbuffer, 0);
  len.72 = (unsigned int) len;
  D.12304 = logbuffer->data;
  memcpy (D.12304, name, len.72);
  D.12304 = logbuffer->data;
  len.73 = (sizetype) len;
  D.12306 = D.12304 + len.73;
  logbuffer->data = D.12306;
  D.12298 = logbuffer->locked;
  D.12307 = D.12298 + -1;
  logbuffer->locked = D.12307;
}


thread_end (struct MonoProfiler * prof, uintptr_t tid)
{
  struct LogBuffer * tlsbuffer.74;

  take_lock ();
  tlsbuffer.74 = tlsbuffer;
  if (tlsbuffer.74 != 0B) goto <D.12312>; else goto <D.12313>;
  <D.12312>:
  tlsbuffer.74 = tlsbuffer;
  dump_buffer (prof, tlsbuffer.74);
  <D.12313>:
  release_lock ();
  tlsbuffer = 0B;
}


thread_start (struct MonoProfiler * prof, uintptr_t tid)
{
  init_thread ();
}


image_loaded (struct MonoProfiler * prof, struct MonoImage * image, int result)
{
  unsigned int D.12316;
  unsigned int D.12317;
  int D.12318;
  int D.12319;
  int D.12322;
  unsigned int nlen.75;
  unsigned char * D.12324;
  sizetype nlen.76;
  unsigned char * D.12326;
  int D.12327;
  struct LogBuffer * D.12328;
  uint64_t now;
  const char * name;
  int nlen;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.12314>; else goto <D.12315>;
  <D.12314>:
  return;
  <D.12315>:
  name = mono_image_get_filename (image);
  D.12316 = strlen (name);
  D.12317 = D.12316 + 1;
  nlen = (int) D.12317;
  D.12318 = nlen + 16;
  logbuffer = ensure_logbuf (D.12318);
  now = current_time ();
  D.12319 = logbuffer->locked;
  if (D.12319 != 0) goto <D.12320>; else goto <D.12321>;
  <D.12320>:
  write (2, "image", 5);
  write (2, "\n", 1);
  return;
  <D.12321>:
  D.12319 = logbuffer->locked;
  D.12322 = D.12319 + 1;
  logbuffer->locked = D.12322;
  emit_byte (logbuffer, 34);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 2);
  emit_ptr (logbuffer, image);
  emit_value (logbuffer, 0);
  nlen.75 = (unsigned int) nlen;
  D.12324 = logbuffer->data;
  memcpy (D.12324, name, nlen.75);
  D.12324 = logbuffer->data;
  nlen.76 = (sizetype) nlen;
  D.12326 = D.12324 + nlen.76;
  logbuffer->data = D.12326;
  D.12319 = logbuffer->locked;
  D.12327 = D.12319 + -1;
  logbuffer->locked = D.12327;
  D.12328 = logbuffer->next;
  if (D.12328 != 0B) goto <D.12329>; else goto <D.12330>;
  <D.12329>:
  safe_dump (prof, logbuffer);
  <D.12330>:
  process_requests (prof);
}


class_loaded (struct MonoProfiler * prof, struct MonoClass * klass, int result)
{
  int runtime_inited.77;
  struct MonoType * D.12340;
  unsigned int D.12342;
  unsigned int D.12343;
  int D.12344;
  int D.12345;
  int D.12348;
  unsigned int nlen.78;
  unsigned char * D.12350;
  sizetype nlen.79;
  unsigned char * D.12352;
  int D.12356;
  struct LogBuffer * D.12357;
  uint64_t now;
  char * name;
  int nlen;
  struct MonoImage * image;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.12335>; else goto <D.12336>;
  <D.12335>:
  return;
  <D.12336>:
  runtime_inited.77 = runtime_inited;
  if (runtime_inited.77 != 0) goto <D.12338>; else goto <D.12339>;
  <D.12338>:
  D.12340 = mono_class_get_type (klass);
  name = mono_type_get_name (D.12340);
  goto <D.12341>;
  <D.12339>:
  name = type_name (klass);
  <D.12341>:
  D.12342 = strlen (name);
  D.12343 = D.12342 + 1;
  nlen = (int) D.12343;
  image = mono_class_get_image (klass);
  D.12344 = nlen + 24;
  logbuffer = ensure_logbuf (D.12344);
  now = current_time ();
  D.12345 = logbuffer->locked;
  if (D.12345 != 0) goto <D.12346>; else goto <D.12347>;
  <D.12346>:
  write (2, "class", 5);
  write (2, "\n", 1);
  return;
  <D.12347>:
  D.12345 = logbuffer->locked;
  D.12348 = D.12345 + 1;
  logbuffer->locked = D.12348;
  emit_byte (logbuffer, 34);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 1);
  emit_ptr (logbuffer, klass);
  emit_ptr (logbuffer, image);
  emit_value (logbuffer, 0);
  nlen.78 = (unsigned int) nlen;
  D.12350 = logbuffer->data;
  memcpy (D.12350, name, nlen.78);
  D.12350 = logbuffer->data;
  nlen.79 = (sizetype) nlen;
  D.12352 = D.12350 + nlen.79;
  logbuffer->data = D.12352;
  runtime_inited.77 = runtime_inited;
  if (runtime_inited.77 != 0) goto <D.12353>; else goto <D.12354>;
  <D.12353>:
  mono_free (name);
  goto <D.12355>;
  <D.12354>:
  free (name);
  <D.12355>:
  D.12345 = logbuffer->locked;
  D.12356 = D.12345 + -1;
  logbuffer->locked = D.12356;
  D.12357 = logbuffer->next;
  if (D.12357 != 0B) goto <D.12358>; else goto <D.12359>;
  <D.12358>:
  safe_dump (prof, logbuffer);
  <D.12359>:
  process_requests (prof);
}


type_name (struct MonoClass * klass)
{
  unsigned int D.12367;
  unsigned int D.12368;
  char * D.12369;
  char buf[1024];
  char * p;

  try
    {
      push_nesting (&buf, klass);
      D.12367 = strlen (&buf);
      D.12368 = D.12367 + 1;
      p = malloc (D.12368);
      strcpy (p, &buf);
      D.12369 = p;
      return D.12369;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


push_nesting (char * p, struct MonoClass * klass)
{
  char * p.80;
  char D.12376;
  unsigned int D.12379;
  char * p.81;
  unsigned int D.12381;
  char * D.12382;
  struct MonoClass * nesting;
  const char * name;
  const char * nspace;

  nesting = mono_class_get_nesting_type (klass);
  if (nesting != 0B) goto <D.12373>; else goto <D.12374>;
  <D.12373>:
  p = push_nesting (p, nesting);
  p.80 = p;
  p = p.80 + 1;
  *p.80 = 47;
  *p = 0;
  <D.12374>:
  name = mono_class_get_name (klass);
  nspace = mono_class_get_namespace (klass);
  D.12376 = *nspace;
  if (D.12376 != 0) goto <D.12377>; else goto <D.12378>;
  <D.12377>:
  strcpy (p, nspace);
  D.12379 = strlen (nspace);
  p = p + D.12379;
  p.81 = p;
  p = p.81 + 1;
  *p.81 = 46;
  *p = 0;
  <D.12378>:
  strcpy (p, name);
  D.12381 = strlen (name);
  p = p + D.12381;
  D.12382 = p;
  return D.12382;
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.12388;
  unsigned int D.12389;

  D.12389 = __builtin_object_size (__dest, 1);
  D.12388 = __builtin___strcpy_chk (__dest, __src, D.12389);
  return D.12388;
}


gc_roots (struct MonoProfiler * prof, int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  int D.12391;
  int D.12392;
  int D.12393;
  int D.12396;
  int D.12397;
  int D.12398;
  unsigned int i.82;
  unsigned int D.12400;
  void * * D.12401;
  void * D.12402;
  int * D.12403;
  int D.12404;
  uintptr_t * D.12405;
  unsigned int D.12406;
  int D.12407;
  int D.12408;
  int i;
  struct LogBuffer * logbuffer;

  D.12391 = num * 18;
  D.12392 = D.12391 + 5;
  logbuffer = ensure_logbuf (D.12392);
  D.12393 = logbuffer->locked;
  if (D.12393 != 0) goto <D.12394>; else goto <D.12395>;
  <D.12394>:
  write (2, "gcroots", 7);
  write (2, "\n", 1);
  return;
  <D.12395>:
  D.12393 = logbuffer->locked;
  D.12396 = D.12393 + 1;
  logbuffer->locked = D.12396;
  emit_byte (logbuffer, 54);
  emit_value (logbuffer, num);
  D.12397 = mono_gc_max_generation ();
  D.12398 = mono_gc_collection_count (D.12397);
  emit_value (logbuffer, D.12398);
  i = 0;
  goto <D.10974>;
  <D.10973>:
  i.82 = (unsigned int) i;
  D.12400 = i.82 * 4;
  D.12401 = objects + D.12400;
  D.12402 = *D.12401;
  emit_obj (logbuffer, D.12402);
  i.82 = (unsigned int) i;
  D.12400 = i.82 * 4;
  D.12403 = root_types + D.12400;
  D.12404 = *D.12403;
  emit_value (logbuffer, D.12404);
  i.82 = (unsigned int) i;
  D.12400 = i.82 * 4;
  D.12405 = extra_info + D.12400;
  D.12406 = *D.12405;
  D.12407 = (int) D.12406;
  emit_value (logbuffer, D.12407);
  i = i + 1;
  <D.10974>:
  if (i < num) goto <D.10973>; else goto <D.10975>;
  <D.10975>:
  D.12393 = logbuffer->locked;
  D.12408 = D.12393 + -1;
  logbuffer->locked = D.12408;
}


gc_handle (struct MonoProfiler * prof, int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  int D.12413;
  int D.12416;
  int handle.83;
  int D.12426;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  now = current_time ();
  D.12413 = logbuffer->locked;
  if (D.12413 != 0) goto <D.12414>; else goto <D.12415>;
  <D.12414>:
  write (2, "gchandle", 8);
  write (2, "\n", 1);
  return;
  <D.12415>:
  D.12413 = logbuffer->locked;
  D.12416 = D.12413 + 1;
  logbuffer->locked = D.12416;
  if (op == 0) goto <D.12417>; else goto <D.12418>;
  <D.12417>:
  emit_byte (logbuffer, 65);
  goto <D.12419>;
  <D.12418>:
  if (op == 1) goto <D.12420>; else goto <D.12421>;
  <D.12420>:
  emit_byte (logbuffer, 81);
  goto <D.12422>;
  <D.12421>:
  return;
  <D.12422>:
  <D.12419>:
  emit_time (logbuffer, now);
  emit_value (logbuffer, type);
  handle.83 = (int) handle;
  emit_value (logbuffer, handle.83);
  if (op == 0) goto <D.12424>; else goto <D.12425>;
  <D.12424>:
  emit_obj (logbuffer, obj);
  <D.12425>:
  D.12413 = logbuffer->locked;
  D.12426 = D.12413 + -1;
  logbuffer->locked = D.12426;
  process_requests (prof);
}


gc_moves (struct MonoProfiler * prof, void * * objects, int num)
{
  int D.12430;
  int D.12431;
  int D.12432;
  int D.12435;
  unsigned int i.84;
  unsigned int D.12437;
  void * * D.12438;
  void * D.12439;
  int D.12440;
  int i;
  uint64_t now;
  struct LogBuffer * logbuffer;

  D.12430 = num * 8;
  D.12431 = D.12430 + 10;
  logbuffer = ensure_logbuf (D.12431);
  now = current_time ();
  D.12432 = logbuffer->locked;
  if (D.12432 != 0) goto <D.12433>; else goto <D.12434>;
  <D.12433>:
  write (2, "gcmove", 6);
  write (2, "\n", 1);
  return;
  <D.12434>:
  D.12432 = logbuffer->locked;
  D.12435 = D.12432 + 1;
  logbuffer->locked = D.12435;
  emit_byte (logbuffer, 49);
  emit_time (logbuffer, now);
  emit_value (logbuffer, num);
  i = 0;
  goto <D.10962>;
  <D.10961>:
  i.84 = (unsigned int) i;
  D.12437 = i.84 * 4;
  D.12438 = objects + D.12437;
  D.12439 = *D.12438;
  emit_obj (logbuffer, D.12439);
  i = i + 1;
  <D.10962>:
  if (i < num) goto <D.10961>; else goto <D.10963>;
  <D.10963>:
  D.12432 = logbuffer->locked;
  D.12440 = D.12432 + -1;
  logbuffer->locked = D.12440;
}


gc_alloc (struct MonoProfiler * prof, struct MonoObject * obj, struct MonoClass * klass)
{
  int iftmp.85;
  int nocalls.86;
  int runtime_inited.87;
  int notraces.88;
  int D.12455;
  int D.12458;
  int len.89;
  int D.12462;
  struct LogBuffer * D.12463;
  uint64_t now;
  uintptr_t len;
  int do_bt;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.86 = nocalls;
      if (nocalls.86 != 0) goto <D.12448>; else goto <D.12445>;
      <D.12448>:
      runtime_inited.87 = runtime_inited;
      if (runtime_inited.87 != 0) goto <D.12450>; else goto <D.12445>;
      <D.12450>:
      notraces.88 = notraces;
      if (notraces.88 == 0) goto <D.12452>; else goto <D.12445>;
      <D.12452>:
      iftmp.85 = 16;
      goto <D.12446>;
      <D.12445>:
      iftmp.85 = 0;
      <D.12446>:
      do_bt = iftmp.85;
      len = mono_object_get_size (obj);
      len = len + 7;
      len = len & 4294967288;
      if (do_bt != 0) goto <D.12453>; else goto <D.12454>;
      <D.12453>:
      collect_bt (&data);
      <D.12454>:
      logbuffer = ensure_logbuf (160);
      now = current_time ();
      D.12455 = logbuffer->locked;
      if (D.12455 != 0) goto <D.12456>; else goto <D.12457>;
      <D.12456>:
      write (2, "gcalloc", 7);
      write (2, "\n", 1);
      return;
      <D.12457>:
      D.12455 = logbuffer->locked;
      D.12458 = D.12455 + 1;
      logbuffer->locked = D.12458;
      emit_byte (logbuffer, do_bt);
      emit_time (logbuffer, now);
      emit_ptr (logbuffer, klass);
      emit_obj (logbuffer, obj);
      len.89 = (int) len;
      emit_value (logbuffer, len.89);
      if (do_bt != 0) goto <D.12460>; else goto <D.12461>;
      <D.12460>:
      emit_bt (logbuffer, &data);
      <D.12461>:
      D.12455 = logbuffer->locked;
      D.12462 = D.12455 + -1;
      logbuffer->locked = D.12462;
      D.12463 = logbuffer->next;
      if (D.12463 != 0B) goto <D.12464>; else goto <D.12465>;
      <D.12464>:
      safe_dump (prof, logbuffer);
      <D.12465>:
      process_requests (prof);
    }
  finally
    {
      data = {CLOBBER};
    }
}


gc_resize (struct MonoProfiler * profiler, int64_t new_size)
{
  int D.12473;
  int D.12476;
  int D.12477;
  int D.12478;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (10);
  now = current_time ();
  D.12473 = logbuffer->locked;
  if (D.12473 != 0) goto <D.12474>; else goto <D.12475>;
  <D.12474>:
  write (2, "gcresize", 8);
  write (2, "\n", 1);
  return;
  <D.12475>:
  D.12473 = logbuffer->locked;
  D.12476 = D.12473 + 1;
  logbuffer->locked = D.12476;
  emit_byte (logbuffer, 33);
  emit_time (logbuffer, now);
  D.12477 = (int) new_size;
  emit_value (logbuffer, D.12477);
  D.12473 = logbuffer->locked;
  D.12478 = D.12473 + -1;
  logbuffer->locked = D.12478;
}


gc_event (struct MonoProfiler * profiler, MonoGCEvent ev, int generation)
{
  int D.12482;
  int D.12485;
  int ev.90;
  int D.12489;
  unsigned int gc_count.91;
  unsigned int gc_count.92;
  int D.12496;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (10);
  now = current_time ();
  D.12482 = logbuffer->locked;
  if (D.12482 != 0) goto <D.12483>; else goto <D.12484>;
  <D.12483>:
  write (2, "gcevent", 7);
  write (2, "\n", 1);
  return;
  <D.12484>:
  D.12482 = logbuffer->locked;
  D.12485 = D.12482 + 1;
  logbuffer->locked = D.12485;
  emit_byte (logbuffer, 17);
  emit_time (logbuffer, now);
  ev.90 = (int) ev;
  emit_value (logbuffer, ev.90);
  emit_value (logbuffer, generation);
  if (ev == 0) goto <D.12487>; else goto <D.12488>;
  <D.12487>:
  profiler->last_gc_gen_started = generation;
  D.12489 = mono_gc_max_generation ();
  if (D.12489 == generation) goto <D.12490>; else goto <D.12491>;
  <D.12490>:
  gc_count.91 = gc_count;
  gc_count.92 = gc_count.91 + 1;
  gc_count = gc_count.92;
  <D.12491>:
  <D.12488>:
  if (ev == 8) goto <D.12494>; else goto <D.12495>;
  <D.12494>:
  heap_walk (profiler);
  <D.12495>:
  D.12482 = logbuffer->locked;
  D.12496 = D.12482 + -1;
  logbuffer->locked = D.12496;
  if (ev == 9) goto <D.12497>; else goto <D.12498>;
  <D.12497>:
  safe_dump (profiler, logbuffer);
  <D.12498>:
}


heap_walk (struct MonoProfiler * profiler)
{
  int do_heap_shot.93;
  unsigned int hs_mode_ms.94;
  long long unsigned int last_hs_time.95;
  long long unsigned int D.12511;
  long long unsigned int D.12512;
  long long unsigned int D.12513;
  unsigned int hs_mode_gc.96;
  unsigned int gc_count.97;
  unsigned int D.12520;
  unsigned int hs_mode_ondemand.98;
  int D.12530;
  int D.12531;
  int do_walk;
  uint64_t now;
  struct LogBuffer * logbuffer;

  do_walk = 0;
  do_heap_shot.93 = do_heap_shot;
  if (do_heap_shot.93 == 0) goto <D.12504>; else goto <D.12505>;
  <D.12504>:
  return;
  <D.12505>:
  logbuffer = ensure_logbuf (10);
  now = current_time ();
  hs_mode_ms.94 = hs_mode_ms;
  if (hs_mode_ms.94 != 0) goto <D.12509>; else goto <D.12506>;
  <D.12509>:
  last_hs_time.95 = last_hs_time;
  D.12511 = now - last_hs_time.95;
  D.12512 = D.12511 / 1000000;
  hs_mode_ms.94 = hs_mode_ms;
  D.12513 = (long long unsigned int) hs_mode_ms.94;
  if (D.12512 >= D.12513) goto <D.12514>; else goto <D.12506>;
  <D.12514>:
  do_walk = 1;
  goto <D.12507>;
  <D.12506>:
  hs_mode_gc.96 = hs_mode_gc;
  if (hs_mode_gc.96 != 0) goto <D.12518>; else goto <D.12515>;
  <D.12518>:
  gc_count.97 = gc_count;
  hs_mode_gc.96 = hs_mode_gc;
  D.12520 = gc_count.97 % hs_mode_gc.96;
  if (D.12520 == 0) goto <D.12521>; else goto <D.12515>;
  <D.12521>:
  do_walk = 1;
  goto <D.12516>;
  <D.12515>:
  hs_mode_ondemand.98 = hs_mode_ondemand;
  if (hs_mode_ondemand.98 != 0) goto <D.12523>; else goto <D.12524>;
  <D.12523>:
  do_walk = heapshot_requested;
  goto <D.12525>;
  <D.12524>:
  hs_mode_ms.94 = hs_mode_ms;
  if (hs_mode_ms.94 == 0) goto <D.12526>; else goto <D.12527>;
  <D.12526>:
  hs_mode_gc.96 = hs_mode_gc;
  if (hs_mode_gc.96 == 0) goto <D.12528>; else goto <D.12529>;
  <D.12528>:
  D.12530 = profiler->last_gc_gen_started;
  D.12531 = mono_gc_max_generation ();
  if (D.12530 == D.12531) goto <D.12532>; else goto <D.12533>;
  <D.12532>:
  do_walk = 1;
  <D.12533>:
  <D.12529>:
  <D.12527>:
  <D.12525>:
  <D.12516>:
  <D.12507>:
  if (do_walk == 0) goto <D.12534>; else goto <D.12535>;
  <D.12534>:
  return;
  <D.12535>:
  heapshot_requested = 0;
  emit_byte (logbuffer, 6);
  emit_time (logbuffer, now);
  mono_gc_walk_heap (0, gc_reference, 0B);
  logbuffer = ensure_logbuf (10);
  now = current_time ();
  emit_byte (logbuffer, 22);
  emit_time (logbuffer, now);
  last_hs_time = now;
}


gc_reference (struct MonoObject * obj, struct MonoClass * klass, uintptr_t size, uintptr_t num, struct MonoObject * * refs, uintptr_t * offsets, void * data)
{
  unsigned int D.12542;
  unsigned int D.12543;
  int D.12544;
  int size.99;
  int num.100;
  unsigned int i.101;
  unsigned int D.12548;
  uintptr_t * D.12549;
  unsigned int D.12550;
  unsigned int D.12551;
  int D.12552;
  struct MonoObject * * D.12553;
  struct MonoObject * D.12554;
  unsigned int i.102;
  int D.12556;
  int i;
  uintptr_t last_offset;
  struct LogBuffer * logbuffer;

  last_offset = 0;
  D.12542 = num * 8;
  D.12543 = D.12542 + 20;
  D.12544 = (int) D.12543;
  logbuffer = ensure_logbuf (D.12544);
  emit_byte (logbuffer, 38);
  emit_obj (logbuffer, obj);
  emit_ptr (logbuffer, klass);
  size = size + 7;
  size = size & 4294967288;
  size.99 = (int) size;
  emit_value (logbuffer, size.99);
  num.100 = (int) num;
  emit_value (logbuffer, num.100);
  i = 0;
  goto <D.10894>;
  <D.10893>:
  i.101 = (unsigned int) i;
  D.12548 = i.101 * 4;
  D.12549 = offsets + D.12548;
  D.12550 = *D.12549;
  D.12551 = D.12550 - last_offset;
  D.12552 = (int) D.12551;
  emit_value (logbuffer, D.12552);
  i.101 = (unsigned int) i;
  D.12548 = i.101 * 4;
  D.12549 = offsets + D.12548;
  last_offset = *D.12549;
  i.101 = (unsigned int) i;
  D.12548 = i.101 * 4;
  D.12553 = refs + D.12548;
  D.12554 = *D.12553;
  emit_obj (logbuffer, D.12554);
  i = i + 1;
  <D.10894>:
  i.102 = (unsigned int) i;
  if (i.102 < num) goto <D.10893>; else goto <D.10895>;
  <D.10895>:
  D.12556 = 0;
  return D.12556;
}


log_shutdown (struct MonoProfiler * prof)
{
  int D.12559;
  int D.12562;
  long unsigned int D.12563;
  struct PerfData * perf_data.103;
  int num_perf.104;
  struct StatBuffer * D.12568;
  struct LogBuffer * tlsbuffer.105;
  int D.12572;
  struct FILE * D.12575;

  in_shutdown = 1;
  D.12559 = prof->command_port;
  if (D.12559 != 0) goto <D.12560>; else goto <D.12561>;
  <D.12560>:
  {
    char c;
    void * res;

    try
      {
        c = 1;
        D.12562 = prof->pipes[1];
        write (D.12562, &c, 1);
        D.12563 = prof->helper_thread;
        pthread_join (D.12563, &res);
      }
    finally
      {
        c = {CLOBBER};
        res = {CLOBBER};
      }
  }
  <D.12561>:
  perf_data.103 = perf_data;
  if (perf_data.103 != 0B) goto <D.12565>; else goto <D.12566>;
  <D.12565>:
  {
    int i;

    i = 0;
    goto <D.11322>;
    <D.11321>:
    read_perf_mmap (prof, i);
    i = i + 1;
    <D.11322>:
    num_perf.104 = num_perf;
    if (i < num_perf.104) goto <D.11321>; else goto <D.11323>;
    <D.11323>:
  }
  <D.12566>:
  D.12568 = prof->stat_buffers;
  dump_sample_hits (prof, D.12568, 1);
  take_lock ();
  tlsbuffer.105 = tlsbuffer;
  if (tlsbuffer.105 != 0B) goto <D.12570>; else goto <D.12571>;
  <D.12570>:
  tlsbuffer.105 = tlsbuffer;
  dump_buffer (prof, tlsbuffer.105);
  <D.12571>:
  tlsbuffer = 0B;
  release_lock ();
  D.12572 = prof->pipe_output;
  if (D.12572 != 0) goto <D.12573>; else goto <D.12574>;
  <D.12573>:
  D.12575 = prof->file;
  pclose (D.12575);
  goto <D.12576>;
  <D.12574>:
  D.12575 = prof->file;
  fclose (D.12575);
  <D.12576>:
  free (prof);
}


read_perf_mmap (struct MonoProfiler * prof, int cpu)
{
  struct PerfData * perf_data.106;
  unsigned int cpu.107;
  unsigned int D.12581;
  void * D.12582;
  int D.12583;
  sizetype D.12584;
  struct perf_event_mmap_page * D.12585;
  long long unsigned int D.12586;
  unsigned int D.12587;
  int do_debug.108;
  unsigned int mmap_mask.109;
  unsigned int D.12594;
  unsigned int size.110;
  unsigned int D.12596;
  unsigned int D.12597;
  unsigned int D.12600;
  unsigned int D.12601;
  unsigned int D.12602;
  long long unsigned int D.12607;
  int D.12608;
  struct PerfData * perf;
  unsigned char * buf;
  unsigned char * data;
  unsigned int head;
  int diff;
  int size;
  unsigned int old;

  perf_data.106 = perf_data;
  cpu.107 = (unsigned int) cpu;
  D.12581 = cpu.107 * 16;
  perf = perf_data.106 + D.12581;
  D.12582 = perf->mmap_base;
  D.12583 = getpagesize ();
  D.12584 = (sizetype) D.12583;
  data = D.12582 + D.12584;
  D.12585 = perf->page_desc;
  D.12586 = D.12585->data_head;
  head = (unsigned int) D.12586;
  __asm__ __volatile__("lock; addl $0,0(%%esp)" :  :  : "memory");
  old = perf->prev_pos;
  D.12587 = head - old;
  diff = (int) D.12587;
  if (diff < 0) goto <D.12588>; else goto <D.12589>;
  <D.12588>:
  do_debug.108 = do_debug;
  if (do_debug.108 != 0) goto <D.12591>; else goto <D.12592>;
  <D.12591>:
  printf ("lost mmap events: old: %d, head: %d\n", old, head);
  <D.12592>:
  old = head;
  <D.12589>:
  D.12587 = head - old;
  size = (int) D.12587;
  mmap_mask.109 = mmap_mask;
  D.12594 = old & mmap_mask.109;
  size.110 = (unsigned int) size;
  D.12596 = D.12594 + size.110;
  mmap_mask.109 = mmap_mask;
  D.12597 = head & mmap_mask.109;
  if (D.12596 != D.12597) goto <D.12598>; else goto <D.12599>;
  <D.12598>:
  mmap_mask.109 = mmap_mask;
  D.12594 = old & mmap_mask.109;
  buf = data + D.12594;
  D.12600 = ~old;
  mmap_mask.109 = mmap_mask;
  D.12601 = D.12600 & mmap_mask.109;
  D.12602 = D.12601 + 1;
  size = (int) D.12602;
  size.110 = (unsigned int) size;
  old = old + size.110;
  do_debug.108 = do_debug;
  if (do_debug.108 != 0) goto <D.12603>; else goto <D.12604>;
  <D.12603>:
  printf ("found1 bytes of events: %d\n", size);
  <D.12604>:
  dump_perf_hits (prof, buf, size);
  <D.12599>:
  mmap_mask.109 = mmap_mask;
  D.12594 = old & mmap_mask.109;
  buf = data + D.12594;
  D.12587 = head - old;
  size = (int) D.12587;
  do_debug.108 = do_debug;
  if (do_debug.108 != 0) goto <D.12605>; else goto <D.12606>;
  <D.12605>:
  printf ("found bytes of events: %d\n", size);
  <D.12606>:
  dump_perf_hits (prof, buf, size);
  size.110 = (unsigned int) size;
  old = old + size.110;
  perf->prev_pos = old;
  D.12585 = perf->page_desc;
  D.12607 = (long long unsigned int) old;
  D.12585->data_tail = D.12607;
  D.12608 = 0;
  return D.12608;
}


dump_perf_hits (struct MonoProfiler * prof, void * buf, int size)
{
  sizetype size.111;
  short unsigned int D.12611;
  unsigned int pid.112;
  unsigned int D.12614;
  int do_debug.113;
  sizetype D.12620;
  long long unsigned int D.12621;
  unsigned int D.12622;
  unsigned int D.12623;
  unsigned int D.12624;
  int D.12625;
  int sample_type.114;
  long long unsigned int D.12627;
  long long unsigned int D.12628;
  long long unsigned int D.12629;
  long long unsigned int D.12630;
  unsigned int D.12631;
  void * D.12632;
  unsigned int D.12633;
  struct LogBuffer * logbuffer;
  void * end;
  int samples;
  int pid;

  size.111 = (sizetype) size;
  end = buf + size.111;
  samples = 0;
  pid = getpid ();
  goto <D.11281>;
  <D.11282>:
  {
    struct PSample * s;

    s = buf;
    D.12611 = s->h.size;
    if (D.12611 == 0) goto <D.11280>; else goto <D.12612>;
    <D.12612>:
    pid.112 = (unsigned int) pid;
    D.12614 = s->pid;
    if (pid.112 != D.12614) goto <D.12615>; else goto <D.12616>;
    <D.12615>:
    do_debug.113 = do_debug;
    if (do_debug.113 != 0) goto <D.12618>; else goto <D.12619>;
    <D.12618>:
    D.12614 = s->pid;
    printf ("event for different pid: %d\n", D.12614);
    <D.12619>:
    D.12611 = s->h.size;
    D.12620 = (sizetype) D.12611;
    buf = buf + D.12620;
    // predicted unlikely by continue predictor.
    goto <D.11281>;
    <D.12616>:
    D.12621 = s->nframes;
    D.12622 = (unsigned int) D.12621;
    D.12623 = D.12622 * 8;
    D.12624 = D.12623 + 20;
    D.12625 = (int) D.12624;
    logbuffer = ensure_logbuf (D.12625);
    emit_byte (logbuffer, 7);
    sample_type.114 = sample_type;
    emit_value (logbuffer, sample_type.114);
    D.12627 = s->timestamp;
    D.12628 = prof->startup_time;
    D.12629 = D.12627 - D.12628;
    emit_uvalue (logbuffer, D.12629);
    emit_value (logbuffer, 1);
    D.12630 = s->ip;
    D.12631 = (unsigned int) D.12630;
    D.12632 = (void *) D.12631;
    emit_ptr (logbuffer, D.12632);
    D.12630 = s->ip;
    D.12633 = (unsigned int) D.12630;
    add_code_pointer (D.12633);
    D.12611 = s->h.size;
    D.12620 = (sizetype) D.12611;
    buf = buf + D.12620;
    samples = samples + 1;
  }
  <D.11281>:
  if (buf < end) goto <D.11282>; else goto <D.11280>;
  <D.11280>:
  do_debug.113 = do_debug;
  if (do_debug.113 != 0) goto <D.12634>; else goto <D.12635>;
  <D.12634>:
  printf ("dumped %d samples\n", samples);
  <D.12635>:
  dump_unmanaged_coderefs (prof);
}


emit_uvalue (struct LogBuffer * logbuffer, uint64_t value)
{
  unsigned char * * D.12637;
  unsigned char * D.12638;
  unsigned char * D.12639;
  static const char __PRETTY_FUNCTION__[12] = "emit_uvalue";

  D.12637 = &logbuffer->data;
  D.12638 = logbuffer->data;
  encode_uleb128 (value, D.12638, D.12637);
  D.12638 = logbuffer->data;
  D.12639 = logbuffer->data_end;
  if (D.12638 > D.12639) goto <D.12640>; else goto <D.12641>;
  <D.12640>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 481, &__PRETTY_FUNCTION__);
  <D.12641>:
}


add_code_pointer (uintptr_t ip)
{
  int num_code_pages.115;
  int D.12643;
  int size_code_pages.116;
  int size_code_pages.117;
  unsigned int size_code_pages.118;
  unsigned int D.12651;
  uintptr_t * code_pages.119;
  unsigned int D.12653;
  uintptr_t * D.12654;
  unsigned int D.12655;
  unsigned int size_code_pages.120;
  unsigned int D.12661;
  unsigned int D.12662;
  unsigned int num_code_pages.121;
  unsigned int D.12664;
  int num_code_pages.122;
  uintptr_t i;

  num_code_pages.115 = num_code_pages;
  D.12643 = num_code_pages.115 * 2;
  size_code_pages.116 = size_code_pages;
  if (D.12643 >= size_code_pages.116) goto <D.12645>; else goto <D.12646>;
  <D.12645>:
  {
    uintptr_t * n;
    uintptr_t old_size;

    size_code_pages.116 = size_code_pages;
    old_size = (uintptr_t) size_code_pages.116;
    size_code_pages.116 = size_code_pages;
    size_code_pages.117 = size_code_pages.116 * 2;
    size_code_pages = size_code_pages.117;
    size_code_pages.116 = size_code_pages;
    if (size_code_pages.116 == 0) goto <D.12648>; else goto <D.12649>;
    <D.12648>:
    size_code_pages = 16;
    <D.12649>:
    size_code_pages.116 = size_code_pages;
    size_code_pages.118 = (unsigned int) size_code_pages.116;
    D.12651 = size_code_pages.118 * 4;
    n = calloc (D.12651, 1);
    i = 0;
    goto <D.11119>;
    <D.11118>:
    code_pages.119 = code_pages;
    D.12653 = i * 4;
    D.12654 = code_pages.119 + D.12653;
    D.12655 = *D.12654;
    if (D.12655 != 0) goto <D.12656>; else goto <D.12657>;
    <D.12656>:
    code_pages.119 = code_pages;
    D.12653 = i * 4;
    D.12654 = code_pages.119 + D.12653;
    D.12655 = *D.12654;
    size_code_pages.116 = size_code_pages;
    size_code_pages.120 = (unsigned int) size_code_pages.116;
    add_code_page (n, size_code_pages.120, D.12655);
    <D.12657>:
    i = i + 1;
    <D.11119>:
    if (i < old_size) goto <D.11118>; else goto <D.11120>;
    <D.11120>:
    code_pages.119 = code_pages;
    if (code_pages.119 != 0B) goto <D.12659>; else goto <D.12660>;
    <D.12659>:
    code_pages.119 = code_pages;
    free (code_pages.119);
    <D.12660>:
    code_pages = n;
  }
  <D.12646>:
  D.12661 = ip & 4294966784;
  size_code_pages.116 = size_code_pages;
  size_code_pages.120 = (unsigned int) size_code_pages.116;
  code_pages.119 = code_pages;
  D.12662 = add_code_page (code_pages.119, size_code_pages.120, D.12661);
  num_code_pages.115 = num_code_pages;
  num_code_pages.121 = (unsigned int) num_code_pages.115;
  D.12664 = D.12662 + num_code_pages.121;
  num_code_pages.122 = (int) D.12664;
  num_code_pages = num_code_pages.122;
}


add_code_page (uintptr_t * hash, uintptr_t hsize, uintptr_t page)
{
  unsigned int D.12667;
  unsigned int D.12669;
  uintptr_t * D.12670;
  unsigned int D.12671;
  unsigned int D.12673;
  unsigned int D.12674;
  uintptr_t D.12676;
  uintptr_t i;
  uintptr_t start_pos;

  D.12667 = page >> 9;
  start_pos = D.12667 % hsize;
  i = start_pos;
  <D.11110>:
  D.12669 = i * 4;
  D.12670 = hash + D.12669;
  D.12671 = *D.12670;
  if (D.12671 != 0) goto <D.12672>; else goto <D.12668>;
  <D.12672>:
  D.12669 = i * 4;
  D.12670 = hash + D.12669;
  D.12671 = *D.12670;
  D.12673 = D.12671 ^ page;
  D.12674 = D.12673 & 4294966784;
  if (D.12674 == 0) goto <D.12675>; else goto <D.12668>;
  <D.12675>:
  D.12676 = 0;
  return D.12676;
  <D.12668>:
  D.12669 = i * 4;
  D.12670 = hash + D.12669;
  D.12671 = *D.12670;
  if (D.12671 == 0) goto <D.12677>; else goto <D.12678>;
  <D.12677>:
  D.12669 = i * 4;
  D.12670 = hash + D.12669;
  *D.12670 = page;
  D.12676 = 1;
  return D.12676;
  <D.12678>:
  i = i + 1;
  if (i == hsize) goto <D.12679>; else goto <D.12680>;
  <D.12679>:
  i = 0;
  <D.12680>:
  if (i != start_pos) goto <D.11110>; else goto <D.11111>;
  <D.11111>:
  printf ("failed code page store\n");
  D.12676 = 0;
  return D.12676;
}


dump_unmanaged_coderefs (struct MonoProfiler * prof)
{
  int D.12682;
  uintptr_t * code_pages.123;
  unsigned int i.124;
  unsigned int D.12689;
  uintptr_t * D.12690;
  unsigned int D.12691;
  unsigned int D.12693;
  unsigned int D.12694;
  _Bool D.12695;
  _Bool D.12696;
  _Bool D.12697;
  int size_code_pages.125;
  int i;
  const char * last_symbol;
  uintptr_t addr;
  uintptr_t page_end;

  D.12682 = load_binaries (prof);
  if (D.12682 != 0) goto <D.12683>; else goto <D.12684>;
  <D.12683>:
  return;
  <D.12684>:
  i = 0;
  goto <D.11219>;
  <D.11218>:
  {
    const char * sym;

    code_pages.123 = code_pages;
    i.124 = (unsigned int) i;
    D.12689 = i.124 * 4;
    D.12690 = code_pages.123 + D.12689;
    D.12691 = *D.12690;
    if (D.12691 == 0) goto <D.12685>; else goto <D.12692>;
    <D.12692>:
    code_pages.123 = code_pages;
    i.124 = (unsigned int) i;
    D.12689 = i.124 * 4;
    D.12690 = code_pages.123 + D.12689;
    D.12691 = *D.12690;
    D.12693 = D.12691 & 1;
    if (D.12693 != 0) goto <D.12685>; else goto <D.12686>;
    <D.12685>:
    // predicted unlikely by continue predictor.
    goto <D.11213>;
    <D.12686>:
    last_symbol = 0B;
    code_pages.123 = code_pages;
    i.124 = (unsigned int) i;
    D.12689 = i.124 * 4;
    D.12690 = code_pages.123 + D.12689;
    D.12691 = *D.12690;
    addr = D.12691 & 4294966784;
    page_end = addr + 512;
    code_pages.123 = code_pages;
    i.124 = (unsigned int) i;
    D.12689 = i.124 * 4;
    D.12690 = code_pages.123 + D.12689;
    code_pages.123 = code_pages;
    i.124 = (unsigned int) i;
    D.12689 = i.124 * 4;
    D.12690 = code_pages.123 + D.12689;
    D.12691 = *D.12690;
    D.12694 = D.12691 | 1;
    *D.12690 = D.12694;
    goto <D.11216>;
    <D.11215>:
    sym = symbol_for (addr);
    D.12695 = sym != 0B;
    D.12696 = sym == last_symbol;
    D.12697 = D.12695 & D.12696;
    if (D.12697 != 0) goto <D.12698>; else goto <D.12699>;
    <D.12698>:
    // predicted unlikely by continue predictor.
    goto <D.11214>;
    <D.12699>:
    last_symbol = sym;
    if (sym == 0B) goto <D.12700>; else goto <D.12701>;
    <D.12700>:
    // predicted unlikely by continue predictor.
    goto <D.11214>;
    <D.12701>:
    dump_usym (sym, addr, 0);
    <D.11214>:
    addr = addr + 16;
    <D.11216>:
    if (addr < page_end) goto <D.11215>; else goto <D.11217>;
    <D.11217>:
  }
  <D.11213>:
  i = i + 1;
  <D.11219>:
  size_code_pages.125 = size_code_pages;
  if (i < size_code_pages.125) goto <D.11218>; else goto <D.11220>;
  <D.11220>:
}


load_binaries (struct MonoProfiler * prof)
{
  int D.12706;

  dl_iterate_phdr (elf_dl_callback, prof);
  D.12706 = 1;
  return D.12706;
}


elf_dl_callback (struct dl_phdr_info * info, size_t size, void * data)
{
  unsigned int D.12708;
  void * D.12709;
  int D.12712;
  char D.12715;
  void * D.12720;
  char * D.12721;
  struct BinaryObject * D.12722;
  const struct Elf32_Phdr * D.12725;
  unsigned int i.126;
  unsigned int D.12727;
  const struct Elf32_Phdr * D.12728;
  unsigned int D.12729;
  unsigned int D.12732;
  unsigned int D.12733;
  unsigned int D.12734;
  unsigned int D.12735;
  unsigned int D.12738;
  unsigned int D.12739;
  long long unsigned int D.12740;
  short unsigned int D.12743;
  int D.12744;
  int D.12745;
  const char * D.12750;
  char D.12752;
  unsigned int D.12755;
  struct Elf32_Dyn * D.12756;
  int D.12757;
  int do_debug.127;
  unsigned int D.12765;
  Elf32_Word * D.12774;
  unsigned int D.12775;
  struct MonoProfiler * prof;
  char buf[256];
  const char * filename;
  struct BinaryObject * obj;
  char * a;
  int i;
  int num_sym;
  struct Elf32_Dyn * dyn;
  struct Elf32_Sym * symtab;
  Elf32_Word * hash_table;
  struct Elf32_Ehdr * header;
  const char * strtab;

  try
    {
      prof = data;
      D.12708 = info->dlpi_addr;
      a = (char *) D.12708;
      dyn = 0B;
      symtab = 0B;
      hash_table = 0B;
      header = 0B;
      strtab = 0B;
      obj = prof->binary_objects;
      goto <D.11188>;
      <D.11187>:
      D.12709 = obj->addr;
      if (D.12709 == a) goto <D.12710>; else goto <D.12711>;
      <D.12710>:
      D.12712 = 0;
      return D.12712;
      <D.12711>:
      obj = obj->next;
      <D.11188>:
      if (obj != 0B) goto <D.11187>; else goto <D.11189>;
      <D.11189>:
      filename = info->dlpi_name;
      D.12708 = info->dlpi_addr;
      if (D.12708 == 0) goto <D.12713>; else goto <D.12714>;
      <D.12713>:
      D.12715 = *filename;
      if (D.12715 == 0) goto <D.12716>; else goto <D.12717>;
      <D.12716>:
      {
        int l;

        l = readlink ("/proc/self/exe", &buf, 255);
        if (l > 0) goto <D.12718>; else goto <D.12719>;
        <D.12718>:
        buf[l] = 0;
        filename = &buf;
        <D.12719>:
      }
      <D.12717>:
      <D.12714>:
      obj = calloc (12, 1);
      D.12708 = info->dlpi_addr;
      D.12720 = (void *) D.12708;
      obj->addr = D.12720;
      D.12721 = pstrdup (filename);
      obj->name = D.12721;
      D.12722 = prof->binary_objects;
      obj->next = D.12722;
      prof->binary_objects = obj;
      a = 0B;
      i = 0;
      goto <D.11192>;
      <D.11191>:
      D.12725 = info->dlpi_phdr;
      i.126 = (unsigned int) i;
      D.12727 = i.126 * 32;
      D.12728 = D.12725 + D.12727;
      D.12729 = D.12728->p_type;
      if (D.12729 == 1) goto <D.12730>; else goto <D.12723>;
      <D.12730>:
      if (header == 0B) goto <D.12731>; else goto <D.12723>;
      <D.12731>:
      D.12708 = info->dlpi_addr;
      D.12725 = info->dlpi_phdr;
      i.126 = (unsigned int) i;
      D.12727 = i.126 * 32;
      D.12728 = D.12725 + D.12727;
      D.12732 = D.12728->p_vaddr;
      D.12733 = D.12708 + D.12732;
      header = (struct Elf32_Ehdr *) D.12733;
      D.12734 = BIT_FIELD_REF <*header, 32, 0>;
      D.12735 = D.12734;
      if (D.12735 != 1179403647) goto <D.12736>; else goto <D.12737>;
      <D.12736>:
      header = 0B;
      <D.12737>:
      D.12725 = info->dlpi_phdr;
      i.126 = (unsigned int) i;
      D.12727 = i.126 * 32;
      D.12728 = D.12725 + D.12727;
      D.12738 = D.12728->p_memsz;
      D.12725 = info->dlpi_phdr;
      i.126 = (unsigned int) i;
      D.12727 = i.126 * 32;
      D.12728 = D.12725 + D.12727;
      D.12739 = D.12728->p_offset;
      D.12740 = (long long unsigned int) D.12739;
      D.12708 = info->dlpi_addr;
      D.12725 = info->dlpi_phdr;
      i.126 = (unsigned int) i;
      D.12727 = i.126 * 32;
      D.12728 = D.12725 + D.12727;
      D.12732 = D.12728->p_vaddr;
      D.12733 = D.12708 + D.12732;
      dump_ubin (filename, D.12733, D.12740, D.12738);
      goto <D.12724>;
      <D.12723>:
      D.12725 = info->dlpi_phdr;
      i.126 = (unsigned int) i;
      D.12727 = i.126 * 32;
      D.12728 = D.12725 + D.12727;
      D.12729 = D.12728->p_type;
      if (D.12729 == 2) goto <D.12741>; else goto <D.12742>;
      <D.12741>:
      D.12708 = info->dlpi_addr;
      D.12725 = info->dlpi_phdr;
      i.126 = (unsigned int) i;
      D.12727 = i.126 * 32;
      D.12728 = D.12725 + D.12727;
      D.12732 = D.12728->p_vaddr;
      D.12733 = D.12708 + D.12732;
      dyn = (struct Elf32_Dyn *) D.12733;
      <D.12742>:
      <D.12724>:
      i = i + 1;
      <D.11192>:
      D.12743 = info->dlpi_phnum;
      D.12744 = (int) D.12743;
      if (D.12744 > i) goto <D.11191>; else goto <D.11193>;
      <D.11193>:
      D.12708 = info->dlpi_addr;
      D.12720 = (void *) D.12708;
      D.12745 = read_elf_symbols (prof, filename, D.12720);
      if (D.12745 != 0) goto <D.12746>; else goto <D.12747>;
      <D.12746>:
      D.12712 = 0;
      return D.12712;
      <D.12747>:
      D.12750 = info->dlpi_name;
      if (D.12750 == 0B) goto <D.12748>; else goto <D.12751>;
      <D.12751>:
      D.12750 = info->dlpi_name;
      D.12752 = *D.12750;
      if (D.12752 == 0) goto <D.12748>; else goto <D.12749>;
      <D.12748>:
      D.12712 = 0;
      return D.12712;
      <D.12749>:
      if (dyn == 0B) goto <D.12753>; else goto <D.12754>;
      <D.12753>:
      D.12712 = 0;
      return D.12712;
      <D.12754>:
      i = 0;
      goto <D.11195>;
      <D.11194>:
      i.126 = (unsigned int) i;
      D.12755 = i.126 * 8;
      D.12756 = dyn + D.12755;
      D.12757 = D.12756->d_tag;
      if (D.12757 == 6) goto <D.12758>; else goto <D.12759>;
      <D.12758>:
      if (symtab != 0B) goto <D.12760>; else goto <D.12761>;
      <D.12760>:
      do_debug.127 = do_debug;
      if (do_debug.127 != 0) goto <D.12763>; else goto <D.12764>;
      <D.12763>:
      printf ("multiple symtabs: %d\n", i);
      <D.12764>:
      <D.12761>:
      i.126 = (unsigned int) i;
      D.12755 = i.126 * 8;
      D.12756 = dyn + D.12755;
      D.12765 = D.12756->d_un.d_ptr;
      symtab = a + D.12765;
      goto <D.12766>;
      <D.12759>:
      i.126 = (unsigned int) i;
      D.12755 = i.126 * 8;
      D.12756 = dyn + D.12755;
      D.12757 = D.12756->d_tag;
      if (D.12757 == 4) goto <D.12767>; else goto <D.12768>;
      <D.12767>:
      i.126 = (unsigned int) i;
      D.12755 = i.126 * 8;
      D.12756 = dyn + D.12755;
      D.12765 = D.12756->d_un.d_ptr;
      hash_table = a + D.12765;
      goto <D.12769>;
      <D.12768>:
      i.126 = (unsigned int) i;
      D.12755 = i.126 * 8;
      D.12756 = dyn + D.12755;
      D.12757 = D.12756->d_tag;
      if (D.12757 == 5) goto <D.12770>; else goto <D.12771>;
      <D.12770>:
      i.126 = (unsigned int) i;
      D.12755 = i.126 * 8;
      D.12756 = dyn + D.12755;
      D.12765 = D.12756->d_un.d_ptr;
      strtab = a + D.12765;
      <D.12771>:
      <D.12769>:
      <D.12766>:
      i = i + 1;
      <D.11195>:
      i.126 = (unsigned int) i;
      D.12755 = i.126 * 8;
      D.12756 = dyn + D.12755;
      D.12757 = D.12756->d_tag;
      if (D.12757 != 0) goto <D.11194>; else goto <D.11196>;
      <D.11196>:
      if (hash_table == 0B) goto <D.12772>; else goto <D.12773>;
      <D.12772>:
      D.12712 = 0;
      return D.12712;
      <D.12773>:
      D.12774 = hash_table + 4;
      D.12775 = *D.12774;
      num_sym = (int) D.12775;
      D.12708 = info->dlpi_addr;
      D.12720 = (void *) D.12708;
      dump_elf_symbols (symtab, num_sym, strtab, D.12720);
      D.12712 = 0;
      return D.12712;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


readlink (const char * restrict __path, char * restrict __buf, size_t __len)
{
  unsigned int D.12781;
  int D.12784;
  ssize_t D.12787;
  unsigned int D.12788;
  unsigned int D.12789;
  unsigned int D.12792;

  D.12781 = __builtin_object_size (__buf, 1);
  if (D.12781 != 4294967295) goto <D.12782>; else goto <D.12783>;
  <D.12782>:
  D.12784 = __builtin_constant_p (__len);
  if (D.12784 == 0) goto <D.12785>; else goto <D.12786>;
  <D.12785>:
  D.12788 = __builtin_object_size (__buf, 1);
  D.12787 = __readlink_chk (__path, __buf, __len, D.12788);
  return D.12787;
  <D.12786>:
  D.12789 = __builtin_object_size (__buf, 1);
  if (D.12789 < __len) goto <D.12790>; else goto <D.12791>;
  <D.12790>:
  D.12792 = __builtin_object_size (__buf, 1);
  D.12787 = __readlink_chk_warn (__path, __buf, __len, D.12792);
  return D.12787;
  <D.12791>:
  <D.12783>:
  D.12787 = __readlink_alias (__path, __buf, __len);
  return D.12787;
}


pstrdup (const char * s)
{
  unsigned int D.12794;
  unsigned int D.12795;
  unsigned int len.128;
  char * D.12797;
  int len;
  char * p;

  D.12794 = strlen (s);
  D.12795 = D.12794 + 1;
  len = (int) D.12795;
  len.128 = (unsigned int) len;
  p = malloc (len.128);
  len.128 = (unsigned int) len;
  memcpy (p, s, len.128);
  D.12797 = p;
  return D.12797;
}


dump_ubin (const char * filename, uintptr_t load_addr, uint64_t offset, uintptr_t size)
{
  unsigned int D.12799;
  unsigned int D.12800;
  int D.12801;
  long long int D.12802;
  long long unsigned int D.12803;
  unsigned int len.129;
  unsigned char * D.12805;
  sizetype len.130;
  unsigned char * D.12807;
  uint64_t now;
  struct LogBuffer * logbuffer;
  int len;

  D.12799 = strlen (filename);
  D.12800 = D.12799 + 1;
  len = (int) D.12800;
  now = current_time ();
  D.12801 = len + 20;
  logbuffer = ensure_logbuf (D.12801);
  emit_byte (logbuffer, 39);
  emit_time (logbuffer, now);
  D.12802 = (long long int) load_addr;
  emit_svalue (logbuffer, D.12802);
  emit_uvalue (logbuffer, offset);
  D.12803 = (long long unsigned int) size;
  emit_uvalue (logbuffer, D.12803);
  len.129 = (unsigned int) len;
  D.12805 = logbuffer->data;
  memcpy (D.12805, filename, len.129);
  D.12805 = logbuffer->data;
  len.130 = (sizetype) len;
  D.12807 = D.12805 + len.130;
  logbuffer->data = D.12807;
}


read_elf_symbols (struct MonoProfiler * prof, const char * filename, void * load_addr)
{
  int D.12812;
  int D.12813;
  long long int D.12816;
  unsigned int D.12817;
  unsigned int D.12820;
  unsigned int D.12821;
  unsigned int D.12824;
  short unsigned int D.12825;
  int D.12826;
  short unsigned int D.12827;
  int D.12828;
  int D.12829;
  sizetype D.12830;
  unsigned int D.12831;
  unsigned int D.12832;
  unsigned int D.12835;
  unsigned int D.12836;
  unsigned int D.12837;
  sizetype D.12838;
  sizetype D.12839;
  short unsigned int D.12840;
  int D.12841;
  _Bool D.12842;
  _Bool D.12843;
  _Bool D.12844;
  unsigned int D.12847;
  unsigned int D.12848;
  unsigned int D.12849;
  unsigned int D.12850;
  unsigned int D.12851;
  int fd;
  int i;
  void * data;
  struct stat statb;
  uint64_t file_size;
  struct Elf32_Ehdr * header;
  struct Elf32_Shdr * sheader;
  struct Elf32_Shdr * shstrtabh;
  struct Elf32_Shdr * symtabh;
  struct Elf32_Shdr * strtabh;
  struct Elf32_Sym * symbols;
  const char * strtab;
  int num_symbols;

  try
    {
      symtabh = 0B;
      strtabh = 0B;
      symbols = 0B;
      fd = open (filename, 0);
      if (fd < 0) goto <D.12810>; else goto <D.12811>;
      <D.12810>:
      D.12812 = 0;
      return D.12812;
      <D.12811>:
      D.12813 = fstat (fd, &statb);
      if (D.12813 != 0) goto <D.12814>; else goto <D.12815>;
      <D.12814>:
      close (fd);
      D.12812 = 0;
      return D.12812;
      <D.12815>:
      D.12816 = statb.st_size;
      file_size = (uint64_t) D.12816;
      D.12817 = (unsigned int) file_size;
      data = mmap (0B, D.12817, 1, 2, fd, 0);
      close (fd);
      if (data == 4294967295B) goto <D.12818>; else goto <D.12819>;
      <D.12818>:
      D.12812 = 0;
      return D.12812;
      <D.12819>:
      header = data;
      D.12820 = BIT_FIELD_REF <*header, 32, 0>;
      D.12821 = D.12820;
      if (D.12821 != 1179403647) goto <D.12822>; else goto <D.12823>;
      <D.12822>:
      D.12817 = (unsigned int) file_size;
      munmap (data, D.12817);
      D.12812 = 0;
      return D.12812;
      <D.12823>:
      D.12824 = header->e_shoff;
      sheader = data + D.12824;
      D.12825 = header->e_shentsize;
      D.12826 = (int) D.12825;
      D.12827 = header->e_shstrndx;
      D.12828 = (int) D.12827;
      D.12829 = D.12826 * D.12828;
      D.12830 = (sizetype) D.12829;
      shstrtabh = sheader + D.12830;
      D.12831 = shstrtabh->sh_offset;
      strtab = data + D.12831;
      i = 0;
      goto <D.11169>;
      <D.11168>:
      D.12832 = sheader->sh_type;
      if (D.12832 == 2) goto <D.12833>; else goto <D.12834>;
      <D.12833>:
      symtabh = sheader;
      D.12824 = header->e_shoff;
      D.12835 = sheader->sh_link;
      D.12825 = header->e_shentsize;
      D.12836 = (unsigned int) D.12825;
      D.12837 = D.12835 * D.12836;
      D.12838 = D.12824 + D.12837;
      strtabh = data + D.12838;
      goto <D.11167>;
      <D.12834>:
      D.12825 = header->e_shentsize;
      D.12839 = (sizetype) D.12825;
      sheader = sheader + D.12839;
      i = i + 1;
      <D.11169>:
      D.12840 = header->e_shnum;
      D.12841 = (int) D.12840;
      if (D.12841 > i) goto <D.11168>; else goto <D.11167>;
      <D.11167>:
      D.12842 = symtabh == 0B;
      D.12843 = strtabh == 0B;
      D.12844 = D.12842 | D.12843;
      if (D.12844 != 0) goto <D.12845>; else goto <D.12846>;
      <D.12845>:
      D.12817 = (unsigned int) file_size;
      munmap (data, D.12817);
      D.12812 = 0;
      return D.12812;
      <D.12846>:
      D.12847 = strtabh->sh_offset;
      strtab = data + D.12847;
      D.12848 = symtabh->sh_size;
      D.12849 = symtabh->sh_entsize;
      D.12850 = D.12848 / D.12849;
      num_symbols = (int) D.12850;
      D.12851 = symtabh->sh_offset;
      symbols = data + D.12851;
      dump_elf_symbols (symbols, num_symbols, strtab, load_addr);
      D.12817 = (unsigned int) file_size;
      munmap (data, D.12817);
      D.12812 = 1;
      return D.12812;
    }
  finally
    {
      statb = {CLOBBER};
    }
}


open (const char * __path, int __oflag)
{
  int D.12856;
  int D.12859;
  int D.12864;
  int D.12866;
  int D.12867;
  int D.12870;
  int D.12871;

  D.12856 = __builtin_va_arg_pack_len ();
  if (D.12856 > 1) goto <D.12857>; else goto <D.12858>;
  <D.12857>:
  __open_too_many_args ();
  <D.12858>:
  D.12859 = __builtin_constant_p (__oflag);
  if (D.12859 != 0) goto <D.12860>; else goto <D.12861>;
  <D.12860>:
  D.12864 = __oflag & 64;
  if (D.12864 != 0) goto <D.12862>; else goto <D.12865>;
  <D.12865>:
  D.12866 = __oflag & 4259840;
  if (D.12866 == 4259840) goto <D.12862>; else goto <D.12863>;
  <D.12862>:
  D.12867 = __builtin_va_arg_pack_len ();
  if (D.12867 <= 0) goto <D.12868>; else goto <D.12869>;
  <D.12868>:
  __open_missing_mode ();
  D.12870 = __open_2 (__path, __oflag);
  return D.12870;
  <D.12869>:
  <D.12863>:
  D.12870 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.12870;
  <D.12861>:
  D.12871 = __builtin_va_arg_pack_len ();
  if (D.12871 <= 0) goto <D.12872>; else goto <D.12873>;
  <D.12872>:
  D.12870 = __open_2 (__path, __oflag);
  return D.12870;
  <D.12873>:
  D.12870 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.12870;
}


fstat (int __fd, struct stat * __statbuf)
{
  int D.12879;

  D.12879 = __fxstat (3, __fd, __statbuf);
  return D.12879;
}


dump_elf_symbols (struct Elf32_Sym * symbols, int num_symbols, const char * strtab, void * load_addr)
{
  unsigned int i.131;
  unsigned int D.12882;
  struct Elf32_Sym * D.12883;
  unsigned int D.12884;
  unsigned int D.12888;
  unsigned char D.12890;
  int D.12891;
  int D.12892;
  unsigned int D.12893;
  unsigned int load_addr.132;
  unsigned int D.12895;
  int i;

  i = 0;
  goto <D.11147>;
  <D.11146>:
  {
    const char * sym;

    i.131 = (unsigned int) i;
    D.12882 = i.131 * 16;
    D.12883 = symbols + D.12882;
    D.12884 = D.12883->st_name;
    sym = strtab + D.12884;
    i.131 = (unsigned int) i;
    D.12882 = i.131 * 16;
    D.12883 = symbols + D.12882;
    D.12884 = D.12883->st_name;
    if (D.12884 == 0) goto <D.12885>; else goto <D.12887>;
    <D.12887>:
    i.131 = (unsigned int) i;
    D.12882 = i.131 * 16;
    D.12883 = symbols + D.12882;
    D.12888 = D.12883->st_size;
    if (D.12888 == 0) goto <D.12885>; else goto <D.12889>;
    <D.12889>:
    i.131 = (unsigned int) i;
    D.12882 = i.131 * 16;
    D.12883 = symbols + D.12882;
    D.12890 = D.12883->st_info;
    D.12891 = (int) D.12890;
    D.12892 = D.12891 & 15;
    if (D.12892 != 2) goto <D.12885>; else goto <D.12886>;
    <D.12885>:
    // predicted unlikely by continue predictor.
    goto <D.11145>;
    <D.12886>:
    i.131 = (unsigned int) i;
    D.12882 = i.131 * 16;
    D.12883 = symbols + D.12882;
    D.12888 = D.12883->st_size;
    i.131 = (unsigned int) i;
    D.12882 = i.131 * 16;
    D.12883 = symbols + D.12882;
    D.12893 = D.12883->st_value;
    load_addr.132 = (unsigned int) load_addr;
    D.12895 = D.12893 + load_addr.132;
    dump_usym (sym, D.12895, D.12888);
  }
  <D.11145>:
  i = i + 1;
  <D.11147>:
  if (i < num_symbols) goto <D.11146>; else goto <D.11148>;
  <D.11148>:
}


symbol_for (uintptr_t code)
{
  int D.12896;
  const char * D.12899;
  const char * D.12902;
  void * ip;
  struct Dl_info di;

  try
    {
      ip = (void *) code;
      D.12896 = dladdr (ip, &di);
      if (D.12896 != 0) goto <D.12897>; else goto <D.12898>;
      <D.12897>:
      D.12899 = di.dli_sname;
      if (D.12899 != 0B) goto <D.12900>; else goto <D.12901>;
      <D.12900>:
      D.12902 = di.dli_sname;
      return D.12902;
      <D.12901>:
      goto <D.12903>;
      <D.12898>:
      <D.12903>:
      D.12902 = 0B;
      return D.12902;
    }
  finally
    {
      di = {CLOBBER};
    }
}


dump_usym (const char * name, uintptr_t value, uintptr_t size)
{
  unsigned int D.12906;
  unsigned int D.12907;
  int D.12908;
  void * value.133;
  int size.134;
  unsigned int len.135;
  unsigned char * D.12912;
  sizetype len.136;
  unsigned char * D.12914;
  struct LogBuffer * logbuffer;
  int len;

  D.12906 = strlen (name);
  D.12907 = D.12906 + 1;
  len = (int) D.12907;
  D.12908 = len + 20;
  logbuffer = ensure_logbuf (D.12908);
  emit_byte (logbuffer, 23);
  value.133 = (void *) value;
  emit_ptr (logbuffer, value.133);
  size.134 = (int) size;
  emit_value (logbuffer, size.134);
  len.135 = (unsigned int) len;
  D.12912 = logbuffer->data;
  memcpy (D.12912, name, len.135);
  D.12912 = logbuffer->data;
  len.136 = (sizetype) len;
  D.12914 = D.12912 + len.136;
  logbuffer->data = D.12914;
}


dump_sample_hits (struct MonoProfiler * prof, struct StatBuffer * sbuf, int recurse)
{
  struct StatBuffer * D.12920;
  unsigned int D.12923;
  int D.12924;
  unsigned int D.12925;
  int D.12926;
  unsigned int D.12927;
  sizetype count.137;
  sizetype D.12929;
  sizetype D.12930;
  uintptr_t * D.12931;
  uintptr_t * D.12932;
  int D.12934;
  int D.12935;
  long long unsigned int D.12936;
  uintptr_t * D.12937;
  unsigned int D.12938;
  long long unsigned int D.12939;
  long long unsigned int D.12940;
  long long unsigned int D.12941;
  sizetype i.138;
  sizetype D.12943;
  sizetype D.12944;
  uintptr_t * D.12945;
  unsigned int D.12946;
  void * D.12947;
  uintptr_t * sample;
  struct LogBuffer * logbuffer;

  if (sbuf == 0B) goto <D.12916>; else goto <D.12917>;
  <D.12916>:
  return;
  <D.12917>:
  if (recurse != 0) goto <D.12918>; else goto <D.12919>;
  <D.12918>:
  D.12920 = sbuf->next;
  if (D.12920 != 0B) goto <D.12921>; else goto <D.12922>;
  <D.12921>:
  D.12920 = sbuf->next;
  dump_sample_hits (prof, D.12920, 1);
  D.12920 = sbuf->next;
  D.12923 = D.12920->size;
  D.12924 = (int) D.12923;
  D.12920 = sbuf->next;
  free_buffer (D.12920, D.12924);
  sbuf->next = 0B;
  <D.12922>:
  <D.12919>:
  sample = &sbuf->buf;
  goto <D.11236>;
  <D.11235>:
  {
    int i;
    int count;
    int type;

    D.12925 = *sample;
    D.12926 = (int) D.12925;
    count = D.12926 & 65535;
    D.12925 = *sample;
    D.12927 = D.12925 >> 16;
    type = (int) D.12927;
    count.137 = (sizetype) count;
    D.12929 = count.137 + 3;
    D.12930 = D.12929 * 4;
    D.12931 = sample + D.12930;
    D.12932 = sbuf->data;
    if (D.12931 > D.12932) goto <D.11231>; else goto <D.12933>;
    <D.12933>:
    D.12934 = count * 8;
    D.12935 = D.12934 + 20;
    logbuffer = ensure_logbuf (D.12935);
    emit_byte (logbuffer, 7);
    emit_value (logbuffer, type);
    D.12936 = prof->startup_time;
    D.12937 = sample + 8;
    D.12938 = *D.12937;
    D.12939 = (long long unsigned int) D.12938;
    D.12940 = D.12939 * 10000;
    D.12941 = D.12936 + D.12940;
    emit_uvalue (logbuffer, D.12941);
    emit_value (logbuffer, count);
    i = 0;
    goto <D.11233>;
    <D.11232>:
    i.138 = (sizetype) i;
    D.12943 = i.138 + 3;
    D.12944 = D.12943 * 4;
    D.12945 = sample + D.12944;
    D.12946 = *D.12945;
    D.12947 = (void *) D.12946;
    emit_ptr (logbuffer, D.12947);
    i.138 = (sizetype) i;
    D.12943 = i.138 + 3;
    D.12944 = D.12943 * 4;
    D.12945 = sample + D.12944;
    D.12946 = *D.12945;
    add_code_pointer (D.12946);
    i = i + 1;
    <D.11233>:
    if (i < count) goto <D.11232>; else goto <D.11234>;
    <D.11234>:
    count.137 = (sizetype) count;
    D.12929 = count.137 + 3;
    D.12930 = D.12929 * 4;
    sample = sample + D.12930;
  }
  <D.11236>:
  D.12932 = sbuf->data;
  if (D.12932 > sample) goto <D.11235>; else goto <D.11231>;
  <D.11231>:
  dump_unmanaged_coderefs (prof);
}


set_sample_mode (char * val, int allow_empty)
{
  _Bool D.12950;
  _Bool D.12951;
  _Bool D.12952;
  int D.11473;
  int iftmp.139;
  int D.11472;
  const char[5] * D.12958;
  unsigned char D.12959;
  int D.12960;
  unsigned char D.12961;
  int D.12962;
  _Bool D.12963;
  _Bool D.12964;
  _Bool D.12965;
  const unsigned char * D.12968;
  unsigned char D.12969;
  int D.12970;
  const unsigned char * D.12971;
  unsigned char D.12972;
  int D.12973;
  _Bool D.12974;
  _Bool D.12975;
  const unsigned char * D.12978;
  unsigned char D.12979;
  int D.12980;
  const unsigned char * D.12981;
  unsigned char D.12982;
  int D.12983;
  _Bool D.12984;
  _Bool D.12985;
  const unsigned char * D.12988;
  unsigned char D.12989;
  int D.12990;
  const unsigned char * D.12991;
  unsigned char D.12992;
  int D.12993;
  const char * D.12997;
  unsigned int D.12998;
  unsigned int l.140;
  int D.13000;
  int sample_type.141;
  sizetype l.142;
  char D.13007;
  char * D.13010;
  char * end.143;
  int count.144;
  char * end;
  char * maybe_freq;
  unsigned int count;
  const struct SampleMode * smode;

  try
    {
      maybe_freq = 0B;
      smode = &sample_modes;
      D.12950 = allow_empty != 0;
      D.12951 = val == 0B;
      D.12952 = D.12950 & D.12951;
      if (D.12952 != 0) goto <D.12953>; else goto <D.12954>;
      <D.12953>:
      sample_type = 1;
      sample_freq = 1000;
      return;
      <D.12954>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = val;
          D.12958 = "mono";
          D.12959 = MEM[(const unsigned char *)D.12958];
          D.12960 = (int) D.12959;
          D.12961 = *__s2;
          D.12962 = (int) D.12961;
          __result = D.12960 - D.12962;
          {
            D.12963 = __s2_len != 0;
            D.12964 = __result == 0;
            D.12965 = D.12963 & D.12964;
            if (D.12965 != 0) goto <D.12966>; else goto <D.12967>;
            <D.12966>:
            D.12968 = &MEM[(void *)"mono" + 1B];
            D.12969 = *D.12968;
            D.12970 = (int) D.12969;
            D.12971 = __s2 + 1;
            D.12972 = *D.12971;
            D.12973 = (int) D.12972;
            __result = D.12970 - D.12973;
            D.12974 = __s2_len > 1;
            D.12964 = __result == 0;
            D.12975 = D.12974 & D.12964;
            if (D.12975 != 0) goto <D.12976>; else goto <D.12977>;
            <D.12976>:
            D.12978 = &MEM[(void *)"mono" + 2B];
            D.12979 = *D.12978;
            D.12980 = (int) D.12979;
            D.12981 = __s2 + 2;
            D.12982 = *D.12981;
            D.12983 = (int) D.12982;
            __result = D.12980 - D.12983;
            D.12984 = __s2_len > 2;
            D.12964 = __result == 0;
            D.12985 = D.12984 & D.12964;
            if (D.12985 != 0) goto <D.12986>; else goto <D.12987>;
            <D.12986>:
            D.12988 = &MEM[(void *)"mono" + 3B];
            D.12989 = *D.12988;
            D.12990 = (int) D.12989;
            D.12991 = __s2 + 3;
            D.12992 = *D.12991;
            D.12993 = (int) D.12992;
            __result = D.12990 - D.12993;
            <D.12987>:
            <D.12977>:
            <D.12967>:
          }
          D.11472 = __result;
        }
        iftmp.139 = -D.11472;
        goto <D.12994>;
        <D.12957>:
        iftmp.139 = __builtin_strcmp (val, "mono");
        <D.12994>:
        D.11473 = iftmp.139;
      }
      if (D.11473 == 0) goto <D.12995>; else goto <D.12996>;
      <D.12995>:
      do_mono_sample = 1;
      sample_type = 1;
      free (val);
      return;
      <D.12996>:
      smode = &sample_modes;
      goto <D.11486>;
      <D.11485>:
      {
        int l;

        D.12997 = smode->name;
        D.12998 = strlen (D.12997);
        l = (int) D.12998;
        l.140 = (unsigned int) l;
        D.12997 = smode->name;
        D.13000 = strncmp (val, D.12997, l.140);
        if (D.13000 == 0) goto <D.13001>; else goto <D.13002>;
        <D.13001>:
        sample_type.141 = smode->sample_mode;
        sample_type = sample_type.141;
        l.142 = (sizetype) l;
        maybe_freq = val + l.142;
        goto <D.11484>;
        <D.13002>:
      }
      smode = smode + 8;
      <D.11486>:
      D.12997 = smode->name;
      if (D.12997 != 0B) goto <D.11485>; else goto <D.11484>;
      <D.11484>:
      D.12997 = smode->name;
      if (D.12997 == 0B) goto <D.13005>; else goto <D.13006>;
      <D.13005>:
      usage (1);
      <D.13006>:
      D.13007 = *maybe_freq;
      if (D.13007 == 47) goto <D.13008>; else goto <D.13009>;
      <D.13008>:
      D.13010 = maybe_freq + 1;
      count = strtoul (D.13010, &end, 10);
      D.13010 = maybe_freq + 1;
      end.143 = end;
      if (D.13010 == end.143) goto <D.13012>; else goto <D.13013>;
      <D.13012>:
      usage (1);
      <D.13013>:
      count.144 = (int) count;
      sample_freq = count.144;
      goto <D.13015>;
      <D.13009>:
      D.13007 = *maybe_freq;
      if (D.13007 != 0) goto <D.13016>; else goto <D.13017>;
      <D.13016>:
      usage (1);
      goto <D.13018>;
      <D.13017>:
      sample_freq = 1000;
      <D.13018>:
      <D.13015>:
      free (val);
    }
  finally
    {
      end = {CLOBBER};
    }
}


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

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


set_hsmode (char * val, int allow_empty)
{
  _Bool D.13026;
  _Bool D.13027;
  _Bool D.13028;
  int D.11501;
  int iftmp.145;
  int D.11500;
  const char[9] * D.13034;
  unsigned char D.13035;
  int D.13036;
  unsigned char D.13037;
  int D.13038;
  _Bool D.13039;
  _Bool D.13040;
  _Bool D.13041;
  const unsigned char * D.13044;
  unsigned char D.13045;
  int D.13046;
  const unsigned char * D.13047;
  unsigned char D.13048;
  int D.13049;
  _Bool D.13050;
  _Bool D.13051;
  const unsigned char * D.13054;
  unsigned char D.13055;
  int D.13056;
  const unsigned char * D.13057;
  unsigned char D.13058;
  int D.13059;
  _Bool D.13060;
  _Bool D.13061;
  const unsigned char * D.13064;
  unsigned char D.13065;
  int D.13066;
  const unsigned char * D.13067;
  unsigned char D.13068;
  int D.13069;
  char * end.146;
  int D.11510;
  int iftmp.147;
  int D.11509;
  const char[3] * D.13079;
  unsigned char D.13080;
  int D.13081;
  unsigned char D.13082;
  int D.13083;
  _Bool D.13084;
  _Bool D.13085;
  _Bool D.13086;
  const unsigned char * D.13089;
  unsigned char D.13090;
  int D.13091;
  const unsigned char * D.13092;
  unsigned char D.13093;
  int D.13094;
  _Bool D.13095;
  _Bool D.13096;
  const unsigned char * D.13099;
  unsigned char D.13100;
  int D.13101;
  const unsigned char * D.13102;
  unsigned char D.13103;
  int D.13104;
  _Bool D.13105;
  _Bool D.13106;
  const unsigned char * D.13109;
  unsigned char D.13110;
  int D.13111;
  const unsigned char * D.13112;
  unsigned char D.13113;
  int D.13114;
  int D.11519;
  int iftmp.148;
  int D.11518;
  const char[3] * D.13122;
  unsigned char D.13123;
  int D.13124;
  unsigned char D.13125;
  int D.13126;
  _Bool D.13127;
  _Bool D.13128;
  _Bool D.13129;
  const unsigned char * D.13132;
  unsigned char D.13133;
  int D.13134;
  const unsigned char * D.13135;
  unsigned char D.13136;
  int D.13137;
  _Bool D.13138;
  _Bool D.13139;
  const unsigned char * D.13142;
  unsigned char D.13143;
  int D.13144;
  const unsigned char * D.13145;
  unsigned char D.13146;
  int D.13147;
  _Bool D.13148;
  _Bool D.13149;
  const unsigned char * D.13152;
  unsigned char D.13153;
  int D.13154;
  const unsigned char * D.13155;
  unsigned char D.13156;
  int D.13157;
  char * end;
  unsigned int count;

  try
    {
      D.13026 = allow_empty != 0;
      D.13027 = val == 0B;
      D.13028 = D.13026 & D.13027;
      if (D.13028 != 0) goto <D.13029>; else goto <D.13030>;
      <D.13029>:
      return;
      <D.13030>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.13032>; else goto <D.13033>;
        <D.13032>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = val;
          D.13034 = "ondemand";
          D.13035 = MEM[(const unsigned char *)D.13034];
          D.13036 = (int) D.13035;
          D.13037 = *__s2;
          D.13038 = (int) D.13037;
          __result = D.13036 - D.13038;
          {
            D.13039 = __s2_len != 0;
            D.13040 = __result == 0;
            D.13041 = D.13039 & D.13040;
            if (D.13041 != 0) goto <D.13042>; else goto <D.13043>;
            <D.13042>:
            D.13044 = &MEM[(void *)"ondemand" + 1B];
            D.13045 = *D.13044;
            D.13046 = (int) D.13045;
            D.13047 = __s2 + 1;
            D.13048 = *D.13047;
            D.13049 = (int) D.13048;
            __result = D.13046 - D.13049;
            D.13050 = __s2_len > 1;
            D.13040 = __result == 0;
            D.13051 = D.13050 & D.13040;
            if (D.13051 != 0) goto <D.13052>; else goto <D.13053>;
            <D.13052>:
            D.13054 = &MEM[(void *)"ondemand" + 2B];
            D.13055 = *D.13054;
            D.13056 = (int) D.13055;
            D.13057 = __s2 + 2;
            D.13058 = *D.13057;
            D.13059 = (int) D.13058;
            __result = D.13056 - D.13059;
            D.13060 = __s2_len > 2;
            D.13040 = __result == 0;
            D.13061 = D.13060 & D.13040;
            if (D.13061 != 0) goto <D.13062>; else goto <D.13063>;
            <D.13062>:
            D.13064 = &MEM[(void *)"ondemand" + 3B];
            D.13065 = *D.13064;
            D.13066 = (int) D.13065;
            D.13067 = __s2 + 3;
            D.13068 = *D.13067;
            D.13069 = (int) D.13068;
            __result = D.13066 - D.13069;
            <D.13063>:
            <D.13053>:
            <D.13043>:
          }
          D.11500 = __result;
        }
        iftmp.145 = -D.11500;
        goto <D.13070>;
        <D.13033>:
        iftmp.145 = __builtin_strcmp (val, "ondemand");
        <D.13070>:
        D.11501 = iftmp.145;
      }
      if (D.11501 == 0) goto <D.13071>; else goto <D.13072>;
      <D.13071>:
      hs_mode_ondemand = 1;
      free (val);
      return;
      <D.13072>:
      count = strtoul (val, &end, 10);
      end.146 = end;
      if (val == end.146) goto <D.13074>; else goto <D.13075>;
      <D.13074>:
      usage (1);
      <D.13075>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 2;
        if (__s2_len <= 3) goto <D.13077>; else goto <D.13078>;
        <D.13077>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = end;
          D.13079 = "ms";
          D.13080 = MEM[(const unsigned char *)D.13079];
          D.13081 = (int) D.13080;
          D.13082 = *__s2;
          D.13083 = (int) D.13082;
          __result = D.13081 - D.13083;
          {
            D.13084 = __s2_len != 0;
            D.13085 = __result == 0;
            D.13086 = D.13084 & D.13085;
            if (D.13086 != 0) goto <D.13087>; else goto <D.13088>;
            <D.13087>:
            D.13089 = &MEM[(void *)"ms" + 1B];
            D.13090 = *D.13089;
            D.13091 = (int) D.13090;
            D.13092 = __s2 + 1;
            D.13093 = *D.13092;
            D.13094 = (int) D.13093;
            __result = D.13091 - D.13094;
            D.13095 = __s2_len > 1;
            D.13085 = __result == 0;
            D.13096 = D.13095 & D.13085;
            if (D.13096 != 0) goto <D.13097>; else goto <D.13098>;
            <D.13097>:
            D.13099 = &MEM[(void *)"ms" + 2B];
            D.13100 = *D.13099;
            D.13101 = (int) D.13100;
            D.13102 = __s2 + 2;
            D.13103 = *D.13102;
            D.13104 = (int) D.13103;
            __result = D.13101 - D.13104;
            D.13105 = __s2_len > 2;
            D.13085 = __result == 0;
            D.13106 = D.13105 & D.13085;
            if (D.13106 != 0) goto <D.13107>; else goto <D.13108>;
            <D.13107>:
            D.13109 = &MEM[(void *)"ms" + 3B];
            D.13110 = *D.13109;
            D.13111 = (int) D.13110;
            D.13112 = __s2 + 3;
            D.13113 = *D.13112;
            D.13114 = (int) D.13113;
            __result = D.13111 - D.13114;
            <D.13108>:
            <D.13098>:
            <D.13088>:
          }
          D.11509 = __result;
        }
        iftmp.147 = -D.11509;
        goto <D.13115>;
        <D.13078>:
        end.146 = end;
        iftmp.147 = __builtin_strcmp (end.146, "ms");
        <D.13115>:
        D.11510 = iftmp.147;
      }
      if (D.11510 == 0) goto <D.13116>; else goto <D.13117>;
      <D.13116>:
      hs_mode_ms = count;
      goto <D.13118>;
      <D.13117>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 2;
        if (__s2_len <= 3) goto <D.13120>; else goto <D.13121>;
        <D.13120>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = end;
          D.13122 = "gc";
          D.13123 = MEM[(const unsigned char *)D.13122];
          D.13124 = (int) D.13123;
          D.13125 = *__s2;
          D.13126 = (int) D.13125;
          __result = D.13124 - D.13126;
          {
            D.13127 = __s2_len != 0;
            D.13128 = __result == 0;
            D.13129 = D.13127 & D.13128;
            if (D.13129 != 0) goto <D.13130>; else goto <D.13131>;
            <D.13130>:
            D.13132 = &MEM[(void *)"gc" + 1B];
            D.13133 = *D.13132;
            D.13134 = (int) D.13133;
            D.13135 = __s2 + 1;
            D.13136 = *D.13135;
            D.13137 = (int) D.13136;
            __result = D.13134 - D.13137;
            D.13138 = __s2_len > 1;
            D.13128 = __result == 0;
            D.13139 = D.13138 & D.13128;
            if (D.13139 != 0) goto <D.13140>; else goto <D.13141>;
            <D.13140>:
            D.13142 = &MEM[(void *)"gc" + 2B];
            D.13143 = *D.13142;
            D.13144 = (int) D.13143;
            D.13145 = __s2 + 2;
            D.13146 = *D.13145;
            D.13147 = (int) D.13146;
            __result = D.13144 - D.13147;
            D.13148 = __s2_len > 2;
            D.13128 = __result == 0;
            D.13149 = D.13148 & D.13128;
            if (D.13149 != 0) goto <D.13150>; else goto <D.13151>;
            <D.13150>:
            D.13152 = &MEM[(void *)"gc" + 3B];
            D.13153 = *D.13152;
            D.13154 = (int) D.13153;
            D.13155 = __s2 + 3;
            D.13156 = *D.13155;
            D.13157 = (int) D.13156;
            __result = D.13154 - D.13157;
            <D.13151>:
            <D.13141>:
            <D.13131>:
          }
          D.11518 = __result;
        }
        iftmp.148 = -D.11518;
        goto <D.13158>;
        <D.13121>:
        end.146 = end;
        iftmp.148 = __builtin_strcmp (end.146, "gc");
        <D.13158>:
        D.11519 = iftmp.148;
      }
      if (D.11519 == 0) goto <D.13159>; else goto <D.13160>;
      <D.13159>:
      hs_mode_gc = count;
      goto <D.13161>;
      <D.13160>:
      usage (1);
      <D.13161>:
      <D.13118>:
      free (val);
    }
  finally
    {
      end = {CLOBBER};
    }
}


match_option (const char * p, const char * opt, char * * rval)
{
  unsigned int D.13166;
  unsigned int len.149;
  int D.13168;
  sizetype len.150;
  const char * D.13174;
  char D.13175;
  sizetype D.13178;
  const char * D.13179;
  char D.13180;
  unsigned int D.13185;
  int end.151;
  int opt.152;
  int D.13189;
  unsigned int D.13190;
  unsigned int l.153;
  sizetype l.154;
  char * D.13193;
  const char * D.13194;
  _Bool D.13195;
  _Bool D.13196;
  _Bool D.13197;
  unsigned int D.13200;
  sizetype D.13201;
  int len;

  D.13166 = strlen (opt);
  len = (int) D.13166;
  len.149 = (unsigned int) len;
  D.13168 = strncmp (p, opt, len.149);
  if (D.13168 == 0) goto <D.13169>; else goto <D.13170>;
  <D.13169>:
  if (rval != 0B) goto <D.13171>; else goto <D.13172>;
  <D.13171>:
  len.150 = (sizetype) len;
  D.13174 = p + len.150;
  D.13175 = *D.13174;
  if (D.13175 == 61) goto <D.13176>; else goto <D.13177>;
  <D.13176>:
  len.150 = (sizetype) len;
  D.13178 = len.150 + 1;
  D.13179 = p + D.13178;
  D.13180 = *D.13179;
  if (D.13180 != 0) goto <D.13181>; else goto <D.13182>;
  <D.13181>:
  {
    const char * opt;
    const char * end;
    char * val;
    int l;

    len.150 = (sizetype) len;
    D.13178 = len.150 + 1;
    opt = p + D.13178;
    end = __builtin_strchr (opt, 44);
    if (end == 0B) goto <D.13183>; else goto <D.13184>;
    <D.13183>:
    D.13185 = strlen (opt);
    l = (int) D.13185;
    goto <D.13186>;
    <D.13184>:
    end.151 = (int) end;
    opt.152 = (int) opt;
    l = end.151 - opt.152;
    <D.13186>:
    D.13189 = l + 1;
    D.13190 = (unsigned int) D.13189;
    val = malloc (D.13190);
    l.153 = (unsigned int) l;
    memcpy (val, opt, l.153);
    l.154 = (sizetype) l;
    D.13193 = val + l.154;
    *D.13193 = 0;
    *rval = val;
    l.154 = (sizetype) l;
    D.13194 = opt + l.154;
    return D.13194;
  }
  <D.13182>:
  <D.13177>:
  len.150 = (sizetype) len;
  D.13174 = p + len.150;
  D.13175 = *D.13174;
  D.13195 = D.13175 == 0;
  len.150 = (sizetype) len;
  D.13174 = p + len.150;
  D.13175 = *D.13174;
  D.13196 = D.13175 == 44;
  D.13197 = D.13195 | D.13196;
  if (D.13197 != 0) goto <D.13198>; else goto <D.13199>;
  <D.13198>:
  *rval = 0B;
  len.150 = (sizetype) len;
  D.13174 = p + len.150;
  D.13175 = *D.13174;
  D.13196 = D.13175 == 44;
  D.13200 = (unsigned int) D.13196;
  len.150 = (sizetype) len;
  D.13201 = D.13200 + len.150;
  D.13194 = p + D.13201;
  return D.13194;
  <D.13199>:
  usage (1);
  goto <D.13202>;
  <D.13172>:
  len.150 = (sizetype) len;
  D.13174 = p + len.150;
  D.13175 = *D.13174;
  if (D.13175 == 0) goto <D.13203>; else goto <D.13204>;
  <D.13203>:
  len.150 = (sizetype) len;
  D.13194 = p + len.150;
  return D.13194;
  <D.13204>:
  len.150 = (sizetype) len;
  D.13174 = p + len.150;
  D.13175 = *D.13174;
  if (D.13175 == 44) goto <D.13205>; else goto <D.13206>;
  <D.13205>:
  len.150 = (sizetype) len;
  D.13178 = len.150 + 1;
  D.13194 = p + D.13178;
  return D.13194;
  <D.13206>:
  <D.13202>:
  <D.13170>:
  D.13194 = p;
  return D.13194;
}


usage (int do_exit)
{
  printf ("Log profiler version %d.%d (format: %d)\n", 0, 4, 4);
  printf ("Usage: mono --profile=log[:OPTION1[,OPTION2...]] program.exe\n");
  printf ("Options:\n");
  printf ("\thelp             show this usage info\n");
  printf ("\t[no]alloc        enable/disable recording allocation info\n");
  printf ("\t[no]calls        enable/disable recording enter/leave method events\n");
  printf ("\theapshot[=MODE]  record heap shot info (by default at each major collection)\n");
  printf ("\t                 MODE: every XXms milliseconds, every YYgc collections, ondemand\n");
  printf ("\tsample[=TYPE]    use statistical sampling mode (by default cycles/1000)\n");
  printf ("\t                 TYPE: cycles,instr,cacherefs,cachemiss,branches,branchmiss\n");
  printf ("\t                 TYPE can be followed by /FREQUENCY\n");
  printf ("\ttime=fast        use a faster (but more inaccurate) timer\n");
  printf ("\tmaxframes=NUM    collect up to NUM stack frames\n");
  printf ("\tcalldepth=NUM    ignore method events for call chain depth bigger than NUM\n");
  printf ("\toutput=FILENAME  write the data to file FILENAME (-FILENAME to overwrite)\n");
  printf ("\toutput=|PROGRAM  write the data to the stdin of PROGRAM\n");
  printf ("\t                 %%t is subtituted with date and time, %%p with the pid\n");
  printf ("\treport           create a report instead of writing the raw data to a file\n");
  printf ("\tzip              compress the output data\n");
  printf ("\tport=PORTNUM     use PORTNUM for the listening command server\n");
  if (do_exit != 0) goto <D.13208>; else goto <D.13209>;
  <D.13208>:
  exit (1);
  <D.13209>:
}


create_profiler (const char * filename)
{
  int command_port.155;
  char D.13213;
  int do_report.156;
  unsigned int D.13225;
  unsigned int D.13226;
  unsigned int s.157;
  char D.13228;
  const char * D.13231;
  struct FILE * D.13232;
  char * D.13236;
  struct FILE * D.13237;
  struct _IO_FILE * stderr.158;
  struct MonoProfiler * D.13244;
  struct FILE * D.13245;
  struct FILE * D.13246;
  int sample_type.159;
  int do_mono_sample.160;
  struct PerfData * perf_data.161;
  struct StatBuffer * D.13260;
  unsigned int hs_mode_ondemand.162;
  int D.13265;
  long long unsigned int D.13268;
  struct MonoProfiler * prof;
  char * nf;
  int force_delete;
  int need_helper_thread;

  force_delete = 0;
  need_helper_thread = 0;
  prof = calloc (1, 52);
  command_port.155 = command_port;
  prof->command_port = command_port.155;
  if (filename != 0B) goto <D.13211>; else goto <D.13212>;
  <D.13211>:
  D.13213 = *filename;
  if (D.13213 == 45) goto <D.13214>; else goto <D.13215>;
  <D.13214>:
  force_delete = 1;
  filename = filename + 1;
  <D.13215>:
  <D.13212>:
  if (filename == 0B) goto <D.13216>; else goto <D.13217>;
  <D.13216>:
  do_report.156 = do_report;
  if (do_report.156 != 0) goto <D.13219>; else goto <D.13220>;
  <D.13219>:
  filename = "|mprof-report -";
  goto <D.13221>;
  <D.13220>:
  filename = "output.mlpd";
  <D.13221>:
  nf = filename;
  goto <D.13222>;
  <D.13217>:
  nf = new_filename (filename);
  do_report.156 = do_report;
  if (do_report.156 != 0) goto <D.13223>; else goto <D.13224>;
  <D.13223>:
  {
    int s;
    char * p;

    D.13225 = strlen (nf);
    D.13226 = D.13225 + 32;
    s = (int) D.13226;
    s.157 = (unsigned int) s;
    p = malloc (s.157);
    s.157 = (unsigned int) s;
    snprintf (p, s.157, "|mprof-report \'--out=%s\' -", nf);
    free (nf);
    nf = p;
  }
  <D.13224>:
  <D.13222>:
  D.13228 = *nf;
  if (D.13228 == 124) goto <D.13229>; else goto <D.13230>;
  <D.13229>:
  D.13231 = nf + 1;
  D.13232 = popen (D.13231, "w");
  prof->file = D.13232;
  prof->pipe_output = 1;
  goto <D.13233>;
  <D.13230>:
  D.13228 = *nf;
  if (D.13228 == 35) goto <D.13234>; else goto <D.13235>;
  <D.13234>:
  {
    int fd;

    D.13236 = nf + 1;
    fd = strtol (D.13236, 0B, 10);
    D.13237 = fdopen (fd, "a");
    prof->file = D.13237;
  }
  goto <D.13238>;
  <D.13235>:
  {
    struct FILE * f;

    if (force_delete != 0) goto <D.13239>; else goto <D.13240>;
    <D.13239>:
    unlink (nf);
    <D.13240>:
    f = fopen (nf, "r");
    if (f != 0B) goto <D.13241>; else goto <D.13242>;
    <D.13241>:
    fclose (f);
    stderr.158 = stderr;
    fprintf (stderr.158, "The Mono profiler won\'t overwrite existing filename: %s.\n", nf);
    stderr.158 = stderr;
    fprintf (stderr.158, "Profiling disabled: use a different name or -FILENAME to force overwrite.\n");
    free (prof);
    D.13244 = 0B;
    return D.13244;
    <D.13242>:
    D.13245 = fopen (nf, "wb");
    prof->file = D.13245;
  }
  <D.13238>:
  <D.13233>:
  D.13246 = prof->file;
  if (D.13246 == 0B) goto <D.13247>; else goto <D.13248>;
  <D.13247>:
  stderr.158 = stderr;
  fprintf (stderr.158, "Cannot create profiler output: %s\n", nf);
  exit (1);
  <D.13248>:
  sample_type.159 = sample_type;
  if (sample_type.159 != 0) goto <D.13250>; else goto <D.13251>;
  <D.13250>:
  do_mono_sample.160 = do_mono_sample;
  if (do_mono_sample.160 == 0) goto <D.13253>; else goto <D.13254>;
  <D.13253>:
  need_helper_thread = setup_perf_event ();
  <D.13254>:
  <D.13251>:
  perf_data.161 = perf_data;
  if (perf_data.161 == 0B) goto <D.13256>; else goto <D.13257>;
  <D.13256>:
  do_mono_sample = 1;
  <D.13257>:
  do_mono_sample.160 = do_mono_sample;
  if (do_mono_sample.160 != 0) goto <D.13258>; else goto <D.13259>;
  <D.13258>:
  D.13260 = create_stat_buffer ();
  prof->stat_buffers = D.13260;
  need_helper_thread = 1;
  <D.13259>:
  hs_mode_ondemand.162 = hs_mode_ondemand;
  if (hs_mode_ondemand.162 != 0) goto <D.13261>; else goto <D.13264>;
  <D.13264>:
  if (need_helper_thread != 0) goto <D.13261>; else goto <D.13262>;
  <D.13261>:
  D.13265 = start_helper_thread (prof);
  if (D.13265 == 0) goto <D.13266>; else goto <D.13267>;
  <D.13266>:
  prof->command_port = 0;
  <D.13267>:
  <D.13262>:
  D.13268 = current_time ();
  prof->startup_time = D.13268;
  dump_header (prof);
  D.13244 = prof;
  return D.13244;
}


new_filename (const char * filename)
{
  long int t.163;
  unsigned int D.13279;
  char D.13280;
  int D.13290;
  char * D.13293;
  int D.13294;
  int D.13295;
  int D.13296;
  int D.13297;
  int D.13298;
  int D.13299;
  int D.13300;
  int D.13301;
  unsigned int D.13302;
  unsigned int D.13303;
  unsigned int D.13304;
  int D.13305;
  unsigned int D.13306;
  int D.13307;
  unsigned int D.13308;
  unsigned int D.13309;
  unsigned int D.13310;
  char * d.164;
  sizetype s_date.165;
  sizetype s_pid.166;
  char * d.167;
  char * d.168;
  char * d.169;
  time_t t;
  int pid;
  char pid_buf[16];
  char time_buf[16];
  char * res;
  char * d;
  const char * p;
  int count_dates;
  int count_pids;
  int s_date;
  int s_pid;
  struct tm * ts;

  try
    {
      t.163 = time (0B);
      t = t.163;
      D.13279 = process_id ();
      pid = (int) D.13279;
      count_dates = 0;
      count_pids = 0;
      p = filename;
      goto <D.11342>;
      <D.11341>:
      D.13280 = *p;
      if (D.13280 != 37) goto <D.13281>; else goto <D.13282>;
      <D.13281>:
      // predicted unlikely by continue predictor.
      goto <D.11339>;
      <D.13282>:
      p = p + 1;
      D.13280 = *p;
      if (D.13280 == 116) goto <D.13283>; else goto <D.13284>;
      <D.13283>:
      count_dates = count_dates + 1;
      goto <D.13285>;
      <D.13284>:
      D.13280 = *p;
      if (D.13280 == 112) goto <D.13286>; else goto <D.13287>;
      <D.13286>:
      count_pids = count_pids + 1;
      goto <D.13288>;
      <D.13287>:
      D.13280 = *p;
      if (D.13280 == 0) goto <D.11340>; else goto <D.13289>;
      <D.13289>:
      <D.13288>:
      <D.13285>:
      <D.11339>:
      p = p + 1;
      <D.11342>:
      D.13280 = *p;
      if (D.13280 != 0) goto <D.11341>; else goto <D.11340>;
      <D.11340>:
      D.13290 = count_dates | count_pids;
      if (D.13290 == 0) goto <D.13291>; else goto <D.13292>;
      <D.13291>:
      D.13293 = pstrdup (filename);
      return D.13293;
      <D.13292>:
      snprintf (&pid_buf, 16, "%d", pid);
      ts = gmtime (&t);
      D.13294 = ts->tm_sec;
      D.13295 = ts->tm_min;
      D.13296 = ts->tm_hour;
      D.13297 = ts->tm_mday;
      D.13298 = ts->tm_mon;
      D.13299 = D.13298 + 1;
      D.13300 = ts->tm_year;
      D.13301 = D.13300 + 1900;
      snprintf (&time_buf, 16, "%d%02d%02d%02d%02d%02d", D.13301, D.13299, D.13297, D.13296, D.13295, D.13294);
      D.13302 = strlen (&time_buf);
      s_date = (int) D.13302;
      D.13303 = strlen (&pid_buf);
      s_pid = (int) D.13303;
      D.13304 = strlen (filename);
      D.13305 = s_pid * count_pids;
      D.13306 = (unsigned int) D.13305;
      D.13307 = s_date * count_dates;
      D.13308 = (unsigned int) D.13307;
      D.13309 = D.13306 + D.13308;
      D.13310 = D.13304 + D.13309;
      res = malloc (D.13310);
      d = res;
      p = filename;
      goto <D.11346>;
      <D.11345>:
      D.13280 = *p;
      if (D.13280 != 37) goto <D.13311>; else goto <D.13312>;
      <D.13311>:
      d.164 = d;
      d = d.164 + 1;
      D.13280 = *p;
      *d.164 = D.13280;
      // predicted unlikely by continue predictor.
      goto <D.11343>;
      <D.13312>:
      p = p + 1;
      D.13280 = *p;
      if (D.13280 == 116) goto <D.13314>; else goto <D.13315>;
      <D.13314>:
      strcpy (d, &time_buf);
      s_date.165 = (sizetype) s_date;
      d = d + s_date.165;
      // predicted unlikely by continue predictor.
      goto <D.11343>;
      <D.13315>:
      D.13280 = *p;
      if (D.13280 == 112) goto <D.13317>; else goto <D.13318>;
      <D.13317>:
      strcpy (d, &pid_buf);
      s_pid.166 = (sizetype) s_pid;
      d = d + s_pid.166;
      // predicted unlikely by continue predictor.
      goto <D.11343>;
      <D.13318>:
      D.13280 = *p;
      if (D.13280 == 37) goto <D.13320>; else goto <D.13321>;
      <D.13320>:
      d.167 = d;
      d = d.167 + 1;
      *d.167 = 37;
      // predicted unlikely by continue predictor.
      goto <D.11343>;
      <D.13321>:
      D.13280 = *p;
      if (D.13280 == 0) goto <D.11344>; else goto <D.13323>;
      <D.13323>:
      d.168 = d;
      d = d.168 + 1;
      *d.168 = 37;
      d.169 = d;
      d = d.169 + 1;
      D.13280 = *p;
      *d.169 = D.13280;
      <D.11343>:
      p = p + 1;
      <D.11346>:
      D.13280 = *p;
      if (D.13280 != 0) goto <D.11345>; else goto <D.11344>;
      <D.11344>:
      *d = 0;
      D.13293 = res;
      return D.13293;
    }
  finally
    {
      t = {CLOBBER};
      pid_buf = {CLOBBER};
      time_buf = {CLOBBER};
    }
}


setup_perf_event ()
{
  int D.13331;
  int num_pages.170;
  int D.13333;
  int D.13334;
  unsigned int mmap_mask.171;
  int num_perf.172;
  int num_perf.173;
  unsigned int num_perf.174;
  void * perf_data.175;
  struct PerfData * perf_data.176;
  unsigned int i.177;
  unsigned int D.13342;
  struct PerfData * D.13343;
  int D.13344;
  int D.13347;
  int i;
  int count;

  count = 0;
  D.13331 = getpagesize ();
  num_pages.170 = num_pages;
  D.13333 = D.13331 * num_pages.170;
  D.13334 = D.13333 + -1;
  mmap_mask.171 = (unsigned int) D.13334;
  mmap_mask = mmap_mask.171;
  num_perf.172 = mono_cpu_count ();
  num_perf = num_perf.172;
  num_perf.173 = num_perf;
  num_perf.174 = (unsigned int) num_perf.173;
  perf_data.175 = calloc (num_perf.174, 16);
  perf_data = perf_data.175;
  i = 0;
  goto <D.11313>;
  <D.11312>:
  perf_data.176 = perf_data;
  i.177 = (unsigned int) i;
  D.13342 = i.177 * 16;
  D.13343 = perf_data.176 + D.13342;
  D.13344 = setup_perf_event_for_cpu (D.13343, i);
  count = D.13344 + count;
  i = i + 1;
  <D.11313>:
  num_perf.173 = num_perf;
  if (i < num_perf.173) goto <D.11312>; else goto <D.11314>;
  <D.11314>:
  if (count != 0) goto <D.13345>; else goto <D.13346>;
  <D.13345>:
  D.13347 = 1;
  return D.13347;
  <D.13346>:
  perf_data.176 = perf_data;
  free (perf_data.176);
  perf_data = 0B;
  D.13347 = 0;
  return D.13347;
}


mono_cpu_count ()
{
  int D.13353;
  int count;

  count = 0;
  count = sysconf (84);
  if (count > 0) goto <D.13351>; else goto <D.13352>;
  <D.13351>:
  D.13353 = count;
  return D.13353;
  <D.13352>:
  D.13353 = 1;
  return D.13353;
}


setup_perf_event_for_cpu (struct PerfData * perf, int cpu)
{
  int sample_type.178;
  int sample_freq.179;
  long long unsigned int D.13357;
  int D.13358;
  int D.13359;
  int do_debug.180;
  long long unsigned int D.13363;
  int D.13364;
  struct _IO_FILE * stderr.181;
  int D.13373;
  int D.13374;
  struct perf_event_attr attr;

  try
    {
      memset (&attr, 0, 72);
      attr.type = 0;
      sample_type.178 = sample_type;
      switch (sample_type.178) <default: <D.11306>, case 1: <D.11299>, case 2: <D.11301>, case 3: <D.11302>, case 4: <D.11303>, case 5: <D.11304>, case 6: <D.11305>>
      <D.11299>:
      attr.config = 0;
      goto <D.11300>;
      <D.11301>:
      attr.config = 1;
      goto <D.11300>;
      <D.11302>:
      attr.config = 3;
      goto <D.11300>;
      <D.11303>:
      attr.config = 2;
      goto <D.11300>;
      <D.11304>:
      attr.config = 4;
      goto <D.11300>;
      <D.11305>:
      attr.config = 5;
      goto <D.11300>;
      <D.11306>:
      attr.config = 0;
      goto <D.11300>;
      <D.11300>:
      attr.sample_type = 263;
      attr.read_format = 7;
      attr.inherit = 1;
      attr.freq = 1;
      sample_freq.179 = sample_freq;
      D.13357 = (long long unsigned int) sample_freq.179;
      attr.D.10650.sample_freq = D.13357;
      D.13358 = getpid ();
      D.13359 = perf_event_syscall (&attr, D.13358, cpu, -1, 0);
      perf->perf_fd = D.13359;
      do_debug.180 = do_debug;
      if (do_debug.180 != 0) goto <D.13361>; else goto <D.13362>;
      <D.13361>:
      D.13363 = attr.config;
      sample_freq.179 = sample_freq;
      D.13364 = perf->perf_fd;
      printf ("perf fd: %d, freq: %d, event: %llu\n", D.13364, sample_freq.179, D.13363);
      <D.13362>:
      D.13364 = perf->perf_fd;
      if (D.13364 < 0) goto <D.13365>; else goto <D.13366>;
      <D.13365>:
      D.13364 = perf->perf_fd;
      if (D.13364 == -1) goto <D.13367>; else goto <D.13368>;
      <D.13367>:
      stderr.181 = stderr;
      fprintf (stderr.181, "Perf syscall denied, do \"echo 1 > /proc/sys/kernel/perf_event_paranoid\" as root to enable.\n");
      goto <D.13370>;
      <D.13368>:
      do_debug.180 = do_debug;
      if (do_debug.180 != 0) goto <D.13371>; else goto <D.13372>;
      <D.13371>:
      perror ("open perf event");
      <D.13372>:
      <D.13370>:
      D.13373 = 0;
      return D.13373;
      <D.13366>:
      D.13374 = setup_perf_map (perf);
      if (D.13374 == 0) goto <D.13375>; else goto <D.13376>;
      <D.13375>:
      D.13364 = perf->perf_fd;
      close (D.13364);
      perf->perf_fd = -1;
      D.13373 = 0;
      return D.13373;
      <D.13376>:
      D.13373 = 1;
      return D.13373;
    }
  finally
    {
      attr = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.13384;
  int D.13389;
  void * D.13391;
  unsigned int D.13392;

  D.13384 = __builtin_constant_p (__len);
  if (D.13384 != 0) goto <D.13385>; else goto <D.13386>;
  <D.13385>:
  if (__len == 0) goto <D.13387>; else goto <D.13388>;
  <D.13387>:
  D.13389 = __builtin_constant_p (__ch);
  if (D.13389 == 0) goto <D.13382>; else goto <D.13390>;
  <D.13390>:
  if (__ch != 0) goto <D.13382>; else goto <D.13383>;
  <D.13382>:
  __warn_memset_zero_len ();
  D.13391 = __dest;
  return D.13391;
  <D.13383>:
  <D.13388>:
  <D.13386>:
  D.13392 = __builtin_object_size (__dest, 0);
  D.13391 = __builtin___memset_chk (__dest, __ch, __len, D.13392);
  return D.13391;
}


perf_event_syscall (struct perf_event_attr * attr, pid_t pid, int cpu, int group_fd, long unsigned int flags)
{
  int D.13394;

  attr->size = 64;
  D.13394 = syscall (336, attr, pid, cpu, group_fd, flags);
  return D.13394;
}


setup_perf_map (struct PerfData * perf)
{
  int D.13396;
  int num_pages.182;
  int D.13398;
  int D.13399;
  int D.13400;
  unsigned int D.13401;
  void * D.13402;
  void * D.13403;
  int do_debug.183;
  int D.13409;
  struct perf_event_mmap_page * D.13412;
  unsigned int D.13413;

  D.13396 = perf->perf_fd;
  num_pages.182 = num_pages;
  D.13398 = num_pages.182 + 1;
  D.13399 = getpagesize ();
  D.13400 = D.13398 * D.13399;
  D.13401 = (unsigned int) D.13400;
  D.13402 = mmap (0B, D.13401, 3, 1, D.13396, 0);
  perf->mmap_base = D.13402;
  D.13403 = perf->mmap_base;
  if (D.13403 == 4294967295B) goto <D.13404>; else goto <D.13405>;
  <D.13404>:
  do_debug.183 = do_debug;
  if (do_debug.183 != 0) goto <D.13407>; else goto <D.13408>;
  <D.13407>:
  printf ("failed mmap\n");
  <D.13408>:
  D.13409 = 0;
  return D.13409;
  <D.13405>:
  D.13403 = perf->mmap_base;
  perf->page_desc = D.13403;
  do_debug.183 = do_debug;
  if (do_debug.183 != 0) goto <D.13410>; else goto <D.13411>;
  <D.13410>:
  D.13412 = perf->page_desc;
  D.13413 = D.13412->version;
  printf ("mmap version: %d\n", D.13413);
  <D.13411>:
  D.13409 = 1;
  return D.13409;
}


start_helper_thread (struct MonoProfiler * prof)
{
  int[2] * D.13415;
  int D.13416;
  struct _IO_FILE * stderr.184;
  int D.13420;
  int D.13421;
  int D.13422;
  short unsigned int D.11415;
  int D.13425;
  int D.13426;
  int D.13427;
  short unsigned int D.13430;
  signed short D.13431;
  int D.13432;
  signed short D.13433;
  signed short D.13434;
  union 
{
  const struct sockaddr * restrict __sockaddr__;
  const struct sockaddr_at * restrict __sockaddr_at__;
  const struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  const struct sockaddr_dl * restrict __sockaddr_dl__;
  const struct sockaddr_eon * restrict __sockaddr_eon__;
  const struct sockaddr_in * restrict __sockaddr_in__;
  const struct sockaddr_in6 * restrict __sockaddr_in6__;
  const struct sockaddr_inarp * restrict __sockaddr_inarp__;
  const struct sockaddr_ipx * restrict __sockaddr_ipx__;
  const struct sockaddr_iso * restrict __sockaddr_iso__;
  const struct sockaddr_ns * restrict __sockaddr_ns__;
  const struct sockaddr_un * restrict __sockaddr_un__;
  const struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.13436;
  int D.13437;
  int * D.13440;
  int D.13441;
  char * D.13442;
  int D.13443;
  union 
{
  struct sockaddr * restrict __sockaddr__;
  struct sockaddr_at * restrict __sockaddr_at__;
  struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  struct sockaddr_dl * restrict __sockaddr_dl__;
  struct sockaddr_eon * restrict __sockaddr_eon__;
  struct sockaddr_in * restrict __sockaddr_in__;
  struct sockaddr_in6 * restrict __sockaddr_in6__;
  struct sockaddr_inarp * restrict __sockaddr_inarp__;
  struct sockaddr_ipx * restrict __sockaddr_ipx__;
  struct sockaddr_iso * restrict __sockaddr_iso__;
  struct sockaddr_ns * restrict __sockaddr_ns__;
  struct sockaddr_un * restrict __sockaddr_un__;
  struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.13446;
  int D.13447;
  short unsigned int D.11418;
  int D.13450;
  int D.13451;
  short unsigned int D.13454;
  signed short D.13455;
  int D.13456;
  signed short D.13457;
  signed short D.13458;
  int D.13460;
  pthread_t * D.13461;
  struct sockaddr_in server_address;
  int r;
  socklen_t slen;

  try
    {
      D.13415 = &prof->pipes;
      D.13416 = pipe (D.13415);
      if (D.13416 < 0) goto <D.13417>; else goto <D.13418>;
      <D.13417>:
      stderr.184 = stderr;
      fprintf (stderr.184, "Cannot create pipe\n");
      D.13420 = 0;
      return D.13420;
      <D.13418>:
      D.13421 = socket (2, 1, 0);
      prof->server_socket = D.13421;
      D.13422 = prof->server_socket;
      if (D.13422 < 0) goto <D.13423>; else goto <D.13424>;
      <D.13423>:
      stderr.184 = stderr;
      fprintf (stderr.184, "Cannot create server socket\n");
      D.13420 = 0;
      return D.13420;
      <D.13424>:
      memset (&server_address, 0, 16);
      server_address.sin_family = 2;
      server_address.sin_addr.s_addr = 0;
      {
        short unsigned int __v;
        short unsigned int __x;

        D.13425 = prof->command_port;
        __x = (short unsigned int) D.13425;
        {
          D.13426 = (int) __x;
          D.13427 = __builtin_constant_p (D.13426);
          if (D.13427 != 0) goto <D.13428>; else goto <D.13429>;
          <D.13428>:
          D.13430 = __x >> 8;
          D.13431 = (signed short) D.13430;
          D.13426 = (int) __x;
          D.13432 = D.13426 << 8;
          D.13433 = (signed short) D.13432;
          D.13434 = D.13431 | D.13433;
          __v = (short unsigned int) D.13434;
          goto <D.13435>;
          <D.13429>:
          __asm__("rorw $8, %w0" : "=r" __v : "0" __x : "cc");
          <D.13435>:
        }
        D.11415 = __v;
      }
      server_address.sin_port = D.11415;
      D.13436.__sockaddr__ = &server_address;
      D.13422 = prof->server_socket;
      D.13437 = bind (D.13422, D.13436, 16);
      if (D.13437 < 0) goto <D.13438>; else goto <D.13439>;
      <D.13438>:
      D.13440 = __errno_location ();
      D.13441 = *D.13440;
      D.13442 = strerror (D.13441);
      D.13425 = prof->command_port;
      stderr.184 = stderr;
      fprintf (stderr.184, "Cannot bind server socket, port: %d: %s\n", D.13425, D.13442);
      D.13422 = prof->server_socket;
      close (D.13422);
      D.13420 = 0;
      return D.13420;
      <D.13439>:
      D.13422 = prof->server_socket;
      D.13443 = listen (D.13422, 1);
      if (D.13443 < 0) goto <D.13444>; else goto <D.13445>;
      <D.13444>:
      stderr.184 = stderr;
      fprintf (stderr.184, "Cannot listen server socket\n");
      D.13422 = prof->server_socket;
      close (D.13422);
      D.13420 = 0;
      return D.13420;
      <D.13445>:
      slen = 16;
      D.13446.__sockaddr__ = &server_address;
      D.13422 = prof->server_socket;
      D.13447 = getsockname (D.13422, D.13446, &slen);
      if (D.13447 == 0) goto <D.13448>; else goto <D.13449>;
      <D.13448>:
      {
        short unsigned int __v;
        short unsigned int __x;

        __x = server_address.sin_port;
        {
          D.13450 = (int) __x;
          D.13451 = __builtin_constant_p (D.13450);
          if (D.13451 != 0) goto <D.13452>; else goto <D.13453>;
          <D.13452>:
          D.13454 = __x >> 8;
          D.13455 = (signed short) D.13454;
          D.13450 = (int) __x;
          D.13456 = D.13450 << 8;
          D.13457 = (signed short) D.13456;
          D.13458 = D.13455 | D.13457;
          __v = (short unsigned int) D.13458;
          goto <D.13459>;
          <D.13453>:
          __asm__("rorw $8, %w0" : "=r" __v : "0" __x : "cc");
          <D.13459>:
        }
        D.11418 = __v;
      }
      D.13460 = (int) D.11418;
      prof->command_port = D.13460;
      <D.13449>:
      D.13461 = &prof->helper_thread;
      r = pthread_create (D.13461, 0B, helper_thread, prof);
      if (r != 0) goto <D.13462>; else goto <D.13463>;
      <D.13462>:
      D.13422 = prof->server_socket;
      close (D.13422);
      D.13420 = 0;
      return D.13420;
      <D.13463>:
      D.13420 = 1;
      return D.13420;
    }
  finally
    {
      server_address = {CLOBBER};
      slen = {CLOBBER};
    }
}


helper_thread (void * arg)
{
  long int D.11361;
  long int iftmp.185;
  int D.13468;
  long int iftmp.186;
  unsigned int __d.187;
  long int D.13477;
  long int D.13478;
  int D.13479;
  int D.13480;
  long int D.13481;
  long int D.13482;
  long int D.11363;
  long int iftmp.188;
  int D.13484;
  long int iftmp.189;
  unsigned int __d.190;
  long int D.13493;
  long int D.13494;
  int D.13495;
  int D.13496;
  long int D.13497;
  long int D.13498;
  long int D.11365;
  long int iftmp.191;
  int D.13504;
  long int iftmp.192;
  unsigned int __d.193;
  long int D.13513;
  long int D.13514;
  int D.13515;
  long int D.13516;
  long int D.13517;
  struct PerfData * perf_data.194;
  unsigned int i.195;
  unsigned int D.13524;
  struct PerfData * D.13525;
  int D.13526;
  long int D.11369;
  long int iftmp.196;
  int D.13530;
  long int iftmp.197;
  unsigned int __d.198;
  long int D.13539;
  long int D.13540;
  int D.13541;
  long int D.13542;
  long int D.13543;
  int num_perf.199;
  int D.13547;
  int * D.13550;
  int D.13551;
  char * D.13554;
  void * D.13555;
  long int D.11375;
  long int iftmp.200;
  int D.13557;
  long int iftmp.201;
  unsigned int __d.202;
  long int D.13566;
  long int D.13567;
  long int D.13568;
  char c.203;
  struct StatBuffer * D.13576;
  struct StatBuffer * D.13577;
  int do_debug.204;
  struct _IO_FILE * stderr.205;
  unsigned int D.13582;
  int D.13583;
  unsigned int i.206;
  unsigned int D.13591;
  struct PerfData * D.13592;
  int D.13593;
  long int D.11382;
  long int iftmp.207;
  int D.13597;
  long int iftmp.208;
  unsigned int __d.209;
  long int D.13606;
  int D.13607;
  long int D.13608;
  long int D.13609;
  struct LogBuffer * D.13612;
  unsigned int i.210;
  unsigned int D.13616;
  struct PerfData * D.13617;
  int D.13618;
  long int D.11389;
  long int iftmp.211;
  int D.13622;
  long int iftmp.212;
  unsigned int __d.213;
  long int D.13631;
  int D.13632;
  long int D.13633;
  long int D.13634;
  struct LogBuffer * D.13637;
  long int D.11394;
  long int iftmp.214;
  int D.13641;
  long int iftmp.215;
  unsigned int __d.216;
  long int D.13650;
  long int D.13651;
  long int D.13652;
  int D.11403;
  int iftmp.217;
  int D.11402;
  const char[10] * D.13662;
  unsigned char D.13663;
  int D.13664;
  unsigned char D.13665;
  int D.13666;
  _Bool D.13667;
  _Bool D.13668;
  _Bool D.13669;
  const unsigned char * D.13672;
  unsigned char D.13673;
  int D.13674;
  const unsigned char * D.13675;
  unsigned char D.13676;
  int D.13677;
  _Bool D.13678;
  _Bool D.13679;
  const unsigned char * D.13682;
  unsigned char D.13683;
  int D.13684;
  const unsigned char * D.13685;
  unsigned char D.13686;
  int D.13687;
  _Bool D.13688;
  _Bool D.13689;
  const unsigned char * D.13692;
  unsigned char D.13693;
  int D.13694;
  const unsigned char * D.13695;
  unsigned char D.13696;
  int D.13697;
  int runtime_inited.218;
  struct MonoDomain * D.13706;
  long int D.11405;
  long int iftmp.219;
  int D.13710;
  long int iftmp.220;
  unsigned int __d.221;
  long int D.13719;
  long int D.13720;
  long int D.13721;
  union 
{
  struct sockaddr * restrict __sockaddr__;
  struct sockaddr_at * restrict __sockaddr_at__;
  struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  struct sockaddr_dl * restrict __sockaddr_dl__;
  struct sockaddr_eon * restrict __sockaddr_eon__;
  struct sockaddr_in * restrict __sockaddr_in__;
  struct sockaddr_in6 * restrict __sockaddr_in6__;
  struct sockaddr_inarp * restrict __sockaddr_inarp__;
  struct sockaddr_ipx * restrict __sockaddr_ipx__;
  struct sockaddr_iso * restrict __sockaddr_iso__;
  struct sockaddr_ns * restrict __sockaddr_ns__;
  struct sockaddr_un * restrict __sockaddr_un__;
  struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.13724;
  struct MonoProfiler * prof;
  int command_socket;
  int len;
  char buf[64];
  struct MonoThread * thread;

  try
    {
      prof = arg;
      thread = 0B;
      command_socket = -1;
      <D.11406>:
      {
        struct fd_set rfds;
        struct timeval tv;
        int max_fd;

        try
          {
            max_fd = -1;
            {
              int __d0;
              int __d1;

              __asm__ __volatile__("cld; rep; stosl" : "=c" __d0, "=D" __d1 : "a" 0, "0" 32, "1" &rfds.fds_bits[0] : "memory");
            }
            {
              long int __d;

              __d = prof->server_socket;
              D.13468 = __builtin_constant_p (__d);
              if (D.13468 != 0) goto <D.13469>; else goto <D.13470>;
              <D.13469>:
              __d.187 = (unsigned int) __d;
              if (__d.187 <= 1023) goto <D.13473>; else goto <D.13474>;
              <D.13473>:
              iftmp.186 = __d / 32;
              goto <D.13475>;
              <D.13474>:
              iftmp.186 = __fdelt_warn (__d);
              <D.13475>:
              iftmp.185 = iftmp.186;
              goto <D.13476>;
              <D.13470>:
              iftmp.185 = __fdelt_chk (__d);
              <D.13476>:
              D.11361 = iftmp.185;
            }
            D.13477 = D.11361;
            D.13478 = rfds.fds_bits[D.13477];
            D.13479 = prof->server_socket;
            D.13480 = D.13479 % 32;
            D.13481 = 1 << D.13480;
            D.13482 = D.13478 | D.13481;
            rfds.fds_bits[D.13477] = D.13482;
            max_fd = prof->server_socket;
            {
              long int __d;

              __d = prof->pipes[0];
              D.13484 = __builtin_constant_p (__d);
              if (D.13484 != 0) goto <D.13485>; else goto <D.13486>;
              <D.13485>:
              __d.190 = (unsigned int) __d;
              if (__d.190 <= 1023) goto <D.13489>; else goto <D.13490>;
              <D.13489>:
              iftmp.189 = __d / 32;
              goto <D.13491>;
              <D.13490>:
              iftmp.189 = __fdelt_warn (__d);
              <D.13491>:
              iftmp.188 = iftmp.189;
              goto <D.13492>;
              <D.13486>:
              iftmp.188 = __fdelt_chk (__d);
              <D.13492>:
              D.11363 = iftmp.188;
            }
            D.13493 = D.11363;
            D.13494 = rfds.fds_bits[D.13493];
            D.13495 = prof->pipes[0];
            D.13496 = D.13495 % 32;
            D.13497 = 1 << D.13496;
            D.13498 = D.13494 | D.13497;
            rfds.fds_bits[D.13493] = D.13498;
            D.13495 = prof->pipes[0];
            if (D.13495 > max_fd) goto <D.13499>; else goto <D.13500>;
            <D.13499>:
            max_fd = prof->pipes[0];
            <D.13500>:
            if (command_socket >= 0) goto <D.13501>; else goto <D.13502>;
            <D.13501>:
            {
              long int __d;

              __d = command_socket;
              D.13504 = __builtin_constant_p (__d);
              if (D.13504 != 0) goto <D.13505>; else goto <D.13506>;
              <D.13505>:
              __d.193 = (unsigned int) __d;
              if (__d.193 <= 1023) goto <D.13509>; else goto <D.13510>;
              <D.13509>:
              iftmp.192 = __d / 32;
              goto <D.13511>;
              <D.13510>:
              iftmp.192 = __fdelt_warn (__d);
              <D.13511>:
              iftmp.191 = iftmp.192;
              goto <D.13512>;
              <D.13506>:
              iftmp.191 = __fdelt_chk (__d);
              <D.13512>:
              D.11365 = iftmp.191;
            }
            D.13513 = D.11365;
            D.13514 = rfds.fds_bits[D.13513];
            D.13515 = command_socket % 32;
            D.13516 = 1 << D.13515;
            D.13517 = D.13514 | D.13516;
            rfds.fds_bits[D.13513] = D.13517;
            if (max_fd < command_socket) goto <D.13518>; else goto <D.13519>;
            <D.13518>:
            max_fd = command_socket;
            <D.13519>:
            <D.13502>:
            perf_data.194 = perf_data;
            if (perf_data.194 != 0B) goto <D.13521>; else goto <D.13522>;
            <D.13521>:
            {
              int i;

              i = 0;
              goto <D.11371>;
              <D.11370>:
              perf_data.194 = perf_data;
              i.195 = (unsigned int) i;
              D.13524 = i.195 * 16;
              D.13525 = perf_data.194 + D.13524;
              D.13526 = D.13525->perf_fd;
              if (D.13526 < 0) goto <D.13527>; else goto <D.13528>;
              <D.13527>:
              // predicted unlikely by continue predictor.
              goto <D.11367>;
              <D.13528>:
              {
                long int __d;

                perf_data.194 = perf_data;
                i.195 = (unsigned int) i;
                D.13524 = i.195 * 16;
                D.13525 = perf_data.194 + D.13524;
                __d = D.13525->perf_fd;
                D.13530 = __builtin_constant_p (__d);
                if (D.13530 != 0) goto <D.13531>; else goto <D.13532>;
                <D.13531>:
                __d.198 = (unsigned int) __d;
                if (__d.198 <= 1023) goto <D.13535>; else goto <D.13536>;
                <D.13535>:
                iftmp.197 = __d / 32;
                goto <D.13537>;
                <D.13536>:
                iftmp.197 = __fdelt_warn (__d);
                <D.13537>:
                iftmp.196 = iftmp.197;
                goto <D.13538>;
                <D.13532>:
                iftmp.196 = __fdelt_chk (__d);
                <D.13538>:
                D.11369 = iftmp.196;
              }
              D.13539 = D.11369;
              D.13540 = rfds.fds_bits[D.13539];
              perf_data.194 = perf_data;
              i.195 = (unsigned int) i;
              D.13524 = i.195 * 16;
              D.13525 = perf_data.194 + D.13524;
              D.13526 = D.13525->perf_fd;
              D.13541 = D.13526 % 32;
              D.13542 = 1 << D.13541;
              D.13543 = D.13540 | D.13542;
              rfds.fds_bits[D.13539] = D.13543;
              perf_data.194 = perf_data;
              i.195 = (unsigned int) i;
              D.13524 = i.195 * 16;
              D.13525 = perf_data.194 + D.13524;
              D.13526 = D.13525->perf_fd;
              if (D.13526 > max_fd) goto <D.13544>; else goto <D.13545>;
              <D.13544>:
              perf_data.194 = perf_data;
              i.195 = (unsigned int) i;
              D.13524 = i.195 * 16;
              D.13525 = perf_data.194 + D.13524;
              max_fd = D.13525->perf_fd;
              <D.13545>:
              <D.11367>:
              i = i + 1;
              <D.11371>:
              num_perf.199 = num_perf;
              if (i < num_perf.199) goto <D.11370>; else goto <D.11372>;
              <D.11372>:
            }
            <D.13522>:
            tv.tv_sec = 1;
            tv.tv_usec = 0;
            D.13547 = max_fd + 1;
            len = select (D.13547, &rfds, 0B, 0B, &tv);
            if (len < 0) goto <D.13548>; else goto <D.13549>;
            <D.13548>:
            D.13550 = __errno_location ();
            D.13551 = *D.13550;
            if (D.13551 == 4) goto <D.13552>; else goto <D.13553>;
            <D.13552>:
            // predicted unlikely by continue predictor.
            goto <D.11373>;
            <D.13553>:
            D.13550 = __errno_location ();
            D.13551 = *D.13550;
            D.13554 = strerror (D.13551);
            monoeg_g_log (0B, 16, "Error in proflog server: %s", D.13554);
            D.13555 = 0B;
            return D.13555;
            <D.13549>:
            {
              long int __d;

              __d = prof->pipes[0];
              D.13557 = __builtin_constant_p (__d);
              if (D.13557 != 0) goto <D.13558>; else goto <D.13559>;
              <D.13558>:
              __d.202 = (unsigned int) __d;
              if (__d.202 <= 1023) goto <D.13562>; else goto <D.13563>;
              <D.13562>:
              iftmp.201 = __d / 32;
              goto <D.13564>;
              <D.13563>:
              iftmp.201 = __fdelt_warn (__d);
              <D.13564>:
              iftmp.200 = iftmp.201;
              goto <D.13565>;
              <D.13559>:
              iftmp.200 = __fdelt_chk (__d);
              <D.13565>:
              D.11375 = iftmp.200;
            }
            D.13566 = rfds.fds_bits[D.11375];
            D.13495 = prof->pipes[0];
            D.13496 = D.13495 % 32;
            D.13567 = D.13566 >> D.13496;
            D.13568 = D.13567 & 1;
            if (D.13568 != 0) goto <D.13569>; else goto <D.13570>;
            <D.13569>:
            {
              char c;
              int r;

              try
                {
                  D.13495 = prof->pipes[0];
                  r = read (D.13495, &c, 1);
                  if (r == 1) goto <D.13571>; else goto <D.13572>;
                  <D.13571>:
                  c.203 = c;
                  if (c.203 == 0) goto <D.13574>; else goto <D.13575>;
                  <D.13574>:
                  {
                    struct StatBuffer * sbuf;

                    D.13576 = prof->stat_buffers;
                    D.13577 = D.13576->next;
                    sbuf = D.13577->next;
                    D.13576 = prof->stat_buffers;
                    D.13577 = D.13576->next;
                    D.13577->next = 0B;
                    do_debug.204 = do_debug;
                    if (do_debug.204 != 0) goto <D.13579>; else goto <D.13580>;
                    <D.13579>:
                    stderr.205 = stderr;
                    fprintf (stderr.205, "stat buffer dump\n");
                    <D.13580>:
                    dump_sample_hits (prof, sbuf, 1);
                    D.13582 = sbuf->size;
                    D.13583 = (int) D.13582;
                    free_buffer (sbuf, D.13583);
                    // predicted unlikely by continue predictor.
                    goto <D.11373>;
                  }
                  <D.13575>:
                  <D.13572>:
                  if (thread != 0B) goto <D.13584>; else goto <D.13585>;
                  <D.13584>:
                  mono_thread_detach (thread);
                  <D.13585>:
                  do_debug.204 = do_debug;
                  if (do_debug.204 != 0) goto <D.13586>; else goto <D.13587>;
                  <D.13586>:
                  stderr.205 = stderr;
                  fprintf (stderr.205, "helper shutdown\n");
                  <D.13587>:
                  perf_data.194 = perf_data;
                  if (perf_data.194 != 0B) goto <D.13588>; else goto <D.13589>;
                  <D.13588>:
                  {
                    int i;

                    i = 0;
                    goto <D.11384>;
                    <D.11383>:
                    perf_data.194 = perf_data;
                    i.206 = (unsigned int) i;
                    D.13591 = i.206 * 16;
                    D.13592 = perf_data.194 + D.13591;
                    D.13593 = D.13592->perf_fd;
                    if (D.13593 < 0) goto <D.13594>; else goto <D.13595>;
                    <D.13594>:
                    // predicted unlikely by continue predictor.
                    goto <D.11380>;
                    <D.13595>:
                    {
                      long int __d;

                      perf_data.194 = perf_data;
                      i.206 = (unsigned int) i;
                      D.13591 = i.206 * 16;
                      D.13592 = perf_data.194 + D.13591;
                      __d = D.13592->perf_fd;
                      D.13597 = __builtin_constant_p (__d);
                      if (D.13597 != 0) goto <D.13598>; else goto <D.13599>;
                      <D.13598>:
                      __d.209 = (unsigned int) __d;
                      if (__d.209 <= 1023) goto <D.13602>; else goto <D.13603>;
                      <D.13602>:
                      iftmp.208 = __d / 32;
                      goto <D.13604>;
                      <D.13603>:
                      iftmp.208 = __fdelt_warn (__d);
                      <D.13604>:
                      iftmp.207 = iftmp.208;
                      goto <D.13605>;
                      <D.13599>:
                      iftmp.207 = __fdelt_chk (__d);
                      <D.13605>:
                      D.11382 = iftmp.207;
                    }
                    D.13606 = rfds.fds_bits[D.11382];
                    perf_data.194 = perf_data;
                    i.206 = (unsigned int) i;
                    D.13591 = i.206 * 16;
                    D.13592 = perf_data.194 + D.13591;
                    D.13593 = D.13592->perf_fd;
                    D.13607 = D.13593 % 32;
                    D.13608 = D.13606 >> D.13607;
                    D.13609 = D.13608 & 1;
                    if (D.13609 != 0) goto <D.13610>; else goto <D.13611>;
                    <D.13610>:
                    read_perf_mmap (prof, i);
                    <D.13611>:
                    <D.11380>:
                    i = i + 1;
                    <D.11384>:
                    num_perf.199 = num_perf;
                    if (i < num_perf.199) goto <D.11383>; else goto <D.11385>;
                    <D.11385>:
                  }
                  <D.13589>:
                  D.13612 = ensure_logbuf (0);
                  safe_dump (prof, D.13612);
                  D.13555 = 0B;
                  return D.13555;
                }
              finally
                {
                  c = {CLOBBER};
                }
            }
            <D.13570>:
            perf_data.194 = perf_data;
            if (perf_data.194 != 0B) goto <D.13613>; else goto <D.13614>;
            <D.13613>:
            {
              int i;

              i = 0;
              goto <D.11391>;
              <D.11390>:
              perf_data.194 = perf_data;
              i.210 = (unsigned int) i;
              D.13616 = i.210 * 16;
              D.13617 = perf_data.194 + D.13616;
              D.13618 = D.13617->perf_fd;
              if (D.13618 < 0) goto <D.13619>; else goto <D.13620>;
              <D.13619>:
              // predicted unlikely by continue predictor.
              goto <D.11387>;
              <D.13620>:
              {
                long int __d;

                perf_data.194 = perf_data;
                i.210 = (unsigned int) i;
                D.13616 = i.210 * 16;
                D.13617 = perf_data.194 + D.13616;
                __d = D.13617->perf_fd;
                D.13622 = __builtin_constant_p (__d);
                if (D.13622 != 0) goto <D.13623>; else goto <D.13624>;
                <D.13623>:
                __d.213 = (unsigned int) __d;
                if (__d.213 <= 1023) goto <D.13627>; else goto <D.13628>;
                <D.13627>:
                iftmp.212 = __d / 32;
                goto <D.13629>;
                <D.13628>:
                iftmp.212 = __fdelt_warn (__d);
                <D.13629>:
                iftmp.211 = iftmp.212;
                goto <D.13630>;
                <D.13624>:
                iftmp.211 = __fdelt_chk (__d);
                <D.13630>:
                D.11389 = iftmp.211;
              }
              D.13631 = rfds.fds_bits[D.11389];
              perf_data.194 = perf_data;
              i.210 = (unsigned int) i;
              D.13616 = i.210 * 16;
              D.13617 = perf_data.194 + D.13616;
              D.13618 = D.13617->perf_fd;
              D.13632 = D.13618 % 32;
              D.13633 = D.13631 >> D.13632;
              D.13634 = D.13633 & 1;
              if (D.13634 != 0) goto <D.13635>; else goto <D.13636>;
              <D.13635>:
              read_perf_mmap (prof, i);
              D.13637 = ensure_logbuf (0);
              safe_dump (prof, D.13637);
              <D.13636>:
              <D.11387>:
              i = i + 1;
              <D.11391>:
              num_perf.199 = num_perf;
              if (i < num_perf.199) goto <D.11390>; else goto <D.11392>;
              <D.11392>:
            }
            <D.13614>:
            if (command_socket >= 0) goto <D.13638>; else goto <D.13639>;
            <D.13638>:
            {
              long int __d;

              __d = command_socket;
              D.13641 = __builtin_constant_p (__d);
              if (D.13641 != 0) goto <D.13642>; else goto <D.13643>;
              <D.13642>:
              __d.216 = (unsigned int) __d;
              if (__d.216 <= 1023) goto <D.13646>; else goto <D.13647>;
              <D.13646>:
              iftmp.215 = __d / 32;
              goto <D.13648>;
              <D.13647>:
              iftmp.215 = __fdelt_warn (__d);
              <D.13648>:
              iftmp.214 = iftmp.215;
              goto <D.13649>;
              <D.13643>:
              iftmp.214 = __fdelt_chk (__d);
              <D.13649>:
              D.11394 = iftmp.214;
            }
            D.13650 = rfds.fds_bits[D.11394];
            D.13515 = command_socket % 32;
            D.13651 = D.13650 >> D.13515;
            D.13652 = D.13651 & 1;
            if (D.13652 != 0) goto <D.13653>; else goto <D.13654>;
            <D.13653>:
            len = read (command_socket, &buf, 63);
            if (len < 0) goto <D.13655>; else goto <D.13656>;
            <D.13655>:
            // predicted unlikely by continue predictor.
            goto <D.11373>;
            <D.13656>:
            if (len == 0) goto <D.13657>; else goto <D.13658>;
            <D.13657>:
            close (command_socket);
            command_socket = -1;
            // predicted unlikely by continue predictor.
            goto <D.11373>;
            <D.13658>:
            buf[len] = 0;
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 9;
              if (__s2_len <= 3) goto <D.13660>; else goto <D.13661>;
              <D.13660>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = &buf;
                D.13662 = "heapshot\n";
                D.13663 = MEM[(const unsigned char *)D.13662];
                D.13664 = (int) D.13663;
                D.13665 = *__s2;
                D.13666 = (int) D.13665;
                __result = D.13664 - D.13666;
                {
                  D.13667 = __s2_len != 0;
                  D.13668 = __result == 0;
                  D.13669 = D.13667 & D.13668;
                  if (D.13669 != 0) goto <D.13670>; else goto <D.13671>;
                  <D.13670>:
                  D.13672 = &MEM[(void *)"heapshot\n" + 1B];
                  D.13673 = *D.13672;
                  D.13674 = (int) D.13673;
                  D.13675 = __s2 + 1;
                  D.13676 = *D.13675;
                  D.13677 = (int) D.13676;
                  __result = D.13674 - D.13677;
                  D.13678 = __s2_len > 1;
                  D.13668 = __result == 0;
                  D.13679 = D.13678 & D.13668;
                  if (D.13679 != 0) goto <D.13680>; else goto <D.13681>;
                  <D.13680>:
                  D.13682 = &MEM[(void *)"heapshot\n" + 2B];
                  D.13683 = *D.13682;
                  D.13684 = (int) D.13683;
                  D.13685 = __s2 + 2;
                  D.13686 = *D.13685;
                  D.13687 = (int) D.13686;
                  __result = D.13684 - D.13687;
                  D.13688 = __s2_len > 2;
                  D.13668 = __result == 0;
                  D.13689 = D.13688 & D.13668;
                  if (D.13689 != 0) goto <D.13690>; else goto <D.13691>;
                  <D.13690>:
                  D.13692 = &MEM[(void *)"heapshot\n" + 3B];
                  D.13693 = *D.13692;
                  D.13694 = (int) D.13693;
                  D.13695 = __s2 + 3;
                  D.13696 = *D.13695;
                  D.13697 = (int) D.13696;
                  __result = D.13694 - D.13697;
                  <D.13691>:
                  <D.13681>:
                  <D.13671>:
                }
                D.11402 = __result;
              }
              iftmp.217 = -D.11402;
              goto <D.13698>;
              <D.13661>:
              iftmp.217 = __builtin_strcmp (&buf, "heapshot\n");
              <D.13698>:
              D.11403 = iftmp.217;
            }
            if (D.11403 == 0) goto <D.13699>; else goto <D.13700>;
            <D.13699>:
            heapshot_requested = 1;
            runtime_inited.218 = runtime_inited;
            if (runtime_inited.218 != 0) goto <D.13702>; else goto <D.13703>;
            <D.13702>:
            if (thread == 0B) goto <D.13704>; else goto <D.13705>;
            <D.13704>:
            D.13706 = mono_get_root_domain ();
            thread = mono_thread_attach (D.13706);
            <D.13705>:
            <D.13703>:
            if (thread != 0B) goto <D.13707>; else goto <D.13708>;
            <D.13707>:
            process_requests (prof);
            mono_thread_detach (thread);
            thread = 0B;
            <D.13708>:
            <D.13700>:
            // predicted unlikely by continue predictor.
            goto <D.11373>;
            <D.13654>:
            <D.13639>:
            {
              long int __d;

              __d = prof->server_socket;
              D.13710 = __builtin_constant_p (__d);
              if (D.13710 != 0) goto <D.13711>; else goto <D.13712>;
              <D.13711>:
              __d.221 = (unsigned int) __d;
              if (__d.221 <= 1023) goto <D.13715>; else goto <D.13716>;
              <D.13715>:
              iftmp.220 = __d / 32;
              goto <D.13717>;
              <D.13716>:
              iftmp.220 = __fdelt_warn (__d);
              <D.13717>:
              iftmp.219 = iftmp.220;
              goto <D.13718>;
              <D.13712>:
              iftmp.219 = __fdelt_chk (__d);
              <D.13718>:
              D.11405 = iftmp.219;
            }
            D.13719 = rfds.fds_bits[D.11405];
            D.13479 = prof->server_socket;
            D.13480 = D.13479 % 32;
            D.13720 = D.13719 >> D.13480;
            D.13721 = D.13720 & 1;
            if (D.13721 == 0) goto <D.13722>; else goto <D.13723>;
            <D.13722>:
            // predicted unlikely by continue predictor.
            goto <D.11373>;
            <D.13723>:
            D.13724.__sockaddr__ = 0B;
            D.13479 = prof->server_socket;
            command_socket = accept (D.13479, D.13724, 0B);
            if (command_socket < 0) goto <D.13725>; else goto <D.13726>;
            <D.13725>:
            // predicted unlikely by continue predictor.
            goto <D.11373>;
            <D.13726>:
          }
        finally
          {
            rfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.11373>:
      goto <D.11406>;
      D.13555 = 0B;
      return D.13555;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.13763;
  int D.13766;
  ssize_t D.13769;
  unsigned int D.13770;
  unsigned int D.13771;
  unsigned int D.13774;

  D.13763 = __builtin_object_size (__buf, 0);
  if (D.13763 != 4294967295) goto <D.13764>; else goto <D.13765>;
  <D.13764>:
  D.13766 = __builtin_constant_p (__nbytes);
  if (D.13766 == 0) goto <D.13767>; else goto <D.13768>;
  <D.13767>:
  D.13770 = __builtin_object_size (__buf, 0);
  D.13769 = __read_chk (__fd, __buf, __nbytes, D.13770);
  return D.13769;
  <D.13768>:
  D.13771 = __builtin_object_size (__buf, 0);
  if (D.13771 < __nbytes) goto <D.13772>; else goto <D.13773>;
  <D.13772>:
  D.13774 = __builtin_object_size (__buf, 0);
  D.13769 = __read_chk_warn (__fd, __buf, __nbytes, D.13774);
  return D.13769;
  <D.13773>:
  <D.13765>:
  D.13769 = __read_alias (__fd, __buf, __nbytes);
  return D.13769;
}


dump_header (struct MonoProfiler * profiler)
{
  char * p.222;
  char * p.223;
  char * p.224;
  char * p.225;
  long int D.13783;
  long long unsigned int D.13784;
  long long unsigned int D.13785;
  long long int D.13786;
  int D.13787;
  unsigned int D.13788;
  int D.13789;
  int D.13790;
  struct FILE * D.13791;
  int p.226;
  int hbuf.227;
  int D.13794;
  unsigned int D.13795;
  char hbuf[128];
  char * p;

  try
    {
      p = &hbuf;
      p = write_int32 (p, 1297111553);
      p.222 = p;
      p = p.222 + 1;
      *p.222 = 0;
      p.223 = p;
      p = p.223 + 1;
      *p.223 = 4;
      p.224 = p;
      p = p.224 + 1;
      *p.224 = 4;
      p.225 = p;
      p = p.225 + 1;
      *p.225 = 4;
      D.13783 = time (0B);
      D.13784 = (long long unsigned int) D.13783;
      D.13785 = D.13784 * 1000;
      D.13786 = (long long int) D.13785;
      p = write_int64 (p, D.13786);
      D.13787 = get_timer_overhead ();
      p = write_int32 (p, D.13787);
      p = write_int32 (p, 0);
      D.13788 = process_id ();
      D.13789 = (int) D.13788;
      p = write_int32 (p, D.13789);
      D.13790 = profiler->command_port;
      p = write_int16 (p, D.13790);
      p = write_int16 (p, 0);
      D.13791 = profiler->file;
      p.226 = (int) p;
      hbuf.227 = (int) &hbuf;
      D.13794 = p.226 - hbuf.227;
      D.13795 = (unsigned int) D.13794;
      fwrite (&hbuf, D.13795, 1, D.13791);
      D.13791 = profiler->file;
      fflush (D.13791);
    }
  finally
    {
      hbuf = {CLOBBER};
    }
}


write_int16 (char * buf, int32_t value)
{
  sizetype i.228;
  char * D.13808;
  char D.13809;
  char * D.13810;
  int i;

  i = 0;
  goto <D.10841>;
  <D.10840>:
  i.228 = (sizetype) i;
  D.13808 = buf + i.228;
  D.13809 = (char) value;
  *D.13808 = D.13809;
  value = value >> 8;
  i = i + 1;
  <D.10841>:
  if (i <= 1) goto <D.10840>; else goto <D.10842>;
  <D.10842>:
  D.13810 = buf + 2;
  return D.13810;
}


init_thread ()
{
  struct LogBuffer * tlsbuffer.229;
  unsigned int D.13815;
  struct LogBuffer * logbuffer;

  tlsbuffer.229 = tlsbuffer;
  if (tlsbuffer.229 != 0B) goto <D.13813>; else goto <D.13814>;
  <D.13813>:
  return;
  <D.13814>:
  logbuffer = create_buffer ();
  tlsbuffer = logbuffer;
  D.13815 = thread_id ();
  logbuffer->thread_id = D.13815;
}


create_buffer ()
{
  long long unsigned int D.13819;
  long long unsigned int D.13820;
  int D.13821;
  sizetype D.13822;
  unsigned char * D.13823;
  unsigned char[1] * D.13824;
  struct LogBuffer * D.13825;
  struct LogBuffer * buf;

  buf = alloc_buffer (65536);
  buf->size = 65536;
  D.13819 = current_time ();
  buf->time_base = D.13819;
  D.13820 = buf->time_base;
  buf->last_time = D.13820;
  D.13821 = buf->size;
  D.13822 = (sizetype) D.13821;
  D.13823 = buf + D.13822;
  buf->data_end = D.13823;
  D.13824 = &buf->buf;
  buf->data = D.13824;
  D.13825 = buf;
  return D.13825;
}