mono_chain_signal (int _dummy, struct siginfo_t * info, void * context)
{
  void (*<T332>) (int) D.24639;
  int D.24642;
  int D.24643;
  void (*<T376>) (int, struct siginfo_t *, void *) D.24647;
  gboolean D.24648;
  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.24637>; else goto <D.24638>;
  <D.24637>:
  D.24639 = saved_handler->__sigaction_handler.sa_handler;
  if (D.24639 != 0B) goto <D.24640>; else goto <D.24641>;
  <D.24640>:
  D.24642 = saved_handler->sa_flags;
  D.24643 = D.24642 & 4;
  if (D.24643 == 0) goto <D.24644>; else goto <D.24645>;
  <D.24644>:
  D.24639 = saved_handler->__sigaction_handler.sa_handler;
  D.24639 (signal);
  goto <D.24646>;
  <D.24645>:
  D.24647 = saved_handler->__sigaction_handler.sa_sigaction;
  D.24647 (signal, info, ctx);
  <D.24646>:
  D.24648 = 1;
  return D.24648;
  <D.24641>:
  <D.24638>:
  D.24648 = 0;
  return D.24648;
}


get_saved_signal_handler (int signo)
{
  struct GHashTable * mono_saved_signal_handlers.0;
  void * D.24653;
  const void * signo.1;

  mono_saved_signal_handlers.0 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.0 != 0B) goto <D.24651>; else goto <D.24652>;
  <D.24651>:
  signo.1 = (const void *) signo;
  mono_saved_signal_handlers.0 = mono_saved_signal_handlers;
  D.24653 = monoeg_g_hash_table_lookup (mono_saved_signal_handlers.0, signo.1);
  return D.24653;
  <D.24652>:
  D.24653 = 0B;
  return D.24653;
}


