mono_chain_signal (int _dummy, struct siginfo_t * info, void * context)
{
  void (*<T40d>) (int) D.24971;
  int D.24974;
  int D.24975;
  void (*<T451>) (int, struct siginfo_t *, void *) D.24979;
  gboolean D.24980;
  int signal;
  struct sigaction * saved_handler;
  void * ctx;

  signal = _dummy;
  saved_handler = get_saved_signal_handler (signal);
  ctx = context;
  if (saved_handler != 0B) goto <D.24969>; else goto <D.24970>;
  <D.24969>:
  D.24971 = saved_handler->__sigaction_handler.sa_handler;
  if (D.24971 != 0B) goto <D.24972>; else goto <D.24973>;
  <D.24972>:
  D.24974 = saved_handler->sa_flags;
  D.24975 = D.24974 & 4;
  if (D.24975 == 0) goto <D.24976>; else goto <D.24977>;
  <D.24976>:
  D.24971 = saved_handler->__sigaction_handler.sa_handler;
  D.24971 (signal);
  goto <D.24978>;
  <D.24977>:
  D.24979 = saved_handler->__sigaction_handler.sa_sigaction;
  D.24979 (signal, info, ctx);
  <D.24978>:
  D.24980 = 1;
  return D.24980;
  <D.24973>:
  <D.24970>:
  D.24980 = 0;
  return D.24980;
}


get_saved_signal_handler (int signo)
{
  struct GHashTable * mono_saved_signal_handlers.0;
  void * D.24985;
  long int D.24986;
  const void * D.24987;

  mono_saved_signal_handlers.0 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.0 != 0B) goto <D.24983>; else goto <D.24984>;
  <D.24983>:
  D.24986 = (long int) signo;
  D.24987 = (const void *) D.24986;
  mono_saved_signal_handlers.0 = mono_saved_signal_handlers;
  D.24985 = monoeg_g_hash_table_lookup (mono_saved_signal_handlers.0, D.24987);
  return D.24985;
  <D.24984>:
  D.24985 = 0B;
  return D.24985;
}


mono_runtime_posix_install_handlers ()
{
  struct MonoDebugOptions * D.24989;
  int D.24990;
  struct MonoTraceSpec * mono_jit_trace_calls.1;
  int D.24996;
  int D.24999;
  int D.25000;
  struct sigset_t signal_set;

  try
    {
      D.24989 = mini_get_debug_options ();
      D.24990 = D.24989->handle_sigint;
      if (D.24990 != 0) goto <D.24991>; else goto <D.24992>;
      <D.24991>:
      add_signal_handler (2, mono_sigint_signal_handler);
      <D.24992>:
      add_signal_handler (8, mono_sigfpe_signal_handler);
      add_signal_handler (3, sigquit_signal_handler);
      add_signal_handler (4, mono_sigill_signal_handler);
      add_signal_handler (7, mono_sigsegv_signal_handler);
      mono_jit_trace_calls.1 = mono_jit_trace_calls;
      if (mono_jit_trace_calls.1 != 0B) goto <D.24994>; else goto <D.24995>;
      <D.24994>:
      add_signal_handler (12, sigusr2_signal_handler);
      <D.24995>:
      D.24996 = mono_thread_info_new_interrupt_enabled ();
      if (D.24996 == 0) goto <D.24997>; else goto <D.24998>;
      <D.24997>:
      D.24999 = mono_thread_get_abort_signal ();
      add_signal_handler (D.24999, sigusr1_signal_handler);
      <D.24998>:
      sigemptyset (&signal_set);
      D.25000 = mono_thread_get_abort_signal ();
      sigaddset (&signal_set, D.25000);
      sigprocmask (1, &signal_set, 0B);
      signal (13, 1B);
      add_signal_handler (6, sigabrt_signal_handler);
      add_signal_handler (11, mono_sigsegv_signal_handler);
    }
  finally
    {
      signal_set = {CLOBBER};
    }
}


