utils_init (int fast_time)
{
  long long unsigned int D.11198;
  long long unsigned int time_inc.0;
  uint64_t (*<T1cea>) (void) time_func.1;
  long long unsigned int D.11205;
  long long unsigned int D.11206;
  int timer_overhead.2;
  int i;
  uint64_t time_start;
  uint64_t time_end;

  if (fast_time > 1) goto <D.11193>; else goto <D.11194>;
  <D.11193>:
  time_func = null_time;
  goto <D.11195>;
  <D.11194>:
  if (fast_time != 0) goto <D.11196>; else goto <D.11197>;
  <D.11196>:
  {
    uint64_t timea;
    uint64_t timeb;

    clock_time ();
    timea = clock_time ();
    timeb = clock_time ();
    D.11198 = timeb - timea;
    time_inc.0 = D.11198 / 8;
    time_inc = time_inc.0;
    if (0 != 0) goto <D.11200>; else goto <D.11201>;
    <D.11200>:
    time_func = fast_current_time;
    goto <D.11202>;
    <D.11201>:
    time_func = fast_current_time;
    <D.11202>:
  }
  goto <D.11203>;
  <D.11197>:
  time_func = clock_time;
  <D.11203>:
  <D.11195>:
  time_func.1 = time_func;
  time_start = time_func.1 ();
  i = 0;
  goto <D.10321>;
  <D.10320>:
  time_func.1 = time_func;
  time_func.1 ();
  i = i + 1;
  <D.10321>:
  if (i <= 255) goto <D.10320>; else goto <D.10322>;
  <D.10322>:
  time_func.1 = time_func;
  time_end = time_func.1 ();
  D.11205 = time_end - time_start;
  D.11206 = D.11205 / 256;
  timer_overhead.2 = (int) D.11206;
  timer_overhead = timer_overhead.2;
}


fast_current_time ()
{
  unsigned int D.11212;
  unsigned int D.11213;
  unsigned int D.11214;
  unsigned int D.11215;
  long long unsigned int D.11218;
  long long unsigned int time_inc.3;
  long long unsigned int D.11220;
  uint64_t D.11221;
  long long unsigned int D.11222;
  struct TlsData * tls;

  tls = &tls_data;
  D.11212 = tls->timer_count;
  D.11213 = D.11212;
  D.11214 = D.11213 + 1;
  tls->timer_count = D.11214;
  D.11215 = D.11213 & 7;
  if (D.11215 != 0) goto <D.11216>; else goto <D.11217>;
  <D.11216>:
  D.11218 = tls->last_time;
  time_inc.3 = time_inc;
  D.11220 = D.11218 + time_inc.3;
  tls->last_time = D.11220;
  D.11221 = tls->last_time;
  return D.11221;
  <D.11217>:
  D.11222 = clock_time ();
  tls->last_time = D.11222;
  D.11221 = tls->last_time;
  return D.11221;
}


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


clock_time ()
{
  uint64_t D.11230;
  long int D.11231;
  long long unsigned int D.11232;
  long long unsigned int D.11233;
  long int D.11234;
  long long unsigned int D.11235;
  struct timespec tspec;

  try
    {
      clock_gettime (1, &tspec);
      D.11231 = tspec.tv_sec;
      D.11232 = (long long unsigned int) D.11231;
      D.11233 = D.11232 * 1000000000;
      D.11234 = tspec.tv_nsec;
      D.11235 = (long long unsigned int) D.11234;
      D.11230 = D.11233 + D.11235;
      return D.11230;
    }
  finally
    {
      tspec = {CLOBBER};
    }
}


get_timer_overhead ()
{
  int D.11238;

  D.11238 = timer_overhead;
  return D.11238;
}


current_time ()
{
  uint64_t D.11240;
  uint64_t (*<T1cea>) (void) time_func.7;

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


alloc_buffer (int size)
{
  unsigned int size.8;
  void * D.11247;
  void * ptr;

  size.8 = (unsigned int) size;
  ptr = mmap (0B, size.8, 3, 2050, -1, 0);
  if (ptr == 4294967295B) goto <D.11245>; else goto <D.11246>;
  <D.11245>:
  D.11247 = 0B;
  return D.11247;
  <D.11246>:
  D.11247 = ptr;
  return D.11247;
}


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

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


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.11250;
  uint8_t * p.10;
  uint8_t * p;

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

    D.11250 = (unsigned char) value;
    b = D.11250 & 127;
    value = value >> 7;
    if (value != 0) goto <D.11251>; else goto <D.11252>;
    <D.11251>:
    b = b | 128;
    <D.11252>:
    p.10 = p;
    p = p.10 + 1;
    *p.10 = b;
  }
  if (value != 0) goto <D.10350>; else goto <D.10351>;
  <D.10351>:
  *endbuf = p;
}


encode_sleb128 (intptr_t value, uint8_t * buf, uint8_t * * endbuf)
{
  _Bool D.11254;
  unsigned char D.11255;
  unsigned int D.11258;
  int D.11259;
  int D.11260;
  int D.11261;
  int D.11267;
  int D.11268;
  uint8_t * p.11;
  int more;
  int negative;
  unsigned int size;
  uint8_t byte;
  uint8_t * p;

  more = 1;
  D.11254 = value < 0;
  negative = (int) D.11254;
  size = 32;
  p = buf;
  goto <D.10363>;
  <D.10362>:
  D.11255 = (unsigned char) value;
  byte = D.11255 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.11256>; else goto <D.11257>;
  <D.11256>:
  D.11258 = size + 4294967289;
  D.11259 = (int) D.11258;
  D.11260 = 1 << D.11259;
  D.11261 = -D.11260;
  value = D.11261 | value;
  <D.11257>:
  if (value == 0) goto <D.11266>; else goto <D.11262>;
  <D.11266>:
  D.11267 = (int) byte;
  D.11268 = D.11267 & 64;
  if (D.11268 == 0) goto <D.11263>; else goto <D.11262>;
  <D.11262>:
  if (value == -1) goto <D.11269>; else goto <D.11264>;
  <D.11269>:
  D.11267 = (int) byte;
  D.11268 = D.11267 & 64;
  if (D.11268 != 0) goto <D.11263>; else goto <D.11264>;
  <D.11263>:
  more = 0;
  goto <D.11265>;
  <D.11264>:
  byte = byte | 128;
  <D.11265>:
  p.11 = p;
  p = p.11 + 1;
  *p.11 = byte;
  <D.10363>:
  if (more != 0) goto <D.10362>; else goto <D.10364>;
  <D.10364>:
  *endbuf = p;
}


decode_uleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  uint8_t * buf.12;
  long long unsigned int D.11272;
  long long unsigned int D.11273;
  long long unsigned int D.11274;
  signed char b.13;
  uint64_t D.11277;
  uint64_t res;
  int shift;

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

    buf.12 = buf;
    buf = buf.12 + 1;
    b = *buf.12;
    D.11272 = (long long unsigned int) b;
    D.11273 = D.11272 & 127;
    D.11274 = D.11273 << shift;
    res = D.11274 | res;
    b.13 = (signed char) b;
    if (b.13 >= 0) goto <D.10372>; else goto <D.11276>;
    <D.11276>:
    shift = shift + 7;
  }
  goto <D.10373>;
  <D.10372>:
  *endbuf = buf;
  D.11277 = res;
  return D.11277;
}


decode_sleb128 (uint8_t * buf, uint8_t * * endbuf)
{
  int D.11279;
  int D.11280;
  int D.11281;
  signed char b.14;
  unsigned int shift.15;
  int D.11288;
  int D.11291;
  int D.11292;
  intptr_t D.11293;
  uint8_t * p;
  intptr_t res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.11279 = (int) b;
    D.11280 = D.11279 & 127;
    D.11281 = D.11280 << shift;
    res = D.11281 | res;
    shift = shift + 7;
    b.14 = (signed char) b;
    if (b.14 >= 0) goto <D.11283>; else goto <D.11284>;
    <D.11283>:
    shift.15 = (unsigned int) shift;
    if (shift.15 <= 31) goto <D.11286>; else goto <D.11287>;
    <D.11286>:
    D.11279 = (int) b;
    D.11288 = D.11279 & 64;
    if (D.11288 != 0) goto <D.11289>; else goto <D.11290>;
    <D.11289>:
    D.11291 = 1 << shift;
    D.11292 = -D.11291;
    res = D.11292 | res;
    <D.11290>:
    <D.11287>:
    goto <D.10382>;
    <D.11284>:
  }
  goto <D.10383>;
  <D.10382>:
  *endbuf = p;
  D.11293 = res;
  return D.11293;
}


thread_id ()
{
  uintptr_t D.11295;

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


process_id ()
{
  uintptr_t D.11297;
  int D.11298;

  D.11298 = getpid ();
  D.11297 = (uintptr_t) D.11298;
  return D.11297;
}


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


mono_profiler_startup (const char * desc)
{
  int D.11300;
  char D.11303;
  int D.11176;
  int iftmp.16;
  int D.11175;
  const char[5] * D.11323;
  unsigned char D.11324;
  int D.11325;
  unsigned char D.11326;
  int D.11327;
  const unsigned char * D.11332;
  unsigned char D.11333;
  int D.11334;
  const unsigned char * D.11335;
  unsigned char D.11336;
  int D.11337;
  const unsigned char * D.11342;
  unsigned char D.11343;
  int D.11344;
  const unsigned char * D.11345;
  unsigned char D.11346;
  int D.11347;
  const unsigned char * D.11352;
  unsigned char D.11353;
  int D.11354;
  const unsigned char * D.11355;
  unsigned char D.11356;
  int D.11357;
  char * val.17;
  int D.11185;
  int iftmp.18;
  int D.11184;
  const char[5] * D.11366;
  unsigned char D.11367;
  int D.11368;
  unsigned char D.11369;
  int D.11370;
  const unsigned char * D.11375;
  unsigned char D.11376;
  int D.11377;
  const unsigned char * D.11378;
  unsigned char D.11379;
  int D.11380;
  const unsigned char * D.11385;
  unsigned char D.11386;
  int D.11387;
  const unsigned char * D.11388;
  unsigned char D.11389;
  int D.11390;
  const unsigned char * D.11395;
  unsigned char D.11396;
  int D.11397;
  const unsigned char * D.11398;
  unsigned char D.11399;
  int D.11400;
  struct _IO_FILE * stderr.19;
  long unsigned int D.11422;
  int command_port.20;
  long unsigned int D.11426;
  int num_frames.21;
  int num_frames.22;
  _Bool D.11431;
  int notraces.23;
  long unsigned int D.11435;
  int max_call_depth.24;
  int do_mono_sample.25;
  int sample_type.26;
  <unnamed type> events.27;
  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.11300 = strncmp (p, "log", 3);
  if (D.11300 != 0) goto <D.11301>; else goto <D.11302>;
  <D.11301>:
  usage (1);
  <D.11302>:
  p = p + 3;
  D.11303 = *p;
  if (D.11303 == 58) goto <D.11304>; else goto <D.11305>;
  <D.11304>:
  p = p + 1;
  <D.11305>:
  goto <D.11190>;
  <D.11189>:
  {
    char * val;

    try
      {
        D.11303 = *p;
        if (D.11303 == 44) goto <D.11306>; else goto <D.11307>;
        <D.11306>:
        opt = p + 1;
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11307>:
        opt = match_option (p, "help", 0B);
        if (opt != p) goto <D.11308>; else goto <D.11309>;
        <D.11308>:
        usage (0);
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11309>:
        opt = match_option (p, "calls", 0B);
        if (opt != p) goto <D.11310>; else goto <D.11311>;
        <D.11310>:
        calls_enabled = 1;
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11311>:
        opt = match_option (p, "nocalls", 0B);
        if (opt != p) goto <D.11312>; else goto <D.11313>;
        <D.11312>:
        events = events & -4097;
        nocalls = 1;
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11313>:
        opt = match_option (p, "alloc", 0B);
        if (opt != p) goto <D.11314>; else goto <D.11315>;
        <D.11314>:
        allocs_enabled = 1;
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11315>:
        opt = match_option (p, "noalloc", 0B);
        if (opt != p) goto <D.11316>; else goto <D.11317>;
        <D.11316>:
        events = events & -129;
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11317>:
        opt = match_option (p, "time", &val);
        if (opt != p) goto <D.11318>; else goto <D.11319>;
        <D.11318>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = val;
            D.11323 = "fast";
            D.11324 = MEM[(const unsigned char *)D.11323];
            D.11325 = (int) D.11324;
            D.11326 = *__s2;
            D.11327 = (int) D.11326;
            __result = D.11325 - D.11327;
            {
              if (__s2_len != 0) goto <D.11328>; else goto <D.11329>;
              <D.11328>:
              if (__result == 0) goto <D.11330>; else goto <D.11331>;
              <D.11330>:
              D.11332 = &MEM[(void *)"fast" + 1B];
              D.11333 = *D.11332;
              D.11334 = (int) D.11333;
              D.11335 = __s2 + 1;
              D.11336 = *D.11335;
              D.11337 = (int) D.11336;
              __result = D.11334 - D.11337;
              if (__s2_len > 1) goto <D.11338>; else goto <D.11339>;
              <D.11338>:
              if (__result == 0) goto <D.11340>; else goto <D.11341>;
              <D.11340>:
              D.11342 = &MEM[(void *)"fast" + 2B];
              D.11343 = *D.11342;
              D.11344 = (int) D.11343;
              D.11345 = __s2 + 2;
              D.11346 = *D.11345;
              D.11347 = (int) D.11346;
              __result = D.11344 - D.11347;
              if (__s2_len > 2) goto <D.11348>; else goto <D.11349>;
              <D.11348>:
              if (__result == 0) goto <D.11350>; else goto <D.11351>;
              <D.11350>:
              D.11352 = &MEM[(void *)"fast" + 3B];
              D.11353 = *D.11352;
              D.11354 = (int) D.11353;
              D.11355 = __s2 + 3;
              D.11356 = *D.11355;
              D.11357 = (int) D.11356;
              __result = D.11354 - D.11357;
              <D.11351>:
              <D.11349>:
              <D.11341>:
              <D.11339>:
              <D.11331>:
              <D.11329>:
            }
            D.11175 = __result;
          }
          iftmp.16 = -D.11175;
          goto <D.11358>;
          <D.11322>:
          val.17 = val;
          iftmp.16 = __builtin_strcmp (val.17, "fast");
          <D.11358>:
          D.11176 = iftmp.16;
        }
        if (D.11176 == 0) goto <D.11360>; else goto <D.11361>;
        <D.11360>:
        fast_time = 1;
        goto <D.11362>;
        <D.11361>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = val;
            D.11366 = "null";
            D.11367 = MEM[(const unsigned char *)D.11366];
            D.11368 = (int) D.11367;
            D.11369 = *__s2;
            D.11370 = (int) D.11369;
            __result = D.11368 - D.11370;
            {
              if (__s2_len != 0) goto <D.11371>; else goto <D.11372>;
              <D.11371>:
              if (__result == 0) goto <D.11373>; else goto <D.11374>;
              <D.11373>:
              D.11375 = &MEM[(void *)"null" + 1B];
              D.11376 = *D.11375;
              D.11377 = (int) D.11376;
              D.11378 = __s2 + 1;
              D.11379 = *D.11378;
              D.11380 = (int) D.11379;
              __result = D.11377 - D.11380;
              if (__s2_len > 1) goto <D.11381>; else goto <D.11382>;
              <D.11381>:
              if (__result == 0) goto <D.11383>; else goto <D.11384>;
              <D.11383>:
              D.11385 = &MEM[(void *)"null" + 2B];
              D.11386 = *D.11385;
              D.11387 = (int) D.11386;
              D.11388 = __s2 + 2;
              D.11389 = *D.11388;
              D.11390 = (int) D.11389;
              __result = D.11387 - D.11390;
              if (__s2_len > 2) goto <D.11391>; else goto <D.11392>;
              <D.11391>:
              if (__result == 0) goto <D.11393>; else goto <D.11394>;
              <D.11393>:
              D.11395 = &MEM[(void *)"null" + 3B];
              D.11396 = *D.11395;
              D.11397 = (int) D.11396;
              D.11398 = __s2 + 3;
              D.11399 = *D.11398;
              D.11400 = (int) D.11399;
              __result = D.11397 - D.11400;
              <D.11394>:
              <D.11392>:
              <D.11384>:
              <D.11382>:
              <D.11374>:
              <D.11372>:
            }
            D.11184 = __result;
          }
          iftmp.18 = -D.11184;
          goto <D.11401>;
          <D.11365>:
          val.17 = val;
          iftmp.18 = __builtin_strcmp (val.17, "null");
          <D.11401>:
          D.11185 = iftmp.18;
        }
        if (D.11185 == 0) goto <D.11402>; else goto <D.11403>;
        <D.11402>:
        fast_time = 2;
        goto <D.11404>;
        <D.11403>:
        usage (1);
        <D.11404>:
        <D.11362>:
        val.17 = val;
        free (val.17);
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11319>:
        opt = match_option (p, "report", 0B);
        if (opt != p) goto <D.11405>; else goto <D.11406>;
        <D.11405>:
        do_report = 1;
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11406>:
        opt = match_option (p, "debug", 0B);
        if (opt != p) goto <D.11407>; else goto <D.11408>;
        <D.11407>:
        do_debug = 1;
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11408>:
        opt = match_option (p, "heapshot", &val);
        if (opt != p) goto <D.11409>; else goto <D.11410>;
        <D.11409>:
        events = events & -129;
        events = events & -4097;
        nocalls = 1;
        do_heap_shot = 1;
        val.17 = val;
        set_hsmode (val.17, 1);
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11410>:
        opt = match_option (p, "sample", &val);
        if (opt != p) goto <D.11411>; else goto <D.11412>;
        <D.11411>:
        events = events & -129;
        events = events & -4097;
        nocalls = 1;
        val.17 = val;
        set_sample_mode (val.17, 1);
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11412>:
        opt = match_option (p, "hsmode", &val);
        if (opt != p) goto <D.11413>; else goto <D.11414>;
        <D.11413>:
        stderr.19 = stderr;
        fprintf (stderr.19, "The hsmode profiler option is obsolete, use heapshot=MODE.\n");
        val.17 = val;
        set_hsmode (val.17, 0);
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11414>:
        opt = match_option (p, "zip", 0B);
        if (opt != p) goto <D.11416>; else goto <D.11417>;
        <D.11416>:
        use_zip = 1;
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11417>:
        opt = match_option (p, "output", &val);
        if (opt != p) goto <D.11418>; else goto <D.11419>;
        <D.11418>:
        filename = val;
        // predicted unlikely by continue predictor.
        goto <D.11167>;
        <D.11419>:
        opt = match_option (p, "port", &val);
        if (opt != p) goto <D.11420>; else goto <D.11421>;
        <D.11420>:
        {
          char * end;

          try
            {
              val.17 = val;
              D.11422 = strtoul (val.17, &end, 10);
              command_port.20 = (int) D.11422;
              command_port = command_port.20;
              val.17 = val;
              free (val.17);
              // predicted unlikely by continue predictor.
              goto <D.11167>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.11421>:
        opt = match_option (p, "maxframes", &val);
        if (opt != p) goto <D.11424>; else goto <D.11425>;
        <D.11424>:
        {
          char * end;

          try
            {
              val.17 = val;
              D.11426 = strtoul (val.17, &end, 10);
              num_frames.21 = (int) D.11426;
              num_frames = num_frames.21;
              num_frames.22 = num_frames;
              if (num_frames.22 > 16) goto <D.11429>; else goto <D.11430>;
              <D.11429>:
              num_frames = 16;
              <D.11430>:
              val.17 = val;
              free (val.17);
              num_frames.22 = num_frames;
              D.11431 = num_frames.22 == 0;
              notraces.23 = (int) D.11431;
              notraces = notraces.23;
              // predicted unlikely by continue predictor.
              goto <D.11167>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.11425>:
        opt = match_option (p, "calldepth", &val);
        if (opt != p) goto <D.11433>; else goto <D.11434>;
        <D.11433>:
        {
          char * end;

          try
            {
              val.17 = val;
              D.11435 = strtoul (val.17, &end, 10);
              max_call_depth.24 = (int) D.11435;
              max_call_depth = max_call_depth.24;
              val.17 = val;
              free (val.17);
              // predicted unlikely by continue predictor.
              goto <D.11167>;
            }
          finally
            {
              end = {CLOBBER};
            }
        }
        <D.11434>:
        if (opt == p) goto <D.11437>; else goto <D.11438>;
        <D.11437>:
        usage (0);
        exit (0);
        <D.11438>:
      }
    finally
      {
        val = {CLOBBER};
      }
  }
  <D.11167>:
  p = opt;
  <D.11190>:
  D.11303 = *p;
  if (D.11303 != 0) goto <D.11189>; else goto <D.11191>;
  <D.11191>:
  if (calls_enabled != 0) goto <D.11439>; else goto <D.11440>;
  <D.11439>:
  events = events | 4096;
  nocalls = 0;
  <D.11440>:
  if (allocs_enabled != 0) goto <D.11441>; else goto <D.11442>;
  <D.11441>:
  events = events | 128;
  <D.11442>:
  utils_init (fast_time);
  prof = create_profiler (filename);
  if (prof == 0B) goto <D.11443>; else goto <D.11444>;
  <D.11443>:
  return;
  <D.11444>:
  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.25 = do_mono_sample;
  if (do_mono_sample.25 != 0) goto <D.11446>; else goto <D.11447>;
  <D.11446>:
  sample_type.26 = sample_type;
  if (sample_type.26 == 1) goto <D.11449>; else goto <D.11450>;
  <D.11449>:
  events = events | 32768;
  mono_profiler_install_statistical (mono_sample_hit);
  <D.11450>:
  <D.11447>:
  events.27 = (<unnamed type>) events;
  mono_profiler_set_events (events.27);
}


mono_sample_hit (struct MonoProfiler * profiler, unsigned char * ip, void * context)
{
  int in_shutdown.28;
  int do_debug.29;
  unsigned int D.11482;
  void * D.11483;
  unsigned int D.11484;
  unsigned int len.30;
  uintptr_t * D.11488;
  uintptr_t * D.11489;
  uintptr_t * D.11490;
  struct StatBuffer * D.11493;
  struct StatBuffer * D.11496;
  struct StatBuffer * D.11497;
  int D.11500;
  uintptr_t * * D.11503;
  int sample_type.31;
  int D.11507;
  int D.11508;
  unsigned int D.11509;
  uintptr_t * D.11510;
  unsigned int D.11511;
  uintptr_t * D.11512;
  long long unsigned int D.11513;
  long long unsigned int D.11514;
  long long unsigned int D.11515;
  unsigned int D.11516;
  uintptr_t * D.11517;
  unsigned int ip.32;
  struct StatBuffer * sbuf;
  uint64_t now;
  uintptr_t * data;
  uintptr_t * new_data;
  uintptr_t * old_data;

  in_shutdown.28 = in_shutdown;
  if (in_shutdown.28 != 0) goto <D.11477>; else goto <D.11478>;
  <D.11477>:
  return;
  <D.11478>:
  now = current_time ();
  do_debug.29 = do_debug;
  if (do_debug.29 != 0) goto <D.11480>; else goto <D.11481>;
  <D.11480>:
  {
    int len;
    char buf[256];

    try
      {
        D.11482 = thread_id ();
        D.11483 = (void *) D.11482;
        snprintf (&buf, 256, "hit at %p in thread %p at %llu\n", ip, D.11483, now);
        D.11484 = strlen (&buf);
        len = (int) D.11484;
        len.30 = (unsigned int) len;
        write (2, &buf, len.30);
      }
    finally
      {
        buf = {CLOBBER};
      }
  }
  <D.11481>:
  sbuf = profiler->stat_buffers;
  if (sbuf == 0B) goto <D.11486>; else goto <D.11487>;
  <D.11486>:
  return;
  <D.11487>:
  D.11488 = sbuf->data;
  D.11489 = D.11488 + 1600;
  D.11490 = sbuf->data_end;
  if (D.11489 >= D.11490) goto <D.11491>; else goto <D.11492>;
  <D.11491>:
  sbuf = create_stat_buffer ();
  D.11493 = profiler->stat_buffers;
  sbuf->next = D.11493;
  profiler->stat_buffers = sbuf;
  do_debug.29 = do_debug;
  if (do_debug.29 != 0) goto <D.11494>; else goto <D.11495>;
  <D.11494>:
  write (2, "overflow\n", 9);
  <D.11495>:
  D.11496 = sbuf->next;
  D.11497 = D.11496->next;
  if (D.11497 != 0B) goto <D.11498>; else goto <D.11499>;
  <D.11498>:
  {
    char c;

    try
      {
        c = 0;
        D.11500 = profiler->pipes[1];
        write (D.11500, &c, 1);
        do_debug.29 = do_debug;
        if (do_debug.29 != 0) goto <D.11501>; else goto <D.11502>;
        <D.11501>:
        write (2, "notify\n", 7);
        <D.11502>:
      }
    finally
      {
        c = {CLOBBER};
      }
  }
  <D.11499>:
  <D.11492>:
  <D.10819>:
  old_data = sbuf->data;
  new_data = old_data + 16;
  D.11503 = &sbuf->data;
  data = InterlockedCompareExchangePointer (D.11503, new_data, old_data);
  if (data != old_data) goto <D.10819>; else goto <D.10820>;
  <D.10820>:
  D.11490 = sbuf->data_end;
  if (D.11490 <= old_data) goto <D.11504>; else goto <D.11505>;
  <D.11504>:
  return;
  <D.11505>:
  sample_type.31 = sample_type;
  D.11507 = sample_type.31 << 16;
  D.11508 = D.11507 | 1;
  D.11509 = (unsigned int) D.11508;
  *old_data = D.11509;
  D.11510 = old_data + 4;
  D.11511 = thread_id ();
  *D.11510 = D.11511;
  D.11512 = old_data + 8;
  D.11513 = profiler->startup_time;
  D.11514 = now - D.11513;
  D.11515 = D.11514 / 10000;
  D.11516 = (unsigned int) D.11515;
  *D.11512 = D.11516;
  D.11517 = old_data + 12;
  ip.32 = (unsigned int) ip;
  *D.11517 = ip.32;
}


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

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


create_stat_buffer ()
{
  unsigned int D.11532;
  uintptr_t * D.11533;
  uintptr_t[1] * D.11534;
  struct StatBuffer * D.11535;
  struct StatBuffer * buf;

  buf = alloc_buffer (65536);
  buf->size = 65536;
  D.11532 = buf->size;
  D.11533 = buf + D.11532;
  buf->data_end = D.11533;
  D.11534 = &buf->buf;
  buf->data = D.11534;
  D.11535 = buf;
  return D.11535;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.11538;
  unsigned int comp.33;
  unsigned int exch.34;
  unsigned int D.11541;

  comp.33 = (unsigned int) comp;
  exch.34 = (unsigned int) exch;
  D.11541 = __sync_val_compare_and_swap_4 (dest, comp.33, exch.34);
  D.11538 = (void *) D.11541;
  return D.11538;
}


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


monitor_event (struct MonoProfiler * profiler, struct MonoObject * object, MonoProfilerMonitorEvent event)
{
  int iftmp.35;
  int nocalls.36;
  int runtime_inited.37;
  int notraces.38;
  int D.11555;
  int D.11558;
  unsigned int D.11559;
  unsigned int do_bt.39;
  unsigned int D.11561;
  unsigned int D.11562;
  int D.11563;
  int D.11566;
  int do_bt;
  uint64_t now;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.36 = nocalls;
      if (nocalls.36 != 0) goto <D.11547>; else goto <D.11544>;
      <D.11547>:
      runtime_inited.37 = runtime_inited;
      if (runtime_inited.37 != 0) goto <D.11549>; else goto <D.11544>;
      <D.11549>:
      notraces.38 = notraces;
      if (notraces.38 == 0) goto <D.11551>; else goto <D.11544>;
      <D.11551>:
      if (event == 1) goto <D.11552>; else goto <D.11544>;
      <D.11552>:
      iftmp.35 = 128;
      goto <D.11545>;
      <D.11544>:
      iftmp.35 = 0;
      <D.11545>:
      do_bt = iftmp.35;
      if (do_bt != 0) goto <D.11553>; else goto <D.11554>;
      <D.11553>:
      collect_bt (&data);
      <D.11554>:
      logbuffer = ensure_logbuf (144);
      now = current_time ();
      D.11555 = logbuffer->locked;
      if (D.11555 != 0) goto <D.11556>; else goto <D.11557>;
      <D.11556>:
      write (2, "monitor", 7);
      write (2, "\n", 1);
      return;
      <D.11557>:
      D.11555 = logbuffer->locked;
      D.11558 = D.11555 + 1;
      logbuffer->locked = D.11558;
      D.11559 = event << 4;
      do_bt.39 = (unsigned int) do_bt;
      D.11561 = D.11559 | do_bt.39;
      D.11562 = D.11561 | 5;
      D.11563 = (int) D.11562;
      emit_byte (logbuffer, D.11563);
      emit_time (logbuffer, now);
      emit_obj (logbuffer, object);
      if (do_bt != 0) goto <D.11564>; else goto <D.11565>;
      <D.11564>:
      emit_bt (logbuffer, &data);
      <D.11565>:
      D.11555 = logbuffer->locked;
      D.11566 = D.11555 + -1;
      logbuffer->locked = D.11566;
      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.11575;
  int num_frames.40;
  int D.11579;
  int D.11580;
  mono_bool D.11581;
  _Bool D.11582;
  struct FrameData * frame;

  frame = data;
  if (method != 0B) goto <D.11573>; else goto <D.11574>;
  <D.11573>:
  D.11575 = frame->count;
  num_frames.40 = num_frames;
  if (D.11575 < num_frames.40) goto <D.11577>; else goto <D.11578>;
  <D.11577>:
  D.11575 = frame->count;
  D.11579 = D.11575;
  D.11580 = D.11579 + 1;
  frame->count = D.11580;
  frame->methods[D.11579] = method;
  <D.11578>:
  <D.11574>:
  D.11575 = frame->count;
  num_frames.40 = num_frames;
  D.11582 = D.11575 == num_frames.40;
  D.11581 = (mono_bool) D.11582;
  return D.11581;
}


ensure_logbuf (int bytes)
{
  unsigned char * D.11586;
  sizetype bytes.41;
  sizetype D.11588;
  unsigned char * D.11589;
  unsigned char * D.11590;
  struct LogBuffer * D.11593;
  struct LogBuffer * tlsbuffer.42;
  int D.11597;
  struct LogBuffer * old;

  old = tlsbuffer;
  if (old != 0B) goto <D.11584>; else goto <D.11585>;
  <D.11584>:
  D.11586 = old->data;
  bytes.41 = (sizetype) bytes;
  D.11588 = bytes.41 + 100;
  D.11589 = D.11586 + D.11588;
  D.11590 = old->data_end;
  if (D.11589 < D.11590) goto <D.11591>; else goto <D.11592>;
  <D.11591>:
  D.11593 = old;
  return D.11593;
  <D.11592>:
  <D.11585>:
  tlsbuffer = 0B;
  init_thread ();
  tlsbuffer.42 = tlsbuffer;
  tlsbuffer.42->next = old;
  if (old != 0B) goto <D.11595>; else goto <D.11596>;
  <D.11595>:
  tlsbuffer.42 = tlsbuffer;
  D.11597 = old->call_depth;
  tlsbuffer.42->call_depth = D.11597;
  <D.11596>:
  D.11593 = tlsbuffer;
  return D.11593;
}


emit_byte (struct LogBuffer * logbuffer, int value)
{
  unsigned char * D.11599;
  unsigned char D.11600;
  unsigned char * D.11601;
  unsigned char * D.11602;
  static const char __PRETTY_FUNCTION__[10] = "emit_byte";

  D.11599 = logbuffer->data;
  D.11600 = (unsigned char) value;
  *D.11599 = D.11600;
  D.11599 = logbuffer->data;
  D.11601 = D.11599 + 1;
  logbuffer->data = D.11601;
  D.11599 = logbuffer->data;
  D.11602 = logbuffer->data_end;
  if (D.11599 > D.11602) goto <D.11603>; else goto <D.11604>;
  <D.11603>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 443, &__PRETTY_FUNCTION__);
  <D.11604>:
}


