__attribute__((visibility ("hidden")))
mono_chain_signal (int _dummy, struct siginfo_t * info, void * context)
{
  void (*<T481>) (int) D.25127;
  int D.25130;
  int D.25131;
  void (*<T4c4>) (int, struct siginfo_t *, void *) D.25135;
  gboolean D.25136;
  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.25125>; else goto <D.25126>;
  <D.25125>:
  D.25127 = saved_handler->__sigaction_handler.sa_handler;
  if (D.25127 != 0B) goto <D.25128>; else goto <D.25129>;
  <D.25128>:
  D.25130 = saved_handler->sa_flags;
  D.25131 = D.25130 & 4;
  if (D.25131 == 0) goto <D.25132>; else goto <D.25133>;
  <D.25132>:
  D.25127 = saved_handler->__sigaction_handler.sa_handler;
  D.25127 (signal);
  goto <D.25134>;
  <D.25133>:
  D.25135 = saved_handler->__sigaction_handler.sa_sigaction;
  D.25135 (signal, info, ctx);
  <D.25134>:
  D.25136 = 1;
  return D.25136;
  <D.25129>:
  <D.25126>:
  D.25136 = 0;
  return D.25136;
}


get_saved_signal_handler (int signo)
{
  struct GHashTable * mono_saved_signal_handlers.0;
  void * D.25141;
  long int D.25142;
  const void * D.25143;

  mono_saved_signal_handlers.0 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.0 != 0B) goto <D.25139>; else goto <D.25140>;
  <D.25139>:
  mono_saved_signal_handlers.0 = mono_saved_signal_handlers;
  D.25142 = (long int) signo;
  D.25143 = (const void *) D.25142;
  D.25141 = monoeg_g_hash_table_lookup (mono_saved_signal_handlers.0, D.25143);
  return D.25141;
  <D.25140>:
  D.25141 = 0B;
  return D.25141;
}


__attribute__((visibility ("hidden")))
mono_runtime_posix_install_handlers ()
{
  struct MonoDebugOptions * D.25145;
  int D.25146;
  struct MonoTraceSpec * mono_jit_trace_calls.1;
  int D.25152;
  int D.25155;
  int D.25156;
  struct sigset_t signal_set;

  try
    {
      D.25145 = mini_get_debug_options ();
      D.25146 = D.25145->handle_sigint;
      if (D.25146 != 0) goto <D.25147>; else goto <D.25148>;
      <D.25147>:
      add_signal_handler (2, mono_sigint_signal_handler);
      <D.25148>:
      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.25150>; else goto <D.25151>;
      <D.25150>:
      add_signal_handler (12, sigusr2_signal_handler);
      <D.25151>:
      D.25152 = mono_thread_info_new_interrupt_enabled ();
      if (D.25152 == 0) goto <D.25153>; else goto <D.25154>;
      <D.25153>:
      D.25155 = mono_thread_get_abort_signal ();
      add_signal_handler (D.25155, sigusr1_signal_handler);
      <D.25154>:
      sigemptyset (&signal_set);
      D.25156 = mono_thread_get_abort_signal ();
      sigaddset (&signal_set, D.25156);
      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.25157;
  struct MonoDomain * D.25160;
  void * D.25161;
  int D.25164;
  struct MonoJitInfo * ji;
  void * ctx;

  ji = 0B;
  ctx = context;
  D.25157 = mono_thread_internal_current ();
  if (D.25157 != 0B) goto <D.25158>; else goto <D.25159>;
  <D.25158>:
  D.25160 = mono_domain_get ();
  D.25161 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.25160, D.25161);
  <D.25159>:
  if (ji == 0B) goto <D.25162>; else goto <D.25163>;
  <D.25162>:
  D.25164 = mono_chain_signal (_dummy, info, context);
  if (D.25164 != 0) goto <D.25165>; else goto <D.25166>;
  <D.25165>:
  return;
  <D.25166>:
  mono_handle_native_sigsegv (6, ctx);
  <D.25163>:
}


