mono_chain_signal (int _dummy, struct siginfo_t * info, void * context)
{
  void (*<T323>) (int) D.24196;
  unsigned int D.24199;
  unsigned int D.24200;
  void (*<T367>) (int, struct siginfo_t *, void *) D.24204;
  gboolean D.24205;
  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.24194>; else goto <D.24195>;
  <D.24194>:
  D.24196 = saved_handler->__sigaction_handler.sa_handler;
  if (D.24196 != 0B) goto <D.24197>; else goto <D.24198>;
  <D.24197>:
  D.24199 = saved_handler->sa_flags;
  D.24200 = D.24199 & 8;
  if (D.24200 == 0) goto <D.24201>; else goto <D.24202>;
  <D.24201>:
  D.24196 = saved_handler->__sigaction_handler.sa_handler;
  D.24196 (signal);
  goto <D.24203>;
  <D.24202>:
  D.24204 = saved_handler->__sigaction_handler.sa_sigaction;
  D.24204 (signal, info, ctx);
  <D.24203>:
  D.24205 = 1;
  return D.24205;
  <D.24198>:
  <D.24195>:
  D.24205 = 0;
  return D.24205;
}


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

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


mono_runtime_posix_install_handlers ()
{
  struct MonoDebugOptions * D.24213;
  int D.24214;
  struct MonoTraceSpec * mono_jit_trace_calls.2;
  int D.24220;
  int D.24223;
  int D.24224;
  struct sigset_t signal_set;

  try
    {
      D.24213 = mini_get_debug_options ();
      D.24214 = D.24213->handle_sigint;
      if (D.24214 != 0) goto <D.24215>; else goto <D.24216>;
      <D.24215>:
      add_signal_handler (2, mono_sigint_signal_handler);
      <D.24216>:
      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 (10, mono_sigsegv_signal_handler);
      mono_jit_trace_calls.2 = mono_jit_trace_calls;
      if (mono_jit_trace_calls.2 != 0B) goto <D.24218>; else goto <D.24219>;
      <D.24218>:
      add_signal_handler (17, sigusr2_signal_handler);
      <D.24219>:
      D.24220 = mono_thread_info_new_interrupt_enabled ();
      if (D.24220 == 0) goto <D.24221>; else goto <D.24222>;
      <D.24221>:
      D.24223 = mono_thread_get_abort_signal ();
      add_signal_handler (D.24223, sigusr1_signal_handler);
      <D.24222>:
      sigemptyset (&signal_set);
      D.24224 = mono_thread_get_abort_signal ();
      sigaddset (&signal_set, D.24224);
      sigprocmask (2, &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.24225;
  struct MonoDomain * D.24228;
  void * D.24229;
  int D.24232;
  struct MonoJitInfo * ji;
  void * ctx;

  ji = 0B;
  ctx = context;
  D.24225 = mono_thread_internal_current ();
  if (D.24225 != 0B) goto <D.24226>; else goto <D.24227>;
  <D.24226>:
  D.24228 = mono_domain_get ();
  D.24229 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.24228, D.24229);
  <D.24227>:
  if (ji == 0B) goto <D.24230>; else goto <D.24231>;
  <D.24230>:
  D.24232 = mono_chain_signal (_dummy, info, context);
  if (D.24232 != 0) goto <D.24233>; else goto <D.24234>;
  <D.24233>:
  return;
  <D.24234>:
  mono_handle_native_sigsegv (6, ctx);
  <D.24231>:
}


sigusr1_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  int D.24239;
  unsigned char D.24242;
  struct MonoDomain * D.24247;
  void * D.24248;
  _Bool D.24249;
  int D.24250;
  int mono_aot_only.3;
  int D.24259;
  int D.24262;
  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.24236>; else goto <D.24238>;
  <D.24238>:
  if (domain == 0B) goto <D.24236>; else goto <D.24237>;
  <D.24236>:
  mono_debugger_agent_thread_interrupt (ctx, 0B);
  return;
  <D.24237>:
  D.24239 = thread->ignore_next_signal;
  if (D.24239 != 0) goto <D.24240>; else goto <D.24241>;
  <D.24240>:
  thread->ignore_next_signal = 0;
  return;
  <D.24241>:
  D.24242 = thread->thread_dump_requested;
  if (D.24242 != 0) goto <D.24243>; else goto <D.24244>;
  <D.24243>:
  thread->thread_dump_requested = 0;
  mono_print_thread_dump (ctx);
  <D.24244>:
  if (ctx != 0B) goto <D.24245>; else goto <D.24246>;
  <D.24245>:
  D.24247 = mono_domain_get ();
  D.24248 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.24247, D.24248);
  D.24249 = ji != 0B;
  running_managed = (gboolean) D.24249;
  D.24250 = mono_debugger_agent_thread_interrupt (ctx, ji);
  if (D.24250 != 0) goto <D.24251>; else goto <D.24252>;
  <D.24251>:
  return;
  <D.24252>:
  goto <D.24253>;
  <D.24246>:
  running_managed = 0;
  <D.24253>:
  mono_aot_only.3 = mono_aot_only;
  if (mono_aot_only.3 == 0) goto <D.24255>; else goto <D.24256>;
  <D.24255>:
  if (ctx != 0B) goto <D.24257>; else goto <D.24258>;
  <D.24257>:
  {
    struct MonoThreadUnwindState unwind_state;

    try
      {
        D.24259 = mono_thread_state_init_from_sigctx (&unwind_state, ctx);
        if (D.24259 != 0) goto <D.24260>; else goto <D.24261>;
        <D.24260>:
        D.24262 = mono_install_handler_block_guard (&unwind_state);
        if (D.24262 != 0) goto <D.24263>; else goto <D.24264>;
        <D.24263>:
        wapi_clear_interruption ();
        return;
        <D.24264>:
        <D.24261>:
      }
    finally
      {
        unwind_state = {CLOBBER};
      }
  }
  <D.24258>:
  <D.24256>:
  exc = mono_thread_request_interruption (running_managed);
  if (exc == 0B) goto <D.24265>; else goto <D.24266>;
  <D.24265>:
  return;
  <D.24266>:
  mono_arch_handle_exception (ctx, exc);
}


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

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


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

  ctx = context;
  res = mono_attach_start ();
  if (res != 0) goto <D.24272>; else goto <D.24273>;
  <D.24272>:
  return;
  <D.24273>:
  D.24274 = mono_thread_info_new_interrupt_enabled ();
  if (D.24274 != 0) goto <D.24275>; else goto <D.24276>;
  <D.24275>:
  mono_threads_request_thread_dump ();
  goto <D.24277>;
  <D.24276>:
  printf ("Full thread dump:\n");
  mono_threads_request_thread_dump ();
  mono_print_thread_dump (ctx);
  <D.24277>:
  mono_chain_signal (_dummy, info, context);
}


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

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