emit_time (struct LogBuffer * logbuffer, uint64_t value)
{
  long long unsigned int D.11605;
  unsigned char * D.11608;
  unsigned char * * D.11609;
  unsigned char * D.11610;
  uint64_t tdiff;
  unsigned char * p;
  static const char __PRETTY_FUNCTION__[10] = "emit_time";

  D.11605 = logbuffer->last_time;
  tdiff = value - D.11605;
  D.11605 = logbuffer->last_time;
  if (D.11605 > value) goto <D.11606>; else goto <D.11607>;
  <D.11606>:
  printf ("time went backwards\n");
  <D.11607>:
  p = logbuffer->data;
  D.11608 = logbuffer->data;
  D.11609 = &logbuffer->data;
  encode_uleb128 (tdiff, D.11608, D.11609);
  logbuffer->last_time = value;
  D.11608 = logbuffer->data;
  D.11610 = logbuffer->data_end;
  if (D.11608 > D.11610) goto <D.11611>; else goto <D.11612>;
  <D.11611>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 467, &__PRETTY_FUNCTION__);
  <D.11612>:
}


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

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


emit_obj (struct LogBuffer * logbuffer, void * ptr)
{
  unsigned int D.11616;
  unsigned int ptr.43;
  unsigned int D.11620;
  unsigned int D.11621;
  long long int D.11622;
  unsigned char * D.11623;
  unsigned char * D.11624;
  static const char __PRETTY_FUNCTION__[9] = "emit_obj";

  D.11616 = logbuffer->obj_base;
  if (D.11616 == 0) goto <D.11617>; else goto <D.11618>;
  <D.11617>:
  ptr.43 = (unsigned int) ptr;
  D.11620 = ptr.43 >> 3;
  logbuffer->obj_base = D.11620;
  <D.11618>:
  ptr.43 = (unsigned int) ptr;
  D.11620 = ptr.43 >> 3;
  D.11616 = logbuffer->obj_base;
  D.11621 = D.11620 - D.11616;
  D.11622 = (long long int) D.11621;
  emit_svalue (logbuffer, D.11622);
  D.11623 = logbuffer->data;
  D.11624 = logbuffer->data_end;
  if (D.11623 > D.11624) goto <D.11625>; else goto <D.11626>;
  <D.11625>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 511, &__PRETTY_FUNCTION__);
  <D.11626>:
}


emit_svalue (struct LogBuffer * logbuffer, int64_t value)
{
  int D.11627;
  unsigned char * D.11628;
  unsigned char * * D.11629;
  unsigned char * D.11630;
  static const char __PRETTY_FUNCTION__[12] = "emit_svalue";

  D.11627 = (int) value;
  D.11628 = logbuffer->data;
  D.11629 = &logbuffer->data;
  encode_sleb128 (D.11627, D.11628, D.11629);
  D.11628 = logbuffer->data;
  D.11630 = logbuffer->data_end;
  if (D.11628 > D.11630) goto <D.11631>; else goto <D.11632>;
  <D.11631>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 474, &__PRETTY_FUNCTION__);
  <D.11632>:
}


emit_bt (struct LogBuffer * logbuffer, struct FrameData * data)
{
  int D.11633;
  int num_frames.44;
  int D.11637;
  struct MonoMethod * D.11638;

  D.11633 = data->count;
  num_frames.44 = num_frames;
  if (D.11633 > num_frames.44) goto <D.11635>; else goto <D.11636>;
  <D.11635>:
  D.11633 = data->count;
  printf ("bad num frames: %d\n", D.11633);
  <D.11636>:
  emit_value (logbuffer, 0);
  D.11633 = data->count;
  emit_value (logbuffer, D.11633);
  goto <D.10662>;
  <D.10661>:
  D.11633 = data->count;
  D.11637 = D.11633 + -1;
  data->count = D.11637;
  D.11633 = data->count;
  D.11638 = data->methods[D.11633];
  emit_ptr (logbuffer, D.11638);
  <D.10662>:
  D.11633 = data->count;
  if (D.11633 != 0) goto <D.10661>; else goto <D.10663>;
  <D.10663>:
}


emit_value (struct LogBuffer * logbuffer, int value)
{
  long long unsigned int D.11639;
  unsigned char * D.11640;
  unsigned char * * D.11641;
  unsigned char * D.11642;
  static const char __PRETTY_FUNCTION__[11] = "emit_value";

  D.11639 = (long long unsigned int) value;
  D.11640 = logbuffer->data;
  D.11641 = &logbuffer->data;
  encode_uleb128 (D.11639, D.11640, D.11641);
  D.11640 = logbuffer->data;
  D.11642 = logbuffer->data_end;
  if (D.11640 > D.11642) goto <D.11643>; else goto <D.11644>;
  <D.11643>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 450, &__PRETTY_FUNCTION__);
  <D.11644>:
}


emit_ptr (struct LogBuffer * logbuffer, void * ptr)
{
  unsigned int D.11645;
  unsigned int ptr.45;
  unsigned int ptr.46;
  unsigned int D.11650;
  long long int D.11651;
  unsigned char * D.11652;
  unsigned char * D.11653;
  static const char __PRETTY_FUNCTION__[9] = "emit_ptr";

  D.11645 = logbuffer->ptr_base;
  if (D.11645 == 0) goto <D.11646>; else goto <D.11647>;
  <D.11646>:
  ptr.45 = (unsigned int) ptr;
  logbuffer->ptr_base = ptr.45;
  <D.11647>:
  ptr.46 = (unsigned int) ptr;
  D.11645 = logbuffer->ptr_base;
  D.11650 = ptr.46 - D.11645;
  D.11651 = (long long int) D.11650;
  emit_svalue (logbuffer, D.11651);
  D.11652 = logbuffer->data;
  D.11653 = logbuffer->data_end;
  if (D.11652 > D.11653) goto <D.11654>; else goto <D.11655>;
  <D.11654>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 490, &__PRETTY_FUNCTION__);
  <D.11655>:
}


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

  heapshot_requested.47 = heapshot_requested;
  if (heapshot_requested.47 != 0) goto <D.11657>; else goto <D.11658>;
  <D.11657>:
  D.11659 = mono_gc_max_generation ();
  mono_gc_collect (D.11659);
  <D.11658>:
}


clause_exc (struct MonoProfiler * prof, struct MonoMethod * method, int clause_type, int clause_num)
{
  int D.11661;
  int D.11664;
  int D.11665;
  uint64_t now;
  struct LogBuffer * logbuffer;

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


emit_method (struct LogBuffer * logbuffer, void * method)
{
  unsigned int D.11669;
  unsigned int method.48;
  int method.49;
  unsigned int D.11674;
  int D.11675;
  int D.11676;
  unsigned char * D.11677;
  unsigned char * * D.11678;
  unsigned char * D.11679;
  static const char __PRETTY_FUNCTION__[12] = "emit_method";

  D.11669 = logbuffer->method_base;
  if (D.11669 == 0) goto <D.11670>; else goto <D.11671>;
  <D.11670>:
  method.48 = (unsigned int) method;
  logbuffer->method_base = method.48;
  method.48 = (unsigned int) method;
  logbuffer->last_method = method.48;
  <D.11671>:
  method.49 = (int) method;
  D.11674 = logbuffer->last_method;
  D.11675 = (int) D.11674;
  D.11676 = method.49 - D.11675;
  D.11677 = logbuffer->data;
  D.11678 = &logbuffer->data;
  encode_sleb128 (D.11676, D.11677, D.11678);
  method.48 = (unsigned int) method;
  logbuffer->last_method = method.48;
  D.11677 = logbuffer->data;
  D.11679 = logbuffer->data_end;
  if (D.11677 > D.11679) goto <D.11680>; else goto <D.11681>;
  <D.11680>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 502, &__PRETTY_FUNCTION__);
  <D.11681>:
}


method_exc_leave (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int nocalls.50;
  int D.11685;
  int D.11686;
  int max_call_depth.51;
  int D.11690;
  int D.11693;
  int D.11694;
  uint64_t now;
  struct LogBuffer * logbuffer;

  nocalls.50 = nocalls;
  if (nocalls.50 != 0) goto <D.11683>; else goto <D.11684>;
  <D.11683>:
  return;
  <D.11684>:
  logbuffer = ensure_logbuf (16);
  D.11685 = logbuffer->call_depth;
  D.11686 = D.11685 + -1;
  logbuffer->call_depth = D.11686;
  D.11685 = logbuffer->call_depth;
  max_call_depth.51 = max_call_depth;
  if (D.11685 > max_call_depth.51) goto <D.11688>; else goto <D.11689>;
  <D.11688>:
  return;
  <D.11689>:
  now = current_time ();
  D.11690 = logbuffer->locked;
  if (D.11690 != 0) goto <D.11691>; else goto <D.11692>;
  <D.11691>:
  write (2, "eleave", 6);
  write (2, "\n", 1);
  return;
  <D.11692>:
  D.11690 = logbuffer->locked;
  D.11693 = D.11690 + 1;
  logbuffer->locked = D.11693;
  emit_byte (logbuffer, 51);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.11690 = logbuffer->locked;
  D.11694 = D.11690 + -1;
  logbuffer->locked = D.11694;
  process_requests (prof);
}