sigabrt_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  struct MonoInternalThread * D.25001;
  void * D.25004;
  struct MonoDomain * D.25005;
  int D.25008;
  struct MonoJitInfo * ji;
  void * ctx;

  ji = 0B;
  ctx = context;
  D.25001 = mono_thread_internal_current ();
  if (D.25001 != 0B) goto <D.25002>; else goto <D.25003>;
  <D.25002>:
  D.25004 = mono_arch_ip_from_context (ctx);
  D.25005 = mono_domain_get ();
  ji = mono_jit_info_table_find (D.25005, D.25004);
  <D.25003>:
  if (ji == 0B) goto <D.25006>; else goto <D.25007>;
  <D.25006>:
  D.25008 = mono_chain_signal (_dummy, info, context);
  if (D.25008 != 0) goto <D.25009>; else goto <D.25010>;
  <D.25009>:
  return;
  <D.25010>:
  mono_handle_native_sigsegv (6, ctx);
  <D.25007>:
}


sigusr1_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  _Bool D.25012;
  _Bool D.25013;
  _Bool D.25014;
  int D.25017;
  unsigned char D.25020;
  void * D.25025;
  struct MonoDomain * D.25026;
  _Bool D.25027;
  int D.25028;
  int mono_aot_only.2;
  int D.25037;
  int D.25040;
  gboolean running_managed;
  struct MonoException * exc;
  struct MonoInternalThread * thread;
  struct MonoDomain * domain;
  void * ji;
  void * ctx;

  thread = mono_thread_internal_current ();
  domain = mono_domain_get ();
  ctx = context;
  D.25012 = thread == 0B;
  D.25013 = domain == 0B;
  D.25014 = D.25012 | D.25013;
  if (D.25014 != 0) goto <D.25015>; else goto <D.25016>;
  <D.25015>:
  mono_debugger_agent_thread_interrupt (ctx, 0B);
  return;
  <D.25016>:
  D.25017 = thread->ignore_next_signal;
  if (D.25017 != 0) goto <D.25018>; else goto <D.25019>;
  <D.25018>:
  thread->ignore_next_signal = 0;
  return;
  <D.25019>:
  D.25020 = thread->thread_dump_requested;
  if (D.25020 != 0) goto <D.25021>; else goto <D.25022>;
  <D.25021>:
  thread->thread_dump_requested = 0;
  mono_print_thread_dump (ctx);
  <D.25022>:
  if (ctx != 0B) goto <D.25023>; else goto <D.25024>;
  <D.25023>:
  D.25025 = mono_arch_ip_from_context (ctx);
  D.25026 = mono_domain_get ();
  ji = mono_jit_info_table_find (D.25026, D.25025);
  D.25027 = ji != 0B;
  running_managed = (gboolean) D.25027;
  D.25028 = mono_debugger_agent_thread_interrupt (ctx, ji);
  if (D.25028 != 0) goto <D.25029>; else goto <D.25030>;
  <D.25029>:
  return;
  <D.25030>:
  goto <D.25031>;
  <D.25024>:
  running_managed = 0;
  <D.25031>:
  mono_aot_only.2 = mono_aot_only;
  if (mono_aot_only.2 == 0) goto <D.25033>; else goto <D.25034>;
  <D.25033>:
  if (ctx != 0B) goto <D.25035>; else goto <D.25036>;
  <D.25035>:
  {
    struct MonoThreadUnwindState unwind_state;

    try
      {
        D.25037 = mono_thread_state_init_from_sigctx (&unwind_state, ctx);
        if (D.25037 != 0) goto <D.25038>; else goto <D.25039>;
        <D.25038>:
        D.25040 = mono_install_handler_block_guard (&unwind_state);
        if (D.25040 != 0) goto <D.25041>; else goto <D.25042>;
        <D.25041>:
        wapi_clear_interruption ();
        return;
        <D.25042>:
        <D.25039>:
      }
    finally
      {
        unwind_state = {CLOBBER};
      }
  }
  <D.25036>:
  <D.25034>:
  exc = mono_thread_request_interruption (running_managed);
  if (exc == 0B) goto <D.25043>; else goto <D.25044>;
  <D.25043>:
  return;
  <D.25044>:
  mono_arch_handle_exception (ctx, exc);
}