mono_runtime_posix_install_handlers ()
{
  struct MonoDebugOptions * D.24656;
  int D.24657;
  struct MonoTraceSpec * mono_jit_trace_calls.2;
  int D.24663;
  int D.24666;
  int D.24667;
  struct sigset_t signal_set;

  try
    {
      D.24656 = mini_get_debug_options ();
      D.24657 = D.24656->handle_sigint;
      if (D.24657 != 0) goto <D.24658>; else goto <D.24659>;
      <D.24658>:
      add_signal_handler (2, mono_sigint_signal_handler);
      <D.24659>:
      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.2 = mono_jit_trace_calls;
      if (mono_jit_trace_calls.2 != 0B) goto <D.24661>; else goto <D.24662>;
      <D.24661>:
      add_signal_handler (12, sigusr2_signal_handler);
      <D.24662>:
      D.24663 = mono_thread_info_new_interrupt_enabled ();
      if (D.24663 == 0) goto <D.24664>; else goto <D.24665>;
      <D.24664>:
      D.24666 = mono_thread_get_abort_signal ();
      add_signal_handler (D.24666, sigusr1_signal_handler);
      <D.24665>:
      sigemptyset (&signal_set);
      D.24667 = mono_thread_get_abort_signal ();
      sigaddset (&signal_set, D.24667);
      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.24668;
  void * D.24671;
  struct MonoDomain * D.24672;
  int D.24675;
  struct MonoJitInfo * ji;
  void * ctx;

  ji = 0B;
  ctx = context;
  D.24668 = mono_thread_internal_current ();
  if (D.24668 != 0B) goto <D.24669>; else goto <D.24670>;
  <D.24669>:
  D.24671 = mono_arch_ip_from_context (ctx);
  D.24672 = mono_domain_get ();
  ji = mono_jit_info_table_find (D.24672, D.24671);
  <D.24670>:
  if (ji == 0B) goto <D.24673>; else goto <D.24674>;
  <D.24673>:
  D.24675 = mono_chain_signal (_dummy, info, context);
  if (D.24675 != 0) goto <D.24676>; else goto <D.24677>;
  <D.24676>:
  return;
  <D.24677>:
  mono_handle_native_sigsegv (6, ctx);
  <D.24674>:
}


sigusr1_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  _Bool D.24679;
  _Bool D.24680;
  _Bool D.24681;
  int D.24684;
  unsigned char D.24687;
  void * D.24692;
  struct MonoDomain * D.24693;
  _Bool D.24694;
  int D.24695;
  int mono_aot_only.3;
  int D.24704;
  int D.24707;
  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.24679 = thread == 0B;
  D.24680 = domain == 0B;
  D.24681 = D.24679 | D.24680;
  if (D.24681 != 0) goto <D.24682>; else goto <D.24683>;
  <D.24682>:
  mono_debugger_agent_thread_interrupt (ctx, 0B);
  return;
  <D.24683>:
  D.24684 = thread->ignore_next_signal;
  if (D.24684 != 0) goto <D.24685>; else goto <D.24686>;
  <D.24685>:
  thread->ignore_next_signal = 0;
  return;
  <D.24686>:
  D.24687 = thread->thread_dump_requested;
  if (D.24687 != 0) goto <D.24688>; else goto <D.24689>;
  <D.24688>:
  thread->thread_dump_requested = 0;
  mono_print_thread_dump (ctx);
  <D.24689>:
  if (ctx != 0B) goto <D.24690>; else goto <D.24691>;
  <D.24690>:
  D.24692 = mono_arch_ip_from_context (ctx);
  D.24693 = mono_domain_get ();
  ji = mono_jit_info_table_find (D.24693, D.24692);
  D.24694 = ji != 0B;
  running_managed = (gboolean) D.24694;
  D.24695 = mono_debugger_agent_thread_interrupt (ctx, ji);
  if (D.24695 != 0) goto <D.24696>; else goto <D.24697>;
  <D.24696>:
  return;
  <D.24697>:
  goto <D.24698>;
  <D.24691>:
  running_managed = 0;
  <D.24698>:
  mono_aot_only.3 = mono_aot_only;
  if (mono_aot_only.3 == 0) goto <D.24700>; else goto <D.24701>;
  <D.24700>:
  if (ctx != 0B) goto <D.24702>; else goto <D.24703>;
  <D.24702>:
  {
    struct MonoThreadUnwindState unwind_state;

    try
      {
        D.24704 = mono_thread_state_init_from_sigctx (&unwind_state, ctx);
        if (D.24704 != 0) goto <D.24705>; else goto <D.24706>;
        <D.24705>:
        D.24707 = mono_install_handler_block_guard (&unwind_state);
        if (D.24707 != 0) goto <D.24708>; else goto <D.24709>;
        <D.24708>:
        wapi_clear_interruption ();
        return;
        <D.24709>:
        <D.24706>:
      }
    finally
      {
        unwind_state = {CLOBBER};
      }
  }
  <D.24703>:
  <D.24701>:
  exc = mono_thread_request_interruption (running_managed);
  if (exc == 0B) goto <D.24710>; else goto <D.24711>;
  <D.24710>:
  return;
  <D.24711>:
  mono_arch_handle_exception (ctx, exc);
}


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

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


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

  ctx = context;
  res = mono_attach_start ();
  if (res != 0) goto <D.24717>; else goto <D.24718>;
  <D.24717>:
  return;
  <D.24718>:
  D.24719 = mono_thread_info_new_interrupt_enabled ();
  if (D.24719 != 0) goto <D.24720>; else goto <D.24721>;
  <D.24720>:
  mono_threads_request_thread_dump ();
  goto <D.24722>;
  <D.24721>:
  printf ("Full thread dump:\n");
  mono_threads_request_thread_dump ();
  mono_print_thread_dump (ctx);
  <D.24722>:
  mono_chain_signal (_dummy, info, context);
}


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

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