throw_exc (struct MonoProfiler * prof, struct MonoObject * object)
{
  int iftmp.52;
  int nocalls.53;
  int runtime_inited.54;
  int notraces.55;
  int D.11709;
  int D.11712;
  int D.11713;
  int D.11716;
  int do_bt;
  uint64_t now;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.53 = nocalls;
      if (nocalls.53 != 0) goto <D.11702>; else goto <D.11699>;
      <D.11702>:
      runtime_inited.54 = runtime_inited;
      if (runtime_inited.54 != 0) goto <D.11704>; else goto <D.11699>;
      <D.11704>:
      notraces.55 = notraces;
      if (notraces.55 == 0) goto <D.11706>; else goto <D.11699>;
      <D.11706>:
      iftmp.52 = 128;
      goto <D.11700>;
      <D.11699>:
      iftmp.52 = 0;
      <D.11700>:
      do_bt = iftmp.52;
      if (do_bt != 0) goto <D.11707>; else goto <D.11708>;
      <D.11707>:
      collect_bt (&data);
      <D.11708>:
      logbuffer = ensure_logbuf (144);
      now = current_time ();
      D.11709 = logbuffer->locked;
      if (D.11709 != 0) goto <D.11710>; else goto <D.11711>;
      <D.11710>:
      write (2, "throw", 5);
      write (2, "\n", 1);
      return;
      <D.11711>:
      D.11709 = logbuffer->locked;
      D.11712 = D.11709 + 1;
      logbuffer->locked = D.11712;
      D.11713 = do_bt | 4;
      emit_byte (logbuffer, D.11713);
      emit_time (logbuffer, now);
      emit_obj (logbuffer, object);
      if (do_bt != 0) goto <D.11714>; else goto <D.11715>;
      <D.11714>:
      emit_bt (logbuffer, &data);
      <D.11715>:
      D.11709 = logbuffer->locked;
      D.11716 = D.11709 + -1;
      logbuffer->locked = D.11716;
      process_requests (prof);
    }
  finally
    {
      data = {CLOBBER};
    }
}


method_jitted (struct MonoProfiler * prof, struct MonoMethod * method, struct MonoJitInfo * jinfo, int result)
{
  unsigned int D.11725;
  unsigned int D.11726;
  int D.11727;
  int D.11728;
  int D.11731;
  void * D.11732;
  int D.11733;
  unsigned char * D.11734;
  unsigned int nlen.56;
  sizetype nlen.57;
  unsigned char * D.11737;
  int D.11738;
  struct LogBuffer * D.11739;
  uint64_t now;
  char * name;
  int nlen;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.11723>; else goto <D.11724>;
  <D.11723>:
  return;
  <D.11724>:
  name = mono_method_full_name (method, 1);
  D.11725 = strlen (name);
  D.11726 = D.11725 + 1;
  nlen = (int) D.11726;
  D.11727 = nlen + 32;
  logbuffer = ensure_logbuf (D.11727);
  now = current_time ();
  D.11728 = logbuffer->locked;
  if (D.11728 != 0) goto <D.11729>; else goto <D.11730>;
  <D.11729>:
  write (2, "jit", 3);
  write (2, "\n", 1);
  return;
  <D.11730>:
  D.11728 = logbuffer->locked;
  D.11731 = D.11728 + 1;
  logbuffer->locked = D.11731;
  emit_byte (logbuffer, 67);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.11732 = mono_jit_info_get_code_start (jinfo);
  emit_ptr (logbuffer, D.11732);
  D.11733 = mono_jit_info_get_code_size (jinfo);
  emit_value (logbuffer, D.11733);
  D.11734 = logbuffer->data;
  nlen.56 = (unsigned int) nlen;
  memcpy (D.11734, name, nlen.56);
  D.11734 = logbuffer->data;
  nlen.57 = (sizetype) nlen;
  D.11737 = D.11734 + nlen.57;
  logbuffer->data = D.11737;
  mono_free (name);
  D.11728 = logbuffer->locked;
  D.11738 = D.11728 + -1;
  logbuffer->locked = D.11738;
  D.11739 = logbuffer->next;
  if (D.11739 != 0B) goto <D.11740>; else goto <D.11741>;
  <D.11740>:
  safe_dump (prof, logbuffer);
  <D.11741>:
  process_requests (prof);
}


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

  D.11749 = __builtin_object_size (__dest, 0);
  D.11748 = __builtin___memcpy_chk (__dest, __src, __len, D.11749);
  return D.11748;
}


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

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


dump_buffer (struct MonoProfiler * profiler, struct LogBuffer * buf)
{
  struct LogBuffer * D.11752;
  unsigned char * D.11755;
  int D.11756;
  unsigned char[1] * D.11757;
  int D.11758;
  int D.11759;
  long long unsigned int D.11760;
  long long int D.11761;
  unsigned int D.11762;
  long long int D.11763;
  unsigned int D.11764;
  long long int D.11765;
  unsigned int D.11766;
  long long int D.11767;
  unsigned int D.11768;
  long long int D.11769;
  int p.59;
  int hbuf.60;
  int D.11772;
  unsigned int D.11773;
  struct FILE * D.11774;
  unsigned int D.11775;
  int D.11776;
  char hbuf[128];
  char * p;

  try
    {
      p = &hbuf;
      D.11752 = buf->next;
      if (D.11752 != 0B) goto <D.11753>; else goto <D.11754>;
      <D.11753>:
      D.11752 = buf->next;
      dump_buffer (profiler, D.11752);
      <D.11754>:
      p = write_int32 (p, 1297107969);
      D.11755 = buf->data;
      D.11756 = (int) D.11755;
      D.11757 = &buf->buf;
      D.11758 = (int) D.11757;
      D.11759 = D.11756 - D.11758;
      p = write_int32 (p, D.11759);
      D.11760 = buf->time_base;
      D.11761 = (long long int) D.11760;
      p = write_int64 (p, D.11761);
      D.11762 = buf->ptr_base;
      D.11763 = (long long int) D.11762;
      p = write_int64 (p, D.11763);
      D.11764 = buf->obj_base;
      D.11765 = (long long int) D.11764;
      p = write_int64 (p, D.11765);
      D.11766 = buf->thread_id;
      D.11767 = (long long int) D.11766;
      p = write_int64 (p, D.11767);
      D.11768 = buf->method_base;
      D.11769 = (long long int) D.11768;
      p = write_int64 (p, D.11769);
      p.59 = (int) p;
      hbuf.60 = (int) &hbuf;
      D.11772 = p.59 - hbuf.60;
      D.11773 = (unsigned int) D.11772;
      D.11774 = profiler->file;
      fwrite (&hbuf, D.11773, 1, D.11774);
      D.11757 = &buf->buf;
      D.11755 = buf->data;
      D.11756 = (int) D.11755;
      D.11757 = &buf->buf;
      D.11758 = (int) D.11757;
      D.11759 = D.11756 - D.11758;
      D.11775 = (unsigned int) D.11759;
      D.11774 = profiler->file;
      fwrite (D.11757, D.11775, 1, D.11774);
      D.11774 = profiler->file;
      fflush (D.11774);
      D.11776 = buf->size;
      free_buffer (buf, D.11776);
    }
  finally
    {
      hbuf = {CLOBBER};
    }
}


write_int32 (char * buf, int32_t value)
{
  sizetype i.61;
  char * D.11787;
  char D.11788;
  char * D.11789;
  int i;

  i = 0;
  goto <D.10570>;
  <D.10569>:
  i.61 = (sizetype) i;
  D.11787 = buf + i.61;
  D.11788 = (char) value;
  *D.11787 = D.11788;
  value = value >> 8;
  i = i + 1;
  <D.10570>:
  if (i <= 3) goto <D.10569>; else goto <D.10571>;
  <D.10571>:
  D.11789 = buf + 4;
  return D.11789;
}


write_int64 (char * buf, int64_t value)
{
  sizetype i.62;
  char * D.11792;
  char D.11793;
  char * D.11794;
  int i;

  i = 0;
  goto <D.10578>;
  <D.10577>:
  i.62 = (sizetype) i;
  D.11792 = buf + i.62;
  D.11793 = (char) value;
  *D.11792 = D.11793;
  value = value >> 8;
  i = i + 1;
  <D.10578>:
  if (i <= 7) goto <D.10577>; else goto <D.10579>;
  <D.10579>:
  D.11794 = buf + 8;
  return D.11794;
}


method_leave (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int D.11796;
  int D.11797;
  int max_call_depth.63;
  int D.11801;
  int D.11804;
  int D.11805;
  struct LogBuffer * D.11806;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  D.11796 = logbuffer->call_depth;
  D.11797 = D.11796 + -1;
  logbuffer->call_depth = D.11797;
  D.11796 = logbuffer->call_depth;
  max_call_depth.63 = max_call_depth;
  if (D.11796 > max_call_depth.63) goto <D.11799>; else goto <D.11800>;
  <D.11799>:
  return;
  <D.11800>:
  now = current_time ();
  D.11801 = logbuffer->locked;
  if (D.11801 != 0) goto <D.11802>; else goto <D.11803>;
  <D.11802>:
  write (2, "leave", 5);
  write (2, "\n", 1);
  return;
  <D.11803>:
  D.11801 = logbuffer->locked;
  D.11804 = D.11801 + 1;
  logbuffer->locked = D.11804;
  emit_byte (logbuffer, 19);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.11801 = logbuffer->locked;
  D.11805 = D.11801 + -1;
  logbuffer->locked = D.11805;
  D.11806 = logbuffer->next;
  if (D.11806 != 0B) goto <D.11807>; else goto <D.11808>;
  <D.11807>:
  safe_dump (prof, logbuffer);
  <D.11808>:
  process_requests (prof);
}


method_enter (struct MonoProfiler * prof, struct MonoMethod * method)
{
  int D.11812;
  int D.11813;
  int D.11814;
  int max_call_depth.64;
  int D.11818;
  int D.11821;
  int D.11822;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  D.11812 = logbuffer->call_depth;
  D.11813 = D.11812;
  D.11814 = D.11813 + 1;
  logbuffer->call_depth = D.11814;
  max_call_depth.64 = max_call_depth;
  if (D.11813 > max_call_depth.64) goto <D.11816>; else goto <D.11817>;
  <D.11816>:
  return;
  <D.11817>:
  now = current_time ();
  D.11818 = logbuffer->locked;
  if (D.11818 != 0) goto <D.11819>; else goto <D.11820>;
  <D.11819>:
  write (2, "enter", 5);
  write (2, "\n", 1);
  return;
  <D.11820>:
  D.11818 = logbuffer->locked;
  D.11821 = D.11818 + 1;
  logbuffer->locked = D.11821;
  emit_byte (logbuffer, 35);
  emit_time (logbuffer, now);
  emit_method (logbuffer, method);
  D.11818 = logbuffer->locked;
  D.11822 = D.11818 + -1;
  logbuffer->locked = D.11822;
  process_requests (prof);
}


thread_name (struct MonoProfiler * prof, uintptr_t tid, const char * name)
{
  unsigned int D.11826;
  unsigned int D.11827;
  int D.11828;
  int D.11829;
  int D.11832;
  void * tid.65;
  unsigned char * D.11834;
  unsigned int len.66;
  sizetype len.67;
  unsigned char * D.11837;
  int D.11838;
  int len;
  uint64_t now;
  struct LogBuffer * logbuffer;

  D.11826 = strlen (name);
  D.11827 = D.11826 + 1;
  len = (int) D.11827;
  D.11828 = len + 10;
  logbuffer = ensure_logbuf (D.11828);
  now = current_time ();
  D.11829 = logbuffer->locked;
  if (D.11829 != 0) goto <D.11830>; else goto <D.11831>;
  <D.11830>:
  write (2, "tname", 5);
  write (2, "\n", 1);
  return;
  <D.11831>:
  D.11829 = logbuffer->locked;
  D.11832 = D.11829 + 1;
  logbuffer->locked = D.11832;
  emit_byte (logbuffer, 2);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 5);
  tid.65 = (void *) tid;
  emit_ptr (logbuffer, tid.65);
  emit_value (logbuffer, 0);
  D.11834 = logbuffer->data;
  len.66 = (unsigned int) len;
  memcpy (D.11834, name, len.66);
  D.11834 = logbuffer->data;
  len.67 = (sizetype) len;
  D.11837 = D.11834 + len.67;
  logbuffer->data = D.11837;
  D.11829 = logbuffer->locked;
  D.11838 = D.11829 + -1;
  logbuffer->locked = D.11838;
}


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

  take_lock ();
  tlsbuffer.68 = tlsbuffer;
  if (tlsbuffer.68 != 0B) goto <D.11843>; else goto <D.11844>;
  <D.11843>:
  tlsbuffer.68 = tlsbuffer;
  dump_buffer (prof, tlsbuffer.68);
  <D.11844>:
  release_lock ();
  tlsbuffer = 0B;
}


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


image_loaded (struct MonoProfiler * prof, struct MonoImage * image, int result)
{
  unsigned int D.11847;
  unsigned int D.11848;
  int D.11849;
  int D.11850;
  int D.11853;
  unsigned char * D.11854;
  unsigned int nlen.69;
  sizetype nlen.70;
  unsigned char * D.11857;
  int D.11858;
  struct LogBuffer * D.11859;
  uint64_t now;
  const char * name;
  int nlen;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.11845>; else goto <D.11846>;
  <D.11845>:
  return;
  <D.11846>:
  name = mono_image_get_filename (image);
  D.11847 = strlen (name);
  D.11848 = D.11847 + 1;
  nlen = (int) D.11848;
  D.11849 = nlen + 16;
  logbuffer = ensure_logbuf (D.11849);
  now = current_time ();
  D.11850 = logbuffer->locked;
  if (D.11850 != 0) goto <D.11851>; else goto <D.11852>;
  <D.11851>:
  write (2, "image", 5);
  write (2, "\n", 1);
  return;
  <D.11852>:
  D.11850 = logbuffer->locked;
  D.11853 = D.11850 + 1;
  logbuffer->locked = D.11853;
  emit_byte (logbuffer, 34);
  emit_time (logbuffer, now);
  emit_byte (logbuffer, 2);
  emit_ptr (logbuffer, image);
  emit_value (logbuffer, 0);
  D.11854 = logbuffer->data;
  nlen.69 = (unsigned int) nlen;
  memcpy (D.11854, name, nlen.69);
  D.11854 = logbuffer->data;
  nlen.70 = (sizetype) nlen;
  D.11857 = D.11854 + nlen.70;
  logbuffer->data = D.11857;
  D.11850 = logbuffer->locked;
  D.11858 = D.11850 + -1;
  logbuffer->locked = D.11858;
  D.11859 = logbuffer->next;
  if (D.11859 != 0B) goto <D.11860>; else goto <D.11861>;
  <D.11860>:
  safe_dump (prof, logbuffer);
  <D.11861>:
  process_requests (prof);
}


class_loaded (struct MonoProfiler * prof, struct MonoClass * klass, int result)
{
  int runtime_inited.71;
  struct MonoType * D.11871;
  unsigned int D.11873;
  unsigned int D.11874;
  int D.11875;
  int D.11876;
  int D.11879;
  unsigned char * D.11880;
  unsigned int nlen.72;
  sizetype nlen.73;
  unsigned char * D.11883;
  int D.11887;
  struct LogBuffer * D.11888;
  uint64_t now;
  char * name;
  int nlen;
  struct MonoImage * image;
  struct LogBuffer * logbuffer;

  if (result != 0) goto <D.11866>; else goto <D.11867>;
  <D.11866>:
  return;
  <D.11867>:
  runtime_inited.71 = runtime_inited;
  if (runtime_inited.71 != 0) goto <D.11869>; else goto <D.11870>;
  <D.11869>:
  D.11871 = mono_class_get_type (klass);
  name = mono_type_get_name (D.11871);
  goto <D.11872>;
  <D.11870>:
  name = type_name (klass);
  <D.11872>:
  D.11873 = strlen (name);
  D.11874 = D.11873 + 1;
  nlen = (int) D.11874;
  image = mono_class_get_image (klass);
  D.11875 = nlen + 24;
  logbuffer = ensure_logbuf (D.11875);
  now = current_time ();
  D.11876 = logbuffer->locked;
  if (D.11876 != 0) goto <D.11877>; else goto <D.11878>;
  <D.11877>:
  write (2, "class", 5);
  write (2, "\n", 1);
  return;
  <D.11878>:
  D.11876 = logbuffer->locked;
  D.11879 = D.11876 + 1;
  logbuffer->locked = D.11879;
  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.11880 = logbuffer->data;
  nlen.72 = (unsigned int) nlen;
  memcpy (D.11880, name, nlen.72);
  D.11880 = logbuffer->data;
  nlen.73 = (sizetype) nlen;
  D.11883 = D.11880 + nlen.73;
  logbuffer->data = D.11883;
  runtime_inited.71 = runtime_inited;
  if (runtime_inited.71 != 0) goto <D.11884>; else goto <D.11885>;
  <D.11884>:
  mono_free (name);
  goto <D.11886>;
  <D.11885>:
  free (name);
  <D.11886>:
  D.11876 = logbuffer->locked;
  D.11887 = D.11876 + -1;
  logbuffer->locked = D.11887;
  D.11888 = logbuffer->next;
  if (D.11888 != 0B) goto <D.11889>; else goto <D.11890>;
  <D.11889>:
  safe_dump (prof, logbuffer);
  <D.11890>:
  process_requests (prof);
}


