utils_init (int fast_time)
{
  long unsigned int D.12269;
  long unsigned int time_inc.0;
  int D.12271;
  uint64_t (*<T1d6d>) (void) time_func.1;
  long unsigned int D.12277;
  long unsigned int D.12278;
  int timer_overhead.2;
  int i;
  uint64_t time_start;
  uint64_t time_end;

  if (fast_time > 1) goto <D.12264>; else goto <D.12265>;
  <D.12264>:
  time_func = null_time;
  goto <D.12266>;
  <D.12265>:
  if (fast_time != 0) goto <D.12267>; else goto <D.12268>;
  <D.12267>:
  {
    uint64_t timea;
    uint64_t timeb;

    clock_time ();
    timea = clock_time ();
    timeb = clock_time ();
    D.12269 = timeb - timea;
    time_inc.0 = D.12269 / 8;
    time_inc = time_inc.0;
    D.12271 = have_rdtsc ();
    if (D.12271 != 0) goto <D.12272>; else goto <D.12273>;
    <D.12272>:
    time_func = rdtsc_current_time;
    goto <D.12274>;
    <D.12273>:
    time_func = fast_current_time;
    <D.12274>:
  }
  goto <D.12275>;
  <D.12268>:
  time_func = clock_time;
  <D.12275>:
  <D.12266>:
  time_func.1 = time_func;
  time_start = time_func.1 ();
  i = 0;
  goto <D.10694>;
  <D.10693>:
  time_func.1 = time_func;
  time_func.1 ();
  i = i + 1;
  <D.10694>:
  if (i <= 255) goto <D.10693>; else goto <D.10695>;
  <D.10695>:
  time_func.1 = time_func;
  time_end = time_func.1 ();
  D.12277 = time_end - time_start;
  D.12278 = D.12277 / 256;
  timer_overhead.2 = (int) D.12278;
  timer_overhead = timer_overhead.2;
}


fast_current_time ()
{
  unsigned int D.12285;
  unsigned int D.12286;
  unsigned int D.12287;
  unsigned int D.12288;
  long unsigned int D.12291;
  long unsigned int time_inc.3;
  long unsigned int D.12293;
  uint64_t D.12294;
  long unsigned int D.12295;
  struct TlsData * tls;

  tls = &tls_data;
  D.12285 = tls->timer_count;
  D.12286 = D.12285;
  D.12287 = D.12286 + 1;
  tls->timer_count = D.12287;
  D.12288 = D.12286 & 7;
  if (D.12288 != 0) goto <D.12289>; else goto <D.12290>;
  <D.12289>:
  D.12291 = tls->last_time;
  time_inc.3 = time_inc;
  D.12293 = D.12291 + time_inc.3;
  tls->last_time = D.12293;
  D.12294 = tls->last_time;
  return D.12294;
  <D.12290>:
  D.12295 = clock_time ();
  tls->last_time = D.12295;
  D.12294 = tls->last_time;
  return D.12294;
}


rdtsc_current_time ()
{
  unsigned int D.12298;
  unsigned int D.12299;
  unsigned int D.12300;
  unsigned int D.12301;
  int cpu.4;
  int D.12307;
  long unsigned int D.12310;
  long unsigned int D.12311;
  double D.12314;
  double cpu_freq.5;
  double D.12316;
  uint64_t D.12317;
  long unsigned int D.12318;
  long unsigned int D.12320;
  int * D.12321;
  long unsigned int D.12322;
  struct TlsData * tls;

  tls = &tls_data;
  D.12298 = tls->timer_count;
  D.12299 = D.12298;
  D.12300 = D.12299 + 1;
  tls->timer_count = D.12300;
  D.12301 = D.12299 & 63;
  if (D.12301 != 0) goto <D.12302>; else goto <D.12303>;
  <D.12302>:
  {
    int cpu;
    uint64_t tsc;

    try
      {
        tsc = safe_rdtsc (&cpu);
        cpu.4 = cpu;
        if (cpu.4 != -1) goto <D.12305>; else goto <D.12306>;
        <D.12305>:
        D.12307 = tls->last_cpu;
        cpu.4 = cpu;
        if (D.12307 == cpu.4) goto <D.12308>; else goto <D.12309>;
        <D.12308>:
        {
          int64_t diff;
          uint64_t nsecs;

          D.12310 = tls->last_rdtsc;
          D.12311 = tsc - D.12310;
          diff = (int64_t) D.12311;
          if (diff > 0) goto <D.12312>; else goto <D.12313>;
          <D.12312>:
          D.12314 = (double) diff;
          cpu_freq.5 = cpu_freq;
          D.12316 = D.12314 / cpu_freq.5;
          nsecs = (uint64_t) D.12316;
          D.12318 = tls->last_time;
          D.12317 = D.12318 + nsecs;
          return D.12317;
          <D.12313>:
          printf ("tsc went backwards\n");
        }
        goto <D.12319>;
        <D.12309>:
        <D.12319>:
        <D.12306>:
      }
    finally
      {
        cpu = {CLOBBER};
      }
  }
  <D.12303>:
  D.12320 = clock_time ();
  tls->last_time = D.12320;
  D.12321 = &tls->last_cpu;
  D.12322 = safe_rdtsc (D.12321);
  tls->last_rdtsc = D.12322;
  D.12317 = tls->last_time;
  return D.12317;
}


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

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


safe_rdtsc (int * cpu)
{
  uint64_t D.12335;
  long unsigned int D.12336;
  long unsigned int D.12337;
  long unsigned int D.12338;
  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.12333>; else goto <D.12334>;
  <D.12333>:
  *cpu = -1;
  D.12335 = 0;
  return D.12335;
  <D.12334>:
  *cpu = c1;
  D.12336 = (long unsigned int) high;
  D.12337 = D.12336 << 32;
  D.12338 = (long unsigned int) low;
  D.12335 = D.12337 + D.12338;
  return D.12335;
}


null_time ()
{
  uint64_t D.12340;
  long unsigned int timer.6;
  long unsigned int timer.7;
  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.12340 = timer.7;
  return D.12340;
}


clock_time ()
{
  uint64_t D.12345;
  long int D.12346;
  long long unsigned int D.12347;
  long long unsigned int D.12348;
  long int D.12349;
  long long unsigned int D.12350;
  struct timespec tspec;

  try
    {
      clock_gettime (1, &tspec);
      D.12346 = tspec.tv_sec;
      D.12347 = (long long unsigned int) D.12346;
      D.12348 = D.12347 * 1000000000;
      D.12349 = tspec.tv_nsec;
      D.12350 = (long long unsigned int) D.12349;
      D.12345 = D.12348 + D.12350;
      return D.12345;
    }
  finally
    {
      tspec = {CLOBBER};
    }
}


have_rdtsc ()
{
  int D.12355;
  int D.12358;
  float val.9;
  float D.12362;
  double cpu_freq.10;
  int D.12364;
  char * D.12367;
  char * D.12370;
  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.12353>; else goto <D.12354>;
      <D.12353>:
      D.12355 = 0;
      return D.12355;
      <D.12354>:
      cpuinfo = fopen ("/proc/cpuinfo", "r");
      if (cpuinfo == 0B) goto <D.12356>; else goto <D.12357>;
      <D.12356>:
      D.12355 = 0;
      return D.12355;
      <D.12357>:
      goto <D.10671>;
      <D.10670>:
      D.12358 = sscanf (&buf, "cpu MHz : %f", &val);
      if (D.12358 == 1) goto <D.12359>; else goto <D.12360>;
      <D.12359>:
      have_freq = 1;
      val.9 = val;
      D.12362 = val.9 * 1.0e+6;
      cpu_freq.10 = (double) D.12362;
      cpu_freq = cpu_freq.10;
      <D.12360>:
      D.12364 = strncmp (&buf, "flags :", 5);
      if (D.12364 == 0) goto <D.12365>; else goto <D.12366>;
      <D.12365>:
      D.12367 = strstr (&buf, "constant_tsc");
      if (D.12367 != 0B) goto <D.12368>; else goto <D.12369>;
      <D.12368>:
      have_flag = 1;
      <D.12369>:
      <D.12366>:
      <D.10671>:
      D.12370 = fgets (&buf, 256, cpuinfo);
      if (D.12370 != 0B) goto <D.10670>; else goto <D.10672>;
      <D.10672>:
      fclose (cpuinfo);
      if (have_flag != 0) goto <D.12372>; else goto <D.12373>;
      <D.12372>:
      iftmp.11 = have_freq;
      goto <D.12374>;
      <D.12373>:
      iftmp.11 = 0;
      <D.12374>:
      D.12355 = iftmp.11;
      return D.12355;
    }
  finally
    {
      buf = {CLOBBER};
      val = {CLOBBER};
    }
}


fgets (char * restrict __s, int __n, struct FILE * restrict __stream)
{
  long unsigned int D.12380;
  int D.12385;
  char * D.12387;
  long unsigned int D.12388;
  long unsigned int D.12389;
  long unsigned int D.12390;
  long unsigned int D.12393;

  D.12380 = __builtin_object_size (__s, 1);
  if (D.12380 != 18446744073709551615) goto <D.12381>; else goto <D.12382>;
  <D.12381>:
  D.12385 = __builtin_constant_p (__n);
  if (D.12385 == 0) goto <D.12383>; else goto <D.12386>;
  <D.12386>:
  if (__n <= 0) goto <D.12383>; else goto <D.12384>;
  <D.12383>:
  D.12388 = __builtin_object_size (__s, 1);
  D.12387 = __fgets_chk (__s, D.12388, __n, __stream);
  return D.12387;
  <D.12384>:
  D.12389 = (long unsigned int) __n;
  D.12390 = __builtin_object_size (__s, 1);
  if (D.12389 > D.12390) goto <D.12391>; else goto <D.12392>;
  <D.12391>:
  D.12393 = __builtin_object_size (__s, 1);
  D.12387 = __fgets_chk_warn (__s, D.12393, __n, __stream);
  return D.12387;
  <D.12392>:
  <D.12382>:
  D.12387 = __fgets_alias (__s, __n, __stream);
  return D.12387;
}


get_timer_overhead ()
{
  int D.12398;

  D.12398 = timer_overhead;
  return D.12398;
}


current_time ()
{
  uint64_t D.12400;
  uint64_t (*<T1d6d>) (void) time_func.12;

  time_func.12 = time_func;
  D.12400 = time_func.12 ();
  return D.12400;
}


alloc_buffer (int size)
{
  long unsigned int D.12404;
  void * D.12407;
  void * ptr;

  D.12404 = (long unsigned int) size;
  ptr = mmap (0B, D.12404, 3, 34, -1, 0);
  if (ptr == -1B) goto <D.12405>; else goto <D.12406>;
  <D.12405>:
  D.12407 = 0B;
  return D.12407;
  <D.12406>:
  D.12407 = ptr;
  return D.12407;
}


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

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


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.12410;
  uint8_t * p.13;
  uint8_t * p;

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

    D.12410 = (unsigned char) value;
    b = D.12410 & 127;
    value = value >> 7;
    if (value != 0) goto <D.12411>; else goto <D.12412>;
    <D.12411>:
    b = b | 128;
    <D.12412>:
    p.13 = p;
    p = p.13 + 1;
    *p.13 = b;
  }
  if (value != 0) goto <D.10723>; else goto <D.10724>;
  <D.10724>:
  *endbuf = p;
}


encode_sleb128 (intptr_t value, uint8_t * buf, uint8_t * * endbuf)
{
  _Bool D.12414;
  unsigned char D.12415;
  unsigned int D.12418;
  int D.12419;
  long int D.12420;
  long int D.12421;
  int D.12427;
  int D.12428;
  uint8_t * p.14;
  int more;
  int negative;
  unsigned int size;
  uint8_t byte;
  uint8_t * p;

  more = 1;
  D.12414 = value < 0;
  negative = (int) D.12414;
  size = 64;
  p = buf;
  goto <D.10736>;
  <D.10735>:
  D.12415 = (unsigned char) value;
  byte = D.12415 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.12416>; else goto <D.12417>;
  <D.12416>:
  D.12418 = size + 4294967289;
  D.12419 = (int) D.12418;
  D.12420 = 1 << D.12419;
  D.12421 = -D.12420;
  value = D.12421 | value;
  <D.12417>:
  if (value == 0) goto <D.12426>; else goto <D.12422>;
  <D.12426>:
  D.12427 = (int) byte;
  D.12428 = D.12427 & 64;
  if (D.12428 == 0) goto <D.12423>; else goto <D.12422>;
  <D.12422>:
  if (value == -1) goto <D.12429>; else goto <D.12424>;
  <D.12429>:
  D.12427 = (int) byte;
  D.12428 = D.12427 & 64;
  if (D.12428 != 0) goto <D.12423>; else goto <D.12424>;
  <D.12423>:
  more = 0;
  goto <D.12425>;
  <D.12424>:
  byte = byte | 128;
  <D.12425>:
  p.14 = p;
  p = p.14 + 1;
  *p.14 = byte;
  <D.10736>:
  if (more != 0) goto <D.10735>; else goto <D.10737>;
  <D.10737>:
  *endbuf = p;
}


decode_uleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  uint8_t * buf.15;
  long unsigned int D.12432;
  long unsigned int D.12433;
  long unsigned int D.12434;
  signed char b.16;
  uint64_t D.12437;
  uint64_t res;
  int shift;

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

    buf.15 = buf;
    buf = buf.15 + 1;
    b = *buf.15;
    D.12432 = (long unsigned int) b;
    D.12433 = D.12432 & 127;
    D.12434 = D.12433 << shift;
    res = D.12434 | res;
    b.16 = (signed char) b;
    if (b.16 >= 0) goto <D.10745>; else goto <D.12436>;
    <D.12436>:
    shift = shift + 7;
  }
  goto <D.10746>;
  <D.10745>:
  *endbuf = buf;
  D.12437 = res;
  return D.12437;
}


decode_sleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  long int D.12439;
  long int D.12440;
  long int D.12441;
  signed char b.17;
  unsigned int shift.18;
  int D.12448;
  int D.12449;
  long int D.12452;
  long int D.12453;
  intptr_t D.12454;
  uint8_t * p;
  intptr_t res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.12439 = (long int) b;
    D.12440 = D.12439 & 127;
    D.12441 = D.12440 << shift;
    res = D.12441 | res;
    shift = shift + 7;
    b.17 = (signed char) b;
    if (b.17 >= 0) goto <D.12443>; else goto <D.12444>;
    <D.12443>:
    shift.18 = (unsigned int) shift;
    if (shift.18 <= 63) goto <D.12446>; else goto <D.12447>;
    <D.12446>:
    D.12448 = (int) b;
    D.12449 = D.12448 & 64;
    if (D.12449 != 0) goto <D.12450>; else goto <D.12451>;
    <D.12450>:
    D.12452 = 1 << shift;
    D.12453 = -D.12452;
    res = D.12453 | res;
    <D.12451>:
    <D.12447>:
    goto <D.10755>;
    <D.12444>:
  }
  goto <D.10756>;
  <D.10755>:
  *endbuf = p;
  D.12454 = res;
  return D.12454;
}


