mono_chain_signal (int _dummy, struct siginfo_t * info, void * context)
{
  void (*<Tdc6>) (int) D.27280;
  int D.27283;
  int D.27284;
  void (*<Te09>) (int, struct siginfo_t *, void *) D.27288;
  gboolean D.27289;
  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.27278>; else goto <D.27279>;
  <D.27278>:
  D.27280 = saved_handler->__sigaction_handler.sa_handler;
  if (D.27280 != 0B) goto <D.27281>; else goto <D.27282>;
  <D.27281>:
  D.27283 = saved_handler->sa_flags;
  D.27284 = D.27283 & 4;
  if (D.27284 == 0) goto <D.27285>; else goto <D.27286>;
  <D.27285>:
  D.27280 = saved_handler->__sigaction_handler.sa_handler;
  D.27280 (signal);
  goto <D.27287>;
  <D.27286>:
  D.27288 = saved_handler->__sigaction_handler.sa_sigaction;
  D.27288 (signal, info, ctx);
  <D.27287>:
  D.27289 = 1;
  return D.27289;
  <D.27282>:
  <D.27279>:
  D.27289 = 0;
  return D.27289;
}


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

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


mono_runtime_posix_install_handlers ()
{
  struct MonoDebugOptions * D.27297;
  int D.27298;
  struct MonoTraceSpec * mono_jit_trace_calls.2;
  int D.27304;
  int D.27307;
  int D.27308;
  struct sigset_t signal_set;

  try
    {
      D.27297 = mini_get_debug_options ();
      D.27298 = D.27297->handle_sigint;
      if (D.27298 != 0) goto <D.27299>; else goto <D.27300>;
      <D.27299>:
      add_signal_handler (2, mono_sigint_signal_handler);
      <D.27300>:
      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.27302>; else goto <D.27303>;
      <D.27302>:
      add_signal_handler (12, sigusr2_signal_handler);
      <D.27303>:
      D.27304 = mono_thread_info_new_interrupt_enabled ();
      if (D.27304 == 0) goto <D.27305>; else goto <D.27306>;
      <D.27305>:
      D.27307 = mono_thread_get_abort_signal ();
      add_signal_handler (D.27307, sigusr1_signal_handler);
      <D.27306>:
      sigemptyset (&signal_set);
      D.27308 = mono_thread_get_abort_signal ();
      sigaddset (&signal_set, D.27308);
      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.27309;
  struct MonoDomain * D.27312;
  void * D.27313;
  int D.27316;
  struct MonoJitInfo * ji;
  void * ctx;

  ji = 0B;
  ctx = context;
  D.27309 = mono_thread_internal_current ();
  if (D.27309 != 0B) goto <D.27310>; else goto <D.27311>;
  <D.27310>:
  D.27312 = mono_domain_get ();
  D.27313 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.27312, D.27313);
  <D.27311>:
  if (ji == 0B) goto <D.27314>; else goto <D.27315>;
  <D.27314>:
  D.27316 = mono_chain_signal (_dummy, info, context);
  if (D.27316 != 0) goto <D.27317>; else goto <D.27318>;
  <D.27317>:
  return;
  <D.27318>:
  mono_handle_native_sigsegv (6, ctx);
  <D.27315>:
}