type_name (struct MonoClass * klass)
{
  unsigned int D.11898;
  unsigned int D.11899;
  char * D.11900;
  char buf[1024];
  char * p;

  try
    {
      push_nesting (&buf, klass);
      D.11898 = strlen (&buf);
      D.11899 = D.11898 + 1;
      p = malloc (D.11899);
      strcpy (p, &buf);
      D.11900 = p;
      return D.11900;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


push_nesting (char * p, struct MonoClass * klass)
{
  char * p.74;
  char D.11907;
  unsigned int D.11910;
  char * p.75;
  unsigned int D.11912;
  char * D.11913;
  struct MonoClass * nesting;
  const char * name;
  const char * nspace;

  nesting = mono_class_get_nesting_type (klass);
  if (nesting != 0B) goto <D.11904>; else goto <D.11905>;
  <D.11904>:
  p = push_nesting (p, nesting);
  p.74 = p;
  p = p.74 + 1;
  *p.74 = 47;
  *p = 0;
  <D.11905>:
  name = mono_class_get_name (klass);
  nspace = mono_class_get_namespace (klass);
  D.11907 = *nspace;
  if (D.11907 != 0) goto <D.11908>; else goto <D.11909>;
  <D.11908>:
  strcpy (p, nspace);
  D.11910 = strlen (nspace);
  p = p + D.11910;
  p.75 = p;
  p = p.75 + 1;
  *p.75 = 46;
  *p = 0;
  <D.11909>:
  strcpy (p, name);
  D.11912 = strlen (name);
  p = p + D.11912;
  D.11913 = p;
  return D.11913;
}


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

  D.11920 = __builtin_object_size (__dest, 1);
  D.11919 = __builtin___strcpy_chk (__dest, __src, D.11920);
  return D.11919;
}


gc_roots (struct MonoProfiler * prof, int num, void * * objects, int * root_types, uintptr_t * extra_info)
{
  int D.11922;
  int D.11923;
  int D.11924;
  int D.11927;
  int D.11928;
  int D.11929;
  unsigned int i.76;
  unsigned int D.11931;
  void * * D.11932;
  void * D.11933;
  int * D.11934;
  int D.11935;
  uintptr_t * D.11936;
  unsigned int D.11937;
  int D.11938;
  int D.11939;
  int i;
  struct LogBuffer * logbuffer;

  D.11922 = num * 18;
  D.11923 = D.11922 + 5;
  logbuffer = ensure_logbuf (D.11923);
  D.11924 = logbuffer->locked;
  if (D.11924 != 0) goto <D.11925>; else goto <D.11926>;
  <D.11925>:
  write (2, "gcroots", 7);
  write (2, "\n", 1);
  return;
  <D.11926>:
  D.11924 = logbuffer->locked;
  D.11927 = D.11924 + 1;
  logbuffer->locked = D.11927;
  emit_byte (logbuffer, 54);
  emit_value (logbuffer, num);
  D.11928 = mono_gc_max_generation ();
  D.11929 = mono_gc_collection_count (D.11928);
  emit_value (logbuffer, D.11929);
  i = 0;
  goto <D.10695>;
  <D.10694>:
  i.76 = (unsigned int) i;
  D.11931 = i.76 * 4;
  D.11932 = objects + D.11931;
  D.11933 = *D.11932;
  emit_obj (logbuffer, D.11933);
  i.76 = (unsigned int) i;
  D.11931 = i.76 * 4;
  D.11934 = root_types + D.11931;
  D.11935 = *D.11934;
  emit_value (logbuffer, D.11935);
  i.76 = (unsigned int) i;
  D.11931 = i.76 * 4;
  D.11936 = extra_info + D.11931;
  D.11937 = *D.11936;
  D.11938 = (int) D.11937;
  emit_value (logbuffer, D.11938);
  i = i + 1;
  <D.10695>:
  if (i < num) goto <D.10694>; else goto <D.10696>;
  <D.10696>:
  D.11924 = logbuffer->locked;
  D.11939 = D.11924 + -1;
  logbuffer->locked = D.11939;
}


gc_handle (struct MonoProfiler * prof, int op, int type, uintptr_t handle, struct MonoObject * obj)
{
  int D.11944;
  int D.11947;
  int handle.77;
  int D.11957;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (16);
  now = current_time ();
  D.11944 = logbuffer->locked;
  if (D.11944 != 0) goto <D.11945>; else goto <D.11946>;
  <D.11945>:
  write (2, "gchandle", 8);
  write (2, "\n", 1);
  return;
  <D.11946>:
  D.11944 = logbuffer->locked;
  D.11947 = D.11944 + 1;
  logbuffer->locked = D.11947;
  if (op == 0) goto <D.11948>; else goto <D.11949>;
  <D.11948>:
  emit_byte (logbuffer, 65);
  goto <D.11950>;
  <D.11949>:
  if (op == 1) goto <D.11951>; else goto <D.11952>;
  <D.11951>:
  emit_byte (logbuffer, 81);
  goto <D.11953>;
  <D.11952>:
  return;
  <D.11953>:
  <D.11950>:
  emit_time (logbuffer, now);
  emit_value (logbuffer, type);
  handle.77 = (int) handle;
  emit_value (logbuffer, handle.77);
  if (op == 0) goto <D.11955>; else goto <D.11956>;
  <D.11955>:
  emit_obj (logbuffer, obj);
  <D.11956>:
  D.11944 = logbuffer->locked;
  D.11957 = D.11944 + -1;
  logbuffer->locked = D.11957;
  process_requests (prof);
}


gc_moves (struct MonoProfiler * prof, void * * objects, int num)
{
  int D.11961;
  int D.11962;
  int D.11963;
  int D.11966;
  unsigned int i.78;
  unsigned int D.11968;
  void * * D.11969;
  void * D.11970;
  int D.11971;
  int i;
  uint64_t now;
  struct LogBuffer * logbuffer;

  D.11961 = num * 8;
  D.11962 = D.11961 + 10;
  logbuffer = ensure_logbuf (D.11962);
  now = current_time ();
  D.11963 = logbuffer->locked;
  if (D.11963 != 0) goto <D.11964>; else goto <D.11965>;
  <D.11964>:
  write (2, "gcmove", 6);
  write (2, "\n", 1);
  return;
  <D.11965>:
  D.11963 = logbuffer->locked;
  D.11966 = D.11963 + 1;
  logbuffer->locked = D.11966;
  emit_byte (logbuffer, 49);
  emit_time (logbuffer, now);
  emit_value (logbuffer, num);
  i = 0;
  goto <D.10683>;
  <D.10682>:
  i.78 = (unsigned int) i;
  D.11968 = i.78 * 4;
  D.11969 = objects + D.11968;
  D.11970 = *D.11969;
  emit_obj (logbuffer, D.11970);
  i = i + 1;
  <D.10683>:
  if (i < num) goto <D.10682>; else goto <D.10684>;
  <D.10684>:
  D.11963 = logbuffer->locked;
  D.11971 = D.11963 + -1;
  logbuffer->locked = D.11971;
}


gc_alloc (struct MonoProfiler * prof, struct MonoObject * obj, struct MonoClass * klass)
{
  int iftmp.79;
  int nocalls.80;
  int runtime_inited.81;
  int notraces.82;
  int D.11986;
  int D.11989;
  int len.83;
  int D.11993;
  struct LogBuffer * D.11994;
  uint64_t now;
  uintptr_t len;
  int do_bt;
  struct FrameData data;
  struct LogBuffer * logbuffer;

  try
    {
      nocalls.80 = nocalls;
      if (nocalls.80 != 0) goto <D.11979>; else goto <D.11976>;
      <D.11979>:
      runtime_inited.81 = runtime_inited;
      if (runtime_inited.81 != 0) goto <D.11981>; else goto <D.11976>;
      <D.11981>:
      notraces.82 = notraces;
      if (notraces.82 == 0) goto <D.11983>; else goto <D.11976>;
      <D.11983>:
      iftmp.79 = 16;
      goto <D.11977>;
      <D.11976>:
      iftmp.79 = 0;
      <D.11977>:
      do_bt = iftmp.79;
      len = mono_object_get_size (obj);
      len = len + 7;
      len = len & 4294967288;
      if (do_bt != 0) goto <D.11984>; else goto <D.11985>;
      <D.11984>:
      collect_bt (&data);
      <D.11985>:
      logbuffer = ensure_logbuf (160);
      now = current_time ();
      D.11986 = logbuffer->locked;
      if (D.11986 != 0) goto <D.11987>; else goto <D.11988>;
      <D.11987>:
      write (2, "gcalloc", 7);
      write (2, "\n", 1);
      return;
      <D.11988>:
      D.11986 = logbuffer->locked;
      D.11989 = D.11986 + 1;
      logbuffer->locked = D.11989;
      emit_byte (logbuffer, do_bt);
      emit_time (logbuffer, now);
      emit_ptr (logbuffer, klass);
      emit_obj (logbuffer, obj);
      len.83 = (int) len;
      emit_value (logbuffer, len.83);
      if (do_bt != 0) goto <D.11991>; else goto <D.11992>;
      <D.11991>:
      emit_bt (logbuffer, &data);
      <D.11992>:
      D.11986 = logbuffer->locked;
      D.11993 = D.11986 + -1;
      logbuffer->locked = D.11993;
      D.11994 = logbuffer->next;
      if (D.11994 != 0B) goto <D.11995>; else goto <D.11996>;
      <D.11995>:
      safe_dump (prof, logbuffer);
      <D.11996>:
      process_requests (prof);
    }
  finally
    {
      data = {CLOBBER};
    }
}


gc_resize (struct MonoProfiler * profiler, int64_t new_size)
{
  int D.12004;
  int D.12007;
  int D.12008;
  int D.12009;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (10);
  now = current_time ();
  D.12004 = logbuffer->locked;
  if (D.12004 != 0) goto <D.12005>; else goto <D.12006>;
  <D.12005>:
  write (2, "gcresize", 8);
  write (2, "\n", 1);
  return;
  <D.12006>:
  D.12004 = logbuffer->locked;
  D.12007 = D.12004 + 1;
  logbuffer->locked = D.12007;
  emit_byte (logbuffer, 33);
  emit_time (logbuffer, now);
  D.12008 = (int) new_size;
  emit_value (logbuffer, D.12008);
  D.12004 = logbuffer->locked;
  D.12009 = D.12004 + -1;
  logbuffer->locked = D.12009;
}


gc_event (struct MonoProfiler * profiler, MonoGCEvent ev, int generation)
{
  int D.12013;
  int D.12016;
  int ev.84;
  int D.12020;
  unsigned int gc_count.85;
  unsigned int gc_count.86;
  int D.12027;
  uint64_t now;
  struct LogBuffer * logbuffer;

  logbuffer = ensure_logbuf (10);
  now = current_time ();
  D.12013 = logbuffer->locked;
  if (D.12013 != 0) goto <D.12014>; else goto <D.12015>;
  <D.12014>:
  write (2, "gcevent", 7);
  write (2, "\n", 1);
  return;
  <D.12015>:
  D.12013 = logbuffer->locked;
  D.12016 = D.12013 + 1;
  logbuffer->locked = D.12016;
  emit_byte (logbuffer, 17);
  emit_time (logbuffer, now);
  ev.84 = (int) ev;
  emit_value (logbuffer, ev.84);
  emit_value (logbuffer, generation);
  if (ev == 0) goto <D.12018>; else goto <D.12019>;
  <D.12018>:
  profiler->last_gc_gen_started = generation;
  D.12020 = mono_gc_max_generation ();
  if (D.12020 == generation) goto <D.12021>; else goto <D.12022>;
  <D.12021>:
  gc_count.85 = gc_count;
  gc_count.86 = gc_count.85 + 1;
  gc_count = gc_count.86;
  <D.12022>:
  <D.12019>:
  if (ev == 8) goto <D.12025>; else goto <D.12026>;
  <D.12025>:
  heap_walk (profiler);
  <D.12026>:
  D.12013 = logbuffer->locked;
  D.12027 = D.12013 + -1;
  logbuffer->locked = D.12027;
  if (ev == 9) goto <D.12028>; else goto <D.12029>;
  <D.12028>:
  safe_dump (profiler, logbuffer);
  <D.12029>:
}


heap_walk (struct MonoProfiler * profiler)
{
  int do_heap_shot.87;
  unsigned int hs_mode_ms.88;
  long long unsigned int last_hs_time.89;
  long long unsigned int D.12042;
  long long unsigned int D.12043;
  long long unsigned int D.12044;
  unsigned int hs_mode_gc.90;
  unsigned int gc_count.91;
  unsigned int D.12051;
  unsigned int hs_mode_ondemand.92;
  int D.12061;
  int D.12062;
  int do_walk;
  uint64_t now;
  struct LogBuffer * logbuffer;

  do_walk = 0;
  do_heap_shot.87 = do_heap_shot;
  if (do_heap_shot.87 == 0) goto <D.12035>; else goto <D.12036>;
  <D.12035>:
  return;
  <D.12036>:
  logbuffer = ensure_logbuf (10);
  now = current_time ();
  hs_mode_ms.88 = hs_mode_ms;
  if (hs_mode_ms.88 != 0) goto <D.12040>; else goto <D.12037>;
  <D.12040>:
  last_hs_time.89 = last_hs_time;
  D.12042 = now - last_hs_time.89;
  D.12043 = D.12042 / 1000000;
  hs_mode_ms.88 = hs_mode_ms;
  D.12044 = (long long unsigned int) hs_mode_ms.88;
  if (D.12043 >= D.12044) goto <D.12045>; else goto <D.12037>;
  <D.12045>:
  do_walk = 1;
  goto <D.12038>;
  <D.12037>:
  hs_mode_gc.90 = hs_mode_gc;
  if (hs_mode_gc.90 != 0) goto <D.12049>; else goto <D.12046>;
  <D.12049>:
  gc_count.91 = gc_count;
  hs_mode_gc.90 = hs_mode_gc;
  D.12051 = gc_count.91 % hs_mode_gc.90;
  if (D.12051 == 0) goto <D.12052>; else goto <D.12046>;
  <D.12052>:
  do_walk = 1;
  goto <D.12047>;
  <D.12046>:
  hs_mode_ondemand.92 = hs_mode_ondemand;
  if (hs_mode_ondemand.92 != 0) goto <D.12054>; else goto <D.12055>;
  <D.12054>:
  do_walk = heapshot_requested;
  goto <D.12056>;
  <D.12055>:
  hs_mode_ms.88 = hs_mode_ms;
  if (hs_mode_ms.88 == 0) goto <D.12057>; else goto <D.12058>;
  <D.12057>:
  hs_mode_gc.90 = hs_mode_gc;
  if (hs_mode_gc.90 == 0) goto <D.12059>; else goto <D.12060>;
  <D.12059>:
  D.12061 = profiler->last_gc_gen_started;
  D.12062 = mono_gc_max_generation ();
  if (D.12061 == D.12062) goto <D.12063>; else goto <D.12064>;
  <D.12063>:
  do_walk = 1;
  <D.12064>:
  <D.12060>:
  <D.12058>:
  <D.12056>:
  <D.12047>:
  <D.12038>:
  if (do_walk == 0) goto <D.12065>; else goto <D.12066>;
  <D.12065>:
  return;
  <D.12066>:
  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.12073;
  unsigned int D.12074;
  int D.12075;
  int size.93;
  int num.94;
  unsigned int i.95;
  unsigned int D.12079;
  uintptr_t * D.12080;
  unsigned int D.12081;
  unsigned int D.12082;
  int D.12083;
  struct MonoObject * * D.12084;
  struct MonoObject * D.12085;
  unsigned int i.96;
  int D.12087;
  int i;
  uintptr_t last_offset;
  struct LogBuffer * logbuffer;

  last_offset = 0;
  D.12073 = num * 8;
  D.12074 = D.12073 + 20;
  D.12075 = (int) D.12074;
  logbuffer = ensure_logbuf (D.12075);
  emit_byte (logbuffer, 38);
  emit_obj (logbuffer, obj);
  emit_ptr (logbuffer, klass);
  size = size + 7;
  size = size & 4294967288;
  size.93 = (int) size;
  emit_value (logbuffer, size.93);
  num.94 = (int) num;
  emit_value (logbuffer, num.94);
  i = 0;
  goto <D.10615>;
  <D.10614>:
  i.95 = (unsigned int) i;
  D.12079 = i.95 * 4;
  D.12080 = offsets + D.12079;
  D.12081 = *D.12080;
  D.12082 = D.12081 - last_offset;
  D.12083 = (int) D.12082;
  emit_value (logbuffer, D.12083);
  i.95 = (unsigned int) i;
  D.12079 = i.95 * 4;
  D.12080 = offsets + D.12079;
  last_offset = *D.12080;
  i.95 = (unsigned int) i;
  D.12079 = i.95 * 4;
  D.12084 = refs + D.12079;
  D.12085 = *D.12084;
  emit_obj (logbuffer, D.12085);
  i = i + 1;
  <D.10615>:
  i.96 = (unsigned int) i;
  if (i.96 < num) goto <D.10614>; else goto <D.10616>;
  <D.10616>:
  D.12087 = 0;
  return D.12087;
}


log_shutdown (struct MonoProfiler * prof)
{
  int D.12090;
  int D.12093;
  long unsigned int D.12094;
  struct StatBuffer * D.12095;
  struct LogBuffer * tlsbuffer.97;
  int D.12099;
  struct FILE * D.12102;

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

    try
      {
        c = 1;
        D.12093 = prof->pipes[1];
        write (D.12093, &c, 1);
        D.12094 = prof->helper_thread;
        pthread_join (D.12094, &res);
      }
    finally
      {
        c = {CLOBBER};
        res = {CLOBBER};
      }
  }
  <D.12092>:
  D.12095 = prof->stat_buffers;
  dump_sample_hits (prof, D.12095, 1);
  take_lock ();
  tlsbuffer.97 = tlsbuffer;
  if (tlsbuffer.97 != 0B) goto <D.12097>; else goto <D.12098>;
  <D.12097>:
  tlsbuffer.97 = tlsbuffer;
  dump_buffer (prof, tlsbuffer.97);
  <D.12098>:
  tlsbuffer = 0B;
  release_lock ();
  D.12099 = prof->pipe_output;
  if (D.12099 != 0) goto <D.12100>; else goto <D.12101>;
  <D.12100>:
  D.12102 = prof->file;
  pclose (D.12102);
  goto <D.12103>;
  <D.12101>:
  D.12102 = prof->file;
  fclose (D.12102);
  <D.12103>:
  free (prof);
}


dump_sample_hits (struct MonoProfiler * prof, struct StatBuffer * sbuf, int recurse)
{
  struct StatBuffer * D.12110;
  unsigned int D.12113;
  int D.12114;
  unsigned int D.12115;
  int D.12116;
  unsigned int D.12117;
  sizetype count.98;
  sizetype D.12119;
  sizetype D.12120;
  uintptr_t * D.12121;
  uintptr_t * D.12122;
  int D.12124;
  int D.12125;
  long long unsigned int D.12126;
  uintptr_t * D.12127;
  unsigned int D.12128;
  long long unsigned int D.12129;
  long long unsigned int D.12130;
  long long unsigned int D.12131;
  sizetype i.99;
  sizetype D.12133;
  sizetype D.12134;
  uintptr_t * D.12135;
  unsigned int D.12136;
  void * D.12137;
  uintptr_t * sample;
  struct LogBuffer * logbuffer;

  if (sbuf == 0B) goto <D.12106>; else goto <D.12107>;
  <D.12106>:
  return;
  <D.12107>:
  if (recurse != 0) goto <D.12108>; else goto <D.12109>;
  <D.12108>:
  D.12110 = sbuf->next;
  if (D.12110 != 0B) goto <D.12111>; else goto <D.12112>;
  <D.12111>:
  D.12110 = sbuf->next;
  dump_sample_hits (prof, D.12110, 1);
  D.12110 = sbuf->next;
  D.12110 = sbuf->next;
  D.12113 = D.12110->size;
  D.12114 = (int) D.12113;
  free_buffer (D.12110, D.12114);
  sbuf->next = 0B;
  <D.12112>:
  <D.12109>:
  sample = &sbuf->buf;
  goto <D.10957>;
  <D.10956>:
  {
    int i;
    int count;
    int type;

    D.12115 = *sample;
    D.12116 = (int) D.12115;
    count = D.12116 & 65535;
    D.12115 = *sample;
    D.12117 = D.12115 >> 16;
    type = (int) D.12117;
    count.98 = (sizetype) count;
    D.12119 = count.98 + 3;
    D.12120 = D.12119 * 4;
    D.12121 = sample + D.12120;
    D.12122 = sbuf->data;
    if (D.12121 > D.12122) goto <D.10952>; else goto <D.12123>;
    <D.12123>:
    D.12124 = count * 8;
    D.12125 = D.12124 + 20;
    logbuffer = ensure_logbuf (D.12125);
    emit_byte (logbuffer, 7);
    emit_value (logbuffer, type);
    D.12126 = prof->startup_time;
    D.12127 = sample + 8;
    D.12128 = *D.12127;
    D.12129 = (long long unsigned int) D.12128;
    D.12130 = D.12129 * 10000;
    D.12131 = D.12126 + D.12130;
    emit_uvalue (logbuffer, D.12131);
    emit_value (logbuffer, count);
    i = 0;
    goto <D.10954>;
    <D.10953>:
    i.99 = (sizetype) i;
    D.12133 = i.99 + 3;
    D.12134 = D.12133 * 4;
    D.12135 = sample + D.12134;
    D.12136 = *D.12135;
    D.12137 = (void *) D.12136;
    emit_ptr (logbuffer, D.12137);
    i.99 = (sizetype) i;
    D.12133 = i.99 + 3;
    D.12134 = D.12133 * 4;
    D.12135 = sample + D.12134;
    D.12136 = *D.12135;
    add_code_pointer (D.12136);
    i = i + 1;
    <D.10954>:
    if (i < count) goto <D.10953>; else goto <D.10955>;
    <D.10955>:
    count.98 = (sizetype) count;
    D.12119 = count.98 + 3;
    D.12120 = D.12119 * 4;
    sample = sample + D.12120;
  }
  <D.10957>:
  D.12122 = sbuf->data;
  if (D.12122 > sample) goto <D.10956>; else goto <D.10952>;
  <D.10952>:
  dump_unmanaged_coderefs (prof);
}


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

  D.12140 = logbuffer->data;
  D.12141 = &logbuffer->data;
  encode_uleb128 (value, D.12140, D.12141);
  D.12140 = logbuffer->data;
  D.12142 = logbuffer->data_end;
  if (D.12140 > D.12142) goto <D.12143>; else goto <D.12144>;
  <D.12143>:
  __assert_fail ("logbuffer->data <= logbuffer->data_end", "proflog.c", 481, &__PRETTY_FUNCTION__);
  <D.12144>:
}


add_code_pointer (uintptr_t ip)
{
  int num_code_pages.100;
  int D.12146;
  int size_code_pages.101;
  int size_code_pages.102;
  unsigned int size_code_pages.103;
  unsigned int D.12154;
  uintptr_t * code_pages.104;
  unsigned int D.12156;
  uintptr_t * D.12157;
  unsigned int D.12158;
  unsigned int size_code_pages.105;
  unsigned int D.12164;
  unsigned int D.12165;
  unsigned int num_code_pages.106;
  unsigned int D.12167;
  int num_code_pages.107;
  uintptr_t i;

  num_code_pages.100 = num_code_pages;
  D.12146 = num_code_pages.100 * 2;
  size_code_pages.101 = size_code_pages;
  if (D.12146 >= size_code_pages.101) goto <D.12148>; else goto <D.12149>;
  <D.12148>:
  {
    uintptr_t * n;
    uintptr_t old_size;

    size_code_pages.101 = size_code_pages;
    old_size = (uintptr_t) size_code_pages.101;
    size_code_pages.101 = size_code_pages;
    size_code_pages.102 = size_code_pages.101 * 2;
    size_code_pages = size_code_pages.102;
    size_code_pages.101 = size_code_pages;
    if (size_code_pages.101 == 0) goto <D.12151>; else goto <D.12152>;
    <D.12151>:
    size_code_pages = 16;
    <D.12152>:
    size_code_pages.101 = size_code_pages;
    size_code_pages.103 = (unsigned int) size_code_pages.101;
    D.12154 = size_code_pages.103 * 4;
    n = calloc (D.12154, 1);
    i = 0;
    goto <D.10840>;
    <D.10839>:
    code_pages.104 = code_pages;
    D.12156 = i * 4;
    D.12157 = code_pages.104 + D.12156;
    D.12158 = *D.12157;
    if (D.12158 != 0) goto <D.12159>; else goto <D.12160>;
    <D.12159>:
    size_code_pages.101 = size_code_pages;
    size_code_pages.105 = (unsigned int) size_code_pages.101;
    code_pages.104 = code_pages;
    D.12156 = i * 4;
    D.12157 = code_pages.104 + D.12156;
    D.12158 = *D.12157;
    add_code_page (n, size_code_pages.105, D.12158);
    <D.12160>:
    i = i + 1;
    <D.10840>:
    if (i < old_size) goto <D.10839>; else goto <D.10841>;
    <D.10841>:
    code_pages.104 = code_pages;
    if (code_pages.104 != 0B) goto <D.12162>; else goto <D.12163>;
    <D.12162>:
    code_pages.104 = code_pages;
    free (code_pages.104);
    <D.12163>:
    code_pages = n;
  }
  <D.12149>:
  code_pages.104 = code_pages;
  size_code_pages.101 = size_code_pages;
  size_code_pages.105 = (unsigned int) size_code_pages.101;
  D.12164 = ip & 4294966784;
  D.12165 = add_code_page (code_pages.104, size_code_pages.105, D.12164);
  num_code_pages.100 = num_code_pages;
  num_code_pages.106 = (unsigned int) num_code_pages.100;
  D.12167 = D.12165 + num_code_pages.106;
  num_code_pages.107 = (int) D.12167;
  num_code_pages = num_code_pages.107;
}