sigusr1_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  int D.25171;
  unsigned char D.25174;
  struct MonoDomain * D.25179;
  void * D.25180;
  _Bool D.25181;
  int D.25182;
  int mono_aot_only.2;
  int D.25191;
  int D.25194;
  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.25168>; else goto <D.25170>;
  <D.25170>:
  if (domain == 0B) goto <D.25168>; else goto <D.25169>;
  <D.25168>:
  mono_debugger_agent_thread_interrupt (ctx, 0B);
  return;
  <D.25169>:
  D.25171 = thread->ignore_next_signal;
  if (D.25171 != 0) goto <D.25172>; else goto <D.25173>;
  <D.25172>:
  thread->ignore_next_signal = 0;
  return;
  <D.25173>:
  D.25174 = thread->thread_dump_requested;
  if (D.25174 != 0) goto <D.25175>; else goto <D.25176>;
  <D.25175>:
  thread->thread_dump_requested = 0;
  mono_print_thread_dump (ctx);
  <D.25176>:
  if (ctx != 0B) goto <D.25177>; else goto <D.25178>;
  <D.25177>:
  D.25179 = mono_domain_get ();
  D.25180 = mono_arch_ip_from_context (ctx);
  ji = mono_jit_info_table_find (D.25179, D.25180);
  D.25181 = ji != 0B;
  running_managed = (gboolean) D.25181;
  D.25182 = mono_debugger_agent_thread_interrupt (ctx, ji);
  if (D.25182 != 0) goto <D.25183>; else goto <D.25184>;
  <D.25183>:
  return;
  <D.25184>:
  goto <D.25185>;
  <D.25178>:
  running_managed = 0;
  <D.25185>:
  mono_aot_only.2 = mono_aot_only;
  if (mono_aot_only.2 == 0) goto <D.25187>; else goto <D.25188>;
  <D.25187>:
  if (ctx != 0B) goto <D.25189>; else goto <D.25190>;
  <D.25189>:
  {
    struct MonoThreadUnwindState unwind_state;

    try
      {
        D.25191 = mono_thread_state_init_from_sigctx (&unwind_state, ctx);
        if (D.25191 != 0) goto <D.25192>; else goto <D.25193>;
        <D.25192>:
        D.25194 = mono_install_handler_block_guard (&unwind_state);
        if (D.25194 != 0) goto <D.25195>; else goto <D.25196>;
        <D.25195>:
        wapi_clear_interruption ();
        return;
        <D.25196>:
        <D.25193>:
      }
    finally
      {
        unwind_state = {CLOBBER};
      }
  }
  <D.25190>:
  <D.25188>:
  exc = mono_thread_request_interruption (running_managed);
  if (exc == 0B) goto <D.25197>; else goto <D.25198>;
  <D.25197>:
  return;
  <D.25198>:
  mono_arch_handle_exception (ctx, exc);
}


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

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


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

  ctx = context;
  res = mono_attach_start ();
  if (res != 0) goto <D.25204>; else goto <D.25205>;
  <D.25204>:
  return;
  <D.25205>:
  D.25206 = mono_thread_info_new_interrupt_enabled ();
  if (D.25206 != 0) goto <D.25207>; else goto <D.25208>;
  <D.25207>:
  mono_threads_request_thread_dump ();
  goto <D.25209>;
  <D.25208>:
  printf ("Full thread dump:\n");
  mono_threads_request_thread_dump ();
  mono_print_thread_dump (ctx);
  <D.25209>:
  mono_chain_signal (_dummy, info, context);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.25211;

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


