utils_init (int fast_time)
{
  long unsigned int D.12339;
  long unsigned int time_inc.0;
  uint64_t (*<T1d94>) (void) time_func.1;
  long unsigned int D.12346;
  long unsigned int D.12347;
  int timer_overhead.2;
  int i;
  uint64_t time_start;
  uint64_t time_end;

  if (fast_time > 1) goto <D.12334>; else goto <D.12335>;
  <D.12334>:
  time_func = null_time;
  goto <D.12336>;
  <D.12335>:
  if (fast_time != 0) goto <D.12337>; else goto <D.12338>;
  <D.12337>:
  {
    uint64_t timea;
    uint64_t timeb;

    clock_time ();
    timea = clock_time ();
    timeb = clock_time ();
    D.12339 = timeb - timea;
    time_inc.0 = D.12339 / 8;
    time_inc = time_inc.0;
    if (0 != 0) goto <D.12341>; else goto <D.12342>;
    <D.12341>:
    time_func = fast_current_time;
    goto <D.12343>;
    <D.12342>:
    time_func = fast_current_time;
    <D.12343>:
  }
  goto <D.12344>;
  <D.12338>:
  time_func = clock_time;
  <D.12344>:
  <D.12336>:
  time_func.1 = time_func;
  time_start = time_func.1 ();
  i = 0;
  goto <D.11145>;
  <D.11144>:
  time_func.1 = time_func;
  time_func.1 ();
  i = i + 1;
  <D.11145>:
  if (i <= 255) goto <D.11144>; else goto <D.11146>;
  <D.11146>:
  time_func.1 = time_func;
  time_end = time_func.1 ();
  D.12346 = time_end - time_start;
  D.12347 = D.12346 / 256;
  timer_overhead.2 = (int) D.12347;
  timer_overhead = timer_overhead.2;
}


fast_current_time ()
{
  unsigned int D.12353;
  unsigned int D.12354;
  unsigned int D.12355;
  unsigned int D.12356;
  long unsigned int D.12359;
  long unsigned int time_inc.3;
  long unsigned int D.12361;
  uint64_t D.12362;
  long unsigned int D.12363;
  struct TlsData * tls;

  tls = &tls_data;
  D.12353 = tls->timer_count;
  D.12354 = D.12353;
  D.12355 = D.12354 + 1;
  tls->timer_count = D.12355;
  D.12356 = D.12354 & 7;
  if (D.12356 != 0) goto <D.12357>; else goto <D.12358>;
  <D.12357>:
  D.12359 = tls->last_time;
  time_inc.3 = time_inc;
  D.12361 = D.12359 + time_inc.3;
  tls->last_time = D.12361;
  D.12362 = tls->last_time;
  return D.12362;
  <D.12358>:
  D.12363 = clock_time ();
  tls->last_time = D.12363;
  D.12362 = tls->last_time;
  return D.12362;
}


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

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


clock_time ()
{
  uint64_t D.12371;
  long int D.12372;
  long long unsigned int D.12373;
  long long unsigned int D.12374;
  long int D.12375;
  long long unsigned int D.12376;
  struct timespec tspec;

  try
    {
      clock_gettime (1, &tspec);
      D.12372 = tspec.tv_sec;
      D.12373 = (long long unsigned int) D.12372;
      D.12374 = D.12373 * 1000000000;
      D.12375 = tspec.tv_nsec;
      D.12376 = (long long unsigned int) D.12375;
      D.12371 = D.12374 + D.12376;
      return D.12371;
    }
  finally
    {
      tspec = {CLOBBER};
    }
}


get_timer_overhead ()
{
  int D.12379;

  D.12379 = timer_overhead;
  return D.12379;
}


current_time ()
{
  uint64_t D.12381;
  uint64_t (*<T1d94>) (void) time_func.7;

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


alloc_buffer (int size)
{
  long unsigned int D.12385;
  void * D.12388;
  void * ptr;

  D.12385 = (long unsigned int) size;
  ptr = mmap (0B, D.12385, 3, 34, -1, 0);
  if (ptr == -1B) goto <D.12386>; else goto <D.12387>;
  <D.12386>:
  D.12388 = 0B;
  return D.12388;
  <D.12387>:
  D.12388 = ptr;
  return D.12388;
}


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

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


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.12391;
  uint8_t * p.8;
  uint8_t * p;

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

    D.12391 = (unsigned char) value;
    b = D.12391 & 127;
    value = value >> 7;
    if (value != 0) goto <D.12392>; else goto <D.12393>;
    <D.12392>:
    b = b | 128;
    <D.12393>:
    p.8 = p;
    p = p.8 + 1;
    *p.8 = b;
  }
  if (value != 0) goto <D.11174>; else goto <D.11175>;
  <D.11175>:
  *endbuf = p;
}


encode_sleb128 (intptr_t value, uint8_t * buf, uint8_t * * endbuf)
{
  _Bool D.12395;
  unsigned char D.12396;
  unsigned int D.12399;
  int D.12400;
  long int D.12401;
  long int D.12402;
  int D.12408;
  int D.12409;
  uint8_t * p.9;
  int more;
  int negative;
  unsigned int size;
  uint8_t byte;
  uint8_t * p;

  more = 1;
  D.12395 = value < 0;
  negative = (int) D.12395;
  size = 64;
  p = buf;
  goto <D.11187>;
  <D.11186>:
  D.12396 = (unsigned char) value;
  byte = D.12396 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.12397>; else goto <D.12398>;
  <D.12397>:
  D.12399 = size + 4294967289;
  D.12400 = (int) D.12399;
  D.12401 = 1 << D.12400;
  D.12402 = -D.12401;
  value = D.12402 | value;
  <D.12398>:
  if (value == 0) goto <D.12407>; else goto <D.12403>;
  <D.12407>:
  D.12408 = (int) byte;
  D.12409 = D.12408 & 64;
  if (D.12409 == 0) goto <D.12404>; else goto <D.12403>;
  <D.12403>:
  if (value == -1) goto <D.12410>; else goto <D.12405>;
  <D.12410>:
  D.12408 = (int) byte;
  D.12409 = D.12408 & 64;
  if (D.12409 != 0) goto <D.12404>; else goto <D.12405>;
  <D.12404>:
  more = 0;
  goto <D.12406>;
  <D.12405>:
  byte = byte | 128;
  <D.12406>:
  p.9 = p;
  p = p.9 + 1;
  *p.9 = byte;
  <D.11187>:
  if (more != 0) goto <D.11186>; else goto <D.11188>;
  <D.11188>:
  *endbuf = p;
}


decode_uleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  uint8_t * buf.10;
  long unsigned int D.12413;
  long unsigned int D.12414;
  long unsigned int D.12415;
  signed char b.11;
  uint64_t D.12418;
  uint64_t res;
  int shift;

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

    buf.10 = buf;
    buf = buf.10 + 1;
    b = *buf.10;
    D.12413 = (long unsigned int) b;
    D.12414 = D.12413 & 127;
    D.12415 = D.12414 << shift;
    res = D.12415 | res;
    b.11 = (signed char) b;
    if (b.11 >= 0) goto <D.11196>; else goto <D.12417>;
    <D.12417>:
    shift = shift + 7;
  }
  goto <D.11197>;
  <D.11196>:
  *endbuf = buf;
  D.12418 = res;
  return D.12418;
}


decode_sleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  long int D.12420;
  long int D.12421;
  long int D.12422;
  signed char b.12;
  unsigned int shift.13;
  int D.12429;
  int D.12430;
  long int D.12433;
  long int D.12434;
  intptr_t D.12435;
  uint8_t * p;
  intptr_t res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.12420 = (long int) b;
    D.12421 = D.12420 & 127;
    D.12422 = D.12421 << shift;
    res = D.12422 | res;
    shift = shift + 7;
    b.12 = (signed char) b;
    if (b.12 >= 0) goto <D.12424>; else goto <D.12425>;
    <D.12424>:
    shift.13 = (unsigned int) shift;
    if (shift.13 <= 63) goto <D.12427>; else goto <D.12428>;
    <D.12427>:
    D.12429 = (int) b;
    D.12430 = D.12429 & 64;
    if (D.12430 != 0) goto <D.12431>; else goto <D.12432>;
    <D.12431>:
    D.12433 = 1 << shift;
    D.12434 = -D.12433;
    res = D.12434 | res;
    <D.12432>:
    <D.12428>:
    goto <D.11206>;
    <D.12425>:
  }
  goto <D.11207>;
  <D.11206>:
  *endbuf = p;
  D.12435 = res;
  return D.12435;
}