add_signal_handler (int signo, void * handler)
{
  void (*<T376>) (int, struct siginfo_t *, void *) handler.4;
  int D.24729;
  int D.24730;
  _Bool D.24731;
  long int D.24732;
  long int D.24733;
  int D.24738;
  int D.24739;
  void (*<T332>) (int) D.24741;
  int mono_do_signal_chaining.5;
  struct sigaction sa;
  struct sigaction previous_sa;

  try
    {
      handler.4 = (void (*<T376>) (int, struct siginfo_t *, void *)) handler;
      sa.__sigaction_handler.sa_sigaction = handler.4;
      sigemptyset (&sa.sa_mask);
      sa.sa_flags = 4;
      if (signo == 11) goto <D.24727>; else goto <D.24728>;
      <D.24727>:
      {
        struct sigset_t block_mask;

        try
          {
            sigemptyset (&block_mask);
            D.24729 = mono_thread_get_abort_signal ();
            sigaddset (&sa.sa_mask, D.24729);
          }
        finally
          {
            block_mask = {CLOBBER};
          }
      }
      <D.24728>:
      D.24730 = sigaction (signo, &sa, &previous_sa);
      D.24731 = D.24730 == -1;
      D.24732 = (long int) D.24731;
      D.24733 = __builtin_expect (D.24732, 0);
      if (D.24733 != 0) goto <D.24734>; else goto <D.24735>;
      <D.24734>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 471, "sigaction (signo, &sa, &previous_sa) != -1");
      <D.24735>:
      D.24738 = previous_sa.sa_flags;
      D.24739 = D.24738 & 4;
      if (D.24739 == 0) goto <D.24740>; else goto <D.24736>;
      <D.24740>:
      D.24741 = previous_sa.__sigaction_handler.sa_handler;
      if (D.24741 == 0B) goto <D.24742>; else goto <D.24736>;
      <D.24742>:
      goto <D.24737>;
      <D.24736>:
      mono_do_signal_chaining.5 = mono_do_signal_chaining;
      if (mono_do_signal_chaining.5 != 0) goto <D.24744>; else goto <D.24745>;
      <D.24744>:
      save_old_signal_handler (signo, &previous_sa);
      <D.24745>:
      <D.24737>:
    }
  finally
    {
      sa = {CLOBBER};
      previous_sa = {CLOBBER};
    }
}


save_old_signal_handler (int signo, struct sigaction * old_action)
{
  int D.24746;
  int D.24747;
  void (*<T332>) (int) D.24750;
  void (*<T376>) (int, struct siginfo_t *, void *) D.24752;
  struct GHashTable * mono_saved_signal_handlers.6;
  struct GHashTable * mono_saved_signal_handlers.7;
  void * signo.8;
  struct sigaction * handler_to_save;

  handler_to_save = monoeg_malloc (140);
  mono_trace (128, 16, "Saving old signal handler for signal %d.", signo);
  D.24746 = old_action->sa_flags;
  D.24747 = D.24746 & 4;
  if (D.24747 == 0) goto <D.24748>; else goto <D.24749>;
  <D.24748>:
  D.24750 = old_action->__sigaction_handler.sa_handler;
  handler_to_save->__sigaction_handler.sa_handler = D.24750;
  goto <D.24751>;
  <D.24749>:
  D.24752 = old_action->__sigaction_handler.sa_sigaction;
  handler_to_save->__sigaction_handler.sa_sigaction = D.24752;
  <D.24751>:
  handler_to_save->sa_mask = old_action->sa_mask;
  D.24746 = old_action->sa_flags;
  handler_to_save->sa_flags = D.24746;
  mono_saved_signal_handlers.6 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.6 == 0B) goto <D.24754>; else goto <D.24755>;
  <D.24754>:
  mono_saved_signal_handlers.7 = monoeg_g_hash_table_new (0B, 0B);
  mono_saved_signal_handlers = mono_saved_signal_handlers.7;
  <D.24755>:
  signo.8 = (void *) signo;
  mono_saved_signal_handlers.6 = mono_saved_signal_handlers;
  monoeg_g_hash_table_insert_replace (mono_saved_signal_handlers.6, signo.8, handler_to_save, 0);
}


mono_runtime_install_handlers ()
{
  mono_runtime_posix_install_handlers ();
}