thread_id ()
{
  uintptr_t D.12456;

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


process_id ()
{
  uintptr_t D.12458;
  int D.12459;

  D.12459 = getpid ();
  D.12458 = (uintptr_t) D.12459;
  return D.12458;
}


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


mono_profiler_startup (const char * desc)
{
  int D.12461;
  char D.12464;
  int D.12247;
  int iftmp.19;
  int D.12246;
  const char[5] * D.12484;
  unsigned char D.12485;
  int D.12486;
  unsigned char D.12487;
  int D.12488;
  _Bool D.12489;
  _Bool D.12490;
  _Bool D.12491;
  const unsigned char * D.12494;
  unsigned char D.12495;
  int D.12496;
  const unsigned char * D.12497;
  unsigned char D.12498;
  int D.12499;
  _Bool D.12500;
  _Bool D.12501;
  const unsigned char * D.12504;
  unsigned char D.12505;
  int D.12506;
  const unsigned char * D.12507;
  unsigned char D.12508;
  int D.12509;
  _Bool D.12510;
  _Bool D.12511;
  const unsigned char * D.12514;
  unsigned char D.12515;
  int D.12516;
  const unsigned char * D.12517;
  unsigned char D.12518;
  int D.12519;
  char * val.20;
  int D.12256;
  int iftmp.21;
  int D.12255;
  const char[5] * D.12528;
  unsigned char D.12529;
  int D.12530;
  unsigned char D.12531;
  int D.12532;
  _Bool D.12533;
  _Bool D.12534;
  _Bool D.12535;
  const unsigned char * D.12538;
  unsigned char D.12539;
  int D.12540;
  const unsigned char * D.12541;
  unsigned char D.12542;
  int D.12543;
  _Bool D.12544;
  _Bool D.12545;
  const unsigned char * D.12548;
  unsigned char D.12549;
  int D.12550;
  const unsigned char * D.12551;
  unsigned char D.12552;
  int D.12553;
  _Bool D.12554;
  _Bool D.12555;
  const unsigned char * D.12558;
  unsigned char D.12559;
  int D.12560;
  const unsigned char * D.12561;
  unsigned char D.12562;
  int D.12563;
  struct _IO_FILE * stderr.22;
  long unsigned int D.12585;
  int command_port.23;
  long unsigned int D.12589;
  int num_frames.24;
  int num_frames.25;
  _Bool D.12594;
  int notraces.26;
  long unsigned int D.12598;
  int max_call_depth.27;
  int do_mono_sample.28;
  int sample_type.29;
  <unnamed type> events.30;
  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.12461 = strncmp (p, "log", 3);
  if (D.12461 != 0) goto <D.12462>; else goto <D.12463>;
  <D.12462>:
  usage (1);
  <D.12463>:
  p = p + 3;
  D.12464 = *p;
  if (D.12464 == 58) goto <D.12465>; else goto <D.12466>;
  <D.12465>:
  p = p + 1;
  <D.12466>:
  goto <D.12261>;
  <D.12260>:
  {
    char * val;

    try
      {
        D.12464 = *p;
        if (D.12464 == 44) goto <D.12467>; else goto <D.12468>;
        <D.12467>:
        opt = p + 1;
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12468>:
        opt = match_option (p, "help", 0B);
        if (opt != p) goto <D.12469>; else goto <D.12470>;
        <D.12469>:
        usage (0);
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12470>:
        opt = match_option (p, "calls", 0B);
        if (opt != p) goto <D.12471>; else goto <D.12472>;
        <D.12471>:
        calls_enabled = 1;
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12472>:
        opt = match_option (p, "nocalls", 0B);
        if (opt != p) goto <D.12473>; else goto <D.12474>;
        <D.12473>:
        events = events & -4097;
        nocalls = 1;
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12474>:
        opt = match_option (p, "alloc", 0B);
        if (opt != p) goto <D.12475>; else goto <D.12476>;
        <D.12475>:
        allocs_enabled = 1;
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12476>:
        opt = match_option (p, "noalloc", 0B);
        if (opt != p) goto <D.12477>; else goto <D.12478>;
        <D.12477>:
        events = events & -129;
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12478>:
        opt = match_option (p, "time", &val);
        if (opt != p) goto <D.12479>; else goto <D.12480>;
        <D.12479>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = val;
            D.12484 = "fast";
            D.12485 = MEM[(const unsigned char *)D.12484];
            D.12486 = (int) D.12485;
            D.12487 = *__s2;
            D.12488 = (int) D.12487;
            __result = D.12486 - D.12488;
            {
              D.12489 = __s2_len != 0;
              D.12490 = __result == 0;
              D.12491 = D.12489 & D.12490;
              if (D.12491 != 0) goto <D.12492>; else goto <D.12493>;
              <D.12492>:
              D.12494 = &MEM[(void *)"fast" + 1B];
              D.12495 = *D.12494;
              D.12496 = (int) D.12495;
              D.12497 = __s2 + 1;
              D.12498 = *D.12497;
              D.12499 = (int) D.12498;
              __result = D.12496 - D.12499;
              D.12500 = __s2_len > 1;
              D.12490 = __result == 0;
              D.12501 = D.12500 & D.12490;
              if (D.12501 != 0) goto <D.12502>; else goto <D.12503>;
              <D.12502>:
              D.12504 = &MEM[(void *)"fast" + 2B];
              D.12505 = *D.12504;
              D.12506 = (int) D.12505;
              D.12507 = __s2 + 2;
              D.12508 = *D.12507;
              D.12509 = (int) D.12508;
              __result = D.12506 - D.12509;
              D.12510 = __s2_len > 2;
              D.12490 = __result == 0;
              D.12511 = D.12510 & D.12490;
              if (D.12511 != 0) goto <D.12512>; else goto <D.12513>;
              <D.12512>:
              D.12514 = &MEM[(void *)"fast" + 3B];
              D.12515 = *D.12514;
              D.12516 = (int) D.12515;
              D.12517 = __s2 + 3;
              D.12518 = *D.12517;
              D.12519 = (int) D.12518;
              __result = D.12516 - D.12519;
              <D.12513>:
              <D.12503>:
              <D.12493>:
            }
            D.12246 = __result;
          }
          iftmp.19 = -D.12246;
          goto <D.12520>;
          <D.12483>:
          val.20 = val;
          iftmp.19 = __builtin_strcmp (val.20, "fast");
          <D.12520>:
          D.12247 = iftmp.19;
        }
        if (D.12247 == 0) goto <D.12522>; else goto <D.12523>;
        <D.12522>:
        fast_time = 1;
        goto <D.12524>;
        <D.12523>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = val;
            D.12528 = "null";
            D.12529 = MEM[(const unsigned char *)D.12528];
            D.12530 = (int) D.12529;
            D.12531 = *__s2;
            D.12532 = (int) D.12531;
            __result = D.12530 - D.12532;
            {
              D.12533 = __s2_len != 0;
              D.12534 = __result == 0;
              D.12535 = D.12533 & D.12534;
              if (D.12535 != 0) goto <D.12536>; else goto <D.12537>;
              <D.12536>:
              D.12538 = &MEM[(void *)"null" + 1B];
              D.12539 = *D.12538;
              D.12540 = (int) D.12539;
              D.12541 = __s2 + 1;
              D.12542 = *D.12541;
              D.12543 = (int) D.12542;
              __result = D.12540 - D.12543;
              D.12544 = __s2_len > 1;
              D.12534 = __result == 0;
              D.12545 = D.12544 & D.12534;
              if (D.12545 != 0) goto <D.12546>; else goto <D.12547>;
              <D.12546>:
              D.12548 = &MEM[(void *)"null" + 2B];
              D.12549 = *D.12548;
              D.12550 = (int) D.12549;
              D.12551 = __s2 + 2;
              D.12552 = *D.12551;
              D.12553 = (int) D.12552;
              __result = D.12550 - D.12553;
              D.12554 = __s2_len > 2;
              D.12534 = __result == 0;
              D.12555 = D.12554 & D.12534;
              if (D.12555 != 0) goto <D.12556>; else goto <D.12557>;
              <D.12556>:
              D.12558 = &MEM[(void *)"null" + 3B];
              D.12559 = *D.12558;
              D.12560 = (int) D.12559;
              D.12561 = __s2 + 3;
              D.12562 = *D.12561;
              D.12563 = (int) D.12562;
              __result = D.12560 - D.12563;
              <D.12557>:
              <D.12547>:
              <D.12537>:
            }
            D.12255 = __result;
          }
          iftmp.21 = -D.12255;
          goto <D.12564>;
          <D.12527>:
          val.20 = val;
          iftmp.21 = __builtin_strcmp (val.20, "null");
          <D.12564>:
          D.12256 = iftmp.21;
        }
        if (D.12256 == 0) goto <D.12565>; else goto <D.12566>;
        <D.12565>:
        fast_time = 2;
        goto <D.12567>;
        <D.12566>:
        usage (1);
        <D.12567>:
        <D.12524>:
        val.20 = val;
        free (val.20);
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12480>:
        opt = match_option (p, "report", 0B);
        if (opt != p) goto <D.12568>; else goto <D.12569>;
        <D.12568>:
        do_report = 1;
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12569>:
        opt = match_option (p, "debug", 0B);
        if (opt != p) goto <D.12570>; else goto <D.12571>;
        <D.12570>:
        do_debug = 1;
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12571>:
        opt = match_option (p, "heapshot", &val);
        if (opt != p) goto <D.12572>; else goto <D.12573>;
        <D.12572>:
        events = events & -129;
        events = events & -4097;
        nocalls = 1;
        do_heap_shot = 1;
        val.20 = val;
        set_hsmode (val.20, 1);
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12573>:
        opt = match_option (p, "sample", &val);
        if (opt != p) goto <D.12574>; else goto <D.12575>;
        <D.12574>:
        events = events & -129;
        events = events & -4097;
        nocalls = 1;
        val.20 = val;
        set_sample_mode (val.20, 1);
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12575>:
        opt = match_option (p, "hsmode", &val);
        if (opt != p) goto <D.12576>; else goto <D.12577>;
        <D.12576>:
        stderr.22 = stderr;
        fprintf (stderr.22, "The hsmode profiler option is obsolete, use heapshot=MODE.\n");
        val.20 = val;
        set_hsmode (val.20, 0);
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12577>:
        opt = match_option (p, "zip", 0B);
        if (opt != p) goto <D.12579>; else goto <D.12580>;
        <D.12579>:
        use_zip = 1;
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12580>:
        opt = match_option (p, "output", &val);
        if (opt != p) goto <D.12581>; else goto <D.12582>;
        <D.12581>:
        filename = val;
        // predicted unlikely by continue predictor.
        goto <D.12238>;
        <D.12582>:
        opt = match_option (p, "port", &val);
        if (opt != p) goto <D.12583>; else goto <D.12584>;
        <D.12583>:
        {
          char * end;

          try
            {
              val.20 = val;
              D.12585 = strtoul (val.20, &end, 10);
              command_port.23 = (int) D.12585;
              command_port = command_port.23;
              val.20 = val;
              free (val.20);
              // predicted unlikely by continue predictor.
              goto <D.12238>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.12584>:
        opt = match_option (p, "maxframes", &val);
        if (opt != p) goto <D.12587>; else goto <D.12588>;
        <D.12587>:
        {
          char * end;

          try
            {
              val.20 = val;
              D.12589 = strtoul (val.20, &end, 10);
              num_frames.24 = (int) D.12589;
              num_frames = num_frames.24;
              num_frames.25 = num_frames;
              if (num_frames.25 > 16) goto <D.12592>; else goto <D.12593>;
              <D.12592>:
              num_frames = 16;
              <D.12593>:
              val.20 = val;
              free (val.20);
              num_frames.25 = num_frames;
              D.12594 = num_frames.25 == 0;
              notraces.26 = (int) D.12594;
              notraces = notraces.26;
              // predicted unlikely by continue predictor.
              goto <D.12238>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.12588>:
        opt = match_option (p, "calldepth", &val);
        if (opt != p) goto <D.12596>; else goto <D.12597>;
        <D.12596>:
        {
          char * end;

          try
            {
              val.20 = val;
              D.12598 = strtoul (val.20, &end, 10);
              max_call_depth.27 = (int) D.12598;
              max_call_depth = max_call_depth.27;
              val.20 = val;
              free (val.20);
              // predicted unlikely by continue predictor.
              goto <D.12238>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.12597>:
        if (opt == p) goto <D.12600>; else goto <D.12601>;
        <D.12600>:
        usage (0);
        exit (0);
        <D.12601>:
      }
    finally
      {
        val = {CLOBBER};
      }
  }
  <D.12238>:
  p = opt;
  <D.12261>:
  D.12464 = *p;
  if (D.12464 != 0) goto <D.12260>; else goto <D.12262>;
  <D.12262>:
  if (calls_enabled != 0) goto <D.12602>; else goto <D.12603>;
  <D.12602>:
  events = events | 4096;
  nocalls = 0;
  <D.12603>:
  if (allocs_enabled != 0) goto <D.12604>; else goto <D.12605>;
  <D.12604>:
  events = events | 128;
  <D.12605>:
  utils_init (fast_time);
  prof = create_profiler (filename);
  if (prof == 0B) goto <D.12606>; else goto <D.12607>;
  <D.12606>:
  return;
  <D.12607>:
  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.28 = do_mono_sample;
  if (do_mono_sample.28 != 0) goto <D.12609>; else goto <D.12610>;
  <D.12609>:
  sample_type.29 = sample_type;
  if (sample_type.29 == 1) goto <D.12612>; else goto <D.12613>;
  <D.12612>:
  events = events | 32768;
  mono_profiler_install_statistical (mono_sample_hit);
  <D.12613>:
  <D.12610>:
  events.30 = (<unnamed type>) events;
  mono_profiler_set_events (events.30);
}


mono_sample_hit (struct MonoProfiler * profiler, unsigned char * ip, void * context)
{
  int in_shutdown.31;
  int do_debug.32;
  long unsigned int D.12645;
  void * D.12646;
  long unsigned int D.12647;
  long unsigned int D.12648;
  uintptr_t * D.12651;
  uintptr_t * D.12652;
  uintptr_t * D.12653;
  struct StatBuffer * D.12656;
  struct StatBuffer * D.12659;
  struct StatBuffer * D.12660;
  int D.12663;
  uintptr_t * * D.12666;
  int sample_type.33;
  int D.12670;
  int D.12671;
  long unsigned int D.12672;
  uintptr_t * D.12673;
  long unsigned int D.12674;
  uintptr_t * D.12675;
  long unsigned int D.12676;
  long unsigned int D.12677;
  long unsigned int D.12678;
  uintptr_t * D.12679;
  long unsigned int ip.34;
  struct StatBuffer * sbuf;
  uint64_t now;
  uintptr_t * data;
  uintptr_t * new_data;
  uintptr_t * old_data;

  in_shutdown.31 = in_shutdown;
  if (in_shutdown.31 != 0) goto <D.12640>; else goto <D.12641>;
  <D.12640>:
  return;
  <D.12641>:
  now = current_time ();
  do_debug.32 = do_debug;
  if (do_debug.32 != 0) goto <D.12643>; else goto <D.12644>;
  <D.12643>:
  {
    int len;
    char buf[256];

    try
      {
        D.12645 = thread_id ();
        D.12646 = (void *) D.12645;
        snprintf (&buf, 256, "hit at %p in thread %p at %llu\n", ip, D.12646, now);
        D.12647 = strlen (&buf);
        len = (int) D.12647;
        D.12648 = (long unsigned int) len;
        write (2, &buf, D.12648);
      }
    finally
      {
        buf = {CLOBBER};
      }
  }
  <D.12644>:
  sbuf = profiler->stat_buffers;
  if (sbuf == 0B) goto <D.12649>; else goto <D.12650>;
  <D.12649>:
  return;
  <D.12650>:
  D.12651 = sbuf->data;
  D.12652 = D.12651 + 3200;
  D.12653 = sbuf->data_end;
  if (D.12652 >= D.12653) goto <D.12654>; else goto <D.12655>;
  <D.12654>:
  sbuf = create_stat_buffer ();
  D.12656 = profiler->stat_buffers;
  sbuf->next = D.12656;
  profiler->stat_buffers = sbuf;
  do_debug.32 = do_debug;
  if (do_debug.32 != 0) goto <D.12657>; else goto <D.12658>;
  <D.12657>:
  write (2, "overflow\n", 9);
  <D.12658>:
  D.12659 = sbuf->next;
  D.12660 = D.12659->next;
  if (D.12660 != 0B) goto <D.12661>; else goto <D.12662>;
  <D.12661>:
  {
    char c;

    try
      {
        c = 0;
        D.12663 = profiler->pipes[1];
        write (D.12663, &c, 1);
        do_debug.32 = do_debug;
        if (do_debug.32 != 0) goto <D.12664>; else goto <D.12665>;
        <D.12664>:
        write (2, "notify\n", 7);
        <D.12665>:
      }
    finally
      {
        c = {CLOBBER};
      }
  }
  <D.12662>:
  <D.12655>:
  <D.11788>:
  old_data = sbuf->data;
  new_data = old_data + 32;
  D.12666 = &sbuf->data;
  data = InterlockedCompareExchangePointer (D.12666, new_data, old_data);
  if (data != old_data) goto <D.11788>; else goto <D.11789>;
  <D.11789>:
  D.12653 = sbuf->data_end;
  if (D.12653 <= old_data) goto <D.12667>; else goto <D.12668>;
  <D.12667>:
  return;
  <D.12668>:
  sample_type.33 = sample_type;
  D.12670 = sample_type.33 << 16;
  D.12671 = D.12670 | 1;
  D.12672 = (long unsigned int) D.12671;
  *old_data = D.12672;
  D.12673 = old_data + 8;
  D.12674 = thread_id ();
  *D.12673 = D.12674;
  D.12675 = old_data + 16;
  D.12676 = profiler->startup_time;
  D.12677 = now - D.12676;
  D.12678 = D.12677 / 10000;
  *D.12675 = D.12678;
  D.12679 = old_data + 24;
  ip.34 = (long unsigned int) ip;
  *D.12679 = ip.34;
}


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

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


create_stat_buffer ()
{
  long unsigned int D.12694;
  uintptr_t * D.12695;
  uintptr_t[1] * D.12696;
  struct StatBuffer * D.12697;
  struct StatBuffer * buf;

  buf = alloc_buffer (65536);
  buf->size = 65536;
  D.12694 = buf->size;
  D.12695 = buf + D.12694;
  buf->data_end = D.12695;
  D.12696 = &buf->buf;
  buf->data = D.12696;
  D.12697 = buf;
  return D.12697;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.12700;
  long unsigned int exch.35;
  long unsigned int comp.36;
  long unsigned int D.12703;

  exch.35 = (long unsigned int) exch;
  comp.36 = (long unsigned int) comp;
  D.12703 = __sync_val_compare_and_swap_8 (dest, comp.36, exch.35);
  D.12700 = (void *) D.12703;
  return D.12700;
}


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


monitor_event (struct MonoProfiler * profiler, struct MonoObject * object, MonoProfilerMonitorEvent event)
{
  int iftmp.37;
  int nocalls.38;
  int runtime_inited.39;
  int notraces.40;
  int D.12717;
  int D.12720;
  unsigned int D.12721;
  unsigned int do_bt.41;
  unsigned int D.12723;
  unsigned int D.12724;
  int D.12725;
  int D.12728;
  int do_bt;
  uint64_t now;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.38 = nocalls;
      if (nocalls.38 != 0) goto <D.12709>; else goto <D.12706>;
      <D.12709>:
      runtime_inited.39 = runtime_inited;
      if (runtime_inited.39 != 0) goto <D.12711>; else goto <D.12706>;
      <D.12711>:
      notraces.40 = notraces;
      if (notraces.40 == 0) goto <D.12713>; else goto <D.12706>;
      <D.12713>:
      if (event == 1) goto <D.12714>; else goto <D.12706>;
      <D.12714>:
      iftmp.37 = 128;
      goto <D.12707>;
      <D.12706>:
      iftmp.37 = 0;
      <D.12707>:
      do_bt = iftmp.37;
      if (do_bt != 0) goto <D.12715>; else goto <D.12716>;
      <D.12715>:
      collect_bt (&data);
      <D.12716>:
      logbuffer = ensure_logbuf (144);
      now = current_time ();
      D.12717 = logbuffer->locked;
      if (D.12717 != 0) goto <D.12718>; else goto <D.12719>;
      <D.12718>:
      write (2, "monitor", 7);
      write (2, "\n", 1);
      return;
      <D.12719>:
      D.12717 = logbuffer->locked;
      D.12720 = D.12717 + 1;
      logbuffer->locked = D.12720;
      D.12721 = event << 4;
      do_bt.41 = (unsigned int) do_bt;
      D.12723 = D.12721 | do_bt.41;
      D.12724 = D.12723 | 5;
      D.12725 = (int) D.12724;
      emit_byte (logbuffer, D.12725);
      emit_time (logbuffer, now);
      emit_obj (logbuffer, object);
      if (do_bt != 0) goto <D.12726>; else goto <D.12727>;
      <D.12726>:
      emit_bt (logbuffer, &data);
      <D.12727>:
      D.12717 = logbuffer->locked;
      D.12728 = D.12717 + -1;
      logbuffer->locked = D.12728;
      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.12737;
  int num_frames.42;
  int D.12741;
  int D.12742;
  mono_bool D.12743;
  _Bool D.12744;
  struct FrameData * frame;

  frame = data;
  if (method != 0B) goto <D.12735>; else goto <D.12736>;
  <D.12735>:
  D.12737 = frame->count;
  num_frames.42 = num_frames;
  if (D.12737 < num_frames.42) goto <D.12739>; else goto <D.12740>;
  <D.12739>:
  D.12737 = frame->count;
  D.12741 = D.12737;
  D.12742 = D.12741 + 1;
  frame->count = D.12742;
  frame->methods[D.12741] = method;
  <D.12740>:
  <D.12736>:
  D.12737 = frame->count;
  num_frames.42 = num_frames;
  D.12744 = D.12737 == num_frames.42;
  D.12743 = (mono_bool) D.12744;
  return D.12743;
}


ensure_logbuf (int bytes)
{
  unsigned char * D.12748;
  sizetype D.12749;
  sizetype D.12750;
  unsigned char * D.12751;
  unsigned char * D.12752;
  struct LogBuffer * D.12755;
  struct LogBuffer * tlsbuffer.43;
  int D.12759;
  struct LogBuffer * old;

  old = tlsbuffer;
  if (old != 0B) goto <D.12746>; else goto <D.12747>;
  <D.12746>:
  D.12748 = old->data;
  D.12749 = (sizetype) bytes;
  D.12750 = D.12749 + 100;
  D.12751 = D.12748 + D.12750;
  D.12752 = old->data_end;
  if (D.12751 < D.12752) goto <D.12753>; else goto <D.12754>;
  <D.12753>:
  D.12755 = old;
  return D.12755;
  <D.12754>:
  <D.12747>:
  tlsbuffer = 0B;
  init_thread ();
  tlsbuffer.43 = tlsbuffer;
  tlsbuffer.43->next = old;
  if (old != 0B) goto <D.12757>; else goto <D.12758>;
  <D.12757>:
  tlsbuffer.43 = tlsbuffer;
  D.12759 = old->call_depth;
  tlsbuffer.43->call_depth = D.12759;
  <D.12758>:
  D.12755 = tlsbuffer;
  return D.12755;
}


emit_byte (struct LogBuffer * logbuffer, int value)
{
  unsigned char * D.12761;
  unsigned char D.12762;
  unsigned char * D.12763;
  unsigned char * D.12764;
  static const char __PRETTY_FUNCTION__[10] = "emit_byte";

  D.12761 = logbuffer->data;
  D.12762 = (unsigned char) value;
  *D.12761 = D.12762;
  D.12761 = logbuffer->data;
  D.12763 = D.12761 + 1;
  logbuffer->data = D.12763;
  D.12761 = logbuffer->data;
  D.12764 = logbuffer->data_end;
  if (D.12761 > D.12764) goto <D.12765>; else goto <D.12766>;
  <D.12765>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 443, &__PRETTY_FUNCTION__);
  <D.12766>:
}


emit_time (struct LogBuffer * logbuffer, uint64_t value)
{
  long unsigned int D.12767;
  unsigned char * * D.12770;
  unsigned char * D.12771;
  unsigned char * D.12772;
  uint64_t tdiff;
  unsigned char * p;
  static const char __PRETTY_FUNCTION__[10] = "emit_time";

  D.12767 = logbuffer->last_time;
  tdiff = value - D.12767;
  D.12767 = logbuffer->last_time;
  if (D.12767 > value) goto <D.12768>; else goto <D.12769>;
  <D.12768>:
  printf ("time went backwards\n");
  <D.12769>:
  p = logbuffer->data;
  D.12770 = &logbuffer->data;
  D.12771 = logbuffer->data;
  encode_uleb128 (tdiff, D.12771, D.12770);
  logbuffer->last_time = value;
  D.12771 = logbuffer->data;
  D.12772 = logbuffer->data_end;
  if (D.12771 > D.12772) goto <D.12773>; else goto <D.12774>;
  <D.12773>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 467, &__PRETTY_FUNCTION__);
  <D.12774>:
}


emit_obj (struct LogBuffer * logbuffer, void * ptr)
{
  long unsigned int D.12775;
  long unsigned int ptr.44;
  long unsigned int D.12779;
  long unsigned int D.12780;
  long int D.12781;
  unsigned char * D.12782;
  unsigned char * D.12783;
  static const char __PRETTY_FUNCTION__[9] = "emit_obj";

  D.12775 = logbuffer->obj_base;
  if (D.12775 == 0) goto <D.12776>; else goto <D.12777>;
  <D.12776>:
  ptr.44 = (long unsigned int) ptr;
  D.12779 = ptr.44 >> 3;
  logbuffer->obj_base = D.12779;
  <D.12777>:
  ptr.44 = (long unsigned int) ptr;
  D.12779 = ptr.44 >> 3;
  D.12775 = logbuffer->obj_base;
  D.12780 = D.12779 - D.12775;
  D.12781 = (long int) D.12780;
  emit_svalue (logbuffer, D.12781);
  D.12782 = logbuffer->data;
  D.12783 = logbuffer->data_end;
  if (D.12782 > D.12783) goto <D.12784>; else goto <D.12785>;
  <D.12784>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 511, &__PRETTY_FUNCTION__);
  <D.12785>:
}


emit_svalue (struct LogBuffer * logbuffer, int64_t value)
{
  unsigned char * * D.12786;
  unsigned char * D.12787;
  unsigned char * D.12788;
  static const char __PRETTY_FUNCTION__[12] = "emit_svalue";

  D.12786 = &logbuffer->data;
  D.12787 = logbuffer->data;
  encode_sleb128 (value, D.12787, D.12786);
  D.12787 = logbuffer->data;
  D.12788 = logbuffer->data_end;
  if (D.12787 > D.12788) goto <D.12789>; else goto <D.12790>;
  <D.12789>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 474, &__PRETTY_FUNCTION__);
  <D.12790>:
}


emit_bt (struct LogBuffer * logbuffer, struct FrameData * data)
{
  int D.12791;
  int num_frames.45;
  int D.12795;
  struct MonoMethod * D.12796;

  D.12791 = data->count;
  num_frames.45 = num_frames;
  if (D.12791 > num_frames.45) goto <D.12793>; else goto <D.12794>;
  <D.12793>:
  D.12791 = data->count;
  printf ("bad num frames: %d\n", D.12791);
  <D.12794>:
  emit_value (logbuffer, 0);
  D.12791 = data->count;
  emit_value (logbuffer, D.12791);
  goto <D.11631>;
  <D.11630>:
  D.12791 = data->count;
  D.12795 = D.12791 + -1;
  data->count = D.12795;
  D.12791 = data->count;
  D.12796 = data->methods[D.12791];
  emit_ptr (logbuffer, D.12796);
  <D.11631>:
  D.12791 = data->count;
  if (D.12791 != 0) goto <D.11630>; else goto <D.11632>;
  <D.11632>:
}


emit_value (struct LogBuffer * logbuffer, int value)
{
  unsigned char * * D.12797;
  unsigned char * D.12798;
  long unsigned int D.12799;
  unsigned char * D.12800;
  static const char __PRETTY_FUNCTION__[11] = "emit_value";

  D.12797 = &logbuffer->data;
  D.12798 = logbuffer->data;
  D.12799 = (long unsigned int) value;
  encode_uleb128 (D.12799, D.12798, D.12797);
  D.12798 = logbuffer->data;
  D.12800 = logbuffer->data_end;
  if (D.12798 > D.12800) goto <D.12801>; else goto <D.12802>;
  <D.12801>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 450, &__PRETTY_FUNCTION__);
  <D.12802>:
}


emit_ptr (struct LogBuffer * logbuffer, void * ptr)
{
  long unsigned int D.12803;
  long unsigned int ptr.46;
  long unsigned int D.12807;
  long int D.12808;
  unsigned char * D.12809;
  unsigned char * D.12810;
  static const char __PRETTY_FUNCTION__[9] = "emit_ptr";

  D.12803 = logbuffer->ptr_base;
  if (D.12803 == 0) goto <D.12804>; else goto <D.12805>;
  <D.12804>:
  ptr.46 = (long unsigned int) ptr;
  logbuffer->ptr_base = ptr.46;
  <D.12805>:
  ptr.46 = (long unsigned int) ptr;
  D.12803 = logbuffer->ptr_base;
  D.12807 = ptr.46 - D.12803;
  D.12808 = (long int) D.12807;
  emit_svalue (logbuffer, D.12808);
  D.12809 = logbuffer->data;
  D.12810 = logbuffer->data_end;
  if (D.12809 > D.12810) goto <D.12811>; else goto <D.12812>;
  <D.12811>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 490, &__PRETTY_FUNCTION__);
  <D.12812>:
}


process_requests (struct MonoProfiler * profiler)
{
  int heapshot_requested.47;
  int D.12816;

  heapshot_requested.47 = heapshot_requested;
  if (heapshot_requested.47 != 0) goto <D.12814>; else goto <D.12815>;
  <D.12814>:
  D.12816 = mono_gc_max_generation ();
  mono_gc_collect (D.12816);
  <D.12815>:
}


clause_exc (struct MonoProfiler * prof, struct MonoMethod * method, int clause_type, int clause_num)
{
  int D.12818;
  int D.12821;
  int D.12822;
  uint64_t now;
  struct LogBuffer * logbuffer;

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


emit_method (struct LogBuffer * logbuffer, void * method)
{
  long unsigned int D.12826;
  long unsigned int method.48;
  unsigned char * * D.12830;
  unsigned char * D.12831;
  long int method.49;
  long unsigned int D.12833;
  long int D.12834;
  long int D.12835;
  unsigned char * D.12836;
  static const char __PRETTY_FUNCTION__[12] = "emit_method";

  D.12826 = logbuffer->method_base;
  if (D.12826 == 0) goto <D.12827>; else goto <D.12828>;
  <D.12827>:
  method.48 = (long unsigned int) method;
  logbuffer->method_base = method.48;
  method.48 = (long unsigned int) method;
  logbuffer->last_method = method.48;
  <D.12828>:
  D.12830 = &logbuffer->data;
  D.12831 = logbuffer->data;
  method.49 = (long int) method;
  D.12833 = logbuffer->last_method;
  D.12834 = (long int) D.12833;
  D.12835 = method.49 - D.12834;
  encode_sleb128 (D.12835, D.12831, D.12830);
  method.48 = (long unsigned int) method;
  logbuffer->last_method = method.48;
  D.12831 = logbuffer->data;
  D.12836 = logbuffer->data_end;
  if (D.12831 > D.12836) goto <D.12837>; else goto <D.12838>;
  <D.12837>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 502, &__PRETTY_FUNCTION__);
  <D.12838>:
}


method_exc_leave (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int nocalls.50;
  int D.12842;
  int D.12843;
  int max_call_depth.51;
  int D.12847;
  int D.12850;
  int D.12851;
  uint64_t now;
  struct LogBuffer * logbuffer;

  nocalls.50 = nocalls;
  if (nocalls.50 != 0) goto <D.12840>; else goto <D.12841>;
  <D.12840>:
  return;
  <D.12841>:
  logbuffer = ensure_logbuf (16);
  D.12842 = logbuffer->call_depth;
  D.12843 = D.12842 + -1;
  logbuffer->call_depth = D.12843;
  D.12842 = logbuffer->call_depth;
  max_call_depth.51 = max_call_depth;
  if (D.12842 > max_call_depth.51) goto <D.12845>; else goto <D.12846>;
  <D.12845>:
  return;
  <D.12846>:
  now = current_time ();
  D.12847 = logbuffer->locked;
  if (D.12847 != 0) goto <D.12848>; else goto <D.12849>;
  <D.12848>:
  write (2, "eleave", 6);
  write (2, "\n", 1);
  return;
  <D.12849>:
  D.12847 = logbuffer->locked;
  D.12850 = D.12847 + 1;
  logbuffer->locked = D.12850;
  emit_byte (logbuffer, 51);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12847 = logbuffer->locked;
  D.12851 = D.12847 + -1;
  logbuffer->locked = D.12851;
  process_requests (prof);
}


throw_exc (struct MonoProfiler * prof, struct MonoObject * object)
{
  int iftmp.52;
  int nocalls.53;
  int runtime_inited.54;
  int notraces.55;
  int D.12866;
  int D.12869;
  int D.12870;
  int D.12873;
  int do_bt;
  uint64_t now;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.53 = nocalls;
      if (nocalls.53 != 0) goto <D.12859>; else goto <D.12856>;
      <D.12859>:
      runtime_inited.54 = runtime_inited;
      if (runtime_inited.54 != 0) goto <D.12861>; else goto <D.12856>;
      <D.12861>:
      notraces.55 = notraces;
      if (notraces.55 == 0) goto <D.12863>; else goto <D.12856>;
      <D.12863>:
      iftmp.52 = 128;
      goto <D.12857>;
      <D.12856>:
      iftmp.52 = 0;
      <D.12857>:
      do_bt = iftmp.52;
      if (do_bt != 0) goto <D.12864>; else goto <D.12865>;
      <D.12864>:
      collect_bt (&data);
      <D.12865>:
      logbuffer = ensure_logbuf (144);
      now = current_time ();
      D.12866 = logbuffer->locked;
      if (D.12866 != 0) goto <D.12867>; else goto <D.12868>;
      <D.12867>:
      write (2, "throw", 5);
      write (2, "\n", 1);
      return;
      <D.12868>:
      D.12866 = logbuffer->locked;
      D.12869 = D.12866 + 1;
      logbuffer->locked = D.12869;
      D.12870 = do_bt | 4;
      emit_byte (logbuffer, D.12870);
      emit_time (logbuffer, now);
      emit_obj (logbuffer, object);
      if (do_bt != 0) goto <D.12871>; else goto <D.12872>;
      <D.12871>:
      emit_bt (logbuffer, &data);
      <D.12872>:
      D.12866 = logbuffer->locked;
      D.12873 = D.12866 + -1;
      logbuffer->locked = D.12873;
      process_requests (prof);
    }
  finally
    {
      data = {CLOBBER};
    }
}