thread_id ()
{
  uintptr_t D.12437;

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


process_id ()
{
  uintptr_t D.12439;
  int D.12440;

  D.12440 = getpid ();
  D.12439 = (uintptr_t) D.12440;
  return D.12439;
}


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


mono_profiler_startup (const char * desc)
{
  int D.12442;
  char D.12445;
  int D.12317;
  int iftmp.14;
  int D.12316;
  const char[5] * D.12465;
  unsigned char D.12466;
  int D.12467;
  unsigned char D.12468;
  int D.12469;
  const unsigned char * D.12474;
  unsigned char D.12475;
  int D.12476;
  const unsigned char * D.12477;
  unsigned char D.12478;
  int D.12479;
  const unsigned char * D.12484;
  unsigned char D.12485;
  int D.12486;
  const unsigned char * D.12487;
  unsigned char D.12488;
  int D.12489;
  const unsigned char * D.12494;
  unsigned char D.12495;
  int D.12496;
  const unsigned char * D.12497;
  unsigned char D.12498;
  int D.12499;
  char * val.15;
  int D.12326;
  int iftmp.16;
  int D.12325;
  const char[5] * D.12508;
  unsigned char D.12509;
  int D.12510;
  unsigned char D.12511;
  int D.12512;
  const unsigned char * D.12517;
  unsigned char D.12518;
  int D.12519;
  const unsigned char * D.12520;
  unsigned char D.12521;
  int D.12522;
  const unsigned char * D.12527;
  unsigned char D.12528;
  int D.12529;
  const unsigned char * D.12530;
  unsigned char D.12531;
  int D.12532;
  const unsigned char * D.12537;
  unsigned char D.12538;
  int D.12539;
  const unsigned char * D.12540;
  unsigned char D.12541;
  int D.12542;
  struct _IO_FILE * stderr.17;
  long unsigned int D.12564;
  int command_port.18;
  long unsigned int D.12568;
  int num_frames.19;
  int num_frames.20;
  _Bool D.12573;
  int notraces.21;
  long unsigned int D.12577;
  int max_call_depth.22;
  int do_mono_sample.23;
  int sample_type.24;
  <unnamed type> events.25;
  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.12442 = strncmp (p, "log", 3);
  if (D.12442 != 0) goto <D.12443>; else goto <D.12444>;
  <D.12443>:
  usage (1);
  <D.12444>:
  p = p + 3;
  D.12445 = *p;
  if (D.12445 == 58) goto <D.12446>; else goto <D.12447>;
  <D.12446>:
  p = p + 1;
  <D.12447>:
  goto <D.12331>;
  <D.12330>:
  {
    char * val;

    try
      {
        D.12445 = *p;
        if (D.12445 == 44) goto <D.12448>; else goto <D.12449>;
        <D.12448>:
        opt = p + 1;
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12449>:
        opt = match_option (p, "help", 0B);
        if (opt != p) goto <D.12450>; else goto <D.12451>;
        <D.12450>:
        usage (0);
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12451>:
        opt = match_option (p, "calls", 0B);
        if (opt != p) goto <D.12452>; else goto <D.12453>;
        <D.12452>:
        calls_enabled = 1;
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12453>:
        opt = match_option (p, "nocalls", 0B);
        if (opt != p) goto <D.12454>; else goto <D.12455>;
        <D.12454>:
        events = events & -4097;
        nocalls = 1;
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12455>:
        opt = match_option (p, "alloc", 0B);
        if (opt != p) goto <D.12456>; else goto <D.12457>;
        <D.12456>:
        allocs_enabled = 1;
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12457>:
        opt = match_option (p, "noalloc", 0B);
        if (opt != p) goto <D.12458>; else goto <D.12459>;
        <D.12458>:
        events = events & -129;
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12459>:
        opt = match_option (p, "time", &val);
        if (opt != p) goto <D.12460>; else goto <D.12461>;
        <D.12460>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = val;
            D.12465 = "fast";
            D.12466 = MEM[(const unsigned char *)D.12465];
            D.12467 = (int) D.12466;
            D.12468 = *__s2;
            D.12469 = (int) D.12468;
            __result = D.12467 - D.12469;
            {
              if (__s2_len != 0) goto <D.12470>; else goto <D.12471>;
              <D.12470>:
              if (__result == 0) goto <D.12472>; else goto <D.12473>;
              <D.12472>:
              D.12474 = &MEM[(void *)"fast" + 1B];
              D.12475 = *D.12474;
              D.12476 = (int) D.12475;
              D.12477 = __s2 + 1;
              D.12478 = *D.12477;
              D.12479 = (int) D.12478;
              __result = D.12476 - D.12479;
              if (__s2_len > 1) goto <D.12480>; else goto <D.12481>;
              <D.12480>:
              if (__result == 0) goto <D.12482>; else goto <D.12483>;
              <D.12482>:
              D.12484 = &MEM[(void *)"fast" + 2B];
              D.12485 = *D.12484;
              D.12486 = (int) D.12485;
              D.12487 = __s2 + 2;
              D.12488 = *D.12487;
              D.12489 = (int) D.12488;
              __result = D.12486 - D.12489;
              if (__s2_len > 2) goto <D.12490>; else goto <D.12491>;
              <D.12490>:
              if (__result == 0) goto <D.12492>; else goto <D.12493>;
              <D.12492>:
              D.12494 = &MEM[(void *)"fast" + 3B];
              D.12495 = *D.12494;
              D.12496 = (int) D.12495;
              D.12497 = __s2 + 3;
              D.12498 = *D.12497;
              D.12499 = (int) D.12498;
              __result = D.12496 - D.12499;
              <D.12493>:
              <D.12491>:
              <D.12483>:
              <D.12481>:
              <D.12473>:
              <D.12471>:
            }
            D.12316 = __result;
          }
          iftmp.14 = -D.12316;
          goto <D.12500>;
          <D.12464>:
          val.15 = val;
          iftmp.14 = __builtin_strcmp (val.15, "fast");
          <D.12500>:
          D.12317 = iftmp.14;
        }
        if (D.12317 == 0) goto <D.12502>; else goto <D.12503>;
        <D.12502>:
        fast_time = 1;
        goto <D.12504>;
        <D.12503>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = val;
            D.12508 = "null";
            D.12509 = MEM[(const unsigned char *)D.12508];
            D.12510 = (int) D.12509;
            D.12511 = *__s2;
            D.12512 = (int) D.12511;
            __result = D.12510 - D.12512;
            {
              if (__s2_len != 0) goto <D.12513>; else goto <D.12514>;
              <D.12513>:
              if (__result == 0) goto <D.12515>; else goto <D.12516>;
              <D.12515>:
              D.12517 = &MEM[(void *)"null" + 1B];
              D.12518 = *D.12517;
              D.12519 = (int) D.12518;
              D.12520 = __s2 + 1;
              D.12521 = *D.12520;
              D.12522 = (int) D.12521;
              __result = D.12519 - D.12522;
              if (__s2_len > 1) goto <D.12523>; else goto <D.12524>;
              <D.12523>:
              if (__result == 0) goto <D.12525>; else goto <D.12526>;
              <D.12525>:
              D.12527 = &MEM[(void *)"null" + 2B];
              D.12528 = *D.12527;
              D.12529 = (int) D.12528;
              D.12530 = __s2 + 2;
              D.12531 = *D.12530;
              D.12532 = (int) D.12531;
              __result = D.12529 - D.12532;
              if (__s2_len > 2) goto <D.12533>; else goto <D.12534>;
              <D.12533>:
              if (__result == 0) goto <D.12535>; else goto <D.12536>;
              <D.12535>:
              D.12537 = &MEM[(void *)"null" + 3B];
              D.12538 = *D.12537;
              D.12539 = (int) D.12538;
              D.12540 = __s2 + 3;
              D.12541 = *D.12540;
              D.12542 = (int) D.12541;
              __result = D.12539 - D.12542;
              <D.12536>:
              <D.12534>:
              <D.12526>:
              <D.12524>:
              <D.12516>:
              <D.12514>:
            }
            D.12325 = __result;
          }
          iftmp.16 = -D.12325;
          goto <D.12543>;
          <D.12507>:
          val.15 = val;
          iftmp.16 = __builtin_strcmp (val.15, "null");
          <D.12543>:
          D.12326 = iftmp.16;
        }
        if (D.12326 == 0) goto <D.12544>; else goto <D.12545>;
        <D.12544>:
        fast_time = 2;
        goto <D.12546>;
        <D.12545>:
        usage (1);
        <D.12546>:
        <D.12504>:
        val.15 = val;
        free (val.15);
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12461>:
        opt = match_option (p, "report", 0B);
        if (opt != p) goto <D.12547>; else goto <D.12548>;
        <D.12547>:
        do_report = 1;
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12548>:
        opt = match_option (p, "debug", 0B);
        if (opt != p) goto <D.12549>; else goto <D.12550>;
        <D.12549>:
        do_debug = 1;
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12550>:
        opt = match_option (p, "heapshot", &val);
        if (opt != p) goto <D.12551>; else goto <D.12552>;
        <D.12551>:
        events = events & -129;
        events = events & -4097;
        nocalls = 1;
        do_heap_shot = 1;
        val.15 = val;
        set_hsmode (val.15, 1);
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12552>:
        opt = match_option (p, "sample", &val);
        if (opt != p) goto <D.12553>; else goto <D.12554>;
        <D.12553>:
        events = events & -129;
        events = events & -4097;
        nocalls = 1;
        val.15 = val;
        set_sample_mode (val.15, 1);
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12554>:
        opt = match_option (p, "hsmode", &val);
        if (opt != p) goto <D.12555>; else goto <D.12556>;
        <D.12555>:
        stderr.17 = stderr;
        fprintf (stderr.17, "The hsmode profiler option is obsolete, use heapshot=MODE.\n");
        val.15 = val;
        set_hsmode (val.15, 0);
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12556>:
        opt = match_option (p, "zip", 0B);
        if (opt != p) goto <D.12558>; else goto <D.12559>;
        <D.12558>:
        use_zip = 1;
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12559>:
        opt = match_option (p, "output", &val);
        if (opt != p) goto <D.12560>; else goto <D.12561>;
        <D.12560>:
        filename = val;
        // predicted unlikely by continue predictor.
        goto <D.12308>;
        <D.12561>:
        opt = match_option (p, "port", &val);
        if (opt != p) goto <D.12562>; else goto <D.12563>;
        <D.12562>:
        {
          char * end;

          try
            {
              val.15 = val;
              D.12564 = strtoul (val.15, &end, 10);
              command_port.18 = (int) D.12564;
              command_port = command_port.18;
              val.15 = val;
              free (val.15);
              // predicted unlikely by continue predictor.
              goto <D.12308>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.12563>:
        opt = match_option (p, "maxframes", &val);
        if (opt != p) goto <D.12566>; else goto <D.12567>;
        <D.12566>:
        {
          char * end;

          try
            {
              val.15 = val;
              D.12568 = strtoul (val.15, &end, 10);
              num_frames.19 = (int) D.12568;
              num_frames = num_frames.19;
              num_frames.20 = num_frames;
              if (num_frames.20 > 16) goto <D.12571>; else goto <D.12572>;
              <D.12571>:
              num_frames = 16;
              <D.12572>:
              val.15 = val;
              free (val.15);
              num_frames.20 = num_frames;
              D.12573 = num_frames.20 == 0;
              notraces.21 = (int) D.12573;
              notraces = notraces.21;
              // predicted unlikely by continue predictor.
              goto <D.12308>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.12567>:
        opt = match_option (p, "calldepth", &val);
        if (opt != p) goto <D.12575>; else goto <D.12576>;
        <D.12575>:
        {
          char * end;

          try
            {
              val.15 = val;
              D.12577 = strtoul (val.15, &end, 10);
              max_call_depth.22 = (int) D.12577;
              max_call_depth = max_call_depth.22;
              val.15 = val;
              free (val.15);
              // predicted unlikely by continue predictor.
              goto <D.12308>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.12576>:
        if (opt == p) goto <D.12579>; else goto <D.12580>;
        <D.12579>:
        usage (0);
        exit (0);
        <D.12580>:
      }
    finally
      {
        val = {CLOBBER};
      }
  }
  <D.12308>:
  p = opt;
  <D.12331>:
  D.12445 = *p;
  if (D.12445 != 0) goto <D.12330>; else goto <D.12332>;
  <D.12332>:
  if (calls_enabled != 0) goto <D.12581>; else goto <D.12582>;
  <D.12581>:
  events = events | 4096;
  nocalls = 0;
  <D.12582>:
  if (allocs_enabled != 0) goto <D.12583>; else goto <D.12584>;
  <D.12583>:
  events = events | 128;
  <D.12584>:
  utils_init (fast_time);
  prof = create_profiler (filename);
  if (prof == 0B) goto <D.12585>; else goto <D.12586>;
  <D.12585>:
  return;
  <D.12586>:
  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.23 = do_mono_sample;
  if (do_mono_sample.23 != 0) goto <D.12588>; else goto <D.12589>;
  <D.12588>:
  sample_type.24 = sample_type;
  if (sample_type.24 == 1) goto <D.12591>; else goto <D.12592>;
  <D.12591>:
  events = events | 32768;
  mono_profiler_install_statistical (mono_sample_hit);
  <D.12592>:
  <D.12589>:
  events.25 = (<unnamed type>) events;
  mono_profiler_set_events (events.25);
}


mono_sample_hit (struct MonoProfiler * profiler, unsigned char * ip, void * context)
{
  int in_shutdown.26;
  int do_debug.27;
  long unsigned int D.12624;
  void * D.12625;
  long unsigned int D.12626;
  long unsigned int D.12627;
  uintptr_t * D.12630;
  uintptr_t * D.12631;
  uintptr_t * D.12632;
  struct StatBuffer * D.12635;
  struct StatBuffer * D.12638;
  struct StatBuffer * D.12639;
  int D.12642;
  uintptr_t * * D.12645;
  int sample_type.28;
  int D.12649;
  int D.12650;
  long unsigned int D.12651;
  uintptr_t * D.12652;
  long unsigned int D.12653;
  uintptr_t * D.12654;
  long unsigned int D.12655;
  long unsigned int D.12656;
  long unsigned int D.12657;
  uintptr_t * D.12658;
  long unsigned int ip.29;
  struct StatBuffer * sbuf;
  uint64_t now;
  uintptr_t * data;
  uintptr_t * new_data;
  uintptr_t * old_data;

  in_shutdown.26 = in_shutdown;
  if (in_shutdown.26 != 0) goto <D.12619>; else goto <D.12620>;
  <D.12619>:
  return;
  <D.12620>:
  now = current_time ();
  do_debug.27 = do_debug;
  if (do_debug.27 != 0) goto <D.12622>; else goto <D.12623>;
  <D.12622>:
  {
    int len;
    char buf[256];

    try
      {
        D.12624 = thread_id ();
        D.12625 = (void *) D.12624;
        snprintf (&buf, 256, "hit at %p in thread %p at %llu\n", ip, D.12625, now);
        D.12626 = strlen (&buf);
        len = (int) D.12626;
        D.12627 = (long unsigned int) len;
        write (2, &buf, D.12627);
      }
    finally
      {
        buf = {CLOBBER};
      }
  }
  <D.12623>:
  sbuf = profiler->stat_buffers;
  if (sbuf == 0B) goto <D.12628>; else goto <D.12629>;
  <D.12628>:
  return;
  <D.12629>:
  D.12630 = sbuf->data;
  D.12631 = D.12630 + 3200;
  D.12632 = sbuf->data_end;
  if (D.12631 >= D.12632) goto <D.12633>; else goto <D.12634>;
  <D.12633>:
  sbuf = create_stat_buffer ();
  D.12635 = profiler->stat_buffers;
  sbuf->next = D.12635;
  profiler->stat_buffers = sbuf;
  do_debug.27 = do_debug;
  if (do_debug.27 != 0) goto <D.12636>; else goto <D.12637>;
  <D.12636>:
  write (2, "overflow\n", 9);
  <D.12637>:
  D.12638 = sbuf->next;
  D.12639 = D.12638->next;
  if (D.12639 != 0B) goto <D.12640>; else goto <D.12641>;
  <D.12640>:
  {
    char c;

    try
      {
        c = 0;
        D.12642 = profiler->pipes[1];
        write (D.12642, &c, 1);
        do_debug.27 = do_debug;
        if (do_debug.27 != 0) goto <D.12643>; else goto <D.12644>;
        <D.12643>:
        write (2, "notify\n", 7);
        <D.12644>:
      }
    finally
      {
        c = {CLOBBER};
      }
  }
  <D.12641>:
  <D.12634>:
  <D.11960>:
  old_data = sbuf->data;
  new_data = old_data + 32;
  D.12645 = &sbuf->data;
  data = InterlockedCompareExchangePointer (D.12645, new_data, old_data);
  if (data != old_data) goto <D.11960>; else goto <D.11961>;
  <D.11961>:
  D.12632 = sbuf->data_end;
  if (D.12632 <= old_data) goto <D.12646>; else goto <D.12647>;
  <D.12646>:
  return;
  <D.12647>:
  sample_type.28 = sample_type;
  D.12649 = sample_type.28 << 16;
  D.12650 = D.12649 | 1;
  D.12651 = (long unsigned int) D.12650;
  *old_data = D.12651;
  D.12652 = old_data + 8;
  D.12653 = thread_id ();
  *D.12652 = D.12653;
  D.12654 = old_data + 16;
  D.12655 = profiler->startup_time;
  D.12656 = now - D.12655;
  D.12657 = D.12656 / 10000;
  *D.12654 = D.12657;
  D.12658 = old_data + 24;
  ip.29 = (long unsigned int) ip;
  *D.12658 = ip.29;
}


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

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


create_stat_buffer ()
{
  long unsigned int D.12673;
  uintptr_t * D.12674;
  uintptr_t[1] * D.12675;
  struct StatBuffer * D.12676;
  struct StatBuffer * buf;

  buf = alloc_buffer (65536);
  buf->size = 65536;
  D.12673 = buf->size;
  D.12674 = buf + D.12673;
  buf->data_end = D.12674;
  D.12675 = &buf->buf;
  buf->data = D.12675;
  D.12676 = buf;
  return D.12676;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.12679;
  long unsigned int comp.30;
  long unsigned int exch.31;
  long unsigned int D.12682;

  comp.30 = (long unsigned int) comp;
  exch.31 = (long unsigned int) exch;
  D.12682 = __sync_val_compare_and_swap_8 (dest, comp.30, exch.31);
  D.12679 = (void *) D.12682;
  return D.12679;
}


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


monitor_event (struct MonoProfiler * profiler, struct MonoObject * object, MonoProfilerMonitorEvent event)
{
  int iftmp.32;
  int nocalls.33;
  int runtime_inited.34;
  int notraces.35;
  int D.12696;
  int D.12699;
  unsigned int D.12700;
  unsigned int do_bt.36;
  unsigned int D.12702;
  unsigned int D.12703;
  int D.12704;
  int D.12707;
  int do_bt;
  uint64_t now;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.33 = nocalls;
      if (nocalls.33 != 0) goto <D.12688>; else goto <D.12685>;
      <D.12688>:
      runtime_inited.34 = runtime_inited;
      if (runtime_inited.34 != 0) goto <D.12690>; else goto <D.12685>;
      <D.12690>:
      notraces.35 = notraces;
      if (notraces.35 == 0) goto <D.12692>; else goto <D.12685>;
      <D.12692>:
      if (event == 1) goto <D.12693>; else goto <D.12685>;
      <D.12693>:
      iftmp.32 = 128;
      goto <D.12686>;
      <D.12685>:
      iftmp.32 = 0;
      <D.12686>:
      do_bt = iftmp.32;
      if (do_bt != 0) goto <D.12694>; else goto <D.12695>;
      <D.12694>:
      collect_bt (&data);
      <D.12695>:
      logbuffer = ensure_logbuf (144);
      now = current_time ();
      D.12696 = logbuffer->locked;
      if (D.12696 != 0) goto <D.12697>; else goto <D.12698>;
      <D.12697>:
      write (2, "monitor", 7);
      write (2, "\n", 1);
      return;
      <D.12698>:
      D.12696 = logbuffer->locked;
      D.12699 = D.12696 + 1;
      logbuffer->locked = D.12699;
      D.12700 = event << 4;
      do_bt.36 = (unsigned int) do_bt;
      D.12702 = D.12700 | do_bt.36;
      D.12703 = D.12702 | 5;
      D.12704 = (int) D.12703;
      emit_byte (logbuffer, D.12704);
      emit_time (logbuffer, now);
      emit_obj (logbuffer, object);
      if (do_bt != 0) goto <D.12705>; else goto <D.12706>;
      <D.12705>:
      emit_bt (logbuffer, &data);
      <D.12706>:
      D.12696 = logbuffer->locked;
      D.12707 = D.12696 + -1;
      logbuffer->locked = D.12707;
      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.12716;
  int num_frames.37;
  int D.12720;
  int D.12721;
  mono_bool D.12722;
  _Bool D.12723;
  struct FrameData * frame;

  frame = data;
  if (method != 0B) goto <D.12714>; else goto <D.12715>;
  <D.12714>:
  D.12716 = frame->count;
  num_frames.37 = num_frames;
  if (D.12716 < num_frames.37) goto <D.12718>; else goto <D.12719>;
  <D.12718>:
  D.12716 = frame->count;
  D.12720 = D.12716;
  D.12721 = D.12720 + 1;
  frame->count = D.12721;
  frame->methods[D.12720] = method;
  <D.12719>:
  <D.12715>:
  D.12716 = frame->count;
  num_frames.37 = num_frames;
  D.12723 = D.12716 == num_frames.37;
  D.12722 = (mono_bool) D.12723;
  return D.12722;
}


ensure_logbuf (int bytes)
{
  unsigned char * D.12727;
  sizetype D.12728;
  sizetype D.12729;
  unsigned char * D.12730;
  unsigned char * D.12731;
  struct LogBuffer * D.12734;
  struct LogBuffer * tlsbuffer.38;
  int D.12738;
  struct LogBuffer * old;

  old = tlsbuffer;
  if (old != 0B) goto <D.12725>; else goto <D.12726>;
  <D.12725>:
  D.12727 = old->data;
  D.12728 = (sizetype) bytes;
  D.12729 = D.12728 + 100;
  D.12730 = D.12727 + D.12729;
  D.12731 = old->data_end;
  if (D.12730 < D.12731) goto <D.12732>; else goto <D.12733>;
  <D.12732>:
  D.12734 = old;
  return D.12734;
  <D.12733>:
  <D.12726>:
  tlsbuffer = 0B;
  init_thread ();
  tlsbuffer.38 = tlsbuffer;
  tlsbuffer.38->next = old;
  if (old != 0B) goto <D.12736>; else goto <D.12737>;
  <D.12736>:
  tlsbuffer.38 = tlsbuffer;
  D.12738 = old->call_depth;
  tlsbuffer.38->call_depth = D.12738;
  <D.12737>:
  D.12734 = tlsbuffer;
  return D.12734;
}


emit_byte (struct LogBuffer * logbuffer, int value)
{
  unsigned char * D.12740;
  unsigned char D.12741;
  unsigned char * D.12742;
  unsigned char * D.12743;
  static const char __PRETTY_FUNCTION__[10] = "emit_byte";

  D.12740 = logbuffer->data;
  D.12741 = (unsigned char) value;
  *D.12740 = D.12741;
  D.12740 = logbuffer->data;
  D.12742 = D.12740 + 1;
  logbuffer->data = D.12742;
  D.12740 = logbuffer->data;
  D.12743 = logbuffer->data_end;
  if (D.12740 > D.12743) goto <D.12744>; else goto <D.12745>;
  <D.12744>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 443, &__PRETTY_FUNCTION__);
  <D.12745>:
}


emit_time (struct LogBuffer * logbuffer, uint64_t value)
{
  long unsigned int D.12746;
  unsigned char * D.12749;
  unsigned char * * D.12750;
  unsigned char * D.12751;
  uint64_t tdiff;
  unsigned char * p;
  static const char __PRETTY_FUNCTION__[10] = "emit_time";

  D.12746 = logbuffer->last_time;
  tdiff = value - D.12746;
  D.12746 = logbuffer->last_time;
  if (D.12746 > value) goto <D.12747>; else goto <D.12748>;
  <D.12747>:
  printf ("time went backwards\n");
  <D.12748>:
  p = logbuffer->data;
  D.12749 = logbuffer->data;
  D.12750 = &logbuffer->data;
  encode_uleb128 (tdiff, D.12749, D.12750);
  logbuffer->last_time = value;
  D.12749 = logbuffer->data;
  D.12751 = logbuffer->data_end;
  if (D.12749 > D.12751) goto <D.12752>; else goto <D.12753>;
  <D.12752>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 467, &__PRETTY_FUNCTION__);
  <D.12753>:
}


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

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


emit_obj (struct LogBuffer * logbuffer, void * ptr)
{
  long unsigned int D.12757;
  long unsigned int ptr.39;
  long unsigned int D.12761;
  long unsigned int D.12762;
  long int D.12763;
  unsigned char * D.12764;
  unsigned char * D.12765;
  static const char __PRETTY_FUNCTION__[9] = "emit_obj";

  D.12757 = logbuffer->obj_base;
  if (D.12757 == 0) goto <D.12758>; else goto <D.12759>;
  <D.12758>:
  ptr.39 = (long unsigned int) ptr;
  D.12761 = ptr.39 >> 3;
  logbuffer->obj_base = D.12761;
  <D.12759>:
  ptr.39 = (long unsigned int) ptr;
  D.12761 = ptr.39 >> 3;
  D.12757 = logbuffer->obj_base;
  D.12762 = D.12761 - D.12757;
  D.12763 = (long int) D.12762;
  emit_svalue (logbuffer, D.12763);
  D.12764 = logbuffer->data;
  D.12765 = logbuffer->data_end;
  if (D.12764 > D.12765) goto <D.12766>; else goto <D.12767>;
  <D.12766>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 511, &__PRETTY_FUNCTION__);
  <D.12767>:
}


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

  D.12768 = logbuffer->data;
  D.12769 = &logbuffer->data;
  encode_sleb128 (value, D.12768, D.12769);
  D.12768 = logbuffer->data;
  D.12770 = logbuffer->data_end;
  if (D.12768 > D.12770) goto <D.12771>; else goto <D.12772>;
  <D.12771>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 474, &__PRETTY_FUNCTION__);
  <D.12772>:
}


emit_bt (struct LogBuffer * logbuffer, struct FrameData * data)
{
  int D.12773;
  int num_frames.40;
  int D.12777;
  struct MonoMethod * D.12778;

  D.12773 = data->count;
  num_frames.40 = num_frames;
  if (D.12773 > num_frames.40) goto <D.12775>; else goto <D.12776>;
  <D.12775>:
  D.12773 = data->count;
  printf ("bad num frames: %d\n", D.12773);
  <D.12776>:
  emit_value (logbuffer, 0);
  D.12773 = data->count;
  emit_value (logbuffer, D.12773);
  goto <D.11803>;
  <D.11802>:
  D.12773 = data->count;
  D.12777 = D.12773 + -1;
  data->count = D.12777;
  D.12773 = data->count;
  D.12778 = data->methods[D.12773];
  emit_ptr (logbuffer, D.12778);
  <D.11803>:
  D.12773 = data->count;
  if (D.12773 != 0) goto <D.11802>; else goto <D.11804>;
  <D.11804>:
}


emit_value (struct LogBuffer * logbuffer, int value)
{
  long unsigned int D.12779;
  unsigned char * D.12780;
  unsigned char * * D.12781;
  unsigned char * D.12782;
  static const char __PRETTY_FUNCTION__[11] = "emit_value";

  D.12779 = (long unsigned int) value;
  D.12780 = logbuffer->data;
  D.12781 = &logbuffer->data;
  encode_uleb128 (D.12779, D.12780, D.12781);
  D.12780 = logbuffer->data;
  D.12782 = logbuffer->data_end;
  if (D.12780 > D.12782) goto <D.12783>; else goto <D.12784>;
  <D.12783>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 450, &__PRETTY_FUNCTION__);
  <D.12784>:
}


emit_ptr (struct LogBuffer * logbuffer, void * ptr)
{
  long unsigned int D.12785;
  long unsigned int ptr.41;
  long unsigned int D.12789;
  long int D.12790;
  unsigned char * D.12791;
  unsigned char * D.12792;
  static const char __PRETTY_FUNCTION__[9] = "emit_ptr";

  D.12785 = logbuffer->ptr_base;
  if (D.12785 == 0) goto <D.12786>; else goto <D.12787>;
  <D.12786>:
  ptr.41 = (long unsigned int) ptr;
  logbuffer->ptr_base = ptr.41;
  <D.12787>:
  ptr.41 = (long unsigned int) ptr;
  D.12785 = logbuffer->ptr_base;
  D.12789 = ptr.41 - D.12785;
  D.12790 = (long int) D.12789;
  emit_svalue (logbuffer, D.12790);
  D.12791 = logbuffer->data;
  D.12792 = logbuffer->data_end;
  if (D.12791 > D.12792) goto <D.12793>; else goto <D.12794>;
  <D.12793>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 490, &__PRETTY_FUNCTION__);
  <D.12794>:
}


process_requests (struct MonoProfiler * profiler)
{
  int heapshot_requested.42;
  int D.12798;

  heapshot_requested.42 = heapshot_requested;
  if (heapshot_requested.42 != 0) goto <D.12796>; else goto <D.12797>;
  <D.12796>:
  D.12798 = mono_gc_max_generation ();
  mono_gc_collect (D.12798);
  <D.12797>:
}


clause_exc (struct MonoProfiler * prof, struct MonoMethod * method, int clause_type, int clause_num)
{
  int D.12800;
  int D.12803;
  int D.12804;
  uint64_t now;
  struct LogBuffer * logbuffer;

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


emit_method (struct LogBuffer * logbuffer, void * method)
{
  long unsigned int D.12808;
  long unsigned int method.43;
  long int method.44;
  long unsigned int D.12813;
  long int D.12814;
  long int D.12815;
  unsigned char * D.12816;
  unsigned char * * D.12817;
  unsigned char * D.12818;
  static const char __PRETTY_FUNCTION__[12] = "emit_method";

  D.12808 = logbuffer->method_base;
  if (D.12808 == 0) goto <D.12809>; else goto <D.12810>;
  <D.12809>:
  method.43 = (long unsigned int) method;
  logbuffer->method_base = method.43;
  method.43 = (long unsigned int) method;
  logbuffer->last_method = method.43;
  <D.12810>:
  method.44 = (long int) method;
  D.12813 = logbuffer->last_method;
  D.12814 = (long int) D.12813;
  D.12815 = method.44 - D.12814;
  D.12816 = logbuffer->data;
  D.12817 = &logbuffer->data;
  encode_sleb128 (D.12815, D.12816, D.12817);
  method.43 = (long unsigned int) method;
  logbuffer->last_method = method.43;
  D.12816 = logbuffer->data;
  D.12818 = logbuffer->data_end;
  if (D.12816 > D.12818) goto <D.12819>; else goto <D.12820>;
  <D.12819>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 502, &__PRETTY_FUNCTION__);
  <D.12820>:
}


method_exc_leave (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int nocalls.45;
  int D.12824;
  int D.12825;
  int max_call_depth.46;
  int D.12829;
  int D.12832;
  int D.12833;
  uint64_t now;
  struct LogBuffer * logbuffer;

  nocalls.45 = nocalls;
  if (nocalls.45 != 0) goto <D.12822>; else goto <D.12823>;
  <D.12822>:
  return;
  <D.12823>:
  logbuffer = ensure_logbuf (16);
  D.12824 = logbuffer->call_depth;
  D.12825 = D.12824 + -1;
  logbuffer->call_depth = D.12825;
  D.12824 = logbuffer->call_depth;
  max_call_depth.46 = max_call_depth;
  if (D.12824 > max_call_depth.46) goto <D.12827>; else goto <D.12828>;
  <D.12827>:
  return;
  <D.12828>:
  now = current_time ();
  D.12829 = logbuffer->locked;
  if (D.12829 != 0) goto <D.12830>; else goto <D.12831>;
  <D.12830>:
  write (2, "eleave", 6);
  write (2, "\n", 1);
  return;
  <D.12831>:
  D.12829 = logbuffer->locked;
  D.12832 = D.12829 + 1;
  logbuffer->locked = D.12832;
  emit_byte (logbuffer, 51);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12829 = logbuffer->locked;
  D.12833 = D.12829 + -1;
  logbuffer->locked = D.12833;
  process_requests (prof);
}


throw_exc (struct MonoProfiler * prof, struct MonoObject * object)
{
  int iftmp.47;
  int nocalls.48;
  int runtime_inited.49;
  int notraces.50;
  int D.12848;
  int D.12851;
  int D.12852;
  int D.12855;
  int do_bt;
  uint64_t now;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.48 = nocalls;
      if (nocalls.48 != 0) goto <D.12841>; else goto <D.12838>;
      <D.12841>:
      runtime_inited.49 = runtime_inited;
      if (runtime_inited.49 != 0) goto <D.12843>; else goto <D.12838>;
      <D.12843>:
      notraces.50 = notraces;
      if (notraces.50 == 0) goto <D.12845>; else goto <D.12838>;
      <D.12845>:
      iftmp.47 = 128;
      goto <D.12839>;
      <D.12838>:
      iftmp.47 = 0;
      <D.12839>:
      do_bt = iftmp.47;
      if (do_bt != 0) goto <D.12846>; else goto <D.12847>;
      <D.12846>:
      collect_bt (&data);
      <D.12847>:
      logbuffer = ensure_logbuf (144);
      now = current_time ();
      D.12848 = logbuffer->locked;
      if (D.12848 != 0) goto <D.12849>; else goto <D.12850>;
      <D.12849>:
      write (2, "throw", 5);
      write (2, "\n", 1);
      return;
      <D.12850>:
      D.12848 = logbuffer->locked;
      D.12851 = D.12848 + 1;
      logbuffer->locked = D.12851;
      D.12852 = do_bt | 4;
      emit_byte (logbuffer, D.12852);
      emit_time (logbuffer, now);
      emit_obj (logbuffer, object);
      if (do_bt != 0) goto <D.12853>; else goto <D.12854>;
      <D.12853>:
      emit_bt (logbuffer, &data);
      <D.12854>:
      D.12848 = logbuffer->locked;
      D.12855 = D.12848 + -1;
      logbuffer->locked = D.12855;
      process_requests (prof);
    }
  finally
    {
      data = {CLOBBER};
    }
}