add_code_page (uintptr_t * hash, uintptr_t hsize, uintptr_t page)
{
  unsigned int D.12170;
  unsigned int D.12172;
  uintptr_t * D.12173;
  unsigned int D.12174;
  unsigned int D.12176;
  unsigned int D.12177;
  uintptr_t D.12179;
  uintptr_t i;
  uintptr_t start_pos;

  D.12170 = page >> 9;
  start_pos = D.12170 % hsize;
  i = start_pos;
  <D.10831>:
  D.12172 = i * 4;
  D.12173 = hash + D.12172;
  D.12174 = *D.12173;
  if (D.12174 != 0) goto <D.12175>; else goto <D.12171>;
  <D.12175>:
  D.12172 = i * 4;
  D.12173 = hash + D.12172;
  D.12174 = *D.12173;
  D.12176 = D.12174 ^ page;
  D.12177 = D.12176 & 4294966784;
  if (D.12177 == 0) goto <D.12178>; else goto <D.12171>;
  <D.12178>:
  D.12179 = 0;
  return D.12179;
  <D.12171>:
  D.12172 = i * 4;
  D.12173 = hash + D.12172;
  D.12174 = *D.12173;
  if (D.12174 == 0) goto <D.12180>; else goto <D.12181>;
  <D.12180>:
  D.12172 = i * 4;
  D.12173 = hash + D.12172;
  *D.12173 = page;
  D.12179 = 1;
  return D.12179;
  <D.12181>:
  i = i + 1;
  if (i == hsize) goto <D.12182>; else goto <D.12183>;
  <D.12182>:
  i = 0;
  <D.12183>:
  if (i != start_pos) goto <D.10831>; else goto <D.10832>;
  <D.10832>:
  printf ("failed code page store\n");
  D.12179 = 0;
  return D.12179;
}


dump_unmanaged_coderefs (struct MonoProfiler * prof)
{
  int D.12185;
  uintptr_t * code_pages.108;
  unsigned int i.109;
  unsigned int D.12192;
  uintptr_t * D.12193;
  unsigned int D.12194;
  unsigned int D.12196;
  unsigned int D.12197;
  int size_code_pages.110;
  int i;
  const char * last_symbol;
  uintptr_t addr;
  uintptr_t page_end;

  D.12185 = load_binaries (prof);
  if (D.12185 != 0) goto <D.12186>; else goto <D.12187>;
  <D.12186>:
  return;
  <D.12187>:
  i = 0;
  goto <D.10940>;
  <D.10939>:
  {
    const char * sym;

    code_pages.108 = code_pages;
    i.109 = (unsigned int) i;
    D.12192 = i.109 * 4;
    D.12193 = code_pages.108 + D.12192;
    D.12194 = *D.12193;
    if (D.12194 == 0) goto <D.12188>; else goto <D.12195>;
    <D.12195>:
    code_pages.108 = code_pages;
    i.109 = (unsigned int) i;
    D.12192 = i.109 * 4;
    D.12193 = code_pages.108 + D.12192;
    D.12194 = *D.12193;
    D.12196 = D.12194 & 1;
    if (D.12196 != 0) goto <D.12188>; else goto <D.12189>;
    <D.12188>:
    // predicted unlikely by continue predictor.
    goto <D.10934>;
    <D.12189>:
    last_symbol = 0B;
    code_pages.108 = code_pages;
    i.109 = (unsigned int) i;
    D.12192 = i.109 * 4;
    D.12193 = code_pages.108 + D.12192;
    D.12194 = *D.12193;
    addr = D.12194 & 4294966784;
    page_end = addr + 512;
    code_pages.108 = code_pages;
    i.109 = (unsigned int) i;
    D.12192 = i.109 * 4;
    D.12193 = code_pages.108 + D.12192;
    code_pages.108 = code_pages;
    i.109 = (unsigned int) i;
    D.12192 = i.109 * 4;
    D.12193 = code_pages.108 + D.12192;
    D.12194 = *D.12193;
    D.12197 = D.12194 | 1;
    *D.12193 = D.12197;
    goto <D.10937>;
    <D.10936>:
    sym = symbol_for (addr);
    if (sym != 0B) goto <D.12198>; else goto <D.12199>;
    <D.12198>:
    if (sym == last_symbol) goto <D.12200>; else goto <D.12201>;
    <D.12200>:
    // predicted unlikely by continue predictor.
    goto <D.10935>;
    <D.12201>:
    <D.12199>:
    last_symbol = sym;
    if (sym == 0B) goto <D.12202>; else goto <D.12203>;
    <D.12202>:
    // predicted unlikely by continue predictor.
    goto <D.10935>;
    <D.12203>:
    dump_usym (sym, addr, 0);
    <D.10935>:
    addr = addr + 16;
    <D.10937>:
    if (addr < page_end) goto <D.10936>; else goto <D.10938>;
    <D.10938>:
  }
  <D.10934>:
  i = i + 1;
  <D.10940>:
  size_code_pages.110 = size_code_pages;
  if (i < size_code_pages.110) goto <D.10939>; else goto <D.10941>;
  <D.10941>:
}


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

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


elf_dl_callback (struct dl_phdr_info * info, size_t size, void * data)
{
  unsigned int D.12210;
  void * D.12211;
  int D.12214;
  char D.12217;
  void * D.12222;
  char * D.12223;
  struct BinaryObject * D.12224;
  const struct Elf32_Phdr * D.12227;
  unsigned int i.111;
  unsigned int D.12229;
  const struct Elf32_Phdr * D.12230;
  unsigned int D.12231;
  unsigned int D.12234;
  unsigned int D.12235;
  unsigned int D.12236;
  unsigned int D.12237;
  unsigned int D.12240;
  long long unsigned int D.12241;
  unsigned int D.12242;
  short unsigned int D.12245;
  int D.12246;
  int D.12247;
  const char * D.12252;
  char D.12254;
  unsigned int D.12257;
  struct Elf32_Dyn * D.12258;
  int D.12259;
  int do_debug.112;
  unsigned int D.12267;
  Elf32_Word * D.12276;
  unsigned int D.12277;
  struct MonoProfiler * prof;
  char buf[256];
  const char * filename;
  struct BinaryObject * obj;
  char * a;
  int i;
  int num_sym;
  struct Elf32_Dyn * dyn;
  struct Elf32_Sym * symtab;
  Elf32_Word * hash_table;
  struct Elf32_Ehdr * header;
  const char * strtab;

  try
    {
      prof = data;
      D.12210 = info->dlpi_addr;
      a = (char *) D.12210;
      dyn = 0B;
      symtab = 0B;
      hash_table = 0B;
      header = 0B;
      strtab = 0B;
      obj = prof->binary_objects;
      goto <D.10909>;
      <D.10908>:
      D.12211 = obj->addr;
      if (D.12211 == a) goto <D.12212>; else goto <D.12213>;
      <D.12212>:
      D.12214 = 0;
      return D.12214;
      <D.12213>:
      obj = obj->next;
      <D.10909>:
      if (obj != 0B) goto <D.10908>; else goto <D.10910>;
      <D.10910>:
      filename = info->dlpi_name;
      D.12210 = info->dlpi_addr;
      if (D.12210 == 0) goto <D.12215>; else goto <D.12216>;
      <D.12215>:
      D.12217 = *filename;
      if (D.12217 == 0) goto <D.12218>; else goto <D.12219>;
      <D.12218>:
      {
        int l;

        l = readlink ("/proc/self/exe", &buf, 255);
        if (l > 0) goto <D.12220>; else goto <D.12221>;
        <D.12220>:
        buf[l] = 0;
        filename = &buf;
        <D.12221>:
      }
      <D.12219>:
      <D.12216>:
      obj = calloc (12, 1);
      D.12210 = info->dlpi_addr;
      D.12222 = (void *) D.12210;
      obj->addr = D.12222;
      D.12223 = pstrdup (filename);
      obj->name = D.12223;
      D.12224 = prof->binary_objects;
      obj->next = D.12224;
      prof->binary_objects = obj;
      a = 0B;
      i = 0;
      goto <D.10913>;
      <D.10912>:
      D.12227 = info->dlpi_phdr;
      i.111 = (unsigned int) i;
      D.12229 = i.111 * 32;
      D.12230 = D.12227 + D.12229;
      D.12231 = D.12230->p_type;
      if (D.12231 == 1) goto <D.12232>; else goto <D.12225>;
      <D.12232>:
      if (header == 0B) goto <D.12233>; else goto <D.12225>;
      <D.12233>:
      D.12210 = info->dlpi_addr;
      D.12227 = info->dlpi_phdr;
      i.111 = (unsigned int) i;
      D.12229 = i.111 * 32;
      D.12230 = D.12227 + D.12229;
      D.12234 = D.12230->p_vaddr;
      D.12235 = D.12210 + D.12234;
      header = (struct Elf32_Ehdr *) D.12235;
      D.12236 = BIT_FIELD_REF <*header, 32, 0>;
      D.12237 = D.12236;
      if (D.12237 != 1179403647) goto <D.12238>; else goto <D.12239>;
      <D.12238>:
      header = 0B;
      <D.12239>:
      D.12210 = info->dlpi_addr;
      D.12227 = info->dlpi_phdr;
      i.111 = (unsigned int) i;
      D.12229 = i.111 * 32;
      D.12230 = D.12227 + D.12229;
      D.12234 = D.12230->p_vaddr;
      D.12235 = D.12210 + D.12234;
      D.12227 = info->dlpi_phdr;
      i.111 = (unsigned int) i;
      D.12229 = i.111 * 32;
      D.12230 = D.12227 + D.12229;
      D.12240 = D.12230->p_offset;
      D.12241 = (long long unsigned int) D.12240;
      D.12227 = info->dlpi_phdr;
      i.111 = (unsigned int) i;
      D.12229 = i.111 * 32;
      D.12230 = D.12227 + D.12229;
      D.12242 = D.12230->p_memsz;
      dump_ubin (filename, D.12235, D.12241, D.12242);
      goto <D.12226>;
      <D.12225>:
      D.12227 = info->dlpi_phdr;
      i.111 = (unsigned int) i;
      D.12229 = i.111 * 32;
      D.12230 = D.12227 + D.12229;
      D.12231 = D.12230->p_type;
      if (D.12231 == 2) goto <D.12243>; else goto <D.12244>;
      <D.12243>:
      D.12210 = info->dlpi_addr;
      D.12227 = info->dlpi_phdr;
      i.111 = (unsigned int) i;
      D.12229 = i.111 * 32;
      D.12230 = D.12227 + D.12229;
      D.12234 = D.12230->p_vaddr;
      D.12235 = D.12210 + D.12234;
      dyn = (struct Elf32_Dyn *) D.12235;
      <D.12244>:
      <D.12226>:
      i = i + 1;
      <D.10913>:
      D.12245 = info->dlpi_phnum;
      D.12246 = (int) D.12245;
      if (D.12246 > i) goto <D.10912>; else goto <D.10914>;
      <D.10914>:
      D.12210 = info->dlpi_addr;
      D.12222 = (void *) D.12210;
      D.12247 = read_elf_symbols (prof, filename, D.12222);
      if (D.12247 != 0) goto <D.12248>; else goto <D.12249>;
      <D.12248>:
      D.12214 = 0;
      return D.12214;
      <D.12249>:
      D.12252 = info->dlpi_name;
      if (D.12252 == 0B) goto <D.12250>; else goto <D.12253>;
      <D.12253>:
      D.12252 = info->dlpi_name;
      D.12254 = *D.12252;
      if (D.12254 == 0) goto <D.12250>; else goto <D.12251>;
      <D.12250>:
      D.12214 = 0;
      return D.12214;
      <D.12251>:
      if (dyn == 0B) goto <D.12255>; else goto <D.12256>;
      <D.12255>:
      D.12214 = 0;
      return D.12214;
      <D.12256>:
      i = 0;
      goto <D.10916>;
      <D.10915>:
      i.111 = (unsigned int) i;
      D.12257 = i.111 * 8;
      D.12258 = dyn + D.12257;
      D.12259 = D.12258->d_tag;
      if (D.12259 == 6) goto <D.12260>; else goto <D.12261>;
      <D.12260>:
      if (symtab != 0B) goto <D.12262>; else goto <D.12263>;
      <D.12262>:
      do_debug.112 = do_debug;
      if (do_debug.112 != 0) goto <D.12265>; else goto <D.12266>;
      <D.12265>:
      printf ("multiple symtabs: %d\n", i);
      <D.12266>:
      <D.12263>:
      i.111 = (unsigned int) i;
      D.12257 = i.111 * 8;
      D.12258 = dyn + D.12257;
      D.12267 = D.12258->d_un.d_ptr;
      symtab = a + D.12267;
      goto <D.12268>;
      <D.12261>:
      i.111 = (unsigned int) i;
      D.12257 = i.111 * 8;
      D.12258 = dyn + D.12257;
      D.12259 = D.12258->d_tag;
      if (D.12259 == 4) goto <D.12269>; else goto <D.12270>;
      <D.12269>:
      i.111 = (unsigned int) i;
      D.12257 = i.111 * 8;
      D.12258 = dyn + D.12257;
      D.12267 = D.12258->d_un.d_ptr;
      hash_table = a + D.12267;
      goto <D.12271>;
      <D.12270>:
      i.111 = (unsigned int) i;
      D.12257 = i.111 * 8;
      D.12258 = dyn + D.12257;
      D.12259 = D.12258->d_tag;
      if (D.12259 == 5) goto <D.12272>; else goto <D.12273>;
      <D.12272>:
      i.111 = (unsigned int) i;
      D.12257 = i.111 * 8;
      D.12258 = dyn + D.12257;
      D.12267 = D.12258->d_un.d_ptr;
      strtab = a + D.12267;
      <D.12273>:
      <D.12271>:
      <D.12268>:
      i = i + 1;
      <D.10916>:
      i.111 = (unsigned int) i;
      D.12257 = i.111 * 8;
      D.12258 = dyn + D.12257;
      D.12259 = D.12258->d_tag;
      if (D.12259 != 0) goto <D.10915>; else goto <D.10917>;
      <D.10917>:
      if (hash_table == 0B) goto <D.12274>; else goto <D.12275>;
      <D.12274>:
      D.12214 = 0;
      return D.12214;
      <D.12275>:
      D.12276 = hash_table + 4;
      D.12277 = *D.12276;
      num_sym = (int) D.12277;
      D.12210 = info->dlpi_addr;
      D.12222 = (void *) D.12210;
      dump_elf_symbols (symtab, num_sym, strtab, D.12222);
      D.12214 = 0;
      return D.12214;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


readlink (const char * restrict __path, char * restrict __buf, size_t __len)
{
  unsigned int D.12283;
  int D.12286;
  ssize_t D.12289;
  unsigned int D.12290;
  unsigned int D.12291;
  unsigned int D.12294;

  D.12283 = __builtin_object_size (__buf, 1);
  if (D.12283 != 4294967295) goto <D.12284>; else goto <D.12285>;
  <D.12284>:
  D.12286 = __builtin_constant_p (__len);
  if (D.12286 == 0) goto <D.12287>; else goto <D.12288>;
  <D.12287>:
  D.12290 = __builtin_object_size (__buf, 1);
  D.12289 = __readlink_chk (__path, __buf, __len, D.12290);
  return D.12289;
  <D.12288>:
  D.12291 = __builtin_object_size (__buf, 1);
  if (D.12291 < __len) goto <D.12292>; else goto <D.12293>;
  <D.12292>:
  D.12294 = __builtin_object_size (__buf, 1);
  D.12289 = __readlink_chk_warn (__path, __buf, __len, D.12294);
  return D.12289;
  <D.12293>:
  <D.12285>:
  D.12289 = __readlink_alias (__path, __buf, __len);
  return D.12289;
}


pstrdup (const char * s)
{
  unsigned int D.12296;
  unsigned int D.12297;
  unsigned int len.113;
  char * D.12299;
  int len;
  char * p;

  D.12296 = strlen (s);
  D.12297 = D.12296 + 1;
  len = (int) D.12297;
  len.113 = (unsigned int) len;
  p = malloc (len.113);
  len.113 = (unsigned int) len;
  memcpy (p, s, len.113);
  D.12299 = p;
  return D.12299;
}


dump_ubin (const char * filename, uintptr_t load_addr, uint64_t offset, uintptr_t size)
{
  unsigned int D.12301;
  unsigned int D.12302;
  int D.12303;
  long long int D.12304;
  long long unsigned int D.12305;
  unsigned char * D.12306;
  unsigned int len.114;
  sizetype len.115;
  unsigned char * D.12309;
  uint64_t now;
  struct LogBuffer * logbuffer;
  int len;

  D.12301 = strlen (filename);
  D.12302 = D.12301 + 1;
  len = (int) D.12302;
  now = current_time ();
  D.12303 = len + 20;
  logbuffer = ensure_logbuf (D.12303);
  emit_byte (logbuffer, 39);
  emit_time (logbuffer, now);
  D.12304 = (long long int) load_addr;
  emit_svalue (logbuffer, D.12304);
  emit_uvalue (logbuffer, offset);
  D.12305 = (long long unsigned int) size;
  emit_uvalue (logbuffer, D.12305);
  D.12306 = logbuffer->data;
  len.114 = (unsigned int) len;
  memcpy (D.12306, filename, len.114);
  D.12306 = logbuffer->data;
  len.115 = (sizetype) len;
  D.12309 = D.12306 + len.115;
  logbuffer->data = D.12309;
}


read_elf_symbols (struct MonoProfiler * prof, const char * filename, void * load_addr)
{
  int D.12314;
  int D.12315;
  long long int D.12318;
  unsigned int D.12319;
  unsigned int D.12322;
  unsigned int D.12323;
  unsigned int D.12326;
  short unsigned int D.12327;
  int D.12328;
  short unsigned int D.12329;
  int D.12330;
  int D.12331;
  sizetype D.12332;
  unsigned int D.12333;
  unsigned int D.12334;
  unsigned int D.12337;
  unsigned int D.12338;
  unsigned int D.12339;
  sizetype D.12340;
  sizetype D.12341;
  short unsigned int D.12342;
  int D.12343;
  unsigned int D.12347;
  unsigned int D.12348;
  unsigned int D.12349;
  unsigned int D.12350;
  unsigned int D.12351;
  int fd;
  int i;
  void * data;
  struct stat statb;
  uint64_t file_size;
  struct Elf32_Ehdr * header;
  struct Elf32_Shdr * sheader;
  struct Elf32_Shdr * shstrtabh;
  struct Elf32_Shdr * symtabh;
  struct Elf32_Shdr * strtabh;
  struct Elf32_Sym * symbols;
  const char * strtab;
  int num_symbols;

  try
    {
      symtabh = 0B;
      strtabh = 0B;
      symbols = 0B;
      fd = open (filename, 0);
      if (fd < 0) goto <D.12312>; else goto <D.12313>;
      <D.12312>:
      D.12314 = 0;
      return D.12314;
      <D.12313>:
      D.12315 = fstat (fd, &statb);
      if (D.12315 != 0) goto <D.12316>; else goto <D.12317>;
      <D.12316>:
      close (fd);
      D.12314 = 0;
      return D.12314;
      <D.12317>:
      D.12318 = statb.st_size;
      file_size = (uint64_t) D.12318;
      D.12319 = (unsigned int) file_size;
      data = mmap (0B, D.12319, 1, 2, fd, 0);
      close (fd);
      if (data == 4294967295B) goto <D.12320>; else goto <D.12321>;
      <D.12320>:
      D.12314 = 0;
      return D.12314;
      <D.12321>:
      header = data;
      D.12322 = BIT_FIELD_REF <*header, 32, 0>;
      D.12323 = D.12322;
      if (D.12323 != 1179403647) goto <D.12324>; else goto <D.12325>;
      <D.12324>:
      D.12319 = (unsigned int) file_size;
      munmap (data, D.12319);
      D.12314 = 0;
      return D.12314;
      <D.12325>:
      D.12326 = header->e_shoff;
      sheader = data + D.12326;
      D.12327 = header->e_shentsize;
      D.12328 = (int) D.12327;
      D.12329 = header->e_shstrndx;
      D.12330 = (int) D.12329;
      D.12331 = D.12328 * D.12330;
      D.12332 = (sizetype) D.12331;
      shstrtabh = sheader + D.12332;
      D.12333 = shstrtabh->sh_offset;
      strtab = data + D.12333;
      i = 0;
      goto <D.10890>;
      <D.10889>:
      D.12334 = sheader->sh_type;
      if (D.12334 == 2) goto <D.12335>; else goto <D.12336>;
      <D.12335>:
      symtabh = sheader;
      D.12326 = header->e_shoff;
      D.12337 = sheader->sh_link;
      D.12327 = header->e_shentsize;
      D.12338 = (unsigned int) D.12327;
      D.12339 = D.12337 * D.12338;
      D.12340 = D.12326 + D.12339;
      strtabh = data + D.12340;
      goto <D.10888>;
      <D.12336>:
      D.12327 = header->e_shentsize;
      D.12341 = (sizetype) D.12327;
      sheader = sheader + D.12341;
      i = i + 1;
      <D.10890>:
      D.12342 = header->e_shnum;
      D.12343 = (int) D.12342;
      if (D.12343 > i) goto <D.10889>; else goto <D.10888>;
      <D.10888>:
      if (symtabh == 0B) goto <D.12344>; else goto <D.12346>;
      <D.12346>:
      if (strtabh == 0B) goto <D.12344>; else goto <D.12345>;
      <D.12344>:
      D.12319 = (unsigned int) file_size;
      munmap (data, D.12319);
      D.12314 = 0;
      return D.12314;
      <D.12345>:
      D.12347 = strtabh->sh_offset;
      strtab = data + D.12347;
      D.12348 = symtabh->sh_size;
      D.12349 = symtabh->sh_entsize;
      D.12350 = D.12348 / D.12349;
      num_symbols = (int) D.12350;
      D.12351 = symtabh->sh_offset;
      symbols = data + D.12351;
      dump_elf_symbols (symbols, num_symbols, strtab, load_addr);
      D.12319 = (unsigned int) file_size;
      munmap (data, D.12319);
      D.12314 = 1;
      return D.12314;
    }
  finally
    {
      statb = {CLOBBER};
    }
}


open (const char * __path, int __oflag)
{
  int D.12356;
  int D.12359;
  int D.12364;
  int D.12366;
  int D.12367;
  int D.12370;
  int D.12371;

  D.12356 = __builtin_va_arg_pack_len ();
  if (D.12356 > 1) goto <D.12357>; else goto <D.12358>;
  <D.12357>:
  __open_too_many_args ();
  <D.12358>:
  D.12359 = __builtin_constant_p (__oflag);
  if (D.12359 != 0) goto <D.12360>; else goto <D.12361>;
  <D.12360>:
  D.12364 = __oflag & 256;
  if (D.12364 != 0) goto <D.12362>; else goto <D.12365>;
  <D.12365>:
  D.12366 = __oflag & 4259840;
  if (D.12366 == 4259840) goto <D.12362>; else goto <D.12363>;
  <D.12362>:
  D.12367 = __builtin_va_arg_pack_len ();
  if (D.12367 <= 0) goto <D.12368>; else goto <D.12369>;
  <D.12368>:
  __open_missing_mode ();
  D.12370 = __open_2 (__path, __oflag);
  return D.12370;
  <D.12369>:
  <D.12363>:
  D.12370 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.12370;
  <D.12361>:
  D.12371 = __builtin_va_arg_pack_len ();
  if (D.12371 <= 0) goto <D.12372>; else goto <D.12373>;
  <D.12372>:
  D.12370 = __open_2 (__path, __oflag);
  return D.12370;
  <D.12373>:
  D.12370 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.12370;
}


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

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


dump_elf_symbols (struct Elf32_Sym * symbols, int num_symbols, const char * strtab, void * load_addr)
{
  unsigned int i.116;
  unsigned int D.12382;
  struct Elf32_Sym * D.12383;
  unsigned int D.12384;
  unsigned int D.12388;
  unsigned char D.12390;
  int D.12391;
  int D.12392;
  unsigned int D.12393;
  unsigned int load_addr.117;
  unsigned int D.12395;
  int i;

  i = 0;
  goto <D.10868>;
  <D.10867>:
  {
    const char * sym;

    i.116 = (unsigned int) i;
    D.12382 = i.116 * 16;
    D.12383 = symbols + D.12382;
    D.12384 = D.12383->st_name;
    sym = strtab + D.12384;
    i.116 = (unsigned int) i;
    D.12382 = i.116 * 16;
    D.12383 = symbols + D.12382;
    D.12384 = D.12383->st_name;
    if (D.12384 == 0) goto <D.12385>; else goto <D.12387>;
    <D.12387>:
    i.116 = (unsigned int) i;
    D.12382 = i.116 * 16;
    D.12383 = symbols + D.12382;
    D.12388 = D.12383->st_size;
    if (D.12388 == 0) goto <D.12385>; else goto <D.12389>;
    <D.12389>:
    i.116 = (unsigned int) i;
    D.12382 = i.116 * 16;
    D.12383 = symbols + D.12382;
    D.12390 = D.12383->st_info;
    D.12391 = (int) D.12390;
    D.12392 = D.12391 & 15;
    if (D.12392 != 2) goto <D.12385>; else goto <D.12386>;
    <D.12385>:
    // predicted unlikely by continue predictor.
    goto <D.10866>;
    <D.12386>:
    i.116 = (unsigned int) i;
    D.12382 = i.116 * 16;
    D.12383 = symbols + D.12382;
    D.12393 = D.12383->st_value;
    load_addr.117 = (unsigned int) load_addr;
    D.12395 = D.12393 + load_addr.117;
    i.116 = (unsigned int) i;
    D.12382 = i.116 * 16;
    D.12383 = symbols + D.12382;
    D.12388 = D.12383->st_size;
    dump_usym (sym, D.12395, D.12388);
  }
  <D.10866>:
  i = i + 1;
  <D.10868>:
  if (i < num_symbols) goto <D.10867>; else goto <D.10869>;
  <D.10869>:
}


symbol_for (uintptr_t code)
{
  int D.12396;
  const char * D.12399;
  const char * D.12402;
  void * ip;
  struct Dl_info di;

  try
    {
      ip = (void *) code;
      D.12396 = dladdr (ip, &di);
      if (D.12396 != 0) goto <D.12397>; else goto <D.12398>;
      <D.12397>:
      D.12399 = di.dli_sname;
      if (D.12399 != 0B) goto <D.12400>; else goto <D.12401>;
      <D.12400>:
      D.12402 = di.dli_sname;
      return D.12402;
      <D.12401>:
      goto <D.12403>;
      <D.12398>:
      <D.12403>:
      D.12402 = 0B;
      return D.12402;
    }
  finally
    {
      di = {CLOBBER};
    }
}


dump_usym (const char * name, uintptr_t value, uintptr_t size)
{
  unsigned int D.12406;
  unsigned int D.12407;
  int D.12408;
  void * value.118;
  int size.119;
  unsigned char * D.12411;
  unsigned int len.120;
  sizetype len.121;
  unsigned char * D.12414;
  struct LogBuffer * logbuffer;
  int len;

  D.12406 = strlen (name);
  D.12407 = D.12406 + 1;
  len = (int) D.12407;
  D.12408 = len + 20;
  logbuffer = ensure_logbuf (D.12408);
  emit_byte (logbuffer, 23);
  value.118 = (void *) value;
  emit_ptr (logbuffer, value.118);
  size.119 = (int) size;
  emit_value (logbuffer, size.119);
  D.12411 = logbuffer->data;
  len.120 = (unsigned int) len;
  memcpy (D.12411, name, len.120);
  D.12411 = logbuffer->data;
  len.121 = (sizetype) len;
  D.12414 = D.12411 + len.121;
  logbuffer->data = D.12414;
}


set_sample_mode (char * val, int allow_empty)
{
  int D.11092;
  int iftmp.122;
  int D.11091;
  const char[5] * D.12423;
  unsigned char D.12424;
  int D.12425;
  unsigned char D.12426;
  int D.12427;
  const unsigned char * D.12432;
  unsigned char D.12433;
  int D.12434;
  const unsigned char * D.12435;
  unsigned char D.12436;
  int D.12437;
  const unsigned char * D.12442;
  unsigned char D.12443;
  int D.12444;
  const unsigned char * D.12445;
  unsigned char D.12446;
  int D.12447;
  const unsigned char * D.12452;
  unsigned char D.12453;
  int D.12454;
  const unsigned char * D.12455;
  unsigned char D.12456;
  int D.12457;
  const char * D.12461;
  unsigned int D.12462;
  unsigned int l.123;
  int D.12464;
  int sample_type.124;
  sizetype l.125;
  char D.12471;
  char * D.12474;
  char * end.126;
  int count.127;
  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.12416>; else goto <D.12417>;
      <D.12416>:
      if (val == 0B) goto <D.12418>; else goto <D.12419>;
      <D.12418>:
      sample_type = 1;
      sample_freq = 1000;
      return;
      <D.12419>:
      <D.12417>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = val;
          D.12423 = "mono";
          D.12424 = MEM[(const unsigned char *)D.12423];
          D.12425 = (int) D.12424;
          D.12426 = *__s2;
          D.12427 = (int) D.12426;
          __result = D.12425 - D.12427;
          {
            if (__s2_len != 0) goto <D.12428>; else goto <D.12429>;
            <D.12428>:
            if (__result == 0) goto <D.12430>; else goto <D.12431>;
            <D.12430>:
            D.12432 = &MEM[(void *)"mono" + 1B];
            D.12433 = *D.12432;
            D.12434 = (int) D.12433;
            D.12435 = __s2 + 1;
            D.12436 = *D.12435;
            D.12437 = (int) D.12436;
            __result = D.12434 - D.12437;
            if (__s2_len > 1) goto <D.12438>; else goto <D.12439>;
            <D.12438>:
            if (__result == 0) goto <D.12440>; else goto <D.12441>;
            <D.12440>:
            D.12442 = &MEM[(void *)"mono" + 2B];
            D.12443 = *D.12442;
            D.12444 = (int) D.12443;
            D.12445 = __s2 + 2;
            D.12446 = *D.12445;
            D.12447 = (int) D.12446;
            __result = D.12444 - D.12447;
            if (__s2_len > 2) goto <D.12448>; else goto <D.12449>;
            <D.12448>:
            if (__result == 0) goto <D.12450>; else goto <D.12451>;
            <D.12450>:
            D.12452 = &MEM[(void *)"mono" + 3B];
            D.12453 = *D.12452;
            D.12454 = (int) D.12453;
            D.12455 = __s2 + 3;
            D.12456 = *D.12455;
            D.12457 = (int) D.12456;
            __result = D.12454 - D.12457;
            <D.12451>:
            <D.12449>:
            <D.12441>:
            <D.12439>:
            <D.12431>:
            <D.12429>:
          }
          D.11091 = __result;
        }
        iftmp.122 = -D.11091;
        goto <D.12458>;
        <D.12422>:
        iftmp.122 = __builtin_strcmp (val, "mono");
        <D.12458>:
        D.11092 = iftmp.122;
      }
      if (D.11092 == 0) goto <D.12459>; else goto <D.12460>;
      <D.12459>:
      do_mono_sample = 1;
      sample_type = 1;
      free (val);
      return;
      <D.12460>:
      smode = &sample_modes;
      goto <D.11105>;
      <D.11104>:
      {
        int l;

        D.12461 = smode->name;
        D.12462 = strlen (D.12461);
        l = (int) D.12462;
        D.12461 = smode->name;
        l.123 = (unsigned int) l;
        D.12464 = strncmp (val, D.12461, l.123);
        if (D.12464 == 0) goto <D.12465>; else goto <D.12466>;
        <D.12465>:
        sample_type.124 = smode->sample_mode;
        sample_type = sample_type.124;
        l.125 = (sizetype) l;
        maybe_freq = val + l.125;
        goto <D.11103>;
        <D.12466>:
      }
      smode = smode + 8;
      <D.11105>:
      D.12461 = smode->name;
      if (D.12461 != 0B) goto <D.11104>; else goto <D.11103>;
      <D.11103>:
      D.12461 = smode->name;
      if (D.12461 == 0B) goto <D.12469>; else goto <D.12470>;
      <D.12469>:
      usage (1);
      <D.12470>:
      D.12471 = *maybe_freq;
      if (D.12471 == 47) goto <D.12472>; else goto <D.12473>;
      <D.12472>:
      D.12474 = maybe_freq + 1;
      count = strtoul (D.12474, &end, 10);
      D.12474 = maybe_freq + 1;
      end.126 = end;
      if (D.12474 == end.126) goto <D.12476>; else goto <D.12477>;
      <D.12476>:
      usage (1);
      <D.12477>:
      count.127 = (int) count;
      sample_freq = count.127;
      goto <D.12479>;
      <D.12473>:
      D.12471 = *maybe_freq;
      if (D.12471 != 0) goto <D.12480>; else goto <D.12481>;
      <D.12480>:
      usage (1);
      goto <D.12482>;
      <D.12481>:
      sample_freq = 1000;
      <D.12482>:
      <D.12479>:
      free (val);
    }
  finally
    {
      end = {CLOBBER};
    }
}


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

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