sigusr2_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  _Bool D.25048;
  int D.25049;
  gboolean enabled;

  enabled = mono_trace_is_enabled ();
  D.25048 = enabled == 0;
  D.25049 = (int) D.25048;
  mono_trace_enable (D.25049);
  mono_chain_signal (_dummy, info, context);
}


sigquit_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  int D.25052;
  gboolean res;
  void * ctx;

  ctx = context;
  res = mono_attach_start ();
  if (res != 0) goto <D.25050>; else goto <D.25051>;
  <D.25050>:
  return;
  <D.25051>:
  D.25052 = mono_thread_info_new_interrupt_enabled ();
  if (D.25052 != 0) goto <D.25053>; else goto <D.25054>;
  <D.25053>:
  mono_threads_request_thread_dump ();
  goto <D.25055>;
  <D.25054>:
  printf ("Full thread dump:\n");
  mono_threads_request_thread_dump ();
  mono_print_thread_dump (ctx);
  <D.25055>:
  mono_chain_signal (_dummy, info, context);
}


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

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


add_signal_handler (int signo, void * handler)
{
  void (*<T451>) (int, struct siginfo_t *, void *) handler.3;
  int D.25062;
  int D.25063;
  int D.25064;
  int D.25067;
  int D.25070;
  int D.25071;
  _Bool D.25072;
  long int D.25073;
  long int D.25074;
  int D.25079;
  int D.25080;
  void (*<T40d>) (int) D.25082;
  int mono_do_signal_chaining.4;
  struct sigaction sa;
  struct sigaction previous_sa;

  try
    {
      handler.3 = (void (*<T451>) (int, struct siginfo_t *, void *)) handler;
      sa.__sigaction_handler.sa_sigaction = handler.3;
      sigemptyset (&sa.sa_mask);
      sa.sa_flags = 4;
      if (signo == 11) goto <D.25060>; else goto <D.25061>;
      <D.25060>:
      D.25062 = sa.sa_flags;
      D.25063 = D.25062 | 134217728;
      sa.sa_flags = D.25063;
      D.25064 = mono_gc_get_suspend_signal ();
      if (D.25064 != -1) goto <D.25065>; else goto <D.25066>;
      <D.25065>:
      D.25067 = mono_gc_get_suspend_signal ();
      sigaddset (&sa.sa_mask, D.25067);
      <D.25066>:
      <D.25061>:
      if (signo == 11) goto <D.25068>; else goto <D.25069>;
      <D.25068>:
      {
        struct sigset_t block_mask;

        try
          {
            sigemptyset (&block_mask);
            D.25070 = mono_thread_get_abort_signal ();
            sigaddset (&sa.sa_mask, D.25070);
          }
        finally
          {
            block_mask = {CLOBBER};
          }
      }
      <D.25069>:
      D.25071 = sigaction (signo, &sa, &previous_sa);
      D.25072 = D.25071 == -1;
      D.25073 = (long int) D.25072;
      D.25074 = __builtin_expect (D.25073, 0);
      if (D.25074 != 0) goto <D.25075>; else goto <D.25076>;
      <D.25075>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 471, "sigaction (signo, &sa, &previous_sa) != -1");
      <D.25076>:
      D.25079 = previous_sa.sa_flags;
      D.25080 = D.25079 & 4;
      if (D.25080 == 0) goto <D.25081>; else goto <D.25077>;
      <D.25081>:
      D.25082 = previous_sa.__sigaction_handler.sa_handler;
      if (D.25082 == 0B) goto <D.25083>; else goto <D.25077>;
      <D.25083>:
      goto <D.25078>;
      <D.25077>:
      mono_do_signal_chaining.4 = mono_do_signal_chaining;
      if (mono_do_signal_chaining.4 != 0) goto <D.25085>; else goto <D.25086>;
      <D.25085>:
      save_old_signal_handler (signo, &previous_sa);
      <D.25086>:
      <D.25078>:
    }
  finally
    {
      sa = {CLOBBER};
      previous_sa = {CLOBBER};
    }
}