method_jitted (struct MonoProfiler * prof, struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  long unsigned int D.12882;
  unsigned int D.12883;
  unsigned int D.12884;
  int D.12885;
  int D.12886;
  int D.12889;
  void * D.12890;
  int D.12891;
  long unsigned int D.12892;
  unsigned char * D.12893;
  sizetype D.12894;
  unsigned char * D.12895;
  int D.12896;
  struct LogBuffer * D.12897;
  uint64_t now;
  char * name;
  int nlen;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.12880>; else goto <D.12881>;
  <D.12880>:
  return;
  <D.12881>:
  name = mono_method_full_name (method, 1);
  D.12882 = strlen (name);
  D.12883 = (unsigned int) D.12882;
  D.12884 = D.12883 + 1;
  nlen = (int) D.12884;
  D.12885 = nlen + 32;
  logbuffer = ensure_logbuf (D.12885);
  now = current_time ();
  D.12886 = logbuffer->locked;
  if (D.12886 != 0) goto <D.12887>; else goto <D.12888>;
  <D.12887>:
  write (2, "jit", 3);
  write (2, "\n", 1);
  return;
  <D.12888>:
  D.12886 = logbuffer->locked;
  D.12889 = D.12886 + 1;
  logbuffer->locked = D.12889;
  emit_byte (logbuffer, 67);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12890 = mono_jit_info_get_code_start (jinfo);
  emit_ptr (logbuffer, D.12890);
  D.12891 = mono_jit_info_get_code_size (jinfo);
  emit_value (logbuffer, D.12891);
  D.12892 = (long unsigned int) nlen;
  D.12893 = logbuffer->data;
  memcpy (D.12893, name, D.12892);
  D.12893 = logbuffer->data;
  D.12894 = (sizetype) nlen;
  D.12895 = D.12893 + D.12894;
  logbuffer->data = D.12895;
  mono_free (name);
  D.12886 = logbuffer->locked;
  D.12896 = D.12886 + -1;
  logbuffer->locked = D.12896;
  D.12897 = logbuffer->next;
  if (D.12897 != 0B) goto <D.12898>; else goto <D.12899>;
  <D.12898>:
  safe_dump (prof, logbuffer);
  <D.12899>:
  process_requests (prof);
}


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

  D.12907 = __builtin_object_size (__dest, 0);
  D.12906 = __builtin___memcpy_chk (__dest, __src, __len, D.12907);
  return D.12906;
}


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

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


dump_buffer (struct MonoProfiler * profiler, struct LogBuffer * buf)
{
  struct LogBuffer * D.12910;
  unsigned char * D.12913;
  long int D.12914;
  unsigned char[1] * D.12915;
  long int D.12916;
  long int D.12917;
  int D.12918;
  long unsigned int D.12919;
  long int D.12920;
  long unsigned int D.12921;
  long int D.12922;
  long unsigned int D.12923;
  long int D.12924;
  long unsigned int D.12925;
  long int D.12926;
  long unsigned int D.12927;
  long int D.12928;
  struct gzFile_s * * D.12929;
  long int p.57;
  long int hbuf.58;
  long int D.12934;
  unsigned int D.12935;
  unsigned int D.12936;
  struct FILE * D.12938;
  long unsigned int D.12939;
  long unsigned int D.12940;
  int D.12941;
  char hbuf[128];
  char * p;

  try
    {
      p = &hbuf;
      D.12910 = buf->next;
      if (D.12910 != 0B) goto <D.12911>; else goto <D.12912>;
      <D.12911>:
      D.12910 = buf->next;
      dump_buffer (profiler, D.12910);
      <D.12912>:
      p = write_int32 (p, 1297107969);
      D.12913 = buf->data;
      D.12914 = (long int) D.12913;
      D.12915 = &buf->buf;
      D.12916 = (long int) D.12915;
      D.12917 = D.12914 - D.12916;
      D.12918 = (int) D.12917;
      p = write_int32 (p, D.12918);
      D.12919 = buf->time_base;
      D.12920 = (long int) D.12919;
      p = write_int64 (p, D.12920);
      D.12921 = buf->ptr_base;
      D.12922 = (long int) D.12921;
      p = write_int64 (p, D.12922);
      D.12923 = buf->obj_base;
      D.12924 = (long int) D.12923;
      p = write_int64 (p, D.12924);
      D.12925 = buf->thread_id;
      D.12926 = (long int) D.12925;
      p = write_int64 (p, D.12926);
      D.12927 = buf->method_base;
      D.12928 = (long int) D.12927;
      p = write_int64 (p, D.12928);
      D.12929 = profiler->gzfile;
      if (D.12929 != 0B) goto <D.12930>; else goto <D.12931>;
      <D.12930>:
      p.57 = (long int) p;
      hbuf.58 = (long int) &hbuf;
      D.12934 = p.57 - hbuf.58;
      D.12935 = (unsigned int) D.12934;
      D.12929 = profiler->gzfile;
      gzwrite (D.12929, &hbuf, D.12935);
      D.12913 = buf->data;
      D.12914 = (long int) D.12913;
      D.12915 = &buf->buf;
      D.12916 = (long int) D.12915;
      D.12917 = D.12914 - D.12916;
      D.12936 = (unsigned int) D.12917;
      D.12915 = &buf->buf;
      D.12929 = profiler->gzfile;
      gzwrite (D.12929, D.12915, D.12936);
      goto <D.12937>;
      <D.12931>:
      D.12938 = profiler->file;
      p.57 = (long int) p;
      hbuf.58 = (long int) &hbuf;
      D.12934 = p.57 - hbuf.58;
      D.12939 = (long unsigned int) D.12934;
      fwrite (&hbuf, D.12939, 1, D.12938);
      D.12938 = profiler->file;
      D.12913 = buf->data;
      D.12914 = (long int) D.12913;
      D.12915 = &buf->buf;
      D.12916 = (long int) D.12915;
      D.12917 = D.12914 - D.12916;
      D.12940 = (long unsigned int) D.12917;
      D.12915 = &buf->buf;
      fwrite (D.12915, D.12940, 1, D.12938);
      D.12938 = profiler->file;
      fflush (D.12938);
      <D.12937>:
      D.12941 = buf->size;
      free_buffer (buf, D.12941);
    }
  finally
    {
      hbuf = {CLOBBER};
    }
}


write_int32 (char * buf, int32_t value)
{
  sizetype D.12951;
  char * D.12952;
  char D.12953;
  char * D.12954;
  int i;

  i = 0;
  goto <D.11539>;
  <D.11538>:
  D.12951 = (sizetype) i;
  D.12952 = buf + D.12951;
  D.12953 = (char) value;
  *D.12952 = D.12953;
  value = value >> 8;
  i = i + 1;
  <D.11539>:
  if (i <= 3) goto <D.11538>; else goto <D.11540>;
  <D.11540>:
  D.12954 = buf + 4;
  return D.12954;
}


write_int64 (char * buf, int64_t value)
{
  sizetype D.12956;
  char * D.12957;
  char D.12958;
  char * D.12959;
  int i;

  i = 0;
  goto <D.11547>;
  <D.11546>:
  D.12956 = (sizetype) i;
  D.12957 = buf + D.12956;
  D.12958 = (char) value;
  *D.12957 = D.12958;
  value = value >> 8;
  i = i + 1;
  <D.11547>:
  if (i <= 7) goto <D.11546>; else goto <D.11548>;
  <D.11548>:
  D.12959 = buf + 8;
  return D.12959;
}


method_leave (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int D.12961;
  int D.12962;
  int max_call_depth.59;
  int D.12966;
  int D.12969;
  int D.12970;
  struct LogBuffer * D.12971;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  D.12961 = logbuffer->call_depth;
  D.12962 = D.12961 + -1;
  logbuffer->call_depth = D.12962;
  D.12961 = logbuffer->call_depth;
  max_call_depth.59 = max_call_depth;
  if (D.12961 > max_call_depth.59) goto <D.12964>; else goto <D.12965>;
  <D.12964>:
  return;
  <D.12965>:
  now = current_time ();
  D.12966 = logbuffer->locked;
  if (D.12966 != 0) goto <D.12967>; else goto <D.12968>;
  <D.12967>:
  write (2, "leave", 5);
  write (2, "\n", 1);
  return;
  <D.12968>:
  D.12966 = logbuffer->locked;
  D.12969 = D.12966 + 1;
  logbuffer->locked = D.12969;
  emit_byte (logbuffer, 19);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12966 = logbuffer->locked;
  D.12970 = D.12966 + -1;
  logbuffer->locked = D.12970;
  D.12971 = logbuffer->next;
  if (D.12971 != 0B) goto <D.12972>; else goto <D.12973>;
  <D.12972>:
  safe_dump (prof, logbuffer);
  <D.12973>:
  process_requests (prof);
}


method_enter (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int D.12977;
  int D.12978;
  int D.12979;
  int max_call_depth.60;
  int D.12983;
  int D.12986;
  int D.12987;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  D.12977 = logbuffer->call_depth;
  D.12978 = D.12977;
  D.12979 = D.12978 + 1;
  logbuffer->call_depth = D.12979;
  max_call_depth.60 = max_call_depth;
  if (D.12978 > max_call_depth.60) goto <D.12981>; else goto <D.12982>;
  <D.12981>:
  return;
  <D.12982>:
  now = current_time ();
  D.12983 = logbuffer->locked;
  if (D.12983 != 0) goto <D.12984>; else goto <D.12985>;
  <D.12984>:
  write (2, "enter", 5);
  write (2, "\n", 1);
  return;
  <D.12985>:
  D.12983 = logbuffer->locked;
  D.12986 = D.12983 + 1;
  logbuffer->locked = D.12986;
  emit_byte (logbuffer, 35);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12983 = logbuffer->locked;
  D.12987 = D.12983 + -1;
  logbuffer->locked = D.12987;
  process_requests (prof);
}


thread_name (struct MonoProfiler * prof, uintptr_t tid, const char * name)
{
  long unsigned int D.12991;
  unsigned int D.12992;
  unsigned int D.12993;
  int D.12994;
  int D.12995;
  int D.12998;
  void * tid.61;
  long unsigned int D.13000;
  unsigned char * D.13001;
  sizetype D.13002;
  unsigned char * D.13003;
  int D.13004;
  int len;
  uint64_t now;
  struct LogBuffer * logbuffer;

  D.12991 = strlen (name);
  D.12992 = (unsigned int) D.12991;
  D.12993 = D.12992 + 1;
  len = (int) D.12993;
  D.12994 = len + 10;
  logbuffer = ensure_logbuf (D.12994);
  now = current_time ();
  D.12995 = logbuffer->locked;
  if (D.12995 != 0) goto <D.12996>; else goto <D.12997>;
  <D.12996>:
  write (2, "tname", 5);
  write (2, "\n", 1);
  return;
  <D.12997>:
  D.12995 = logbuffer->locked;
  D.12998 = D.12995 + 1;
  logbuffer->locked = D.12998;
  emit_byte (logbuffer, 2);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 5);
  tid.61 = (void *) tid;
  emit_ptr (logbuffer, tid.61);
  emit_value (logbuffer, 0);
  D.13000 = (long unsigned int) len;
  D.13001 = logbuffer->data;
  memcpy (D.13001, name, D.13000);
  D.13001 = logbuffer->data;
  D.13002 = (sizetype) len;
  D.13003 = D.13001 + D.13002;
  logbuffer->data = D.13003;
  D.12995 = logbuffer->locked;
  D.13004 = D.12995 + -1;
  logbuffer->locked = D.13004;
}


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

  take_lock ();
  tlsbuffer.62 = tlsbuffer;
  if (tlsbuffer.62 != 0B) goto <D.13009>; else goto <D.13010>;
  <D.13009>:
  tlsbuffer.62 = tlsbuffer;
  dump_buffer (prof, tlsbuffer.62);
  <D.13010>:
  release_lock ();
  tlsbuffer = 0B;
}


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


image_loaded (struct MonoProfiler * prof, struct MonoImage * image, int result)
{
  long unsigned int D.13013;
  unsigned int D.13014;
  unsigned int D.13015;
  int D.13016;
  int D.13017;
  int D.13020;
  long unsigned int D.13021;
  unsigned char * D.13022;
  sizetype D.13023;
  unsigned char * D.13024;
  int D.13025;
  struct LogBuffer * D.13026;
  uint64_t now;
  const char * name;
  int nlen;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.13011>; else goto <D.13012>;
  <D.13011>:
  return;
  <D.13012>:
  name = mono_image_get_filename (image);
  D.13013 = strlen (name);
  D.13014 = (unsigned int) D.13013;
  D.13015 = D.13014 + 1;
  nlen = (int) D.13015;
  D.13016 = nlen + 16;
  logbuffer = ensure_logbuf (D.13016);
  now = current_time ();
  D.13017 = logbuffer->locked;
  if (D.13017 != 0) goto <D.13018>; else goto <D.13019>;
  <D.13018>:
  write (2, "image", 5);
  write (2, "\n", 1);
  return;
  <D.13019>:
  D.13017 = logbuffer->locked;
  D.13020 = D.13017 + 1;
  logbuffer->locked = D.13020;
  emit_byte (logbuffer, 34);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 2);
  emit_ptr (logbuffer, image);
  emit_value (logbuffer, 0);
  D.13021 = (long unsigned int) nlen;
  D.13022 = logbuffer->data;
  memcpy (D.13022, name, D.13021);
  D.13022 = logbuffer->data;
  D.13023 = (sizetype) nlen;
  D.13024 = D.13022 + D.13023;
  logbuffer->data = D.13024;
  D.13017 = logbuffer->locked;
  D.13025 = D.13017 + -1;
  logbuffer->locked = D.13025;
  D.13026 = logbuffer->next;
  if (D.13026 != 0B) goto <D.13027>; else goto <D.13028>;
  <D.13027>:
  safe_dump (prof, logbuffer);
  <D.13028>:
  process_requests (prof);
}


class_loaded (struct MonoProfiler * prof, struct MonoClass * klass, int result)
{
  int runtime_inited.63;
  struct MonoType * D.13038;
  long unsigned int D.13040;
  unsigned int D.13041;
  unsigned int D.13042;
  int D.13043;
  int D.13044;
  int D.13047;
  long unsigned int D.13048;
  unsigned char * D.13049;
  sizetype D.13050;
  unsigned char * D.13051;
  int D.13055;
  struct LogBuffer * D.13056;
  uint64_t now;
  char * name;
  int nlen;
  struct MonoImage * image;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.13033>; else goto <D.13034>;
  <D.13033>:
  return;
  <D.13034>:
  runtime_inited.63 = runtime_inited;
  if (runtime_inited.63 != 0) goto <D.13036>; else goto <D.13037>;
  <D.13036>:
  D.13038 = mono_class_get_type (klass);
  name = mono_type_get_name (D.13038);
  goto <D.13039>;
  <D.13037>:
  name = type_name (klass);
  <D.13039>:
  D.13040 = strlen (name);
  D.13041 = (unsigned int) D.13040;
  D.13042 = D.13041 + 1;
  nlen = (int) D.13042;
  image = mono_class_get_image (klass);
  D.13043 = nlen + 24;
  logbuffer = ensure_logbuf (D.13043);
  now = current_time ();
  D.13044 = logbuffer->locked;
  if (D.13044 != 0) goto <D.13045>; else goto <D.13046>;
  <D.13045>:
  write (2, "class", 5);
  write (2, "\n", 1);
  return;
  <D.13046>:
  D.13044 = logbuffer->locked;
  D.13047 = D.13044 + 1;
  logbuffer->locked = D.13047;
  emit_byte (logbuffer, 34);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 1);
  emit_ptr (logbuffer, klass);
  emit_ptr (logbuffer, image);
  emit_value (logbuffer, 0);
  D.13048 = (long unsigned int) nlen;
  D.13049 = logbuffer->data;
  memcpy (D.13049, name, D.13048);
  D.13049 = logbuffer->data;
  D.13050 = (sizetype) nlen;
  D.13051 = D.13049 + D.13050;
  logbuffer->data = D.13051;
  runtime_inited.63 = runtime_inited;
  if (runtime_inited.63 != 0) goto <D.13052>; else goto <D.13053>;
  <D.13052>:
  mono_free (name);
  goto <D.13054>;
  <D.13053>:
  free (name);
  <D.13054>:
  D.13044 = logbuffer->locked;
  D.13055 = D.13044 + -1;
  logbuffer->locked = D.13055;
  D.13056 = logbuffer->next;
  if (D.13056 != 0B) goto <D.13057>; else goto <D.13058>;
  <D.13057>:
  safe_dump (prof, logbuffer);
  <D.13058>:
  process_requests (prof);
}


type_name (struct MonoClass * klass)
{
  long unsigned int D.13066;
  long unsigned int D.13067;
  char * D.13068;
  char buf[1024];
  char * p;

  try
    {
      push_nesting (&buf, klass);
      D.13066 = strlen (&buf);
      D.13067 = D.13066 + 1;
      p = malloc (D.13067);
      strcpy (p, &buf);
      D.13068 = p;
      return D.13068;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


push_nesting (char * p, struct MonoClass * klass)
{
  char * p.64;
  char D.13075;
  long unsigned int D.13078;
  char * p.65;
  long unsigned int D.13080;
  char * D.13081;
  struct MonoClass * nesting;
  const char * name;
  const char * nspace;

  nesting = mono_class_get_nesting_type (klass);
  if (nesting != 0B) goto <D.13072>; else goto <D.13073>;
  <D.13072>:
  p = push_nesting (p, nesting);
  p.64 = p;
  p = p.64 + 1;
  *p.64 = 47;
  *p = 0;
  <D.13073>:
  name = mono_class_get_name (klass);
  nspace = mono_class_get_namespace (klass);
  D.13075 = *nspace;
  if (D.13075 != 0) goto <D.13076>; else goto <D.13077>;
  <D.13076>:
  strcpy (p, nspace);
  D.13078 = strlen (nspace);
  p = p + D.13078;
  p.65 = p;
  p = p.65 + 1;
  *p.65 = 46;
  *p = 0;
  <D.13077>:
  strcpy (p, name);
  D.13080 = strlen (name);
  p = p + D.13080;
  D.13081 = p;
  return D.13081;
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.13087;
  long unsigned int D.13088;

  D.13088 = __builtin_object_size (__dest, 1);
  D.13087 = __builtin___strcpy_chk (__dest, __src, D.13088);
  return D.13087;
}


gc_roots (struct MonoProfiler * prof, int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  int D.13090;
  int D.13091;
  int D.13092;
  int D.13095;
  int D.13096;
  int D.13097;
  long unsigned int D.13098;
  long unsigned int D.13099;
  void * * D.13100;
  void * D.13101;
  long unsigned int D.13102;
  int * D.13103;
  int D.13104;
  uintptr_t * D.13105;
  long unsigned int D.13106;
  int D.13107;
  int D.13108;
  int i;
  struct LogBuffer * logbuffer;

  D.13090 = num * 18;
  D.13091 = D.13090 + 5;
  logbuffer = ensure_logbuf (D.13091);
  D.13092 = logbuffer->locked;
  if (D.13092 != 0) goto <D.13093>; else goto <D.13094>;
  <D.13093>:
  write (2, "gcroots", 7);
  write (2, "\n", 1);
  return;
  <D.13094>:
  D.13092 = logbuffer->locked;
  D.13095 = D.13092 + 1;
  logbuffer->locked = D.13095;
  emit_byte (logbuffer, 54);
  emit_value (logbuffer, num);
  D.13096 = mono_gc_max_generation ();
  D.13097 = mono_gc_collection_count (D.13096);
  emit_value (logbuffer, D.13097);
  i = 0;
  goto <D.11664>;
  <D.11663>:
  D.13098 = (long unsigned int) i;
  D.13099 = D.13098 * 8;
  D.13100 = objects + D.13099;
  D.13101 = *D.13100;
  emit_obj (logbuffer, D.13101);
  D.13098 = (long unsigned int) i;
  D.13102 = D.13098 * 4;
  D.13103 = root_types + D.13102;
  D.13104 = *D.13103;
  emit_value (logbuffer, D.13104);
  D.13098 = (long unsigned int) i;
  D.13099 = D.13098 * 8;
  D.13105 = extra_info + D.13099;
  D.13106 = *D.13105;
  D.13107 = (int) D.13106;
  emit_value (logbuffer, D.13107);
  i = i + 1;
  <D.11664>:
  if (i < num) goto <D.11663>; else goto <D.11665>;
  <D.11665>:
  D.13092 = logbuffer->locked;
  D.13108 = D.13092 + -1;
  logbuffer->locked = D.13108;
}


gc_handle (struct MonoProfiler * prof, int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  int D.13113;
  int D.13116;
  int D.13123;
  int D.13126;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  now = current_time ();
  D.13113 = logbuffer->locked;
  if (D.13113 != 0) goto <D.13114>; else goto <D.13115>;
  <D.13114>:
  write (2, "gchandle", 8);
  write (2, "\n", 1);
  return;
  <D.13115>:
  D.13113 = logbuffer->locked;
  D.13116 = D.13113 + 1;
  logbuffer->locked = D.13116;
  if (op == 0) goto <D.13117>; else goto <D.13118>;
  <D.13117>:
  emit_byte (logbuffer, 65);
  goto <D.13119>;
  <D.13118>:
  if (op == 1) goto <D.13120>; else goto <D.13121>;
  <D.13120>:
  emit_byte (logbuffer, 81);
  goto <D.13122>;
  <D.13121>:
  return;
  <D.13122>:
  <D.13119>:
  emit_time (logbuffer, now);
  emit_value (logbuffer, type);
  D.13123 = (int) handle;
  emit_value (logbuffer, D.13123);
  if (op == 0) goto <D.13124>; else goto <D.13125>;
  <D.13124>:
  emit_obj (logbuffer, obj);
  <D.13125>:
  D.13113 = logbuffer->locked;
  D.13126 = D.13113 + -1;
  logbuffer->locked = D.13126;
  process_requests (prof);
}


gc_moves (struct MonoProfiler * prof, void * * objects, int num)
{
  int D.13130;
  int D.13131;
  int D.13132;
  int D.13135;
  long unsigned int D.13136;
  long unsigned int D.13137;
  void * * D.13138;
  void * D.13139;
  int D.13140;
  int i;
  uint64_t now;
  struct LogBuffer * logbuffer;

  D.13130 = num * 8;
  D.13131 = D.13130 + 10;
  logbuffer = ensure_logbuf (D.13131);
  now = current_time ();
  D.13132 = logbuffer->locked;
  if (D.13132 != 0) goto <D.13133>; else goto <D.13134>;
  <D.13133>:
  write (2, "gcmove", 6);
  write (2, "\n", 1);
  return;
  <D.13134>:
  D.13132 = logbuffer->locked;
  D.13135 = D.13132 + 1;
  logbuffer->locked = D.13135;
  emit_byte (logbuffer, 49);
  emit_time (logbuffer, now);
  emit_value (logbuffer, num);
  i = 0;
  goto <D.11652>;
  <D.11651>:
  D.13136 = (long unsigned int) i;
  D.13137 = D.13136 * 8;
  D.13138 = objects + D.13137;
  D.13139 = *D.13138;
  emit_obj (logbuffer, D.13139);
  i = i + 1;
  <D.11652>:
  if (i < num) goto <D.11651>; else goto <D.11653>;
  <D.11653>:
  D.13132 = logbuffer->locked;
  D.13140 = D.13132 + -1;
  logbuffer->locked = D.13140;
}


gc_alloc (struct MonoProfiler * prof, struct MonoObject * obj, struct MonoClass * klass)
{
  int iftmp.66;
  int nocalls.67;
  int runtime_inited.68;
  int notraces.69;
  unsigned int D.13153;
  int D.13156;
  int D.13159;
  int D.13160;
  int D.13163;
  struct LogBuffer * D.13164;
  uint64_t now;
  uintptr_t len;
  int do_bt;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.67 = nocalls;
      if (nocalls.67 != 0) goto <D.13148>; else goto <D.13145>;
      <D.13148>:
      runtime_inited.68 = runtime_inited;
      if (runtime_inited.68 != 0) goto <D.13150>; else goto <D.13145>;
      <D.13150>:
      notraces.69 = notraces;
      if (notraces.69 == 0) goto <D.13152>; else goto <D.13145>;
      <D.13152>:
      iftmp.66 = 16;
      goto <D.13146>;
      <D.13145>:
      iftmp.66 = 0;
      <D.13146>:
      do_bt = iftmp.66;
      D.13153 = mono_object_get_size (obj);
      len = (uintptr_t) D.13153;
      len = len + 7;
      len = len & 18446744073709551608;
      if (do_bt != 0) goto <D.13154>; else goto <D.13155>;
      <D.13154>:
      collect_bt (&data);
      <D.13155>:
      logbuffer = ensure_logbuf (160);
      now = current_time ();
      D.13156 = logbuffer->locked;
      if (D.13156 != 0) goto <D.13157>; else goto <D.13158>;
      <D.13157>:
      write (2, "gcalloc", 7);
      write (2, "\n", 1);
      return;
      <D.13158>:
      D.13156 = logbuffer->locked;
      D.13159 = D.13156 + 1;
      logbuffer->locked = D.13159;
      emit_byte (logbuffer, do_bt);
      emit_time (logbuffer, now);
      emit_ptr (logbuffer, klass);
      emit_obj (logbuffer, obj);
      D.13160 = (int) len;
      emit_value (logbuffer, D.13160);
      if (do_bt != 0) goto <D.13161>; else goto <D.13162>;
      <D.13161>:
      emit_bt (logbuffer, &data);
      <D.13162>:
      D.13156 = logbuffer->locked;
      D.13163 = D.13156 + -1;
      logbuffer->locked = D.13163;
      D.13164 = logbuffer->next;
      if (D.13164 != 0B) goto <D.13165>; else goto <D.13166>;
      <D.13165>:
      safe_dump (prof, logbuffer);
      <D.13166>:
      process_requests (prof);
    }
  finally
    {
      data = {CLOBBER};
    }
}


gc_resize (struct MonoProfiler * profiler, int64_t new_size)
{
  int D.13174;
  int D.13177;
  int D.13178;
  int D.13179;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (10);
  now = current_time ();
  D.13174 = logbuffer->locked;
  if (D.13174 != 0) goto <D.13175>; else goto <D.13176>;
  <D.13175>:
  write (2, "gcresize", 8);
  write (2, "\n", 1);
  return;
  <D.13176>:
  D.13174 = logbuffer->locked;
  D.13177 = D.13174 + 1;
  logbuffer->locked = D.13177;
  emit_byte (logbuffer, 33);
  emit_time (logbuffer, now);
  D.13178 = (int) new_size;
  emit_value (logbuffer, D.13178);
  D.13174 = logbuffer->locked;
  D.13179 = D.13174 + -1;
  logbuffer->locked = D.13179;
}


gc_event (struct MonoProfiler * profiler, MonoGCEvent ev, int generation)
{
  int D.13183;
  int D.13186;
  int ev.70;
  int D.13190;
  unsigned int gc_count.71;
  unsigned int gc_count.72;
  int D.13197;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (10);
  now = current_time ();
  D.13183 = logbuffer->locked;
  if (D.13183 != 0) goto <D.13184>; else goto <D.13185>;
  <D.13184>:
  write (2, "gcevent", 7);
  write (2, "\n", 1);
  return;
  <D.13185>:
  D.13183 = logbuffer->locked;
  D.13186 = D.13183 + 1;
  logbuffer->locked = D.13186;
  emit_byte (logbuffer, 17);
  emit_time (logbuffer, now);
  ev.70 = (int) ev;
  emit_value (logbuffer, ev.70);
  emit_value (logbuffer, generation);
  if (ev == 0) goto <D.13188>; else goto <D.13189>;
  <D.13188>:
  profiler->last_gc_gen_started = generation;
  D.13190 = mono_gc_max_generation ();
  if (D.13190 == generation) goto <D.13191>; else goto <D.13192>;
  <D.13191>:
  gc_count.71 = gc_count;
  gc_count.72 = gc_count.71 + 1;
  gc_count = gc_count.72;
  <D.13192>:
  <D.13189>:
  if (ev == 8) goto <D.13195>; else goto <D.13196>;
  <D.13195>:
  heap_walk (profiler);
  <D.13196>:
  D.13183 = logbuffer->locked;
  D.13197 = D.13183 + -1;
  logbuffer->locked = D.13197;
  if (ev == 9) goto <D.13198>; else goto <D.13199>;
  <D.13198>:
  safe_dump (profiler, logbuffer);
  <D.13199>:
}


heap_walk (struct MonoProfiler * profiler)
{
  int do_heap_shot.73;
  unsigned int hs_mode_ms.74;
  long unsigned int last_hs_time.75;
  long unsigned int D.13212;
  long unsigned int D.13213;
  long unsigned int D.13214;
  unsigned int hs_mode_gc.76;
  unsigned int gc_count.77;
  unsigned int D.13221;
  unsigned int hs_mode_ondemand.78;
  int D.13231;
  int D.13232;
  int do_walk;
  uint64_t now;
  struct LogBuffer * logbuffer;

  do_walk = 0;
  do_heap_shot.73 = do_heap_shot;
  if (do_heap_shot.73 == 0) goto <D.13205>; else goto <D.13206>;
  <D.13205>:
  return;
  <D.13206>:
  logbuffer = ensure_logbuf (10);
  now = current_time ();
  hs_mode_ms.74 = hs_mode_ms;
  if (hs_mode_ms.74 != 0) goto <D.13210>; else goto <D.13207>;
  <D.13210>:
  last_hs_time.75 = last_hs_time;
  D.13212 = now - last_hs_time.75;
  D.13213 = D.13212 / 1000000;
  hs_mode_ms.74 = hs_mode_ms;
  D.13214 = (long unsigned int) hs_mode_ms.74;
  if (D.13213 >= D.13214) goto <D.13215>; else goto <D.13207>;
  <D.13215>:
  do_walk = 1;
  goto <D.13208>;
  <D.13207>:
  hs_mode_gc.76 = hs_mode_gc;
  if (hs_mode_gc.76 != 0) goto <D.13219>; else goto <D.13216>;
  <D.13219>:
  gc_count.77 = gc_count;
  hs_mode_gc.76 = hs_mode_gc;
  D.13221 = gc_count.77 % hs_mode_gc.76;
  if (D.13221 == 0) goto <D.13222>; else goto <D.13216>;
  <D.13222>:
  do_walk = 1;
  goto <D.13217>;
  <D.13216>:
  hs_mode_ondemand.78 = hs_mode_ondemand;
  if (hs_mode_ondemand.78 != 0) goto <D.13224>; else goto <D.13225>;
  <D.13224>:
  do_walk = heapshot_requested;
  goto <D.13226>;
  <D.13225>:
  hs_mode_ms.74 = hs_mode_ms;
  if (hs_mode_ms.74 == 0) goto <D.13227>; else goto <D.13228>;
  <D.13227>:
  hs_mode_gc.76 = hs_mode_gc;
  if (hs_mode_gc.76 == 0) goto <D.13229>; else goto <D.13230>;
  <D.13229>:
  D.13231 = profiler->last_gc_gen_started;
  D.13232 = mono_gc_max_generation ();
  if (D.13231 == D.13232) goto <D.13233>; else goto <D.13234>;
  <D.13233>:
  do_walk = 1;
  <D.13234>:
  <D.13230>:
  <D.13228>:
  <D.13226>:
  <D.13217>:
  <D.13208>:
  if (do_walk == 0) goto <D.13235>; else goto <D.13236>;
  <D.13235>:
  return;
  <D.13236>:
  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.13243;
  unsigned int D.13244;
  unsigned int D.13245;
  int D.13246;
  int D.13247;
  int D.13248;
  long unsigned int D.13249;
  long unsigned int D.13250;
  uintptr_t * D.13251;
  long unsigned int D.13252;
  unsigned int D.13253;
  unsigned int D.13254;
  unsigned int D.13255;
  int D.13256;
  struct MonoObject * * D.13257;
  struct MonoObject * D.13258;
  long unsigned int D.13259;
  int D.13260;
  int i;
  uintptr_t last_offset;
  struct LogBuffer * logbuffer;

  last_offset = 0;
  D.13243 = (unsigned int) num;
  D.13244 = D.13243 * 8;
  D.13245 = D.13244 + 20;
  D.13246 = (int) D.13245;
  logbuffer = ensure_logbuf (D.13246);
  emit_byte (logbuffer, 38);
  emit_obj (logbuffer, obj);
  emit_ptr (logbuffer, klass);
  size = size + 7;
  size = size & 18446744073709551608;
  D.13247 = (int) size;
  emit_value (logbuffer, D.13247);
  D.13248 = (int) num;
  emit_value (logbuffer, D.13248);
  i = 0;
  goto <D.11584>;
  <D.11583>:
  D.13249 = (long unsigned int) i;
  D.13250 = D.13249 * 8;
  D.13251 = offsets + D.13250;
  D.13252 = *D.13251;
  D.13253 = (unsigned int) D.13252;
  D.13254 = (unsigned int) last_offset;
  D.13255 = D.13253 - D.13254;
  D.13256 = (int) D.13255;
  emit_value (logbuffer, D.13256);
  D.13249 = (long unsigned int) i;
  D.13250 = D.13249 * 8;
  D.13251 = offsets + D.13250;
  last_offset = *D.13251;
  D.13249 = (long unsigned int) i;
  D.13250 = D.13249 * 8;
  D.13257 = refs + D.13250;
  D.13258 = *D.13257;
  emit_obj (logbuffer, D.13258);
  i = i + 1;
  <D.11584>:
  D.13259 = (long unsigned int) i;
  if (D.13259 < num) goto <D.11583>; else goto <D.11585>;
  <D.11585>:
  D.13260 = 0;
  return D.13260;
}


log_shutdown (struct MonoProfiler * prof)
{
  int D.13263;
  int D.13266;
  long unsigned int D.13267;
  struct PerfData * perf_data.79;
  int num_perf.80;
  struct StatBuffer * D.13272;
  struct LogBuffer * tlsbuffer.81;
  struct gzFile_s * * D.13276;
  int D.13279;
  struct FILE * D.13282;

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

    try
      {
        c = 1;
        D.13266 = prof->pipes[1];
        write (D.13266, &c, 1);
        D.13267 = prof->helper_thread;
        pthread_join (D.13267, &res);
      }
    finally
      {
        c = {CLOBBER};
        res = {CLOBBER};
      }
  }
  <D.13265>:
  perf_data.79 = perf_data;
  if (perf_data.79 != 0B) goto <D.13269>; else goto <D.13270>;
  <D.13269>:
  {
    int i;

    i = 0;
    goto <D.12012>;
    <D.12011>:
    read_perf_mmap (prof, i);
    i = i + 1;
    <D.12012>:
    num_perf.80 = num_perf;
    if (i < num_perf.80) goto <D.12011>; else goto <D.12013>;
    <D.12013>:
  }
  <D.13270>:
  D.13272 = prof->stat_buffers;
  dump_sample_hits (prof, D.13272, 1);
  take_lock ();
  tlsbuffer.81 = tlsbuffer;
  if (tlsbuffer.81 != 0B) goto <D.13274>; else goto <D.13275>;
  <D.13274>:
  tlsbuffer.81 = tlsbuffer;
  dump_buffer (prof, tlsbuffer.81);
  <D.13275>:
  tlsbuffer = 0B;
  release_lock ();
  D.13276 = prof->gzfile;
  if (D.13276 != 0B) goto <D.13277>; else goto <D.13278>;
  <D.13277>:
  D.13276 = prof->gzfile;
  gzclose (D.13276);
  <D.13278>:
  D.13279 = prof->pipe_output;
  if (D.13279 != 0) goto <D.13280>; else goto <D.13281>;
  <D.13280>:
  D.13282 = prof->file;
  pclose (D.13282);
  goto <D.13283>;
  <D.13281>:
  D.13282 = prof->file;
  fclose (D.13282);
  <D.13283>:
  free (prof);
}