add_signal_handler (int signo, void * handler)
{
  void (*<T367>) (int, struct siginfo_t *, void *) handler.4;
  int D.24284;
  int D.24285;
  _Bool D.24286;
  long int D.24287;
  long int D.24288;
  unsigned int D.24293;
  unsigned int D.24294;
  void (*<T323>) (int) D.24296;
  int mono_do_signal_chaining.5;
  struct sigaction sa;
  struct sigaction previous_sa;

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

        try
          {
            sigemptyset (&block_mask);
            D.24284 = mono_thread_get_abort_signal ();
            sigaddset (&sa.sa_mask, D.24284);
          }
        finally
          {
            block_mask = {CLOBBER};
          }
      }
      <D.24283>:
      D.24285 = sigaction (signo, &sa, &previous_sa);
      D.24286 = D.24285 == -1;
      D.24287 = (long int) D.24286;
      D.24288 = __builtin_expect (D.24287, 0);
      if (D.24288 != 0) goto <D.24289>; else goto <D.24290>;
      <D.24289>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 471, "sigaction (signo, &sa, &previous_sa) != -1");
      <D.24290>:
      D.24293 = previous_sa.sa_flags;
      D.24294 = D.24293 & 8;
      if (D.24294 == 0) goto <D.24295>; else goto <D.24291>;
      <D.24295>:
      D.24296 = previous_sa.__sigaction_handler.sa_handler;
      if (D.24296 == 0B) goto <D.24297>; else goto <D.24291>;
      <D.24297>:
      goto <D.24292>;
      <D.24291>:
      mono_do_signal_chaining.5 = mono_do_signal_chaining;
      if (mono_do_signal_chaining.5 != 0) goto <D.24299>; else goto <D.24300>;
      <D.24299>:
      save_old_signal_handler (signo, &previous_sa);
      <D.24300>:
      <D.24292>:
    }
  finally
    {
      sa = {CLOBBER};
      previous_sa = {CLOBBER};
    }
}


