Mono_Posix_Stdlib_SIG_DFL ()
{
  void * D.10868;

  D.10868 = 0B;
  return D.10868;
}


Mono_Posix_Stdlib_SIG_ERR ()
{
  void * D.10870;

  D.10870 = -1B;
  return D.10870;
}


Mono_Posix_Stdlib_SIG_IGN ()
{
  void * D.10872;

  D.10872 = 1B;
  return D.10872;
}


Mono_Posix_Stdlib_InvokeSignalHandler (int signum, void * handler)
{
  void (*mph_sighandler_t) (int) _h;

  _h = (void (*mph_sighandler_t) (int)) handler;
  _h (signum);
}


Mono_Posix_SIGRTMIN ()
{
  int D.10874;

  D.10874 = __libc_current_sigrtmin ();
  return D.10874;
}


Mono_Posix_SIGRTMAX ()
{
  int D.10876;

  D.10876 = __libc_current_sigrtmax ();
  return D.10876;
}


Mono_Posix_FromRealTimeSignum (int offset, int * r)
{
  int * D.10880;
  int D.10881;
  int D.10885;
  int D.10886;
  int D.10887;
  int D.10888;
  int D.10889;

  if (r == 0B) goto <D.10878>; else goto <D.10879>;
  <D.10878>:
  D.10880 = __errno_location ();
  *D.10880 = 22;
  D.10881 = -1;
  return D.10881;
  <D.10879>:
  *r = 0;
  if (offset < 0) goto <D.10882>; else goto <D.10884>;
  <D.10884>:
  D.10885 = __libc_current_sigrtmin ();
  D.10886 = __libc_current_sigrtmax ();
  D.10887 = D.10886 - offset;
  if (D.10885 > D.10887) goto <D.10882>; else goto <D.10883>;
  <D.10882>:
  D.10880 = __errno_location ();
  *D.10880 = 22;
  D.10881 = -1;
  return D.10881;
  <D.10883>:
  D.10888 = __libc_current_sigrtmin ();
  D.10889 = D.10888 + offset;
  *r = D.10889;
  D.10881 = 0;
  return D.10881;
}


Mono_Posix_Syscall_psignal (int sig, const char * s)
{
  int * D.10891;
  int D.10892;
  int iftmp.0;
  int D.10894;

  D.10891 = __errno_location ();
  *D.10891 = 0;
  psignal (sig, s);
  D.10891 = __errno_location ();
  D.10894 = *D.10891;
  if (D.10894 == 0) goto <D.10895>; else goto <D.10896>;
  <D.10895>:
  iftmp.0 = 0;
  goto <D.10897>;
  <D.10896>:
  iftmp.0 = -1;
  <D.10897>:
  D.10892 = iftmp.0;
  return D.10892;
}