read_perf_mmap (struct MonoProfiler * prof, int cpu)
{
  struct PerfData * perf_data.82;
  long unsigned int D.13287;
  long unsigned int D.13288;
  void * D.13289;
  int D.13290;
  sizetype D.13291;
  struct perf_event_mmap_page * D.13292;
  long long unsigned int D.13293;
  unsigned int D.13294;
  int do_debug.83;
  unsigned int mmap_mask.84;
  unsigned int D.13301;
  unsigned int size.85;
  unsigned int D.13303;
  unsigned int D.13304;
  sizetype D.13307;
  unsigned int D.13308;
  unsigned int D.13309;
  unsigned int D.13310;
  long long unsigned int D.13315;
  int D.13316;
  struct PerfData * perf;
  unsigned char * buf;
  unsigned char * data;
  unsigned int head;
  int diff;
  int size;
  unsigned int old;

  perf_data.82 = perf_data;
  D.13287 = (long unsigned int) cpu;
  D.13288 = D.13287 * 24;
  perf = perf_data.82 + D.13288;
  D.13289 = perf->mmap_base;
  D.13290 = getpagesize ();
  D.13291 = (sizetype) D.13290;
  data = D.13289 + D.13291;
  D.13292 = perf->page_desc;
  D.13293 = D.13292->data_head;
  head = (unsigned int) D.13293;
  __asm__ __volatile__("lfence" :  :  : "memory");
  old = perf->prev_pos;
  D.13294 = head - old;
  diff = (int) D.13294;
  if (diff < 0) goto <D.13295>; else goto <D.13296>;
  <D.13295>:
  do_debug.83 = do_debug;
  if (do_debug.83 != 0) goto <D.13298>; else goto <D.13299>;
  <D.13298>:
  printf ("lost mmap events: old: %d, head: %d\n", old, head);
  <D.13299>:
  old = head;
  <D.13296>:
  D.13294 = head - old;
  size = (int) D.13294;
  mmap_mask.84 = mmap_mask;
  D.13301 = old & mmap_mask.84;
  size.85 = (unsigned int) size;
  D.13303 = D.13301 + size.85;
  mmap_mask.84 = mmap_mask;
  D.13304 = head & mmap_mask.84;
  if (D.13303 != D.13304) goto <D.13305>; else goto <D.13306>;
  <D.13305>:
  mmap_mask.84 = mmap_mask;
  D.13301 = old & mmap_mask.84;
  D.13307 = (sizetype) D.13301;
  buf = data + D.13307;
  D.13308 = ~old;
  mmap_mask.84 = mmap_mask;
  D.13309 = D.13308 & mmap_mask.84;
  D.13310 = D.13309 + 1;
  size = (int) D.13310;
  size.85 = (unsigned int) size;
  old = old + size.85;
  do_debug.83 = do_debug;
  if (do_debug.83 != 0) goto <D.13311>; else goto <D.13312>;
  <D.13311>:
  printf ("found1 bytes of events: %d\n", size);
  <D.13312>:
  dump_perf_hits (prof, buf, size);
  <D.13306>:
  mmap_mask.84 = mmap_mask;
  D.13301 = old & mmap_mask.84;
  D.13307 = (sizetype) D.13301;
  buf = data + D.13307;
  D.13294 = head - old;
  size = (int) D.13294;
  do_debug.83 = do_debug;
  if (do_debug.83 != 0) goto <D.13313>; else goto <D.13314>;
  <D.13313>:
  printf ("found bytes of events: %d\n", size);
  <D.13314>:
  dump_perf_hits (prof, buf, size);
  size.85 = (unsigned int) size;
  old = old + size.85;
  perf->prev_pos = old;
  D.13292 = perf->page_desc;
  D.13315 = (long long unsigned int) old;
  D.13292->data_tail = D.13315;
  D.13316 = 0;
  return D.13316;
}


dump_perf_hits (struct MonoProfiler * prof, void * buf, int size)
{
  sizetype D.13318;
  short unsigned int D.13319;
  unsigned int pid.86;
  unsigned int D.13322;
  int do_debug.87;
  sizetype D.13328;
  long unsigned int D.13329;
  unsigned int D.13330;
  unsigned int D.13331;
  unsigned int D.13332;
  int D.13333;
  int sample_type.88;
  long unsigned int D.13335;
  long unsigned int D.13336;
  long unsigned int D.13337;
  long unsigned int D.13338;
  void * D.13339;
  struct LogBuffer * logbuffer;
  void * end;
  int samples;
  int pid;

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

    s = buf;
    D.13319 = s->h.size;
    if (D.13319 == 0) goto <D.11970>; else goto <D.13320>;
    <D.13320>:
    pid.86 = (unsigned int) pid;
    D.13322 = s->pid;
    if (pid.86 != D.13322) goto <D.13323>; else goto <D.13324>;
    <D.13323>:
    do_debug.87 = do_debug;
    if (do_debug.87 != 0) goto <D.13326>; else goto <D.13327>;
    <D.13326>:
    D.13322 = s->pid;
    printf ("event for different pid: %d\n", D.13322);
    <D.13327>:
    D.13319 = s->h.size;
    D.13328 = (sizetype) D.13319;
    buf = buf + D.13328;
    // predicted unlikely by continue predictor.
    goto <D.11971>;
    <D.13324>:
    D.13329 = s->nframes;
    D.13330 = (unsigned int) D.13329;
    D.13331 = D.13330 * 8;
    D.13332 = D.13331 + 20;
    D.13333 = (int) D.13332;
    logbuffer = ensure_logbuf (D.13333);
    emit_byte (logbuffer, 7);
    sample_type.88 = sample_type;
    emit_value (logbuffer, sample_type.88);
    D.13335 = s->timestamp;
    D.13336 = prof->startup_time;
    D.13337 = D.13335 - D.13336;
    emit_uvalue (logbuffer, D.13337);
    emit_value (logbuffer, 1);
    D.13338 = s->ip;
    D.13339 = (void *) D.13338;
    emit_ptr (logbuffer, D.13339);
    D.13338 = s->ip;
    add_code_pointer (D.13338);
    D.13319 = s->h.size;
    D.13328 = (sizetype) D.13319;
    buf = buf + D.13328;
    samples = samples + 1;
  }
  <D.11971>:
  if (buf < end) goto <D.11972>; else goto <D.11970>;
  <D.11970>:
  do_debug.87 = do_debug;
  if (do_debug.87 != 0) goto <D.13340>; else goto <D.13341>;
  <D.13340>:
  printf ("dumped %d samples\n", samples);
  <D.13341>:
  dump_unmanaged_coderefs (prof);
}


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

  D.13343 = &logbuffer->data;
  D.13344 = logbuffer->data;
  encode_uleb128 (value, D.13344, D.13343);
  D.13344 = logbuffer->data;
  D.13345 = logbuffer->data_end;
  if (D.13344 > D.13345) goto <D.13346>; else goto <D.13347>;
  <D.13346>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 481, &__PRETTY_FUNCTION__);
  <D.13347>:
}


add_code_pointer (uintptr_t ip)
{
  int num_code_pages.89;
  int D.13349;
  int size_code_pages.90;
  int size_code_pages.91;
  long unsigned int D.13356;
  long unsigned int D.13357;
  uintptr_t * code_pages.92;
  long unsigned int D.13359;
  uintptr_t * D.13360;
  long unsigned int D.13361;
  long unsigned int D.13364;
  long unsigned int D.13367;
  long unsigned int D.13368;
  unsigned int D.13369;
  unsigned int num_code_pages.93;
  unsigned int D.13371;
  int num_code_pages.94;
  uintptr_t i;

  num_code_pages.89 = num_code_pages;
  D.13349 = num_code_pages.89 * 2;
  size_code_pages.90 = size_code_pages;
  if (D.13349 >= size_code_pages.90) goto <D.13351>; else goto <D.13352>;
  <D.13351>:
  {
    uintptr_t * n;
    uintptr_t old_size;

    size_code_pages.90 = size_code_pages;
    old_size = (uintptr_t) size_code_pages.90;
    size_code_pages.90 = size_code_pages;
    size_code_pages.91 = size_code_pages.90 * 2;
    size_code_pages = size_code_pages.91;
    size_code_pages.90 = size_code_pages;
    if (size_code_pages.90 == 0) goto <D.13354>; else goto <D.13355>;
    <D.13354>:
    size_code_pages = 16;
    <D.13355>:
    size_code_pages.90 = size_code_pages;
    D.13356 = (long unsigned int) size_code_pages.90;
    D.13357 = D.13356 * 8;
    n = calloc (D.13357, 1);
    i = 0;
    goto <D.11809>;
    <D.11808>:
    code_pages.92 = code_pages;
    D.13359 = i * 8;
    D.13360 = code_pages.92 + D.13359;
    D.13361 = *D.13360;
    if (D.13361 != 0) goto <D.13362>; else goto <D.13363>;
    <D.13362>:
    code_pages.92 = code_pages;
    D.13359 = i * 8;
    D.13360 = code_pages.92 + D.13359;
    D.13361 = *D.13360;
    size_code_pages.90 = size_code_pages;
    D.13364 = (long unsigned int) size_code_pages.90;
    add_code_page (n, D.13364, D.13361);
    <D.13363>:
    i = i + 1;
    <D.11809>:
    if (i < old_size) goto <D.11808>; else goto <D.11810>;
    <D.11810>:
    code_pages.92 = code_pages;
    if (code_pages.92 != 0B) goto <D.13365>; else goto <D.13366>;
    <D.13365>:
    code_pages.92 = code_pages;
    free (code_pages.92);
    <D.13366>:
    code_pages = n;
  }
  <D.13352>:
  D.13367 = ip & 18446744073709551104;
  size_code_pages.90 = size_code_pages;
  D.13364 = (long unsigned int) size_code_pages.90;
  code_pages.92 = code_pages;
  D.13368 = add_code_page (code_pages.92, D.13364, D.13367);
  D.13369 = (unsigned int) D.13368;
  num_code_pages.89 = num_code_pages;
  num_code_pages.93 = (unsigned int) num_code_pages.89;
  D.13371 = D.13369 + num_code_pages.93;
  num_code_pages.94 = (int) D.13371;
  num_code_pages = num_code_pages.94;
}


add_code_page (uintptr_t * hash, uintptr_t hsize, uintptr_t page)
{
  long unsigned int D.13374;
  long unsigned int D.13376;
  uintptr_t * D.13377;
  long unsigned int D.13378;
  long unsigned int D.13380;
  long unsigned int D.13381;
  uintptr_t D.13383;
  uintptr_t i;
  uintptr_t start_pos;

  D.13374 = page >> 9;
  start_pos = D.13374 % hsize;
  i = start_pos;
  <D.11800>:
  D.13376 = i * 8;
  D.13377 = hash + D.13376;
  D.13378 = *D.13377;
  if (D.13378 != 0) goto <D.13379>; else goto <D.13375>;
  <D.13379>:
  D.13376 = i * 8;
  D.13377 = hash + D.13376;
  D.13378 = *D.13377;
  D.13380 = D.13378 ^ page;
  D.13381 = D.13380 & 18446744073709551104;
  if (D.13381 == 0) goto <D.13382>; else goto <D.13375>;
  <D.13382>:
  D.13383 = 0;
  return D.13383;
  <D.13375>:
  D.13376 = i * 8;
  D.13377 = hash + D.13376;
  D.13378 = *D.13377;
  if (D.13378 == 0) goto <D.13384>; else goto <D.13385>;
  <D.13384>:
  D.13376 = i * 8;
  D.13377 = hash + D.13376;
  *D.13377 = page;
  D.13383 = 1;
  return D.13383;
  <D.13385>:
  i = i + 1;
  if (i == hsize) goto <D.13386>; else goto <D.13387>;
  <D.13386>:
  i = 0;
  <D.13387>:
  if (i != start_pos) goto <D.11800>; else goto <D.11801>;
  <D.11801>:
  printf ("failed code page store\n");
  D.13383 = 0;
  return D.13383;
}


dump_unmanaged_coderefs (struct MonoProfiler * prof)
{
  int D.13389;
  uintptr_t * code_pages.95;
  long unsigned int D.13395;
  long unsigned int D.13396;
  uintptr_t * D.13397;
  long unsigned int D.13398;
  long unsigned int D.13400;
  long unsigned int D.13401;
  _Bool D.13402;
  _Bool D.13403;
  _Bool D.13404;
  int size_code_pages.96;
  int i;
  const char * last_symbol;
  uintptr_t addr;
  uintptr_t page_end;

  D.13389 = load_binaries (prof);
  if (D.13389 != 0) goto <D.13390>; else goto <D.13391>;
  <D.13390>:
  return;
  <D.13391>:
  i = 0;
  goto <D.11909>;
  <D.11908>:
  {
    const char * sym;

    code_pages.95 = code_pages;
    D.13395 = (long unsigned int) i;
    D.13396 = D.13395 * 8;
    D.13397 = code_pages.95 + D.13396;
    D.13398 = *D.13397;
    if (D.13398 == 0) goto <D.13392>; else goto <D.13399>;
    <D.13399>:
    code_pages.95 = code_pages;
    D.13395 = (long unsigned int) i;
    D.13396 = D.13395 * 8;
    D.13397 = code_pages.95 + D.13396;
    D.13398 = *D.13397;
    D.13400 = D.13398 & 1;
    if (D.13400 != 0) goto <D.13392>; else goto <D.13393>;
    <D.13392>:
    // predicted unlikely by continue predictor.
    goto <D.11903>;
    <D.13393>:
    last_symbol = 0B;
    code_pages.95 = code_pages;
    D.13395 = (long unsigned int) i;
    D.13396 = D.13395 * 8;
    D.13397 = code_pages.95 + D.13396;
    D.13398 = *D.13397;
    addr = D.13398 & 18446744073709551104;
    page_end = addr + 512;
    code_pages.95 = code_pages;
    D.13395 = (long unsigned int) i;
    D.13396 = D.13395 * 8;
    D.13397 = code_pages.95 + D.13396;
    code_pages.95 = code_pages;
    D.13395 = (long unsigned int) i;
    D.13396 = D.13395 * 8;
    D.13397 = code_pages.95 + D.13396;
    D.13398 = *D.13397;
    D.13401 = D.13398 | 1;
    *D.13397 = D.13401;
    goto <D.11906>;
    <D.11905>:
    sym = symbol_for (addr);
    D.13402 = sym != 0B;
    D.13403 = sym == last_symbol;
    D.13404 = D.13402 & D.13403;
    if (D.13404 != 0) goto <D.13405>; else goto <D.13406>;
    <D.13405>:
    // predicted unlikely by continue predictor.
    goto <D.11904>;
    <D.13406>:
    last_symbol = sym;
    if (sym == 0B) goto <D.13407>; else goto <D.13408>;
    <D.13407>:
    // predicted unlikely by continue predictor.
    goto <D.11904>;
    <D.13408>:
    dump_usym (sym, addr, 0);
    <D.11904>:
    addr = addr + 16;
    <D.11906>:
    if (addr < page_end) goto <D.11905>; else goto <D.11907>;
    <D.11907>:
  }
  <D.11903>:
  i = i + 1;
  <D.11909>:
  size_code_pages.96 = size_code_pages;
  if (i < size_code_pages.96) goto <D.11908>; else goto <D.11910>;
  <D.11910>:
}


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

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