method_jitted (struct MonoProfiler * prof, struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  long unsigned int D.12864;
  unsigned int D.12865;
  unsigned int D.12866;
  int D.12867;
  int D.12868;
  int D.12871;
  void * D.12872;
  int D.12873;
  unsigned char * D.12874;
  long unsigned int D.12875;
  sizetype D.12876;
  unsigned char * D.12877;
  int D.12878;
  struct LogBuffer * D.12879;
  uint64_t now;
  char * name;
  int nlen;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.12862>; else goto <D.12863>;
  <D.12862>:
  return;
  <D.12863>:
  name = mono_method_full_name (method, 1);
  D.12864 = strlen (name);
  D.12865 = (unsigned int) D.12864;
  D.12866 = D.12865 + 1;
  nlen = (int) D.12866;
  D.12867 = nlen + 32;
  logbuffer = ensure_logbuf (D.12867);
  now = current_time ();
  D.12868 = logbuffer->locked;
  if (D.12868 != 0) goto <D.12869>; else goto <D.12870>;
  <D.12869>:
  write (2, "jit", 3);
  write (2, "\n", 1);
  return;
  <D.12870>:
  D.12868 = logbuffer->locked;
  D.12871 = D.12868 + 1;
  logbuffer->locked = D.12871;
  emit_byte (logbuffer, 67);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12872 = mono_jit_info_get_code_start (jinfo);
  emit_ptr (logbuffer, D.12872);
  D.12873 = mono_jit_info_get_code_size (jinfo);
  emit_value (logbuffer, D.12873);
  D.12874 = logbuffer->data;
  D.12875 = (long unsigned int) nlen;
  memcpy (D.12874, name, D.12875);
  D.12874 = logbuffer->data;
  D.12876 = (sizetype) nlen;
  D.12877 = D.12874 + D.12876;
  logbuffer->data = D.12877;
  mono_free (name);
  D.12868 = logbuffer->locked;
  D.12878 = D.12868 + -1;
  logbuffer->locked = D.12878;
  D.12879 = logbuffer->next;
  if (D.12879 != 0B) goto <D.12880>; else goto <D.12881>;
  <D.12880>:
  safe_dump (prof, logbuffer);
  <D.12881>:
  process_requests (prof);
}


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

  D.12889 = __builtin_object_size (__dest, 0);
  D.12888 = __builtin___memcpy_chk (__dest, __src, __len, D.12889);
  return D.12888;
}


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

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


dump_buffer (struct MonoProfiler * profiler, struct LogBuffer * buf)
{
  struct LogBuffer * D.12892;
  unsigned char * D.12895;
  long int D.12896;
  unsigned char[1] * D.12897;
  long int D.12898;
  long int D.12899;
  int D.12900;
  long unsigned int D.12901;
  long int D.12902;
  long unsigned int D.12903;
  long int D.12904;
  long unsigned int D.12905;
  long int D.12906;
  long unsigned int D.12907;
  long int D.12908;
  long unsigned int D.12909;
  long int D.12910;
  struct gzFile_s * * D.12911;
  long int p.52;
  long int hbuf.53;
  long int D.12916;
  unsigned int D.12917;
  unsigned int D.12918;
  long unsigned int D.12920;
  struct FILE * D.12921;
  long unsigned int D.12922;
  int D.12923;
  char hbuf[128];
  char * p;

  try
    {
      p = &hbuf;
      D.12892 = buf->next;
      if (D.12892 != 0B) goto <D.12893>; else goto <D.12894>;
      <D.12893>:
      D.12892 = buf->next;
      dump_buffer (profiler, D.12892);
      <D.12894>:
      p = write_int32 (p, 1297107969);
      D.12895 = buf->data;
      D.12896 = (long int) D.12895;
      D.12897 = &buf->buf;
      D.12898 = (long int) D.12897;
      D.12899 = D.12896 - D.12898;
      D.12900 = (int) D.12899;
      p = write_int32 (p, D.12900);
      D.12901 = buf->time_base;
      D.12902 = (long int) D.12901;
      p = write_int64 (p, D.12902);
      D.12903 = buf->ptr_base;
      D.12904 = (long int) D.12903;
      p = write_int64 (p, D.12904);
      D.12905 = buf->obj_base;
      D.12906 = (long int) D.12905;
      p = write_int64 (p, D.12906);
      D.12907 = buf->thread_id;
      D.12908 = (long int) D.12907;
      p = write_int64 (p, D.12908);
      D.12909 = buf->method_base;
      D.12910 = (long int) D.12909;
      p = write_int64 (p, D.12910);
      D.12911 = profiler->gzfile;
      if (D.12911 != 0B) goto <D.12912>; else goto <D.12913>;
      <D.12912>:
      D.12911 = profiler->gzfile;
      p.52 = (long int) p;
      hbuf.53 = (long int) &hbuf;
      D.12916 = p.52 - hbuf.53;
      D.12917 = (unsigned int) D.12916;
      gzwrite (D.12911, &hbuf, D.12917);
      D.12911 = profiler->gzfile;
      D.12897 = &buf->buf;
      D.12895 = buf->data;
      D.12896 = (long int) D.12895;
      D.12897 = &buf->buf;
      D.12898 = (long int) D.12897;
      D.12899 = D.12896 - D.12898;
      D.12918 = (unsigned int) D.12899;
      gzwrite (D.12911, D.12897, D.12918);
      goto <D.12919>;
      <D.12913>:
      p.52 = (long int) p;
      hbuf.53 = (long int) &hbuf;
      D.12916 = p.52 - hbuf.53;
      D.12920 = (long unsigned int) D.12916;
      D.12921 = profiler->file;
      fwrite (&hbuf, D.12920, 1, D.12921);
      D.12897 = &buf->buf;
      D.12895 = buf->data;
      D.12896 = (long int) D.12895;
      D.12897 = &buf->buf;
      D.12898 = (long int) D.12897;
      D.12899 = D.12896 - D.12898;
      D.12922 = (long unsigned int) D.12899;
      D.12921 = profiler->file;
      fwrite (D.12897, D.12922, 1, D.12921);
      D.12921 = profiler->file;
      fflush (D.12921);
      <D.12919>:
      D.12923 = buf->size;
      free_buffer (buf, D.12923);
    }
  finally
    {
      hbuf = {CLOBBER};
    }
}


write_int32 (char * buf, int32_t value)
{
  sizetype D.12933;
  char * D.12934;
  char D.12935;
  char * D.12936;
  int i;

  i = 0;
  goto <D.11711>;
  <D.11710>:
  D.12933 = (sizetype) i;
  D.12934 = buf + D.12933;
  D.12935 = (char) value;
  *D.12934 = D.12935;
  value = value >> 8;
  i = i + 1;
  <D.11711>:
  if (i <= 3) goto <D.11710>; else goto <D.11712>;
  <D.11712>:
  D.12936 = buf + 4;
  return D.12936;
}


write_int64 (char * buf, int64_t value)
{
  sizetype D.12938;
  char * D.12939;
  char D.12940;
  char * D.12941;
  int i;

  i = 0;
  goto <D.11719>;
  <D.11718>:
  D.12938 = (sizetype) i;
  D.12939 = buf + D.12938;
  D.12940 = (char) value;
  *D.12939 = D.12940;
  value = value >> 8;
  i = i + 1;
  <D.11719>:
  if (i <= 7) goto <D.11718>; else goto <D.11720>;
  <D.11720>:
  D.12941 = buf + 8;
  return D.12941;
}


method_leave (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int D.12943;
  int D.12944;
  int max_call_depth.54;
  int D.12948;
  int D.12951;
  int D.12952;
  struct LogBuffer * D.12953;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  D.12943 = logbuffer->call_depth;
  D.12944 = D.12943 + -1;
  logbuffer->call_depth = D.12944;
  D.12943 = logbuffer->call_depth;
  max_call_depth.54 = max_call_depth;
  if (D.12943 > max_call_depth.54) goto <D.12946>; else goto <D.12947>;
  <D.12946>:
  return;
  <D.12947>:
  now = current_time ();
  D.12948 = logbuffer->locked;
  if (D.12948 != 0) goto <D.12949>; else goto <D.12950>;
  <D.12949>:
  write (2, "leave", 5);
  write (2, "\n", 1);
  return;
  <D.12950>:
  D.12948 = logbuffer->locked;
  D.12951 = D.12948 + 1;
  logbuffer->locked = D.12951;
  emit_byte (logbuffer, 19);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12948 = logbuffer->locked;
  D.12952 = D.12948 + -1;
  logbuffer->locked = D.12952;
  D.12953 = logbuffer->next;
  if (D.12953 != 0B) goto <D.12954>; else goto <D.12955>;
  <D.12954>:
  safe_dump (prof, logbuffer);
  <D.12955>:
  process_requests (prof);
}


method_enter (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int D.12959;
  int D.12960;
  int D.12961;
  int max_call_depth.55;
  int D.12965;
  int D.12968;
  int D.12969;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  D.12959 = logbuffer->call_depth;
  D.12960 = D.12959;
  D.12961 = D.12960 + 1;
  logbuffer->call_depth = D.12961;
  max_call_depth.55 = max_call_depth;
  if (D.12960 > max_call_depth.55) goto <D.12963>; else goto <D.12964>;
  <D.12963>:
  return;
  <D.12964>:
  now = current_time ();
  D.12965 = logbuffer->locked;
  if (D.12965 != 0) goto <D.12966>; else goto <D.12967>;
  <D.12966>:
  write (2, "enter", 5);
  write (2, "\n", 1);
  return;
  <D.12967>:
  D.12965 = logbuffer->locked;
  D.12968 = D.12965 + 1;
  logbuffer->locked = D.12968;
  emit_byte (logbuffer, 35);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.12965 = logbuffer->locked;
  D.12969 = D.12965 + -1;
  logbuffer->locked = D.12969;
  process_requests (prof);
}


thread_name (struct MonoProfiler * prof, uintptr_t tid, const char * name)
{
  long unsigned int D.12973;
  unsigned int D.12974;
  unsigned int D.12975;
  int D.12976;
  int D.12977;
  int D.12980;
  void * tid.56;
  unsigned char * D.12982;
  long unsigned int D.12983;
  sizetype D.12984;
  unsigned char * D.12985;
  int D.12986;
  int len;
  uint64_t now;
  struct LogBuffer * logbuffer;

  D.12973 = strlen (name);
  D.12974 = (unsigned int) D.12973;
  D.12975 = D.12974 + 1;
  len = (int) D.12975;
  D.12976 = len + 10;
  logbuffer = ensure_logbuf (D.12976);
  now = current_time ();
  D.12977 = logbuffer->locked;
  if (D.12977 != 0) goto <D.12978>; else goto <D.12979>;
  <D.12978>:
  write (2, "tname", 5);
  write (2, "\n", 1);
  return;
  <D.12979>:
  D.12977 = logbuffer->locked;
  D.12980 = D.12977 + 1;
  logbuffer->locked = D.12980;
  emit_byte (logbuffer, 2);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 5);
  tid.56 = (void *) tid;
  emit_ptr (logbuffer, tid.56);
  emit_value (logbuffer, 0);
  D.12982 = logbuffer->data;
  D.12983 = (long unsigned int) len;
  memcpy (D.12982, name, D.12983);
  D.12982 = logbuffer->data;
  D.12984 = (sizetype) len;
  D.12985 = D.12982 + D.12984;
  logbuffer->data = D.12985;
  D.12977 = logbuffer->locked;
  D.12986 = D.12977 + -1;
  logbuffer->locked = D.12986;
}


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

  take_lock ();
  tlsbuffer.57 = tlsbuffer;
  if (tlsbuffer.57 != 0B) goto <D.12991>; else goto <D.12992>;
  <D.12991>:
  tlsbuffer.57 = tlsbuffer;
  dump_buffer (prof, tlsbuffer.57);
  <D.12992>:
  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.12995;
  unsigned int D.12996;
  unsigned int D.12997;
  int D.12998;
  int D.12999;
  int D.13002;
  unsigned char * D.13003;
  long unsigned int D.13004;
  sizetype D.13005;
  unsigned char * D.13006;
  int D.13007;
  struct LogBuffer * D.13008;
  uint64_t now;
  const char * name;
  int nlen;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.12993>; else goto <D.12994>;
  <D.12993>:
  return;
  <D.12994>:
  name = mono_image_get_filename (image);
  D.12995 = strlen (name);
  D.12996 = (unsigned int) D.12995;
  D.12997 = D.12996 + 1;
  nlen = (int) D.12997;
  D.12998 = nlen + 16;
  logbuffer = ensure_logbuf (D.12998);
  now = current_time ();
  D.12999 = logbuffer->locked;
  if (D.12999 != 0) goto <D.13000>; else goto <D.13001>;
  <D.13000>:
  write (2, "image", 5);
  write (2, "\n", 1);
  return;
  <D.13001>:
  D.12999 = logbuffer->locked;
  D.13002 = D.12999 + 1;
  logbuffer->locked = D.13002;
  emit_byte (logbuffer, 34);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 2);
  emit_ptr (logbuffer, image);
  emit_value (logbuffer, 0);
  D.13003 = logbuffer->data;
  D.13004 = (long unsigned int) nlen;
  memcpy (D.13003, name, D.13004);
  D.13003 = logbuffer->data;
  D.13005 = (sizetype) nlen;
  D.13006 = D.13003 + D.13005;
  logbuffer->data = D.13006;
  D.12999 = logbuffer->locked;
  D.13007 = D.12999 + -1;
  logbuffer->locked = D.13007;
  D.13008 = logbuffer->next;
  if (D.13008 != 0B) goto <D.13009>; else goto <D.13010>;
  <D.13009>:
  safe_dump (prof, logbuffer);
  <D.13010>:
  process_requests (prof);
}


class_loaded (struct MonoProfiler * prof, struct MonoClass * klass, int result)
{
  int runtime_inited.58;
  struct MonoType * D.13020;
  long unsigned int D.13022;
  unsigned int D.13023;
  unsigned int D.13024;
  int D.13025;
  int D.13026;
  int D.13029;
  unsigned char * D.13030;
  long unsigned int D.13031;
  sizetype D.13032;
  unsigned char * D.13033;
  int D.13037;
  struct LogBuffer * D.13038;
  uint64_t now;
  char * name;
  int nlen;
  struct MonoImage * image;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.13015>; else goto <D.13016>;
  <D.13015>:
  return;
  <D.13016>:
  runtime_inited.58 = runtime_inited;
  if (runtime_inited.58 != 0) goto <D.13018>; else goto <D.13019>;
  <D.13018>:
  D.13020 = mono_class_get_type (klass);
  name = mono_type_get_name (D.13020);
  goto <D.13021>;
  <D.13019>:
  name = type_name (klass);
  <D.13021>:
  D.13022 = strlen (name);
  D.13023 = (unsigned int) D.13022;
  D.13024 = D.13023 + 1;
  nlen = (int) D.13024;
  image = mono_class_get_image (klass);
  D.13025 = nlen + 24;
  logbuffer = ensure_logbuf (D.13025);
  now = current_time ();
  D.13026 = logbuffer->locked;
  if (D.13026 != 0) goto <D.13027>; else goto <D.13028>;
  <D.13027>:
  write (2, "class", 5);
  write (2, "\n", 1);
  return;
  <D.13028>:
  D.13026 = logbuffer->locked;
  D.13029 = D.13026 + 1;
  logbuffer->locked = D.13029;
  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.13030 = logbuffer->data;
  D.13031 = (long unsigned int) nlen;
  memcpy (D.13030, name, D.13031);
  D.13030 = logbuffer->data;
  D.13032 = (sizetype) nlen;
  D.13033 = D.13030 + D.13032;
  logbuffer->data = D.13033;
  runtime_inited.58 = runtime_inited;
  if (runtime_inited.58 != 0) goto <D.13034>; else goto <D.13035>;
  <D.13034>:
  mono_free (name);
  goto <D.13036>;
  <D.13035>:
  free (name);
  <D.13036>:
  D.13026 = logbuffer->locked;
  D.13037 = D.13026 + -1;
  logbuffer->locked = D.13037;
  D.13038 = logbuffer->next;
  if (D.13038 != 0B) goto <D.13039>; else goto <D.13040>;
  <D.13039>:
  safe_dump (prof, logbuffer);
  <D.13040>:
  process_requests (prof);
}