mono_runtime_cleanup_handlers ()
{
  struct MonoDebugOptions * D.24758;
  int D.24759;
  struct MonoTraceSpec * mono_jit_trace_calls.9;
  int D.24765;

  D.24758 = mini_get_debug_options ();
  D.24759 = D.24758->handle_sigint;
  if (D.24759 != 0) goto <D.24760>; else goto <D.24761>;
  <D.24760>:
  remove_signal_handler (2);
  <D.24761>:
  remove_signal_handler (8);
  remove_signal_handler (3);
  remove_signal_handler (4);
  remove_signal_handler (7);
  mono_jit_trace_calls.9 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.9 != 0B) goto <D.24763>; else goto <D.24764>;
  <D.24763>:
  remove_signal_handler (12);
  <D.24764>:
  D.24765 = mono_thread_get_abort_signal ();
  remove_signal_handler (D.24765);
  remove_signal_handler (6);
  remove_signal_handler (11);
  free_saved_signal_handlers ();
}


remove_signal_handler (int signo)
{
  int D.24769;
  _Bool D.24770;
  long int D.24771;
  long int D.24772;
  struct sigaction sa;
  struct sigaction * saved_action;

  try
    {
      saved_action = get_saved_signal_handler (signo);
      if (saved_action == 0B) goto <D.24766>; else goto <D.24767>;
      <D.24766>:
      sa.__sigaction_handler.sa_handler = 0B;
      sigemptyset (&sa.sa_mask);
      sa.sa_flags = 0;
      sigaction (signo, &sa, 0B);
      goto <D.24768>;
      <D.24767>:
      D.24769 = sigaction (signo, saved_action, 0B);
      D.24770 = D.24769 == -1;
      D.24771 = (long int) D.24770;
      D.24772 = __builtin_expect (D.24771, 0);
      if (D.24772 != 0) goto <D.24773>; else goto <D.24774>;
      <D.24773>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 496, "sigaction (signo, saved_action, NULL) != -1");
      <D.24774>:
      <D.24768>:
    }
  finally
    {
      sa = {CLOBBER};
    }
}


free_saved_signal_handlers ()
{
  struct GHashTable * mono_saved_signal_handlers.10;

  mono_saved_signal_handlers.10 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.10 != 0B) goto <D.24776>; else goto <D.24777>;
  <D.24776>:
  mono_saved_signal_handlers.10 = mono_saved_signal_handlers;
  monoeg_g_hash_table_foreach (mono_saved_signal_handlers.10, free_saved_sig_handler_func, 0B);
  mono_saved_signal_handlers.10 = mono_saved_signal_handlers;
  monoeg_g_hash_table_destroy (mono_saved_signal_handlers.10);
  mono_saved_signal_handlers = 0B;
  <D.24777>:
}


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


mono_runtime_shutdown_stat_profiler ()
{
  int rtc_fd.11;

  rtc_fd.11 = rtc_fd;
  if (rtc_fd.11 >= 0) goto <D.24779>; else goto <D.24780>;
  <D.24779>:
  enable_rtc_timer (0);
  <D.24780>:
}


enable_rtc_timer (gboolean enable)
{
  int rtc_fd.12;
  int D.24784;
  int D.24788;
  int flags;

  rtc_fd.12 = rtc_fd;
  flags = fcntl (rtc_fd.12, 3);
  if (flags < 0) goto <D.24782>; else goto <D.24783>;
  <D.24782>:
  perror ("getflags");
  D.24784 = 0;
  return D.24784;
  <D.24783>:
  if (enable != 0) goto <D.24785>; else goto <D.24786>;
  <D.24785>:
  flags = flags | 8192;
  goto <D.24787>;
  <D.24786>:
  flags = flags & -8193;
  <D.24787>:
  rtc_fd.12 = rtc_fd;
  D.24788 = fcntl (rtc_fd.12, 4, flags);
  if (D.24788 == -1) goto <D.24789>; else goto <D.24790>;
  <D.24789>:
  perror ("setflags");
  D.24784 = 0;
  return D.24784;
  <D.24790>:
  D.24784 = 1;
  return D.24784;
}