Mono_Unix_UnixSignal_install (int sig)
{
  int D.10899;
  void * D.10902;
  int D.10903;
  int D.10906;
  int D.10909;
  void (*<T40d>) (int) D.10914;
  void (*<T451>) (int, struct siginfo_t *, void *) D.10916;
  int * D.10917;
  int D.10920;
  void (*<T40d>) (int) D.10923;
  void * D.10924;
  void * D.10931;
  _Bool D.10934;
  _Bool D.10935;
  _Bool D.10936;
  int * D.10942;
  int * D.10943;
  int * D.10944;
  int i;
  struct signal_info * h;
  int have_handler;
  void * handler;

  h = 0B;
  have_handler = 0;
  handler = 0B;
  D.10899 = acquire_mutex (&signals_mutex);
  if (D.10899 == -1) goto <D.10900>; else goto <D.10901>;
  <D.10900>:
  D.10902 = 0B;
  return D.10902;
  <D.10901>:
  D.10903 = __libc_current_sigrtmin ();
  if (D.10903 <= sig) goto <D.10904>; else goto <D.10905>;
  <D.10904>:
  D.10906 = __libc_current_sigrtmax ();
  if (D.10906 >= sig) goto <D.10907>; else goto <D.10908>;
  <D.10907>:
  D.10909 = count_handlers (sig);
  if (D.10909 == 0) goto <D.10910>; else goto <D.10911>;
  <D.10910>:
  {
    struct sigaction sinfo;

    try
      {
        sigaction (sig, 0B, &sinfo);
        D.10914 = sinfo.__sigaction_handler.sa_handler;
        if (D.10914 != 0B) goto <D.10912>; else goto <D.10915>;
        <D.10915>:
        D.10916 = sinfo.__sigaction_handler.sa_sigaction;
        if (D.10916 != 0B) goto <D.10912>; else goto <D.10913>;
        <D.10912>:
        pthread_mutex_unlock (&signals_mutex);
        D.10917 = __errno_location ();
        *D.10917 = 98;
        D.10902 = 0B;
        return D.10902;
        <D.10913>:
      }
    finally
      {
        sinfo = {CLOBBER};
      }
  }
  <D.10911>:
  <D.10908>:
  <D.10905>:
  i = 0;
  goto <D.10797>;
  <D.10796>:
  if (h == 0B) goto <D.10918>; else goto <D.10919>;
  <D.10918>:
  D.10920 = signals[i].signum;
  if (D.10920 == 0) goto <D.10921>; else goto <D.10922>;
  <D.10921>:
  h = &signals[i];
  D.10923 = signal (sig, default_handler);
  h->handler = D.10923;
  D.10924 = h->handler;
  if (D.10924 == -1B) goto <D.10925>; else goto <D.10926>;
  <D.10925>:
  h->handler = 0B;
  h = 0B;
  goto <D.10795>;
  <D.10926>:
  h->have_handler = 1;
  <D.10922>:
  <D.10919>:
  if (have_handler == 0) goto <D.10927>; else goto <D.10928>;
  <D.10927>:
  D.10920 = signals[i].signum;
  if (D.10920 == sig) goto <D.10929>; else goto <D.10930>;
  <D.10929>:
  D.10931 = signals[i].handler;
  if (D.10931 != default_handler) goto <D.10932>; else goto <D.10933>;
  <D.10932>:
  have_handler = 1;
  handler = signals[i].handler;
  <D.10933>:
  <D.10930>:
  <D.10928>:
  D.10934 = h != 0B;
  D.10935 = have_handler != 0;
  D.10936 = D.10934 & D.10935;
  if (D.10936 != 0) goto <D.10795>; else goto <D.10937>;
  <D.10937>:
  i = i + 1;
  <D.10797>:
  if (i <= 63) goto <D.10796>; else goto <D.10795>;
  <D.10795>:
  D.10934 = h != 0B;
  D.10935 = have_handler != 0;
  D.10936 = D.10934 & D.10935;
  if (D.10936 != 0) goto <D.10938>; else goto <D.10939>;
  <D.10938>:
  h->have_handler = 1;
  h->handler = handler;
  <D.10939>:
  if (h != 0B) goto <D.10940>; else goto <D.10941>;
  <D.10940>:
  D.10942 = &h->count;
  InterlockedExchange (D.10942, 0);
  D.10943 = &h->signum;
  InterlockedExchange (D.10943, sig);
  D.10944 = &h->pipecnt;
  InterlockedExchange (D.10944, 0);
  <D.10941>:
  release_mutex (&signals_mutex);
  D.10902 = h;
  return D.10902;
}


default_handler (int signum)
{
  int * D.10948;
  int D.10949;
  int * D.10952;
  int * D.10953;
  char c.1;
  int * D.10957;
  long int D.10958;
  int D.10959;
  int i;

  i = 0;
  goto <D.10784>;
  <D.10783>:
  {
    int fd;
    struct signal_info * h;

    h = &signals[i];
    D.10948 = &h->signum;
    D.10949 = InterlockedExchangeAdd (D.10948, 0);
    if (D.10949 != signum) goto <D.10950>; else goto <D.10951>;
    <D.10950>:
    // predicted unlikely by continue predictor.
    goto <D.10773>;
    <D.10951>:
    D.10952 = &h->count;
    InterlockedIncrement (D.10952);
    D.10953 = &h->write_fd;
    fd = InterlockedExchangeAdd (D.10953, 0);
    if (fd > 0) goto <D.10954>; else goto <D.10955>;
    <D.10954>:
    {
      int j;
      int pipecounter;
      char c;

      try
        {
          c.1 = (char) signum;
          c = c.1;
          D.10957 = &h->pipecnt;
          pipecounter = InterlockedExchangeAdd (D.10957, 0);
          j = 0;
          goto <D.10781>;
          <D.10780>:
          {
            int r;

            <D.10778>:
            D.10958 = write (fd, &c, 1);
            r = (int) D.10958;
            D.10959 = keep_trying (r);
            if (D.10959 != 0) goto <D.10778>; else goto <D.10779>;
            <D.10779>:
            fsync (fd);
          }
          j = j + 1;
          <D.10781>:
          if (j < pipecounter) goto <D.10780>; else goto <D.10782>;
          <D.10782>:
        }
      finally
        {
          c = {CLOBBER};
        }
    }
    <D.10955>:
  }
  <D.10773>:
  i = i + 1;
  <D.10784>:
  if (i <= 63) goto <D.10783>; else goto <D.10785>;
  <D.10785>:
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.10960;
  unsigned int D.10961;

  D.10961 = __sync_add_and_fetch_4 (val, 1);
  D.10960 = (gint32) D.10961;
  return D.10960;
}


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.10963;
  unsigned int add.2;
  unsigned int D.10965;

  add.2 = (unsigned int) add;
  D.10965 = __sync_fetch_and_add_4 (val, add.2);
  D.10963 = (gint32) D.10965;
  return D.10963;
}