save_old_signal_handler (int signo, struct sigaction * old_action)
{
  int D.25087;
  int D.25088;
  void (*<T40d>) (int) D.25091;
  void (*<T451>) (int, struct siginfo_t *, void *) D.25093;
  struct GHashTable * mono_saved_signal_handlers.5;
  struct GHashTable * mono_saved_signal_handlers.6;
  long int D.25098;
  void * D.25099;
  struct sigaction * handler_to_save;

  handler_to_save = monoeg_malloc (152);
  mono_trace (128, 16, "Saving old signal handler for signal %d.", signo);
  D.25087 = old_action->sa_flags;
  D.25088 = D.25087 & 4;
  if (D.25088 == 0) goto <D.25089>; else goto <D.25090>;
  <D.25089>:
  D.25091 = old_action->__sigaction_handler.sa_handler;
  handler_to_save->__sigaction_handler.sa_handler = D.25091;
  goto <D.25092>;
  <D.25090>:
  D.25093 = old_action->__sigaction_handler.sa_sigaction;
  handler_to_save->__sigaction_handler.sa_sigaction = D.25093;
  <D.25092>:
  handler_to_save->sa_mask = old_action->sa_mask;
  D.25087 = old_action->sa_flags;
  handler_to_save->sa_flags = D.25087;
  mono_saved_signal_handlers.5 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.5 == 0B) goto <D.25095>; else goto <D.25096>;
  <D.25095>:
  mono_saved_signal_handlers.6 = monoeg_g_hash_table_new (0B, 0B);
  mono_saved_signal_handlers = mono_saved_signal_handlers.6;
  <D.25096>:
  D.25098 = (long int) signo;
  D.25099 = (void *) D.25098;
  mono_saved_signal_handlers.5 = mono_saved_signal_handlers;
  monoeg_g_hash_table_insert_replace (mono_saved_signal_handlers.5, D.25099, handler_to_save, 0);
}


mono_runtime_install_handlers ()
{
  mono_runtime_posix_install_handlers ();
}


mono_runtime_cleanup_handlers ()
{
  struct MonoDebugOptions * D.25100;
  int D.25101;
  struct MonoTraceSpec * mono_jit_trace_calls.7;
  int D.25107;

  D.25100 = mini_get_debug_options ();
  D.25101 = D.25100->handle_sigint;
  if (D.25101 != 0) goto <D.25102>; else goto <D.25103>;
  <D.25102>:
  remove_signal_handler (2);
  <D.25103>:
  remove_signal_handler (8);
  remove_signal_handler (3);
  remove_signal_handler (4);
  remove_signal_handler (7);
  mono_jit_trace_calls.7 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.7 != 0B) goto <D.25105>; else goto <D.25106>;
  <D.25105>:
  remove_signal_handler (12);
  <D.25106>:
  D.25107 = mono_thread_get_abort_signal ();
  remove_signal_handler (D.25107);
  remove_signal_handler (6);
  remove_signal_handler (11);
  free_saved_signal_handlers ();
}


remove_signal_handler (int signo)
{
  int D.25111;
  _Bool D.25112;
  long int D.25113;
  long int D.25114;
  struct sigaction sa;
  struct sigaction * saved_action;

  try
    {
      saved_action = get_saved_signal_handler (signo);
      if (saved_action == 0B) goto <D.25108>; else goto <D.25109>;
      <D.25108>:
      sa.__sigaction_handler.sa_handler = 0B;
      sigemptyset (&sa.sa_mask);
      sa.sa_flags = 0;
      sigaction (signo, &sa, 0B);
      goto <D.25110>;
      <D.25109>:
      D.25111 = sigaction (signo, saved_action, 0B);
      D.25112 = D.25111 == -1;
      D.25113 = (long int) D.25112;
      D.25114 = __builtin_expect (D.25113, 0);
      if (D.25114 != 0) goto <D.25115>; else goto <D.25116>;
      <D.25115>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 496, "sigaction (signo, saved_action, NULL) != -1");
      <D.25116>:
      <D.25110>:
    }
  finally
    {
      sa = {CLOBBER};
    }
}