type_name (struct MonoClass * klass)
{
  long unsigned int D.13048;
  long unsigned int D.13049;
  char * D.13050;
  char buf[1024];
  char * p;

  try
    {
      push_nesting (&buf, klass);
      D.13048 = strlen (&buf);
      D.13049 = D.13048 + 1;
      p = malloc (D.13049);
      strcpy (p, &buf);
      D.13050 = p;
      return D.13050;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


push_nesting (char * p, struct MonoClass * klass)
{
  char * p.59;
  char D.13057;
  long unsigned int D.13060;
  char * p.60;
  long unsigned int D.13062;
  char * D.13063;
  struct MonoClass * nesting;
  const char * name;
  const char * nspace;

  nesting = mono_class_get_nesting_type (klass);
  if (nesting != 0B) goto <D.13054>; else goto <D.13055>;
  <D.13054>:
  p = push_nesting (p, nesting);
  p.59 = p;
  p = p.59 + 1;
  *p.59 = 47;
  *p = 0;
  <D.13055>:
  name = mono_class_get_name (klass);
  nspace = mono_class_get_namespace (klass);
  D.13057 = *nspace;
  if (D.13057 != 0) goto <D.13058>; else goto <D.13059>;
  <D.13058>:
  strcpy (p, nspace);
  D.13060 = strlen (nspace);
  p = p + D.13060;
  p.60 = p;
  p = p.60 + 1;
  *p.60 = 46;
  *p = 0;
  <D.13059>:
  strcpy (p, name);
  D.13062 = strlen (name);
  p = p + D.13062;
  D.13063 = p;
  return D.13063;
}


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

  D.13070 = __builtin_object_size (__dest, 1);
  D.13069 = __builtin___strcpy_chk (__dest, __src, D.13070);
  return D.13069;
}


gc_roots (struct MonoProfiler * prof, int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  int D.13072;
  int D.13073;
  int D.13074;
  int D.13077;
  int D.13078;
  int D.13079;
  long unsigned int D.13080;
  long unsigned int D.13081;
  void * * D.13082;
  void * D.13083;
  long unsigned int D.13084;
  int * D.13085;
  int D.13086;
  uintptr_t * D.13087;
  long unsigned int D.13088;
  int D.13089;
  int D.13090;
  int i;
  struct LogBuffer * logbuffer;

  D.13072 = num * 18;
  D.13073 = D.13072 + 5;
  logbuffer = ensure_logbuf (D.13073);
  D.13074 = logbuffer->locked;
  if (D.13074 != 0) goto <D.13075>; else goto <D.13076>;
  <D.13075>:
  write (2, "gcroots", 7);
  write (2, "\n", 1);
  return;
  <D.13076>:
  D.13074 = logbuffer->locked;
  D.13077 = D.13074 + 1;
  logbuffer->locked = D.13077;
  emit_byte (logbuffer, 54);
  emit_value (logbuffer, num);
  D.13078 = mono_gc_max_generation ();
  D.13079 = mono_gc_collection_count (D.13078);
  emit_value (logbuffer, D.13079);
  i = 0;
  goto <D.11836>;
  <D.11835>:
  D.13080 = (long unsigned int) i;
  D.13081 = D.13080 * 8;
  D.13082 = objects + D.13081;
  D.13083 = *D.13082;
  emit_obj (logbuffer, D.13083);
  D.13080 = (long unsigned int) i;
  D.13084 = D.13080 * 4;
  D.13085 = root_types + D.13084;
  D.13086 = *D.13085;
  emit_value (logbuffer, D.13086);
  D.13080 = (long unsigned int) i;
  D.13081 = D.13080 * 8;
  D.13087 = extra_info + D.13081;
  D.13088 = *D.13087;
  D.13089 = (int) D.13088;
  emit_value (logbuffer, D.13089);
  i = i + 1;
  <D.11836>:
  if (i < num) goto <D.11835>; else goto <D.11837>;
  <D.11837>:
  D.13074 = logbuffer->locked;
  D.13090 = D.13074 + -1;
  logbuffer->locked = D.13090;
}


gc_handle (struct MonoProfiler * prof, int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  int D.13095;
  int D.13098;
  int D.13105;
  int D.13108;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  now = current_time ();
  D.13095 = logbuffer->locked;
  if (D.13095 != 0) goto <D.13096>; else goto <D.13097>;
  <D.13096>:
  write (2, "gchandle", 8);
  write (2, "\n", 1);
  return;
  <D.13097>:
  D.13095 = logbuffer->locked;
  D.13098 = D.13095 + 1;
  logbuffer->locked = D.13098;
  if (op == 0) goto <D.13099>; else goto <D.13100>;
  <D.13099>:
  emit_byte (logbuffer, 65);
  goto <D.13101>;
  <D.13100>:
  if (op == 1) goto <D.13102>; else goto <D.13103>;
  <D.13102>:
  emit_byte (logbuffer, 81);
  goto <D.13104>;
  <D.13103>:
  return;
  <D.13104>:
  <D.13101>:
  emit_time (logbuffer, now);
  emit_value (logbuffer, type);
  D.13105 = (int) handle;
  emit_value (logbuffer, D.13105);
  if (op == 0) goto <D.13106>; else goto <D.13107>;
  <D.13106>:
  emit_obj (logbuffer, obj);
  <D.13107>:
  D.13095 = logbuffer->locked;
  D.13108 = D.13095 + -1;
  logbuffer->locked = D.13108;
  process_requests (prof);
}


gc_moves (struct MonoProfiler * prof, void * * objects, int num)
{
  int D.13112;
  int D.13113;
  int D.13114;
  int D.13117;
  long unsigned int D.13118;
  long unsigned int D.13119;
  void * * D.13120;
  void * D.13121;
  int D.13122;
  int i;
  uint64_t now;
  struct LogBuffer * logbuffer;

  D.13112 = num * 8;
  D.13113 = D.13112 + 10;
  logbuffer = ensure_logbuf (D.13113);
  now = current_time ();
  D.13114 = logbuffer->locked;
  if (D.13114 != 0) goto <D.13115>; else goto <D.13116>;
  <D.13115>:
  write (2, "gcmove", 6);
  write (2, "\n", 1);
  return;
  <D.13116>:
  D.13114 = logbuffer->locked;
  D.13117 = D.13114 + 1;
  logbuffer->locked = D.13117;
  emit_byte (logbuffer, 49);
  emit_time (logbuffer, now);
  emit_value (logbuffer, num);
  i = 0;
  goto <D.11824>;
  <D.11823>:
  D.13118 = (long unsigned int) i;
  D.13119 = D.13118 * 8;
  D.13120 = objects + D.13119;
  D.13121 = *D.13120;
  emit_obj (logbuffer, D.13121);
  i = i + 1;
  <D.11824>:
  if (i < num) goto <D.11823>; else goto <D.11825>;
  <D.11825>:
  D.13114 = logbuffer->locked;
  D.13122 = D.13114 + -1;
  logbuffer->locked = D.13122;
}


gc_alloc (struct MonoProfiler * prof, struct MonoObject * obj, struct MonoClass * klass)
{
  int iftmp.61;
  int nocalls.62;
  int runtime_inited.63;
  int notraces.64;
  unsigned int D.13135;
  int D.13138;
  int D.13141;
  int D.13142;
  int D.13145;
  struct LogBuffer * D.13146;
  uint64_t now;
  uintptr_t len;
  int do_bt;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.62 = nocalls;
      if (nocalls.62 != 0) goto <D.13130>; else goto <D.13127>;
      <D.13130>:
      runtime_inited.63 = runtime_inited;
      if (runtime_inited.63 != 0) goto <D.13132>; else goto <D.13127>;
      <D.13132>:
      notraces.64 = notraces;
      if (notraces.64 == 0) goto <D.13134>; else goto <D.13127>;
      <D.13134>:
      iftmp.61 = 16;
      goto <D.13128>;
      <D.13127>:
      iftmp.61 = 0;
      <D.13128>:
      do_bt = iftmp.61;
      D.13135 = mono_object_get_size (obj);
      len = (uintptr_t) D.13135;
      len = len + 7;
      len = len & 18446744073709551608;
      if (do_bt != 0) goto <D.13136>; else goto <D.13137>;
      <D.13136>:
      collect_bt (&data);
      <D.13137>:
      logbuffer = ensure_logbuf (160);
      now = current_time ();
      D.13138 = logbuffer->locked;
      if (D.13138 != 0) goto <D.13139>; else goto <D.13140>;
      <D.13139>:
      write (2, "gcalloc", 7);
      write (2, "\n", 1);
      return;
      <D.13140>:
      D.13138 = logbuffer->locked;
      D.13141 = D.13138 + 1;
      logbuffer->locked = D.13141;
      emit_byte (logbuffer, do_bt);
      emit_time (logbuffer, now);
      emit_ptr (logbuffer, klass);
      emit_obj (logbuffer, obj);
      D.13142 = (int) len;
      emit_value (logbuffer, D.13142);
      if (do_bt != 0) goto <D.13143>; else goto <D.13144>;
      <D.13143>:
      emit_bt (logbuffer, &data);
      <D.13144>:
      D.13138 = logbuffer->locked;
      D.13145 = D.13138 + -1;
      logbuffer->locked = D.13145;
      D.13146 = logbuffer->next;
      if (D.13146 != 0B) goto <D.13147>; else goto <D.13148>;
      <D.13147>:
      safe_dump (prof, logbuffer);
      <D.13148>:
      process_requests (prof);
    }
  finally
    {
      data = {CLOBBER};
    }
}


gc_resize (struct MonoProfiler * profiler, int64_t new_size)
{
  int D.13156;
  int D.13159;
  int D.13160;
  int D.13161;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (10);
  now = current_time ();
  D.13156 = logbuffer->locked;
  if (D.13156 != 0) goto <D.13157>; else goto <D.13158>;
  <D.13157>:
  write (2, "gcresize", 8);
  write (2, "\n", 1);
  return;
  <D.13158>:
  D.13156 = logbuffer->locked;
  D.13159 = D.13156 + 1;
  logbuffer->locked = D.13159;
  emit_byte (logbuffer, 33);
  emit_time (logbuffer, now);
  D.13160 = (int) new_size;
  emit_value (logbuffer, D.13160);
  D.13156 = logbuffer->locked;
  D.13161 = D.13156 + -1;
  logbuffer->locked = D.13161;
}


gc_event (struct MonoProfiler * profiler, MonoGCEvent ev, int generation)
{
  int D.13165;
  int D.13168;
  int ev.65;
  int D.13172;
  unsigned int gc_count.66;
  unsigned int gc_count.67;
  int D.13179;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (10);
  now = current_time ();
  D.13165 = logbuffer->locked;
  if (D.13165 != 0) goto <D.13166>; else goto <D.13167>;
  <D.13166>:
  write (2, "gcevent", 7);
  write (2, "\n", 1);
  return;
  <D.13167>:
  D.13165 = logbuffer->locked;
  D.13168 = D.13165 + 1;
  logbuffer->locked = D.13168;
  emit_byte (logbuffer, 17);
  emit_time (logbuffer, now);
  ev.65 = (int) ev;
  emit_value (logbuffer, ev.65);
  emit_value (logbuffer, generation);
  if (ev == 0) goto <D.13170>; else goto <D.13171>;
  <D.13170>:
  profiler->last_gc_gen_started = generation;
  D.13172 = mono_gc_max_generation ();
  if (D.13172 == generation) goto <D.13173>; else goto <D.13174>;
  <D.13173>:
  gc_count.66 = gc_count;
  gc_count.67 = gc_count.66 + 1;
  gc_count = gc_count.67;
  <D.13174>:
  <D.13171>:
  if (ev == 8) goto <D.13177>; else goto <D.13178>;
  <D.13177>:
  heap_walk (profiler);
  <D.13178>:
  D.13165 = logbuffer->locked;
  D.13179 = D.13165 + -1;
  logbuffer->locked = D.13179;
  if (ev == 9) goto <D.13180>; else goto <D.13181>;
  <D.13180>:
  safe_dump (profiler, logbuffer);
  <D.13181>:
}


heap_walk (struct MonoProfiler * profiler)
{
  int do_heap_shot.68;
  unsigned int hs_mode_ms.69;
  long unsigned int last_hs_time.70;
  long unsigned int D.13194;
  long unsigned int D.13195;
  long unsigned int D.13196;
  unsigned int hs_mode_gc.71;
  unsigned int gc_count.72;
  unsigned int D.13203;
  unsigned int hs_mode_ondemand.73;
  int D.13213;
  int D.13214;
  int do_walk;
  uint64_t now;
  struct LogBuffer * logbuffer;

  do_walk = 0;
  do_heap_shot.68 = do_heap_shot;
  if (do_heap_shot.68 == 0) goto <D.13187>; else goto <D.13188>;
  <D.13187>:
  return;
  <D.13188>:
  logbuffer = ensure_logbuf (10);
  now = current_time ();
  hs_mode_ms.69 = hs_mode_ms;
  if (hs_mode_ms.69 != 0) goto <D.13192>; else goto <D.13189>;
  <D.13192>:
  last_hs_time.70 = last_hs_time;
  D.13194 = now - last_hs_time.70;
  D.13195 = D.13194 / 1000000;
  hs_mode_ms.69 = hs_mode_ms;
  D.13196 = (long unsigned int) hs_mode_ms.69;
  if (D.13195 >= D.13196) goto <D.13197>; else goto <D.13189>;
  <D.13197>:
  do_walk = 1;
  goto <D.13190>;
  <D.13189>:
  hs_mode_gc.71 = hs_mode_gc;
  if (hs_mode_gc.71 != 0) goto <D.13201>; else goto <D.13198>;
  <D.13201>:
  gc_count.72 = gc_count;
  hs_mode_gc.71 = hs_mode_gc;
  D.13203 = gc_count.72 % hs_mode_gc.71;
  if (D.13203 == 0) goto <D.13204>; else goto <D.13198>;
  <D.13204>:
  do_walk = 1;
  goto <D.13199>;
  <D.13198>:
  hs_mode_ondemand.73 = hs_mode_ondemand;
  if (hs_mode_ondemand.73 != 0) goto <D.13206>; else goto <D.13207>;
  <D.13206>:
  do_walk = heapshot_requested;
  goto <D.13208>;
  <D.13207>:
  hs_mode_ms.69 = hs_mode_ms;
  if (hs_mode_ms.69 == 0) goto <D.13209>; else goto <D.13210>;
  <D.13209>:
  hs_mode_gc.71 = hs_mode_gc;
  if (hs_mode_gc.71 == 0) goto <D.13211>; else goto <D.13212>;
  <D.13211>:
  D.13213 = profiler->last_gc_gen_started;
  D.13214 = mono_gc_max_generation ();
  if (D.13213 == D.13214) goto <D.13215>; else goto <D.13216>;
  <D.13215>:
  do_walk = 1;
  <D.13216>:
  <D.13212>:
  <D.13210>:
  <D.13208>:
  <D.13199>:
  <D.13190>:
  if (do_walk == 0) goto <D.13217>; else goto <D.13218>;
  <D.13217>:
  return;
  <D.13218>:
  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.13225;
  unsigned int D.13226;
  unsigned int D.13227;
  int D.13228;
  int D.13229;
  int D.13230;
  long unsigned int D.13231;
  long unsigned int D.13232;
  uintptr_t * D.13233;
  long unsigned int D.13234;
  unsigned int D.13235;
  unsigned int D.13236;
  unsigned int D.13237;
  int D.13238;
  struct MonoObject * * D.13239;
  struct MonoObject * D.13240;
  long unsigned int D.13241;
  int D.13242;
  int i;
  uintptr_t last_offset;
  struct LogBuffer * logbuffer;

  last_offset = 0;
  D.13225 = (unsigned int) num;
  D.13226 = D.13225 * 8;
  D.13227 = D.13226 + 20;
  D.13228 = (int) D.13227;
  logbuffer = ensure_logbuf (D.13228);
  emit_byte (logbuffer, 38);
  emit_obj (logbuffer, obj);
  emit_ptr (logbuffer, klass);
  size = size + 7;
  size = size & 18446744073709551608;
  D.13229 = (int) size;
  emit_value (logbuffer, D.13229);
  D.13230 = (int) num;
  emit_value (logbuffer, D.13230);
  i = 0;
  goto <D.11756>;
  <D.11755>:
  D.13231 = (long unsigned int) i;
  D.13232 = D.13231 * 8;
  D.13233 = offsets + D.13232;
  D.13234 = *D.13233;
  D.13235 = (unsigned int) D.13234;
  D.13236 = (unsigned int) last_offset;
  D.13237 = D.13235 - D.13236;
  D.13238 = (int) D.13237;
  emit_value (logbuffer, D.13238);
  D.13231 = (long unsigned int) i;
  D.13232 = D.13231 * 8;
  D.13233 = offsets + D.13232;
  last_offset = *D.13233;
  D.13231 = (long unsigned int) i;
  D.13232 = D.13231 * 8;
  D.13239 = refs + D.13232;
  D.13240 = *D.13239;
  emit_obj (logbuffer, D.13240);
  i = i + 1;
  <D.11756>:
  D.13241 = (long unsigned int) i;
  if (D.13241 < num) goto <D.11755>; else goto <D.11757>;
  <D.11757>:
  D.13242 = 0;
  return D.13242;
}


log_shutdown (struct MonoProfiler * prof)
{
  int D.13245;
  int D.13248;
  long unsigned int D.13249;
  struct StatBuffer * D.13250;
  struct LogBuffer * tlsbuffer.74;
  struct gzFile_s * * D.13254;
  int D.13257;
  struct FILE * D.13260;

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

    try
      {
        c = 1;
        D.13248 = prof->pipes[1];
        write (D.13248, &c, 1);
        D.13249 = prof->helper_thread;
        pthread_join (D.13249, &res);
      }
    finally
      {
        c = {CLOBBER};
        res = {CLOBBER};
      }
  }
  <D.13247>:
  D.13250 = prof->stat_buffers;
  dump_sample_hits (prof, D.13250, 1);
  take_lock ();
  tlsbuffer.74 = tlsbuffer;
  if (tlsbuffer.74 != 0B) goto <D.13252>; else goto <D.13253>;
  <D.13252>:
  tlsbuffer.74 = tlsbuffer;
  dump_buffer (prof, tlsbuffer.74);
  <D.13253>:
  tlsbuffer = 0B;
  release_lock ();
  D.13254 = prof->gzfile;
  if (D.13254 != 0B) goto <D.13255>; else goto <D.13256>;
  <D.13255>:
  D.13254 = prof->gzfile;
  gzclose (D.13254);
  <D.13256>:
  D.13257 = prof->pipe_output;
  if (D.13257 != 0) goto <D.13258>; else goto <D.13259>;
  <D.13258>:
  D.13260 = prof->file;
  pclose (D.13260);
  goto <D.13261>;
  <D.13259>:
  D.13260 = prof->file;
  fclose (D.13260);
  <D.13261>:
  free (prof);
}


dump_sample_hits (struct MonoProfiler * prof, struct StatBuffer * sbuf, int recurse)
{
  struct StatBuffer * D.13268;
  long unsigned int D.13271;
  int D.13272;
  long unsigned int D.13273;
  int D.13274;
  long unsigned int D.13275;
  sizetype D.13276;
  sizetype D.13277;
  sizetype D.13278;
  uintptr_t * D.13279;
  uintptr_t * D.13280;
  int D.13282;
  int D.13283;
  long unsigned int D.13284;
  uintptr_t * D.13285;
  long unsigned int D.13286;
  long unsigned int D.13287;
  long unsigned int D.13288;
  sizetype D.13289;
  sizetype D.13290;
  sizetype D.13291;
  uintptr_t * D.13292;
  long unsigned int D.13293;
  void * D.13294;
  uintptr_t * sample;
  struct LogBuffer * logbuffer;

  if (sbuf == 0B) goto <D.13264>; else goto <D.13265>;
  <D.13264>:
  return;
  <D.13265>:
  if (recurse != 0) goto <D.13266>; else goto <D.13267>;
  <D.13266>:
  D.13268 = sbuf->next;
  if (D.13268 != 0B) goto <D.13269>; else goto <D.13270>;
  <D.13269>:
  D.13268 = sbuf->next;
  dump_sample_hits (prof, D.13268, 1);
  D.13268 = sbuf->next;
  D.13268 = sbuf->next;
  D.13271 = D.13268->size;
  D.13272 = (int) D.13271;
  free_buffer (D.13268, D.13272);
  sbuf->next = 0B;
  <D.13270>:
  <D.13267>:
  sample = &sbuf->buf;
  goto <D.12098>;
  <D.12097>:
  {
    int i;
    int count;
    int type;

    D.13273 = *sample;
    D.13274 = (int) D.13273;
    count = D.13274 & 65535;
    D.13273 = *sample;
    D.13275 = D.13273 >> 16;
    type = (int) D.13275;
    D.13276 = (sizetype) count;
    D.13277 = D.13276 + 3;
    D.13278 = D.13277 * 8;
    D.13279 = sample + D.13278;
    D.13280 = sbuf->data;
    if (D.13279 > D.13280) goto <D.12093>; else goto <D.13281>;
    <D.13281>:
    D.13282 = count * 8;
    D.13283 = D.13282 + 20;
    logbuffer = ensure_logbuf (D.13283);
    emit_byte (logbuffer, 7);
    emit_value (logbuffer, type);
    D.13284 = prof->startup_time;
    D.13285 = sample + 16;
    D.13286 = *D.13285;
    D.13287 = D.13286 * 10000;
    D.13288 = D.13284 + D.13287;
    emit_uvalue (logbuffer, D.13288);
    emit_value (logbuffer, count);
    i = 0;
    goto <D.12095>;
    <D.12094>:
    D.13289 = (sizetype) i;
    D.13290 = D.13289 + 3;
    D.13291 = D.13290 * 8;
    D.13292 = sample + D.13291;
    D.13293 = *D.13292;
    D.13294 = (void *) D.13293;
    emit_ptr (logbuffer, D.13294);
    D.13289 = (sizetype) i;
    D.13290 = D.13289 + 3;
    D.13291 = D.13290 * 8;
    D.13292 = sample + D.13291;
    D.13293 = *D.13292;
    add_code_pointer (D.13293);
    i = i + 1;
    <D.12095>:
    if (i < count) goto <D.12094>; else goto <D.12096>;
    <D.12096>:
    D.13276 = (sizetype) count;
    D.13277 = D.13276 + 3;
    D.13278 = D.13277 * 8;
    sample = sample + D.13278;
  }
  <D.12098>:
  D.13280 = sbuf->data;
  if (D.13280 > sample) goto <D.12097>; else goto <D.12093>;
  <D.12093>:
  dump_unmanaged_coderefs (prof);
}


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

  D.13297 = logbuffer->data;
  D.13298 = &logbuffer->data;
  encode_uleb128 (value, D.13297, D.13298);
  D.13297 = logbuffer->data;
  D.13299 = logbuffer->data_end;
  if (D.13297 > D.13299) goto <D.13300>; else goto <D.13301>;
  <D.13300>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 481, &__PRETTY_FUNCTION__);
  <D.13301>:
}


add_code_pointer (uintptr_t ip)
{
  int num_code_pages.75;
  int D.13303;
  int size_code_pages.76;
  int size_code_pages.77;
  long unsigned int D.13310;
  long unsigned int D.13311;
  uintptr_t * code_pages.78;
  long unsigned int D.13313;
  uintptr_t * D.13314;
  long unsigned int D.13315;
  long unsigned int D.13318;
  long unsigned int D.13321;
  long unsigned int D.13322;
  unsigned int D.13323;
  unsigned int num_code_pages.79;
  unsigned int D.13325;
  int num_code_pages.80;
  uintptr_t i;

  num_code_pages.75 = num_code_pages;
  D.13303 = num_code_pages.75 * 2;
  size_code_pages.76 = size_code_pages;
  if (D.13303 >= size_code_pages.76) goto <D.13305>; else goto <D.13306>;
  <D.13305>:
  {
    uintptr_t * n;
    uintptr_t old_size;

    size_code_pages.76 = size_code_pages;
    old_size = (uintptr_t) size_code_pages.76;
    size_code_pages.76 = size_code_pages;
    size_code_pages.77 = size_code_pages.76 * 2;
    size_code_pages = size_code_pages.77;
    size_code_pages.76 = size_code_pages;
    if (size_code_pages.76 == 0) goto <D.13308>; else goto <D.13309>;
    <D.13308>:
    size_code_pages = 16;
    <D.13309>:
    size_code_pages.76 = size_code_pages;
    D.13310 = (long unsigned int) size_code_pages.76;
    D.13311 = D.13310 * 8;
    n = calloc (D.13311, 1);
    i = 0;
    goto <D.11981>;
    <D.11980>:
    code_pages.78 = code_pages;
    D.13313 = i * 8;
    D.13314 = code_pages.78 + D.13313;
    D.13315 = *D.13314;
    if (D.13315 != 0) goto <D.13316>; else goto <D.13317>;
    <D.13316>:
    size_code_pages.76 = size_code_pages;
    D.13318 = (long unsigned int) size_code_pages.76;
    code_pages.78 = code_pages;
    D.13313 = i * 8;
    D.13314 = code_pages.78 + D.13313;
    D.13315 = *D.13314;
    add_code_page (n, D.13318, D.13315);
    <D.13317>:
    i = i + 1;
    <D.11981>:
    if (i < old_size) goto <D.11980>; else goto <D.11982>;
    <D.11982>:
    code_pages.78 = code_pages;
    if (code_pages.78 != 0B) goto <D.13319>; else goto <D.13320>;
    <D.13319>:
    code_pages.78 = code_pages;
    free (code_pages.78);
    <D.13320>:
    code_pages = n;
  }
  <D.13306>:
  code_pages.78 = code_pages;
  size_code_pages.76 = size_code_pages;
  D.13318 = (long unsigned int) size_code_pages.76;
  D.13321 = ip & 18446744073709551104;
  D.13322 = add_code_page (code_pages.78, D.13318, D.13321);
  D.13323 = (unsigned int) D.13322;
  num_code_pages.75 = num_code_pages;
  num_code_pages.79 = (unsigned int) num_code_pages.75;
  D.13325 = D.13323 + num_code_pages.79;
  num_code_pages.80 = (int) D.13325;
  num_code_pages = num_code_pages.80;
}