keep_trying (int r)
{
  int D.10967;
  int iftmp.3;
  int * D.10972;
  int D.10973;

  if (r == -1) goto <D.10971>; else goto <D.10969>;
  <D.10971>:
  D.10972 = __errno_location ();
  D.10973 = *D.10972;
  if (D.10973 == 4) goto <D.10974>; else goto <D.10969>;
  <D.10974>:
  iftmp.3 = 1;
  goto <D.10970>;
  <D.10969>:
  iftmp.3 = 0;
  <D.10970>:
  D.10967 = iftmp.3;
  return D.10967;
}


acquire_mutex (union pthread_mutex_t * mutex)
{
  _Bool D.10976;
  _Bool D.10977;
  _Bool D.10978;
  int * D.10981;
  int D.10982;
  int mr;

  goto <D.10755>;
  <D.10754>:
  <D.10755>:
  mr = pthread_mutex_lock (mutex);
  if (mr == 11) goto <D.10754>; else goto <D.10756>;
  <D.10756>:
  D.10976 = mr != 0;
  D.10977 = mr != 35;
  D.10978 = D.10976 & D.10977;
  if (D.10978 != 0) goto <D.10979>; else goto <D.10980>;
  <D.10979>:
  D.10981 = __errno_location ();
  *D.10981 = mr;
  D.10982 = -1;
  return D.10982;
  <D.10980>:
  D.10982 = 0;
  return D.10982;
}


count_handlers (int signum)
{
  int D.10984;
  int D.10987;
  int i;
  int count;

  count = 0;
  i = 0;
  goto <D.10804>;
  <D.10803>:
  D.10984 = signals[i].signum;
  if (D.10984 == signum) goto <D.10985>; else goto <D.10986>;
  <D.10985>:
  count = count + 1;
  <D.10986>:
  i = i + 1;
  <D.10804>:
  if (i <= 63) goto <D.10803>; else goto <D.10805>;
  <D.10805>:
  D.10987 = count;
  return D.10987;
}


InterlockedExchange (volatile gint32 * val, gint32 new_val)
{
  unsigned int new_val.4;
  unsigned int old_val.5;
  unsigned int D.10991;
  int D.10992;
  gint32 D.10993;
  gint32 old_val;

  <D.8616>:
  old_val = *val;
  new_val.4 = (unsigned int) new_val;
  old_val.5 = (unsigned int) old_val;
  D.10991 = __sync_val_compare_and_swap_4 (val, old_val.5, new_val.4);
  D.10992 = (int) D.10991;
  if (D.10992 != old_val) goto <D.8616>; else goto <D.8617>;
  <D.8617>:
  D.10993 = old_val;
  return D.10993;
}


release_mutex (union pthread_mutex_t * mutex)
{
  int mr;

  goto <D.10762>;
  <D.10761>:
  <D.10762>:
  mr = pthread_mutex_unlock (mutex);
  if (mr == 11) goto <D.10761>; else goto <D.10763>;
  <D.10763>:
}