elf_dl_callback (struct dl_phdr_info * info, size_t size, void * data)
{
  long unsigned int D.13415;
  void * D.13416;
  int D.13419;
  char D.13422;
  long int D.13425;
  void * D.13428;
  char * D.13429;
  struct BinaryObject * D.13430;
  const struct Elf64_Phdr * D.13433;
  long unsigned int D.13434;
  long unsigned int D.13435;
  const struct Elf64_Phdr * D.13436;
  unsigned int D.13437;
  long unsigned int D.13440;
  long unsigned int D.13441;
  unsigned int D.13442;
  unsigned int D.13443;
  long unsigned int D.13446;
  long unsigned int D.13447;
  short unsigned int D.13450;
  int D.13451;
  int D.13452;
  const char * D.13457;
  char D.13459;
  long unsigned int D.13462;
  struct Elf64_Dyn * D.13463;
  long int D.13464;
  int do_debug.97;
  long unsigned int D.13472;
  Elf64_Word * D.13481;
  unsigned int D.13482;
  struct MonoProfiler * prof;
  char buf[256];
  const char * filename;
  struct BinaryObject * obj;
  char * a;
  int i;
  int num_sym;
  struct Elf64_Dyn * dyn;
  struct Elf64_Sym * symtab;
  Elf64_Word * hash_table;
  struct Elf64_Ehdr * header;
  const char * strtab;

  try
    {
      prof = data;
      D.13415 = info->dlpi_addr;
      a = (char *) D.13415;
      dyn = 0B;
      symtab = 0B;
      hash_table = 0B;
      header = 0B;
      strtab = 0B;
      obj = prof->binary_objects;
      goto <D.11878>;
      <D.11877>:
      D.13416 = obj->addr;
      if (D.13416 == a) goto <D.13417>; else goto <D.13418>;
      <D.13417>:
      D.13419 = 0;
      return D.13419;
      <D.13418>:
      obj = obj->next;
      <D.11878>:
      if (obj != 0B) goto <D.11877>; else goto <D.11879>;
      <D.11879>:
      filename = info->dlpi_name;
      D.13415 = info->dlpi_addr;
      if (D.13415 == 0) goto <D.13420>; else goto <D.13421>;
      <D.13420>:
      D.13422 = *filename;
      if (D.13422 == 0) goto <D.13423>; else goto <D.13424>;
      <D.13423>:
      {
        int l;

        D.13425 = readlink ("/proc/self/exe", &buf, 255);
        l = (int) D.13425;
        if (l > 0) goto <D.13426>; else goto <D.13427>;
        <D.13426>:
        buf[l] = 0;
        filename = &buf;
        <D.13427>:
      }
      <D.13424>:
      <D.13421>:
      obj = calloc (24, 1);
      D.13415 = info->dlpi_addr;
      D.13428 = (void *) D.13415;
      obj->addr = D.13428;
      D.13429 = pstrdup (filename);
      obj->name = D.13429;
      D.13430 = prof->binary_objects;
      obj->next = D.13430;
      prof->binary_objects = obj;
      a = 0B;
      i = 0;
      goto <D.11882>;
      <D.11881>:
      D.13433 = info->dlpi_phdr;
      D.13434 = (long unsigned int) i;
      D.13435 = D.13434 * 56;
      D.13436 = D.13433 + D.13435;
      D.13437 = D.13436->p_type;
      if (D.13437 == 1) goto <D.13438>; else goto <D.13431>;
      <D.13438>:
      if (header == 0B) goto <D.13439>; else goto <D.13431>;
      <D.13439>:
      D.13415 = info->dlpi_addr;
      D.13433 = info->dlpi_phdr;
      D.13434 = (long unsigned int) i;
      D.13435 = D.13434 * 56;
      D.13436 = D.13433 + D.13435;
      D.13440 = D.13436->p_vaddr;
      D.13441 = D.13415 + D.13440;
      header = (struct Elf64_Ehdr *) D.13441;
      D.13442 = BIT_FIELD_REF <*header, 32, 0>;
      D.13443 = D.13442;
      if (D.13443 != 1179403647) goto <D.13444>; else goto <D.13445>;
      <D.13444>:
      header = 0B;
      <D.13445>:
      D.13433 = info->dlpi_phdr;
      D.13434 = (long unsigned int) i;
      D.13435 = D.13434 * 56;
      D.13436 = D.13433 + D.13435;
      D.13446 = D.13436->p_memsz;
      D.13433 = info->dlpi_phdr;
      D.13434 = (long unsigned int) i;
      D.13435 = D.13434 * 56;
      D.13436 = D.13433 + D.13435;
      D.13447 = D.13436->p_offset;
      D.13415 = info->dlpi_addr;
      D.13433 = info->dlpi_phdr;
      D.13434 = (long unsigned int) i;
      D.13435 = D.13434 * 56;
      D.13436 = D.13433 + D.13435;
      D.13440 = D.13436->p_vaddr;
      D.13441 = D.13415 + D.13440;
      dump_ubin (filename, D.13441, D.13447, D.13446);
      goto <D.13432>;
      <D.13431>:
      D.13433 = info->dlpi_phdr;
      D.13434 = (long unsigned int) i;
      D.13435 = D.13434 * 56;
      D.13436 = D.13433 + D.13435;
      D.13437 = D.13436->p_type;
      if (D.13437 == 2) goto <D.13448>; else goto <D.13449>;
      <D.13448>:
      D.13415 = info->dlpi_addr;
      D.13433 = info->dlpi_phdr;
      D.13434 = (long unsigned int) i;
      D.13435 = D.13434 * 56;
      D.13436 = D.13433 + D.13435;
      D.13440 = D.13436->p_vaddr;
      D.13441 = D.13415 + D.13440;
      dyn = (struct Elf64_Dyn *) D.13441;
      <D.13449>:
      <D.13432>:
      i = i + 1;
      <D.11882>:
      D.13450 = info->dlpi_phnum;
      D.13451 = (int) D.13450;
      if (D.13451 > i) goto <D.11881>; else goto <D.11883>;
      <D.11883>:
      D.13415 = info->dlpi_addr;
      D.13428 = (void *) D.13415;
      D.13452 = read_elf_symbols (prof, filename, D.13428);
      if (D.13452 != 0) goto <D.13453>; else goto <D.13454>;
      <D.13453>:
      D.13419 = 0;
      return D.13419;
      <D.13454>:
      D.13457 = info->dlpi_name;
      if (D.13457 == 0B) goto <D.13455>; else goto <D.13458>;
      <D.13458>:
      D.13457 = info->dlpi_name;
      D.13459 = *D.13457;
      if (D.13459 == 0) goto <D.13455>; else goto <D.13456>;
      <D.13455>:
      D.13419 = 0;
      return D.13419;
      <D.13456>:
      if (dyn == 0B) goto <D.13460>; else goto <D.13461>;
      <D.13460>:
      D.13419 = 0;
      return D.13419;
      <D.13461>:
      i = 0;
      goto <D.11885>;
      <D.11884>:
      D.13434 = (long unsigned int) i;
      D.13462 = D.13434 * 16;
      D.13463 = dyn + D.13462;
      D.13464 = D.13463->d_tag;
      if (D.13464 == 6) goto <D.13465>; else goto <D.13466>;
      <D.13465>:
      if (symtab != 0B) goto <D.13467>; else goto <D.13468>;
      <D.13467>:
      do_debug.97 = do_debug;
      if (do_debug.97 != 0) goto <D.13470>; else goto <D.13471>;
      <D.13470>:
      printf ("multiple symtabs: %d\n", i);
      <D.13471>:
      <D.13468>:
      D.13434 = (long unsigned int) i;
      D.13462 = D.13434 * 16;
      D.13463 = dyn + D.13462;
      D.13472 = D.13463->d_un.d_ptr;
      symtab = a + D.13472;
      goto <D.13473>;
      <D.13466>:
      D.13434 = (long unsigned int) i;
      D.13462 = D.13434 * 16;
      D.13463 = dyn + D.13462;
      D.13464 = D.13463->d_tag;
      if (D.13464 == 4) goto <D.13474>; else goto <D.13475>;
      <D.13474>:
      D.13434 = (long unsigned int) i;
      D.13462 = D.13434 * 16;
      D.13463 = dyn + D.13462;
      D.13472 = D.13463->d_un.d_ptr;
      hash_table = a + D.13472;
      goto <D.13476>;
      <D.13475>:
      D.13434 = (long unsigned int) i;
      D.13462 = D.13434 * 16;
      D.13463 = dyn + D.13462;
      D.13464 = D.13463->d_tag;
      if (D.13464 == 5) goto <D.13477>; else goto <D.13478>;
      <D.13477>:
      D.13434 = (long unsigned int) i;
      D.13462 = D.13434 * 16;
      D.13463 = dyn + D.13462;
      D.13472 = D.13463->d_un.d_ptr;
      strtab = a + D.13472;
      <D.13478>:
      <D.13476>:
      <D.13473>:
      i = i + 1;
      <D.11885>:
      D.13434 = (long unsigned int) i;
      D.13462 = D.13434 * 16;
      D.13463 = dyn + D.13462;
      D.13464 = D.13463->d_tag;
      if (D.13464 != 0) goto <D.11884>; else goto <D.11886>;
      <D.11886>:
      if (hash_table == 0B) goto <D.13479>; else goto <D.13480>;
      <D.13479>:
      D.13419 = 0;
      return D.13419;
      <D.13480>:
      D.13481 = hash_table + 4;
      D.13482 = *D.13481;
      num_sym = (int) D.13482;
      D.13415 = info->dlpi_addr;
      D.13428 = (void *) D.13415;
      dump_elf_symbols (symtab, num_sym, strtab, D.13428);
      D.13419 = 0;
      return D.13419;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


readlink (const char * restrict __path, char * restrict __buf, size_t __len)
{
  long unsigned int D.13488;
  int D.13491;
  ssize_t D.13494;
  long unsigned int D.13495;
  long unsigned int D.13496;
  long unsigned int D.13499;

  D.13488 = __builtin_object_size (__buf, 1);
  if (D.13488 != 18446744073709551615) goto <D.13489>; else goto <D.13490>;
  <D.13489>:
  D.13491 = __builtin_constant_p (__len);
  if (D.13491 == 0) goto <D.13492>; else goto <D.13493>;
  <D.13492>:
  D.13495 = __builtin_object_size (__buf, 1);
  D.13494 = __readlink_chk (__path, __buf, __len, D.13495);
  return D.13494;
  <D.13493>:
  D.13496 = __builtin_object_size (__buf, 1);
  if (D.13496 < __len) goto <D.13497>; else goto <D.13498>;
  <D.13497>:
  D.13499 = __builtin_object_size (__buf, 1);
  D.13494 = __readlink_chk_warn (__path, __buf, __len, D.13499);
  return D.13494;
  <D.13498>:
  <D.13490>:
  D.13494 = __readlink_alias (__path, __buf, __len);
  return D.13494;
}


pstrdup (const char * s)
{
  long unsigned int D.13501;
  unsigned int D.13502;
  unsigned int D.13503;
  long unsigned int D.13504;
  char * D.13505;
  int len;
  char * p;

  D.13501 = strlen (s);
  D.13502 = (unsigned int) D.13501;
  D.13503 = D.13502 + 1;
  len = (int) D.13503;
  D.13504 = (long unsigned int) len;
  p = malloc (D.13504);
  D.13504 = (long unsigned int) len;
  memcpy (p, s, D.13504);
  D.13505 = p;
  return D.13505;
}


dump_ubin (const char * filename, uintptr_t load_addr, uint64_t offset, uintptr_t size)
{
  long unsigned int D.13507;
  unsigned int D.13508;
  unsigned int D.13509;
  int D.13510;
  long int load_addr.98;
  long unsigned int D.13512;
  unsigned char * D.13513;
  sizetype D.13514;
  unsigned char * D.13515;
  uint64_t now;
  struct LogBuffer * logbuffer;
  int len;

  D.13507 = strlen (filename);
  D.13508 = (unsigned int) D.13507;
  D.13509 = D.13508 + 1;
  len = (int) D.13509;
  now = current_time ();
  D.13510 = len + 20;
  logbuffer = ensure_logbuf (D.13510);
  emit_byte (logbuffer, 39);
  emit_time (logbuffer, now);
  load_addr.98 = (long int) load_addr;
  emit_svalue (logbuffer, load_addr.98);
  emit_uvalue (logbuffer, offset);
  emit_uvalue (logbuffer, size);
  D.13512 = (long unsigned int) len;
  D.13513 = logbuffer->data;
  memcpy (D.13513, filename, D.13512);
  D.13513 = logbuffer->data;
  D.13514 = (sizetype) len;
  D.13515 = D.13513 + D.13514;
  logbuffer->data = D.13515;
}


read_elf_symbols (struct MonoProfiler * prof, const char * filename, void * load_addr)
{
  int D.13520;
  int D.13521;
  long int D.13524;
  unsigned int D.13527;
  unsigned int D.13528;
  long unsigned int D.13531;
  short unsigned int D.13532;
  int D.13533;
  short unsigned int D.13534;
  int D.13535;
  int D.13536;
  sizetype D.13537;
  long unsigned int D.13538;
  unsigned int D.13539;
  unsigned int D.13542;
  unsigned int D.13543;
  unsigned int D.13544;
  sizetype D.13545;
  sizetype D.13546;
  sizetype D.13547;
  short unsigned int D.13548;
  int D.13549;
  _Bool D.13550;
  _Bool D.13551;
  _Bool D.13552;
  long unsigned int D.13555;
  long unsigned int D.13556;
  long unsigned int D.13557;
  long unsigned int D.13558;
  long unsigned int D.13559;
  int fd;
  int i;
  void * data;
  struct stat statb;
  uint64_t file_size;
  struct Elf64_Ehdr * header;
  struct Elf64_Shdr * sheader;
  struct Elf64_Shdr * shstrtabh;
  struct Elf64_Shdr * symtabh;
  struct Elf64_Shdr * strtabh;
  struct Elf64_Sym * symbols;
  const char * strtab;
  int num_symbols;

  try
    {
      symtabh = 0B;
      strtabh = 0B;
      symbols = 0B;
      fd = open (filename, 0);
      if (fd < 0) goto <D.13518>; else goto <D.13519>;
      <D.13518>:
      D.13520 = 0;
      return D.13520;
      <D.13519>:
      D.13521 = fstat (fd, &statb);
      if (D.13521 != 0) goto <D.13522>; else goto <D.13523>;
      <D.13522>:
      close (fd);
      D.13520 = 0;
      return D.13520;
      <D.13523>:
      D.13524 = statb.st_size;
      file_size = (uint64_t) D.13524;
      data = mmap (0B, file_size, 1, 2, fd, 0);
      close (fd);
      if (data == -1B) goto <D.13525>; else goto <D.13526>;
      <D.13525>:
      D.13520 = 0;
      return D.13520;
      <D.13526>:
      header = data;
      D.13527 = BIT_FIELD_REF <*header, 32, 0>;
      D.13528 = D.13527;
      if (D.13528 != 1179403647) goto <D.13529>; else goto <D.13530>;
      <D.13529>:
      munmap (data, file_size);
      D.13520 = 0;
      return D.13520;
      <D.13530>:
      D.13531 = header->e_shoff;
      sheader = data + D.13531;
      D.13532 = header->e_shentsize;
      D.13533 = (int) D.13532;
      D.13534 = header->e_shstrndx;
      D.13535 = (int) D.13534;
      D.13536 = D.13533 * D.13535;
      D.13537 = (sizetype) D.13536;
      shstrtabh = sheader + D.13537;
      D.13538 = shstrtabh->sh_offset;
      strtab = data + D.13538;
      i = 0;
      goto <D.11859>;
      <D.11858>:
      D.13539 = sheader->sh_type;
      if (D.13539 == 2) goto <D.13540>; else goto <D.13541>;
      <D.13540>:
      symtabh = sheader;
      D.13531 = header->e_shoff;
      D.13542 = sheader->sh_link;
      D.13532 = header->e_shentsize;
      D.13543 = (unsigned int) D.13532;
      D.13544 = D.13542 * D.13543;
      D.13545 = (sizetype) D.13544;
      D.13546 = D.13531 + D.13545;
      strtabh = data + D.13546;
      goto <D.11857>;
      <D.13541>:
      D.13532 = header->e_shentsize;
      D.13547 = (sizetype) D.13532;
      sheader = sheader + D.13547;
      i = i + 1;
      <D.11859>:
      D.13548 = header->e_shnum;
      D.13549 = (int) D.13548;
      if (D.13549 > i) goto <D.11858>; else goto <D.11857>;
      <D.11857>:
      D.13550 = symtabh == 0B;
      D.13551 = strtabh == 0B;
      D.13552 = D.13550 | D.13551;
      if (D.13552 != 0) goto <D.13553>; else goto <D.13554>;
      <D.13553>:
      munmap (data, file_size);
      D.13520 = 0;
      return D.13520;
      <D.13554>:
      D.13555 = strtabh->sh_offset;
      strtab = data + D.13555;
      D.13556 = symtabh->sh_size;
      D.13557 = symtabh->sh_entsize;
      D.13558 = D.13556 / D.13557;
      num_symbols = (int) D.13558;
      D.13559 = symtabh->sh_offset;
      symbols = data + D.13559;
      dump_elf_symbols (symbols, num_symbols, strtab, load_addr);
      munmap (data, file_size);
      D.13520 = 1;
      return D.13520;
    }
  finally
    {
      statb = {CLOBBER};
    }
}


open (const char * __path, int __oflag)
{
  int D.13564;
  int D.13567;
  int D.13572;
  int D.13574;
  int D.13575;
  int D.13578;
  int D.13579;

  D.13564 = __builtin_va_arg_pack_len ();
  if (D.13564 > 1) goto <D.13565>; else goto <D.13566>;
  <D.13565>:
  __open_too_many_args ();
  <D.13566>:
  D.13567 = __builtin_constant_p (__oflag);
  if (D.13567 != 0) goto <D.13568>; else goto <D.13569>;
  <D.13568>:
  D.13572 = __oflag & 64;
  if (D.13572 != 0) goto <D.13570>; else goto <D.13573>;
  <D.13573>:
  D.13574 = __oflag & 4259840;
  if (D.13574 == 4259840) goto <D.13570>; else goto <D.13571>;
  <D.13570>:
  D.13575 = __builtin_va_arg_pack_len ();
  if (D.13575 <= 0) goto <D.13576>; else goto <D.13577>;
  <D.13576>:
  __open_missing_mode ();
  D.13578 = __open_2 (__path, __oflag);
  return D.13578;
  <D.13577>:
  <D.13571>:
  D.13578 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.13578;
  <D.13569>:
  D.13579 = __builtin_va_arg_pack_len ();
  if (D.13579 <= 0) goto <D.13580>; else goto <D.13581>;
  <D.13580>:
  D.13578 = __open_2 (__path, __oflag);
  return D.13578;
  <D.13581>:
  D.13578 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.13578;
}


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

  D.13587 = __fxstat (1, __fd, __statbuf);
  return D.13587;
}


dump_elf_symbols (struct Elf64_Sym * symbols, int num_symbols, const char * strtab, void * load_addr)
{
  long unsigned int D.13589;
  long unsigned int D.13590;
  struct Elf64_Sym * D.13591;
  unsigned int D.13592;
  sizetype D.13593;
  long unsigned int D.13597;
  unsigned char D.13599;
  int D.13600;
  int D.13601;
  long unsigned int D.13602;
  long unsigned int load_addr.99;
  long unsigned int D.13604;
  int i;

  i = 0;
  goto <D.11837>;
  <D.11836>:
  {
    const char * sym;

    D.13589 = (long unsigned int) i;
    D.13590 = D.13589 * 24;
    D.13591 = symbols + D.13590;
    D.13592 = D.13591->st_name;
    D.13593 = (sizetype) D.13592;
    sym = strtab + D.13593;
    D.13589 = (long unsigned int) i;
    D.13590 = D.13589 * 24;
    D.13591 = symbols + D.13590;
    D.13592 = D.13591->st_name;
    if (D.13592 == 0) goto <D.13594>; else goto <D.13596>;
    <D.13596>:
    D.13589 = (long unsigned int) i;
    D.13590 = D.13589 * 24;
    D.13591 = symbols + D.13590;
    D.13597 = D.13591->st_size;
    if (D.13597 == 0) goto <D.13594>; else goto <D.13598>;
    <D.13598>:
    D.13589 = (long unsigned int) i;
    D.13590 = D.13589 * 24;
    D.13591 = symbols + D.13590;
    D.13599 = D.13591->st_info;
    D.13600 = (int) D.13599;
    D.13601 = D.13600 & 15;
    if (D.13601 != 2) goto <D.13594>; else goto <D.13595>;
    <D.13594>:
    // predicted unlikely by continue predictor.
    goto <D.11835>;
    <D.13595>:
    D.13589 = (long unsigned int) i;
    D.13590 = D.13589 * 24;
    D.13591 = symbols + D.13590;
    D.13597 = D.13591->st_size;
    D.13589 = (long unsigned int) i;
    D.13590 = D.13589 * 24;
    D.13591 = symbols + D.13590;
    D.13602 = D.13591->st_value;
    load_addr.99 = (long unsigned int) load_addr;
    D.13604 = D.13602 + load_addr.99;
    dump_usym (sym, D.13604, D.13597);
  }
  <D.11835>:
  i = i + 1;
  <D.11837>:
  if (i < num_symbols) goto <D.11836>; else goto <D.11838>;
  <D.11838>:
}


symbol_for (uintptr_t code)
{
  int D.13605;
  const char * D.13608;
  const char * D.13611;
  void * ip;
  struct Dl_info di;

  try
    {
      ip = (void *) code;
      D.13605 = dladdr (ip, &di);
      if (D.13605 != 0) goto <D.13606>; else goto <D.13607>;
      <D.13606>:
      D.13608 = di.dli_sname;
      if (D.13608 != 0B) goto <D.13609>; else goto <D.13610>;
      <D.13609>:
      D.13611 = di.dli_sname;
      return D.13611;
      <D.13610>:
      goto <D.13612>;
      <D.13607>:
      <D.13612>:
      D.13611 = 0B;
      return D.13611;
    }
  finally
    {
      di = {CLOBBER};
    }
}


dump_usym (const char * name, uintptr_t value, uintptr_t size)
{
  long unsigned int D.13615;
  unsigned int D.13616;
  unsigned int D.13617;
  int D.13618;
  void * value.100;
  int D.13620;
  long unsigned int D.13621;
  unsigned char * D.13622;
  sizetype D.13623;
  unsigned char * D.13624;
  struct LogBuffer * logbuffer;
  int len;

  D.13615 = strlen (name);
  D.13616 = (unsigned int) D.13615;
  D.13617 = D.13616 + 1;
  len = (int) D.13617;
  D.13618 = len + 20;
  logbuffer = ensure_logbuf (D.13618);
  emit_byte (logbuffer, 23);
  value.100 = (void *) value;
  emit_ptr (logbuffer, value.100);
  D.13620 = (int) size;
  emit_value (logbuffer, D.13620);
  D.13621 = (long unsigned int) len;
  D.13622 = logbuffer->data;
  memcpy (D.13622, name, D.13621);
  D.13622 = logbuffer->data;
  D.13623 = (sizetype) len;
  D.13624 = D.13622 + D.13623;
  logbuffer->data = D.13624;
}


dump_sample_hits (struct MonoProfiler * prof, struct StatBuffer * sbuf, int recurse)
{
  struct StatBuffer * D.13630;
  long unsigned int D.13633;
  int D.13634;
  long unsigned int D.13635;
  int D.13636;
  long unsigned int D.13637;
  sizetype D.13638;
  sizetype D.13639;
  sizetype D.13640;
  uintptr_t * D.13641;
  uintptr_t * D.13642;
  int D.13644;
  int D.13645;
  long unsigned int D.13646;
  uintptr_t * D.13647;
  long unsigned int D.13648;
  long unsigned int D.13649;
  long unsigned int D.13650;
  sizetype D.13651;
  sizetype D.13652;
  sizetype D.13653;
  uintptr_t * D.13654;
  long unsigned int D.13655;
  void * D.13656;
  uintptr_t * sample;
  struct LogBuffer * logbuffer;

  if (sbuf == 0B) goto <D.13626>; else goto <D.13627>;
  <D.13626>:
  return;
  <D.13627>:
  if (recurse != 0) goto <D.13628>; else goto <D.13629>;
  <D.13628>:
  D.13630 = sbuf->next;
  if (D.13630 != 0B) goto <D.13631>; else goto <D.13632>;
  <D.13631>:
  D.13630 = sbuf->next;
  dump_sample_hits (prof, D.13630, 1);
  D.13630 = sbuf->next;
  D.13633 = D.13630->size;
  D.13634 = (int) D.13633;
  D.13630 = sbuf->next;
  free_buffer (D.13630, D.13634);
  sbuf->next = 0B;
  <D.13632>:
  <D.13629>:
  sample = &sbuf->buf;
  goto <D.11926>;
  <D.11925>:
  {
    int i;
    int count;
    int type;

    D.13635 = *sample;
    D.13636 = (int) D.13635;
    count = D.13636 & 65535;
    D.13635 = *sample;
    D.13637 = D.13635 >> 16;
    type = (int) D.13637;
    D.13638 = (sizetype) count;
    D.13639 = D.13638 + 3;
    D.13640 = D.13639 * 8;
    D.13641 = sample + D.13640;
    D.13642 = sbuf->data;
    if (D.13641 > D.13642) goto <D.11921>; else goto <D.13643>;
    <D.13643>:
    D.13644 = count * 8;
    D.13645 = D.13644 + 20;
    logbuffer = ensure_logbuf (D.13645);
    emit_byte (logbuffer, 7);
    emit_value (logbuffer, type);
    D.13646 = prof->startup_time;
    D.13647 = sample + 16;
    D.13648 = *D.13647;
    D.13649 = D.13648 * 10000;
    D.13650 = D.13646 + D.13649;
    emit_uvalue (logbuffer, D.13650);
    emit_value (logbuffer, count);
    i = 0;
    goto <D.11923>;
    <D.11922>:
    D.13651 = (sizetype) i;
    D.13652 = D.13651 + 3;
    D.13653 = D.13652 * 8;
    D.13654 = sample + D.13653;
    D.13655 = *D.13654;
    D.13656 = (void *) D.13655;
    emit_ptr (logbuffer, D.13656);
    D.13651 = (sizetype) i;
    D.13652 = D.13651 + 3;
    D.13653 = D.13652 * 8;
    D.13654 = sample + D.13653;
    D.13655 = *D.13654;
    add_code_pointer (D.13655);
    i = i + 1;
    <D.11923>:
    if (i < count) goto <D.11922>; else goto <D.11924>;
    <D.11924>:
    D.13638 = (sizetype) count;
    D.13639 = D.13638 + 3;
    D.13640 = D.13639 * 8;
    sample = sample + D.13640;
  }
  <D.11926>:
  D.13642 = sbuf->data;
  if (D.13642 > sample) goto <D.11925>; else goto <D.11921>;
  <D.11921>:
  dump_unmanaged_coderefs (prof);
}


set_sample_mode (char * val, int allow_empty)
{
  _Bool D.13659;
  _Bool D.13660;
  _Bool D.13661;
  int D.12163;
  int iftmp.101;
  int D.12162;
  const char[5] * D.13667;
  unsigned char D.13668;
  int D.13669;
  unsigned char D.13670;
  int D.13671;
  _Bool D.13672;
  _Bool D.13673;
  _Bool D.13674;
  const unsigned char * D.13677;
  unsigned char D.13678;
  int D.13679;
  const unsigned char * D.13680;
  unsigned char D.13681;
  int D.13682;
  _Bool D.13683;
  _Bool D.13684;
  const unsigned char * D.13687;
  unsigned char D.13688;
  int D.13689;
  const unsigned char * D.13690;
  unsigned char D.13691;
  int D.13692;
  _Bool D.13693;
  _Bool D.13694;
  const unsigned char * D.13697;
  unsigned char D.13698;
  int D.13699;
  const unsigned char * D.13700;
  unsigned char D.13701;
  int D.13702;
  const char * D.13706;
  long unsigned int D.13707;
  long unsigned int D.13708;
  int D.13709;
  int sample_type.102;
  sizetype D.13713;
  char D.13716;
  char * D.13719;
  long unsigned int D.13720;
  char * end.103;
  int count.104;
  char * end;
  char * maybe_freq;
  unsigned int count;
  const struct SampleMode * smode;

  try
    {
      maybe_freq = 0B;
      smode = &sample_modes;
      D.13659 = allow_empty != 0;
      D.13660 = val == 0B;
      D.13661 = D.13659 & D.13660;
      if (D.13661 != 0) goto <D.13662>; else goto <D.13663>;
      <D.13662>:
      sample_type = 1;
      sample_freq = 1000;
      return;
      <D.13663>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = val;
          D.13667 = "mono";
          D.13668 = MEM[(const unsigned char *)D.13667];
          D.13669 = (int) D.13668;
          D.13670 = *__s2;
          D.13671 = (int) D.13670;
          __result = D.13669 - D.13671;
          {
            D.13672 = __s2_len != 0;
            D.13673 = __result == 0;
            D.13674 = D.13672 & D.13673;
            if (D.13674 != 0) goto <D.13675>; else goto <D.13676>;
            <D.13675>:
            D.13677 = &MEM[(void *)"mono" + 1B];
            D.13678 = *D.13677;
            D.13679 = (int) D.13678;
            D.13680 = __s2 + 1;
            D.13681 = *D.13680;
            D.13682 = (int) D.13681;
            __result = D.13679 - D.13682;
            D.13683 = __s2_len > 1;
            D.13673 = __result == 0;
            D.13684 = D.13683 & D.13673;
            if (D.13684 != 0) goto <D.13685>; else goto <D.13686>;
            <D.13685>:
            D.13687 = &MEM[(void *)"mono" + 2B];
            D.13688 = *D.13687;
            D.13689 = (int) D.13688;
            D.13690 = __s2 + 2;
            D.13691 = *D.13690;
            D.13692 = (int) D.13691;
            __result = D.13689 - D.13692;
            D.13693 = __s2_len > 2;
            D.13673 = __result == 0;
            D.13694 = D.13693 & D.13673;
            if (D.13694 != 0) goto <D.13695>; else goto <D.13696>;
            <D.13695>:
            D.13697 = &MEM[(void *)"mono" + 3B];
            D.13698 = *D.13697;
            D.13699 = (int) D.13698;
            D.13700 = __s2 + 3;
            D.13701 = *D.13700;
            D.13702 = (int) D.13701;
            __result = D.13699 - D.13702;
            <D.13696>:
            <D.13686>:
            <D.13676>:
          }
          D.12162 = __result;
        }
        iftmp.101 = -D.12162;
        goto <D.13703>;
        <D.13666>:
        iftmp.101 = __builtin_strcmp (val, "mono");
        <D.13703>:
        D.12163 = iftmp.101;
      }
      if (D.12163 == 0) goto <D.13704>; else goto <D.13705>;
      <D.13704>:
      do_mono_sample = 1;
      sample_type = 1;
      free (val);
      return;
      <D.13705>:
      smode = &sample_modes;
      goto <D.12176>;
      <D.12175>:
      {
        int l;

        D.13706 = smode->name;
        D.13707 = strlen (D.13706);
        l = (int) D.13707;
        D.13708 = (long unsigned int) l;
        D.13706 = smode->name;
        D.13709 = strncmp (val, D.13706, D.13708);
        if (D.13709 == 0) goto <D.13710>; else goto <D.13711>;
        <D.13710>:
        sample_type.102 = smode->sample_mode;
        sample_type = sample_type.102;
        D.13713 = (sizetype) l;
        maybe_freq = val + D.13713;
        goto <D.12174>;
        <D.13711>:
      }
      smode = smode + 16;
      <D.12176>:
      D.13706 = smode->name;
      if (D.13706 != 0B) goto <D.12175>; else goto <D.12174>;
      <D.12174>:
      D.13706 = smode->name;
      if (D.13706 == 0B) goto <D.13714>; else goto <D.13715>;
      <D.13714>:
      usage (1);
      <D.13715>:
      D.13716 = *maybe_freq;
      if (D.13716 == 47) goto <D.13717>; else goto <D.13718>;
      <D.13717>:
      D.13719 = maybe_freq + 1;
      D.13720 = strtoul (D.13719, &end, 10);
      count = (unsigned int) D.13720;
      D.13719 = maybe_freq + 1;
      end.103 = end;
      if (D.13719 == end.103) goto <D.13722>; else goto <D.13723>;
      <D.13722>:
      usage (1);
      <D.13723>:
      count.104 = (int) count;
      sample_freq = count.104;
      goto <D.13725>;
      <D.13718>:
      D.13716 = *maybe_freq;
      if (D.13716 != 0) goto <D.13726>; else goto <D.13727>;
      <D.13726>:
      usage (1);
      goto <D.13728>;
      <D.13727>:
      sample_freq = 1000;
      <D.13728>:
      <D.13725>:
      free (val);
    }
  finally
    {
      end = {CLOBBER};
    }
}


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

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


