mono_chain_signal (int _dummy, struct siginfo_t * info, void * context)
{
  void (*<T40d>) (int) D.25133;
  int D.25136;
  int D.25137;
  void (*<T451>) (int, struct siginfo_t *, void *) D.25141;
  gboolean D.25142;
  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.25131>; else goto <D.25132>;
  <D.25131>:
  D.25133 = saved_handler->__sigaction_handler.sa_handler;
  if (D.25133 != 0B) goto <D.25134>; else goto <D.25135>;
  <D.25134>:
  D.25136 = saved_handler->sa_flags;
  D.25137 = D.25136 & 4;
  if (D.25137 == 0) goto <D.25138>; else goto <D.25139>;
  <D.25138>:
  D.25133 = saved_handler->__sigaction_handler.sa_handler;
  D.25133 (signal);
  goto <D.25140>;
  <D.25139>:
  D.25141 = saved_handler->__sigaction_handler.sa_sigaction;
  D.25141 (signal, info, ctx);
  <D.25140>:
  D.25142 = 1;
  return D.25142;
  <D.25135>:
  <D.25132>:
  D.25142 = 0;
  return D.25142;
}


get_saved_signal_handler (int signo)
{
  struct GHashTable * mono_saved_signal_handlers.0;
  void * D.25147;
  long int D.25148;
  const void * D.25149;

  mono_saved_signal_handlers.0 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.0 != 0B) goto <D.25145>; else goto <D.25146>;
  <D.25145>:
  mono_saved_signal_handlers.0 = mono_saved_signal_handlers;
  D.25148 = (long int) signo;
  D.25149 = (const void *) D.25148;
  D.25147 = monoeg_g_hash_table_lookup (mono_saved_signal_handlers.0, D.25149);
  return D.25147;
  <D.25146>:
  D.25147 = 0B;
  return D.25147;
}


mono_runtime_posix_install_handlers ()
{
  struct MonoDebugOptions * D.25151;
  int D.25152;
  struct MonoTraceSpec * mono_jit_trace_calls.1;
  int D.25158;
  int D.25161;
  int D.25162;
  struct sigset_t signal_set;

  try
    {
      D.25151 = mini_get_debug_options ();
      D.25152 = D.25151->handle_sigint;
      if (D.25152 != 0) goto <D.25153>; else goto <D.25154>;
      <D.25153>:
      add_signal_handler (2, mono_sigint_signal_handler);
      <D.25154>:
      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.25156>; else goto <D.25157>;
      <D.25156>:
      add_signal_handler (12, sigusr2_signal_handler);
      <D.25157>:
      D.25158 = mono_thread_info_new_interrupt_enabled ();
      if (D.25158 == 0) goto <D.25159>; else goto <D.25160>;
      <D.25159>:
      D.25161 = mono_thread_get_abort_signal ();
      add_signal_handler (D.25161, sigusr1_signal_handler);
      <D.25160>:
      sigemptyset (&signal_set);
      D.25162 = mono_thread_get_abort_signal ();
      sigaddset (&signal_set, D.25162);
      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.25163;
  struct MonoDomain * D.25166;
  void * D.25167;
  int D.25170;
  struct MonoJitInfo * ji;
  void * ctx;

  ji = 0B;
  ctx = context;
  D.25163 = mono_thread_internal_current ();
  if (D.25163 != 0B) goto <D.25164>; else goto <D.25165>;
  <D.25164>:
  D.25166 = mono_domain_get ();
  D.25167 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.25166, D.25167);
  <D.25165>:
  if (ji == 0B) goto <D.25168>; else goto <D.25169>;
  <D.25168>:
  D.25170 = mono_chain_signal (_dummy, info, context);
  if (D.25170 != 0) goto <D.25171>; else goto <D.25172>;
  <D.25171>:
  return;
  <D.25172>:
  mono_handle_native_sigsegv (6, ctx);
  <D.25169>:
}