set_hsmode (char * val, int allow_empty)
{
  int D.11120;
  int iftmp.128;
  int D.11119;
  const char[9] * D.12497;
  unsigned char D.12498;
  int D.12499;
  unsigned char D.12500;
  int D.12501;
  const unsigned char * D.12506;
  unsigned char D.12507;
  int D.12508;
  const unsigned char * D.12509;
  unsigned char D.12510;
  int D.12511;
  const unsigned char * D.12516;
  unsigned char D.12517;
  int D.12518;
  const unsigned char * D.12519;
  unsigned char D.12520;
  int D.12521;
  const unsigned char * D.12526;
  unsigned char D.12527;
  int D.12528;
  const unsigned char * D.12529;
  unsigned char D.12530;
  int D.12531;
  char * end.129;
  int D.11129;
  int iftmp.130;
  int D.11128;
  const char[3] * D.12541;
  unsigned char D.12542;
  int D.12543;
  unsigned char D.12544;
  int D.12545;
  const unsigned char * D.12550;
  unsigned char D.12551;
  int D.12552;
  const unsigned char * D.12553;
  unsigned char D.12554;
  int D.12555;
  const unsigned char * D.12560;
  unsigned char D.12561;
  int D.12562;
  const unsigned char * D.12563;
  unsigned char D.12564;
  int D.12565;
  const unsigned char * D.12570;
  unsigned char D.12571;
  int D.12572;
  const unsigned char * D.12573;
  unsigned char D.12574;
  int D.12575;
  int D.11138;
  int iftmp.131;
  int D.11137;
  const char[3] * D.12583;
  unsigned char D.12584;
  int D.12585;
  unsigned char D.12586;
  int D.12587;
  const unsigned char * D.12592;
  unsigned char D.12593;
  int D.12594;
  const unsigned char * D.12595;
  unsigned char D.12596;
  int D.12597;
  const unsigned char * D.12602;
  unsigned char D.12603;
  int D.12604;
  const unsigned char * D.12605;
  unsigned char D.12606;
  int D.12607;
  const unsigned char * D.12612;
  unsigned char D.12613;
  int D.12614;
  const unsigned char * D.12615;
  unsigned char D.12616;
  int D.12617;
  char * end;
  unsigned int count;

  try
    {
      if (allow_empty != 0) goto <D.12490>; else goto <D.12491>;
      <D.12490>:
      if (val == 0B) goto <D.12492>; else goto <D.12493>;
      <D.12492>:
      return;
      <D.12493>:
      <D.12491>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = val;
          D.12497 = "ondemand";
          D.12498 = MEM[(const unsigned char *)D.12497];
          D.12499 = (int) D.12498;
          D.12500 = *__s2;
          D.12501 = (int) D.12500;
          __result = D.12499 - D.12501;
          {
            if (__s2_len != 0) goto <D.12502>; else goto <D.12503>;
            <D.12502>:
            if (__result == 0) goto <D.12504>; else goto <D.12505>;
            <D.12504>:
            D.12506 = &MEM[(void *)"ondemand" + 1B];
            D.12507 = *D.12506;
            D.12508 = (int) D.12507;
            D.12509 = __s2 + 1;
            D.12510 = *D.12509;
            D.12511 = (int) D.12510;
            __result = D.12508 - D.12511;
            if (__s2_len > 1) goto <D.12512>; else goto <D.12513>;
            <D.12512>:
            if (__result == 0) goto <D.12514>; else goto <D.12515>;
            <D.12514>:
            D.12516 = &MEM[(void *)"ondemand" + 2B];
            D.12517 = *D.12516;
            D.12518 = (int) D.12517;
            D.12519 = __s2 + 2;
            D.12520 = *D.12519;
            D.12521 = (int) D.12520;
            __result = D.12518 - D.12521;
            if (__s2_len > 2) goto <D.12522>; else goto <D.12523>;
            <D.12522>:
            if (__result == 0) goto <D.12524>; else goto <D.12525>;
            <D.12524>:
            D.12526 = &MEM[(void *)"ondemand" + 3B];
            D.12527 = *D.12526;
            D.12528 = (int) D.12527;
            D.12529 = __s2 + 3;
            D.12530 = *D.12529;
            D.12531 = (int) D.12530;
            __result = D.12528 - D.12531;
            <D.12525>:
            <D.12523>:
            <D.12515>:
            <D.12513>:
            <D.12505>:
            <D.12503>:
          }
          D.11119 = __result;
        }
        iftmp.128 = -D.11119;
        goto <D.12532>;
        <D.12496>:
        iftmp.128 = __builtin_strcmp (val, "ondemand");
        <D.12532>:
        D.11120 = iftmp.128;
      }
      if (D.11120 == 0) goto <D.12533>; else goto <D.12534>;
      <D.12533>:
      hs_mode_ondemand = 1;
      free (val);
      return;
      <D.12534>:
      count = strtoul (val, &end, 10);
      end.129 = end;
      if (val == end.129) goto <D.12536>; else goto <D.12537>;
      <D.12536>:
      usage (1);
      <D.12537>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = end;
          D.12541 = "ms";
          D.12542 = MEM[(const unsigned char *)D.12541];
          D.12543 = (int) D.12542;
          D.12544 = *__s2;
          D.12545 = (int) D.12544;
          __result = D.12543 - D.12545;
          {
            if (__s2_len != 0) goto <D.12546>; else goto <D.12547>;
            <D.12546>:
            if (__result == 0) goto <D.12548>; else goto <D.12549>;
            <D.12548>:
            D.12550 = &MEM[(void *)"ms" + 1B];
            D.12551 = *D.12550;
            D.12552 = (int) D.12551;
            D.12553 = __s2 + 1;
            D.12554 = *D.12553;
            D.12555 = (int) D.12554;
            __result = D.12552 - D.12555;
            if (__s2_len > 1) goto <D.12556>; else goto <D.12557>;
            <D.12556>:
            if (__result == 0) goto <D.12558>; else goto <D.12559>;
            <D.12558>:
            D.12560 = &MEM[(void *)"ms" + 2B];
            D.12561 = *D.12560;
            D.12562 = (int) D.12561;
            D.12563 = __s2 + 2;
            D.12564 = *D.12563;
            D.12565 = (int) D.12564;
            __result = D.12562 - D.12565;
            if (__s2_len > 2) goto <D.12566>; else goto <D.12567>;
            <D.12566>:
            if (__result == 0) goto <D.12568>; else goto <D.12569>;
            <D.12568>:
            D.12570 = &MEM[(void *)"ms" + 3B];
            D.12571 = *D.12570;
            D.12572 = (int) D.12571;
            D.12573 = __s2 + 3;
            D.12574 = *D.12573;
            D.12575 = (int) D.12574;
            __result = D.12572 - D.12575;
            <D.12569>:
            <D.12567>:
            <D.12559>:
            <D.12557>:
            <D.12549>:
            <D.12547>:
          }
          D.11128 = __result;
        }
        iftmp.130 = -D.11128;
        goto <D.12576>;
        <D.12540>:
        end.129 = end;
        iftmp.130 = __builtin_strcmp (end.129, "ms");
        <D.12576>:
        D.11129 = iftmp.130;
      }
      if (D.11129 == 0) goto <D.12577>; else goto <D.12578>;
      <D.12577>:
      hs_mode_ms = count;
      goto <D.12579>;
      <D.12578>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = end;
          D.12583 = "gc";
          D.12584 = MEM[(const unsigned char *)D.12583];
          D.12585 = (int) D.12584;
          D.12586 = *__s2;
          D.12587 = (int) D.12586;
          __result = D.12585 - D.12587;
          {
            if (__s2_len != 0) goto <D.12588>; else goto <D.12589>;
            <D.12588>:
            if (__result == 0) goto <D.12590>; else goto <D.12591>;
            <D.12590>:
            D.12592 = &MEM[(void *)"gc" + 1B];
            D.12593 = *D.12592;
            D.12594 = (int) D.12593;
            D.12595 = __s2 + 1;
            D.12596 = *D.12595;
            D.12597 = (int) D.12596;
            __result = D.12594 - D.12597;
            if (__s2_len > 1) goto <D.12598>; else goto <D.12599>;
            <D.12598>:
            if (__result == 0) goto <D.12600>; else goto <D.12601>;
            <D.12600>:
            D.12602 = &MEM[(void *)"gc" + 2B];
            D.12603 = *D.12602;
            D.12604 = (int) D.12603;
            D.12605 = __s2 + 2;
            D.12606 = *D.12605;
            D.12607 = (int) D.12606;
            __result = D.12604 - D.12607;
            if (__s2_len > 2) goto <D.12608>; else goto <D.12609>;
            <D.12608>:
            if (__result == 0) goto <D.12610>; else goto <D.12611>;
            <D.12610>:
            D.12612 = &MEM[(void *)"gc" + 3B];
            D.12613 = *D.12612;
            D.12614 = (int) D.12613;
            D.12615 = __s2 + 3;
            D.12616 = *D.12615;
            D.12617 = (int) D.12616;
            __result = D.12614 - D.12617;
            <D.12611>:
            <D.12609>:
            <D.12601>:
            <D.12599>:
            <D.12591>:
            <D.12589>:
          }
          D.11137 = __result;
        }
        iftmp.131 = -D.11137;
        goto <D.12618>;
        <D.12582>:
        end.129 = end;
        iftmp.131 = __builtin_strcmp (end.129, "gc");
        <D.12618>:
        D.11138 = iftmp.131;
      }
      if (D.11138 == 0) goto <D.12619>; else goto <D.12620>;
      <D.12619>:
      hs_mode_gc = count;
      goto <D.12621>;
      <D.12620>:
      usage (1);
      <D.12621>:
      <D.12579>:
      free (val);
    }
  finally
    {
      end = {CLOBBER};
    }
}