free_saved_signal_handlers ()
{
  struct GHashTable * mono_saved_signal_handlers.8;

  mono_saved_signal_handlers.8 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.8 != 0B) goto <D.25118>; else goto <D.25119>;
  <D.25118>:
  mono_saved_signal_handlers.8 = mono_saved_signal_handlers;
  monoeg_g_hash_table_foreach (mono_saved_signal_handlers.8, free_saved_sig_handler_func, 0B);
  mono_saved_signal_handlers.8 = mono_saved_signal_handlers;
  monoeg_g_hash_table_destroy (mono_saved_signal_handlers.8);
  mono_saved_signal_handlers = 0B;
  <D.25119>:
}


free_saved_sig_handler_func (void * key, void * value, void * user_data)
{
  monoeg_g_free (value);
}


mono_runtime_shutdown_stat_profiler ()
{
  int rtc_fd.9;

  rtc_fd.9 = rtc_fd;
  if (rtc_fd.9 >= 0) goto <D.25121>; else goto <D.25122>;
  <D.25121>:
  enable_rtc_timer (0);
  <D.25122>:
}


enable_rtc_timer (gboolean enable)
{
  int rtc_fd.10;
  int D.25126;
  int D.25130;
  int flags;

  rtc_fd.10 = rtc_fd;
  flags = fcntl (rtc_fd.10, 3);
  if (flags < 0) goto <D.25124>; else goto <D.25125>;
  <D.25124>:
  perror ("getflags");
  D.25126 = 0;
  return D.25126;
  <D.25125>:
  if (enable != 0) goto <D.25127>; else goto <D.25128>;
  <D.25127>:
  flags = flags | 8192;
  goto <D.25129>;
  <D.25128>:
  flags = flags & -8193;
  <D.25129>:
  rtc_fd.10 = rtc_fd;
  D.25130 = fcntl (rtc_fd.10, 4, flags);
  if (D.25130 == -1) goto <D.25131>; else goto <D.25132>;
  <D.25131>:
  perror ("setflags");
  D.25126 = 0;
  return D.25126;
  <D.25132>:
  D.25126 = 1;
  return D.25126;
}


mono_runtime_setup_stat_profiler ()
{
  int inited.11;
  char D.25139;
  int rtc_fd.12;
  int rtc_fd.13;
  int D.25148;
  int D.25151;
  int D.25154;
  int D.25157;
  int D.25158;
  struct itimerval itval;
  static int inited = 0;
  const char * rtc_freq;

  try
    {
      inited.11 = inited;
      if (inited.11 == 0) goto <D.25135>; else goto <D.25136>;
      <D.25135>:
      rtc_freq = monoeg_g_getenv ("MONO_RTC");
      if (rtc_freq != 0B) goto <D.25137>; else goto <D.25138>;
      <D.25137>:
      {
        int freq;

        freq = 0;
        inited = 1;
        D.25139 = *rtc_freq;
        if (D.25139 != 0) goto <D.25140>; else goto <D.25141>;
        <D.25140>:
        freq = atoi (rtc_freq);
        <D.25141>:
        if (freq == 0) goto <D.25142>; else goto <D.25143>;
        <D.25142>:
        freq = 1024;
        <D.25143>:
        rtc_fd.12 = open ("/dev/rtc", 0);
        rtc_fd = rtc_fd.12;
        rtc_fd.13 = rtc_fd;
        if (rtc_fd.13 == -1) goto <D.25146>; else goto <D.25147>;
        <D.25146>:
        perror ("open /dev/rtc");
        return;
        <D.25147>:
        add_signal_handler (27, sigprof_signal_handler);
        rtc_fd.13 = rtc_fd;
        D.25148 = ioctl (rtc_fd.13, 1074294796, freq);
        if (D.25148 == -1) goto <D.25149>; else goto <D.25150>;
        <D.25149>:
        perror ("set rtc freq");
        return;
        <D.25150>:
        rtc_fd.13 = rtc_fd;
        D.25151 = ioctl (rtc_fd.13, 28677, 0);
        if (D.25151 == -1) goto <D.25152>; else goto <D.25153>;
        <D.25152>:
        perror ("start rtc");
        return;
        <D.25153>:
        rtc_fd.13 = rtc_fd;
        D.25154 = fcntl (rtc_fd.13, 10, 27);
        if (D.25154 == -1) goto <D.25155>; else goto <D.25156>;
        <D.25155>:
        perror ("setsig");
        return;
        <D.25156>:
        D.25157 = getpid ();
        rtc_fd.13 = rtc_fd;
        D.25158 = fcntl (rtc_fd.13, 8, D.25157);
        if (D.25158 == -1) goto <D.25159>; else goto <D.25160>;
        <D.25159>:
        perror ("setown");
        return;
        <D.25160>:
        enable_rtc_timer (1);
        return;
      }
      <D.25138>:
      <D.25136>:
      rtc_fd.13 = rtc_fd;
      if (rtc_fd.13 >= 0) goto <D.25161>; else goto <D.25162>;
      <D.25161>:
      return;
      <D.25162>:
      itval.it_interval.tv_usec = 999;
      itval.it_interval.tv_sec = 0;
      itval.it_value = itval.it_interval;
      setitimer (2, &itval, 0B);
      inited.11 = inited;
      if (inited.11 != 0) goto <D.25163>; else goto <D.25164>;
      <D.25163>:
      return;
      <D.25164>:
      inited = 1;
      add_signal_handler (27, sigprof_signal_handler);
    }
  finally
    {
      itval = {CLOBBER};
    }
}