add_code_page (uintptr_t * hash, uintptr_t hsize, uintptr_t page)
{
  long unsigned int D.13328;
  long unsigned int D.13330;
  uintptr_t * D.13331;
  long unsigned int D.13332;
  long unsigned int D.13334;
  long unsigned int D.13335;
  uintptr_t D.13337;
  uintptr_t i;
  uintptr_t start_pos;

  D.13328 = page >> 9;
  start_pos = D.13328 % hsize;
  i = start_pos;
  <D.11972>:
  D.13330 = i * 8;
  D.13331 = hash + D.13330;
  D.13332 = *D.13331;
  if (D.13332 != 0) goto <D.13333>; else goto <D.13329>;
  <D.13333>:
  D.13330 = i * 8;
  D.13331 = hash + D.13330;
  D.13332 = *D.13331;
  D.13334 = D.13332 ^ page;
  D.13335 = D.13334 & 18446744073709551104;
  if (D.13335 == 0) goto <D.13336>; else goto <D.13329>;
  <D.13336>:
  D.13337 = 0;
  return D.13337;
  <D.13329>:
  D.13330 = i * 8;
  D.13331 = hash + D.13330;
  D.13332 = *D.13331;
  if (D.13332 == 0) goto <D.13338>; else goto <D.13339>;
  <D.13338>:
  D.13330 = i * 8;
  D.13331 = hash + D.13330;
  *D.13331 = page;
  D.13337 = 1;
  return D.13337;
  <D.13339>:
  i = i + 1;
  if (i == hsize) goto <D.13340>; else goto <D.13341>;
  <D.13340>:
  i = 0;
  <D.13341>:
  if (i != start_pos) goto <D.11972>; else goto <D.11973>;
  <D.11973>:
  printf ("failed code page store\n");
  D.13337 = 0;
  return D.13337;
}


dump_unmanaged_coderefs (struct MonoProfiler * prof)
{
  int D.13343;
  uintptr_t * code_pages.81;
  long unsigned int D.13349;
  long unsigned int D.13350;
  uintptr_t * D.13351;
  long unsigned int D.13352;
  long unsigned int D.13354;
  long unsigned int D.13355;
  int size_code_pages.82;
  int i;
  const char * last_symbol;
  uintptr_t addr;
  uintptr_t page_end;

  D.13343 = load_binaries (prof);
  if (D.13343 != 0) goto <D.13344>; else goto <D.13345>;
  <D.13344>:
  return;
  <D.13345>:
  i = 0;
  goto <D.12081>;
  <D.12080>:
  {
    const char * sym;

    code_pages.81 = code_pages;
    D.13349 = (long unsigned int) i;
    D.13350 = D.13349 * 8;
    D.13351 = code_pages.81 + D.13350;
    D.13352 = *D.13351;
    if (D.13352 == 0) goto <D.13346>; else goto <D.13353>;
    <D.13353>:
    code_pages.81 = code_pages;
    D.13349 = (long unsigned int) i;
    D.13350 = D.13349 * 8;
    D.13351 = code_pages.81 + D.13350;
    D.13352 = *D.13351;
    D.13354 = D.13352 & 1;
    if (D.13354 != 0) goto <D.13346>; else goto <D.13347>;
    <D.13346>:
    // predicted unlikely by continue predictor.
    goto <D.12075>;
    <D.13347>:
    last_symbol = 0B;
    code_pages.81 = code_pages;
    D.13349 = (long unsigned int) i;
    D.13350 = D.13349 * 8;
    D.13351 = code_pages.81 + D.13350;
    D.13352 = *D.13351;
    addr = D.13352 & 18446744073709551104;
    page_end = addr + 512;
    code_pages.81 = code_pages;
    D.13349 = (long unsigned int) i;
    D.13350 = D.13349 * 8;
    D.13351 = code_pages.81 + D.13350;
    code_pages.81 = code_pages;
    D.13349 = (long unsigned int) i;
    D.13350 = D.13349 * 8;
    D.13351 = code_pages.81 + D.13350;
    D.13352 = *D.13351;
    D.13355 = D.13352 | 1;
    *D.13351 = D.13355;
    goto <D.12078>;
    <D.12077>:
    sym = symbol_for (addr);
    if (sym != 0B) goto <D.13356>; else goto <D.13357>;
    <D.13356>:
    if (sym == last_symbol) goto <D.13358>; else goto <D.13359>;
    <D.13358>:
    // predicted unlikely by continue predictor.
    goto <D.12076>;
    <D.13359>:
    <D.13357>:
    last_symbol = sym;
    if (sym == 0B) goto <D.13360>; else goto <D.13361>;
    <D.13360>:
    // predicted unlikely by continue predictor.
    goto <D.12076>;
    <D.13361>:
    dump_usym (sym, addr, 0);
    <D.12076>:
    addr = addr + 16;
    <D.12078>:
    if (addr < page_end) goto <D.12077>; else goto <D.12079>;
    <D.12079>:
  }
  <D.12075>:
  i = i + 1;
  <D.12081>:
  size_code_pages.82 = size_code_pages;
  if (i < size_code_pages.82) goto <D.12080>; else goto <D.12082>;
  <D.12082>:
}


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

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


elf_dl_callback (struct dl_phdr_info * info, size_t size, void * data)
{
  long unsigned int D.13368;
  void * D.13369;
  int D.13372;
  char D.13375;
  long int D.13378;
  void * D.13381;
  char * D.13382;
  struct BinaryObject * D.13383;
  const struct Elf64_Phdr * D.13386;
  long unsigned int D.13387;
  long unsigned int D.13388;
  const struct Elf64_Phdr * D.13389;
  unsigned int D.13390;
  long unsigned int D.13393;
  long unsigned int D.13394;
  long unsigned int D.13395;
  long unsigned int D.13396;
  long unsigned int D.13399;
  long unsigned int D.13400;
  short unsigned int D.13403;
  int D.13404;
  int D.13405;
  const char * D.13410;
  char D.13412;
  long unsigned int D.13415;
  struct Elf64_Dyn * D.13416;
  long int D.13417;
  int do_debug.83;
  long unsigned int D.13425;
  Elf64_Word * D.13434;
  unsigned int D.13435;
  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.13368 = info->dlpi_addr;
      a = (char *) D.13368;
      dyn = 0B;
      symtab = 0B;
      hash_table = 0B;
      header = 0B;
      strtab = 0B;
      obj = prof->binary_objects;
      goto <D.12050>;
      <D.12049>:
      D.13369 = obj->addr;
      if (D.13369 == a) goto <D.13370>; else goto <D.13371>;
      <D.13370>:
      D.13372 = 0;
      return D.13372;
      <D.13371>:
      obj = obj->next;
      <D.12050>:
      if (obj != 0B) goto <D.12049>; else goto <D.12051>;
      <D.12051>:
      filename = info->dlpi_name;
      D.13368 = info->dlpi_addr;
      if (D.13368 == 0) goto <D.13373>; else goto <D.13374>;
      <D.13373>:
      D.13375 = *filename;
      if (D.13375 == 0) goto <D.13376>; else goto <D.13377>;
      <D.13376>:
      {
        int l;

        D.13378 = readlink ("/proc/self/exe", &buf, 255);
        l = (int) D.13378;
        if (l > 0) goto <D.13379>; else goto <D.13380>;
        <D.13379>:
        buf[l] = 0;
        filename = &buf;
        <D.13380>:
      }
      <D.13377>:
      <D.13374>:
      obj = calloc (24, 1);
      D.13368 = info->dlpi_addr;
      D.13381 = (void *) D.13368;
      obj->addr = D.13381;
      D.13382 = pstrdup (filename);
      obj->name = D.13382;
      D.13383 = prof->binary_objects;
      obj->next = D.13383;
      prof->binary_objects = obj;
      a = 0B;
      i = 0;
      goto <D.12054>;
      <D.12053>:
      D.13386 = info->dlpi_phdr;
      D.13387 = (long unsigned int) i;
      D.13388 = D.13387 * 56;
      D.13389 = D.13386 + D.13388;
      D.13390 = D.13389->p_type;
      if (D.13390 == 1) goto <D.13391>; else goto <D.13384>;
      <D.13391>:
      if (header == 0B) goto <D.13392>; else goto <D.13384>;
      <D.13392>:
      D.13368 = info->dlpi_addr;
      D.13386 = info->dlpi_phdr;
      D.13387 = (long unsigned int) i;
      D.13388 = D.13387 * 56;
      D.13389 = D.13386 + D.13388;
      D.13393 = D.13389->p_vaddr;
      D.13394 = D.13368 + D.13393;
      header = (struct Elf64_Ehdr *) D.13394;
      D.13395 = BIT_FIELD_REF <*header, 64, 0>;
      D.13396 = D.13395 & 4294967295;
      if (D.13396 != 1179403647) goto <D.13397>; else goto <D.13398>;
      <D.13397>:
      header = 0B;
      <D.13398>:
      D.13368 = info->dlpi_addr;
      D.13386 = info->dlpi_phdr;
      D.13387 = (long unsigned int) i;
      D.13388 = D.13387 * 56;
      D.13389 = D.13386 + D.13388;
      D.13393 = D.13389->p_vaddr;
      D.13394 = D.13368 + D.13393;
      D.13386 = info->dlpi_phdr;
      D.13387 = (long unsigned int) i;
      D.13388 = D.13387 * 56;
      D.13389 = D.13386 + D.13388;
      D.13399 = D.13389->p_offset;
      D.13386 = info->dlpi_phdr;
      D.13387 = (long unsigned int) i;
      D.13388 = D.13387 * 56;
      D.13389 = D.13386 + D.13388;
      D.13400 = D.13389->p_memsz;
      dump_ubin (filename, D.13394, D.13399, D.13400);
      goto <D.13385>;
      <D.13384>:
      D.13386 = info->dlpi_phdr;
      D.13387 = (long unsigned int) i;
      D.13388 = D.13387 * 56;
      D.13389 = D.13386 + D.13388;
      D.13390 = D.13389->p_type;
      if (D.13390 == 2) goto <D.13401>; else goto <D.13402>;
      <D.13401>:
      D.13368 = info->dlpi_addr;
      D.13386 = info->dlpi_phdr;
      D.13387 = (long unsigned int) i;
      D.13388 = D.13387 * 56;
      D.13389 = D.13386 + D.13388;
      D.13393 = D.13389->p_vaddr;
      D.13394 = D.13368 + D.13393;
      dyn = (struct Elf64_Dyn *) D.13394;
      <D.13402>:
      <D.13385>:
      i = i + 1;
      <D.12054>:
      D.13403 = info->dlpi_phnum;
      D.13404 = (int) D.13403;
      if (D.13404 > i) goto <D.12053>; else goto <D.12055>;
      <D.12055>:
      D.13368 = info->dlpi_addr;
      D.13381 = (void *) D.13368;
      D.13405 = read_elf_symbols (prof, filename, D.13381);
      if (D.13405 != 0) goto <D.13406>; else goto <D.13407>;
      <D.13406>:
      D.13372 = 0;
      return D.13372;
      <D.13407>:
      D.13410 = info->dlpi_name;
      if (D.13410 == 0B) goto <D.13408>; else goto <D.13411>;
      <D.13411>:
      D.13410 = info->dlpi_name;
      D.13412 = *D.13410;
      if (D.13412 == 0) goto <D.13408>; else goto <D.13409>;
      <D.13408>:
      D.13372 = 0;
      return D.13372;
      <D.13409>:
      if (dyn == 0B) goto <D.13413>; else goto <D.13414>;
      <D.13413>:
      D.13372 = 0;
      return D.13372;
      <D.13414>:
      i = 0;
      goto <D.12057>;
      <D.12056>:
      D.13387 = (long unsigned int) i;
      D.13415 = D.13387 * 16;
      D.13416 = dyn + D.13415;
      D.13417 = D.13416->d_tag;
      if (D.13417 == 6) goto <D.13418>; else goto <D.13419>;
      <D.13418>:
      if (symtab != 0B) goto <D.13420>; else goto <D.13421>;
      <D.13420>:
      do_debug.83 = do_debug;
      if (do_debug.83 != 0) goto <D.13423>; else goto <D.13424>;
      <D.13423>:
      printf ("multiple symtabs: %d\n", i);
      <D.13424>:
      <D.13421>:
      D.13387 = (long unsigned int) i;
      D.13415 = D.13387 * 16;
      D.13416 = dyn + D.13415;
      D.13425 = D.13416->d_un.d_ptr;
      symtab = a + D.13425;
      goto <D.13426>;
      <D.13419>:
      D.13387 = (long unsigned int) i;
      D.13415 = D.13387 * 16;
      D.13416 = dyn + D.13415;
      D.13417 = D.13416->d_tag;
      if (D.13417 == 4) goto <D.13427>; else goto <D.13428>;
      <D.13427>:
      D.13387 = (long unsigned int) i;
      D.13415 = D.13387 * 16;
      D.13416 = dyn + D.13415;
      D.13425 = D.13416->d_un.d_ptr;
      hash_table = a + D.13425;
      goto <D.13429>;
      <D.13428>:
      D.13387 = (long unsigned int) i;
      D.13415 = D.13387 * 16;
      D.13416 = dyn + D.13415;
      D.13417 = D.13416->d_tag;
      if (D.13417 == 5) goto <D.13430>; else goto <D.13431>;
      <D.13430>:
      D.13387 = (long unsigned int) i;
      D.13415 = D.13387 * 16;
      D.13416 = dyn + D.13415;
      D.13425 = D.13416->d_un.d_ptr;
      strtab = a + D.13425;
      <D.13431>:
      <D.13429>:
      <D.13426>:
      i = i + 1;
      <D.12057>:
      D.13387 = (long unsigned int) i;
      D.13415 = D.13387 * 16;
      D.13416 = dyn + D.13415;
      D.13417 = D.13416->d_tag;
      if (D.13417 != 0) goto <D.12056>; else goto <D.12058>;
      <D.12058>:
      if (hash_table == 0B) goto <D.13432>; else goto <D.13433>;
      <D.13432>:
      D.13372 = 0;
      return D.13372;
      <D.13433>:
      D.13434 = hash_table + 4;
      D.13435 = *D.13434;
      num_sym = (int) D.13435;
      D.13368 = info->dlpi_addr;
      D.13381 = (void *) D.13368;
      dump_elf_symbols (symtab, num_sym, strtab, D.13381);
      D.13372 = 0;
      return D.13372;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


readlink (const char * restrict __path, char * restrict __buf, size_t __len)
{
  long unsigned int D.13441;
  int D.13444;
  ssize_t D.13447;
  long unsigned int D.13448;
  long unsigned int D.13449;
  long unsigned int D.13452;

  D.13441 = __builtin_object_size (__buf, 1);
  if (D.13441 != 18446744073709551615) goto <D.13442>; else goto <D.13443>;
  <D.13442>:
  D.13444 = __builtin_constant_p (__len);
  if (D.13444 == 0) goto <D.13445>; else goto <D.13446>;
  <D.13445>:
  D.13448 = __builtin_object_size (__buf, 1);
  D.13447 = __readlink_chk (__path, __buf, __len, D.13448);
  return D.13447;
  <D.13446>:
  D.13449 = __builtin_object_size (__buf, 1);
  if (D.13449 < __len) goto <D.13450>; else goto <D.13451>;
  <D.13450>:
  D.13452 = __builtin_object_size (__buf, 1);
  D.13447 = __readlink_chk_warn (__path, __buf, __len, D.13452);
  return D.13447;
  <D.13451>:
  <D.13443>:
  D.13447 = __readlink_alias (__path, __buf, __len);
  return D.13447;
}


pstrdup (const char * s)
{
  long unsigned int D.13454;
  unsigned int D.13455;
  unsigned int D.13456;
  long unsigned int D.13457;
  char * D.13458;
  int len;
  char * p;

  D.13454 = strlen (s);
  D.13455 = (unsigned int) D.13454;
  D.13456 = D.13455 + 1;
  len = (int) D.13456;
  D.13457 = (long unsigned int) len;
  p = malloc (D.13457);
  D.13457 = (long unsigned int) len;
  memcpy (p, s, D.13457);
  D.13458 = p;
  return D.13458;
}


dump_ubin (const char * filename, uintptr_t load_addr, uint64_t offset, uintptr_t size)
{
  long unsigned int D.13460;
  unsigned int D.13461;
  unsigned int D.13462;
  int D.13463;
  long int load_addr.84;
  unsigned char * D.13465;
  long unsigned int D.13466;
  sizetype D.13467;
  unsigned char * D.13468;
  uint64_t now;
  struct LogBuffer * logbuffer;
  int len;

  D.13460 = strlen (filename);
  D.13461 = (unsigned int) D.13460;
  D.13462 = D.13461 + 1;
  len = (int) D.13462;
  now = current_time ();
  D.13463 = len + 20;
  logbuffer = ensure_logbuf (D.13463);
  emit_byte (logbuffer, 39);
  emit_time (logbuffer, now);
  load_addr.84 = (long int) load_addr;
  emit_svalue (logbuffer, load_addr.84);
  emit_uvalue (logbuffer, offset);
  emit_uvalue (logbuffer, size);
  D.13465 = logbuffer->data;
  D.13466 = (long unsigned int) len;
  memcpy (D.13465, filename, D.13466);
  D.13465 = logbuffer->data;
  D.13467 = (sizetype) len;
  D.13468 = D.13465 + D.13467;
  logbuffer->data = D.13468;
}


read_elf_symbols (struct MonoProfiler * prof, const char * filename, void * load_addr)
{
  int D.13473;
  int D.13474;
  long int D.13477;
  long unsigned int D.13480;
  long unsigned int D.13481;
  long unsigned int D.13484;
  short unsigned int D.13485;
  int D.13486;
  short unsigned int D.13487;
  int D.13488;
  int D.13489;
  sizetype D.13490;
  long unsigned int D.13491;
  unsigned int D.13492;
  unsigned int D.13495;
  unsigned int D.13496;
  unsigned int D.13497;
  sizetype D.13498;
  sizetype D.13499;
  sizetype D.13500;
  short unsigned int D.13501;
  int D.13502;
  long unsigned int D.13506;
  long unsigned int D.13507;
  long unsigned int D.13508;
  long unsigned int D.13509;
  long unsigned int D.13510;
  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.13471>; else goto <D.13472>;
      <D.13471>:
      D.13473 = 0;
      return D.13473;
      <D.13472>:
      D.13474 = fstat (fd, &statb);
      if (D.13474 != 0) goto <D.13475>; else goto <D.13476>;
      <D.13475>:
      close (fd);
      D.13473 = 0;
      return D.13473;
      <D.13476>:
      D.13477 = statb.st_size;
      file_size = (uint64_t) D.13477;
      data = mmap (0B, file_size, 1, 2, fd, 0);
      close (fd);
      if (data == -1B) goto <D.13478>; else goto <D.13479>;
      <D.13478>:
      D.13473 = 0;
      return D.13473;
      <D.13479>:
      header = data;
      D.13480 = BIT_FIELD_REF <*header, 64, 0>;
      D.13481 = D.13480 & 4294967295;
      if (D.13481 != 1179403647) goto <D.13482>; else goto <D.13483>;
      <D.13482>:
      munmap (data, file_size);
      D.13473 = 0;
      return D.13473;
      <D.13483>:
      D.13484 = header->e_shoff;
      sheader = data + D.13484;
      D.13485 = header->e_shentsize;
      D.13486 = (int) D.13485;
      D.13487 = header->e_shstrndx;
      D.13488 = (int) D.13487;
      D.13489 = D.13486 * D.13488;
      D.13490 = (sizetype) D.13489;
      shstrtabh = sheader + D.13490;
      D.13491 = shstrtabh->sh_offset;
      strtab = data + D.13491;
      i = 0;
      goto <D.12031>;
      <D.12030>:
      D.13492 = sheader->sh_type;
      if (D.13492 == 2) goto <D.13493>; else goto <D.13494>;
      <D.13493>:
      symtabh = sheader;
      D.13484 = header->e_shoff;
      D.13495 = sheader->sh_link;
      D.13485 = header->e_shentsize;
      D.13496 = (unsigned int) D.13485;
      D.13497 = D.13495 * D.13496;
      D.13498 = (sizetype) D.13497;
      D.13499 = D.13484 + D.13498;
      strtabh = data + D.13499;
      goto <D.12029>;
      <D.13494>:
      D.13485 = header->e_shentsize;
      D.13500 = (sizetype) D.13485;
      sheader = sheader + D.13500;
      i = i + 1;
      <D.12031>:
      D.13501 = header->e_shnum;
      D.13502 = (int) D.13501;
      if (D.13502 > i) goto <D.12030>; else goto <D.12029>;
      <D.12029>:
      if (symtabh == 0B) goto <D.13503>; else goto <D.13505>;
      <D.13505>:
      if (strtabh == 0B) goto <D.13503>; else goto <D.13504>;
      <D.13503>:
      munmap (data, file_size);
      D.13473 = 0;
      return D.13473;
      <D.13504>:
      D.13506 = strtabh->sh_offset;
      strtab = data + D.13506;
      D.13507 = symtabh->sh_size;
      D.13508 = symtabh->sh_entsize;
      D.13509 = D.13507 / D.13508;
      num_symbols = (int) D.13509;
      D.13510 = symtabh->sh_offset;
      symbols = data + D.13510;
      dump_elf_symbols (symbols, num_symbols, strtab, load_addr);
      munmap (data, file_size);
      D.13473 = 1;
      return D.13473;
    }
  finally
    {
      statb = {CLOBBER};
    }
}