set_hsmode (char * val, int allow_empty)
{
  _Bool D.13736;
  _Bool D.13737;
  _Bool D.13738;
  int D.12191;
  int iftmp.105;
  int D.12190;
  const char[9] * D.13744;
  unsigned char D.13745;
  int D.13746;
  unsigned char D.13747;
  int D.13748;
  _Bool D.13749;
  _Bool D.13750;
  _Bool D.13751;
  const unsigned char * D.13754;
  unsigned char D.13755;
  int D.13756;
  const unsigned char * D.13757;
  unsigned char D.13758;
  int D.13759;
  _Bool D.13760;
  _Bool D.13761;
  const unsigned char * D.13764;
  unsigned char D.13765;
  int D.13766;
  const unsigned char * D.13767;
  unsigned char D.13768;
  int D.13769;
  _Bool D.13770;
  _Bool D.13771;
  const unsigned char * D.13774;
  unsigned char D.13775;
  int D.13776;
  const unsigned char * D.13777;
  unsigned char D.13778;
  int D.13779;
  long unsigned int D.13783;
  char * end.106;
  int D.12200;
  int iftmp.107;
  int D.12199;
  const char[3] * D.13790;
  unsigned char D.13791;
  int D.13792;
  unsigned char D.13793;
  int D.13794;
  _Bool D.13795;
  _Bool D.13796;
  _Bool D.13797;
  const unsigned char * D.13800;
  unsigned char D.13801;
  int D.13802;
  const unsigned char * D.13803;
  unsigned char D.13804;
  int D.13805;
  _Bool D.13806;
  _Bool D.13807;
  const unsigned char * D.13810;
  unsigned char D.13811;
  int D.13812;
  const unsigned char * D.13813;
  unsigned char D.13814;
  int D.13815;
  _Bool D.13816;
  _Bool D.13817;
  const unsigned char * D.13820;
  unsigned char D.13821;
  int D.13822;
  const unsigned char * D.13823;
  unsigned char D.13824;
  int D.13825;
  int D.12209;
  int iftmp.108;
  int D.12208;
  const char[3] * D.13833;
  unsigned char D.13834;
  int D.13835;
  unsigned char D.13836;
  int D.13837;
  _Bool D.13838;
  _Bool D.13839;
  _Bool D.13840;
  const unsigned char * D.13843;
  unsigned char D.13844;
  int D.13845;
  const unsigned char * D.13846;
  unsigned char D.13847;
  int D.13848;
  _Bool D.13849;
  _Bool D.13850;
  const unsigned char * D.13853;
  unsigned char D.13854;
  int D.13855;
  const unsigned char * D.13856;
  unsigned char D.13857;
  int D.13858;
  _Bool D.13859;
  _Bool D.13860;
  const unsigned char * D.13863;
  unsigned char D.13864;
  int D.13865;
  const unsigned char * D.13866;
  unsigned char D.13867;
  int D.13868;
  char * end;
  unsigned int count;

  try
    {
      D.13736 = allow_empty != 0;
      D.13737 = val == 0B;
      D.13738 = D.13736 & D.13737;
      if (D.13738 != 0) goto <D.13739>; else goto <D.13740>;
      <D.13739>:
      return;
      <D.13740>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = val;
          D.13744 = "ondemand";
          D.13745 = MEM[(const unsigned char *)D.13744];
          D.13746 = (int) D.13745;
          D.13747 = *__s2;
          D.13748 = (int) D.13747;
          __result = D.13746 - D.13748;
          {
            D.13749 = __s2_len != 0;
            D.13750 = __result == 0;
            D.13751 = D.13749 & D.13750;
            if (D.13751 != 0) goto <D.13752>; else goto <D.13753>;
            <D.13752>:
            D.13754 = &MEM[(void *)"ondemand" + 1B];
            D.13755 = *D.13754;
            D.13756 = (int) D.13755;
            D.13757 = __s2 + 1;
            D.13758 = *D.13757;
            D.13759 = (int) D.13758;
            __result = D.13756 - D.13759;
            D.13760 = __s2_len > 1;
            D.13750 = __result == 0;
            D.13761 = D.13760 & D.13750;
            if (D.13761 != 0) goto <D.13762>; else goto <D.13763>;
            <D.13762>:
            D.13764 = &MEM[(void *)"ondemand" + 2B];
            D.13765 = *D.13764;
            D.13766 = (int) D.13765;
            D.13767 = __s2 + 2;
            D.13768 = *D.13767;
            D.13769 = (int) D.13768;
            __result = D.13766 - D.13769;
            D.13770 = __s2_len > 2;
            D.13750 = __result == 0;
            D.13771 = D.13770 & D.13750;
            if (D.13771 != 0) goto <D.13772>; else goto <D.13773>;
            <D.13772>:
            D.13774 = &MEM[(void *)"ondemand" + 3B];
            D.13775 = *D.13774;
            D.13776 = (int) D.13775;
            D.13777 = __s2 + 3;
            D.13778 = *D.13777;
            D.13779 = (int) D.13778;
            __result = D.13776 - D.13779;
            <D.13773>:
            <D.13763>:
            <D.13753>:
          }
          D.12190 = __result;
        }
        iftmp.105 = -D.12190;
        goto <D.13780>;
        <D.13743>:
        iftmp.105 = __builtin_strcmp (val, "ondemand");
        <D.13780>:
        D.12191 = iftmp.105;
      }
      if (D.12191 == 0) goto <D.13781>; else goto <D.13782>;
      <D.13781>:
      hs_mode_ondemand = 1;
      free (val);
      return;
      <D.13782>:
      D.13783 = strtoul (val, &end, 10);
      count = (unsigned int) D.13783;
      end.106 = end;
      if (val == end.106) goto <D.13785>; else goto <D.13786>;
      <D.13785>:
      usage (1);
      <D.13786>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = end;
          D.13790 = "ms";
          D.13791 = MEM[(const unsigned char *)D.13790];
          D.13792 = (int) D.13791;
          D.13793 = *__s2;
          D.13794 = (int) D.13793;
          __result = D.13792 - D.13794;
          {
            D.13795 = __s2_len != 0;
            D.13796 = __result == 0;
            D.13797 = D.13795 & D.13796;
            if (D.13797 != 0) goto <D.13798>; else goto <D.13799>;
            <D.13798>:
            D.13800 = &MEM[(void *)"ms" + 1B];
            D.13801 = *D.13800;
            D.13802 = (int) D.13801;
            D.13803 = __s2 + 1;
            D.13804 = *D.13803;
            D.13805 = (int) D.13804;
            __result = D.13802 - D.13805;
            D.13806 = __s2_len > 1;
            D.13796 = __result == 0;
            D.13807 = D.13806 & D.13796;
            if (D.13807 != 0) goto <D.13808>; else goto <D.13809>;
            <D.13808>:
            D.13810 = &MEM[(void *)"ms" + 2B];
            D.13811 = *D.13810;
            D.13812 = (int) D.13811;
            D.13813 = __s2 + 2;
            D.13814 = *D.13813;
            D.13815 = (int) D.13814;
            __result = D.13812 - D.13815;
            D.13816 = __s2_len > 2;
            D.13796 = __result == 0;
            D.13817 = D.13816 & D.13796;
            if (D.13817 != 0) goto <D.13818>; else goto <D.13819>;
            <D.13818>:
            D.13820 = &MEM[(void *)"ms" + 3B];
            D.13821 = *D.13820;
            D.13822 = (int) D.13821;
            D.13823 = __s2 + 3;
            D.13824 = *D.13823;
            D.13825 = (int) D.13824;
            __result = D.13822 - D.13825;
            <D.13819>:
            <D.13809>:
            <D.13799>:
          }
          D.12199 = __result;
        }
        iftmp.107 = -D.12199;
        goto <D.13826>;
        <D.13789>:
        end.106 = end;
        iftmp.107 = __builtin_strcmp (end.106, "ms");
        <D.13826>:
        D.12200 = iftmp.107;
      }
      if (D.12200 == 0) goto <D.13827>; else goto <D.13828>;
      <D.13827>:
      hs_mode_ms = count;
      goto <D.13829>;
      <D.13828>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = end;
          D.13833 = "gc";
          D.13834 = MEM[(const unsigned char *)D.13833];
          D.13835 = (int) D.13834;
          D.13836 = *__s2;
          D.13837 = (int) D.13836;
          __result = D.13835 - D.13837;
          {
            D.13838 = __s2_len != 0;
            D.13839 = __result == 0;
            D.13840 = D.13838 & D.13839;
            if (D.13840 != 0) goto <D.13841>; else goto <D.13842>;
            <D.13841>:
            D.13843 = &MEM[(void *)"gc" + 1B];
            D.13844 = *D.13843;
            D.13845 = (int) D.13844;
            D.13846 = __s2 + 1;
            D.13847 = *D.13846;
            D.13848 = (int) D.13847;
            __result = D.13845 - D.13848;
            D.13849 = __s2_len > 1;
            D.13839 = __result == 0;
            D.13850 = D.13849 & D.13839;
            if (D.13850 != 0) goto <D.13851>; else goto <D.13852>;
            <D.13851>:
            D.13853 = &MEM[(void *)"gc" + 2B];
            D.13854 = *D.13853;
            D.13855 = (int) D.13854;
            D.13856 = __s2 + 2;
            D.13857 = *D.13856;
            D.13858 = (int) D.13857;
            __result = D.13855 - D.13858;
            D.13859 = __s2_len > 2;
            D.13839 = __result == 0;
            D.13860 = D.13859 & D.13839;
            if (D.13860 != 0) goto <D.13861>; else goto <D.13862>;
            <D.13861>:
            D.13863 = &MEM[(void *)"gc" + 3B];
            D.13864 = *D.13863;
            D.13865 = (int) D.13864;
            D.13866 = __s2 + 3;
            D.13867 = *D.13866;
            D.13868 = (int) D.13867;
            __result = D.13865 - D.13868;
            <D.13862>:
            <D.13852>:
            <D.13842>:
          }
          D.12208 = __result;
        }
        iftmp.108 = -D.12208;
        goto <D.13869>;
        <D.13832>:
        end.106 = end;
        iftmp.108 = __builtin_strcmp (end.106, "gc");
        <D.13869>:
        D.12209 = iftmp.108;
      }
      if (D.12209 == 0) goto <D.13870>; else goto <D.13871>;
      <D.13870>:
      hs_mode_gc = count;
      goto <D.13872>;
      <D.13871>:
      usage (1);
      <D.13872>:
      <D.13829>:
      free (val);
    }
  finally
    {
      end = {CLOBBER};
    }
}


match_option (const char * p, const char * opt, char * * rval)
{
  long unsigned int D.13877;
  long unsigned int D.13878;
  int D.13879;
  sizetype D.13884;
  const char * D.13885;
  char D.13886;
  sizetype D.13889;
  const char * D.13890;
  char D.13891;
  long unsigned int D.13896;
  long int end.109;
  long int opt.110;
  long int D.13900;
  int D.13901;
  long unsigned int D.13902;
  long unsigned int D.13903;
  sizetype D.13904;
  char * D.13905;
  const char * D.13906;
  _Bool D.13907;
  _Bool D.13908;
  _Bool D.13909;
  long unsigned int D.13912;
  sizetype D.13913;
  int len;

  D.13877 = strlen (opt);
  len = (int) D.13877;
  D.13878 = (long unsigned int) len;
  D.13879 = strncmp (p, opt, D.13878);
  if (D.13879 == 0) goto <D.13880>; else goto <D.13881>;
  <D.13880>:
  if (rval != 0B) goto <D.13882>; else goto <D.13883>;
  <D.13882>:
  D.13884 = (sizetype) len;
  D.13885 = p + D.13884;
  D.13886 = *D.13885;
  if (D.13886 == 61) goto <D.13887>; else goto <D.13888>;
  <D.13887>:
  D.13884 = (sizetype) len;
  D.13889 = D.13884 + 1;
  D.13890 = p + D.13889;
  D.13891 = *D.13890;
  if (D.13891 != 0) goto <D.13892>; else goto <D.13893>;
  <D.13892>:
  {
    const char * opt;
    const char * end;
    char * val;
    int l;

    D.13884 = (sizetype) len;
    D.13889 = D.13884 + 1;
    opt = p + D.13889;
    end = __builtin_strchr (opt, 44);
    if (end == 0B) goto <D.13894>; else goto <D.13895>;
    <D.13894>:
    D.13896 = strlen (opt);
    l = (int) D.13896;
    goto <D.13897>;
    <D.13895>:
    end.109 = (long int) end;
    opt.110 = (long int) opt;
    D.13900 = end.109 - opt.110;
    l = (int) D.13900;
    <D.13897>:
    D.13901 = l + 1;
    D.13902 = (long unsigned int) D.13901;
    val = malloc (D.13902);
    D.13903 = (long unsigned int) l;
    memcpy (val, opt, D.13903);
    D.13904 = (sizetype) l;
    D.13905 = val + D.13904;
    *D.13905 = 0;
    *rval = val;
    D.13904 = (sizetype) l;
    D.13906 = opt + D.13904;
    return D.13906;
  }
  <D.13893>:
  <D.13888>:
  D.13884 = (sizetype) len;
  D.13885 = p + D.13884;
  D.13886 = *D.13885;
  D.13907 = D.13886 == 0;
  D.13884 = (sizetype) len;
  D.13885 = p + D.13884;
  D.13886 = *D.13885;
  D.13908 = D.13886 == 44;
  D.13909 = D.13907 | D.13908;
  if (D.13909 != 0) goto <D.13910>; else goto <D.13911>;
  <D.13910>:
  *rval = 0B;
  D.13884 = (sizetype) len;
  D.13884 = (sizetype) len;
  D.13885 = p + D.13884;
  D.13886 = *D.13885;
  D.13908 = D.13886 == 44;
  D.13912 = (long unsigned int) D.13908;
  D.13913 = D.13884 + D.13912;
  D.13906 = p + D.13913;
  return D.13906;
  <D.13911>:
  usage (1);
  goto <D.13914>;
  <D.13883>:
  D.13884 = (sizetype) len;
  D.13885 = p + D.13884;
  D.13886 = *D.13885;
  if (D.13886 == 0) goto <D.13915>; else goto <D.13916>;
  <D.13915>:
  D.13884 = (sizetype) len;
  D.13906 = p + D.13884;
  return D.13906;
  <D.13916>:
  D.13884 = (sizetype) len;
  D.13885 = p + D.13884;
  D.13886 = *D.13885;
  if (D.13886 == 44) goto <D.13917>; else goto <D.13918>;
  <D.13917>:
  D.13884 = (sizetype) len;
  D.13889 = D.13884 + 1;
  D.13906 = p + D.13889;
  return D.13906;
  <D.13918>:
  <D.13914>:
  <D.13881>:
  D.13906 = p;
  return D.13906;
}


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.13920>; else goto <D.13921>;
  <D.13920>:
  exit (1);
  <D.13921>:
}


create_profiler (const char * filename)
{
  int command_port.111;
  char D.13925;
  int do_report.112;
  long unsigned int D.13937;
  unsigned int D.13938;
  unsigned int D.13939;
  long unsigned int D.13940;
  char D.13941;
  const char * D.13944;
  struct FILE * D.13945;
  char * D.13949;
  long int D.13950;
  struct FILE * D.13951;
  struct _IO_FILE * stderr.113;
  struct MonoProfiler * D.13958;
  struct FILE * D.13959;
  struct FILE * D.13960;
  int use_zip.114;
  int D.13966;
  struct gzFile_s * D.13967;
  int sample_type.115;
  int do_mono_sample.116;
  struct PerfData * perf_data.117;
  struct StatBuffer * D.13979;
  unsigned int hs_mode_ondemand.118;
  int D.13984;
  long unsigned int D.13987;
  struct MonoProfiler * prof;
  char * nf;
  int force_delete;
  int need_helper_thread;

  force_delete = 0;
  need_helper_thread = 0;
  prof = calloc (1, 80);
  command_port.111 = command_port;
  prof->command_port = command_port.111;
  if (filename != 0B) goto <D.13923>; else goto <D.13924>;
  <D.13923>:
  D.13925 = *filename;
  if (D.13925 == 45) goto <D.13926>; else goto <D.13927>;
  <D.13926>:
  force_delete = 1;
  filename = filename + 1;
  <D.13927>:
  <D.13924>:
  if (filename == 0B) goto <D.13928>; else goto <D.13929>;
  <D.13928>:
  do_report.112 = do_report;
  if (do_report.112 != 0) goto <D.13931>; else goto <D.13932>;
  <D.13931>:
  filename = "|mprof-report -";
  goto <D.13933>;
  <D.13932>:
  filename = "output.mlpd";
  <D.13933>:
  nf = filename;
  goto <D.13934>;
  <D.13929>:
  nf = new_filename (filename);
  do_report.112 = do_report;
  if (do_report.112 != 0) goto <D.13935>; else goto <D.13936>;
  <D.13935>:
  {
    int s;
    char * p;

    D.13937 = strlen (nf);
    D.13938 = (unsigned int) D.13937;
    D.13939 = D.13938 + 32;
    s = (int) D.13939;
    D.13940 = (long unsigned int) s;
    p = malloc (D.13940);
    D.13940 = (long unsigned int) s;
    snprintf (p, D.13940, "|mprof-report \'--out=%s\' -", nf);
    free (nf);
    nf = p;
  }
  <D.13936>:
  <D.13934>:
  D.13941 = *nf;
  if (D.13941 == 124) goto <D.13942>; else goto <D.13943>;
  <D.13942>:
  D.13944 = nf + 1;
  D.13945 = popen (D.13944, "w");
  prof->file = D.13945;
  prof->pipe_output = 1;
  goto <D.13946>;
  <D.13943>:
  D.13941 = *nf;
  if (D.13941 == 35) goto <D.13947>; else goto <D.13948>;
  <D.13947>:
  {
    int fd;

    D.13949 = nf + 1;
    D.13950 = strtol (D.13949, 0B, 10);
    fd = (int) D.13950;
    D.13951 = fdopen (fd, "a");
    prof->file = D.13951;
  }
  goto <D.13952>;
  <D.13948>:
  {
    struct FILE * f;

    if (force_delete != 0) goto <D.13953>; else goto <D.13954>;
    <D.13953>:
    unlink (nf);
    <D.13954>:
    f = fopen (nf, "r");
    if (f != 0B) goto <D.13955>; else goto <D.13956>;
    <D.13955>:
    fclose (f);
    stderr.113 = stderr;
    fprintf (stderr.113, "The Mono profiler won\'t overwrite existing filename: %s.\n", nf);
    stderr.113 = stderr;
    fprintf (stderr.113, "Profiling disabled: use a different name or -FILENAME to force overwrite.\n");
    free (prof);
    D.13958 = 0B;
    return D.13958;
    <D.13956>:
    D.13959 = fopen (nf, "wb");
    prof->file = D.13959;
  }
  <D.13952>:
  <D.13946>:
  D.13960 = prof->file;
  if (D.13960 == 0B) goto <D.13961>; else goto <D.13962>;
  <D.13961>:
  stderr.113 = stderr;
  fprintf (stderr.113, "Cannot create profiler output: %s\n", nf);
  exit (1);
  <D.13962>:
  use_zip.114 = use_zip;
  if (use_zip.114 != 0) goto <D.13964>; else goto <D.13965>;
  <D.13964>:
  D.13960 = prof->file;
  D.13966 = fileno (D.13960);
  D.13967 = gzdopen (D.13966, "wb");
  prof->gzfile = D.13967;
  <D.13965>:
  sample_type.115 = sample_type;
  if (sample_type.115 != 0) goto <D.13969>; else goto <D.13970>;
  <D.13969>:
  do_mono_sample.116 = do_mono_sample;
  if (do_mono_sample.116 == 0) goto <D.13972>; else goto <D.13973>;
  <D.13972>:
  need_helper_thread = setup_perf_event ();
  <D.13973>:
  <D.13970>:
  perf_data.117 = perf_data;
  if (perf_data.117 == 0B) goto <D.13975>; else goto <D.13976>;
  <D.13975>:
  do_mono_sample = 1;
  <D.13976>:
  do_mono_sample.116 = do_mono_sample;
  if (do_mono_sample.116 != 0) goto <D.13977>; else goto <D.13978>;
  <D.13977>:
  D.13979 = create_stat_buffer ();
  prof->stat_buffers = D.13979;
  need_helper_thread = 1;
  <D.13978>:
  hs_mode_ondemand.118 = hs_mode_ondemand;
  if (hs_mode_ondemand.118 != 0) goto <D.13980>; else goto <D.13983>;
  <D.13983>:
  if (need_helper_thread != 0) goto <D.13980>; else goto <D.13981>;
  <D.13980>:
  D.13984 = start_helper_thread (prof);
  if (D.13984 == 0) goto <D.13985>; else goto <D.13986>;
  <D.13985>:
  prof->command_port = 0;
  <D.13986>:
  <D.13981>:
  D.13987 = current_time ();
  prof->startup_time = D.13987;
  dump_header (prof);
  D.13958 = prof;
  return D.13958;
}