sigprof_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  void * D.25170;
  unsigned int mono_jit_tls_id.14;
  int D.25173;
  long int D.25174;
  long int D.25175;
  sizetype D.25176;
  sizetype D.25177;
  bitsizetype D.25178;
  bitsizetype D.25179;
  sizetype D.25180;
  guchar *[0:D.25176] * ips.15;
  long int D.25182;
  guchar * D.25183;
  long int D.25188;
  long int D.25189;
  void * D.25190;
  _Bool D.25191;
  _Bool D.25192;
  _Bool D.25193;
  long int D.25201;
  guchar * D.25202;
  _Bool D.25203;
  _Bool D.25204;
  guchar * * D.25205;
  void * saved_stack.16;
  int call_chain_depth;
  MonoProfilerCallChainStrategy call_chain_strategy;
  void * ctx;

  call_chain_depth = mono_profiler_stat_get_call_chain_depth ();
  call_chain_strategy = mono_profiler_stat_get_call_chain_strategy ();
  ctx = context;
  if (call_chain_depth == 0) goto <D.25168>; else goto <D.25169>;
  <D.25168>:
  D.25170 = mono_arch_ip_from_context (ctx);
  mono_profiler_stat_hit (D.25170, ctx);
  goto <D.25171>;
  <D.25169>:
  {
    struct MonoJitTlsData * jit_tls;
    int current_frame_index;
    struct MonoContext mono_context;
    guchar * ips[0:D.25176] [value-expr: *ips.15];

    saved_stack.16 = __builtin_stack_save ();
    try
      {
        mono_jit_tls_id.14 = mono_jit_tls_id;
        jit_tls = pthread_getspecific (mono_jit_tls_id.14);
        current_frame_index = 1;
        D.25173 = call_chain_depth + 1;
        D.25174 = (long int) D.25173;
        D.25175 = D.25174 + -1;
        D.25176 = (sizetype) D.25175;
        D.25177 = (sizetype) D.25173;
        D.25178 = (bitsizetype) D.25177;
        D.25179 = D.25178 * 64;
        D.25177 = (sizetype) D.25173;
        D.25180 = D.25177 * 8;
        D.25177 = (sizetype) D.25173;
        D.25178 = (bitsizetype) D.25177;
        D.25179 = D.25178 * 64;
        D.25177 = (sizetype) D.25173;
        D.25180 = D.25177 * 8;
        ips.15 = __builtin_alloca_with_align (D.25180, 64);
        mono_arch_sigctx_to_monoctx (ctx, &mono_context);
        D.25182 = mono_context.rip;
        D.25183 = (guchar *) D.25182;
        *ips.15[0] = D.25183;
        if (jit_tls != 0B) goto <D.25184>; else goto <D.25185>;
        <D.25184>:
        if (call_chain_strategy == 1) goto <D.25186>; else goto <D.25187>;
        <D.25186>:
        {
          guchar * current_frame;
          guchar * stack_bottom;
          guchar * stack_top;

          stack_bottom = jit_tls->end_of_stack;
          D.25188 = mono_context.rsp;
          stack_top = (guchar *) D.25188;
          D.25189 = mono_context.rbp;
          current_frame = (guchar *) D.25189;
          goto <D.24646>;
          <D.24645>:
          D.25190 = MEM[(void * *)current_frame + 8B];
          *ips.15[current_frame_index] = D.25190;
          current_frame_index = current_frame_index + 1;
          stack_top = current_frame;
          current_frame = MEM[(void * *)current_frame];
          <D.24646>:
          D.25191 = current_frame_index <= call_chain_depth;
          D.25192 = stack_bottom > current_frame;
          D.25193 = D.25191 & D.25192;
          if (D.25193 != 0) goto <D.25194>; else goto <D.24647>;
          <D.25194>:
          if (current_frame > stack_top) goto <D.24645>; else goto <D.24647>;
          <D.24647>:
        }
        <D.25187>:
        if (call_chain_strategy == 2) goto <D.25195>; else goto <D.25196>;
        <D.25195>:
        call_chain_strategy = 3;
        <D.25196>:
        if (call_chain_strategy == 3) goto <D.25197>; else goto <D.25198>;
        <D.25197>:
        {
          struct MonoDomain * domain;

          domain = mono_domain_get ();
          if (domain != 0B) goto <D.25199>; else goto <D.25200>;
          <D.25199>:
          {
            struct MonoLMF * lmf;
            struct MonoJitInfo * ji;
            struct MonoJitInfo res;
            struct MonoContext new_mono_context;
            int native_offset;

            try
              {
                lmf = 0B;
                ji = mono_find_jit_info (domain, jit_tls, &res, 0B, &mono_context, &new_mono_context, 0B, &lmf, &native_offset, 0B);
                goto <D.24655>;
                <D.24654>:
                D.25201 = new_mono_context.rip;
                D.25202 = (guchar *) D.25201;
                *ips.15[current_frame_index] = D.25202;
                current_frame_index = current_frame_index + 1;
                mono_context = new_mono_context;
                ji = mono_find_jit_info (domain, jit_tls, &res, 0B, &mono_context, &new_mono_context, 0B, &lmf, &native_offset, 0B);
                <D.24655>:
                D.25203 = ji != 0B;
                D.25191 = current_frame_index <= call_chain_depth;
                D.25204 = D.25203 & D.25191;
                if (D.25204 != 0) goto <D.24654>; else goto <D.24656>;
                <D.24656>:
              }
            finally
              {
                lmf = {CLOBBER};
                res = {CLOBBER};
                new_mono_context = {CLOBBER};
                native_offset = {CLOBBER};
              }
          }
          <D.25200>:
        }
        <D.25198>:
        <D.25185>:
        D.25205 = &*ips.15[0];
        mono_profiler_stat_call_chain (current_frame_index, D.25205, ctx);
      }
    finally
      {
        __builtin_stack_restore (saved_stack.16);
        mono_context = {CLOBBER};
      }
  }
  <D.25171>:
  mono_chain_signal (_dummy, info, context);
}