open (const char * __path, int __oflag)
{
  int D.13515;
  int D.13518;
  int D.13523;
  int D.13525;
  int D.13526;
  int D.13529;
  int D.13530;

  D.13515 = __builtin_va_arg_pack_len ();
  if (D.13515 > 1) goto <D.13516>; else goto <D.13517>;
  <D.13516>:
  __open_too_many_args ();
  <D.13517>:
  D.13518 = __builtin_constant_p (__oflag);
  if (D.13518 != 0) goto <D.13519>; else goto <D.13520>;
  <D.13519>:
  D.13523 = __oflag & 64;
  if (D.13523 != 0) goto <D.13521>; else goto <D.13524>;
  <D.13524>:
  D.13525 = __oflag & 4259840;
  if (D.13525 == 4259840) goto <D.13521>; else goto <D.13522>;
  <D.13521>:
  D.13526 = __builtin_va_arg_pack_len ();
  if (D.13526 <= 0) goto <D.13527>; else goto <D.13528>;
  <D.13527>:
  __open_missing_mode ();
  D.13529 = __open_2 (__path, __oflag);
  return D.13529;
  <D.13528>:
  <D.13522>:
  D.13529 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.13529;
  <D.13520>:
  D.13530 = __builtin_va_arg_pack_len ();
  if (D.13530 <= 0) goto <D.13531>; else goto <D.13532>;
  <D.13531>:
  D.13529 = __open_2 (__path, __oflag);
  return D.13529;
  <D.13532>:
  D.13529 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.13529;
}


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

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


dump_elf_symbols (struct Elf64_Sym * symbols, int num_symbols, const char * strtab, void * load_addr)
{
  long unsigned int D.13540;
  long unsigned int D.13541;
  struct Elf64_Sym * D.13542;
  unsigned int D.13543;
  sizetype D.13544;
  long unsigned int D.13548;
  unsigned char D.13550;
  int D.13551;
  int D.13552;
  long unsigned int D.13553;
  long unsigned int load_addr.85;
  long unsigned int D.13555;
  int i;

  i = 0;
  goto <D.12009>;
  <D.12008>:
  {
    const char * sym;

    D.13540 = (long unsigned int) i;
    D.13541 = D.13540 * 24;
    D.13542 = symbols + D.13541;
    D.13543 = D.13542->st_name;
    D.13544 = (sizetype) D.13543;
    sym = strtab + D.13544;
    D.13540 = (long unsigned int) i;
    D.13541 = D.13540 * 24;
    D.13542 = symbols + D.13541;
    D.13543 = D.13542->st_name;
    if (D.13543 == 0) goto <D.13545>; else goto <D.13547>;
    <D.13547>:
    D.13540 = (long unsigned int) i;
    D.13541 = D.13540 * 24;
    D.13542 = symbols + D.13541;
    D.13548 = D.13542->st_size;
    if (D.13548 == 0) goto <D.13545>; else goto <D.13549>;
    <D.13549>:
    D.13540 = (long unsigned int) i;
    D.13541 = D.13540 * 24;
    D.13542 = symbols + D.13541;
    D.13550 = D.13542->st_info;
    D.13551 = (int) D.13550;
    D.13552 = D.13551 & 15;
    if (D.13552 != 2) goto <D.13545>; else goto <D.13546>;
    <D.13545>:
    // predicted unlikely by continue predictor.
    goto <D.12007>;
    <D.13546>:
    D.13540 = (long unsigned int) i;
    D.13541 = D.13540 * 24;
    D.13542 = symbols + D.13541;
    D.13553 = D.13542->st_value;
    load_addr.85 = (long unsigned int) load_addr;
    D.13555 = D.13553 + load_addr.85;
    D.13540 = (long unsigned int) i;
    D.13541 = D.13540 * 24;
    D.13542 = symbols + D.13541;
    D.13548 = D.13542->st_size;
    dump_usym (sym, D.13555, D.13548);
  }
  <D.12007>:
  i = i + 1;
  <D.12009>:
  if (i < num_symbols) goto <D.12008>; else goto <D.12010>;
  <D.12010>:
}


symbol_for (uintptr_t code)
{
  int D.13556;
  const char * D.13559;
  const char * D.13562;
  void * ip;
  struct Dl_info di;

  try
    {
      ip = (void *) code;
      D.13556 = dladdr (ip, &di);
      if (D.13556 != 0) goto <D.13557>; else goto <D.13558>;
      <D.13557>:
      D.13559 = di.dli_sname;
      if (D.13559 != 0B) goto <D.13560>; else goto <D.13561>;
      <D.13560>:
      D.13562 = di.dli_sname;
      return D.13562;
      <D.13561>:
      goto <D.13563>;
      <D.13558>:
      <D.13563>:
      D.13562 = 0B;
      return D.13562;
    }
  finally
    {
      di = {CLOBBER};
    }
}


dump_usym (const char * name, uintptr_t value, uintptr_t size)
{
  long unsigned int D.13566;
  unsigned int D.13567;
  unsigned int D.13568;
  int D.13569;
  void * value.86;
  int D.13571;
  unsigned char * D.13572;
  long unsigned int D.13573;
  sizetype D.13574;
  unsigned char * D.13575;
  struct LogBuffer * logbuffer;
  int len;

  D.13566 = strlen (name);
  D.13567 = (unsigned int) D.13566;
  D.13568 = D.13567 + 1;
  len = (int) D.13568;
  D.13569 = len + 20;
  logbuffer = ensure_logbuf (D.13569);
  emit_byte (logbuffer, 23);
  value.86 = (void *) value;
  emit_ptr (logbuffer, value.86);
  D.13571 = (int) size;
  emit_value (logbuffer, D.13571);
  D.13572 = logbuffer->data;
  D.13573 = (long unsigned int) len;
  memcpy (D.13572, name, D.13573);
  D.13572 = logbuffer->data;
  D.13574 = (sizetype) len;
  D.13575 = D.13572 + D.13574;
  logbuffer->data = D.13575;
}


set_sample_mode (char * val, int allow_empty)
{
  int D.12233;
  int iftmp.87;
  int D.12232;
  const char[5] * D.13584;
  unsigned char D.13585;
  int D.13586;
  unsigned char D.13587;
  int D.13588;
  const unsigned char * D.13593;
  unsigned char D.13594;
  int D.13595;
  const unsigned char * D.13596;
  unsigned char D.13597;
  int D.13598;
  const unsigned char * D.13603;
  unsigned char D.13604;
  int D.13605;
  const unsigned char * D.13606;
  unsigned char D.13607;
  int D.13608;
  const unsigned char * D.13613;
  unsigned char D.13614;
  int D.13615;
  const unsigned char * D.13616;
  unsigned char D.13617;
  int D.13618;
  const char * D.13622;
  long unsigned int D.13623;
  long unsigned int D.13624;
  int D.13625;
  int sample_type.88;
  sizetype D.13629;
  char D.13632;
  char * D.13635;
  long unsigned int D.13636;
  char * end.89;
  int count.90;
  char * end;
  char * maybe_freq;
  unsigned int count;
  const struct SampleMode * smode;

  try
    {
      maybe_freq = 0B;
      smode = &sample_modes;
      do_mono_sample = 1;
      if (allow_empty != 0) goto <D.13577>; else goto <D.13578>;
      <D.13577>:
      if (val == 0B) goto <D.13579>; else goto <D.13580>;
      <D.13579>:
      sample_type = 1;
      sample_freq = 1000;
      return;
      <D.13580>:
      <D.13578>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = val;
          D.13584 = "mono";
          D.13585 = MEM[(const unsigned char *)D.13584];
          D.13586 = (int) D.13585;
          D.13587 = *__s2;
          D.13588 = (int) D.13587;
          __result = D.13586 - D.13588;
          {
            if (__s2_len != 0) goto <D.13589>; else goto <D.13590>;
            <D.13589>:
            if (__result == 0) goto <D.13591>; else goto <D.13592>;
            <D.13591>:
            D.13593 = &MEM[(void *)"mono" + 1B];
            D.13594 = *D.13593;
            D.13595 = (int) D.13594;
            D.13596 = __s2 + 1;
            D.13597 = *D.13596;
            D.13598 = (int) D.13597;
            __result = D.13595 - D.13598;
            if (__s2_len > 1) goto <D.13599>; else goto <D.13600>;
            <D.13599>:
            if (__result == 0) goto <D.13601>; else goto <D.13602>;
            <D.13601>:
            D.13603 = &MEM[(void *)"mono" + 2B];
            D.13604 = *D.13603;
            D.13605 = (int) D.13604;
            D.13606 = __s2 + 2;
            D.13607 = *D.13606;
            D.13608 = (int) D.13607;
            __result = D.13605 - D.13608;
            if (__s2_len > 2) goto <D.13609>; else goto <D.13610>;
            <D.13609>:
            if (__result == 0) goto <D.13611>; else goto <D.13612>;
            <D.13611>:
            D.13613 = &MEM[(void *)"mono" + 3B];
            D.13614 = *D.13613;
            D.13615 = (int) D.13614;
            D.13616 = __s2 + 3;
            D.13617 = *D.13616;
            D.13618 = (int) D.13617;
            __result = D.13615 - D.13618;
            <D.13612>:
            <D.13610>:
            <D.13602>:
            <D.13600>:
            <D.13592>:
            <D.13590>:
          }
          D.12232 = __result;
        }
        iftmp.87 = -D.12232;
        goto <D.13619>;
        <D.13583>:
        iftmp.87 = __builtin_strcmp (val, "mono");
        <D.13619>:
        D.12233 = iftmp.87;
      }
      if (D.12233 == 0) goto <D.13620>; else goto <D.13621>;
      <D.13620>:
      do_mono_sample = 1;
      sample_type = 1;
      free (val);
      return;
      <D.13621>:
      smode = &sample_modes;
      goto <D.12246>;
      <D.12245>:
      {
        int l;

        D.13622 = smode->name;
        D.13623 = strlen (D.13622);
        l = (int) D.13623;
        D.13622 = smode->name;
        D.13624 = (long unsigned int) l;
        D.13625 = strncmp (val, D.13622, D.13624);
        if (D.13625 == 0) goto <D.13626>; else goto <D.13627>;
        <D.13626>:
        sample_type.88 = smode->sample_mode;
        sample_type = sample_type.88;
        D.13629 = (sizetype) l;
        maybe_freq = val + D.13629;
        goto <D.12244>;
        <D.13627>:
      }
      smode = smode + 16;
      <D.12246>:
      D.13622 = smode->name;
      if (D.13622 != 0B) goto <D.12245>; else goto <D.12244>;
      <D.12244>:
      D.13622 = smode->name;
      if (D.13622 == 0B) goto <D.13630>; else goto <D.13631>;
      <D.13630>:
      usage (1);
      <D.13631>:
      D.13632 = *maybe_freq;
      if (D.13632 == 47) goto <D.13633>; else goto <D.13634>;
      <D.13633>:
      D.13635 = maybe_freq + 1;
      D.13636 = strtoul (D.13635, &end, 10);
      count = (unsigned int) D.13636;
      D.13635 = maybe_freq + 1;
      end.89 = end;
      if (D.13635 == end.89) goto <D.13638>; else goto <D.13639>;
      <D.13638>:
      usage (1);
      <D.13639>:
      count.90 = (int) count;
      sample_freq = count.90;
      goto <D.13641>;
      <D.13634>:
      D.13632 = *maybe_freq;
      if (D.13632 != 0) goto <D.13642>; else goto <D.13643>;
      <D.13642>:
      usage (1);
      goto <D.13644>;
      <D.13643>:
      sample_freq = 1000;
      <D.13644>:
      <D.13641>:
      free (val);
    }
  finally
    {
      end = {CLOBBER};
    }
}


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

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


set_hsmode (char * val, int allow_empty)
{
  int D.12261;
  int iftmp.91;
  int D.12260;
  const char[9] * D.13659;
  unsigned char D.13660;
  int D.13661;
  unsigned char D.13662;
  int D.13663;
  const unsigned char * D.13668;
  unsigned char D.13669;
  int D.13670;
  const unsigned char * D.13671;
  unsigned char D.13672;
  int D.13673;
  const unsigned char * D.13678;
  unsigned char D.13679;
  int D.13680;
  const unsigned char * D.13681;
  unsigned char D.13682;
  int D.13683;
  const unsigned char * D.13688;
  unsigned char D.13689;
  int D.13690;
  const unsigned char * D.13691;
  unsigned char D.13692;
  int D.13693;
  long unsigned int D.13697;
  char * end.92;
  int D.12270;
  int iftmp.93;
  int D.12269;
  const char[3] * D.13704;
  unsigned char D.13705;
  int D.13706;
  unsigned char D.13707;
  int D.13708;
  const unsigned char * D.13713;
  unsigned char D.13714;
  int D.13715;
  const unsigned char * D.13716;
  unsigned char D.13717;
  int D.13718;
  const unsigned char * D.13723;
  unsigned char D.13724;
  int D.13725;
  const unsigned char * D.13726;
  unsigned char D.13727;
  int D.13728;
  const unsigned char * D.13733;
  unsigned char D.13734;
  int D.13735;
  const unsigned char * D.13736;
  unsigned char D.13737;
  int D.13738;
  int D.12279;
  int iftmp.94;
  int D.12278;
  const char[3] * D.13746;
  unsigned char D.13747;
  int D.13748;
  unsigned char D.13749;
  int D.13750;
  const unsigned char * D.13755;
  unsigned char D.13756;
  int D.13757;
  const unsigned char * D.13758;
  unsigned char D.13759;
  int D.13760;
  const unsigned char * D.13765;
  unsigned char D.13766;
  int D.13767;
  const unsigned char * D.13768;
  unsigned char D.13769;
  int D.13770;
  const unsigned char * D.13775;
  unsigned char D.13776;
  int D.13777;
  const unsigned char * D.13778;
  unsigned char D.13779;
  int D.13780;
  char * end;
  unsigned int count;

  try
    {
      if (allow_empty != 0) goto <D.13652>; else goto <D.13653>;
      <D.13652>:
      if (val == 0B) goto <D.13654>; else goto <D.13655>;
      <D.13654>:
      return;
      <D.13655>:
      <D.13653>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = val;
          D.13659 = "ondemand";
          D.13660 = MEM[(const unsigned char *)D.13659];
          D.13661 = (int) D.13660;
          D.13662 = *__s2;
          D.13663 = (int) D.13662;
          __result = D.13661 - D.13663;
          {
            if (__s2_len != 0) goto <D.13664>; else goto <D.13665>;
            <D.13664>:
            if (__result == 0) goto <D.13666>; else goto <D.13667>;
            <D.13666>:
            D.13668 = &MEM[(void *)"ondemand" + 1B];
            D.13669 = *D.13668;
            D.13670 = (int) D.13669;
            D.13671 = __s2 + 1;
            D.13672 = *D.13671;
            D.13673 = (int) D.13672;
            __result = D.13670 - D.13673;
            if (__s2_len > 1) goto <D.13674>; else goto <D.13675>;
            <D.13674>:
            if (__result == 0) goto <D.13676>; else goto <D.13677>;
            <D.13676>:
            D.13678 = &MEM[(void *)"ondemand" + 2B];
            D.13679 = *D.13678;
            D.13680 = (int) D.13679;
            D.13681 = __s2 + 2;
            D.13682 = *D.13681;
            D.13683 = (int) D.13682;
            __result = D.13680 - D.13683;
            if (__s2_len > 2) goto <D.13684>; else goto <D.13685>;
            <D.13684>:
            if (__result == 0) goto <D.13686>; else goto <D.13687>;
            <D.13686>:
            D.13688 = &MEM[(void *)"ondemand" + 3B];
            D.13689 = *D.13688;
            D.13690 = (int) D.13689;
            D.13691 = __s2 + 3;
            D.13692 = *D.13691;
            D.13693 = (int) D.13692;
            __result = D.13690 - D.13693;
            <D.13687>:
            <D.13685>:
            <D.13677>:
            <D.13675>:
            <D.13667>:
            <D.13665>:
          }
          D.12260 = __result;
        }
        iftmp.91 = -D.12260;
        goto <D.13694>;
        <D.13658>:
        iftmp.91 = __builtin_strcmp (val, "ondemand");
        <D.13694>:
        D.12261 = iftmp.91;
      }
      if (D.12261 == 0) goto <D.13695>; else goto <D.13696>;
      <D.13695>:
      hs_mode_ondemand = 1;
      free (val);
      return;
      <D.13696>:
      D.13697 = strtoul (val, &end, 10);
      count = (unsigned int) D.13697;
      end.92 = end;
      if (val == end.92) goto <D.13699>; else goto <D.13700>;
      <D.13699>:
      usage (1);
      <D.13700>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = end;
          D.13704 = "ms";
          D.13705 = MEM[(const unsigned char *)D.13704];
          D.13706 = (int) D.13705;
          D.13707 = *__s2;
          D.13708 = (int) D.13707;
          __result = D.13706 - D.13708;
          {
            if (__s2_len != 0) goto <D.13709>; else goto <D.13710>;
            <D.13709>:
            if (__result == 0) goto <D.13711>; else goto <D.13712>;
            <D.13711>:
            D.13713 = &MEM[(void *)"ms" + 1B];
            D.13714 = *D.13713;
            D.13715 = (int) D.13714;
            D.13716 = __s2 + 1;
            D.13717 = *D.13716;
            D.13718 = (int) D.13717;
            __result = D.13715 - D.13718;
            if (__s2_len > 1) goto <D.13719>; else goto <D.13720>;
            <D.13719>:
            if (__result == 0) goto <D.13721>; else goto <D.13722>;
            <D.13721>:
            D.13723 = &MEM[(void *)"ms" + 2B];
            D.13724 = *D.13723;
            D.13725 = (int) D.13724;
            D.13726 = __s2 + 2;
            D.13727 = *D.13726;
            D.13728 = (int) D.13727;
            __result = D.13725 - D.13728;
            if (__s2_len > 2) goto <D.13729>; else goto <D.13730>;
            <D.13729>:
            if (__result == 0) goto <D.13731>; else goto <D.13732>;
            <D.13731>:
            D.13733 = &MEM[(void *)"ms" + 3B];
            D.13734 = *D.13733;
            D.13735 = (int) D.13734;
            D.13736 = __s2 + 3;
            D.13737 = *D.13736;
            D.13738 = (int) D.13737;
            __result = D.13735 - D.13738;
            <D.13732>:
            <D.13730>:
            <D.13722>:
            <D.13720>:
            <D.13712>:
            <D.13710>:
          }
          D.12269 = __result;
        }
        iftmp.93 = -D.12269;
        goto <D.13739>;
        <D.13703>:
        end.92 = end;
        iftmp.93 = __builtin_strcmp (end.92, "ms");
        <D.13739>:
        D.12270 = iftmp.93;
      }
      if (D.12270 == 0) goto <D.13740>; else goto <D.13741>;
      <D.13740>:
      hs_mode_ms = count;
      goto <D.13742>;
      <D.13741>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = end;
          D.13746 = "gc";
          D.13747 = MEM[(const unsigned char *)D.13746];
          D.13748 = (int) D.13747;
          D.13749 = *__s2;
          D.13750 = (int) D.13749;
          __result = D.13748 - D.13750;
          {
            if (__s2_len != 0) goto <D.13751>; else goto <D.13752>;
            <D.13751>:
            if (__result == 0) goto <D.13753>; else goto <D.13754>;
            <D.13753>:
            D.13755 = &MEM[(void *)"gc" + 1B];
            D.13756 = *D.13755;
            D.13757 = (int) D.13756;
            D.13758 = __s2 + 1;
            D.13759 = *D.13758;
            D.13760 = (int) D.13759;
            __result = D.13757 - D.13760;
            if (__s2_len > 1) goto <D.13761>; else goto <D.13762>;
            <D.13761>:
            if (__result == 0) goto <D.13763>; else goto <D.13764>;
            <D.13763>:
            D.13765 = &MEM[(void *)"gc" + 2B];
            D.13766 = *D.13765;
            D.13767 = (int) D.13766;
            D.13768 = __s2 + 2;
            D.13769 = *D.13768;
            D.13770 = (int) D.13769;
            __result = D.13767 - D.13770;
            if (__s2_len > 2) goto <D.13771>; else goto <D.13772>;
            <D.13771>:
            if (__result == 0) goto <D.13773>; else goto <D.13774>;
            <D.13773>:
            D.13775 = &MEM[(void *)"gc" + 3B];
            D.13776 = *D.13775;
            D.13777 = (int) D.13776;
            D.13778 = __s2 + 3;
            D.13779 = *D.13778;
            D.13780 = (int) D.13779;
            __result = D.13777 - D.13780;
            <D.13774>:
            <D.13772>:
            <D.13764>:
            <D.13762>:
            <D.13754>:
            <D.13752>:
          }
          D.12278 = __result;
        }
        iftmp.94 = -D.12278;
        goto <D.13781>;
        <D.13745>:
        end.92 = end;
        iftmp.94 = __builtin_strcmp (end.92, "gc");
        <D.13781>:
        D.12279 = iftmp.94;
      }
      if (D.12279 == 0) goto <D.13782>; else goto <D.13783>;
      <D.13782>:
      hs_mode_gc = count;
      goto <D.13784>;
      <D.13783>:
      usage (1);
      <D.13784>:
      <D.13742>:
      free (val);
    }
  finally
    {
      end = {CLOBBER};
    }
}