new_filename (const char * filename)
{
  long int t.119;
  long unsigned int D.13999;
  char D.14000;
  int D.14010;
  char * D.14013;
  int D.14014;
  int D.14015;
  int D.14016;
  int D.14017;
  int D.14018;
  int D.14019;
  int D.14020;
  int D.14021;
  long unsigned int D.14022;
  long unsigned int D.14023;
  long unsigned int D.14024;
  int D.14025;
  long unsigned int D.14026;
  long unsigned int D.14027;
  int D.14028;
  long unsigned int D.14029;
  long unsigned int D.14030;
  char * d.120;
  sizetype D.14036;
  sizetype D.14039;
  char * d.121;
  char * d.122;
  char * d.123;
  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.119 = time (0B);
      t = t.119;
      D.13999 = process_id ();
      pid = (int) D.13999;
      count_dates = 0;
      count_pids = 0;
      p = filename;
      goto <D.12032>;
      <D.12031>:
      D.14000 = *p;
      if (D.14000 != 37) goto <D.14001>; else goto <D.14002>;
      <D.14001>:
      // predicted unlikely by continue predictor.
      goto <D.12029>;
      <D.14002>:
      p = p + 1;
      D.14000 = *p;
      if (D.14000 == 116) goto <D.14003>; else goto <D.14004>;
      <D.14003>:
      count_dates = count_dates + 1;
      goto <D.14005>;
      <D.14004>:
      D.14000 = *p;
      if (D.14000 == 112) goto <D.14006>; else goto <D.14007>;
      <D.14006>:
      count_pids = count_pids + 1;
      goto <D.14008>;
      <D.14007>:
      D.14000 = *p;
      if (D.14000 == 0) goto <D.12030>; else goto <D.14009>;
      <D.14009>:
      <D.14008>:
      <D.14005>:
      <D.12029>:
      p = p + 1;
      <D.12032>:
      D.14000 = *p;
      if (D.14000 != 0) goto <D.12031>; else goto <D.12030>;
      <D.12030>:
      D.14010 = count_dates | count_pids;
      if (D.14010 == 0) goto <D.14011>; else goto <D.14012>;
      <D.14011>:
      D.14013 = pstrdup (filename);
      return D.14013;
      <D.14012>:
      snprintf (&pid_buf, 16, "%d", pid);
      ts = gmtime (&t);
      D.14014 = ts->tm_sec;
      D.14015 = ts->tm_min;
      D.14016 = ts->tm_hour;
      D.14017 = ts->tm_mday;
      D.14018 = ts->tm_mon;
      D.14019 = D.14018 + 1;
      D.14020 = ts->tm_year;
      D.14021 = D.14020 + 1900;
      snprintf (&time_buf, 16, "%d%02d%02d%02d%02d%02d", D.14021, D.14019, D.14017, D.14016, D.14015, D.14014);
      D.14022 = strlen (&time_buf);
      s_date = (int) D.14022;
      D.14023 = strlen (&pid_buf);
      s_pid = (int) D.14023;
      D.14024 = strlen (filename);
      D.14025 = s_date * count_dates;
      D.14026 = (long unsigned int) D.14025;
      D.14027 = D.14024 + D.14026;
      D.14028 = s_pid * count_pids;
      D.14029 = (long unsigned int) D.14028;
      D.14030 = D.14027 + D.14029;
      res = malloc (D.14030);
      d = res;
      p = filename;
      goto <D.12036>;
      <D.12035>:
      D.14000 = *p;
      if (D.14000 != 37) goto <D.14031>; else goto <D.14032>;
      <D.14031>:
      d.120 = d;
      d = d.120 + 1;
      D.14000 = *p;
      *d.120 = D.14000;
      // predicted unlikely by continue predictor.
      goto <D.12033>;
      <D.14032>:
      p = p + 1;
      D.14000 = *p;
      if (D.14000 == 116) goto <D.14034>; else goto <D.14035>;
      <D.14034>:
      strcpy (d, &time_buf);
      D.14036 = (sizetype) s_date;
      d = d + D.14036;
      // predicted unlikely by continue predictor.
      goto <D.12033>;
      <D.14035>:
      D.14000 = *p;
      if (D.14000 == 112) goto <D.14037>; else goto <D.14038>;
      <D.14037>:
      strcpy (d, &pid_buf);
      D.14039 = (sizetype) s_pid;
      d = d + D.14039;
      // predicted unlikely by continue predictor.
      goto <D.12033>;
      <D.14038>:
      D.14000 = *p;
      if (D.14000 == 37) goto <D.14040>; else goto <D.14041>;
      <D.14040>:
      d.121 = d;
      d = d.121 + 1;
      *d.121 = 37;
      // predicted unlikely by continue predictor.
      goto <D.12033>;
      <D.14041>:
      D.14000 = *p;
      if (D.14000 == 0) goto <D.12034>; else goto <D.14043>;
      <D.14043>:
      d.122 = d;
      d = d.122 + 1;
      *d.122 = 37;
      d.123 = d;
      d = d.123 + 1;
      D.14000 = *p;
      *d.123 = D.14000;
      <D.12033>:
      p = p + 1;
      <D.12036>:
      D.14000 = *p;
      if (D.14000 != 0) goto <D.12035>; else goto <D.12034>;
      <D.12034>:
      *d = 0;
      D.14013 = res;
      return D.14013;
    }
  finally
    {
      t = {CLOBBER};
      pid_buf = {CLOBBER};
      time_buf = {CLOBBER};
    }
}


setup_perf_event ()
{
  int D.14051;
  int num_pages.124;
  int D.14053;
  int D.14054;
  unsigned int mmap_mask.125;
  int num_perf.126;
  int num_perf.127;
  long unsigned int D.14058;
  void * perf_data.128;
  struct PerfData * perf_data.129;
  long unsigned int D.14061;
  long unsigned int D.14062;
  struct PerfData * D.14063;
  int D.14064;
  int D.14067;
  int i;
  int count;

  count = 0;
  D.14051 = getpagesize ();
  num_pages.124 = num_pages;
  D.14053 = D.14051 * num_pages.124;
  D.14054 = D.14053 + -1;
  mmap_mask.125 = (unsigned int) D.14054;
  mmap_mask = mmap_mask.125;
  num_perf.126 = mono_cpu_count ();
  num_perf = num_perf.126;
  num_perf.127 = num_perf;
  D.14058 = (long unsigned int) num_perf.127;
  perf_data.128 = calloc (D.14058, 24);
  perf_data = perf_data.128;
  i = 0;
  goto <D.12003>;
  <D.12002>:
  perf_data.129 = perf_data;
  D.14061 = (long unsigned int) i;
  D.14062 = D.14061 * 24;
  D.14063 = perf_data.129 + D.14062;
  D.14064 = setup_perf_event_for_cpu (D.14063, i);
  count = D.14064 + count;
  i = i + 1;
  <D.12003>:
  num_perf.127 = num_perf;
  if (i < num_perf.127) goto <D.12002>; else goto <D.12004>;
  <D.12004>:
  if (count != 0) goto <D.14065>; else goto <D.14066>;
  <D.14065>:
  D.14067 = 1;
  return D.14067;
  <D.14066>:
  perf_data.129 = perf_data;
  free (perf_data.129);
  perf_data = 0B;
  D.14067 = 0;
  return D.14067;
}


mono_cpu_count ()
{
  long int D.14071;
  int D.14074;
  int count;

  count = 0;
  D.14071 = sysconf (84);
  count = (int) D.14071;
  if (count > 0) goto <D.14072>; else goto <D.14073>;
  <D.14072>:
  D.14074 = count;
  return D.14074;
  <D.14073>:
  D.14074 = 1;
  return D.14074;
}


setup_perf_event_for_cpu (struct PerfData * perf, int cpu)
{
  int sample_type.130;
  int sample_freq.131;
  long long unsigned int D.14078;
  int D.14079;
  int D.14080;
  int do_debug.132;
  long long unsigned int D.14084;
  int D.14085;
  struct _IO_FILE * stderr.133;
  int D.14094;
  int D.14095;
  struct perf_event_attr attr;

  try
    {
      memset (&attr, 0, 72);
      attr.type = 0;
      sample_type.130 = sample_type;
      switch (sample_type.130) <default: <D.11996>, case 1: <D.11989>, case 2: <D.11991>, case 3: <D.11992>, case 4: <D.11993>, case 5: <D.11994>, case 6: <D.11995>>
      <D.11989>:
      attr.config = 0;
      goto <D.11990>;
      <D.11991>:
      attr.config = 1;
      goto <D.11990>;
      <D.11992>:
      attr.config = 3;
      goto <D.11990>;
      <D.11993>:
      attr.config = 2;
      goto <D.11990>;
      <D.11994>:
      attr.config = 4;
      goto <D.11990>;
      <D.11995>:
      attr.config = 5;
      goto <D.11990>;
      <D.11996>:
      attr.config = 0;
      goto <D.11990>;
      <D.11990>:
      attr.sample_type = 263;
      attr.read_format = 7;
      attr.inherit = 1;
      attr.freq = 1;
      sample_freq.131 = sample_freq;
      D.14078 = (long long unsigned int) sample_freq.131;
      attr.D.11339.sample_freq = D.14078;
      D.14079 = getpid ();
      D.14080 = perf_event_syscall (&attr, D.14079, cpu, -1, 0);
      perf->perf_fd = D.14080;
      do_debug.132 = do_debug;
      if (do_debug.132 != 0) goto <D.14082>; else goto <D.14083>;
      <D.14082>:
      D.14084 = attr.config;
      sample_freq.131 = sample_freq;
      D.14085 = perf->perf_fd;
      printf ("perf fd: %d, freq: %d, event: %llu\n", D.14085, sample_freq.131, D.14084);
      <D.14083>:
      D.14085 = perf->perf_fd;
      if (D.14085 < 0) goto <D.14086>; else goto <D.14087>;
      <D.14086>:
      D.14085 = perf->perf_fd;
      if (D.14085 == -1) goto <D.14088>; else goto <D.14089>;
      <D.14088>:
      stderr.133 = stderr;
      fprintf (stderr.133, "Perf syscall denied, do \"echo 1 > /proc/sys/kernel/perf_event_paranoid\" as root to enable.\n");
      goto <D.14091>;
      <D.14089>:
      do_debug.132 = do_debug;
      if (do_debug.132 != 0) goto <D.14092>; else goto <D.14093>;
      <D.14092>:
      perror ("open perf event");
      <D.14093>:
      <D.14091>:
      D.14094 = 0;
      return D.14094;
      <D.14087>:
      D.14095 = setup_perf_map (perf);
      if (D.14095 == 0) goto <D.14096>; else goto <D.14097>;
      <D.14096>:
      D.14085 = perf->perf_fd;
      close (D.14085);
      perf->perf_fd = -1;
      D.14094 = 0;
      return D.14094;
      <D.14097>:
      D.14094 = 1;
      return D.14094;
    }
  finally
    {
      attr = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.14105;
  int D.14110;
  void * D.14112;
  long unsigned int D.14113;

  D.14105 = __builtin_constant_p (__len);
  if (D.14105 != 0) goto <D.14106>; else goto <D.14107>;
  <D.14106>:
  if (__len == 0) goto <D.14108>; else goto <D.14109>;
  <D.14108>:
  D.14110 = __builtin_constant_p (__ch);
  if (D.14110 == 0) goto <D.14103>; else goto <D.14111>;
  <D.14111>:
  if (__ch != 0) goto <D.14103>; else goto <D.14104>;
  <D.14103>:
  __warn_memset_zero_len ();
  D.14112 = __dest;
  return D.14112;
  <D.14104>:
  <D.14109>:
  <D.14107>:
  D.14113 = __builtin_object_size (__dest, 0);
  D.14112 = __builtin___memset_chk (__dest, __ch, __len, D.14113);
  return D.14112;
}


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

  attr->size = 64;
  D.14116 = syscall (298, attr, pid, cpu, group_fd, flags);
  D.14115 = (int) D.14116;
  return D.14115;
}


setup_perf_map (struct PerfData * perf)
{
  int D.14118;
  int num_pages.134;
  int D.14120;
  int D.14121;
  int D.14122;
  long unsigned int D.14123;
  void * D.14124;
  void * D.14125;
  int do_debug.135;
  int D.14131;
  struct perf_event_mmap_page * D.14134;
  unsigned int D.14135;

  D.14118 = perf->perf_fd;
  num_pages.134 = num_pages;
  D.14120 = num_pages.134 + 1;
  D.14121 = getpagesize ();
  D.14122 = D.14120 * D.14121;
  D.14123 = (long unsigned int) D.14122;
  D.14124 = mmap (0B, D.14123, 3, 1, D.14118, 0);
  perf->mmap_base = D.14124;
  D.14125 = perf->mmap_base;
  if (D.14125 == -1B) goto <D.14126>; else goto <D.14127>;
  <D.14126>:
  do_debug.135 = do_debug;
  if (do_debug.135 != 0) goto <D.14129>; else goto <D.14130>;
  <D.14129>:
  printf ("failed mmap\n");
  <D.14130>:
  D.14131 = 0;
  return D.14131;
  <D.14127>:
  D.14125 = perf->mmap_base;
  perf->page_desc = D.14125;
  do_debug.135 = do_debug;
  if (do_debug.135 != 0) goto <D.14132>; else goto <D.14133>;
  <D.14132>:
  D.14134 = perf->page_desc;
  D.14135 = D.14134->version;
  printf ("mmap version: %d\n", D.14135);
  <D.14133>:
  D.14131 = 1;
  return D.14131;
}


start_helper_thread (struct MonoProfiler * prof)
{
  int[2] * D.14137;
  int D.14138;
  struct _IO_FILE * stderr.136;
  int D.14142;
  int D.14143;
  int D.14144;
  short unsigned int D.12105;
  int D.14147;
  int D.14148;
  int D.14149;
  short unsigned int D.14152;
  signed short D.14153;
  int D.14154;
  signed short D.14155;
  signed short D.14156;
  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.14158;
  int D.14159;
  int * D.14162;
  int D.14163;
  char * D.14164;
  int D.14165;
  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.14168;
  int D.14169;
  short unsigned int D.12108;
  int D.14172;
  int D.14173;
  short unsigned int D.14176;
  signed short D.14177;
  int D.14178;
  signed short D.14179;
  signed short D.14180;
  int D.14182;
  pthread_t * D.14183;
  struct sockaddr_in server_address;
  int r;
  socklen_t slen;

  try
    {
      D.14137 = &prof->pipes;
      D.14138 = pipe (D.14137);
      if (D.14138 < 0) goto <D.14139>; else goto <D.14140>;
      <D.14139>:
      stderr.136 = stderr;
      fprintf (stderr.136, "Cannot create pipe\n");
      D.14142 = 0;
      return D.14142;
      <D.14140>:
      D.14143 = socket (2, 1, 0);
      prof->server_socket = D.14143;
      D.14144 = prof->server_socket;
      if (D.14144 < 0) goto <D.14145>; else goto <D.14146>;
      <D.14145>:
      stderr.136 = stderr;
      fprintf (stderr.136, "Cannot create server socket\n");
      D.14142 = 0;
      return D.14142;
      <D.14146>:
      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.14147 = prof->command_port;
        __x = (short unsigned int) D.14147;
        {
          D.14148 = (int) __x;
          D.14149 = __builtin_constant_p (D.14148);
          if (D.14149 != 0) goto <D.14150>; else goto <D.14151>;
          <D.14150>:
          D.14152 = __x >> 8;
          D.14153 = (signed short) D.14152;
          D.14148 = (int) __x;
          D.14154 = D.14148 << 8;
          D.14155 = (signed short) D.14154;
          D.14156 = D.14153 | D.14155;
          __v = (short unsigned int) D.14156;
          goto <D.14157>;
          <D.14151>:
          __asm__("rorw $8, %w0" : "=r" __v : "0" __x : "cc");
          <D.14157>:
        }
        D.12105 = __v;
      }
      server_address.sin_port = D.12105;
      D.14158.__sockaddr__ = &server_address;
      D.14144 = prof->server_socket;
      D.14159 = bind (D.14144, D.14158, 16);
      if (D.14159 < 0) goto <D.14160>; else goto <D.14161>;
      <D.14160>:
      D.14162 = __errno_location ();
      D.14163 = *D.14162;
      D.14164 = strerror (D.14163);
      D.14147 = prof->command_port;
      stderr.136 = stderr;
      fprintf (stderr.136, "Cannot bind server socket, port: %d: %s\n", D.14147, D.14164);
      D.14144 = prof->server_socket;
      close (D.14144);
      D.14142 = 0;
      return D.14142;
      <D.14161>:
      D.14144 = prof->server_socket;
      D.14165 = listen (D.14144, 1);
      if (D.14165 < 0) goto <D.14166>; else goto <D.14167>;
      <D.14166>:
      stderr.136 = stderr;
      fprintf (stderr.136, "Cannot listen server socket\n");
      D.14144 = prof->server_socket;
      close (D.14144);
      D.14142 = 0;
      return D.14142;
      <D.14167>:
      slen = 16;
      D.14168.__sockaddr__ = &server_address;
      D.14144 = prof->server_socket;
      D.14169 = getsockname (D.14144, D.14168, &slen);
      if (D.14169 == 0) goto <D.14170>; else goto <D.14171>;
      <D.14170>:
      {
        short unsigned int __v;
        short unsigned int __x;

        __x = server_address.sin_port;
        {
          D.14172 = (int) __x;
          D.14173 = __builtin_constant_p (D.14172);
          if (D.14173 != 0) goto <D.14174>; else goto <D.14175>;
          <D.14174>:
          D.14176 = __x >> 8;
          D.14177 = (signed short) D.14176;
          D.14172 = (int) __x;
          D.14178 = D.14172 << 8;
          D.14179 = (signed short) D.14178;
          D.14180 = D.14177 | D.14179;
          __v = (short unsigned int) D.14180;
          goto <D.14181>;
          <D.14175>:
          __asm__("rorw $8, %w0" : "=r" __v : "0" __x : "cc");
          <D.14181>:
        }
        D.12108 = __v;
      }
      D.14182 = (int) D.12108;
      prof->command_port = D.14182;
      <D.14171>:
      D.14183 = &prof->helper_thread;
      r = pthread_create (D.14183, 0B, helper_thread, prof);
      if (r != 0) goto <D.14184>; else goto <D.14185>;
      <D.14184>:
      D.14144 = prof->server_socket;
      close (D.14144);
      D.14142 = 0;
      return D.14142;
      <D.14185>:
      D.14142 = 1;
      return D.14142;
    }
  finally
    {
      server_address = {CLOBBER};
      slen = {CLOBBER};
    }
}