match_option (const char * p, const char * opt, char * * rval)
{
  unsigned int D.12626;
  unsigned int len.132;
  int D.12628;
  sizetype len.133;
  const char * D.12634;
  char D.12635;
  sizetype D.12638;
  const char * D.12639;
  char D.12640;
  unsigned int D.12645;
  int end.134;
  int opt.135;
  int D.12649;
  unsigned int D.12650;
  unsigned int l.136;
  sizetype l.137;
  char * D.12653;
  const char * D.12654;
  _Bool D.12658;
  unsigned int D.12659;
  sizetype D.12660;
  int len;

  D.12626 = strlen (opt);
  len = (int) D.12626;
  len.132 = (unsigned int) len;
  D.12628 = strncmp (p, opt, len.132);
  if (D.12628 == 0) goto <D.12629>; else goto <D.12630>;
  <D.12629>:
  if (rval != 0B) goto <D.12631>; else goto <D.12632>;
  <D.12631>:
  len.133 = (sizetype) len;
  D.12634 = p + len.133;
  D.12635 = *D.12634;
  if (D.12635 == 61) goto <D.12636>; else goto <D.12637>;
  <D.12636>:
  len.133 = (sizetype) len;
  D.12638 = len.133 + 1;
  D.12639 = p + D.12638;
  D.12640 = *D.12639;
  if (D.12640 != 0) goto <D.12641>; else goto <D.12642>;
  <D.12641>:
  {
    const char * opt;
    const char * end;
    char * val;
    int l;

    len.133 = (sizetype) len;
    D.12638 = len.133 + 1;
    opt = p + D.12638;
    end = __builtin_strchr (opt, 44);
    if (end == 0B) goto <D.12643>; else goto <D.12644>;
    <D.12643>:
    D.12645 = strlen (opt);
    l = (int) D.12645;
    goto <D.12646>;
    <D.12644>:
    end.134 = (int) end;
    opt.135 = (int) opt;
    l = end.134 - opt.135;
    <D.12646>:
    D.12649 = l + 1;
    D.12650 = (unsigned int) D.12649;
    val = malloc (D.12650);
    l.136 = (unsigned int) l;
    memcpy (val, opt, l.136);
    l.137 = (sizetype) l;
    D.12653 = val + l.137;
    *D.12653 = 0;
    *rval = val;
    l.137 = (sizetype) l;
    D.12654 = opt + l.137;
    return D.12654;
  }
  <D.12642>:
  <D.12637>:
  len.133 = (sizetype) len;
  D.12634 = p + len.133;
  D.12635 = *D.12634;
  if (D.12635 == 0) goto <D.12655>; else goto <D.12657>;
  <D.12657>:
  len.133 = (sizetype) len;
  D.12634 = p + len.133;
  D.12635 = *D.12634;
  if (D.12635 == 44) goto <D.12655>; else goto <D.12656>;
  <D.12655>:
  *rval = 0B;
  len.133 = (sizetype) len;
  D.12634 = p + len.133;
  D.12635 = *D.12634;
  D.12658 = D.12635 == 44;
  D.12659 = (unsigned int) D.12658;
  len.133 = (sizetype) len;
  D.12660 = D.12659 + len.133;
  D.12654 = p + D.12660;
  return D.12654;
  <D.12656>:
  usage (1);
  goto <D.12661>;
  <D.12632>:
  len.133 = (sizetype) len;
  D.12634 = p + len.133;
  D.12635 = *D.12634;
  if (D.12635 == 0) goto <D.12662>; else goto <D.12663>;
  <D.12662>:
  len.133 = (sizetype) len;
  D.12654 = p + len.133;
  return D.12654;
  <D.12663>:
  len.133 = (sizetype) len;
  D.12634 = p + len.133;
  D.12635 = *D.12634;
  if (D.12635 == 44) goto <D.12664>; else goto <D.12665>;
  <D.12664>:
  len.133 = (sizetype) len;
  D.12638 = len.133 + 1;
  D.12654 = p + D.12638;
  return D.12654;
  <D.12665>:
  <D.12661>:
  <D.12630>:
  D.12654 = p;
  return D.12654;
}


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


create_profiler (const char * filename)
{
  int command_port.138;
  char D.12672;
  int do_report.139;
  unsigned int D.12684;
  unsigned int D.12685;
  unsigned int s.140;
  char D.12687;
  const char * D.12690;
  struct FILE * D.12691;
  char * D.12695;
  struct FILE * D.12696;
  struct _IO_FILE * stderr.141;
  struct MonoProfiler * D.12703;
  struct FILE * D.12704;
  struct FILE * D.12705;
  int do_mono_sample.142;
  struct StatBuffer * D.12711;
  unsigned int hs_mode_ondemand.143;
  int D.12716;
  long long unsigned int D.12719;
  struct MonoProfiler * prof;
  char * nf;
  int force_delete;
  int need_helper_thread;

  force_delete = 0;
  need_helper_thread = 0;
  prof = calloc (1, 56);
  command_port.138 = command_port;
  prof->command_port = command_port.138;
  if (filename != 0B) goto <D.12670>; else goto <D.12671>;
  <D.12670>:
  D.12672 = *filename;
  if (D.12672 == 45) goto <D.12673>; else goto <D.12674>;
  <D.12673>:
  force_delete = 1;
  filename = filename + 1;
  <D.12674>:
  <D.12671>:
  if (filename == 0B) goto <D.12675>; else goto <D.12676>;
  <D.12675>:
  do_report.139 = do_report;
  if (do_report.139 != 0) goto <D.12678>; else goto <D.12679>;
  <D.12678>:
  filename = "|mprof-report -";
  goto <D.12680>;
  <D.12679>:
  filename = "output.mlpd";
  <D.12680>:
  nf = filename;
  goto <D.12681>;
  <D.12676>:
  nf = new_filename (filename);
  do_report.139 = do_report;
  if (do_report.139 != 0) goto <D.12682>; else goto <D.12683>;
  <D.12682>:
  {
    int s;
    char * p;

    D.12684 = strlen (nf);
    D.12685 = D.12684 + 32;
    s = (int) D.12685;
    s.140 = (unsigned int) s;
    p = malloc (s.140);
    s.140 = (unsigned int) s;
    snprintf (p, s.140, "|mprof-report \'--out=%s\' -", nf);
    free (nf);
    nf = p;
  }
  <D.12683>:
  <D.12681>:
  D.12687 = *nf;
  if (D.12687 == 124) goto <D.12688>; else goto <D.12689>;
  <D.12688>:
  D.12690 = nf + 1;
  D.12691 = popen (D.12690, "w");
  prof->file = D.12691;
  prof->pipe_output = 1;
  goto <D.12692>;
  <D.12689>:
  D.12687 = *nf;
  if (D.12687 == 35) goto <D.12693>; else goto <D.12694>;
  <D.12693>:
  {
    int fd;

    D.12695 = nf + 1;
    fd = strtol (D.12695, 0B, 10);
    D.12696 = fdopen (fd, "a");
    prof->file = D.12696;
  }
  goto <D.12697>;
  <D.12694>:
  {
    struct FILE * f;

    if (force_delete != 0) goto <D.12698>; else goto <D.12699>;
    <D.12698>:
    unlink (nf);
    <D.12699>:
    f = fopen (nf, "r");
    if (f != 0B) goto <D.12700>; else goto <D.12701>;
    <D.12700>:
    fclose (f);
    stderr.141 = stderr;
    fprintf (stderr.141, "The Mono profiler won\'t overwrite existing filename: %s.\n", nf);
    stderr.141 = stderr;
    fprintf (stderr.141, "Profiling disabled: use a different name or -FILENAME to force overwrite.\n");
    free (prof);
    D.12703 = 0B;
    return D.12703;
    <D.12701>:
    D.12704 = fopen (nf, "wb");
    prof->file = D.12704;
  }
  <D.12697>:
  <D.12692>:
  D.12705 = prof->file;
  if (D.12705 == 0B) goto <D.12706>; else goto <D.12707>;
  <D.12706>:
  stderr.141 = stderr;
  fprintf (stderr.141, "Cannot create profiler output: %s\n", nf);
  exit (1);
  <D.12707>:
  do_mono_sample.142 = do_mono_sample;
  if (do_mono_sample.142 != 0) goto <D.12709>; else goto <D.12710>;
  <D.12709>:
  D.12711 = create_stat_buffer ();
  prof->stat_buffers = D.12711;
  need_helper_thread = 1;
  <D.12710>:
  hs_mode_ondemand.143 = hs_mode_ondemand;
  if (hs_mode_ondemand.143 != 0) goto <D.12712>; else goto <D.12715>;
  <D.12715>:
  if (need_helper_thread != 0) goto <D.12712>; else goto <D.12713>;
  <D.12712>:
  D.12716 = start_helper_thread (prof);
  if (D.12716 == 0) goto <D.12717>; else goto <D.12718>;
  <D.12717>:
  prof->command_port = 0;
  <D.12718>:
  <D.12713>:
  D.12719 = current_time ();
  prof->startup_time = D.12719;
  dump_header (prof);
  D.12703 = prof;
  return D.12703;
}


new_filename (const char * filename)
{
  long int t.144;
  unsigned int D.12729;
  char D.12730;
  char * D.12744;
  int D.12745;
  int D.12746;
  int D.12747;
  int D.12748;
  int D.12749;
  int D.12750;
  int D.12751;
  int D.12752;
  unsigned int D.12753;
  unsigned int D.12754;
  unsigned int D.12755;
  int D.12756;
  unsigned int D.12757;
  int D.12758;
  unsigned int D.12759;
  unsigned int D.12760;
  unsigned int D.12761;
  char * d.145;
  sizetype s_date.146;
  sizetype s_pid.147;
  char * d.148;
  char * d.149;
  char * d.150;
  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.144 = time (0B);
      t = t.144;
      D.12729 = process_id ();
      pid = (int) D.12729;
      count_dates = 0;
      count_pids = 0;
      p = filename;
      goto <D.10981>;
      <D.10980>:
      D.12730 = *p;
      if (D.12730 != 37) goto <D.12731>; else goto <D.12732>;
      <D.12731>:
      // predicted unlikely by continue predictor.
      goto <D.10978>;
      <D.12732>:
      p = p + 1;
      D.12730 = *p;
      if (D.12730 == 116) goto <D.12733>; else goto <D.12734>;
      <D.12733>:
      count_dates = count_dates + 1;
      goto <D.12735>;
      <D.12734>:
      D.12730 = *p;
      if (D.12730 == 112) goto <D.12736>; else goto <D.12737>;
      <D.12736>:
      count_pids = count_pids + 1;
      goto <D.12738>;
      <D.12737>:
      D.12730 = *p;
      if (D.12730 == 0) goto <D.10979>; else goto <D.12739>;
      <D.12739>:
      <D.12738>:
      <D.12735>:
      <D.10978>:
      p = p + 1;
      <D.10981>:
      D.12730 = *p;
      if (D.12730 != 0) goto <D.10980>; else goto <D.10979>;
      <D.10979>:
      if (count_dates == 0) goto <D.12740>; else goto <D.12741>;
      <D.12740>:
      if (count_pids == 0) goto <D.12742>; else goto <D.12743>;
      <D.12742>:
      D.12744 = pstrdup (filename);
      return D.12744;
      <D.12743>:
      <D.12741>:
      snprintf (&pid_buf, 16, "%d", pid);
      ts = gmtime (&t);
      D.12745 = ts->tm_year;
      D.12746 = D.12745 + 1900;
      D.12747 = ts->tm_mon;
      D.12748 = D.12747 + 1;
      D.12749 = ts->tm_mday;
      D.12750 = ts->tm_hour;
      D.12751 = ts->tm_min;
      D.12752 = ts->tm_sec;
      snprintf (&time_buf, 16, "%d%02d%02d%02d%02d%02d", D.12746, D.12748, D.12749, D.12750, D.12751, D.12752);
      D.12753 = strlen (&time_buf);
      s_date = (int) D.12753;
      D.12754 = strlen (&pid_buf);
      s_pid = (int) D.12754;
      D.12755 = strlen (filename);
      D.12756 = s_pid * count_pids;
      D.12757 = (unsigned int) D.12756;
      D.12758 = s_date * count_dates;
      D.12759 = (unsigned int) D.12758;
      D.12760 = D.12757 + D.12759;
      D.12761 = D.12755 + D.12760;
      res = malloc (D.12761);
      d = res;
      p = filename;
      goto <D.10985>;
      <D.10984>:
      D.12730 = *p;
      if (D.12730 != 37) goto <D.12762>; else goto <D.12763>;
      <D.12762>:
      d.145 = d;
      d = d.145 + 1;
      D.12730 = *p;
      *d.145 = D.12730;
      // predicted unlikely by continue predictor.
      goto <D.10982>;
      <D.12763>:
      p = p + 1;
      D.12730 = *p;
      if (D.12730 == 116) goto <D.12765>; else goto <D.12766>;
      <D.12765>:
      strcpy (d, &time_buf);
      s_date.146 = (sizetype) s_date;
      d = d + s_date.146;
      // predicted unlikely by continue predictor.
      goto <D.10982>;
      <D.12766>:
      D.12730 = *p;
      if (D.12730 == 112) goto <D.12768>; else goto <D.12769>;
      <D.12768>:
      strcpy (d, &pid_buf);
      s_pid.147 = (sizetype) s_pid;
      d = d + s_pid.147;
      // predicted unlikely by continue predictor.
      goto <D.10982>;
      <D.12769>:
      D.12730 = *p;
      if (D.12730 == 37) goto <D.12771>; else goto <D.12772>;
      <D.12771>:
      d.148 = d;
      d = d.148 + 1;
      *d.148 = 37;
      // predicted unlikely by continue predictor.
      goto <D.10982>;
      <D.12772>:
      D.12730 = *p;
      if (D.12730 == 0) goto <D.10983>; else goto <D.12774>;
      <D.12774>:
      d.149 = d;
      d = d.149 + 1;
      *d.149 = 37;
      d.150 = d;
      d = d.150 + 1;
      D.12730 = *p;
      *d.150 = D.12730;
      <D.10982>:
      p = p + 1;
      <D.10985>:
      D.12730 = *p;
      if (D.12730 != 0) goto <D.10984>; else goto <D.10983>;
      <D.10983>:
      *d = 0;
      D.12744 = res;
      return D.12744;
    }
  finally
    {
      t = {CLOBBER};
      pid_buf = {CLOBBER};
      time_buf = {CLOBBER};
    }
}


start_helper_thread (struct MonoProfiler * prof)
{
  int[2] * D.12782;
  int D.12783;
  struct _IO_FILE * stderr.151;
  int D.12787;
  int D.12788;
  int D.12789;
  short unsigned int D.11035;
  int D.12792;
  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.12793;
  int D.12794;
  int * D.12797;
  int D.12798;
  char * D.12799;
  int D.12800;
  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.12803;
  int D.12804;
  short unsigned int D.11037;
  int D.12807;
  pthread_t * D.12808;
  struct sockaddr_in server_address;
  int r;
  socklen_t slen;

  try
    {
      D.12782 = &prof->pipes;
      D.12783 = pipe (D.12782);
      if (D.12783 < 0) goto <D.12784>; else goto <D.12785>;
      <D.12784>:
      stderr.151 = stderr;
      fprintf (stderr.151, "Cannot create pipe\n");
      D.12787 = 0;
      return D.12787;
      <D.12785>:
      D.12788 = socket (2, 2, 0);
      prof->server_socket = D.12788;
      D.12789 = prof->server_socket;
      if (D.12789 < 0) goto <D.12790>; else goto <D.12791>;
      <D.12790>:
      stderr.151 = stderr;
      fprintf (stderr.151, "Cannot create server socket\n");
      D.12787 = 0;
      return D.12787;
      <D.12791>:
      memset (&server_address, 0, 16);
      server_address.sin_family = 2;
      server_address.sin_addr.s_addr = 0;
      {
        short unsigned int __bsx;

        D.12792 = prof->command_port;
        __bsx = (short unsigned int) D.12792;
        D.11035 = __bsx r>> 8;
      }
      server_address.sin_port = D.11035;
      D.12789 = prof->server_socket;
      D.12793.__sockaddr__ = &server_address;
      D.12794 = bind (D.12789, D.12793, 16);
      if (D.12794 < 0) goto <D.12795>; else goto <D.12796>;
      <D.12795>:
      stderr.151 = stderr;
      D.12792 = prof->command_port;
      D.12797 = __errno_location ();
      D.12798 = *D.12797;
      D.12799 = strerror (D.12798);
      fprintf (stderr.151, "Cannot bind server socket, port: %d: %s\n", D.12792, D.12799);
      D.12789 = prof->server_socket;
      close (D.12789);
      D.12787 = 0;
      return D.12787;
      <D.12796>:
      D.12789 = prof->server_socket;
      D.12800 = listen (D.12789, 1);
      if (D.12800 < 0) goto <D.12801>; else goto <D.12802>;
      <D.12801>:
      stderr.151 = stderr;
      fprintf (stderr.151, "Cannot listen server socket\n");
      D.12789 = prof->server_socket;
      close (D.12789);
      D.12787 = 0;
      return D.12787;
      <D.12802>:
      slen = 16;
      D.12789 = prof->server_socket;
      D.12803.__sockaddr__ = &server_address;
      D.12804 = getsockname (D.12789, D.12803, &slen);
      if (D.12804 == 0) goto <D.12805>; else goto <D.12806>;
      <D.12805>:
      {
        short unsigned int __bsx;

        __bsx = server_address.sin_port;
        D.11037 = __bsx r>> 8;
      }
      D.12807 = (int) D.11037;
      prof->command_port = D.12807;
      <D.12806>:
      D.12808 = &prof->helper_thread;
      r = pthread_create (D.12808, 0B, helper_thread, prof);
      if (r != 0) goto <D.12809>; else goto <D.12810>;
      <D.12809>:
      D.12789 = prof->server_socket;
      close (D.12789);
      D.12787 = 0;
      return D.12787;
      <D.12810>:
      D.12787 = 1;
      return D.12787;
    }
  finally
    {
      server_address = {CLOBBER};
      slen = {CLOBBER};
    }
}