save_old_signal_handler (int signo, struct sigaction * old_action)
{
  unsigned int D.24301;
  unsigned int D.24302;
  void (*<T323>) (int) D.24305;
  void (*<T367>) (int, struct siginfo_t *, void *) D.24307;
  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 (144);
  mono_trace (128, 16, "Saving old signal handler for signal %d.", signo);
  D.24301 = old_action->sa_flags;
  D.24302 = D.24301 & 8;
  if (D.24302 == 0) goto <D.24303>; else goto <D.24304>;
  <D.24303>:
  D.24305 = old_action->__sigaction_handler.sa_handler;
  handler_to_save->__sigaction_handler.sa_handler = D.24305;
  goto <D.24306>;
  <D.24304>:
  D.24307 = old_action->__sigaction_handler.sa_sigaction;
  handler_to_save->__sigaction_handler.sa_sigaction = D.24307;
  <D.24306>:
  handler_to_save->sa_mask = old_action->sa_mask;
  D.24301 = old_action->sa_flags;
  handler_to_save->sa_flags = D.24301;
  mono_saved_signal_handlers.6 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.6 == 0B) goto <D.24309>; else goto <D.24310>;
  <D.24309>:
  mono_saved_signal_handlers.7 = monoeg_g_hash_table_new (0B, 0B);
  mono_saved_signal_handlers = mono_saved_signal_handlers.7;
  <D.24310>:
  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.24313;
  int D.24314;
  struct MonoTraceSpec * mono_jit_trace_calls.9;
  int D.24320;

  D.24313 = mini_get_debug_options ();
  D.24314 = D.24313->handle_sigint;
  if (D.24314 != 0) goto <D.24315>; else goto <D.24316>;
  <D.24315>:
  remove_signal_handler (2);
  <D.24316>:
  remove_signal_handler (8);
  remove_signal_handler (3);
  remove_signal_handler (4);
  remove_signal_handler (10);
  mono_jit_trace_calls.9 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.9 != 0B) goto <D.24318>; else goto <D.24319>;
  <D.24318>:
  remove_signal_handler (17);
  <D.24319>:
  D.24320 = mono_thread_get_abort_signal ();
  remove_signal_handler (D.24320);
  remove_signal_handler (6);
  remove_signal_handler (11);
  free_saved_signal_handlers ();
}