mono_runtime_setup_stat_profiler ()
{
  int inited.13;
  char D.24797;
  int rtc_fd.14;
  int rtc_fd.15;
  int D.24806;
  int D.24809;
  int D.24812;
  int D.24815;
  int D.24816;
  struct itimerval itval;
  static int inited = 0;
  const char * rtc_freq;

  try
    {
      inited.13 = inited;
      if (inited.13 == 0) goto <D.24793>; else goto <D.24794>;
      <D.24793>:
      rtc_freq = monoeg_g_getenv ("MONO_RTC");
      if (rtc_freq != 0B) goto <D.24795>; else goto <D.24796>;
      <D.24795>:
      {
        int freq;

        freq = 0;
        inited = 1;
        D.24797 = *rtc_freq;
        if (D.24797 != 0) goto <D.24798>; else goto <D.24799>;
        <D.24798>:
        freq = atoi (rtc_freq);
        <D.24799>:
        if (freq == 0) goto <D.24800>; else goto <D.24801>;
        <D.24800>:
        freq = 1024;
        <D.24801>:
        rtc_fd.14 = open ("/dev/rtc", 0);
        rtc_fd = rtc_fd.14;
        rtc_fd.15 = rtc_fd;
        if (rtc_fd.15 == -1) goto <D.24804>; else goto <D.24805>;
        <D.24804>:
        perror ("open /dev/rtc");
        return;
        <D.24805>:
        add_signal_handler (27, sigprof_signal_handler);
        rtc_fd.15 = rtc_fd;
        D.24806 = ioctl (rtc_fd.15, 1074032652, freq);
        if (D.24806 == -1) goto <D.24807>; else goto <D.24808>;
        <D.24807>:
        perror ("set rtc freq");
        return;
        <D.24808>:
        rtc_fd.15 = rtc_fd;
        D.24809 = ioctl (rtc_fd.15, 28677, 0);
        if (D.24809 == -1) goto <D.24810>; else goto <D.24811>;
        <D.24810>:
        perror ("start rtc");
        return;
        <D.24811>:
        rtc_fd.15 = rtc_fd;
        D.24812 = fcntl (rtc_fd.15, 10, 27);
        if (D.24812 == -1) goto <D.24813>; else goto <D.24814>;
        <D.24813>:
        perror ("setsig");
        return;
        <D.24814>:
        D.24815 = getpid ();
        rtc_fd.15 = rtc_fd;
        D.24816 = fcntl (rtc_fd.15, 8, D.24815);
        if (D.24816 == -1) goto <D.24817>; else goto <D.24818>;
        <D.24817>:
        perror ("setown");
        return;
        <D.24818>:
        enable_rtc_timer (1);
        return;
      }
      <D.24796>:
      <D.24794>:
      rtc_fd.15 = rtc_fd;
      if (rtc_fd.15 >= 0) goto <D.24819>; else goto <D.24820>;
      <D.24819>:
      return;
      <D.24820>:
      itval.it_interval.tv_usec = 999;
      itval.it_interval.tv_sec = 0;
      itval.it_value = itval.it_interval;
      setitimer (2, &itval, 0B);
      inited.13 = inited;
      if (inited.13 != 0) goto <D.24821>; else goto <D.24822>;
      <D.24821>:
      return;
      <D.24822>:
      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.24828;
  unsigned int mono_jit_tls_id.16;
  int D.24831;
  int D.24832;
  sizetype D.24833;
  sizetype D.24834;
  bitsizetype D.24835;
  bitsizetype D.24836;
  sizetype D.24837;
  guchar *[0:D.24833] * ips.17;
  int D.24839;
  guchar * D.24840;
  int D.24845;
  int D.24846;
  void * D.24847;
  _Bool D.24848;
  _Bool D.24849;
  _Bool D.24850;
  int D.24858;
  guchar * D.24859;
  _Bool D.24860;
  _Bool D.24861;
  guchar * * D.24862;
  void * saved_stack.18;
  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.24826>; else goto <D.24827>;
  <D.24826>:
  D.24828 = mono_arch_ip_from_context (ctx);
  mono_profiler_stat_hit (D.24828, ctx);
  goto <D.24829>;
  <D.24827>:
  {
    struct MonoJitTlsData * jit_tls;
    int current_frame_index;
    struct MonoContext mono_context;
    guchar * ips[0:D.24833] [value-expr: *ips.17];

    saved_stack.18 = __builtin_stack_save ();
    try
      {
        mono_jit_tls_id.16 = mono_jit_tls_id;
        jit_tls = pthread_getspecific (mono_jit_tls_id.16);
        current_frame_index = 1;
        D.24831 = call_chain_depth + 1;
        D.24832 = D.24831 + -1;
        D.24833 = (sizetype) D.24832;
        D.24834 = (sizetype) D.24831;
        D.24835 = (bitsizetype) D.24834;
        D.24836 = D.24835 * 32;
        D.24834 = (sizetype) D.24831;
        D.24837 = D.24834 * 4;
        D.24834 = (sizetype) D.24831;
        D.24835 = (bitsizetype) D.24834;
        D.24836 = D.24835 * 32;
        D.24834 = (sizetype) D.24831;
        D.24837 = D.24834 * 4;
        ips.17 = __builtin_alloca_with_align (D.24837, 32);
        mono_arch_sigctx_to_monoctx (ctx, &mono_context);
        D.24839 = mono_context.eip;
        D.24840 = (guchar *) D.24839;
        *ips.17[0] = D.24840;
        if (jit_tls != 0B) goto <D.24841>; else goto <D.24842>;
        <D.24841>:
        if (call_chain_strategy == 1) goto <D.24843>; else goto <D.24844>;
        <D.24843>:
        {
          guchar * current_frame;
          guchar * stack_bottom;
          guchar * stack_top;

          stack_bottom = jit_tls->end_of_stack;
          D.24845 = mono_context.esp;
          stack_top = (guchar *) D.24845;
          D.24846 = mono_context.ebp;
          current_frame = (guchar *) D.24846;
          goto <D.24312>;
          <D.24311>:
          D.24847 = MEM[(void * *)current_frame + 4B];
          *ips.17[current_frame_index] = D.24847;
          current_frame_index = current_frame_index + 1;
          stack_top = current_frame;
          current_frame = MEM[(void * *)current_frame];
          <D.24312>:
          D.24848 = current_frame_index <= call_chain_depth;
          D.24849 = stack_bottom > current_frame;
          D.24850 = D.24848 & D.24849;
          if (D.24850 != 0) goto <D.24851>; else goto <D.24313>;
          <D.24851>:
          if (current_frame > stack_top) goto <D.24311>; else goto <D.24313>;
          <D.24313>:
        }
        <D.24844>:
        if (call_chain_strategy == 2) goto <D.24852>; else goto <D.24853>;
        <D.24852>:
        call_chain_strategy = 3;
        <D.24853>:
        if (call_chain_strategy == 3) goto <D.24854>; else goto <D.24855>;
        <D.24854>:
        {
          struct MonoDomain * domain;

          domain = mono_domain_get ();
          if (domain != 0B) goto <D.24856>; else goto <D.24857>;
          <D.24856>:
          {
            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.24321>;
                <D.24320>:
                D.24858 = new_mono_context.eip;
                D.24859 = (guchar *) D.24858;
                *ips.17[current_frame_index] = D.24859;
                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.24321>:
                D.24860 = ji != 0B;
                D.24848 = current_frame_index <= call_chain_depth;
                D.24861 = D.24860 & D.24848;
                if (D.24861 != 0) goto <D.24320>; else goto <D.24322>;
                <D.24322>:
              }
            finally
              {
                lmf = {CLOBBER};
                res = {CLOBBER};
                new_mono_context = {CLOBBER};
                native_offset = {CLOBBER};
              }
          }
          <D.24857>:
        }
        <D.24855>:
        <D.24842>:
        D.24862 = &*ips.17[0];
        mono_profiler_stat_call_chain (current_frame_index, D.24862, ctx);
      }
    finally
      {
        __builtin_stack_restore (saved_stack.18);
        mono_context = {CLOBBER};
      }
  }
  <D.24829>:
  mono_chain_signal (_dummy, info, context);
}