helper_thread (void * arg)
{
  long int D.11003;
  long int iftmp.152;
  int D.12815;
  long int iftmp.153;
  unsigned int __d.154;
  long int D.12824;
  long int D.12825;
  int D.12826;
  int D.12827;
  long int D.12828;
  long int D.12829;
  long int D.11005;
  long int iftmp.155;
  int D.12831;
  long int iftmp.156;
  unsigned int __d.157;
  long int D.12840;
  long int D.12841;
  int D.12842;
  int D.12843;
  long int D.12844;
  long int D.12845;
  long int D.11007;
  long int iftmp.158;
  int D.12851;
  long int iftmp.159;
  unsigned int __d.160;
  long int D.12860;
  long int D.12861;
  int D.12862;
  long int D.12863;
  long int D.12864;
  int D.12867;
  int * D.12870;
  int D.12871;
  char * D.12874;
  void * D.12875;
  long int D.11010;
  long int iftmp.161;
  int D.12877;
  long int iftmp.162;
  unsigned int __d.163;
  long int D.12886;
  long int D.12887;
  long int D.12888;
  char c.164;
  struct StatBuffer * D.12896;
  struct StatBuffer * D.12897;
  int do_debug.165;
  struct _IO_FILE * stderr.166;
  unsigned int D.12902;
  int D.12903;
  struct LogBuffer * D.12908;
  long int D.11015;
  long int iftmp.167;
  int D.12912;
  long int iftmp.168;
  unsigned int __d.169;
  long int D.12921;
  long int D.12922;
  long int D.12923;
  int D.11024;
  int iftmp.170;
  int D.11023;
  const char[10] * D.12933;
  unsigned char D.12934;
  int D.12935;
  unsigned char D.12936;
  int D.12937;
  const unsigned char * D.12942;
  unsigned char D.12943;
  int D.12944;
  const unsigned char * D.12945;
  unsigned char D.12946;
  int D.12947;
  const unsigned char * D.12952;
  unsigned char D.12953;
  int D.12954;
  const unsigned char * D.12955;
  unsigned char D.12956;
  int D.12957;
  const unsigned char * D.12962;
  unsigned char D.12963;
  int D.12964;
  const unsigned char * D.12965;
  unsigned char D.12966;
  int D.12967;
  int runtime_inited.171;
  struct MonoDomain * D.12976;
  long int D.11026;
  long int iftmp.172;
  int D.12980;
  long int iftmp.173;
  unsigned int __d.174;
  long int D.12989;
  long int D.12990;
  long int D.12991;
  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.12994;
  struct MonoProfiler * prof;
  int command_socket;
  int len;
  char buf[64];
  struct MonoThread * thread;

  try
    {
      prof = arg;
      thread = 0B;
      command_socket = -1;
      <D.11027>:
      {
        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.11000>;
              <D.10999>:
              __arr->fds_bits[__i] = 0;
              __i = __i + 1;
              <D.11000>:
              if (__i <= 31) goto <D.10999>; else goto <D.11001>;
              <D.11001>:
            }
            {
              long int __d;

              __d = prof->server_socket;
              D.12815 = __builtin_constant_p (__d);
              if (D.12815 != 0) goto <D.12816>; else goto <D.12817>;
              <D.12816>:
              __d.154 = (unsigned int) __d;
              if (__d.154 <= 1023) goto <D.12820>; else goto <D.12821>;
              <D.12820>:
              iftmp.153 = __d / 32;
              goto <D.12822>;
              <D.12821>:
              iftmp.153 = __fdelt_warn (__d);
              <D.12822>:
              iftmp.152 = iftmp.153;
              goto <D.12823>;
              <D.12817>:
              iftmp.152 = __fdelt_chk (__d);
              <D.12823>:
              D.11003 = iftmp.152;
            }
            D.12824 = D.11003;
            D.12825 = rfds.fds_bits[D.12824];
            D.12826 = prof->server_socket;
            D.12827 = D.12826 % 32;
            D.12828 = 1 << D.12827;
            D.12829 = D.12825 | D.12828;
            rfds.fds_bits[D.12824] = D.12829;
            max_fd = prof->server_socket;
            {
              long int __d;

              __d = prof->pipes[0];
              D.12831 = __builtin_constant_p (__d);
              if (D.12831 != 0) goto <D.12832>; else goto <D.12833>;
              <D.12832>:
              __d.157 = (unsigned int) __d;
              if (__d.157 <= 1023) goto <D.12836>; else goto <D.12837>;
              <D.12836>:
              iftmp.156 = __d / 32;
              goto <D.12838>;
              <D.12837>:
              iftmp.156 = __fdelt_warn (__d);
              <D.12838>:
              iftmp.155 = iftmp.156;
              goto <D.12839>;
              <D.12833>:
              iftmp.155 = __fdelt_chk (__d);
              <D.12839>:
              D.11005 = iftmp.155;
            }
            D.12840 = D.11005;
            D.12841 = rfds.fds_bits[D.12840];
            D.12842 = prof->pipes[0];
            D.12843 = D.12842 % 32;
            D.12844 = 1 << D.12843;
            D.12845 = D.12841 | D.12844;
            rfds.fds_bits[D.12840] = D.12845;
            D.12842 = prof->pipes[0];
            if (D.12842 > max_fd) goto <D.12846>; else goto <D.12847>;
            <D.12846>:
            max_fd = prof->pipes[0];
            <D.12847>:
            if (command_socket >= 0) goto <D.12848>; else goto <D.12849>;
            <D.12848>:
            {
              long int __d;

              __d = command_socket;
              D.12851 = __builtin_constant_p (__d);
              if (D.12851 != 0) goto <D.12852>; else goto <D.12853>;
              <D.12852>:
              __d.160 = (unsigned int) __d;
              if (__d.160 <= 1023) goto <D.12856>; else goto <D.12857>;
              <D.12856>:
              iftmp.159 = __d / 32;
              goto <D.12858>;
              <D.12857>:
              iftmp.159 = __fdelt_warn (__d);
              <D.12858>:
              iftmp.158 = iftmp.159;
              goto <D.12859>;
              <D.12853>:
              iftmp.158 = __fdelt_chk (__d);
              <D.12859>:
              D.11007 = iftmp.158;
            }
            D.12860 = D.11007;
            D.12861 = rfds.fds_bits[D.12860];
            D.12862 = command_socket % 32;
            D.12863 = 1 << D.12862;
            D.12864 = D.12861 | D.12863;
            rfds.fds_bits[D.12860] = D.12864;
            if (max_fd < command_socket) goto <D.12865>; else goto <D.12866>;
            <D.12865>:
            max_fd = command_socket;
            <D.12866>:
            <D.12849>:
            tv.tv_sec = 1;
            tv.tv_usec = 0;
            D.12867 = max_fd + 1;
            len = select (D.12867, &rfds, 0B, 0B, &tv);
            if (len < 0) goto <D.12868>; else goto <D.12869>;
            <D.12868>:
            D.12870 = __errno_location ();
            D.12871 = *D.12870;
            if (D.12871 == 4) goto <D.12872>; else goto <D.12873>;
            <D.12872>:
            // predicted unlikely by continue predictor.
            goto <D.11008>;
            <D.12873>:
            D.12870 = __errno_location ();
            D.12871 = *D.12870;
            D.12874 = strerror (D.12871);
            monoeg_g_log (0B, 16, "Error in proflog server: %s", D.12874);
            D.12875 = 0B;
            return D.12875;
            <D.12869>:
            {
              long int __d;

              __d = prof->pipes[0];
              D.12877 = __builtin_constant_p (__d);
              if (D.12877 != 0) goto <D.12878>; else goto <D.12879>;
              <D.12878>:
              __d.163 = (unsigned int) __d;
              if (__d.163 <= 1023) goto <D.12882>; else goto <D.12883>;
              <D.12882>:
              iftmp.162 = __d / 32;
              goto <D.12884>;
              <D.12883>:
              iftmp.162 = __fdelt_warn (__d);
              <D.12884>:
              iftmp.161 = iftmp.162;
              goto <D.12885>;
              <D.12879>:
              iftmp.161 = __fdelt_chk (__d);
              <D.12885>:
              D.11010 = iftmp.161;
            }
            D.12886 = rfds.fds_bits[D.11010];
            D.12842 = prof->pipes[0];
            D.12843 = D.12842 % 32;
            D.12887 = D.12886 >> D.12843;
            D.12888 = D.12887 & 1;
            if (D.12888 != 0) goto <D.12889>; else goto <D.12890>;
            <D.12889>:
            {
              char c;
              int r;

              try
                {
                  D.12842 = prof->pipes[0];
                  r = read (D.12842, &c, 1);
                  if (r == 1) goto <D.12891>; else goto <D.12892>;
                  <D.12891>:
                  c.164 = c;
                  if (c.164 == 0) goto <D.12894>; else goto <D.12895>;
                  <D.12894>:
                  {
                    struct StatBuffer * sbuf;

                    D.12896 = prof->stat_buffers;
                    D.12897 = D.12896->next;
                    sbuf = D.12897->next;
                    D.12896 = prof->stat_buffers;
                    D.12897 = D.12896->next;
                    D.12897->next = 0B;
                    do_debug.165 = do_debug;
                    if (do_debug.165 != 0) goto <D.12899>; else goto <D.12900>;
                    <D.12899>:
                    stderr.166 = stderr;
                    fprintf (stderr.166, "stat buffer dump\n");
                    <D.12900>:
                    dump_sample_hits (prof, sbuf, 1);
                    D.12902 = sbuf->size;
                    D.12903 = (int) D.12902;
                    free_buffer (sbuf, D.12903);
                    // predicted unlikely by continue predictor.
                    goto <D.11008>;
                  }
                  <D.12895>:
                  <D.12892>:
                  if (thread != 0B) goto <D.12904>; else goto <D.12905>;
                  <D.12904>:
                  mono_thread_detach (thread);
                  <D.12905>:
                  do_debug.165 = do_debug;
                  if (do_debug.165 != 0) goto <D.12906>; else goto <D.12907>;
                  <D.12906>:
                  stderr.166 = stderr;
                  fprintf (stderr.166, "helper shutdown\n");
                  <D.12907>:
                  D.12908 = ensure_logbuf (0);
                  safe_dump (prof, D.12908);
                  D.12875 = 0B;
                  return D.12875;
                }
              finally
                {
                  c = {CLOBBER};
                }
            }
            <D.12890>:
            if (command_socket >= 0) goto <D.12909>; else goto <D.12910>;
            <D.12909>:
            {
              long int __d;

              __d = command_socket;
              D.12912 = __builtin_constant_p (__d);
              if (D.12912 != 0) goto <D.12913>; else goto <D.12914>;
              <D.12913>:
              __d.169 = (unsigned int) __d;
              if (__d.169 <= 1023) goto <D.12917>; else goto <D.12918>;
              <D.12917>:
              iftmp.168 = __d / 32;
              goto <D.12919>;
              <D.12918>:
              iftmp.168 = __fdelt_warn (__d);
              <D.12919>:
              iftmp.167 = iftmp.168;
              goto <D.12920>;
              <D.12914>:
              iftmp.167 = __fdelt_chk (__d);
              <D.12920>:
              D.11015 = iftmp.167;
            }
            D.12921 = rfds.fds_bits[D.11015];
            D.12862 = command_socket % 32;
            D.12922 = D.12921 >> D.12862;
            D.12923 = D.12922 & 1;
            if (D.12923 != 0) goto <D.12924>; else goto <D.12925>;
            <D.12924>:
            len = read (command_socket, &buf, 63);
            if (len < 0) goto <D.12926>; else goto <D.12927>;
            <D.12926>:
            // predicted unlikely by continue predictor.
            goto <D.11008>;
            <D.12927>:
            if (len == 0) goto <D.12928>; else goto <D.12929>;
            <D.12928>:
            close (command_socket);
            command_socket = -1;
            // predicted unlikely by continue predictor.
            goto <D.11008>;
            <D.12929>:
            buf[len] = 0;
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = &buf;
                D.12933 = "heapshot\n";
                D.12934 = MEM[(const unsigned char *)D.12933];
                D.12935 = (int) D.12934;
                D.12936 = *__s2;
                D.12937 = (int) D.12936;
                __result = D.12935 - D.12937;
                {
                  if (__s2_len != 0) goto <D.12938>; else goto <D.12939>;
                  <D.12938>:
                  if (__result == 0) goto <D.12940>; else goto <D.12941>;
                  <D.12940>:
                  D.12942 = &MEM[(void *)"heapshot\n" + 1B];
                  D.12943 = *D.12942;
                  D.12944 = (int) D.12943;
                  D.12945 = __s2 + 1;
                  D.12946 = *D.12945;
                  D.12947 = (int) D.12946;
                  __result = D.12944 - D.12947;
                  if (__s2_len > 1) goto <D.12948>; else goto <D.12949>;
                  <D.12948>:
                  if (__result == 0) goto <D.12950>; else goto <D.12951>;
                  <D.12950>:
                  D.12952 = &MEM[(void *)"heapshot\n" + 2B];
                  D.12953 = *D.12952;
                  D.12954 = (int) D.12953;
                  D.12955 = __s2 + 2;
                  D.12956 = *D.12955;
                  D.12957 = (int) D.12956;
                  __result = D.12954 - D.12957;
                  if (__s2_len > 2) goto <D.12958>; else goto <D.12959>;
                  <D.12958>:
                  if (__result == 0) goto <D.12960>; else goto <D.12961>;
                  <D.12960>:
                  D.12962 = &MEM[(void *)"heapshot\n" + 3B];
                  D.12963 = *D.12962;
                  D.12964 = (int) D.12963;
                  D.12965 = __s2 + 3;
                  D.12966 = *D.12965;
                  D.12967 = (int) D.12966;
                  __result = D.12964 - D.12967;
                  <D.12961>:
                  <D.12959>:
                  <D.12951>:
                  <D.12949>:
                  <D.12941>:
                  <D.12939>:
                }
                D.11023 = __result;
              }
              iftmp.170 = -D.11023;
              goto <D.12968>;
              <D.12932>:
              iftmp.170 = __builtin_strcmp (&buf, "heapshot\n");
              <D.12968>:
              D.11024 = iftmp.170;
            }
            if (D.11024 == 0) goto <D.12969>; else goto <D.12970>;
            <D.12969>:
            heapshot_requested = 1;
            runtime_inited.171 = runtime_inited;
            if (runtime_inited.171 != 0) goto <D.12972>; else goto <D.12973>;
            <D.12972>:
            if (thread == 0B) goto <D.12974>; else goto <D.12975>;
            <D.12974>:
            D.12976 = mono_get_root_domain ();
            thread = mono_thread_attach (D.12976);
            <D.12975>:
            <D.12973>:
            if (thread != 0B) goto <D.12977>; else goto <D.12978>;
            <D.12977>:
            process_requests (prof);
            mono_thread_detach (thread);
            thread = 0B;
            <D.12978>:
            <D.12970>:
            // predicted unlikely by continue predictor.
            goto <D.11008>;
            <D.12925>:
            <D.12910>:
            {
              long int __d;

              __d = prof->server_socket;
              D.12980 = __builtin_constant_p (__d);
              if (D.12980 != 0) goto <D.12981>; else goto <D.12982>;
              <D.12981>:
              __d.174 = (unsigned int) __d;
              if (__d.174 <= 1023) goto <D.12985>; else goto <D.12986>;
              <D.12985>:
              iftmp.173 = __d / 32;
              goto <D.12987>;
              <D.12986>:
              iftmp.173 = __fdelt_warn (__d);
              <D.12987>:
              iftmp.172 = iftmp.173;
              goto <D.12988>;
              <D.12982>:
              iftmp.172 = __fdelt_chk (__d);
              <D.12988>:
              D.11026 = iftmp.172;
            }
            D.12989 = rfds.fds_bits[D.11026];
            D.12826 = prof->server_socket;
            D.12827 = D.12826 % 32;
            D.12990 = D.12989 >> D.12827;
            D.12991 = D.12990 & 1;
            if (D.12991 == 0) goto <D.12992>; else goto <D.12993>;
            <D.12992>:
            // predicted unlikely by continue predictor.
            goto <D.11008>;
            <D.12993>:
            D.12826 = prof->server_socket;
            D.12994.__sockaddr__ = 0B;
            command_socket = accept (D.12826, D.12994, 0B);
            if (command_socket < 0) goto <D.12995>; else goto <D.12996>;
            <D.12995>:
            // predicted unlikely by continue predictor.
            goto <D.11008>;
            <D.12996>:
          }
        finally
          {
            rfds = {CLOBBER};
            tv = {CLOBBER};
          }
      }
      <D.11008>:
      goto <D.11027>;
      D.12875 = 0B;
      return D.12875;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.13026;
  int D.13029;
  ssize_t D.13032;
  unsigned int D.13033;
  unsigned int D.13034;
  unsigned int D.13037;

  D.13026 = __builtin_object_size (__buf, 0);
  if (D.13026 != 4294967295) goto <D.13027>; else goto <D.13028>;
  <D.13027>:
  D.13029 = __builtin_constant_p (__nbytes);
  if (D.13029 == 0) goto <D.13030>; else goto <D.13031>;
  <D.13030>:
  D.13033 = __builtin_object_size (__buf, 0);
  D.13032 = __read_chk (__fd, __buf, __nbytes, D.13033);
  return D.13032;
  <D.13031>:
  D.13034 = __builtin_object_size (__buf, 0);
  if (D.13034 < __nbytes) goto <D.13035>; else goto <D.13036>;
  <D.13035>:
  D.13037 = __builtin_object_size (__buf, 0);
  D.13032 = __read_chk_warn (__fd, __buf, __nbytes, D.13037);
  return D.13032;
  <D.13036>:
  <D.13028>:
  D.13032 = __read_alias (__fd, __buf, __nbytes);
  return D.13032;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.13044;
  int D.13049;
  void * D.13051;
  unsigned int D.13052;

  D.13044 = __builtin_constant_p (__len);
  if (D.13044 != 0) goto <D.13045>; else goto <D.13046>;
  <D.13045>:
  if (__len == 0) goto <D.13047>; else goto <D.13048>;
  <D.13047>:
  D.13049 = __builtin_constant_p (__ch);
  if (D.13049 == 0) goto <D.13042>; else goto <D.13050>;
  <D.13050>:
  if (__ch != 0) goto <D.13042>; else goto <D.13043>;
  <D.13042>:
  __warn_memset_zero_len ();
  D.13051 = __dest;
  return D.13051;
  <D.13043>:
  <D.13048>:
  <D.13046>:
  D.13052 = __builtin_object_size (__dest, 0);
  D.13051 = __builtin___memset_chk (__dest, __ch, __len, D.13052);
  return D.13051;
}


dump_header (struct MonoProfiler * profiler)
{
  char * p.175;
  char * p.176;
  char * p.177;
  char * p.178;
  long int D.13058;
  long long unsigned int D.13059;
  long long unsigned int D.13060;
  long long int D.13061;
  int D.13062;
  unsigned int D.13063;
  int D.13064;
  int D.13065;
  int p.179;
  int hbuf.180;
  int D.13068;
  unsigned int D.13069;
  struct FILE * D.13070;
  char hbuf[128];
  char * p;

  try
    {
      p = &hbuf;
      p = write_int32 (p, 1297111553);
      p.175 = p;
      p = p.175 + 1;
      *p.175 = 0;
      p.176 = p;
      p = p.176 + 1;
      *p.176 = 4;
      p.177 = p;
      p = p.177 + 1;
      *p.177 = 4;
      p.178 = p;
      p = p.178 + 1;
      *p.178 = 4;
      D.13058 = time (0B);
      D.13059 = (long long unsigned int) D.13058;
      D.13060 = D.13059 * 1000;
      D.13061 = (long long int) D.13060;
      p = write_int64 (p, D.13061);
      D.13062 = get_timer_overhead ();
      p = write_int32 (p, D.13062);
      p = write_int32 (p, 0);
      D.13063 = process_id ();
      D.13064 = (int) D.13063;
      p = write_int32 (p, D.13064);
      D.13065 = profiler->command_port;
      p = write_int16 (p, D.13065);
      p = write_int16 (p, 0);
      p.179 = (int) p;
      hbuf.180 = (int) &hbuf;
      D.13068 = p.179 - hbuf.180;
      D.13069 = (unsigned int) D.13068;
      D.13070 = profiler->file;
      fwrite (&hbuf, D.13069, 1, D.13070);
      D.13070 = profiler->file;
      fflush (D.13070);
    }
  finally
    {
      hbuf = {CLOBBER};
    }
}


write_int16 (char * buf, int32_t value)
{
  sizetype i.181;
  char * D.13083;
  char D.13084;
  char * D.13085;
  int i;

  i = 0;
  goto <D.10562>;
  <D.10561>:
  i.181 = (sizetype) i;
  D.13083 = buf + i.181;
  D.13084 = (char) value;
  *D.13083 = D.13084;
  value = value >> 8;
  i = i + 1;
  <D.10562>:
  if (i <= 1) goto <D.10561>; else goto <D.10563>;
  <D.10563>:
  D.13085 = buf + 2;
  return D.13085;
}


init_thread ()
{
  struct LogBuffer * tlsbuffer.182;
  unsigned int D.13090;
  struct LogBuffer * logbuffer;

  tlsbuffer.182 = tlsbuffer;
  if (tlsbuffer.182 != 0B) goto <D.13088>; else goto <D.13089>;
  <D.13088>:
  return;
  <D.13089>:
  logbuffer = create_buffer ();
  tlsbuffer = logbuffer;
  D.13090 = thread_id ();
  logbuffer->thread_id = D.13090;
}


create_buffer ()
{
  long long unsigned int D.13094;
  long long unsigned int D.13095;
  int D.13096;
  sizetype D.13097;
  unsigned char * D.13098;
  unsigned char[1] * D.13099;
  struct LogBuffer * D.13100;
  struct LogBuffer * buf;

  buf = alloc_buffer (65536);
  buf->size = 65536;
  D.13094 = current_time ();
  buf->time_base = D.13094;
  D.13095 = buf->time_base;
  buf->last_time = D.13095;
  D.13096 = buf->size;
  D.13097 = (sizetype) D.13096;
  D.13098 = buf + D.13097;
  buf->data_end = D.13098;
  D.13099 = &buf->buf;
  buf->data = D.13099;
  D.13100 = buf;
  return D.13100;
}