atoi (const char * __nptr)
{
  int D.25207;
  long int D.25208;

  D.25208 = strtol (__nptr, 0B, 10);
  D.25207 = (int) D.25208;
  return D.25207;
}


open (const char * __path, int __oflag)
{
  int D.25210;
  int D.25213;
  int D.25218;
  int D.25220;
  int D.25221;
  int D.25224;
  int D.25225;

  D.25210 = __builtin_va_arg_pack_len ();
  if (D.25210 > 1) goto <D.25211>; else goto <D.25212>;
  <D.25211>:
  __open_too_many_args ();
  <D.25212>:
  D.25213 = __builtin_constant_p (__oflag);
  if (D.25213 != 0) goto <D.25214>; else goto <D.25215>;
  <D.25214>:
  D.25218 = __oflag & 64;
  if (D.25218 != 0) goto <D.25216>; else goto <D.25219>;
  <D.25219>:
  D.25220 = __oflag & 4259840;
  if (D.25220 == 4259840) goto <D.25216>; else goto <D.25217>;
  <D.25216>:
  D.25221 = __builtin_va_arg_pack_len ();
  if (D.25221 <= 0) goto <D.25222>; else goto <D.25223>;
  <D.25222>:
  __open_missing_mode ();
  D.25224 = __open_2 (__path, __oflag);
  return D.25224;
  <D.25223>:
  <D.25217>:
  D.25224 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.25224;
  <D.25215>:
  D.25225 = __builtin_va_arg_pack_len ();
  if (D.25225 <= 0) goto <D.25226>; else goto <D.25227>;
  <D.25226>:
  D.25224 = __open_2 (__path, __oflag);
  return D.25224;
  <D.25227>:
  D.25224 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.25224;
}