remove_signal_handler (int signo)
{
  int D.24324;
  _Bool D.24325;
  long int D.24326;
  long int D.24327;
  struct sigaction sa;
  struct sigaction * saved_action;

  try
    {
      saved_action = get_saved_signal_handler (signo);
      if (saved_action == 0B) goto <D.24321>; else goto <D.24322>;
      <D.24321>:
      sa.__sigaction_handler.sa_handler = 0B;
      sigemptyset (&sa.sa_mask);
      sa.sa_flags = 0;
      sigaction (signo, &sa, 0B);
      goto <D.24323>;
      <D.24322>:
      D.24324 = sigaction (signo, saved_action, 0B);
      D.24325 = D.24324 == -1;
      D.24326 = (long int) D.24325;
      D.24327 = __builtin_expect (D.24326, 0);
      if (D.24327 != 0) goto <D.24328>; else goto <D.24329>;
      <D.24328>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 496, "sigaction (signo, saved_action, NULL) != -1");
      <D.24329>:
      <D.24323>:
    }
  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.24331>; else goto <D.24332>;
  <D.24331>:
  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.24332>:
}


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


enable_rtc_timer (gboolean enable)
{
  int rtc_fd.12;
  int D.24339;
  int D.24343;
  int flags;

  rtc_fd.12 = rtc_fd;
  flags = fcntl (rtc_fd.12, 3);
  if (flags < 0) goto <D.24337>; else goto <D.24338>;
  <D.24337>:
  perror ("getflags");
  D.24339 = 0;
  return D.24339;
  <D.24338>:
  if (enable != 0) goto <D.24340>; else goto <D.24341>;
  <D.24340>:
  flags = flags | 4096;
  goto <D.24342>;
  <D.24341>:
  flags = flags & -4097;
  <D.24342>:
  rtc_fd.12 = rtc_fd;
  D.24343 = fcntl (rtc_fd.12, 4, flags);
  if (D.24343 == -1) goto <D.24344>; else goto <D.24345>;
  <D.24344>:
  perror ("setflags");
  D.24339 = 0;
  return D.24339;
  <D.24345>:
  D.24339 = 1;
  return D.24339;
}


mono_runtime_setup_stat_profiler ()
{
  int inited.13;
  char D.24352;
  int rtc_fd.14;
  int rtc_fd.15;
  int D.24361;
  int D.24364;
  int D.24367;
  int D.24370;
  int D.24371;
  struct itimerval itval;
  static int inited = 0;
  const char * rtc_freq;

  try
    {
      inited.13 = inited;
      if (inited.13 == 0) goto <D.24348>; else goto <D.24349>;
      <D.24348>:
      rtc_freq = monoeg_g_getenv ("MONO_RTC");
      if (rtc_freq != 0B) goto <D.24350>; else goto <D.24351>;
      <D.24350>:
      {
        int freq;

        freq = 0;
        inited = 1;
        D.24352 = *rtc_freq;
        if (D.24352 != 0) goto <D.24353>; else goto <D.24354>;
        <D.24353>:
        freq = atoi (rtc_freq);
        <D.24354>:
        if (freq == 0) goto <D.24355>; else goto <D.24356>;
        <D.24355>:
        freq = 1024;
        <D.24356>:
        rtc_fd.14 = open ("/dev/rtc", 0);
        rtc_fd = rtc_fd.14;
        rtc_fd.15 = rtc_fd;
        if (rtc_fd.15 == -1) goto <D.24359>; else goto <D.24360>;
        <D.24359>:
        perror ("open /dev/rtc");
        return;
        <D.24360>:
        add_signal_handler (29, sigprof_signal_handler);
        rtc_fd.15 = rtc_fd;
        D.24361 = ioctl (rtc_fd.15, 2147774476, freq);
        if (D.24361 == -1) goto <D.24362>; else goto <D.24363>;
        <D.24362>:
        perror ("set rtc freq");
        return;
        <D.24363>:
        rtc_fd.15 = rtc_fd;
        D.24364 = ioctl (rtc_fd.15, 536899589, 0);
        if (D.24364 == -1) goto <D.24365>; else goto <D.24366>;
        <D.24365>:
        perror ("start rtc");
        return;
        <D.24366>:
        rtc_fd.15 = rtc_fd;
        D.24367 = fcntl (rtc_fd.15, 10, 29);
        if (D.24367 == -1) goto <D.24368>; else goto <D.24369>;
        <D.24368>:
        perror ("setsig");
        return;
        <D.24369>:
        rtc_fd.15 = rtc_fd;
        D.24370 = getpid ();
        D.24371 = fcntl (rtc_fd.15, 24, D.24370);
        if (D.24371 == -1) goto <D.24372>; else goto <D.24373>;
        <D.24372>:
        perror ("setown");
        return;
        <D.24373>:
        enable_rtc_timer (1);
        return;
      }
      <D.24351>:
      <D.24349>:
      rtc_fd.15 = rtc_fd;
      if (rtc_fd.15 >= 0) goto <D.24374>; else goto <D.24375>;
      <D.24374>:
      return;
      <D.24375>:
      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.24376>; else goto <D.24377>;
      <D.24376>:
      return;
      <D.24377>:
      inited = 1;
      add_signal_handler (29, sigprof_signal_handler);
    }
  finally
    {
      itval = {CLOBBER};
    }
}