sigusr1_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  _Bool D.27320;
  _Bool D.27321;
  _Bool D.27322;
  int D.27325;
  unsigned char D.27328;
  struct MonoDomain * D.27333;
  void * D.27334;
  _Bool D.27335;
  int D.27336;
  int mono_aot_only.3;
  int D.27345;
  int D.27348;
  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.27320 = thread == 0B;
  D.27321 = domain == 0B;
  D.27322 = D.27320 | D.27321;
  if (D.27322 != 0) goto <D.27323>; else goto <D.27324>;
  <D.27323>:
  mono_debugger_agent_thread_interrupt (ctx, 0B);
  return;
  <D.27324>:
  D.27325 = thread->ignore_next_signal;
  if (D.27325 != 0) goto <D.27326>; else goto <D.27327>;
  <D.27326>:
  thread->ignore_next_signal = 0;
  return;
  <D.27327>:
  D.27328 = thread->thread_dump_requested;
  if (D.27328 != 0) goto <D.27329>; else goto <D.27330>;
  <D.27329>:
  thread->thread_dump_requested = 0;
  mono_print_thread_dump (ctx);
  <D.27330>:
  if (ctx != 0B) goto <D.27331>; else goto <D.27332>;
  <D.27331>:
  D.27333 = mono_domain_get ();
  D.27334 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.27333, D.27334);
  D.27335 = ji != 0B;
  running_managed = (gboolean) D.27335;
  D.27336 = mono_debugger_agent_thread_interrupt (ctx, ji);
  if (D.27336 != 0) goto <D.27337>; else goto <D.27338>;
  <D.27337>:
  return;
  <D.27338>:
  goto <D.27339>;
  <D.27332>:
  running_managed = 0;
  <D.27339>:
  mono_aot_only.3 = mono_aot_only;
  if (mono_aot_only.3 == 0) goto <D.27341>; else goto <D.27342>;
  <D.27341>:
  if (ctx != 0B) goto <D.27343>; else goto <D.27344>;
  <D.27343>:
  {
    struct MonoThreadUnwindState unwind_state;

    try
      {
        D.27345 = mono_thread_state_init_from_sigctx (&unwind_state, ctx);
        if (D.27345 != 0) goto <D.27346>; else goto <D.27347>;
        <D.27346>:
        D.27348 = mono_install_handler_block_guard (&unwind_state);
        if (D.27348 != 0) goto <D.27349>; else goto <D.27350>;
        <D.27349>:
        wapi_clear_interruption ();
        return;
        <D.27350>:
        <D.27347>:
      }
    finally
      {
        unwind_state = {CLOBBER};
      }
  }
  <D.27344>:
  <D.27342>:
  exc = mono_thread_request_interruption (running_managed);
  if (exc == 0B) goto <D.27351>; else goto <D.27352>;
  <D.27351>:
  return;
  <D.27352>:
  mono_arch_handle_exception (ctx, exc);
}


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

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


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

  ctx = context;
  res = mono_attach_start ();
  if (res != 0) goto <D.27358>; else goto <D.27359>;
  <D.27358>:
  return;
  <D.27359>:
  D.27360 = mono_thread_info_new_interrupt_enabled ();
  if (D.27360 != 0) goto <D.27361>; else goto <D.27362>;
  <D.27361>:
  mono_threads_request_thread_dump ();
  goto <D.27363>;
  <D.27362>:
  printf ("Full thread dump:\n");
  mono_threads_request_thread_dump ();
  mono_print_thread_dump (ctx);
  <D.27363>:
  mono_chain_signal (_dummy, info, context);
}


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

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