sigusr1_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  int D.25177;
  unsigned char D.25180;
  struct MonoDomain * D.25185;
  void * D.25186;
  _Bool D.25187;
  int D.25188;
  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;
  if (thread == 0B) goto <D.25174>; else goto <D.25176>;
  <D.25176>:
  if (domain == 0B) goto <D.25174>; else goto <D.25175>;
  <D.25174>:
  mono_debugger_agent_thread_interrupt (ctx, 0B);
  return;
  <D.25175>:
  D.25177 = thread->ignore_next_signal;
  if (D.25177 != 0) goto <D.25178>; else goto <D.25179>;
  <D.25178>:
  thread->ignore_next_signal = 0;
  return;
  <D.25179>:
  D.25180 = thread->thread_dump_requested;
  if (D.25180 != 0) goto <D.25181>; else goto <D.25182>;
  <D.25181>:
  thread->thread_dump_requested = 0;
  mono_print_thread_dump (ctx);
  <D.25182>:
  if (ctx != 0B) goto <D.25183>; else goto <D.25184>;
  <D.25183>:
  D.25185 = mono_domain_get ();
  D.25186 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.25185, D.25186);
  D.25187 = ji != 0B;
  running_managed = (gboolean) D.25187;
  D.25188 = mono_debugger_agent_thread_interrupt (ctx, ji);
  if (D.25188 != 0) goto <D.25189>; else goto <D.25190>;
  <D.25189>:
  return;
  <D.25190>:
  goto <D.25191>;
  <D.25184>:
  running_managed = 0;
  <D.25191>:
  exc = mono_thread_request_interruption (running_managed);
  if (exc == 0B) goto <D.25192>; else goto <D.25193>;
  <D.25192>:
  return;
  <D.25193>:
  mono_arch_handle_exception (ctx, exc);
}


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

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


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

  ctx = context;
  res = mono_attach_start ();
  if (res != 0) goto <D.25197>; else goto <D.25198>;
  <D.25197>:
  return;
  <D.25198>:
  D.25199 = mono_thread_info_new_interrupt_enabled ();
  if (D.25199 != 0) goto <D.25200>; else goto <D.25201>;
  <D.25200>:
  mono_threads_request_thread_dump ();
  goto <D.25202>;
  <D.25201>:
  printf ("Full thread dump:\n");
  mono_threads_request_thread_dump ();
  mono_print_thread_dump (ctx);
  <D.25202>:
  mono_chain_signal (_dummy, info, context);
}


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

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


add_signal_handler (int signo, void * handler)
{
  void (*<T451>) (int, struct siginfo_t *, void *) handler.2;
  int D.25209;
  int D.25210;
  _Bool D.25211;
  long int D.25212;
  long int D.25213;
  int D.25218;
  int D.25219;
  void (*<T40d>) (int) D.25221;
  int mono_do_signal_chaining.3;
  struct sigaction sa;
  struct sigaction previous_sa;

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

        try
          {
            sigemptyset (&block_mask);
            D.25209 = mono_thread_get_abort_signal ();
            sigaddset (&sa.sa_mask, D.25209);
          }
        finally
          {
            block_mask = {CLOBBER};
          }
      }
      <D.25208>:
      D.25210 = sigaction (signo, &sa, &previous_sa);
      D.25211 = D.25210 == -1;
      D.25212 = (long int) D.25211;
      D.25213 = __builtin_expect (D.25212, 0);
      if (D.25213 != 0) goto <D.25214>; else goto <D.25215>;
      <D.25214>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 471, "sigaction (signo, &sa, &previous_sa) != -1");
      <D.25215>:
      D.25218 = previous_sa.sa_flags;
      D.25219 = D.25218 & 4;
      if (D.25219 == 0) goto <D.25220>; else goto <D.25216>;
      <D.25220>:
      D.25221 = previous_sa.__sigaction_handler.sa_handler;
      if (D.25221 == 0B) goto <D.25222>; else goto <D.25216>;
      <D.25222>:
      goto <D.25217>;
      <D.25216>:
      mono_do_signal_chaining.3 = mono_do_signal_chaining;
      if (mono_do_signal_chaining.3 != 0) goto <D.25224>; else goto <D.25225>;
      <D.25224>:
      save_old_signal_handler (signo, &previous_sa);
      <D.25225>:
      <D.25217>:
    }
  finally
    {
      sa = {CLOBBER};
      previous_sa = {CLOBBER};
    }
}