atoi (const char * __nptr)
{
  int D.24864;

  D.24864 = strtol (__nptr, 0B, 10);
  return D.24864;
}


open (const char * __path, int __oflag)
{
  int D.24866;
  int D.24869;
  int D.24874;
  int D.24876;
  int D.24877;
  int D.24880;
  int D.24881;

  D.24866 = __builtin_va_arg_pack_len ();
  if (D.24866 > 1) goto <D.24867>; else goto <D.24868>;
  <D.24867>:
  __open_too_many_args ();
  <D.24868>:
  D.24869 = __builtin_constant_p (__oflag);
  if (D.24869 != 0) goto <D.24870>; else goto <D.24871>;
  <D.24870>:
  D.24874 = __oflag & 64;
  if (D.24874 != 0) goto <D.24872>; else goto <D.24875>;
  <D.24875>:
  D.24876 = __oflag & 4259840;
  if (D.24876 == 4259840) goto <D.24872>; else goto <D.24873>;
  <D.24872>:
  D.24877 = __builtin_va_arg_pack_len ();
  if (D.24877 <= 0) goto <D.24878>; else goto <D.24879>;
  <D.24878>:
  __open_missing_mode ();
  D.24880 = __open_2 (__path, __oflag);
  return D.24880;
  <D.24879>:
  <D.24873>:
  D.24880 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.24880;
  <D.24871>:
  D.24881 = __builtin_va_arg_pack_len ();
  if (D.24881 <= 0) goto <D.24882>; else goto <D.24883>;
  <D.24882>:
  D.24880 = __open_2 (__path, __oflag);
  return D.24880;
  <D.24883>:
  D.24880 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.24880;
}