add_signal_handler (int signo, void * handler)
{
  void (*<Te09>) (int, struct siginfo_t *, void *) handler.4;
  int D.27370;
  int D.27371;
  _Bool D.27372;
  long int D.27373;
  long int D.27374;
  int D.27379;
  int D.27380;
  void (*<Tdc6>) (int) D.27382;
  int mono_do_signal_chaining.5;
  struct sigaction sa;
  struct sigaction previous_sa;

  try
    {
      handler.4 = (void (*<Te09>) (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.27368>; else goto <D.27369>;
      <D.27368>:
      {
        struct sigset_t block_mask;

        try
          {
            sigemptyset (&block_mask);
            D.27370 = mono_thread_get_abort_signal ();
            sigaddset (&sa.sa_mask, D.27370);
          }
        finally
          {
            block_mask = {CLOBBER};
          }
      }
      <D.27369>:
      D.27371 = sigaction (signo, &sa, &previous_sa);
      D.27372 = D.27371 == -1;
      D.27373 = (long int) D.27372;
      D.27374 = __builtin_expect (D.27373, 0);
      if (D.27374 != 0) goto <D.27375>; else goto <D.27376>;
      <D.27375>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 471, "sigaction (signo, &sa, &previous_sa) != -1");
      <D.27376>:
      D.27379 = previous_sa.sa_flags;
      D.27380 = D.27379 & 4;
      if (D.27380 == 0) goto <D.27381>; else goto <D.27377>;
      <D.27381>:
      D.27382 = previous_sa.__sigaction_handler.sa_handler;
      if (D.27382 == 0B) goto <D.27383>; else goto <D.27377>;
      <D.27383>:
      goto <D.27378>;
      <D.27377>:
      mono_do_signal_chaining.5 = mono_do_signal_chaining;
      if (mono_do_signal_chaining.5 != 0) goto <D.27385>; else goto <D.27386>;
      <D.27385>:
      save_old_signal_handler (signo, &previous_sa);
      <D.27386>:
      <D.27378>:
    }
  finally
    {
      sa = {CLOBBER};
      previous_sa = {CLOBBER};
    }
}


save_old_signal_handler (int signo, struct sigaction * old_action)
{
  int D.27387;
  int D.27388;
  void (*<Tdc6>) (int) D.27391;
  void (*<Te09>) (int, struct siginfo_t *, void *) D.27393;
  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.27387 = old_action->sa_flags;
  D.27388 = D.27387 & 4;
  if (D.27388 == 0) goto <D.27389>; else goto <D.27390>;
  <D.27389>:
  D.27391 = old_action->__sigaction_handler.sa_handler;
  handler_to_save->__sigaction_handler.sa_handler = D.27391;
  goto <D.27392>;
  <D.27390>:
  D.27393 = old_action->__sigaction_handler.sa_sigaction;
  handler_to_save->__sigaction_handler.sa_sigaction = D.27393;
  <D.27392>:
  handler_to_save->sa_mask = old_action->sa_mask;
  D.27387 = old_action->sa_flags;
  handler_to_save->sa_flags = D.27387;
  mono_saved_signal_handlers.6 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.6 == 0B) goto <D.27395>; else goto <D.27396>;
  <D.27395>:
  mono_saved_signal_handlers.7 = monoeg_g_hash_table_new (0B, 0B);
  mono_saved_signal_handlers = mono_saved_signal_handlers.7;
  <D.27396>:
  mono_saved_signal_handlers.6 = mono_saved_signal_handlers;
  signo.8 = (void *) signo;
  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.27399;
  int D.27400;
  struct MonoTraceSpec * mono_jit_trace_calls.9;
  int D.27406;

  D.27399 = mini_get_debug_options ();
  D.27400 = D.27399->handle_sigint;
  if (D.27400 != 0) goto <D.27401>; else goto <D.27402>;
  <D.27401>:
  remove_signal_handler (2);
  <D.27402>:
  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.27404>; else goto <D.27405>;
  <D.27404>:
  remove_signal_handler (12);
  <D.27405>:
  D.27406 = mono_thread_get_abort_signal ();
  remove_signal_handler (D.27406);
  remove_signal_handler (6);
  remove_signal_handler (11);
  free_saved_signal_handlers ();
}