save_old_signal_handler (int signo, struct sigaction * old_action)
{
  int D.25226;
  int D.25227;
  void (*<T40d>) (int) D.25230;
  void (*<T451>) (int, struct siginfo_t *, void *) D.25232;
  struct GHashTable * mono_saved_signal_handlers.4;
  struct GHashTable * mono_saved_signal_handlers.5;
  long int D.25237;
  void * D.25238;
  struct sigaction * handler_to_save;

  handler_to_save = monoeg_malloc (152);
  mono_trace (128, 16, "Saving old signal handler for signal %d.", signo);
  D.25226 = old_action->sa_flags;
  D.25227 = D.25226 & 4;
  if (D.25227 == 0) goto <D.25228>; else goto <D.25229>;
  <D.25228>:
  D.25230 = old_action->__sigaction_handler.sa_handler;
  handler_to_save->__sigaction_handler.sa_handler = D.25230;
  goto <D.25231>;
  <D.25229>:
  D.25232 = old_action->__sigaction_handler.sa_sigaction;
  handler_to_save->__sigaction_handler.sa_sigaction = D.25232;
  <D.25231>:
  handler_to_save->sa_mask = old_action->sa_mask;
  D.25226 = old_action->sa_flags;
  handler_to_save->sa_flags = D.25226;
  mono_saved_signal_handlers.4 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.4 == 0B) goto <D.25234>; else goto <D.25235>;
  <D.25234>:
  mono_saved_signal_handlers.5 = monoeg_g_hash_table_new (0B, 0B);
  mono_saved_signal_handlers = mono_saved_signal_handlers.5;
  <D.25235>:
  mono_saved_signal_handlers.4 = mono_saved_signal_handlers;
  D.25237 = (long int) signo;
  D.25238 = (void *) D.25237;
  monoeg_g_hash_table_insert_replace (mono_saved_signal_handlers.4, D.25238, handler_to_save, 0);
}


mono_runtime_install_handlers ()
{
  mono_runtime_posix_install_handlers ();
}


mono_runtime_cleanup_handlers ()
{
  struct MonoDebugOptions * D.25239;
  int D.25240;
  struct MonoTraceSpec * mono_jit_trace_calls.6;
  int D.25246;

  D.25239 = mini_get_debug_options ();
  D.25240 = D.25239->handle_sigint;
  if (D.25240 != 0) goto <D.25241>; else goto <D.25242>;
  <D.25241>:
  remove_signal_handler (2);
  <D.25242>:
  remove_signal_handler (8);
  remove_signal_handler (3);
  remove_signal_handler (4);
  remove_signal_handler (7);
  mono_jit_trace_calls.6 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.6 != 0B) goto <D.25244>; else goto <D.25245>;
  <D.25244>:
  remove_signal_handler (12);
  <D.25245>:
  D.25246 = mono_thread_get_abort_signal ();
  remove_signal_handler (D.25246);
  remove_signal_handler (6);
  remove_signal_handler (11);
  free_saved_signal_handlers ();
}


remove_signal_handler (int signo)
{
  int D.25250;
  _Bool D.25251;
  long int D.25252;
  long int D.25253;
  struct sigaction sa;
  struct sigaction * saved_action;

  try
    {
      saved_action = get_saved_signal_handler (signo);
      if (saved_action == 0B) goto <D.25247>; else goto <D.25248>;
      <D.25247>:
      sa.__sigaction_handler.sa_handler = 0B;
      sigemptyset (&sa.sa_mask);
      sa.sa_flags = 0;
      sigaction (signo, &sa, 0B);
      goto <D.25249>;
      <D.25248>:
      D.25250 = sigaction (signo, saved_action, 0B);
      D.25251 = D.25250 == -1;
      D.25252 = (long int) D.25251;
      D.25253 = __builtin_expect (D.25252, 0);
      if (D.25253 != 0) goto <D.25254>; else goto <D.25255>;
      <D.25254>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 496, "sigaction (signo, saved_action, NULL) != -1");
      <D.25255>:
      <D.25249>:
    }
  finally
    {
      sa = {CLOBBER};
    }
}


free_saved_signal_handlers ()
{
  struct GHashTable * mono_saved_signal_handlers.7;

  mono_saved_signal_handlers.7 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.7 != 0B) goto <D.25257>; else goto <D.25258>;
  <D.25257>:
  mono_saved_signal_handlers.7 = mono_saved_signal_handlers;
  monoeg_g_hash_table_foreach (mono_saved_signal_handlers.7, free_saved_sig_handler_func, 0B);
  mono_saved_signal_handlers.7 = mono_saved_signal_handlers;
  monoeg_g_hash_table_destroy (mono_saved_signal_handlers.7);
  mono_saved_signal_handlers = 0B;
  <D.25258>:
}


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