mono_runtime_syscall_fork ()
{
  pid_t D.24885;

  D.24885 = syscall (2);
  return D.24885;
}


mono_gdb_render_native_backtraces (pid_t crashed_pid)
{
  gchar * D.24887;
  const char * D.24888;
  gchar * D.24891;
  int D.24896;
  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.24887 = monoeg_g_find_program_in_path ("gdb");
      argv[0] = D.24887;
      D.24888 = argv[0];
      if (D.24888 == 0B) goto <D.24889>; else goto <D.24890>;
      <D.24889>:
      D.24891 = monoeg_g_find_program_in_path ("lldb");
      argv[0] = D.24891;
      using_lldb = 1;
      <D.24890>:
      D.24888 = argv[0];
      if (D.24888 == 0B) goto <D.24892>; else goto <D.24893>;
      <D.24892>:
      return;
      <D.24893>:
      if (using_lldb != 0) goto <D.24894>; else goto <D.24895>;
      <D.24894>:
      D.24896 = mkstemp (&template);
      if (D.24896 == -1) goto <D.24897>; else goto <D.24898>;
      <D.24897>:
      return;
      <D.24898>:
      commands = fopen (&template, "w");
      fprintf (commands, "process attach --pid %ld\n", crashed_pid);
      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.24899>;
      <D.24895>:
      argv[1] = "-ex";
      sprintf (&buf1, "attach %ld", crashed_pid);
      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.24899>:
      D.24888 = argv[0];
      execv (D.24888, &argv);
      if (using_lldb != 0) goto <D.24900>; else goto <D.24901>;
      <D.24900>:
      unlink (&template);
      <D.24901>:
    }
  finally
    {
      argv = {CLOBBER};
      template = {CLOBBER};
      buf1 = {CLOBBER};
    }
}


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

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


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.24907;
  unsigned int D.24908;

  D.24908 = __builtin_object_size (__s, 1);
  D.24907 = __builtin___sprintf_chk (__s, 1, D.24908, __fmt, __builtin_va_arg_pack ());
  return D.24907;
}


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

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