mono_runtime_syscall_fork ()
{
  pid_t D.25229;
  long int D.25230;

  D.25230 = syscall (57);
  D.25229 = (pid_t) D.25230;
  return D.25229;
}


mono_gdb_render_native_backtraces (pid_t crashed_pid)
{
  gchar * D.25232;
  const char * D.25233;
  gchar * D.25236;
  int D.25241;
  long int D.25244;
  const char * argv[9];
  char template[31];
  char buf1[128];
  struct FILE * commands;
  gboolean using_lldb;

  try
    {
      template = "/tmp/mono-lldb-commands.XXXXXX";
      using_lldb = 0;
      D.25232 = monoeg_g_find_program_in_path ("gdb");
      argv[0] = D.25232;
      D.25233 = argv[0];
      if (D.25233 == 0B) goto <D.25234>; else goto <D.25235>;
      <D.25234>:
      D.25236 = monoeg_g_find_program_in_path ("lldb");
      argv[0] = D.25236;
      using_lldb = 1;
      <D.25235>:
      D.25233 = argv[0];
      if (D.25233 == 0B) goto <D.25237>; else goto <D.25238>;
      <D.25237>:
      return;
      <D.25238>:
      if (using_lldb != 0) goto <D.25239>; else goto <D.25240>;
      <D.25239>:
      D.25241 = mkstemp (&template);
      if (D.25241 == -1) goto <D.25242>; else goto <D.25243>;
      <D.25242>:
      return;
      <D.25243>:
      commands = fopen (&template, "w");
      D.25244 = (long int) crashed_pid;
      fprintf (commands, "process attach --pid %ld\n", D.25244);
      fprintf (commands, "script lldb.debugger.HandleCommand (\"thread list\")\n");
      fprintf (commands, "script lldb.debugger.HandleCommand (\"thread backtrace all\")\n");
      fprintf (commands, "detach\n");
      fprintf (commands, "quit\n");
      fflush (commands);
      fclose (commands);
      argv[1] = "--source";
      argv[2] = &template;
      argv[3] = 0B;
      goto <D.25245>;
      <D.25240>:
      argv[1] = "-ex";
      D.25244 = (long int) crashed_pid;
      sprintf (&buf1, "attach %ld", D.25244);
      argv[2] = &buf1;
      argv[3] = "--ex";
      argv[4] = "info threads";
      argv[5] = "--ex";
      argv[6] = "thread apply all bt";
      argv[7] = "--batch";
      argv[8] = 0B;
      <D.25245>:
      D.25233 = argv[0];
      execv (D.25233, &argv);
      if (using_lldb != 0) goto <D.25246>; else goto <D.25247>;
      <D.25246>:
      unlink (&template);
      <D.25247>:
    }
  finally
    {
      argv = {CLOBBER};
      template = {CLOBBER};
      buf1 = {CLOBBER};
    }
}


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

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


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.25253;
  long unsigned int D.25254;

  D.25254 = __builtin_object_size (__s, 1);
  D.25253 = __builtin___sprintf_chk (__s, 1, D.25254, __fmt, __builtin_va_arg_pack ());
  return D.25253;
}


mono_thread_state_init_from_handle (struct MonoThreadUnwindState * tctx, MonoNativeThreadId thread_id, MonoNativeThreadHandle thread_handle)
{
  gboolean D.25256;

  monoeg_g_log (0B, 4, "Posix systems don\'t support mono_thread_state_init_from_handle");
  <D.24967>:
  goto <D.24967>;
  D.25256 = 0;
  return D.25256;
}