mono_runtime_shutdown_stat_profiler ()
{
  int rtc_fd.8;

  rtc_fd.8 = rtc_fd;
  if (rtc_fd.8 >= 0) goto <D.25260>; else goto <D.25261>;
  <D.25260>:
  enable_rtc_timer (0);
  <D.25261>:
}


enable_rtc_timer (gboolean enable)
{
  int rtc_fd.9;
  int D.25265;
  int D.25269;
  int flags;

  rtc_fd.9 = rtc_fd;
  flags = fcntl (rtc_fd.9, 3);
  if (flags < 0) goto <D.25263>; else goto <D.25264>;
  <D.25263>:
  perror ("getflags");
  D.25265 = 0;
  return D.25265;
  <D.25264>:
  if (enable != 0) goto <D.25266>; else goto <D.25267>;
  <D.25266>:
  flags = flags | 8192;
  goto <D.25268>;
  <D.25267>:
  flags = flags & -8193;
  <D.25268>:
  rtc_fd.9 = rtc_fd;
  D.25269 = fcntl (rtc_fd.9, 4, flags);
  if (D.25269 == -1) goto <D.25270>; else goto <D.25271>;
  <D.25270>:
  perror ("setflags");
  D.25265 = 0;
  return D.25265;
  <D.25271>:
  D.25265 = 1;
  return D.25265;
}