Mono_Unix_UnixSignal_uninstall (void * info)
{
  int D.10995;
  int D.10998;
  int * D.11004;
  int D.11005;
  int D.11008;
  int D.11009;
  void * D.11012;
  void (*<T40d>) (int) D.11013;
  struct signal_info * h;
  int r;

  r = -1;
  D.10995 = acquire_mutex (&signals_mutex);
  if (D.10995 == -1) goto <D.10996>; else goto <D.10997>;
  <D.10996>:
  D.10998 = -1;
  return D.10998;
  <D.10997>:
  h = info;
  if (h == 0B) goto <D.10999>; else goto <D.11002>;
  <D.11002>:
  if (h < &signals) goto <D.10999>; else goto <D.11003>;
  <D.11003>:
  if (h > &signals[64]) goto <D.10999>; else goto <D.11000>;
  <D.10999>:
  D.11004 = __errno_location ();
  *D.11004 = 22;
  goto <D.11001>;
  <D.11000>:
  D.11005 = h->have_handler;
  if (D.11005 != 0) goto <D.11006>; else goto <D.11007>;
  <D.11006>:
  D.11008 = h->signum;
  D.11009 = count_handlers (D.11008);
  if (D.11009 == 1) goto <D.11010>; else goto <D.11011>;
  <D.11010>:
  {
    void (*mph_sighandler_t) (int) p;

    D.11012 = h->handler;
    D.11013 = (void (*<T40d>) (int)) D.11012;
    D.11008 = h->signum;
    p = signal (D.11008, D.11013);
    if (p != -1B) goto <D.11014>; else goto <D.11015>;
    <D.11014>:
    r = 0;
    <D.11015>:
    h->handler = 0B;
    h->have_handler = 0;
  }
  <D.11011>:
  <D.11007>:
  h->signum = 0;
  <D.11001>:
  release_mutex (&signals_mutex);
  D.10998 = r;
  return D.10998;
}


Mono_Unix_UnixSignal_WaitAny (void * * _signals, int count, int timeout, int (*Mono_Posix_RuntimeIsShuttingDown) (void) shutting_down)
{
  int D.11019;
  int D.11020;
  int D.11025;
  int r;
  int currfd;
  struct pollfd fd_structs[64];
  struct signal_info * * signals;

  try
    {
      currfd = 0;
      signals = _signals;
      if (count > 64) goto <D.11017>; else goto <D.11018>;
      <D.11017>:
      D.11019 = -1;
      return D.11019;
      <D.11018>:
      D.11020 = acquire_mutex (&signals_mutex);
      if (D.11020 == -1) goto <D.11021>; else goto <D.11022>;
      <D.11021>:
      D.11019 = -1;
      return D.11019;
      <D.11022>:
      r = setup_pipes (signals, count, &fd_structs[0], &currfd);
      release_mutex (&signals_mutex);
      if (r == 0) goto <D.11023>; else goto <D.11024>;
      <D.11023>:
      r = wait_for_any (signals, count, &currfd, &fd_structs[0], timeout, shutting_down);
      <D.11024>:
      D.11025 = acquire_mutex (&signals_mutex);
      if (D.11025 == -1) goto <D.11026>; else goto <D.11027>;
      <D.11026>:
      D.11019 = -1;
      return D.11019;
      <D.11027>:
      teardown_pipes (signals, count);
      release_mutex (&signals_mutex);
      D.11019 = r;
      return D.11019;
    }
  finally
    {
      currfd = {CLOBBER};
      fd_structs = {CLOBBER};
    }
}


setup_pipes (struct signal_info * * signals, int count, struct pollfd * fd_structs, int * currfd)
{
  long unsigned int D.11030;
  long unsigned int D.11031;
  struct signal_info * * D.11032;
  int * D.11033;
  int D.11034;
  int D.11038;
  int D.11039;
  int D.11040;
  long unsigned int D.11041;
  long unsigned int D.11042;
  struct pollfd * D.11043;
  int D.11044;
  int D.11045;
  int D.11046;
  int i;
  int r;

  r = 0;
  i = 0;
  goto <D.10824>;
  <D.10823>:
  {
    struct signal_info * h;
    int filedes[2];

    try
      {
        D.11030 = (long unsigned int) i;
        D.11031 = D.11030 * 8;
        D.11032 = signals + D.11031;
        h = *D.11032;
        D.11033 = &h->pipecnt;
        D.11034 = InterlockedExchangeAdd (D.11033, 0);
        if (D.11034 == 0) goto <D.11035>; else goto <D.11036>;
        <D.11035>:
        r = pipe (&filedes);
        if (r != 0) goto <D.10822>; else goto <D.11037>;
        <D.11037>:
        D.11038 = filedes[0];
        h->read_fd = D.11038;
        D.11039 = filedes[1];
        h->write_fd = D.11039;
        <D.11036>:
        D.11033 = &h->pipecnt;
        InterlockedIncrement (D.11033);
        D.11040 = *currfd;
        D.11041 = (long unsigned int) D.11040;
        D.11042 = D.11041 * 8;
        D.11043 = fd_structs + D.11042;
        D.11044 = h->read_fd;
        D.11043->fd = D.11044;
        D.11040 = *currfd;
        D.11041 = (long unsigned int) D.11040;
        D.11042 = D.11041 * 8;
        D.11043 = fd_structs + D.11042;
        D.11043->events = 1;
        D.11040 = *currfd;
        D.11045 = D.11040 + 1;
        *currfd = D.11045;
      }
    finally
      {
        filedes = {CLOBBER};
      }
  }
  i = i + 1;
  <D.10824>:
  if (i < count) goto <D.10823>; else goto <D.10822>;
  <D.10822>:
  D.11046 = r;
  return D.11046;
}