add_signal_handler (int signo, void * handler)
{
  void (*<T4c4>) (int, struct siginfo_t *, void *) handler.3;
  int D.25216;
  int D.25217;
  _Bool D.25218;
  long int D.25219;
  long int D.25220;
  int D.25225;
  int D.25226;
  void (*<T481>) (int) D.25228;
  int mono_do_signal_chaining.4;
  struct sigaction sa;
  struct sigaction previous_sa;

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

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


save_old_signal_handler (int signo, struct sigaction * old_action)
{
  int D.25233;
  int D.25234;
  void (*<T481>) (int) D.25237;
  void (*<T4c4>) (int, struct siginfo_t *, void *) D.25239;
  struct GHashTable * mono_saved_signal_handlers.5;
  struct GHashTable * D.25243;
  long int D.25244;
  void * D.25245;
  struct sigaction * handler_to_save;

  handler_to_save = monoeg_malloc (152);
  mono_trace (128, 16, "Saving old signal handler for signal %d.", signo);
  D.25233 = old_action->sa_flags;
  D.25234 = D.25233 & 4;
  if (D.25234 == 0) goto <D.25235>; else goto <D.25236>;
  <D.25235>:
  D.25237 = old_action->__sigaction_handler.sa_handler;
  handler_to_save->__sigaction_handler.sa_handler = D.25237;
  goto <D.25238>;
  <D.25236>:
  D.25239 = old_action->__sigaction_handler.sa_sigaction;
  handler_to_save->__sigaction_handler.sa_sigaction = D.25239;
  <D.25238>:
  handler_to_save->sa_mask = old_action->sa_mask;
  D.25233 = old_action->sa_flags;
  handler_to_save->sa_flags = D.25233;
  mono_saved_signal_handlers.5 = mono_saved_signal_handlers;
  if (mono_saved_signal_handlers.5 == 0B) goto <D.25241>; else goto <D.25242>;
  <D.25241>:
  D.25243 = monoeg_g_hash_table_new (0B, 0B);
  mono_saved_signal_handlers = D.25243;
  <D.25242>:
  mono_saved_signal_handlers.5 = mono_saved_signal_handlers;
  D.25244 = (long int) signo;
  D.25245 = (void *) D.25244;
  monoeg_g_hash_table_insert_replace (mono_saved_signal_handlers.5, D.25245, handler_to_save, 0);
}


__attribute__((visibility ("hidden")))
mono_runtime_install_handlers ()
{
  mono_runtime_posix_install_handlers ();
}


__attribute__((visibility ("hidden")))
mono_runtime_cleanup_handlers ()
{
  struct MonoDebugOptions * D.25246;
  int D.25247;
  struct MonoTraceSpec * mono_jit_trace_calls.6;
  int D.25253;

  D.25246 = mini_get_debug_options ();
  D.25247 = D.25246->handle_sigint;
  if (D.25247 != 0) goto <D.25248>; else goto <D.25249>;
  <D.25248>:
  remove_signal_handler (2);
  <D.25249>:
  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.25251>; else goto <D.25252>;
  <D.25251>:
  remove_signal_handler (12);
  <D.25252>:
  D.25253 = mono_thread_get_abort_signal ();
  remove_signal_handler (D.25253);
  remove_signal_handler (6);
  remove_signal_handler (11);
  free_saved_signal_handlers ();
}


remove_signal_handler (int signo)
{
  int D.25257;
  _Bool D.25258;
  long int D.25259;
  long int D.25260;
  struct sigaction sa;
  struct sigaction * saved_action;

  try
    {
      saved_action = get_saved_signal_handler (signo);
      if (saved_action == 0B) goto <D.25254>; else goto <D.25255>;
      <D.25254>:
      sa.__sigaction_handler.sa_handler = 0B;
      sigemptyset (&sa.sa_mask);
      sa.sa_flags = 0;
      sigaction (signo, &sa, 0B);
      goto <D.25256>;
      <D.25255>:
      D.25257 = sigaction (signo, saved_action, 0B);
      D.25258 = D.25257 == -1;
      D.25259 = (long int) D.25258;
      D.25260 = __builtin_expect (D.25259, 0);
      if (D.25260 != 0) goto <D.25261>; else goto <D.25262>;
      <D.25261>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-posix.c", 496, "sigaction (signo, saved_action, NULL) != -1");
      <D.25262>:
      <D.25256>:
    }
  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.25264>; else goto <D.25265>;
  <D.25264>:
  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.25265>:
}


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


__attribute__((visibility ("hidden")))
mono_runtime_shutdown_stat_profiler ()
{
  int rtc_fd.8;

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


enable_rtc_timer (gboolean enable)
{
  int rtc_fd.9;
  int D.25272;
  int D.25276;
  int flags;

  rtc_fd.9 = rtc_fd;
  flags = fcntl (rtc_fd.9, 3);
  if (flags < 0) goto <D.25270>; else goto <D.25271>;
  <D.25270>:
  perror ("getflags");
  D.25272 = 0;
  return D.25272;
  <D.25271>:
  if (enable != 0) goto <D.25273>; else goto <D.25274>;
  <D.25273>:
  flags = flags | 8192;
  goto <D.25275>;
  <D.25274>:
  flags = flags & -8193;
  <D.25275>:
  rtc_fd.9 = rtc_fd;
  D.25276 = fcntl (rtc_fd.9, 4, flags);
  if (D.25276 == -1) goto <D.25277>; else goto <D.25278>;
  <D.25277>:
  perror ("setflags");
  D.25272 = 0;
  return D.25272;
  <D.25278>:
  D.25272 = 1;
  return D.25272;
}


__attribute__((visibility ("hidden")))
mono_runtime_setup_stat_profiler ()
{
  int inited.10;
  char D.25285;
  int D.25290;
  int rtc_fd.11;
  int D.25294;
  int D.25297;
  int D.25300;
  int D.25303;
  int D.25304;
  struct itimerval itval;
  static int inited = 0;
  const char * rtc_freq;

  try
    {
      inited.10 = inited;
      if (inited.10 == 0) goto <D.25281>; else goto <D.25282>;
      <D.25281>:
      rtc_freq = monoeg_g_getenv ("MONO_RTC");
      if (rtc_freq != 0B) goto <D.25283>; else goto <D.25284>;
      <D.25283>:
      {
        int freq;

        freq = 0;
        inited = 1;
        D.25285 = *rtc_freq;
        if (D.25285 != 0) goto <D.25286>; else goto <D.25287>;
        <D.25286>:
        freq = atoi (rtc_freq);
        <D.25287>:
        if (freq == 0) goto <D.25288>; else goto <D.25289>;
        <D.25288>:
        freq = 1024;
        <D.25289>:
        D.25290 = open ("/dev/rtc", 0);
        rtc_fd = D.25290;
        rtc_fd.11 = rtc_fd;
        if (rtc_fd.11 == -1) goto <D.25292>; else goto <D.25293>;
        <D.25292>:
        perror ("open /dev/rtc");
        return;
        <D.25293>:
        add_signal_handler (27, sigprof_signal_handler);
        rtc_fd.11 = rtc_fd;
        D.25294 = ioctl (rtc_fd.11, 1074294796, freq);
        if (D.25294 == -1) goto <D.25295>; else goto <D.25296>;
        <D.25295>:
        perror ("set rtc freq");
        return;
        <D.25296>:
        rtc_fd.11 = rtc_fd;
        D.25297 = ioctl (rtc_fd.11, 28677, 0);
        if (D.25297 == -1) goto <D.25298>; else goto <D.25299>;
        <D.25298>:
        perror ("start rtc");
        return;
        <D.25299>:
        rtc_fd.11 = rtc_fd;
        D.25300 = fcntl (rtc_fd.11, 10, 27);
        if (D.25300 == -1) goto <D.25301>; else goto <D.25302>;
        <D.25301>:
        perror ("setsig");
        return;
        <D.25302>:
        rtc_fd.11 = rtc_fd;
        D.25303 = getpid ();
        D.25304 = fcntl (rtc_fd.11, 8, D.25303);
        if (D.25304 == -1) goto <D.25305>; else goto <D.25306>;
        <D.25305>:
        perror ("setown");
        return;
        <D.25306>:
        enable_rtc_timer (1);
        return;
      }
      <D.25284>:
      <D.25282>:
      rtc_fd.11 = rtc_fd;
      if (rtc_fd.11 >= 0) goto <D.25307>; else goto <D.25308>;
      <D.25307>:
      return;
      <D.25308>:
      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.25309>; else goto <D.25310>;
      <D.25309>:
      return;
      <D.25310>:
      inited = 1;
      add_signal_handler (27, sigprof_signal_handler);
    }
  finally
    {
      itval = {CLOBBER};
    }
}


sigprof_signal_handler (int _dummy, struct siginfo_t * info, void * context)
{
  int D.25314;

  D.25314 = mono_chain_signal (_dummy, info, context);
  if (D.25314 != 0) goto <D.25315>; else goto <D.25316>;
  <D.25315>:
  return;
  <D.25316>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-posix.c", 306);
}


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atoi (const char * __nptr)
{
  int D.25318;
  long int D.25319;

  D.25319 = strtol (__nptr, 0B, 10);
  D.25318 = (int) D.25319;
  return D.25318;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
open (const char * __path, int __oflag)
{
  int D.25321;
  int D.25324;
  int D.25329;
  int D.25331;
  int D.25332;
  int D.25335;
  int D.25336;

  D.25321 = __builtin_va_arg_pack_len ();
  if (D.25321 > 1) goto <D.25322>; else goto <D.25323>;
  <D.25322>:
  __open_too_many_args ();
  <D.25323>:
  D.25324 = __builtin_constant_p (__oflag);
  if (D.25324 != 0) goto <D.25325>; else goto <D.25326>;
  <D.25325>:
  D.25329 = __oflag & 64;
  if (D.25329 != 0) goto <D.25327>; else goto <D.25330>;
  <D.25330>:
  D.25331 = __oflag & 4259840;
  if (D.25331 == 4259840) goto <D.25327>; else goto <D.25328>;
  <D.25327>:
  D.25332 = __builtin_va_arg_pack_len ();
  if (D.25332 <= 0) goto <D.25333>; else goto <D.25334>;
  <D.25333>:
  __open_missing_mode ();
  D.25335 = __open_2 (__path, __oflag);
  return D.25335;
  <D.25334>:
  <D.25328>:
  D.25335 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.25335;
  <D.25326>:
  D.25336 = __builtin_va_arg_pack_len ();
  if (D.25336 <= 0) goto <D.25337>; else goto <D.25338>;
  <D.25337>:
  D.25335 = __open_2 (__path, __oflag);
  return D.25335;
  <D.25338>:
  D.25335 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.25335;
}


__attribute__((visibility ("hidden")))
mono_runtime_syscall_fork ()
{
  pid_t D.25340;
  long int D.25341;

  D.25341 = syscall (2);
  D.25340 = (pid_t) D.25341;
  return D.25340;
}


__attribute__((visibility ("hidden")))
mono_gdb_render_native_backtraces (pid_t crashed_pid)
{
  gchar * D.25343;
  const char * D.25344;
  gchar * D.25347;
  int D.25352;
  long int D.25355;
  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.25343 = monoeg_g_find_program_in_path ("gdb");
      argv[0] = D.25343;
      D.25344 = argv[0];
      if (D.25344 == 0B) goto <D.25345>; else goto <D.25346>;
      <D.25345>:
      D.25347 = monoeg_g_find_program_in_path ("lldb");
      argv[0] = D.25347;
      using_lldb = 1;
      <D.25346>:
      D.25344 = argv[0];
      if (D.25344 == 0B) goto <D.25348>; else goto <D.25349>;
      <D.25348>:
      return;
      <D.25349>:
      if (using_lldb != 0) goto <D.25350>; else goto <D.25351>;
      <D.25350>:
      D.25352 = mkstemp (&template);
      if (D.25352 == -1) goto <D.25353>; else goto <D.25354>;
      <D.25353>:
      return;
      <D.25354>:
      commands = fopen (&template, "w");
      D.25355 = (long int) crashed_pid;
      fprintf (commands, "process attach --pid %ld\n", D.25355);
      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.25356>;
      <D.25351>:
      argv[1] = "-ex";
      D.25355 = (long int) crashed_pid;
      sprintf (&buf1, "attach %ld", D.25355);
      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.25356>:
      D.25344 = argv[0];
      execv (D.25344, &argv);
      if (using_lldb != 0) goto <D.25357>; else goto <D.25358>;
      <D.25357>:
      unlink (&template);
      <D.25358>:
    }
  finally
    {
      argv = {CLOBBER};
      template = {CLOBBER};
      buf1 = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.25362;

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.25364;
  long unsigned int D.25365;

  D.25365 = __builtin_object_size (__s, 1);
  D.25364 = __builtin___sprintf_chk (__s, 1, D.25365, __fmt, __builtin_va_arg_pack ());
  return D.25364;
}


__attribute__((visibility ("hidden")))
mono_thread_state_init_from_handle (struct MonoThreadUnwindState * tctx, MonoNativeThreadId thread_id, MonoNativeThreadHandle thread_handle)
{
  gboolean D.25367;

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