mono_runtime_setup_stat_profiler ()
{
  int inited.10;
  char D.25278;
  int rtc_fd.11;
  int rtc_fd.12;
  int D.25287;
  int D.25290;
  int D.25293;
  int D.25296;
  int D.25297;
  struct itimerval itval;
  static int inited = 0;
  const char * rtc_freq;

  try
    {
      inited.10 = inited;
      if (inited.10 == 0) goto <D.25274>; else goto <D.25275>;
      <D.25274>:
      rtc_freq = monoeg_g_getenv ("MONO_RTC");
      if (rtc_freq != 0B) goto <D.25276>; else goto <D.25277>;
      <D.25276>:
      {
        int freq;

        freq = 0;
        inited = 1;
        D.25278 = *rtc_freq;
        if (D.25278 != 0) goto <D.25279>; else goto <D.25280>;
        <D.25279>:
        freq = atoi (rtc_freq);
        <D.25280>:
        if (freq == 0) goto <D.25281>; else goto <D.25282>;
        <D.25281>:
        freq = 1024;
        <D.25282>:
        rtc_fd.11 = open ("/dev/rtc", 0);
        rtc_fd = rtc_fd.11;
        rtc_fd.12 = rtc_fd;
        if (rtc_fd.12 == -1) goto <D.25285>; else goto <D.25286>;
        <D.25285>:
        perror ("open /dev/rtc");
        return;
        <D.25286>:
        add_signal_handler (27, sigprof_signal_handler);
        rtc_fd.12 = rtc_fd;
        D.25287 = ioctl (rtc_fd.12, 2148036620, freq);
        if (D.25287 == -1) goto <D.25288>; else goto <D.25289>;
        <D.25288>:
        perror ("set rtc freq");
        return;
        <D.25289>:
        rtc_fd.12 = rtc_fd;
        D.25290 = ioctl (rtc_fd.12, 536899589, 0);
        if (D.25290 == -1) goto <D.25291>; else goto <D.25292>;
        <D.25291>:
        perror ("start rtc");
        return;
        <D.25292>:
        rtc_fd.12 = rtc_fd;
        D.25293 = fcntl (rtc_fd.12, 10, 27);
        if (D.25293 == -1) goto <D.25294>; else goto <D.25295>;
        <D.25294>:
        perror ("setsig");
        return;
        <D.25295>:
        rtc_fd.12 = rtc_fd;
        D.25296 = getpid ();
        D.25297 = fcntl (rtc_fd.12, 8, D.25296);
        if (D.25297 == -1) goto <D.25298>; else goto <D.25299>;
        <D.25298>:
        perror ("setown");
        return;
        <D.25299>:
        enable_rtc_timer (1);
        return;
      }
      <D.25277>:
      <D.25275>:
      rtc_fd.12 = rtc_fd;
      if (rtc_fd.12 >= 0) goto <D.25300>; else goto <D.25301>;
      <D.25300>:
      return;
      <D.25301>:
      itval.it_interval.tv_usec = 999;
      itval.it_interval.tv_sec = 0;
      itval.it_value = itval.it_interval;
      setitimer (2, &itval, 0B);
      inited.10 = inited;
      if (inited.10 != 0) goto <D.25302>; else goto <D.25303>;
      <D.25302>:
      return;
      <D.25303>:
      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.25309;
  unsigned int mono_jit_tls_id.13;
  int D.25312;
  long int D.25313;
  long int D.25314;
  sizetype D.25315;
  sizetype D.25316;
  bitsizetype D.25317;
  bitsizetype D.25318;
  sizetype D.25319;
  guchar *[0:D.25315] * ips.14;
  long unsigned int D.25321;
  guchar * D.25322;
  long unsigned int D.25333;
  guchar * D.25334;
  guchar * * D.25336;
  void * saved_stack.15;
  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.25307>; else goto <D.25308>;
  <D.25307>:
  D.25309 = mono_arch_ip_from_context (ctx);
  mono_profiler_stat_hit (D.25309, ctx);
  goto <D.25310>;
  <D.25308>:
  {
    struct MonoJitTlsData * jit_tls;
    int current_frame_index;
    struct MonoContext mono_context;
    guchar * ips[0:D.25315] [value-expr: *ips.14];

    saved_stack.15 = __builtin_stack_save ();
    try
      {
        mono_jit_tls_id.13 = mono_jit_tls_id;
        jit_tls = pthread_getspecific (mono_jit_tls_id.13);
        current_frame_index = 1;
        D.25312 = call_chain_depth + 1;
        D.25313 = (long int) D.25312;
        D.25314 = D.25313 + -1;
        D.25315 = (sizetype) D.25314;
        D.25316 = (sizetype) D.25312;
        D.25317 = (bitsizetype) D.25316;
        D.25318 = D.25317 * 64;
        D.25316 = (sizetype) D.25312;
        D.25319 = D.25316 * 8;
        D.25316 = (sizetype) D.25312;
        D.25317 = (bitsizetype) D.25316;
        D.25318 = D.25317 * 64;
        D.25316 = (sizetype) D.25312;
        D.25319 = D.25316 * 8;
        ips.14 = __builtin_alloca_with_align (D.25319, 64);
        mono_arch_sigctx_to_monoctx (ctx, &mono_context);
        D.25321 = mono_context.sc_ir;
        D.25322 = (guchar *) D.25321;
        *ips.14[0] = D.25322;
        if (jit_tls != 0B) goto <D.25323>; else goto <D.25324>;
        <D.25323>:
        if (call_chain_strategy == 1) goto <D.25325>; else goto <D.25326>;
        <D.25325>:
        call_chain_strategy = 2;
        <D.25326>:
        if (call_chain_strategy == 2) goto <D.25327>; else goto <D.25328>;
        <D.25327>:
        call_chain_strategy = 3;
        <D.25328>:
        if (call_chain_strategy == 3) goto <D.25329>; else goto <D.25330>;
        <D.25329>:
        {
          struct MonoDomain * domain;

          domain = mono_domain_get ();
          if (domain != 0B) goto <D.25331>; else goto <D.25332>;
          <D.25331>:
          {
            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.24746>;
                <D.24745>:
                D.25333 = new_mono_context.sc_ir;
                D.25334 = (guchar *) D.25333;
                *ips.14[current_frame_index] = D.25334;
                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.24746>:
                if (ji != 0B) goto <D.25335>; else goto <D.24747>;
                <D.25335>:
                if (current_frame_index <= call_chain_depth) goto <D.24745>; else goto <D.24747>;
                <D.24747>:
              }
            finally
              {
                lmf = {CLOBBER};
                res = {CLOBBER};
                new_mono_context = {CLOBBER};
                native_offset = {CLOBBER};
              }
          }
          <D.25332>:
        }
        <D.25330>:
        <D.25324>:
        D.25336 = &*ips.14[0];
        mono_profiler_stat_call_chain (current_frame_index, D.25336, ctx);
      }
    finally
      {
        __builtin_stack_restore (saved_stack.15);
        mono_context = {CLOBBER};
      }
  }
  <D.25310>:
  mono_chain_signal (_dummy, info, context);
}