remove_signal_handler (int signo)
{
  int D.27410;
  _Bool D.27411;
  long int D.27412;
  long int D.27413;
  struct sigaction sa;
  struct sigaction * saved_action;

  try
    {
      saved_action = get_saved_signal_handler (signo);
      if (saved_action == 0B) goto <D.27407>; else goto <D.27408>;
      <D.27407>:
      sa.__sigaction_handler.sa_handler = 0B;
      sigemptyset (&sa.sa_mask);
      sa.sa_flags = 0;
      sigaction (signo, &sa, 0B);
      goto <D.27409>;
      <D.27408>:
      D.27410 = sigaction (signo, saved_action, 0B);
      D.27411 = D.27410 == -1;
      D.27412 = (long int) D.27411;
      D.27413 = __builtin_expect (D.27412, 0);
      if (D.27413 != 0) goto <D.27414>; else goto <D.27415>;
      <D.27414>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 496, "sigaction (signo, saved_action, NULL) != -1");
      <D.27415>:
      <D.27409>:
    }
  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.27417>; else goto <D.27418>;
  <D.27417>:
  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.27418>:
}


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.27420>; else goto <D.27421>;
  <D.27420>:
  enable_rtc_timer (0);
  <D.27421>:
}


enable_rtc_timer (gboolean enable)
{
  int rtc_fd.12;
  int D.27425;
  int D.27429;
  int flags;

  rtc_fd.12 = rtc_fd;
  flags = fcntl (rtc_fd.12, 3);
  if (flags < 0) goto <D.27423>; else goto <D.27424>;
  <D.27423>:
  perror ("getflags");
  D.27425 = 0;
  return D.27425;
  <D.27424>:
  if (enable != 0) goto <D.27426>; else goto <D.27427>;
  <D.27426>:
  flags = flags | 8192;
  goto <D.27428>;
  <D.27427>:
  flags = flags & -8193;
  <D.27428>:
  rtc_fd.12 = rtc_fd;
  D.27429 = fcntl (rtc_fd.12, 4, flags);
  if (D.27429 == -1) goto <D.27430>; else goto <D.27431>;
  <D.27430>:
  perror ("setflags");
  D.27425 = 0;
  return D.27425;
  <D.27431>:
  D.27425 = 1;
  return D.27425;
}