helper_thread (void * arg)
{
  long int D.12051;
  int D.14189;
  long int iftmp.137;
  int D.14191;
  long int iftmp.138;
  unsigned long __d.139;
  long int D.14200;
  long int D.14201;
  int D.14202;
  long int D.14203;
  long int D.14204;
  long int D.12053;
  int D.14205;
  long int iftmp.140;
  int D.14207;
  long int iftmp.141;
  unsigned long __d.142;
  long int D.14216;
  long int D.14217;
  int D.14218;
  long int D.14219;
  long int D.14220;
  long int D.12055;
  long int iftmp.143;
  int D.14226;
  long int iftmp.144;
  unsigned long __d.145;
  long int D.14235;
  long int D.14236;
  int D.14237;
  long int D.14238;
  long int D.14239;
  struct PerfData * perf_data.146;
  long unsigned int D.14245;
  long unsigned int D.14246;
  struct PerfData * D.14247;
  int D.14248;
  long int D.12059;
  long int iftmp.147;
  int D.14252;
  long int iftmp.148;
  unsigned long __d.149;
  long int D.14261;
  long int D.14262;
  int D.14263;
  long int D.14264;
  long int D.14265;
  int num_perf.150;
  int D.14269;
  int * D.14272;
  int D.14273;
  char * D.14276;
  void * D.14277;
  long int D.12065;
  long int iftmp.151;
  int D.14279;
  long int iftmp.152;
  unsigned long __d.153;
  long int D.14288;
  long int D.14289;
  long int D.14290;
  long int D.14293;
  char c.154;
  struct StatBuffer * D.14299;
  struct StatBuffer * D.14300;
  int do_debug.155;
  struct _IO_FILE * stderr.156;
  long unsigned int D.14305;
  int D.14306;
  long unsigned int D.14313;
  long unsigned int D.14314;
  struct PerfData * D.14315;
  int D.14316;
  long int D.12072;
  long int iftmp.157;
  int D.14320;
  long int iftmp.158;
  unsigned long __d.159;
  long int D.14329;
  int D.14330;
  long int D.14331;
  long int D.14332;
  struct LogBuffer * D.14335;
  long unsigned int D.14338;
  long unsigned int D.14339;
  struct PerfData * D.14340;
  int D.14341;
  long int D.12079;
  long int iftmp.160;
  int D.14345;
  long int iftmp.161;
  unsigned long __d.162;
  long int D.14354;
  int D.14355;
  long int D.14356;
  long int D.14357;
  struct LogBuffer * D.14360;
  long int D.12084;
  long int iftmp.163;
  int D.14364;
  long int iftmp.164;
  unsigned long __d.165;
  long int D.14373;
  long int D.14374;
  long int D.14375;
  long int D.14378;
  int D.12093;
  int iftmp.166;
  int D.12092;
  const char[10] * D.14386;
  unsigned char D.14387;
  int D.14388;
  unsigned char D.14389;
  int D.14390;
  _Bool D.14391;
  _Bool D.14392;
  _Bool D.14393;
  const unsigned char * D.14396;
  unsigned char D.14397;
  int D.14398;
  const unsigned char * D.14399;
  unsigned char D.14400;
  int D.14401;
  _Bool D.14402;
  _Bool D.14403;
  const unsigned char * D.14406;
  unsigned char D.14407;
  int D.14408;
  const unsigned char * D.14409;
  unsigned char D.14410;
  int D.14411;
  _Bool D.14412;
  _Bool D.14413;
  const unsigned char * D.14416;
  unsigned char D.14417;
  int D.14418;
  const unsigned char * D.14419;
  unsigned char D.14420;
  int D.14421;
  int runtime_inited.167;
  struct MonoDomain * D.14430;
  long int D.12095;
  long int iftmp.168;
  int D.14434;
  long int iftmp.169;
  unsigned long __d.170;
  long int D.14443;
  long int D.14444;
  long int D.14445;
  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.14448;
  struct MonoProfiler * prof;
  int command_socket;
  int len;
  char buf[64];
  struct MonoThread * thread;

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

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

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

              D.14189 = prof->server_socket;
              __d = (long int) D.14189;
              D.14191 = __builtin_constant_p (__d);
              if (D.14191 != 0) goto <D.14192>; else goto <D.14193>;
              <D.14192>:
              __d.139 = (unsigned long) __d;
              if (__d.139 <= 1023) goto <D.14196>; else goto <D.14197>;
              <D.14196>:
              iftmp.138 = __d / 64;
              goto <D.14198>;
              <D.14197>:
              iftmp.138 = __fdelt_warn (__d);
              <D.14198>:
              iftmp.137 = iftmp.138;
              goto <D.14199>;
              <D.14193>:
              iftmp.137 = __fdelt_chk (__d);
              <D.14199>:
              D.12051 = iftmp.137;
            }
            D.14200 = D.12051;
            D.14201 = rfds.fds_bits[D.14200];
            D.14189 = prof->server_socket;
            D.14202 = D.14189 % 64;
            D.14203 = 1 << D.14202;
            D.14204 = D.14201 | D.14203;
            rfds.fds_bits[D.14200] = D.14204;
            max_fd = prof->server_socket;
            {
              long int __d;

              D.14205 = prof->pipes[0];
              __d = (long int) D.14205;
              D.14207 = __builtin_constant_p (__d);
              if (D.14207 != 0) goto <D.14208>; else goto <D.14209>;
              <D.14208>:
              __d.142 = (unsigned long) __d;
              if (__d.142 <= 1023) goto <D.14212>; else goto <D.14213>;
              <D.14212>:
              iftmp.141 = __d / 64;
              goto <D.14214>;
              <D.14213>:
              iftmp.141 = __fdelt_warn (__d);
              <D.14214>:
              iftmp.140 = iftmp.141;
              goto <D.14215>;
              <D.14209>:
              iftmp.140 = __fdelt_chk (__d);
              <D.14215>:
              D.12053 = iftmp.140;
            }
            D.14216 = D.12053;
            D.14217 = rfds.fds_bits[D.14216];
            D.14205 = prof->pipes[0];
            D.14218 = D.14205 % 64;
            D.14219 = 1 << D.14218;
            D.14220 = D.14217 | D.14219;
            rfds.fds_bits[D.14216] = D.14220;
            D.14205 = prof->pipes[0];
            if (D.14205 > max_fd) goto <D.14221>; else goto <D.14222>;
            <D.14221>:
            max_fd = prof->pipes[0];
            <D.14222>:
            if (command_socket >= 0) goto <D.14223>; else goto <D.14224>;
            <D.14223>:
            {
              long int __d;

              __d = (long int) command_socket;
              D.14226 = __builtin_constant_p (__d);
              if (D.14226 != 0) goto <D.14227>; else goto <D.14228>;
              <D.14227>:
              __d.145 = (unsigned long) __d;
              if (__d.145 <= 1023) goto <D.14231>; else goto <D.14232>;
              <D.14231>:
              iftmp.144 = __d / 64;
              goto <D.14233>;
              <D.14232>:
              iftmp.144 = __fdelt_warn (__d);
              <D.14233>:
              iftmp.143 = iftmp.144;
              goto <D.14234>;
              <D.14228>:
              iftmp.143 = __fdelt_chk (__d);
              <D.14234>:
              D.12055 = iftmp.143;
            }
            D.14235 = D.12055;
            D.14236 = rfds.fds_bits[D.14235];
            D.14237 = command_socket % 64;
            D.14238 = 1 << D.14237;
            D.14239 = D.14236 | D.14238;
            rfds.fds_bits[D.14235] = D.14239;
            if (max_fd < command_socket) goto <D.14240>; else goto <D.14241>;
            <D.14240>:
            max_fd = command_socket;
            <D.14241>:
            <D.14224>:
            perf_data.146 = perf_data;
            if (perf_data.146 != 0B) goto <D.14243>; else goto <D.14244>;
            <D.14243>:
            {
              int i;

              i = 0;
              goto <D.12061>;
              <D.12060>:
              perf_data.146 = perf_data;
              D.14245 = (long unsigned int) i;
              D.14246 = D.14245 * 24;
              D.14247 = perf_data.146 + D.14246;
              D.14248 = D.14247->perf_fd;
              if (D.14248 < 0) goto <D.14249>; else goto <D.14250>;
              <D.14249>:
              // predicted unlikely by continue predictor.
              goto <D.12057>;
              <D.14250>:
              {
                long int __d;

                perf_data.146 = perf_data;
                D.14245 = (long unsigned int) i;
                D.14246 = D.14245 * 24;
                D.14247 = perf_data.146 + D.14246;
                D.14248 = D.14247->perf_fd;
                __d = (long int) D.14248;
                D.14252 = __builtin_constant_p (__d);
                if (D.14252 != 0) goto <D.14253>; else goto <D.14254>;
                <D.14253>:
                __d.149 = (unsigned long) __d;
                if (__d.149 <= 1023) goto <D.14257>; else goto <D.14258>;
                <D.14257>:
                iftmp.148 = __d / 64;
                goto <D.14259>;
                <D.14258>:
                iftmp.148 = __fdelt_warn (__d);
                <D.14259>:
                iftmp.147 = iftmp.148;
                goto <D.14260>;
                <D.14254>:
                iftmp.147 = __fdelt_chk (__d);
                <D.14260>:
                D.12059 = iftmp.147;
              }
              D.14261 = D.12059;
              D.14262 = rfds.fds_bits[D.14261];
              perf_data.146 = perf_data;
              D.14245 = (long unsigned int) i;
              D.14246 = D.14245 * 24;
              D.14247 = perf_data.146 + D.14246;
              D.14248 = D.14247->perf_fd;
              D.14263 = D.14248 % 64;
              D.14264 = 1 << D.14263;
              D.14265 = D.14262 | D.14264;
              rfds.fds_bits[D.14261] = D.14265;
              perf_data.146 = perf_data;
              D.14245 = (long unsigned int) i;
              D.14246 = D.14245 * 24;
              D.14247 = perf_data.146 + D.14246;
              D.14248 = D.14247->perf_fd;
              if (D.14248 > max_fd) goto <D.14266>; else goto <D.14267>;
              <D.14266>:
              perf_data.146 = perf_data;
              D.14245 = (long unsigned int) i;
              D.14246 = D.14245 * 24;
              D.14247 = perf_data.146 + D.14246;
              max_fd = D.14247->perf_fd;
              <D.14267>:
              <D.12057>:
              i = i + 1;
              <D.12061>:
              num_perf.150 = num_perf;
              if (i < num_perf.150) goto <D.12060>; else goto <D.12062>;
              <D.12062>:
            }
            <D.14244>:
            tv.tv_sec = 1;
            tv.tv_usec = 0;
            D.14269 = max_fd + 1;
            len = select (D.14269, &rfds, 0B, 0B, &tv);
            if (len < 0) goto <D.14270>; else goto <D.14271>;
            <D.14270>:
            D.14272 = __errno_location ();
            D.14273 = *D.14272;
            if (D.14273 == 4) goto <D.14274>; else goto <D.14275>;
            <D.14274>:
            // predicted unlikely by continue predictor.
            goto <D.12063>;
            <D.14275>:
            D.14272 = __errno_location ();
            D.14273 = *D.14272;
            D.14276 = strerror (D.14273);
            monoeg_g_log (0B, 16, "Error in proflog server: %s", D.14276);
            D.14277 = 0B;
            return D.14277;
            <D.14271>:
            {
              long int __d;

              D.14205 = prof->pipes[0];
              __d = (long int) D.14205;
              D.14279 = __builtin_constant_p (__d);
              if (D.14279 != 0) goto <D.14280>; else goto <D.14281>;
              <D.14280>:
              __d.153 = (unsigned long) __d;
              if (__d.153 <= 1023) goto <D.14284>; else goto <D.14285>;
              <D.14284>:
              iftmp.152 = __d / 64;
              goto <D.14286>;
              <D.14285>:
              iftmp.152 = __fdelt_warn (__d);
              <D.14286>:
              iftmp.151 = iftmp.152;
              goto <D.14287>;
              <D.14281>:
              iftmp.151 = __fdelt_chk (__d);
              <D.14287>:
              D.12065 = iftmp.151;
            }
            D.14288 = rfds.fds_bits[D.12065];
            D.14205 = prof->pipes[0];
            D.14218 = D.14205 % 64;
            D.14289 = D.14288 >> D.14218;
            D.14290 = D.14289 & 1;
            if (D.14290 != 0) goto <D.14291>; else goto <D.14292>;
            <D.14291>:
            {
              char c;
              int r;

              try
                {
                  D.14205 = prof->pipes[0];
                  D.14293 = read (D.14205, &c, 1);
                  r = (int) D.14293;
                  if (r == 1) goto <D.14294>; else goto <D.14295>;
                  <D.14294>:
                  c.154 = c;
                  if (c.154 == 0) goto <D.14297>; else goto <D.14298>;
                  <D.14297>:
                  {
                    struct StatBuffer * sbuf;

                    D.14299 = prof->stat_buffers;
                    D.14300 = D.14299->next;
                    sbuf = D.14300->next;
                    D.14299 = prof->stat_buffers;
                    D.14300 = D.14299->next;
                    D.14300->next = 0B;
                    do_debug.155 = do_debug;
                    if (do_debug.155 != 0) goto <D.14302>; else goto <D.14303>;
                    <D.14302>:
                    stderr.156 = stderr;
                    fprintf (stderr.156, "stat buffer dump\n");
                    <D.14303>:
                    dump_sample_hits (prof, sbuf, 1);
                    D.14305 = sbuf->size;
                    D.14306 = (int) D.14305;
                    free_buffer (sbuf, D.14306);
                    // predicted unlikely by continue predictor.
                    goto <D.12063>;
                  }
                  <D.14298>:
                  <D.14295>:
                  if (thread != 0B) goto <D.14307>; else goto <D.14308>;
                  <D.14307>:
                  mono_thread_detach (thread);
                  <D.14308>:
                  do_debug.155 = do_debug;
                  if (do_debug.155 != 0) goto <D.14309>; else goto <D.14310>;
                  <D.14309>:
                  stderr.156 = stderr;
                  fprintf (stderr.156, "helper shutdown\n");
                  <D.14310>:
                  perf_data.146 = perf_data;
                  if (perf_data.146 != 0B) goto <D.14311>; else goto <D.14312>;
                  <D.14311>:
                  {
                    int i;

                    i = 0;
                    goto <D.12074>;
                    <D.12073>:
                    perf_data.146 = perf_data;
                    D.14313 = (long unsigned int) i;
                    D.14314 = D.14313 * 24;
                    D.14315 = perf_data.146 + D.14314;
                    D.14316 = D.14315->perf_fd;
                    if (D.14316 < 0) goto <D.14317>; else goto <D.14318>;
                    <D.14317>:
                    // predicted unlikely by continue predictor.
                    goto <D.12070>;
                    <D.14318>:
                    {
                      long int __d;

                      perf_data.146 = perf_data;
                      D.14313 = (long unsigned int) i;
                      D.14314 = D.14313 * 24;
                      D.14315 = perf_data.146 + D.14314;
                      D.14316 = D.14315->perf_fd;
                      __d = (long int) D.14316;
                      D.14320 = __builtin_constant_p (__d);
                      if (D.14320 != 0) goto <D.14321>; else goto <D.14322>;
                      <D.14321>:
                      __d.159 = (unsigned long) __d;
                      if (__d.159 <= 1023) goto <D.14325>; else goto <D.14326>;
                      <D.14325>:
                      iftmp.158 = __d / 64;
                      goto <D.14327>;
                      <D.14326>:
                      iftmp.158 = __fdelt_warn (__d);
                      <D.14327>:
                      iftmp.157 = iftmp.158;
                      goto <D.14328>;
                      <D.14322>:
                      iftmp.157 = __fdelt_chk (__d);
                      <D.14328>:
                      D.12072 = iftmp.157;
                    }
                    D.14329 = rfds.fds_bits[D.12072];
                    perf_data.146 = perf_data;
                    D.14313 = (long unsigned int) i;
                    D.14314 = D.14313 * 24;
                    D.14315 = perf_data.146 + D.14314;
                    D.14316 = D.14315->perf_fd;
                    D.14330 = D.14316 % 64;
                    D.14331 = D.14329 >> D.14330;
                    D.14332 = D.14331 & 1;
                    if (D.14332 != 0) goto <D.14333>; else goto <D.14334>;
                    <D.14333>:
                    read_perf_mmap (prof, i);
                    <D.14334>:
                    <D.12070>:
                    i = i + 1;
                    <D.12074>:
                    num_perf.150 = num_perf;
                    if (i < num_perf.150) goto <D.12073>; else goto <D.12075>;
                    <D.12075>:
                  }
                  <D.14312>:
                  D.14335 = ensure_logbuf (0);
                  safe_dump (prof, D.14335);
                  D.14277 = 0B;
                  return D.14277;
                }
              finally
                {
                  c = {CLOBBER};
                }
            }
            <D.14292>:
            perf_data.146 = perf_data;
            if (perf_data.146 != 0B) goto <D.14336>; else goto <D.14337>;
            <D.14336>:
            {
              int i;

              i = 0;
              goto <D.12081>;
              <D.12080>:
              perf_data.146 = perf_data;
              D.14338 = (long unsigned int) i;
              D.14339 = D.14338 * 24;
              D.14340 = perf_data.146 + D.14339;
              D.14341 = D.14340->perf_fd;
              if (D.14341 < 0) goto <D.14342>; else goto <D.14343>;
              <D.14342>:
              // predicted unlikely by continue predictor.
              goto <D.12077>;
              <D.14343>:
              {
                long int __d;

                perf_data.146 = perf_data;
                D.14338 = (long unsigned int) i;
                D.14339 = D.14338 * 24;
                D.14340 = perf_data.146 + D.14339;
                D.14341 = D.14340->perf_fd;
                __d = (long int) D.14341;
                D.14345 = __builtin_constant_p (__d);
                if (D.14345 != 0) goto <D.14346>; else goto <D.14347>;
                <D.14346>:
                __d.162 = (unsigned long) __d;
                if (__d.162 <= 1023) goto <D.14350>; else goto <D.14351>;
                <D.14350>:
                iftmp.161 = __d / 64;
                goto <D.14352>;
                <D.14351>:
                iftmp.161 = __fdelt_warn (__d);
                <D.14352>:
                iftmp.160 = iftmp.161;
                goto <D.14353>;
                <D.14347>:
                iftmp.160 = __fdelt_chk (__d);
                <D.14353>:
                D.12079 = iftmp.160;
              }
              D.14354 = rfds.fds_bits[D.12079];
              perf_data.146 = perf_data;
              D.14338 = (long unsigned int) i;
              D.14339 = D.14338 * 24;
              D.14340 = perf_data.146 + D.14339;
              D.14341 = D.14340->perf_fd;
              D.14355 = D.14341 % 64;
              D.14356 = D.14354 >> D.14355;
              D.14357 = D.14356 & 1;
              if (D.14357 != 0) goto <D.14358>; else goto <D.14359>;
              <D.14358>:
              read_perf_mmap (prof, i);
              D.14360 = ensure_logbuf (0);
              safe_dump (prof, D.14360);
              <D.14359>:
              <D.12077>:
              i = i + 1;
              <D.12081>:
              num_perf.150 = num_perf;
              if (i < num_perf.150) goto <D.12080>; else goto <D.12082>;
              <D.12082>:
            }
            <D.14337>:
            if (command_socket >= 0) goto <D.14361>; else goto <D.14362>;
            <D.14361>:
            {
              long int __d;

              __d = (long int) command_socket;
              D.14364 = __builtin_constant_p (__d);
              if (D.14364 != 0) goto <D.14365>; else goto <D.14366>;
              <D.14365>:
              __d.165 = (unsigned long) __d;
              if (__d.165 <= 1023) goto <D.14369>; else goto <D.14370>;
              <D.14369>:
              iftmp.164 = __d / 64;
              goto <D.14371>;
              <D.14370>:
              iftmp.164 = __fdelt_warn (__d);
              <D.14371>:
              iftmp.163 = iftmp.164;
              goto <D.14372>;
              <D.14366>:
              iftmp.163 = __fdelt_chk (__d);
              <D.14372>:
              D.12084 = iftmp.163;
            }
            D.14373 = rfds.fds_bits[D.12084];
            D.14237 = command_socket % 64;
            D.14374 = D.14373 >> D.14237;
            D.14375 = D.14374 & 1;
            if (D.14375 != 0) goto <D.14376>; else goto <D.14377>;
            <D.14376>:
            D.14378 = read (command_socket, &buf, 63);
            len = (int) D.14378;
            if (len < 0) goto <D.14379>; else goto <D.14380>;
            <D.14379>:
            // predicted unlikely by continue predictor.
            goto <D.12063>;
            <D.14380>:
            if (len == 0) goto <D.14381>; else goto <D.14382>;
            <D.14381>:
            close (command_socket);
            command_socket = -1;
            // predicted unlikely by continue predictor.
            goto <D.12063>;
            <D.14382>:
            buf[len] = 0;
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = &buf;
                D.14386 = "heapshot\n";
                D.14387 = MEM[(const unsigned char *)D.14386];
                D.14388 = (int) D.14387;
                D.14389 = *__s2;
                D.14390 = (int) D.14389;
                __result = D.14388 - D.14390;
                {
                  D.14391 = __s2_len != 0;
                  D.14392 = __result == 0;
                  D.14393 = D.14391 & D.14392;
                  if (D.14393 != 0) goto <D.14394>; else goto <D.14395>;
                  <D.14394>:
                  D.14396 = &MEM[(void *)"heapshot\n" + 1B];
                  D.14397 = *D.14396;
                  D.14398 = (int) D.14397;
                  D.14399 = __s2 + 1;
                  D.14400 = *D.14399;
                  D.14401 = (int) D.14400;
                  __result = D.14398 - D.14401;
                  D.14402 = __s2_len > 1;
                  D.14392 = __result == 0;
                  D.14403 = D.14402 & D.14392;
                  if (D.14403 != 0) goto <D.14404>; else goto <D.14405>;
                  <D.14404>:
                  D.14406 = &MEM[(void *)"heapshot\n" + 2B];
                  D.14407 = *D.14406;
                  D.14408 = (int) D.14407;
                  D.14409 = __s2 + 2;
                  D.14410 = *D.14409;
                  D.14411 = (int) D.14410;
                  __result = D.14408 - D.14411;
                  D.14412 = __s2_len > 2;
                  D.14392 = __result == 0;
                  D.14413 = D.14412 & D.14392;
                  if (D.14413 != 0) goto <D.14414>; else goto <D.14415>;
                  <D.14414>:
                  D.14416 = &MEM[(void *)"heapshot\n" + 3B];
                  D.14417 = *D.14416;
                  D.14418 = (int) D.14417;
                  D.14419 = __s2 + 3;
                  D.14420 = *D.14419;
                  D.14421 = (int) D.14420;
                  __result = D.14418 - D.14421;
                  <D.14415>:
                  <D.14405>:
                  <D.14395>:
                }
                D.12092 = __result;
              }
              iftmp.166 = -D.12092;
              goto <D.14422>;
              <D.14385>:
              iftmp.166 = __builtin_strcmp (&buf, "heapshot\n");
              <D.14422>:
              D.12093 = iftmp.166;
            }
            if (D.12093 == 0) goto <D.14423>; else goto <D.14424>;
            <D.14423>:
            heapshot_requested = 1;
            runtime_inited.167 = runtime_inited;
            if (runtime_inited.167 != 0) goto <D.14426>; else goto <D.14427>;
            <D.14426>:
            if (thread == 0B) goto <D.14428>; else goto <D.14429>;
            <D.14428>:
            D.14430 = mono_get_root_domain ();
            thread = mono_thread_attach (D.14430);
            <D.14429>:
            <D.14427>:
            if (thread != 0B) goto <D.14431>; else goto <D.14432>;
            <D.14431>:
            process_requests (prof);
            mono_thread_detach (thread);
            thread = 0B;
            <D.14432>:
            <D.14424>:
            // predicted unlikely by continue predictor.
            goto <D.12063>;
            <D.14377>:
            <D.14362>:
            {
              long int __d;

              D.14189 = prof->server_socket;
              __d = (long int) D.14189;
              D.14434 = __builtin_constant_p (__d);
              if (D.14434 != 0) goto <D.14435>; else goto <D.14436>;
              <D.14435>:
              __d.170 = (unsigned long) __d;
              if (__d.170 <= 1023) goto <D.14439>; else goto <D.14440>;
              <D.14439>:
              iftmp.169 = __d / 64;
              goto <D.14441>;
              <D.14440>:
              iftmp.169 = __fdelt_warn (__d);
              <D.14441>:
              iftmp.168 = iftmp.169;
              goto <D.14442>;
              <D.14436>:
              iftmp.168 = __fdelt_chk (__d);
              <D.14442>:
              D.12095 = iftmp.168;
            }
            D.14443 = rfds.fds_bits[D.12095];
            D.14189 = prof->server_socket;
            D.14202 = D.14189 % 64;
            D.14444 = D.14443 >> D.14202;
            D.14445 = D.14444 & 1;
            if (D.14445 == 0) goto <D.14446>; else goto <D.14447>;
            <D.14446>:
            // predicted unlikely by continue predictor.
            goto <D.12063>;
            <D.14447>:
            D.14448.__sockaddr__ = 0B;
            D.14189 = prof->server_socket;
            command_socket = accept (D.14189, D.14448, 0B);
            if (command_socket < 0) goto <D.14449>; else goto <D.14450>;
            <D.14449>:
            // predicted unlikely by continue predictor.
            goto <D.12063>;
            <D.14450>:
          }
        finally
          {
            rfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.12063>:
      goto <D.12096>;
      D.14277 = 0B;
      return D.14277;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.14487;
  int D.14490;
  ssize_t D.14493;
  long unsigned int D.14494;
  long unsigned int D.14495;
  long unsigned int D.14498;

  D.14487 = __builtin_object_size (__buf, 0);
  if (D.14487 != 18446744073709551615) goto <D.14488>; else goto <D.14489>;
  <D.14488>:
  D.14490 = __builtin_constant_p (__nbytes);
  if (D.14490 == 0) goto <D.14491>; else goto <D.14492>;
  <D.14491>:
  D.14494 = __builtin_object_size (__buf, 0);
  D.14493 = __read_chk (__fd, __buf, __nbytes, D.14494);
  return D.14493;
  <D.14492>:
  D.14495 = __builtin_object_size (__buf, 0);
  if (D.14495 < __nbytes) goto <D.14496>; else goto <D.14497>;
  <D.14496>:
  D.14498 = __builtin_object_size (__buf, 0);
  D.14493 = __read_chk_warn (__fd, __buf, __nbytes, D.14498);
  return D.14493;
  <D.14497>:
  <D.14489>:
  D.14493 = __read_alias (__fd, __buf, __nbytes);
  return D.14493;
}


dump_header (struct MonoProfiler * profiler)
{
  char * p.171;
  char * p.172;
  char * p.173;
  char * p.174;
  long int D.14507;
  long unsigned int D.14508;
  long unsigned int D.14509;
  long int D.14510;
  int D.14511;
  long unsigned int D.14512;
  int D.14513;
  int D.14514;
  struct gzFile_s * * D.14515;
  long int p.175;
  long int hbuf.176;
  long int D.14520;
  unsigned int D.14521;
  struct FILE * D.14523;
  long unsigned int D.14524;
  char hbuf[128];
  char * p;

  try
    {
      p = &hbuf;
      p = write_int32 (p, 1297111553);
      p.171 = p;
      p = p.171 + 1;
      *p.171 = 0;
      p.172 = p;
      p = p.172 + 1;
      *p.172 = 4;
      p.173 = p;
      p = p.173 + 1;
      *p.173 = 4;
      p.174 = p;
      p = p.174 + 1;
      *p.174 = 8;
      D.14507 = time (0B);
      D.14508 = (long unsigned int) D.14507;
      D.14509 = D.14508 * 1000;
      D.14510 = (long int) D.14509;
      p = write_int64 (p, D.14510);
      D.14511 = get_timer_overhead ();
      p = write_int32 (p, D.14511);
      p = write_int32 (p, 0);
      D.14512 = process_id ();
      D.14513 = (int) D.14512;
      p = write_int32 (p, D.14513);
      D.14514 = profiler->command_port;
      p = write_int16 (p, D.14514);
      p = write_int16 (p, 0);
      D.14515 = profiler->gzfile;
      if (D.14515 != 0B) goto <D.14516>; else goto <D.14517>;
      <D.14516>:
      p.175 = (long int) p;
      hbuf.176 = (long int) &hbuf;
      D.14520 = p.175 - hbuf.176;
      D.14521 = (unsigned int) D.14520;
      D.14515 = profiler->gzfile;
      gzwrite (D.14515, &hbuf, D.14521);
      goto <D.14522>;
      <D.14517>:
      D.14523 = profiler->file;
      p.175 = (long int) p;
      hbuf.176 = (long int) &hbuf;
      D.14520 = p.175 - hbuf.176;
      D.14524 = (long unsigned int) D.14520;
      fwrite (&hbuf, D.14524, 1, D.14523);
      <D.14522>:
    }
  finally
    {
      hbuf = {CLOBBER};
    }
}


write_int16 (char * buf, int32_t value)
{
  sizetype D.14536;
  char * D.14537;
  char D.14538;
  char * D.14539;
  int i;

  i = 0;
  goto <D.11531>;
  <D.11530>:
  D.14536 = (sizetype) i;
  D.14537 = buf + D.14536;
  D.14538 = (char) value;
  *D.14537 = D.14538;
  value = value >> 8;
  i = i + 1;
  <D.11531>:
  if (i <= 1) goto <D.11530>; else goto <D.11532>;
  <D.11532>:
  D.14539 = buf + 2;
  return D.14539;
}


init_thread ()
{
  struct LogBuffer * tlsbuffer.177;
  long unsigned int D.14544;
  struct LogBuffer * logbuffer;

  tlsbuffer.177 = tlsbuffer;
  if (tlsbuffer.177 != 0B) goto <D.14542>; else goto <D.14543>;
  <D.14542>:
  return;
  <D.14543>:
  logbuffer = create_buffer ();
  tlsbuffer = logbuffer;
  D.14544 = thread_id ();
  logbuffer->thread_id = D.14544;
}


create_buffer ()
{
  long unsigned int D.14548;
  long unsigned int D.14549;
  int D.14550;
  sizetype D.14551;
  unsigned char * D.14552;
  unsigned char[1] * D.14553;
  struct LogBuffer * D.14554;
  struct LogBuffer * buf;

  buf = alloc_buffer (65536);
  buf->size = 65536;
  D.14548 = current_time ();
  buf->time_base = D.14548;
  D.14549 = buf->time_base;
  buf->last_time = D.14549;
  D.14550 = buf->size;
  D.14551 = (sizetype) D.14550;
  D.14552 = buf + D.14551;
  buf->data_end = D.14552;
  D.14553 = &buf->buf;
  buf->data = D.14553;
  D.14554 = buf;
  return D.14554;
}