match_option (const char * p, const char * opt, char * * rval)
{
  long unsigned int D.13789;
  long unsigned int D.13790;
  int D.13791;
  sizetype D.13796;
  const char * D.13797;
  char D.13798;
  sizetype D.13801;
  const char * D.13802;
  char D.13803;
  long unsigned int D.13808;
  long int end.95;
  long int opt.96;
  long int D.13812;
  int D.13813;
  long unsigned int D.13814;
  long unsigned int D.13815;
  sizetype D.13816;
  char * D.13817;
  const char * D.13818;
  _Bool D.13822;
  long unsigned int D.13823;
  sizetype D.13824;
  int len;

  D.13789 = strlen (opt);
  len = (int) D.13789;
  D.13790 = (long unsigned int) len;
  D.13791 = strncmp (p, opt, D.13790);
  if (D.13791 == 0) goto <D.13792>; else goto <D.13793>;
  <D.13792>:
  if (rval != 0B) goto <D.13794>; else goto <D.13795>;
  <D.13794>:
  D.13796 = (sizetype) len;
  D.13797 = p + D.13796;
  D.13798 = *D.13797;
  if (D.13798 == 61) goto <D.13799>; else goto <D.13800>;
  <D.13799>:
  D.13796 = (sizetype) len;
  D.13801 = D.13796 + 1;
  D.13802 = p + D.13801;
  D.13803 = *D.13802;
  if (D.13803 != 0) goto <D.13804>; else goto <D.13805>;
  <D.13804>:
  {
    const char * opt;
    const char * end;
    char * val;
    int l;

    D.13796 = (sizetype) len;
    D.13801 = D.13796 + 1;
    opt = p + D.13801;
    end = __builtin_strchr (opt, 44);
    if (end == 0B) goto <D.13806>; else goto <D.13807>;
    <D.13806>:
    D.13808 = strlen (opt);
    l = (int) D.13808;
    goto <D.13809>;
    <D.13807>:
    end.95 = (long int) end;
    opt.96 = (long int) opt;
    D.13812 = end.95 - opt.96;
    l = (int) D.13812;
    <D.13809>:
    D.13813 = l + 1;
    D.13814 = (long unsigned int) D.13813;
    val = malloc (D.13814);
    D.13815 = (long unsigned int) l;
    memcpy (val, opt, D.13815);
    D.13816 = (sizetype) l;
    D.13817 = val + D.13816;
    *D.13817 = 0;
    *rval = val;
    D.13816 = (sizetype) l;
    D.13818 = opt + D.13816;
    return D.13818;
  }
  <D.13805>:
  <D.13800>:
  D.13796 = (sizetype) len;
  D.13797 = p + D.13796;
  D.13798 = *D.13797;
  if (D.13798 == 0) goto <D.13819>; else goto <D.13821>;
  <D.13821>:
  D.13796 = (sizetype) len;
  D.13797 = p + D.13796;
  D.13798 = *D.13797;
  if (D.13798 == 44) goto <D.13819>; else goto <D.13820>;
  <D.13819>:
  *rval = 0B;
  D.13796 = (sizetype) len;
  D.13796 = (sizetype) len;
  D.13797 = p + D.13796;
  D.13798 = *D.13797;
  D.13822 = D.13798 == 44;
  D.13823 = (long unsigned int) D.13822;
  D.13824 = D.13796 + D.13823;
  D.13818 = p + D.13824;
  return D.13818;
  <D.13820>:
  usage (1);
  goto <D.13825>;
  <D.13795>:
  D.13796 = (sizetype) len;
  D.13797 = p + D.13796;
  D.13798 = *D.13797;
  if (D.13798 == 0) goto <D.13826>; else goto <D.13827>;
  <D.13826>:
  D.13796 = (sizetype) len;
  D.13818 = p + D.13796;
  return D.13818;
  <D.13827>:
  D.13796 = (sizetype) len;
  D.13797 = p + D.13796;
  D.13798 = *D.13797;
  if (D.13798 == 44) goto <D.13828>; else goto <D.13829>;
  <D.13828>:
  D.13796 = (sizetype) len;
  D.13801 = D.13796 + 1;
  D.13818 = p + D.13801;
  return D.13818;
  <D.13829>:
  <D.13825>:
  <D.13793>:
  D.13818 = p;
  return D.13818;
}


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


create_profiler (const char * filename)
{
  int command_port.97;
  char D.13836;
  int do_report.98;
  long unsigned int D.13848;
  unsigned int D.13849;
  unsigned int D.13850;
  long unsigned int D.13851;
  char D.13852;
  const char * D.13855;
  struct FILE * D.13856;
  char * D.13860;
  long int D.13861;
  struct FILE * D.13862;
  struct _IO_FILE * stderr.99;
  struct MonoProfiler * D.13869;
  struct FILE * D.13870;
  struct FILE * D.13871;
  int use_zip.100;
  int D.13877;
  struct gzFile_s * D.13878;
  int do_mono_sample.101;
  struct StatBuffer * D.13882;
  unsigned int hs_mode_ondemand.102;
  int D.13887;
  long unsigned int D.13890;
  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.97 = command_port;
  prof->command_port = command_port.97;
  if (filename != 0B) goto <D.13834>; else goto <D.13835>;
  <D.13834>:
  D.13836 = *filename;
  if (D.13836 == 45) goto <D.13837>; else goto <D.13838>;
  <D.13837>:
  force_delete = 1;
  filename = filename + 1;
  <D.13838>:
  <D.13835>:
  if (filename == 0B) goto <D.13839>; else goto <D.13840>;
  <D.13839>:
  do_report.98 = do_report;
  if (do_report.98 != 0) goto <D.13842>; else goto <D.13843>;
  <D.13842>:
  filename = "|mprof-report -";
  goto <D.13844>;
  <D.13843>:
  filename = "output.mlpd";
  <D.13844>:
  nf = filename;
  goto <D.13845>;
  <D.13840>:
  nf = new_filename (filename);
  do_report.98 = do_report;
  if (do_report.98 != 0) goto <D.13846>; else goto <D.13847>;
  <D.13846>:
  {
    int s;
    char * p;

    D.13848 = strlen (nf);
    D.13849 = (unsigned int) D.13848;
    D.13850 = D.13849 + 32;
    s = (int) D.13850;
    D.13851 = (long unsigned int) s;
    p = malloc (D.13851);
    D.13851 = (long unsigned int) s;
    snprintf (p, D.13851, "|mprof-report \'--out=%s\' -", nf);
    free (nf);
    nf = p;
  }
  <D.13847>:
  <D.13845>:
  D.13852 = *nf;
  if (D.13852 == 124) goto <D.13853>; else goto <D.13854>;
  <D.13853>:
  D.13855 = nf + 1;
  D.13856 = popen (D.13855, "w");
  prof->file = D.13856;
  prof->pipe_output = 1;
  goto <D.13857>;
  <D.13854>:
  D.13852 = *nf;
  if (D.13852 == 35) goto <D.13858>; else goto <D.13859>;
  <D.13858>:
  {
    int fd;

    D.13860 = nf + 1;
    D.13861 = strtol (D.13860, 0B, 10);
    fd = (int) D.13861;
    D.13862 = fdopen (fd, "a");
    prof->file = D.13862;
  }
  goto <D.13863>;
  <D.13859>:
  {
    struct FILE * f;

    if (force_delete != 0) goto <D.13864>; else goto <D.13865>;
    <D.13864>:
    unlink (nf);
    <D.13865>:
    f = fopen (nf, "r");
    if (f != 0B) goto <D.13866>; else goto <D.13867>;
    <D.13866>:
    fclose (f);
    stderr.99 = stderr;
    fprintf (stderr.99, "The Mono profiler won\'t overwrite existing filename: %s.\n", nf);
    stderr.99 = stderr;
    fprintf (stderr.99, "Profiling disabled: use a different name or -FILENAME to force overwrite.\n");
    free (prof);
    D.13869 = 0B;
    return D.13869;
    <D.13867>:
    D.13870 = fopen (nf, "wb");
    prof->file = D.13870;
  }
  <D.13863>:
  <D.13857>:
  D.13871 = prof->file;
  if (D.13871 == 0B) goto <D.13872>; else goto <D.13873>;
  <D.13872>:
  stderr.99 = stderr;
  fprintf (stderr.99, "Cannot create profiler output: %s\n", nf);
  exit (1);
  <D.13873>:
  use_zip.100 = use_zip;
  if (use_zip.100 != 0) goto <D.13875>; else goto <D.13876>;
  <D.13875>:
  D.13871 = prof->file;
  D.13877 = fileno (D.13871);
  D.13878 = gzdopen (D.13877, "wb");
  prof->gzfile = D.13878;
  <D.13876>:
  do_mono_sample.101 = do_mono_sample;
  if (do_mono_sample.101 != 0) goto <D.13880>; else goto <D.13881>;
  <D.13880>:
  D.13882 = create_stat_buffer ();
  prof->stat_buffers = D.13882;
  need_helper_thread = 1;
  <D.13881>:
  hs_mode_ondemand.102 = hs_mode_ondemand;
  if (hs_mode_ondemand.102 != 0) goto <D.13883>; else goto <D.13886>;
  <D.13886>:
  if (need_helper_thread != 0) goto <D.13883>; else goto <D.13884>;
  <D.13883>:
  D.13887 = start_helper_thread (prof);
  if (D.13887 == 0) goto <D.13888>; else goto <D.13889>;
  <D.13888>:
  prof->command_port = 0;
  <D.13889>:
  <D.13884>:
  D.13890 = current_time ();
  prof->startup_time = D.13890;
  dump_header (prof);
  D.13869 = prof;
  return D.13869;
}


new_filename (const char * filename)
{
  long int t.103;
  long unsigned int D.13901;
  char D.13902;
  int D.13912;
  char * D.13915;
  int D.13916;
  int D.13917;
  int D.13918;
  int D.13919;
  int D.13920;
  int D.13921;
  int D.13922;
  int D.13923;
  long unsigned int D.13924;
  long unsigned int D.13925;
  long unsigned int D.13926;
  int D.13927;
  long unsigned int D.13928;
  long unsigned int D.13929;
  int D.13930;
  long unsigned int D.13931;
  long unsigned int D.13932;
  char * d.104;
  sizetype D.13938;
  sizetype D.13941;
  char * d.105;
  char * d.106;
  char * d.107;
  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.103 = time (0B);
      t = t.103;
      D.13901 = process_id ();
      pid = (int) D.13901;
      count_dates = 0;
      count_pids = 0;
      p = filename;
      goto <D.12122>;
      <D.12121>:
      D.13902 = *p;
      if (D.13902 != 37) goto <D.13903>; else goto <D.13904>;
      <D.13903>:
      // predicted unlikely by continue predictor.
      goto <D.12119>;
      <D.13904>:
      p = p + 1;
      D.13902 = *p;
      if (D.13902 == 116) goto <D.13905>; else goto <D.13906>;
      <D.13905>:
      count_dates = count_dates + 1;
      goto <D.13907>;
      <D.13906>:
      D.13902 = *p;
      if (D.13902 == 112) goto <D.13908>; else goto <D.13909>;
      <D.13908>:
      count_pids = count_pids + 1;
      goto <D.13910>;
      <D.13909>:
      D.13902 = *p;
      if (D.13902 == 0) goto <D.12120>; else goto <D.13911>;
      <D.13911>:
      <D.13910>:
      <D.13907>:
      <D.12119>:
      p = p + 1;
      <D.12122>:
      D.13902 = *p;
      if (D.13902 != 0) goto <D.12121>; else goto <D.12120>;
      <D.12120>:
      D.13912 = count_dates | count_pids;
      if (D.13912 == 0) goto <D.13913>; else goto <D.13914>;
      <D.13913>:
      D.13915 = pstrdup (filename);
      return D.13915;
      <D.13914>:
      snprintf (&pid_buf, 16, "%d", pid);
      ts = gmtime (&t);
      D.13916 = ts->tm_year;
      D.13917 = D.13916 + 1900;
      D.13918 = ts->tm_mon;
      D.13919 = D.13918 + 1;
      D.13920 = ts->tm_mday;
      D.13921 = ts->tm_hour;
      D.13922 = ts->tm_min;
      D.13923 = ts->tm_sec;
      snprintf (&time_buf, 16, "%d%02d%02d%02d%02d%02d", D.13917, D.13919, D.13920, D.13921, D.13922, D.13923);
      D.13924 = strlen (&time_buf);
      s_date = (int) D.13924;
      D.13925 = strlen (&pid_buf);
      s_pid = (int) D.13925;
      D.13926 = strlen (filename);
      D.13927 = s_date * count_dates;
      D.13928 = (long unsigned int) D.13927;
      D.13929 = D.13926 + D.13928;
      D.13930 = s_pid * count_pids;
      D.13931 = (long unsigned int) D.13930;
      D.13932 = D.13929 + D.13931;
      res = malloc (D.13932);
      d = res;
      p = filename;
      goto <D.12126>;
      <D.12125>:
      D.13902 = *p;
      if (D.13902 != 37) goto <D.13933>; else goto <D.13934>;
      <D.13933>:
      d.104 = d;
      d = d.104 + 1;
      D.13902 = *p;
      *d.104 = D.13902;
      // predicted unlikely by continue predictor.
      goto <D.12123>;
      <D.13934>:
      p = p + 1;
      D.13902 = *p;
      if (D.13902 == 116) goto <D.13936>; else goto <D.13937>;
      <D.13936>:
      strcpy (d, &time_buf);
      D.13938 = (sizetype) s_date;
      d = d + D.13938;
      // predicted unlikely by continue predictor.
      goto <D.12123>;
      <D.13937>:
      D.13902 = *p;
      if (D.13902 == 112) goto <D.13939>; else goto <D.13940>;
      <D.13939>:
      strcpy (d, &pid_buf);
      D.13941 = (sizetype) s_pid;
      d = d + D.13941;
      // predicted unlikely by continue predictor.
      goto <D.12123>;
      <D.13940>:
      D.13902 = *p;
      if (D.13902 == 37) goto <D.13942>; else goto <D.13943>;
      <D.13942>:
      d.105 = d;
      d = d.105 + 1;
      *d.105 = 37;
      // predicted unlikely by continue predictor.
      goto <D.12123>;
      <D.13943>:
      D.13902 = *p;
      if (D.13902 == 0) goto <D.12124>; else goto <D.13945>;
      <D.13945>:
      d.106 = d;
      d = d.106 + 1;
      *d.106 = 37;
      d.107 = d;
      d = d.107 + 1;
      D.13902 = *p;
      *d.107 = D.13902;
      <D.12123>:
      p = p + 1;
      <D.12126>:
      D.13902 = *p;
      if (D.13902 != 0) goto <D.12125>; else goto <D.12124>;
      <D.12124>:
      *d = 0;
      D.13915 = res;
      return D.13915;
    }
  finally
    {
      t = {CLOBBER};
      pid_buf = {CLOBBER};
      time_buf = {CLOBBER};
    }
}


start_helper_thread (struct MonoProfiler * prof)
{
  int[2] * D.13953;
  int D.13954;
  struct _IO_FILE * stderr.108;
  int D.13958;
  int D.13959;
  int D.13960;
  short unsigned int D.12176;
  int D.13963;
  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.13964;
  int D.13965;
  int * D.13968;
  int D.13969;
  char * D.13970;
  int D.13971;
  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.13974;
  int D.13975;
  short unsigned int D.12178;
  int D.13978;
  pthread_t * D.13979;
  struct sockaddr_in server_address;
  int r;
  socklen_t slen;

  try
    {
      D.13953 = &prof->pipes;
      D.13954 = pipe (D.13953);
      if (D.13954 < 0) goto <D.13955>; else goto <D.13956>;
      <D.13955>:
      stderr.108 = stderr;
      fprintf (stderr.108, "Cannot create pipe\n");
      D.13958 = 0;
      return D.13958;
      <D.13956>:
      D.13959 = socket (2, 1, 0);
      prof->server_socket = D.13959;
      D.13960 = prof->server_socket;
      if (D.13960 < 0) goto <D.13961>; else goto <D.13962>;
      <D.13961>:
      stderr.108 = stderr;
      fprintf (stderr.108, "Cannot create server socket\n");
      D.13958 = 0;
      return D.13958;
      <D.13962>:
      memset (&server_address, 0, 16);
      server_address.sin_family = 2;
      server_address.sin_addr.s_addr = 0;
      {
        short unsigned int __bsx;

        D.13963 = prof->command_port;
        __bsx = (short unsigned int) D.13963;
        D.12176 = __bsx r>> 8;
      }
      server_address.sin_port = D.12176;
      D.13960 = prof->server_socket;
      D.13964.__sockaddr__ = &server_address;
      D.13965 = bind (D.13960, D.13964, 16);
      if (D.13965 < 0) goto <D.13966>; else goto <D.13967>;
      <D.13966>:
      stderr.108 = stderr;
      D.13963 = prof->command_port;
      D.13968 = __errno_location ();
      D.13969 = *D.13968;
      D.13970 = strerror (D.13969);
      fprintf (stderr.108, "Cannot bind server socket, port: %d: %s\n", D.13963, D.13970);
      D.13960 = prof->server_socket;
      close (D.13960);
      D.13958 = 0;
      return D.13958;
      <D.13967>:
      D.13960 = prof->server_socket;
      D.13971 = listen (D.13960, 1);
      if (D.13971 < 0) goto <D.13972>; else goto <D.13973>;
      <D.13972>:
      stderr.108 = stderr;
      fprintf (stderr.108, "Cannot listen server socket\n");
      D.13960 = prof->server_socket;
      close (D.13960);
      D.13958 = 0;
      return D.13958;
      <D.13973>:
      slen = 16;
      D.13960 = prof->server_socket;
      D.13974.__sockaddr__ = &server_address;
      D.13975 = getsockname (D.13960, D.13974, &slen);
      if (D.13975 == 0) goto <D.13976>; else goto <D.13977>;
      <D.13976>:
      {
        short unsigned int __bsx;

        __bsx = server_address.sin_port;
        D.12178 = __bsx r>> 8;
      }
      D.13978 = (int) D.12178;
      prof->command_port = D.13978;
      <D.13977>:
      D.13979 = &prof->helper_thread;
      r = pthread_create (D.13979, 0B, helper_thread, prof);
      if (r != 0) goto <D.13980>; else goto <D.13981>;
      <D.13980>:
      D.13960 = prof->server_socket;
      close (D.13960);
      D.13958 = 0;
      return D.13958;
      <D.13981>:
      D.13958 = 1;
      return D.13958;
    }
  finally
    {
      server_address = {CLOBBER};
      slen = {CLOBBER};
    }
}