mono_runtime_setup_stat_profiler ()
{
  int inited.13;
  char D.27438;
  int rtc_fd.14;
  int rtc_fd.15;
  int D.27447;
  int D.27450;
  int D.27453;
  int D.27456;
  int D.27457;
  struct itimerval itval;
  static int inited = 0;
  const char * rtc_freq;

  try
    {
      inited.13 = inited;
      if (inited.13 == 0) goto <D.27434>; else goto <D.27435>;
      <D.27434>:
      rtc_freq = monoeg_g_getenv ("MONO_RTC");
      if (rtc_freq != 0B) goto <D.27436>; else goto <D.27437>;
      <D.27436>:
      {
        int freq;

        freq = 0;
        inited = 1;
        D.27438 = *rtc_freq;
        if (D.27438 != 0) goto <D.27439>; else goto <D.27440>;
        <D.27439>:
        freq = atoi (rtc_freq);
        <D.27440>:
        if (freq == 0) goto <D.27441>; else goto <D.27442>;
        <D.27441>:
        freq = 1024;
        <D.27442>:
        rtc_fd.14 = open ("/dev/rtc", 0);
        rtc_fd = rtc_fd.14;
        rtc_fd.15 = rtc_fd;
        if (rtc_fd.15 == -1) goto <D.27445>; else goto <D.27446>;
        <D.27445>:
        perror ("open /dev/rtc");
        return;
        <D.27446>:
        add_signal_handler (27, sigprof_signal_handler);
        rtc_fd.15 = rtc_fd;
        D.27447 = ioctl (rtc_fd.15, 1074032652, freq);
        if (D.27447 == -1) goto <D.27448>; else goto <D.27449>;
        <D.27448>:
        perror ("set rtc freq");
        return;
        <D.27449>:
        rtc_fd.15 = rtc_fd;
        D.27450 = ioctl (rtc_fd.15, 28677, 0);
        if (D.27450 == -1) goto <D.27451>; else goto <D.27452>;
        <D.27451>:
        perror ("start rtc");
        return;
        <D.27452>:
        rtc_fd.15 = rtc_fd;
        D.27453 = fcntl (rtc_fd.15, 10, 27);
        if (D.27453 == -1) goto <D.27454>; else goto <D.27455>;
        <D.27454>:
        perror ("setsig");
        return;
        <D.27455>:
        rtc_fd.15 = rtc_fd;
        D.27456 = getpid ();
        D.27457 = fcntl (rtc_fd.15, 8, D.27456);
        if (D.27457 == -1) goto <D.27458>; else goto <D.27459>;
        <D.27458>:
        perror ("setown");
        return;
        <D.27459>:
        enable_rtc_timer (1);
        return;
      }
      <D.27437>:
      <D.27435>:
      rtc_fd.15 = rtc_fd;
      if (rtc_fd.15 >= 0) goto <D.27460>; else goto <D.27461>;
      <D.27460>:
      return;
      <D.27461>:
      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.27462>; else goto <D.27463>;
      <D.27462>:
      return;
      <D.27463>:
      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.27469;
  unsigned int mono_jit_tls_id.16;
  int D.27472;
  int D.27473;
  sizetype D.27474;
  sizetype D.27475;
  bitsizetype D.27476;
  bitsizetype D.27477;
  sizetype D.27478;
  guchar *[0:D.27474] * ips.17;
  int D.27480;
  guchar * D.27481;
  int D.27492;
  guchar * D.27493;
  _Bool D.27494;
  _Bool D.27495;
  _Bool D.27496;
  guchar * * D.27497;
  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.27467>; else goto <D.27468>;
  <D.27467>:
  D.27469 = mono_arch_ip_from_context (ctx);
  mono_profiler_stat_hit (D.27469, ctx);
  goto <D.27470>;
  <D.27468>:
  {
    struct MonoJitTlsData * jit_tls;
    int current_frame_index;
    struct MonoContext mono_context;
    guchar * ips[0:D.27474] [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.27472 = call_chain_depth + 1;
        D.27473 = D.27472 + -1;
        D.27474 = (sizetype) D.27473;
        D.27475 = (sizetype) D.27472;
        D.27476 = (bitsizetype) D.27475;
        D.27477 = D.27476 * 32;
        D.27475 = (sizetype) D.27472;
        D.27478 = D.27475 * 4;
        D.27475 = (sizetype) D.27472;
        D.27476 = (bitsizetype) D.27475;
        D.27477 = D.27476 * 32;
        D.27475 = (sizetype) D.27472;
        D.27478 = D.27475 * 4;
        ips.17 = __builtin_alloca_with_align (D.27478, 32);
        mono_arch_sigctx_to_monoctx (ctx, &mono_context);
        D.27480 = mono_context.pc;
        D.27481 = (guchar *) D.27480;
        *ips.17[0] = D.27481;
        if (jit_tls != 0B) goto <D.27482>; else goto <D.27483>;
        <D.27482>:
        if (call_chain_strategy == 1) goto <D.27484>; else goto <D.27485>;
        <D.27484>:
        call_chain_strategy = 2;
        <D.27485>:
        if (call_chain_strategy == 2) goto <D.27486>; else goto <D.27487>;
        <D.27486>:
        call_chain_strategy = 3;
        <D.27487>:
        if (call_chain_strategy == 3) goto <D.27488>; else goto <D.27489>;
        <D.27488>:
        {
          struct MonoDomain * domain;

          domain = mono_domain_get ();
          if (domain != 0B) goto <D.27490>; else goto <D.27491>;
          <D.27490>:
          {
            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.26960>;
                <D.26959>:
                D.27492 = new_mono_context.pc;
                D.27493 = (guchar *) D.27492;
                *ips.17[current_frame_index] = D.27493;
                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.26960>:
                D.27494 = ji != 0B;
                D.27495 = current_frame_index <= call_chain_depth;
                D.27496 = D.27494 & D.27495;
                if (D.27496 != 0) goto <D.26959>; else goto <D.26961>;
                <D.26961>:
              }
            finally
              {
                lmf = {CLOBBER};
                res = {CLOBBER};
                new_mono_context = {CLOBBER};
                native_offset = {CLOBBER};
              }
          }
          <D.27491>:
        }
        <D.27489>:
        <D.27483>:
        D.27497 = &*ips.17[0];
        mono_profiler_stat_call_chain (current_frame_index, D.27497, ctx);
      }
    finally
      {
        __builtin_stack_restore (saved_stack.18);
        mono_context = {CLOBBER};
      }
  }
  <D.27470>:
  mono_chain_signal (_dummy, info, context);
}


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

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