sigprof_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  void * D.24383;
  unsigned int mono_jit_tls_id.16;
  int D.24386;
  int D.24387;
  sizetype D.24388;
  sizetype D.24389;
  bitsizetype D.24390;
  bitsizetype D.24391;
  sizetype D.24392;
  guchar *[0:D.24388] * ips.17;
  int D.24394;
  guchar * D.24395;
  int D.24406;
  guchar * D.24407;
  guchar * * D.24409;
  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.24381>; else goto <D.24382>;
  <D.24381>:
  D.24383 = mono_arch_ip_from_context (ctx);
  mono_profiler_stat_hit (D.24383, ctx);
  goto <D.24384>;
  <D.24382>:
  {
    struct MonoJitTlsData * jit_tls;
    int current_frame_index;
    struct MonoContext mono_context;
    guchar * ips[0:D.24388] [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.24386 = call_chain_depth + 1;
        D.24387 = D.24386 + -1;
        D.24388 = (sizetype) D.24387;
        D.24389 = (sizetype) D.24386;
        D.24390 = (bitsizetype) D.24389;
        D.24391 = D.24390 * 32;
        D.24389 = (sizetype) D.24386;
        D.24392 = D.24389 * 4;
        D.24389 = (sizetype) D.24386;
        D.24390 = (bitsizetype) D.24389;
        D.24391 = D.24390 * 32;
        D.24389 = (sizetype) D.24386;
        D.24392 = D.24389 * 4;
        ips.17 = __builtin_alloca_with_align (D.24392, 32);
        mono_arch_sigctx_to_monoctx (ctx, &mono_context);
        D.24394 = mono_context.sc_pc;
        D.24395 = (guchar *) D.24394;
        *ips.17[0] = D.24395;
        if (jit_tls != 0B) goto <D.24396>; else goto <D.24397>;
        <D.24396>:
        if (call_chain_strategy == 1) goto <D.24398>; else goto <D.24399>;
        <D.24398>:
        call_chain_strategy = 2;
        <D.24399>:
        if (call_chain_strategy == 2) goto <D.24400>; else goto <D.24401>;
        <D.24400>:
        call_chain_strategy = 3;
        <D.24401>:
        if (call_chain_strategy == 3) goto <D.24402>; else goto <D.24403>;
        <D.24402>:
        {
          struct MonoDomain * domain;

          domain = mono_domain_get ();
          if (domain != 0B) goto <D.24404>; else goto <D.24405>;
          <D.24404>:
          {
            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.23875>;
                <D.23874>:
                D.24406 = new_mono_context.sc_pc;
                D.24407 = (guchar *) D.24406;
                *ips.17[current_frame_index] = D.24407;
                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.23875>:
                if (ji != 0B) goto <D.24408>; else goto <D.23876>;
                <D.24408>:
                if (current_frame_index <= call_chain_depth) goto <D.23874>; else goto <D.23876>;
                <D.23876>:
              }
            finally
              {
                lmf = {CLOBBER};
                res = {CLOBBER};
                new_mono_context = {CLOBBER};
                native_offset = {CLOBBER};
              }
          }
          <D.24405>:
        }
        <D.24403>:
        <D.24397>:
        D.24409 = &*ips.17[0];
        mono_profiler_stat_call_chain (current_frame_index, D.24409, ctx);
      }
    finally
      {
        __builtin_stack_restore (saved_stack.18);
        mono_context = {CLOBBER};
      }
  }
  <D.24384>:
  mono_chain_signal (_dummy, info, context);
}


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

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