helper_thread (void * arg)
{
  long int D.12144;
  int D.13985;
  long int iftmp.109;
  int D.13987;
  long int iftmp.110;
  unsigned long __d.111;
  long int D.13996;
  long int D.13997;
  int D.13998;
  long int D.13999;
  long int D.14000;
  long int D.12146;
  int D.14001;
  long int iftmp.112;
  int D.14003;
  long int iftmp.113;
  unsigned long __d.114;
  long int D.14012;
  long int D.14013;
  int D.14014;
  long int D.14015;
  long int D.14016;
  long int D.12148;
  long int iftmp.115;
  int D.14022;
  long int iftmp.116;
  unsigned long __d.117;
  long int D.14031;
  long int D.14032;
  int D.14033;
  long int D.14034;
  long int D.14035;
  int D.14038;
  int * D.14041;
  int D.14042;
  char * D.14045;
  void * D.14046;
  long int D.12151;
  long int iftmp.118;
  int D.14048;
  long int iftmp.119;
  unsigned long __d.120;
  long int D.14057;
  long int D.14058;
  long int D.14059;
  long int D.14062;
  char c.121;
  struct StatBuffer * D.14068;
  struct StatBuffer * D.14069;
  int do_debug.122;
  struct _IO_FILE * stderr.123;
  long unsigned int D.14074;
  int D.14075;
  struct LogBuffer * D.14080;
  long int D.12156;
  long int iftmp.124;
  int D.14084;
  long int iftmp.125;
  unsigned long __d.126;
  long int D.14093;
  long int D.14094;
  long int D.14095;
  long int D.14098;
  int D.12165;
  int iftmp.127;
  int D.12164;
  const char[10] * D.14106;
  unsigned char D.14107;
  int D.14108;
  unsigned char D.14109;
  int D.14110;
  const unsigned char * D.14115;
  unsigned char D.14116;
  int D.14117;
  const unsigned char * D.14118;
  unsigned char D.14119;
  int D.14120;
  const unsigned char * D.14125;
  unsigned char D.14126;
  int D.14127;
  const unsigned char * D.14128;
  unsigned char D.14129;
  int D.14130;
  const unsigned char * D.14135;
  unsigned char D.14136;
  int D.14137;
  const unsigned char * D.14138;
  unsigned char D.14139;
  int D.14140;
  int runtime_inited.128;
  struct MonoDomain * D.14149;
  long int D.12167;
  long int iftmp.129;
  int D.14153;
  long int iftmp.130;
  unsigned long __d.131;
  long int D.14162;
  long int D.14163;
  long int D.14164;
  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.14167;
  struct MonoProfiler * prof;
  int command_socket;
  int len;
  char buf[64];
  struct MonoThread * thread;

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

        try
          {
            max_fd = -1;
            {
              unsigned int __i;
              struct fd_set * __arr;

              __arr = &rfds;
              __i = 0;
              goto <D.12141>;
              <D.12140>:
              __arr->fds_bits[__i] = 0;
              __i = __i + 1;
              <D.12141>:
              if (__i <= 15) goto <D.12140>; else goto <D.12142>;
              <D.12142>:
            }
            {
              long int __d;

              D.13985 = prof->server_socket;
              __d = (long int) D.13985;
              D.13987 = __builtin_constant_p (__d);
              if (D.13987 != 0) goto <D.13988>; else goto <D.13989>;
              <D.13988>:
              __d.111 = (unsigned long) __d;
              if (__d.111 <= 1023) goto <D.13992>; else goto <D.13993>;
              <D.13992>:
              iftmp.110 = __d / 64;
              goto <D.13994>;
              <D.13993>:
              iftmp.110 = __fdelt_warn (__d);
              <D.13994>:
              iftmp.109 = iftmp.110;
              goto <D.13995>;
              <D.13989>:
              iftmp.109 = __fdelt_chk (__d);
              <D.13995>:
              D.12144 = iftmp.109;
            }
            D.13996 = D.12144;
            D.13997 = rfds.fds_bits[D.13996];
            D.13985 = prof->server_socket;
            D.13998 = D.13985 % 64;
            D.13999 = 1 << D.13998;
            D.14000 = D.13997 | D.13999;
            rfds.fds_bits[D.13996] = D.14000;
            max_fd = prof->server_socket;
            {
              long int __d;

              D.14001 = prof->pipes[0];
              __d = (long int) D.14001;
              D.14003 = __builtin_constant_p (__d);
              if (D.14003 != 0) goto <D.14004>; else goto <D.14005>;
              <D.14004>:
              __d.114 = (unsigned long) __d;
              if (__d.114 <= 1023) goto <D.14008>; else goto <D.14009>;
              <D.14008>:
              iftmp.113 = __d / 64;
              goto <D.14010>;
              <D.14009>:
              iftmp.113 = __fdelt_warn (__d);
              <D.14010>:
              iftmp.112 = iftmp.113;
              goto <D.14011>;
              <D.14005>:
              iftmp.112 = __fdelt_chk (__d);
              <D.14011>:
              D.12146 = iftmp.112;
            }
            D.14012 = D.12146;
            D.14013 = rfds.fds_bits[D.14012];
            D.14001 = prof->pipes[0];
            D.14014 = D.14001 % 64;
            D.14015 = 1 << D.14014;
            D.14016 = D.14013 | D.14015;
            rfds.fds_bits[D.14012] = D.14016;
            D.14001 = prof->pipes[0];
            if (D.14001 > max_fd) goto <D.14017>; else goto <D.14018>;
            <D.14017>:
            max_fd = prof->pipes[0];
            <D.14018>:
            if (command_socket >= 0) goto <D.14019>; else goto <D.14020>;
            <D.14019>:
            {
              long int __d;

              __d = (long int) command_socket;
              D.14022 = __builtin_constant_p (__d);
              if (D.14022 != 0) goto <D.14023>; else goto <D.14024>;
              <D.14023>:
              __d.117 = (unsigned long) __d;
              if (__d.117 <= 1023) goto <D.14027>; else goto <D.14028>;
              <D.14027>:
              iftmp.116 = __d / 64;
              goto <D.14029>;
              <D.14028>:
              iftmp.116 = __fdelt_warn (__d);
              <D.14029>:
              iftmp.115 = iftmp.116;
              goto <D.14030>;
              <D.14024>:
              iftmp.115 = __fdelt_chk (__d);
              <D.14030>:
              D.12148 = iftmp.115;
            }
            D.14031 = D.12148;
            D.14032 = rfds.fds_bits[D.14031];
            D.14033 = command_socket % 64;
            D.14034 = 1 << D.14033;
            D.14035 = D.14032 | D.14034;
            rfds.fds_bits[D.14031] = D.14035;
            if (max_fd < command_socket) goto <D.14036>; else goto <D.14037>;
            <D.14036>:
            max_fd = command_socket;
            <D.14037>:
            <D.14020>:
            tv.tv_sec = 1;
            tv.tv_usec = 0;
            D.14038 = max_fd + 1;
            len = select (D.14038, &rfds, 0B, 0B, &tv);
            if (len < 0) goto <D.14039>; else goto <D.14040>;
            <D.14039>:
            D.14041 = __errno_location ();
            D.14042 = *D.14041;
            if (D.14042 == 4) goto <D.14043>; else goto <D.14044>;
            <D.14043>:
            // predicted unlikely by continue predictor.
            goto <D.12149>;
            <D.14044>:
            D.14041 = __errno_location ();
            D.14042 = *D.14041;
            D.14045 = strerror (D.14042);
            monoeg_g_log (0B, 16, "Error in proflog server: %s", D.14045);
            D.14046 = 0B;
            return D.14046;
            <D.14040>:
            {
              long int __d;

              D.14001 = prof->pipes[0];
              __d = (long int) D.14001;
              D.14048 = __builtin_constant_p (__d);
              if (D.14048 != 0) goto <D.14049>; else goto <D.14050>;
              <D.14049>:
              __d.120 = (unsigned long) __d;
              if (__d.120 <= 1023) goto <D.14053>; else goto <D.14054>;
              <D.14053>:
              iftmp.119 = __d / 64;
              goto <D.14055>;
              <D.14054>:
              iftmp.119 = __fdelt_warn (__d);
              <D.14055>:
              iftmp.118 = iftmp.119;
              goto <D.14056>;
              <D.14050>:
              iftmp.118 = __fdelt_chk (__d);
              <D.14056>:
              D.12151 = iftmp.118;
            }
            D.14057 = rfds.fds_bits[D.12151];
            D.14001 = prof->pipes[0];
            D.14014 = D.14001 % 64;
            D.14058 = D.14057 >> D.14014;
            D.14059 = D.14058 & 1;
            if (D.14059 != 0) goto <D.14060>; else goto <D.14061>;
            <D.14060>:
            {
              char c;
              int r;

              try
                {
                  D.14001 = prof->pipes[0];
                  D.14062 = read (D.14001, &c, 1);
                  r = (int) D.14062;
                  if (r == 1) goto <D.14063>; else goto <D.14064>;
                  <D.14063>:
                  c.121 = c;
                  if (c.121 == 0) goto <D.14066>; else goto <D.14067>;
                  <D.14066>:
                  {
                    struct StatBuffer * sbuf;

                    D.14068 = prof->stat_buffers;
                    D.14069 = D.14068->next;
                    sbuf = D.14069->next;
                    D.14068 = prof->stat_buffers;
                    D.14069 = D.14068->next;
                    D.14069->next = 0B;
                    do_debug.122 = do_debug;
                    if (do_debug.122 != 0) goto <D.14071>; else goto <D.14072>;
                    <D.14071>:
                    stderr.123 = stderr;
                    fprintf (stderr.123, "stat buffer dump\n");
                    <D.14072>:
                    dump_sample_hits (prof, sbuf, 1);
                    D.14074 = sbuf->size;
                    D.14075 = (int) D.14074;
                    free_buffer (sbuf, D.14075);
                    // predicted unlikely by continue predictor.
                    goto <D.12149>;
                  }
                  <D.14067>:
                  <D.14064>:
                  if (thread != 0B) goto <D.14076>; else goto <D.14077>;
                  <D.14076>:
                  mono_thread_detach (thread);
                  <D.14077>:
                  do_debug.122 = do_debug;
                  if (do_debug.122 != 0) goto <D.14078>; else goto <D.14079>;
                  <D.14078>:
                  stderr.123 = stderr;
                  fprintf (stderr.123, "helper shutdown\n");
                  <D.14079>:
                  D.14080 = ensure_logbuf (0);
                  safe_dump (prof, D.14080);
                  D.14046 = 0B;
                  return D.14046;
                }
              finally
                {
                  c = {CLOBBER};
                }
            }
            <D.14061>:
            if (command_socket >= 0) goto <D.14081>; else goto <D.14082>;
            <D.14081>:
            {
              long int __d;

              __d = (long int) command_socket;
              D.14084 = __builtin_constant_p (__d);
              if (D.14084 != 0) goto <D.14085>; else goto <D.14086>;
              <D.14085>:
              __d.126 = (unsigned long) __d;
              if (__d.126 <= 1023) goto <D.14089>; else goto <D.14090>;
              <D.14089>:
              iftmp.125 = __d / 64;
              goto <D.14091>;
              <D.14090>:
              iftmp.125 = __fdelt_warn (__d);
              <D.14091>:
              iftmp.124 = iftmp.125;
              goto <D.14092>;
              <D.14086>:
              iftmp.124 = __fdelt_chk (__d);
              <D.14092>:
              D.12156 = iftmp.124;
            }
            D.14093 = rfds.fds_bits[D.12156];
            D.14033 = command_socket % 64;
            D.14094 = D.14093 >> D.14033;
            D.14095 = D.14094 & 1;
            if (D.14095 != 0) goto <D.14096>; else goto <D.14097>;
            <D.14096>:
            D.14098 = read (command_socket, &buf, 63);
            len = (int) D.14098;
            if (len < 0) goto <D.14099>; else goto <D.14100>;
            <D.14099>:
            // predicted unlikely by continue predictor.
            goto <D.12149>;
            <D.14100>:
            if (len == 0) goto <D.14101>; else goto <D.14102>;
            <D.14101>:
            close (command_socket);
            command_socket = -1;
            // predicted unlikely by continue predictor.
            goto <D.12149>;
            <D.14102>:
            buf[len] = 0;
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = &buf;
                D.14106 = "heapshot\n";
                D.14107 = MEM[(const unsigned char *)D.14106];
                D.14108 = (int) D.14107;
                D.14109 = *__s2;
                D.14110 = (int) D.14109;
                __result = D.14108 - D.14110;
                {
                  if (__s2_len != 0) goto <D.14111>; else goto <D.14112>;
                  <D.14111>:
                  if (__result == 0) goto <D.14113>; else goto <D.14114>;
                  <D.14113>:
                  D.14115 = &MEM[(void *)"heapshot\n" + 1B];
                  D.14116 = *D.14115;
                  D.14117 = (int) D.14116;
                  D.14118 = __s2 + 1;
                  D.14119 = *D.14118;
                  D.14120 = (int) D.14119;
                  __result = D.14117 - D.14120;
                  if (__s2_len > 1) goto <D.14121>; else goto <D.14122>;
                  <D.14121>:
                  if (__result == 0) goto <D.14123>; else goto <D.14124>;
                  <D.14123>:
                  D.14125 = &MEM[(void *)"heapshot\n" + 2B];
                  D.14126 = *D.14125;
                  D.14127 = (int) D.14126;
                  D.14128 = __s2 + 2;
                  D.14129 = *D.14128;
                  D.14130 = (int) D.14129;
                  __result = D.14127 - D.14130;
                  if (__s2_len > 2) goto <D.14131>; else goto <D.14132>;
                  <D.14131>:
                  if (__result == 0) goto <D.14133>; else goto <D.14134>;
                  <D.14133>:
                  D.14135 = &MEM[(void *)"heapshot\n" + 3B];
                  D.14136 = *D.14135;
                  D.14137 = (int) D.14136;
                  D.14138 = __s2 + 3;
                  D.14139 = *D.14138;
                  D.14140 = (int) D.14139;
                  __result = D.14137 - D.14140;
                  <D.14134>:
                  <D.14132>:
                  <D.14124>:
                  <D.14122>:
                  <D.14114>:
                  <D.14112>:
                }
                D.12164 = __result;
              }
              iftmp.127 = -D.12164;
              goto <D.14141>;
              <D.14105>:
              iftmp.127 = __builtin_strcmp (&buf, "heapshot\n");
              <D.14141>:
              D.12165 = iftmp.127;
            }
            if (D.12165 == 0) goto <D.14142>; else goto <D.14143>;
            <D.14142>:
            heapshot_requested = 1;
            runtime_inited.128 = runtime_inited;
            if (runtime_inited.128 != 0) goto <D.14145>; else goto <D.14146>;
            <D.14145>:
            if (thread == 0B) goto <D.14147>; else goto <D.14148>;
            <D.14147>:
            D.14149 = mono_get_root_domain ();
            thread = mono_thread_attach (D.14149);
            <D.14148>:
            <D.14146>:
            if (thread != 0B) goto <D.14150>; else goto <D.14151>;
            <D.14150>:
            process_requests (prof);
            mono_thread_detach (thread);
            thread = 0B;
            <D.14151>:
            <D.14143>:
            // predicted unlikely by continue predictor.
            goto <D.12149>;
            <D.14097>:
            <D.14082>:
            {
              long int __d;

              D.13985 = prof->server_socket;
              __d = (long int) D.13985;
              D.14153 = __builtin_constant_p (__d);
              if (D.14153 != 0) goto <D.14154>; else goto <D.14155>;
              <D.14154>:
              __d.131 = (unsigned long) __d;
              if (__d.131 <= 1023) goto <D.14158>; else goto <D.14159>;
              <D.14158>:
              iftmp.130 = __d / 64;
              goto <D.14160>;
              <D.14159>:
              iftmp.130 = __fdelt_warn (__d);
              <D.14160>:
              iftmp.129 = iftmp.130;
              goto <D.14161>;
              <D.14155>:
              iftmp.129 = __fdelt_chk (__d);
              <D.14161>:
              D.12167 = iftmp.129;
            }
            D.14162 = rfds.fds_bits[D.12167];
            D.13985 = prof->server_socket;
            D.13998 = D.13985 % 64;
            D.14163 = D.14162 >> D.13998;
            D.14164 = D.14163 & 1;
            if (D.14164 == 0) goto <D.14165>; else goto <D.14166>;
            <D.14165>:
            // predicted unlikely by continue predictor.
            goto <D.12149>;
            <D.14166>:
            D.13985 = prof->server_socket;
            D.14167.__sockaddr__ = 0B;
            command_socket = accept (D.13985, D.14167, 0B);
            if (command_socket < 0) goto <D.14168>; else goto <D.14169>;
            <D.14168>:
            // predicted unlikely by continue predictor.
            goto <D.12149>;
            <D.14169>:
          }
        finally
          {
            rfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.12149>:
      goto <D.12168>;
      D.14046 = 0B;
      return D.14046;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.14199;
  int D.14202;
  ssize_t D.14205;
  long unsigned int D.14206;
  long unsigned int D.14207;
  long unsigned int D.14210;

  D.14199 = __builtin_object_size (__buf, 0);
  if (D.14199 != 18446744073709551615) goto <D.14200>; else goto <D.14201>;
  <D.14200>:
  D.14202 = __builtin_constant_p (__nbytes);
  if (D.14202 == 0) goto <D.14203>; else goto <D.14204>;
  <D.14203>:
  D.14206 = __builtin_object_size (__buf, 0);
  D.14205 = __read_chk (__fd, __buf, __nbytes, D.14206);
  return D.14205;
  <D.14204>:
  D.14207 = __builtin_object_size (__buf, 0);
  if (D.14207 < __nbytes) goto <D.14208>; else goto <D.14209>;
  <D.14208>:
  D.14210 = __builtin_object_size (__buf, 0);
  D.14205 = __read_chk_warn (__fd, __buf, __nbytes, D.14210);
  return D.14205;
  <D.14209>:
  <D.14201>:
  D.14205 = __read_alias (__fd, __buf, __nbytes);
  return D.14205;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.14217;
  int D.14222;
  void * D.14224;
  long unsigned int D.14225;

  D.14217 = __builtin_constant_p (__len);
  if (D.14217 != 0) goto <D.14218>; else goto <D.14219>;
  <D.14218>:
  if (__len == 0) goto <D.14220>; else goto <D.14221>;
  <D.14220>:
  D.14222 = __builtin_constant_p (__ch);
  if (D.14222 == 0) goto <D.14215>; else goto <D.14223>;
  <D.14223>:
  if (__ch != 0) goto <D.14215>; else goto <D.14216>;
  <D.14215>:
  __warn_memset_zero_len ();
  D.14224 = __dest;
  return D.14224;
  <D.14216>:
  <D.14221>:
  <D.14219>:
  D.14225 = __builtin_object_size (__dest, 0);
  D.14224 = __builtin___memset_chk (__dest, __ch, __len, D.14225);
  return D.14224;
}


dump_header (struct MonoProfiler * profiler)
{
  char * p.132;
  char * p.133;
  char * p.134;
  char * p.135;
  long int D.14231;
  long unsigned int D.14232;
  long unsigned int D.14233;
  long int D.14234;
  int D.14235;
  long unsigned int D.14236;
  int D.14237;
  int D.14238;
  struct gzFile_s * * D.14239;
  long int p.136;
  long int hbuf.137;
  long int D.14244;
  unsigned int D.14245;
  long unsigned int D.14247;
  struct FILE * D.14248;
  char hbuf[128];
  char * p;

  try
    {
      p = &hbuf;
      p = write_int32 (p, 1297111553);
      p.132 = p;
      p = p.132 + 1;
      *p.132 = 0;
      p.133 = p;
      p = p.133 + 1;
      *p.133 = 4;
      p.134 = p;
      p = p.134 + 1;
      *p.134 = 4;
      p.135 = p;
      p = p.135 + 1;
      *p.135 = 8;
      D.14231 = time (0B);
      D.14232 = (long unsigned int) D.14231;
      D.14233 = D.14232 * 1000;
      D.14234 = (long int) D.14233;
      p = write_int64 (p, D.14234);
      D.14235 = get_timer_overhead ();
      p = write_int32 (p, D.14235);
      p = write_int32 (p, 0);
      D.14236 = process_id ();
      D.14237 = (int) D.14236;
      p = write_int32 (p, D.14237);
      D.14238 = profiler->command_port;
      p = write_int16 (p, D.14238);
      p = write_int16 (p, 0);
      D.14239 = profiler->gzfile;
      if (D.14239 != 0B) goto <D.14240>; else goto <D.14241>;
      <D.14240>:
      D.14239 = profiler->gzfile;
      p.136 = (long int) p;
      hbuf.137 = (long int) &hbuf;
      D.14244 = p.136 - hbuf.137;
      D.14245 = (unsigned int) D.14244;
      gzwrite (D.14239, &hbuf, D.14245);
      goto <D.14246>;
      <D.14241>:
      p.136 = (long int) p;
      hbuf.137 = (long int) &hbuf;
      D.14244 = p.136 - hbuf.137;
      D.14247 = (long unsigned int) D.14244;
      D.14248 = profiler->file;
      fwrite (&hbuf, D.14247, 1, D.14248);
      <D.14246>:
    }
  finally
    {
      hbuf = {CLOBBER};
    }
}


write_int16 (char * buf, int32_t value)
{
  sizetype D.14260;
  char * D.14261;
  char D.14262;
  char * D.14263;
  int i;

  i = 0;
  goto <D.11703>;
  <D.11702>:
  D.14260 = (sizetype) i;
  D.14261 = buf + D.14260;
  D.14262 = (char) value;
  *D.14261 = D.14262;
  value = value >> 8;
  i = i + 1;
  <D.11703>:
  if (i <= 1) goto <D.11702>; else goto <D.11704>;
  <D.11704>:
  D.14263 = buf + 2;
  return D.14263;
}


init_thread ()
{
  struct LogBuffer * tlsbuffer.138;
  long unsigned int D.14268;
  struct LogBuffer * logbuffer;

  tlsbuffer.138 = tlsbuffer;
  if (tlsbuffer.138 != 0B) goto <D.14266>; else goto <D.14267>;
  <D.14266>:
  return;
  <D.14267>:
  logbuffer = create_buffer ();
  tlsbuffer = logbuffer;
  D.14268 = thread_id ();
  logbuffer->thread_id = D.14268;
}


create_buffer ()
{
  long unsigned int D.14272;
  long unsigned int D.14273;
  int D.14274;
  sizetype D.14275;
  unsigned char * D.14276;
  unsigned char[1] * D.14277;
  struct LogBuffer * D.14278;
  struct LogBuffer * buf;

  buf = alloc_buffer (65536);
  buf->size = 65536;
  D.14272 = current_time ();
  buf->time_base = D.14272;
  D.14273 = buf->time_base;
  buf->last_time = D.14273;
  D.14274 = buf->size;
  D.14275 = (sizetype) D.14274;
  D.14276 = buf + D.14275;
  buf->data_end = D.14276;
  D.14277 = &buf->buf;
  buf->data = D.14277;
  D.14278 = buf;
  return D.14278;
}