open (const char * __path, int __oflag)
{
  int D.27501;
  int D.27504;
  int D.27509;
  int D.27511;
  int D.27512;
  int D.27515;
  int D.27516;

  D.27501 = __builtin_va_arg_pack_len ();
  if (D.27501 > 1) goto <D.27502>; else goto <D.27503>;
  <D.27502>:
  __open_too_many_args ();
  <D.27503>:
  D.27504 = __builtin_constant_p (__oflag);
  if (D.27504 != 0) goto <D.27505>; else goto <D.27506>;
  <D.27505>:
  D.27509 = __oflag & 64;
  if (D.27509 != 0) goto <D.27507>; else goto <D.27510>;
  <D.27510>:
  D.27511 = __oflag & 4210688;
  if (D.27511 == 4210688) goto <D.27507>; else goto <D.27508>;
  <D.27507>:
  D.27512 = __builtin_va_arg_pack_len ();
  if (D.27512 <= 0) goto <D.27513>; else goto <D.27514>;
  <D.27513>:
  __open_missing_mode ();
  D.27515 = __open_2 (__path, __oflag);
  return D.27515;
  <D.27514>:
  <D.27508>:
  D.27515 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.27515;
  <D.27506>:
  D.27516 = __builtin_va_arg_pack_len ();
  if (D.27516 <= 0) goto <D.27517>; else goto <D.27518>;
  <D.27517>:
  D.27515 = __open_2 (__path, __oflag);
  return D.27515;
  <D.27518>:
  D.27515 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.27515;
}


mono_runtime_syscall_fork ()
{
  pid_t D.27520;

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


mono_gdb_render_native_backtraces (pid_t crashed_pid)
{
  gchar * D.27522;
  const char * D.27523;
  gchar * D.27526;
  int D.27531;
  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.27522 = monoeg_g_find_program_in_path ("gdb");
      argv[0] = D.27522;
      D.27523 = argv[0];
      if (D.27523 == 0B) goto <D.27524>; else goto <D.27525>;
      <D.27524>:
      D.27526 = monoeg_g_find_program_in_path ("lldb");
      argv[0] = D.27526;
      using_lldb = 1;
      <D.27525>:
      D.27523 = argv[0];
      if (D.27523 == 0B) goto <D.27527>; else goto <D.27528>;
      <D.27527>:
      return;
      <D.27528>:
      if (using_lldb != 0) goto <D.27529>; else goto <D.27530>;
      <D.27529>:
      D.27531 = mkstemp (&template);
      if (D.27531 == -1) goto <D.27532>; else goto <D.27533>;
      <D.27532>:
      return;
      <D.27533>:
      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.27534>;
      <D.27530>:
      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.27534>:
      D.27523 = argv[0];
      execv (D.27523, &argv);
      if (using_lldb != 0) goto <D.27535>; else goto <D.27536>;
      <D.27535>:
      unlink (&template);
      <D.27536>:
    }
  finally
    {
      argv = {CLOBBER};
      template = {CLOBBER};
      buf1 = {CLOBBER};
    }
}


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

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


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

  D.27543 = __builtin_object_size (__s, 1);
  D.27542 = __builtin___sprintf_chk (__s, 1, D.27543, __fmt, __builtin_va_arg_pack ());
  return D.27542;
}


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

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