atoi (const char * __nptr)
{
  int D.25338;
  long int D.25339;

  D.25339 = strtol (__nptr, 0B, 10);
  D.25338 = (int) D.25339;
  return D.25338;
}


open (const char * __path, int __oflag)
{
  int D.25341;
  int D.25344;
  int D.25349;
  int D.25351;
  int D.25352;
  int D.25355;
  int D.25356;

  D.25341 = __builtin_va_arg_pack_len ();
  if (D.25341 > 1) goto <D.25342>; else goto <D.25343>;
  <D.25342>:
  __open_too_many_args ();
  <D.25343>:
  D.25344 = __builtin_constant_p (__oflag);
  if (D.25344 != 0) goto <D.25345>; else goto <D.25346>;
  <D.25345>:
  D.25349 = __oflag & 64;
  if (D.25349 != 0) goto <D.25347>; else goto <D.25350>;
  <D.25350>:
  D.25351 = __oflag & 4259840;
  if (D.25351 == 4259840) goto <D.25347>; else goto <D.25348>;
  <D.25347>:
  D.25352 = __builtin_va_arg_pack_len ();
  if (D.25352 <= 0) goto <D.25353>; else goto <D.25354>;
  <D.25353>:
  __open_missing_mode ();
  D.25355 = __open_2 (__path, __oflag);
  return D.25355;
  <D.25354>:
  <D.25348>:
  D.25355 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.25355;
  <D.25346>:
  D.25356 = __builtin_va_arg_pack_len ();
  if (D.25356 <= 0) goto <D.25357>; else goto <D.25358>;
  <D.25357>:
  D.25355 = __open_2 (__path, __oflag);
  return D.25355;
  <D.25358>:
  D.25355 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.25355;
}


mono_runtime_syscall_fork ()
{
  pid_t D.25360;
  long int D.25361;

  D.25361 = syscall (2);
  D.25360 = (pid_t) D.25361;
  return D.25360;
}


mono_gdb_render_native_backtraces (pid_t crashed_pid)
{
  gchar * D.25363;
  const char * D.25364;
  gchar * D.25367;
  int D.25372;
  long int D.25375;
  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.25363 = monoeg_g_find_program_in_path ("gdb");
      argv[0] = D.25363;
      D.25364 = argv[0];
      if (D.25364 == 0B) goto <D.25365>; else goto <D.25366>;
      <D.25365>:
      D.25367 = monoeg_g_find_program_in_path ("lldb");
      argv[0] = D.25367;
      using_lldb = 1;
      <D.25366>:
      D.25364 = argv[0];
      if (D.25364 == 0B) goto <D.25368>; else goto <D.25369>;
      <D.25368>:
      return;
      <D.25369>:
      if (using_lldb != 0) goto <D.25370>; else goto <D.25371>;
      <D.25370>:
      D.25372 = mkstemp (&template);
      if (D.25372 == -1) goto <D.25373>; else goto <D.25374>;
      <D.25373>:
      return;
      <D.25374>:
      commands = fopen (&template, "w");
      D.25375 = (long int) crashed_pid;
      fprintf (commands, "process attach --pid %ld\n", D.25375);
      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.25376>;
      <D.25371>:
      argv[1] = "-ex";
      D.25375 = (long int) crashed_pid;
      sprintf (&buf1, "attach %ld", D.25375);
      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.25376>:
      D.25364 = argv[0];
      execv (D.25364, &argv);
      if (using_lldb != 0) goto <D.25377>; else goto <D.25378>;
      <D.25377>:
      unlink (&template);
      <D.25378>:
    }
  finally
    {
      argv = {CLOBBER};
      template = {CLOBBER};
      buf1 = {CLOBBER};
    }
}


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

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


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

  D.25385 = __builtin_object_size (__s, 1);
  D.25384 = __builtin___sprintf_chk (__s, 1, D.25385, __fmt, __builtin_va_arg_pack ());
  return D.25384;
}


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

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