wait_for_any (struct signal_info * * signals, int count, int * currfd, struct pollfd * fd_structs, int timeout, int (*Mono_Posix_RuntimeIsShuttingDown) (void) shutting_down)
{
  int D.11052;
  long int D.11053;
  int D.11054;
  int D.11055;
  long int D.11056;
  long unsigned int D.11057;
  int D.11058;
  int D.11060;
  long unsigned int D.11066;
  long unsigned int D.11067;
  struct signal_info * * D.11068;
  struct pollfd * D.11069;
  short int D.11070;
  int D.11071;
  int D.11072;
  int D.11075;
  long int D.11076;
  int D.11077;
  int D.11079;
  int D.11082;
  int r;
  int idx;

  <D.10846>:
  {
    struct timeval tv;
    struct timeval * ptv;

    try
      {
        ptv = 0B;
        if (timeout != -1) goto <D.11050>; else goto <D.11051>;
        <D.11050>:
        D.11052 = timeout / 1000;
        D.11053 = (long int) D.11052;
        tv.tv_sec = D.11053;
        D.11054 = timeout % 1000;
        D.11055 = D.11054 * 1000;
        D.11056 = (long int) D.11055;
        tv.tv_usec = D.11056;
        ptv = &tv;
        <D.11051>:
        D.11057 = (long unsigned int) count;
        r = poll (fd_structs, D.11057, timeout);
      }
    finally
      {
        tv = {CLOBBER};
      }
  }
  D.11058 = keep_trying (r);
  if (D.11058 != 0) goto <D.11059>; else goto <D.10847>;
  <D.11059>:
  D.11060 = shutting_down ();
  if (D.11060 == 0) goto <D.10846>; else goto <D.10847>;
  <D.10847>:
  idx = -1;
  if (r == 0) goto <D.11061>; else goto <D.11062>;
  <D.11061>:
  idx = timeout;
  goto <D.11063>;
  <D.11062>:
  if (r > 0) goto <D.11064>; else goto <D.11065>;
  <D.11064>:
  {
    int i;

    i = 0;
    goto <D.10855>;
    <D.10854>:
    {
      struct signal_info * h;

      D.11066 = (long unsigned int) i;
      D.11067 = D.11066 * 8;
      D.11068 = signals + D.11067;
      h = *D.11068;
      D.11066 = (long unsigned int) i;
      D.11067 = D.11066 * 8;
      D.11069 = fd_structs + D.11067;
      D.11070 = D.11069->revents;
      D.11071 = (int) D.11070;
      D.11072 = D.11071 & 1;
      if (D.11072 != 0) goto <D.11073>; else goto <D.11074>;
      <D.11073>:
      {
        int r;
        char c;

        try
          {
            <D.10852>:
            D.11075 = h->read_fd;
            D.11076 = read (D.11075, &c, 1);
            r = (int) D.11076;
            D.11077 = keep_trying (r);
            if (D.11077 != 0) goto <D.11078>; else goto <D.10853>;
            <D.11078>:
            D.11079 = shutting_down ();
            if (D.11079 == 0) goto <D.10852>; else goto <D.10853>;
            <D.10853>:
            if (idx == -1) goto <D.11080>; else goto <D.11081>;
            <D.11080>:
            idx = i;
            <D.11081>:
          }
        finally
          {
            c = {CLOBBER};
          }
      }
      <D.11074>:
    }
    i = i + 1;
    <D.10855>:
    if (i < count) goto <D.10854>; else goto <D.10856>;
    <D.10856>:
  }
  <D.11065>:
  <D.11063>:
  D.11082 = idx;
  return D.11082;
}