open (const char * __path, int __oflag)
{
  int D.24413;
  int D.24416;
  int D.24421;
  int D.24423;
  int D.24424;
  int D.24427;
  int D.24428;

  D.24413 = __builtin_va_arg_pack_len ();
  if (D.24413 > 1) goto <D.24414>; else goto <D.24415>;
  <D.24414>:
  __open_too_many_args ();
  <D.24415>:
  D.24416 = __builtin_constant_p (__oflag);
  if (D.24416 != 0) goto <D.24417>; else goto <D.24418>;
  <D.24417>:
  D.24421 = __oflag & 256;
  if (D.24421 != 0) goto <D.24419>; else goto <D.24422>;
  <D.24422>:
  D.24423 = __oflag & 4259840;
  if (D.24423 == 4259840) goto <D.24419>; else goto <D.24420>;
  <D.24419>:
  D.24424 = __builtin_va_arg_pack_len ();
  if (D.24424 <= 0) goto <D.24425>; else goto <D.24426>;
  <D.24425>:
  __open_missing_mode ();
  D.24427 = __open_2 (__path, __oflag);
  return D.24427;
  <D.24426>:
  <D.24420>:
  D.24427 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.24427;
  <D.24418>:
  D.24428 = __builtin_va_arg_pack_len ();
  if (D.24428 <= 0) goto <D.24429>; else goto <D.24430>;
  <D.24429>:
  D.24427 = __open_2 (__path, __oflag);
  return D.24427;
  <D.24430>:
  D.24427 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.24427;
}


mono_runtime_syscall_fork ()
{
  pid_t D.24432;

  D.24432 = syscall (4002);
  return D.24432;
}


mono_gdb_render_native_backtraces (pid_t crashed_pid)
{
  gchar * D.24434;
  const char * D.24435;
  gchar * D.24438;
  int D.24443;
  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.24434 = monoeg_g_find_program_in_path ("gdb");
      argv[0] = D.24434;
      D.24435 = argv[0];
      if (D.24435 == 0B) goto <D.24436>; else goto <D.24437>;
      <D.24436>:
      D.24438 = monoeg_g_find_program_in_path ("lldb");
      argv[0] = D.24438;
      using_lldb = 1;
      <D.24437>:
      D.24435 = argv[0];
      if (D.24435 == 0B) goto <D.24439>; else goto <D.24440>;
      <D.24439>:
      return;
      <D.24440>:
      if (using_lldb != 0) goto <D.24441>; else goto <D.24442>;
      <D.24441>:
      D.24443 = mkstemp (&template);
      if (D.24443 == -1) goto <D.24444>; else goto <D.24445>;
      <D.24444>:
      return;
      <D.24445>:
      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.24446>;
      <D.24442>:
      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.24446>:
      D.24435 = argv[0];
      execv (D.24435, &argv);
      if (using_lldb != 0) goto <D.24447>; else goto <D.24448>;
      <D.24447>:
      unlink (&template);
      <D.24448>:
    }
  finally
    {
      argv = {CLOBBER};
      template = {CLOBBER};
      buf1 = {CLOBBER};
    }
}


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

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


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

  D.24455 = __builtin_object_size (__s, 1);
  D.24454 = __builtin___sprintf_chk (__s, 1, D.24455, __fmt, __builtin_va_arg_pack ());
  return D.24454;
}


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

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