poll (struct pollfd * __fds, nfds_t __nfds, int __timeout)
{
  long unsigned int D.11084;
  int D.11087;
  int D.11090;
  long unsigned int D.11091;
  long unsigned int D.11092;
  long unsigned int D.11093;
  long unsigned int D.11096;

  D.11084 = __builtin_object_size (__fds, 1);
  if (D.11084 != 18446744073709551615) goto <D.11085>; else goto <D.11086>;
  <D.11085>:
  D.11087 = __builtin_constant_p (__nfds);
  if (D.11087 == 0) goto <D.11088>; else goto <D.11089>;
  <D.11088>:
  D.11091 = __builtin_object_size (__fds, 1);
  D.11090 = __poll_chk (__fds, __nfds, __timeout, D.11091);
  return D.11090;
  <D.11089>:
  D.11092 = __builtin_object_size (__fds, 1);
  D.11093 = D.11092 / 8;
  if (D.11093 < __nfds) goto <D.11094>; else goto <D.11095>;
  <D.11094>:
  D.11096 = __builtin_object_size (__fds, 1);
  D.11090 = __poll_chk_warn (__fds, __nfds, __timeout, D.11096);
  return D.11090;
  <D.11095>:
  <D.11086>:
  D.11090 = __poll_alias (__fds, __nfds, __timeout);
  return D.11090;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.11098;
  int D.11101;
  ssize_t D.11104;
  long unsigned int D.11105;
  long unsigned int D.11106;
  long unsigned int D.11109;

  D.11098 = __builtin_object_size (__buf, 0);
  if (D.11098 != 18446744073709551615) goto <D.11099>; else goto <D.11100>;
  <D.11099>:
  D.11101 = __builtin_constant_p (__nbytes);
  if (D.11101 == 0) goto <D.11102>; else goto <D.11103>;
  <D.11102>:
  D.11105 = __builtin_object_size (__buf, 0);
  D.11104 = __read_chk (__fd, __buf, __nbytes, D.11105);
  return D.11104;
  <D.11103>:
  D.11106 = __builtin_object_size (__buf, 0);
  if (D.11106 < __nbytes) goto <D.11107>; else goto <D.11108>;
  <D.11107>:
  D.11109 = __builtin_object_size (__buf, 0);
  D.11104 = __read_chk_warn (__fd, __buf, __nbytes, D.11109);
  return D.11104;
  <D.11108>:
  <D.11100>:
  D.11104 = __read_alias (__fd, __buf, __nbytes);
  return D.11104;
}


teardown_pipes (struct signal_info * * signals, int count)
{
  long unsigned int D.11111;
  long unsigned int D.11112;
  struct signal_info * * D.11113;
  int * D.11114;
  int D.11115;
  int D.11118;
  int D.11121;
  int i;

  i = 0;
  goto <D.10832>;
  <D.10831>:
  {
    struct signal_info * h;

    D.11111 = (long unsigned int) i;
    D.11112 = D.11111 * 8;
    D.11113 = signals + D.11112;
    h = *D.11113;
    D.11114 = &h->pipecnt;
    D.11115 = InterlockedDecrement (D.11114);
    if (D.11115 == 0) goto <D.11116>; else goto <D.11117>;
    <D.11116>:
    D.11118 = h->read_fd;
    if (D.11118 != 0) goto <D.11119>; else goto <D.11120>;
    <D.11119>:
    D.11118 = h->read_fd;
    close (D.11118);
    <D.11120>:
    D.11121 = h->write_fd;
    if (D.11121 != 0) goto <D.11122>; else goto <D.11123>;
    <D.11122>:
    D.11121 = h->write_fd;
    close (D.11121);
    <D.11123>:
    h->read_fd = 0;
    h->write_fd = 0;
    <D.11117>:
  }
  i = i + 1;
  <D.10832>:
  if (i < count) goto <D.10831>; else goto <D.10833>;
  <D.10833>:
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.11124;
  unsigned int D.11125;

  D.11125 = __sync_sub_and_fetch_4 (val, 1);
  D.11124 = (gint32) D.11125;
  return D.11124;
}