socket_close (void * handle, void * data)
{
  unsigned int startup_count.0;
  unsigned int in_cleanup.1;
  long int handle.2;
  int D.12727;
  int * D.12729;
  int D.12730;
  int D.12732;
  unsigned int errnum.3;
  unsigned int D.12736;
  int ret;
  struct _WapiHandle_socket * socket_handle;
  static const char __func__[13] = "socket_close";

  socket_handle = data;
  startup_count.0 = startup_count;
  if (startup_count.0 == 0) goto <D.12721>; else goto <D.12722>;
  <D.12721>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.12724>; else goto <D.12725>;
  <D.12724>:
  WSASetLastError (10093);
  return;
  <D.12725>:
  <D.12722>:
  handle.2 = (long int) handle;
  D.12727 = (int) handle.2;
  shutdown (D.12727, 0);
  <D.12320>:
  handle.2 = (long int) handle;
  D.12727 = (int) handle.2;
  ret = close (D.12727);
  if (ret == -1) goto <D.12728>; else goto <D.12321>;
  <D.12728>:
  D.12729 = __errno_location ();
  D.12730 = *D.12729;
  if (D.12730 == 4) goto <D.12731>; else goto <D.12321>;
  <D.12731>:
  D.12732 = _wapi_thread_cur_apc_pending ();
  if (D.12732 == 0) goto <D.12320>; else goto <D.12321>;
  <D.12321>:
  if (ret == -1) goto <D.12733>; else goto <D.12734>;
  <D.12733>:
  {
    gint errnum;

    D.12729 = __errno_location ();
    errnum = *D.12729;
    errnum.3 = (unsigned int) errnum;
    D.12736 = errno_to_WSA (errnum.3, &__func__);
    errnum = (gint) D.12736;
    in_cleanup.1 = in_cleanup;
    if (in_cleanup.1 == 0) goto <D.12737>; else goto <D.12738>;
    <D.12737>:
    WSASetLastError (errnum);
    <D.12738>:
  }
  <D.12734>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.12739>; else goto <D.12740>;
  <D.12739>:
  socket_handle->saved_error = 0;
  <D.12740>:
}


WSAStartup (guint32 requested, struct WapiWSAData * data)
{
  int D.12744;
  unsigned int startup_count.4;
  unsigned int startup_count.5;
  short unsigned int D.12749;
  unsigned int D.12750;
  unsigned int D.12751;
  short unsigned int D.12752;
  char[257] * D.12753;
  char[129] * D.12754;

  if (data == 0B) goto <D.12742>; else goto <D.12743>;
  <D.12742>:
  D.12744 = 10014;
  return D.12744;
  <D.12743>:
  if (requested <= 1) goto <D.12745>; else goto <D.12746>;
  <D.12745>:
  D.12744 = 10092;
  return D.12744;
  <D.12746>:
  startup_count.4 = startup_count;
  startup_count.5 = startup_count.4 + 1;
  startup_count = startup_count.5;
  data->wHighVersion = 514;
  D.12749 = data->wHighVersion;
  D.12750 = (unsigned int) D.12749;
  D.12751 = MIN_EXPR <D.12750, requested>;
  D.12752 = (short unsigned int) D.12751;
  data->wVersion = D.12752;
  D.12753 = &data->szDescription;
  strncpy (D.12753, "WAPI", 256);
  D.12754 = &data->szSystemStatus;
  strncpy (D.12754, "groovy", 128);
  D.12744 = 0;
  return D.12744;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.12756;
  long unsigned int D.12757;

  D.12757 = __builtin_object_size (__dest, 1);
  D.12756 = __builtin___strncpy_chk (__dest, __src, __len, D.12757);
  return D.12756;
}


WSACleanup ()
{
  unsigned int startup_count.6;
  unsigned int startup_count.7;
  int D.12763;

  startup_count.6 = startup_count;
  startup_count.7 = startup_count.6 + 4294967295;
  startup_count = startup_count.7;
  startup_count.6 = startup_count;
  if (startup_count.6 != 0) goto <D.12761>; else goto <D.12762>;
  <D.12761>:
  D.12763 = 0;
  return D.12763;
  <D.12762>:
  in_cleanup = 1;
  _wapi_handle_foreach (7, cleanup_close, 0B);
  in_cleanup = 0;
  D.12763 = 0;
  return D.12763;
}


cleanup_close (void * handle, void * data)
{
  gboolean D.12765;

  _wapi_handle_ops_close (handle, 0B);
  D.12765 = 1;
  return D.12765;
}


WSASetLastError (int error)
{
  unsigned int error.8;

  error.8 = (unsigned int) error;
  SetLastError (error.8);
}


WSAGetLastError ()
{
  int D.12768;
  unsigned int D.12769;

  D.12769 = GetLastError ();
  D.12768 = (int) D.12769;
  return D.12768;
}


closesocket (guint32 fd)
{
  long unsigned int D.12771;
  <unnamed type> D.12772;
  int D.12775;
  void * handle;

  D.12771 = (long unsigned int) fd;
  handle = (void *) D.12771;
  D.12772 = _wapi_handle_type (handle);
  if (D.12772 != 7) goto <D.12773>; else goto <D.12774>;
  <D.12773>:
  WSASetLastError (10038);
  D.12775 = 0;
  return D.12775;
  <D.12774>:
  _wapi_handle_unref (handle);
  D.12775 = 0;
  return D.12775;
}


_wapi_handle_type (void * handle)
{
  long int handle.9;
  unsigned int D.12782;
  struct _WapiHandleUnshared * D.12783;
  WapiHandleType D.12784;
  unsigned int D.12785;
  struct _WapiHandleUnshared * D.12786;
  long unsigned int D.12787;
  long unsigned int D.12788;
  long unsigned int D.12789;
  struct _WapiHandleUnshared * D.12790;
  guint32 idx;

  handle.9 = (long int) handle;
  idx = (guint32) handle.9;
  if (idx > 4194303) goto <D.12778>; else goto <D.12780>;
  <D.12780>:
  if (idx > 268435455) goto <D.12778>; else goto <D.12781>;
  <D.12781>:
  D.12782 = idx / 256;
  D.12783 = _wapi_private_handles[D.12782];
  if (D.12783 == 0B) goto <D.12778>; else goto <D.12779>;
  <D.12778>:
  D.12784 = 0;
  return D.12784;
  <D.12779>:
  D.12785 = idx / 256;
  D.12786 = _wapi_private_handles[D.12785];
  D.12787 = (long unsigned int) idx;
  D.12788 = D.12787 & 255;
  D.12789 = D.12788 * 200;
  D.12790 = D.12786 + D.12789;
  D.12784 = D.12790->type;
  return D.12784;
}


_wapi_accept (guint32 fd, struct sockaddr * addr, socklen_t * addrlen)
{
  long unsigned int D.12792;
  unsigned int startup_count.10;
  guint32 D.12796;
  unsigned int D.12799;
  <unnamed type> D.12802;
  int fd.11;
  union 
{
  struct sockaddr * restrict __sockaddr__;
  struct sockaddr_at * restrict __sockaddr_at__;
  struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  struct sockaddr_dl * restrict __sockaddr_dl__;
  struct sockaddr_eon * restrict __sockaddr_eon__;
  struct sockaddr_in * restrict __sockaddr_in__;
  struct sockaddr_in6 * restrict __sockaddr_in6__;
  struct sockaddr_inarp * restrict __sockaddr_inarp__;
  struct sockaddr_ipx * restrict __sockaddr_ipx__;
  struct sockaddr_iso * restrict __sockaddr_iso__;
  struct sockaddr_ns * restrict __sockaddr_ns__;
  struct sockaddr_un * restrict __sockaddr_un__;
  struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.12808;
  int * D.12810;
  int D.12811;
  int D.12813;
  unsigned int errnum.12;
  unsigned int D.12817;
  unsigned int new_fd.13;
  unsigned int _wapi_fd_reserve.14;
  struct _WapiHandle_socket * socket_handle.15;
  int D.12823;
  int D.12824;
  int D.12825;
  void * handle;
  void * new_handle;
  struct _WapiHandle_socket * socket_handle;
  struct _WapiHandle_socket new_socket_handle;
  gboolean ok;
  int new_fd;
  static const char __func__[13] = "_wapi_accept";

  try
    {
      D.12792 = (long unsigned int) fd;
      handle = (void *) D.12792;
      new_socket_handle = {};
      startup_count.10 = startup_count;
      if (startup_count.10 == 0) goto <D.12794>; else goto <D.12795>;
      <D.12794>:
      WSASetLastError (10093);
      D.12796 = 4294967295;
      return D.12796;
      <D.12795>:
      if (addr != 0B) goto <D.12797>; else goto <D.12798>;
      <D.12797>:
      D.12799 = *addrlen;
      if (D.12799 <= 15) goto <D.12800>; else goto <D.12801>;
      <D.12800>:
      WSASetLastError (10014);
      D.12796 = 4294967295;
      return D.12796;
      <D.12801>:
      <D.12798>:
      D.12802 = _wapi_handle_type (handle);
      if (D.12802 != 7) goto <D.12803>; else goto <D.12804>;
      <D.12803>:
      WSASetLastError (10038);
      D.12796 = 4294967295;
      return D.12796;
      <D.12804>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12805>; else goto <D.12806>;
      <D.12805>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12796 = 4294967295;
      return D.12796;
      <D.12806>:
      <D.12357>:
      fd.11 = (int) fd;
      D.12808.__sockaddr__ = addr;
      new_fd = accept (fd.11, D.12808, addrlen);
      if (new_fd == -1) goto <D.12809>; else goto <D.12358>;
      <D.12809>:
      D.12810 = __errno_location ();
      D.12811 = *D.12810;
      if (D.12811 == 4) goto <D.12812>; else goto <D.12358>;
      <D.12812>:
      D.12813 = _wapi_thread_cur_apc_pending ();
      if (D.12813 == 0) goto <D.12357>; else goto <D.12358>;
      <D.12358>:
      if (new_fd == -1) goto <D.12814>; else goto <D.12815>;
      <D.12814>:
      {
        gint errnum;

        D.12810 = __errno_location ();
        errnum = *D.12810;
        errnum.12 = (unsigned int) errnum;
        D.12817 = errno_to_WSA (errnum.12, &__func__);
        errnum = (gint) D.12817;
        WSASetLastError (errnum);
        D.12796 = 4294967295;
        return D.12796;
      }
      <D.12815>:
      new_fd.13 = (unsigned int) new_fd;
      _wapi_fd_reserve.14 = _wapi_fd_reserve;
      if (new_fd.13 >= _wapi_fd_reserve.14) goto <D.12820>; else goto <D.12821>;
      <D.12820>:
      WSASetLastError (10107);
      close (new_fd);
      D.12796 = 4294967295;
      return D.12796;
      <D.12821>:
      socket_handle.15 = socket_handle;
      D.12823 = socket_handle.15->domain;
      new_socket_handle.domain = D.12823;
      socket_handle.15 = socket_handle;
      D.12824 = socket_handle.15->type;
      new_socket_handle.type = D.12824;
      socket_handle.15 = socket_handle;
      D.12825 = socket_handle.15->protocol;
      new_socket_handle.protocol = D.12825;
      new_socket_handle.still_readable = 1;
      new_handle = _wapi_handle_new_fd (7, new_fd, &new_socket_handle);
      if (new_handle == -1B) goto <D.12826>; else goto <D.12827>;
      <D.12826>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (31);
      D.12796 = 4294967295;
      return D.12796;
      <D.12827>:
      D.12796 = (guint32) new_fd;
      return D.12796;
    }
  finally
    {
      socket_handle = {CLOBBER};
      new_socket_handle = {CLOBBER};
    }
}


_wapi_bind (guint32 fd, struct sockaddr * my_addr, socklen_t addrlen)
{
  long unsigned int D.12830;
  unsigned int startup_count.16;
  int D.12834;
  <unnamed type> D.12835;
  int fd.17;
  union 
{
  const struct sockaddr * restrict __sockaddr__;
  const struct sockaddr_at * restrict __sockaddr_at__;
  const struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  const struct sockaddr_dl * restrict __sockaddr_dl__;
  const struct sockaddr_eon * restrict __sockaddr_eon__;
  const struct sockaddr_in * restrict __sockaddr_in__;
  const struct sockaddr_in6 * restrict __sockaddr_in6__;
  const struct sockaddr_inarp * restrict __sockaddr_inarp__;
  const struct sockaddr_ipx * restrict __sockaddr_ipx__;
  const struct sockaddr_iso * restrict __sockaddr_iso__;
  const struct sockaddr_ns * restrict __sockaddr_ns__;
  const struct sockaddr_un * restrict __sockaddr_un__;
  const struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.12839;
  int * D.12842;
  unsigned int errnum.18;
  unsigned int D.12844;
  void * handle;
  int ret;
  static const char __func__[11] = "_wapi_bind";

  D.12830 = (long unsigned int) fd;
  handle = (void *) D.12830;
  startup_count.16 = startup_count;
  if (startup_count.16 == 0) goto <D.12832>; else goto <D.12833>;
  <D.12832>:
  WSASetLastError (10093);
  D.12834 = -1;
  return D.12834;
  <D.12833>:
  D.12835 = _wapi_handle_type (handle);
  if (D.12835 != 7) goto <D.12836>; else goto <D.12837>;
  <D.12836>:
  WSASetLastError (10038);
  D.12834 = -1;
  return D.12834;
  <D.12837>:
  fd.17 = (int) fd;
  D.12839.__sockaddr__ = my_addr;
  ret = bind (fd.17, D.12839, addrlen);
  if (ret == -1) goto <D.12840>; else goto <D.12841>;
  <D.12840>:
  {
    gint errnum;

    D.12842 = __errno_location ();
    errnum = *D.12842;
    errnum.18 = (unsigned int) errnum;
    D.12844 = errno_to_WSA (errnum.18, &__func__);
    errnum = (gint) D.12844;
    WSASetLastError (errnum);
    D.12834 = -1;
    return D.12834;
  }
  <D.12841>:
  D.12834 = ret;
  return D.12834;
}


_wapi_connect (guint32 fd, const struct sockaddr * serv_addr, socklen_t addrlen)
{
  long unsigned int D.12846;
  unsigned int startup_count.19;
  int D.12850;
  <unnamed type> D.12851;
  int fd.20;
  union 
{
  const struct sockaddr * restrict __sockaddr__;
  const struct sockaddr_at * restrict __sockaddr_at__;
  const struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  const struct sockaddr_dl * restrict __sockaddr_dl__;
  const struct sockaddr_eon * restrict __sockaddr_eon__;
  const struct sockaddr_in * restrict __sockaddr_in__;
  const struct sockaddr_in6 * restrict __sockaddr_in6__;
  const struct sockaddr_inarp * restrict __sockaddr_inarp__;
  const struct sockaddr_ipx * restrict __sockaddr_ipx__;
  const struct sockaddr_iso * restrict __sockaddr_iso__;
  const struct sockaddr_ns * restrict __sockaddr_ns__;
  const struct sockaddr_un * restrict __sockaddr_un__;
  const struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.12855;
  int D.12856;
  int * D.12859;
  int D.12860;
  unsigned int errnum.21;
  unsigned int D.12864;
  struct _WapiHandle_socket * socket_handle.22;
  unsigned int D.12879;
  unsigned int D.12880;
  int D.12881;
  int D.12883;
  int D.12884;
  unsigned int D.12887;
  int so_error.23;
  unsigned int so_error.24;
  unsigned int D.12892;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  gint errnum;
  static const char __func__[14] = "_wapi_connect";

  try
    {
      D.12846 = (long unsigned int) fd;
      handle = (void *) D.12846;
      startup_count.19 = startup_count;
      if (startup_count.19 == 0) goto <D.12848>; else goto <D.12849>;
      <D.12848>:
      WSASetLastError (10093);
      D.12850 = -1;
      return D.12850;
      <D.12849>:
      D.12851 = _wapi_handle_type (handle);
      if (D.12851 != 7) goto <D.12852>; else goto <D.12853>;
      <D.12852>:
      WSASetLastError (10038);
      D.12850 = -1;
      return D.12850;
      <D.12853>:
      fd.20 = (int) fd;
      D.12855.__sockaddr__ = serv_addr;
      D.12856 = connect (fd.20, D.12855, addrlen);
      if (D.12856 == -1) goto <D.12857>; else goto <D.12858>;
      <D.12857>:
      {
        struct mono_pollfd fds;
        int so_error;
        socklen_t len;

        try
          {
            D.12859 = __errno_location ();
            errnum = *D.12859;
            D.12859 = __errno_location ();
            D.12860 = *D.12859;
            if (D.12860 != 4) goto <D.12861>; else goto <D.12862>;
            <D.12861>:
            errnum.21 = (unsigned int) errnum;
            D.12864 = errno_to_WSA (errnum.21, &__func__);
            errnum = (gint) D.12864;
            if (errnum == 10036) goto <D.12865>; else goto <D.12866>;
            <D.12865>:
            errnum = 10035;
            <D.12866>:
            WSASetLastError (errnum);
            if (errnum != 10035) goto <D.12867>; else goto <D.12868>;
            <D.12867>:
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.12869>; else goto <D.12870>;
            <D.12869>:
            if (errnum != 10054) goto <D.12871>; else goto <D.12872>;
            <D.12871>:
            if (errnum != 10050) goto <D.12873>; else goto <D.12874>;
            <D.12873>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p (error %d)", &__func__, handle, errnum);
            <D.12874>:
            <D.12872>:
            goto <D.12875>;
            <D.12870>:
            socket_handle.22 = socket_handle;
            socket_handle.22->saved_error = errnum;
            <D.12875>:
            <D.12868>:
            D.12850 = -1;
            return D.12850;
            <D.12862>:
            fd.20 = (int) fd;
            fds.fd = fd.20;
            fds.events = 4;
            goto <D.12383>;
            <D.12382>:
            D.12859 = __errno_location ();
            D.12860 = *D.12859;
            if (D.12860 != 4) goto <D.12877>; else goto <D.12878>;
            <D.12877>:
            D.12859 = __errno_location ();
            D.12860 = *D.12859;
            D.12879 = (unsigned int) D.12860;
            D.12880 = errno_to_WSA (D.12879, &__func__);
            errnum = (gint) D.12880;
            WSASetLastError (errnum);
            D.12850 = -1;
            return D.12850;
            <D.12878>:
            <D.12383>:
            D.12881 = mono_poll (&fds, 1, -1);
            if (D.12881 == -1) goto <D.12882>; else goto <D.12384>;
            <D.12882>:
            D.12883 = _wapi_thread_cur_apc_pending ();
            if (D.12883 == 0) goto <D.12382>; else goto <D.12384>;
            <D.12384>:
            len = 4;
            fd.20 = (int) fd;
            D.12884 = getsockopt (fd.20, 1, 4, &so_error, &len);
            if (D.12884 == -1) goto <D.12885>; else goto <D.12886>;
            <D.12885>:
            D.12859 = __errno_location ();
            D.12860 = *D.12859;
            D.12879 = (unsigned int) D.12860;
            D.12887 = errno_to_WSA (D.12879, &__func__);
            errnum = (gint) D.12887;
            WSASetLastError (errnum);
            D.12850 = -1;
            return D.12850;
            <D.12886>:
            so_error.23 = so_error;
            if (so_error.23 != 0) goto <D.12889>; else goto <D.12890>;
            <D.12889>:
            so_error.23 = so_error;
            so_error.24 = (unsigned int) so_error.23;
            D.12892 = errno_to_WSA (so_error.24, &__func__);
            errnum = (gint) D.12892;
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.12893>; else goto <D.12894>;
            <D.12893>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
            goto <D.12895>;
            <D.12894>:
            socket_handle.22 = socket_handle;
            socket_handle.22->saved_error = errnum;
            <D.12895>:
            WSASetLastError (errnum);
            D.12850 = -1;
            return D.12850;
            <D.12890>:
          }
        finally
          {
            fds = {CLOBBER};
            so_error = {CLOBBER};
            len = {CLOBBER};
          }
      }
      <D.12858>:
      D.12850 = 0;
      return D.12850;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_getpeername (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  long unsigned int D.12900;
  unsigned int startup_count.25;
  int D.12904;
  <unnamed type> D.12905;
  int fd.26;
  union 
{
  struct sockaddr * restrict __sockaddr__;
  struct sockaddr_at * restrict __sockaddr_at__;
  struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  struct sockaddr_dl * restrict __sockaddr_dl__;
  struct sockaddr_eon * restrict __sockaddr_eon__;
  struct sockaddr_in * restrict __sockaddr_in__;
  struct sockaddr_in6 * restrict __sockaddr_in6__;
  struct sockaddr_inarp * restrict __sockaddr_inarp__;
  struct sockaddr_ipx * restrict __sockaddr_ipx__;
  struct sockaddr_iso * restrict __sockaddr_iso__;
  struct sockaddr_ns * restrict __sockaddr_ns__;
  struct sockaddr_un * restrict __sockaddr_un__;
  struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.12909;
  int * D.12912;
  unsigned int errnum.27;
  unsigned int D.12914;
  void * handle;
  int ret;
  static const char __func__[18] = "_wapi_getpeername";

  D.12900 = (long unsigned int) fd;
  handle = (void *) D.12900;
  startup_count.25 = startup_count;
  if (startup_count.25 == 0) goto <D.12902>; else goto <D.12903>;
  <D.12902>:
  WSASetLastError (10093);
  D.12904 = -1;
  return D.12904;
  <D.12903>:
  D.12905 = _wapi_handle_type (handle);
  if (D.12905 != 7) goto <D.12906>; else goto <D.12907>;
  <D.12906>:
  WSASetLastError (10038);
  D.12904 = -1;
  return D.12904;
  <D.12907>:
  fd.26 = (int) fd;
  D.12909.__sockaddr__ = name;
  ret = getpeername (fd.26, D.12909, namelen);
  if (ret == -1) goto <D.12910>; else goto <D.12911>;
  <D.12910>:
  {
    gint errnum;

    D.12912 = __errno_location ();
    errnum = *D.12912;
    errnum.27 = (unsigned int) errnum;
    D.12914 = errno_to_WSA (errnum.27, &__func__);
    errnum = (gint) D.12914;
    WSASetLastError (errnum);
    D.12904 = -1;
    return D.12904;
  }
  <D.12911>:
  D.12904 = ret;
  return D.12904;
}


_wapi_getsockname (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  long unsigned int D.12916;
  unsigned int startup_count.28;
  int D.12920;
  <unnamed type> D.12921;
  int fd.29;
  union 
{
  struct sockaddr * restrict __sockaddr__;
  struct sockaddr_at * restrict __sockaddr_at__;
  struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  struct sockaddr_dl * restrict __sockaddr_dl__;
  struct sockaddr_eon * restrict __sockaddr_eon__;
  struct sockaddr_in * restrict __sockaddr_in__;
  struct sockaddr_in6 * restrict __sockaddr_in6__;
  struct sockaddr_inarp * restrict __sockaddr_inarp__;
  struct sockaddr_ipx * restrict __sockaddr_ipx__;
  struct sockaddr_iso * restrict __sockaddr_iso__;
  struct sockaddr_ns * restrict __sockaddr_ns__;
  struct sockaddr_un * restrict __sockaddr_un__;
  struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.12925;
  int * D.12928;
  unsigned int errnum.30;
  unsigned int D.12930;
  void * handle;
  int ret;
  static const char __func__[18] = "_wapi_getsockname";

  D.12916 = (long unsigned int) fd;
  handle = (void *) D.12916;
  startup_count.28 = startup_count;
  if (startup_count.28 == 0) goto <D.12918>; else goto <D.12919>;
  <D.12918>:
  WSASetLastError (10093);
  D.12920 = -1;
  return D.12920;
  <D.12919>:
  D.12921 = _wapi_handle_type (handle);
  if (D.12921 != 7) goto <D.12922>; else goto <D.12923>;
  <D.12922>:
  WSASetLastError (10038);
  D.12920 = -1;
  return D.12920;
  <D.12923>:
  fd.29 = (int) fd;
  D.12925.__sockaddr__ = name;
  ret = getsockname (fd.29, D.12925, namelen);
  if (ret == -1) goto <D.12926>; else goto <D.12927>;
  <D.12926>:
  {
    gint errnum;

    D.12928 = __errno_location ();
    errnum = *D.12928;
    errnum.30 = (unsigned int) errnum;
    D.12930 = errno_to_WSA (errnum.30, &__func__);
    errnum = (gint) D.12930;
    WSASetLastError (errnum);
    D.12920 = -1;
    return D.12920;
  }
  <D.12927>:
  D.12920 = ret;
  return D.12920;
}


_wapi_getsockopt (guint32 fd, int level, int optname, void * optval, socklen_t * optlen)
{
  long unsigned int D.12932;
  unsigned int startup_count.31;
  int D.12936;
  <unnamed type> D.12937;
  unsigned int optname.32;
  unsigned int D.12943;
  int fd.33;
  int * D.12949;
  unsigned int errnum.34;
  unsigned int D.12951;
  long int D.12956;
  unsigned int D.12957;
  unsigned int D.12958;
  long int D.12959;
  long int D.12960;
  unsigned int D.12961;
  unsigned int D.12962;
  int D.12963;
  int D.12968;
  unsigned int D.12969;
  unsigned int D.12970;
  int D.12971;
  unsigned int D.12975;
  int D.12976;
  struct _WapiHandle_socket * socket_handle.35;
  int D.12979;
  void * handle;
  int ret;
  struct timeval tv;
  void * tmp_val;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  static const char __func__[17] = "_wapi_getsockopt";

  try
    {
      D.12932 = (long unsigned int) fd;
      handle = (void *) D.12932;
      startup_count.31 = startup_count;
      if (startup_count.31 == 0) goto <D.12934>; else goto <D.12935>;
      <D.12934>:
      WSASetLastError (10093);
      D.12936 = -1;
      return D.12936;
      <D.12935>:
      D.12937 = _wapi_handle_type (handle);
      if (D.12937 != 7) goto <D.12938>; else goto <D.12939>;
      <D.12938>:
      WSASetLastError (10038);
      D.12936 = -1;
      return D.12936;
      <D.12939>:
      tmp_val = optval;
      if (level == 1) goto <D.12940>; else goto <D.12941>;
      <D.12940>:
      optname.32 = (unsigned int) optname;
      D.12943 = optname.32 + 4294967278;
      if (D.12943 <= 1) goto <D.12944>; else goto <D.12945>;
      <D.12944>:
      tmp_val = &tv;
      *optlen = 16;
      <D.12945>:
      <D.12941>:
      fd.33 = (int) fd;
      ret = getsockopt (fd.33, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.12947>; else goto <D.12948>;
      <D.12947>:
      {
        gint errnum;

        D.12949 = __errno_location ();
        errnum = *D.12949;
        errnum.34 = (unsigned int) errnum;
        D.12951 = errno_to_WSA (errnum.34, &__func__);
        errnum = (gint) D.12951;
        WSASetLastError (errnum);
        D.12936 = -1;
        return D.12936;
      }
      <D.12948>:
      if (level == 1) goto <D.12952>; else goto <D.12953>;
      <D.12952>:
      optname.32 = (unsigned int) optname;
      D.12943 = optname.32 + 4294967278;
      if (D.12943 <= 1) goto <D.12954>; else goto <D.12955>;
      <D.12954>:
      D.12956 = tv.tv_sec;
      D.12957 = (unsigned int) D.12956;
      D.12958 = D.12957 * 1000;
      D.12959 = tv.tv_usec;
      D.12960 = D.12959 / 1000;
      D.12961 = (unsigned int) D.12960;
      D.12962 = D.12958 + D.12961;
      D.12963 = (int) D.12962;
      MEM[(int *)optval] = D.12963;
      *optlen = 4;
      <D.12955>:
      <D.12953>:
      if (optname == 4) goto <D.12964>; else goto <D.12965>;
      <D.12964>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12966>; else goto <D.12967>;
      <D.12966>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      D.12968 = MEM[(int *)optval];
      D.12969 = (unsigned int) D.12968;
      D.12970 = errno_to_WSA (D.12969, &__func__);
      D.12971 = (int) D.12970;
      MEM[(int *)optval] = D.12971;
      goto <D.12972>;
      <D.12967>:
      D.12968 = MEM[(int *)optval];
      if (D.12968 != 0) goto <D.12973>; else goto <D.12974>;
      <D.12973>:
      D.12968 = MEM[(int *)optval];
      D.12969 = (unsigned int) D.12968;
      D.12975 = errno_to_WSA (D.12969, &__func__);
      D.12976 = (int) D.12975;
      MEM[(int *)optval] = D.12976;
      socket_handle.35 = socket_handle;
      D.12968 = MEM[(int *)optval];
      socket_handle.35->saved_error = D.12968;
      goto <D.12978>;
      <D.12974>:
      socket_handle.35 = socket_handle;
      D.12979 = socket_handle.35->saved_error;
      MEM[(int *)optval] = D.12979;
      <D.12978>:
      <D.12972>:
      <D.12965>:
      D.12936 = ret;
      return D.12936;
    }
  finally
    {
      tv = {CLOBBER};
      socket_handle = {CLOBBER};
    }
}


_wapi_listen (guint32 fd, int backlog)
{
  long unsigned int D.12982;
  unsigned int startup_count.36;
  int D.12986;
  <unnamed type> D.12987;
  int fd.37;
  int * D.12993;
  unsigned int errnum.38;
  unsigned int D.12995;
  void * handle;
  int ret;
  static const char __func__[13] = "_wapi_listen";

  D.12982 = (long unsigned int) fd;
  handle = (void *) D.12982;
  startup_count.36 = startup_count;
  if (startup_count.36 == 0) goto <D.12984>; else goto <D.12985>;
  <D.12984>:
  WSASetLastError (10093);
  D.12986 = -1;
  return D.12986;
  <D.12985>:
  D.12987 = _wapi_handle_type (handle);
  if (D.12987 != 7) goto <D.12988>; else goto <D.12989>;
  <D.12988>:
  WSASetLastError (10038);
  D.12986 = -1;
  return D.12986;
  <D.12989>:
  fd.37 = (int) fd;
  ret = listen (fd.37, backlog);
  if (ret == -1) goto <D.12991>; else goto <D.12992>;
  <D.12991>:
  {
    gint errnum;

    D.12993 = __errno_location ();
    errnum = *D.12993;
    errnum.38 = (unsigned int) errnum;
    D.12995 = errno_to_WSA (errnum.38, &__func__);
    errnum = (gint) D.12995;
    WSASetLastError (errnum);
    D.12986 = -1;
    return D.12986;
  }
  <D.12992>:
  D.12986 = 0;
  return D.12986;
}


_wapi_recv (guint32 fd, void * buf, size_t len, int recv_flags)
{
  int D.12997;

  D.12997 = _wapi_recvfrom (fd, buf, len, recv_flags, 0B, 0B);
  return D.12997;
}


_wapi_recvfrom (guint32 fd, void * buf, size_t len, int recv_flags, struct sockaddr * from, socklen_t * fromlen)
{
  long unsigned int D.12999;
  unsigned int startup_count.39;
  int D.13003;
  <unnamed type> D.13004;
  int fd.40;
  union 
{
  struct sockaddr * restrict __sockaddr__;
  struct sockaddr_at * restrict __sockaddr_at__;
  struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  struct sockaddr_dl * restrict __sockaddr_dl__;
  struct sockaddr_eon * restrict __sockaddr_eon__;
  struct sockaddr_in * restrict __sockaddr_in__;
  struct sockaddr_in6 * restrict __sockaddr_in6__;
  struct sockaddr_inarp * restrict __sockaddr_inarp__;
  struct sockaddr_ipx * restrict __sockaddr_ipx__;
  struct sockaddr_iso * restrict __sockaddr_iso__;
  struct sockaddr_ns * restrict __sockaddr_ns__;
  struct sockaddr_un * restrict __sockaddr_un__;
  struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.13008;
  long int D.13009;
  int * D.13011;
  int D.13012;
  int D.13014;
  struct _WapiHandle_socket * socket_handle.41;
  int D.13023;
  unsigned int errnum.42;
  unsigned int D.13027;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  int ret;
  static const char __func__[15] = "_wapi_recvfrom";

  try
    {
      D.12999 = (long unsigned int) fd;
      handle = (void *) D.12999;
      startup_count.39 = startup_count;
      if (startup_count.39 == 0) goto <D.13001>; else goto <D.13002>;
      <D.13001>:
      WSASetLastError (10093);
      D.13003 = -1;
      return D.13003;
      <D.13002>:
      D.13004 = _wapi_handle_type (handle);
      if (D.13004 != 7) goto <D.13005>; else goto <D.13006>;
      <D.13005>:
      WSASetLastError (10038);
      D.13003 = -1;
      return D.13003;
      <D.13006>:
      <D.12444>:
      fd.40 = (int) fd;
      D.13008.__sockaddr__ = from;
      D.13009 = recvfrom (fd.40, buf, len, recv_flags, D.13008, fromlen);
      ret = (int) D.13009;
      if (ret == -1) goto <D.13010>; else goto <D.12445>;
      <D.13010>:
      D.13011 = __errno_location ();
      D.13012 = *D.13011;
      if (D.13012 == 4) goto <D.13013>; else goto <D.12445>;
      <D.13013>:
      D.13014 = _wapi_thread_cur_apc_pending ();
      if (D.13014 == 0) goto <D.12444>; else goto <D.12445>;
      <D.12445>:
      if (ret == 0) goto <D.13015>; else goto <D.13016>;
      <D.13015>:
      if (len != 0) goto <D.13017>; else goto <D.13018>;
      <D.13017>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.13019>; else goto <D.13021>;
      <D.13021>:
      socket_handle.41 = socket_handle;
      D.13023 = socket_handle.41->still_readable;
      if (D.13023 != 1) goto <D.13019>; else goto <D.13020>;
      <D.13019>:
      ret = -1;
      D.13011 = __errno_location ();
      *D.13011 = 4;
      <D.13020>:
      <D.13018>:
      <D.13016>:
      if (ret == -1) goto <D.13024>; else goto <D.13025>;
      <D.13024>:
      {
        gint errnum;

        D.13011 = __errno_location ();
        errnum = *D.13011;
        errnum.42 = (unsigned int) errnum;
        D.13027 = errno_to_WSA (errnum.42, &__func__);
        errnum = (gint) D.13027;
        WSASetLastError (errnum);
        D.13003 = -1;
        return D.13003;
      }
      <D.13025>:
      D.13003 = ret;
      return D.13003;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


recvfrom (int __fd, void * restrict __buf, size_t __n, int __flags, union __SOCKADDR_ARG __addr, socklen_t * restrict __addr_len)
{
  long unsigned int D.13030;
  int D.13033;
  ssize_t D.13036;
  long unsigned int D.13037;
  long unsigned int D.13038;
  long unsigned int D.13041;

  D.13030 = __builtin_object_size (__buf, 0);
  if (D.13030 != 18446744073709551615) goto <D.13031>; else goto <D.13032>;
  <D.13031>:
  D.13033 = __builtin_constant_p (__n);
  if (D.13033 == 0) goto <D.13034>; else goto <D.13035>;
  <D.13034>:
  D.13037 = __builtin_object_size (__buf, 0);
  D.13036 = __recvfrom_chk (__fd, __buf, __n, D.13037, __flags, __addr, __addr_len);
  return D.13036;
  <D.13035>:
  D.13038 = __builtin_object_size (__buf, 0);
  if (D.13038 < __n) goto <D.13039>; else goto <D.13040>;
  <D.13039>:
  D.13041 = __builtin_object_size (__buf, 0);
  D.13036 = __recvfrom_chk_warn (__fd, __buf, __n, D.13041, __flags, __addr, __addr_len);
  return D.13036;
  <D.13040>:
  <D.13032>:
  D.13036 = __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
  return D.13036;
}


_wapi_send (guint32 fd, const void * msg, size_t len, int send_flags)
{
  long unsigned int D.13043;
  unsigned int startup_count.43;
  int D.13047;
  <unnamed type> D.13048;
  int fd.44;
  long int D.13052;
  int * D.13054;
  int D.13055;
  int D.13057;
  int D.13064;
  unsigned int errnum.45;
  unsigned int D.13068;
  void * handle;
  int ret;
  static const char __func__[11] = "_wapi_send";

  D.13043 = (long unsigned int) fd;
  handle = (void *) D.13043;
  startup_count.43 = startup_count;
  if (startup_count.43 == 0) goto <D.13045>; else goto <D.13046>;
  <D.13045>:
  WSASetLastError (10093);
  D.13047 = -1;
  return D.13047;
  <D.13046>:
  D.13048 = _wapi_handle_type (handle);
  if (D.13048 != 7) goto <D.13049>; else goto <D.13050>;
  <D.13049>:
  WSASetLastError (10038);
  D.13047 = -1;
  return D.13047;
  <D.13050>:
  <D.12469>:
  fd.44 = (int) fd;
  D.13052 = send (fd.44, msg, len, send_flags);
  ret = (int) D.13052;
  if (ret == -1) goto <D.13053>; else goto <D.12470>;
  <D.13053>:
  D.13054 = __errno_location ();
  D.13055 = *D.13054;
  if (D.13055 == 4) goto <D.13056>; else goto <D.12470>;
  <D.13056>:
  D.13057 = _wapi_thread_cur_apc_pending ();
  if (D.13057 == 0) goto <D.12469>; else goto <D.12470>;
  <D.12470>:
  if (ret == -1) goto <D.13058>; else goto <D.13059>;
  <D.13058>:
  {
    gint errnum;

    D.13054 = __errno_location ();
    errnum = *D.13054;
    if (errnum == 11) goto <D.13060>; else goto <D.13061>;
    <D.13060>:
    fd.44 = (int) fd;
    ret = fcntl (fd.44, 3, 0);
    if (ret != -1) goto <D.13062>; else goto <D.13063>;
    <D.13062>:
    D.13064 = ret & 2048;
    if (D.13064 == 0) goto <D.13065>; else goto <D.13066>;
    <D.13065>:
    errnum = 110;
    <D.13066>:
    <D.13063>:
    <D.13061>:
    errnum.45 = (unsigned int) errnum;
    D.13068 = errno_to_WSA (errnum.45, &__func__);
    errnum = (gint) D.13068;
    WSASetLastError (errnum);
    D.13047 = -1;
    return D.13047;
  }
  <D.13059>:
  D.13047 = ret;
  return D.13047;
}


_wapi_sendto (guint32 fd, const void * msg, size_t len, int send_flags, const struct sockaddr * to, socklen_t tolen)
{
  long unsigned int D.13070;
  unsigned int startup_count.46;
  int D.13074;
  <unnamed type> D.13075;
  int fd.47;
  union 
{
  const struct sockaddr * restrict __sockaddr__;
  const struct sockaddr_at * restrict __sockaddr_at__;
  const struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  const struct sockaddr_dl * restrict __sockaddr_dl__;
  const struct sockaddr_eon * restrict __sockaddr_eon__;
  const struct sockaddr_in * restrict __sockaddr_in__;
  const struct sockaddr_in6 * restrict __sockaddr_in6__;
  const struct sockaddr_inarp * restrict __sockaddr_inarp__;
  const struct sockaddr_ipx * restrict __sockaddr_ipx__;
  const struct sockaddr_iso * restrict __sockaddr_iso__;
  const struct sockaddr_ns * restrict __sockaddr_ns__;
  const struct sockaddr_un * restrict __sockaddr_un__;
  const struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.13079;
  long int D.13080;
  int * D.13082;
  int D.13083;
  int D.13085;
  unsigned int errnum.48;
  unsigned int D.13089;
  void * handle;
  int ret;
  static const char __func__[13] = "_wapi_sendto";

  D.13070 = (long unsigned int) fd;
  handle = (void *) D.13070;
  startup_count.46 = startup_count;
  if (startup_count.46 == 0) goto <D.13072>; else goto <D.13073>;
  <D.13072>:
  WSASetLastError (10093);
  D.13074 = -1;
  return D.13074;
  <D.13073>:
  D.13075 = _wapi_handle_type (handle);
  if (D.13075 != 7) goto <D.13076>; else goto <D.13077>;
  <D.13076>:
  WSASetLastError (10038);
  D.13074 = -1;
  return D.13074;
  <D.13077>:
  <D.12483>:
  fd.47 = (int) fd;
  D.13079.__sockaddr__ = to;
  D.13080 = sendto (fd.47, msg, len, send_flags, D.13079, tolen);
  ret = (int) D.13080;
  if (ret == -1) goto <D.13081>; else goto <D.12484>;
  <D.13081>:
  D.13082 = __errno_location ();
  D.13083 = *D.13082;
  if (D.13083 == 4) goto <D.13084>; else goto <D.12484>;
  <D.13084>:
  D.13085 = _wapi_thread_cur_apc_pending ();
  if (D.13085 == 0) goto <D.12483>; else goto <D.12484>;
  <D.12484>:
  if (ret == -1) goto <D.13086>; else goto <D.13087>;
  <D.13086>:
  {
    gint errnum;

    D.13082 = __errno_location ();
    errnum = *D.13082;
    errnum.48 = (unsigned int) errnum;
    D.13089 = errno_to_WSA (errnum.48, &__func__);
    errnum = (gint) D.13089;
    WSASetLastError (errnum);
    D.13074 = -1;
    return D.13074;
  }
  <D.13087>:
  D.13074 = ret;
  return D.13074;
}


_wapi_setsockopt (guint32 fd, int level, int optname, const void * optval, socklen_t optlen)
{
  long unsigned int D.13091;
  unsigned int startup_count.49;
  int D.13095;
  <unnamed type> D.13096;
  unsigned int optname.50;
  unsigned int D.13103;
  int D.13105;
  long int D.13106;
  int D.13107;
  int D.13108;
  long int D.13109;
  unsigned int D.13112;
  int bufsize.51;
  int bufsize.52;
  int bufsize.53;
  int fd.54;
  int * D.13121;
  unsigned int errnum.55;
  unsigned int D.13123;
  int D.13128;
  int type.56;
  void * handle;
  int ret;
  const void * tmp_val;
  int bufsize;
  struct timeval tv;
  static const char __func__[17] = "_wapi_setsockopt";

  try
    {
      D.13091 = (long unsigned int) fd;
      handle = (void *) D.13091;
      bufsize = 0;
      startup_count.49 = startup_count;
      if (startup_count.49 == 0) goto <D.13093>; else goto <D.13094>;
      <D.13093>:
      WSASetLastError (10093);
      D.13095 = -1;
      return D.13095;
      <D.13094>:
      D.13096 = _wapi_handle_type (handle);
      if (D.13096 != 7) goto <D.13097>; else goto <D.13098>;
      <D.13097>:
      WSASetLastError (10038);
      D.13095 = -1;
      return D.13095;
      <D.13098>:
      tmp_val = optval;
      if (level == 1) goto <D.13101>; else goto <D.13099>;
      <D.13101>:
      optname.50 = (unsigned int) optname;
      D.13103 = optname.50 + 4294967278;
      if (D.13103 <= 1) goto <D.13104>; else goto <D.13099>;
      <D.13104>:
      {
        int ms;

        ms = MEM[(int *)optval];
        D.13105 = ms / 1000;
        D.13106 = (long int) D.13105;
        tv.tv_sec = D.13106;
        D.13107 = ms % 1000;
        D.13108 = D.13107 * 1000;
        D.13109 = (long int) D.13108;
        tv.tv_usec = D.13109;
        tmp_val = &tv;
        optlen = 16;
      }
      goto <D.13100>;
      <D.13099>:
      if (level == 1) goto <D.13110>; else goto <D.13111>;
      <D.13110>:
      optname.50 = (unsigned int) optname;
      D.13112 = optname.50 + 4294967289;
      if (D.13112 <= 1) goto <D.13113>; else goto <D.13114>;
      <D.13113>:
      bufsize.51 = MEM[(int *)optval];
      bufsize = bufsize.51;
      bufsize.52 = bufsize;
      bufsize.53 = bufsize.52 / 2;
      bufsize = bufsize.53;
      tmp_val = &bufsize;
      <D.13114>:
      <D.13111>:
      <D.13100>:
      fd.54 = (int) fd;
      ret = setsockopt (fd.54, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.13119>; else goto <D.13120>;
      <D.13119>:
      {
        gint errnum;

        D.13121 = __errno_location ();
        errnum = *D.13121;
        errnum.55 = (unsigned int) errnum;
        D.13123 = errno_to_WSA (errnum.55, &__func__);
        errnum = (gint) D.13123;
        WSASetLastError (errnum);
        D.13095 = -1;
        return D.13095;
      }
      <D.13120>:
      if (level == 1) goto <D.13124>; else goto <D.13125>;
      <D.13124>:
      if (optname == 2) goto <D.13126>; else goto <D.13127>;
      <D.13126>:
      {
        int type;
        socklen_t type_len;

        try
          {
            type_len = 4;
            fd.54 = (int) fd;
            D.13128 = getsockopt (fd.54, level, 3, &type, &type_len);
            if (D.13128 == 0) goto <D.13129>; else goto <D.13130>;
            <D.13129>:
            type.56 = type;
            if (type.56 == 2) goto <D.13132>; else goto <D.13133>;
            <D.13132>:
            fd.54 = (int) fd;
            setsockopt (fd.54, level, 15, tmp_val, optlen);
            <D.13133>:
            <D.13130>:
          }
        finally
          {
            type = {CLOBBER};
            type_len = {CLOBBER};
          }
      }
      <D.13127>:
      <D.13125>:
      D.13095 = ret;
      return D.13095;
    }
  finally
    {
      bufsize = {CLOBBER};
      tv = {CLOBBER};
    }
}


_wapi_shutdown (guint32 fd, int how)
{
  long unsigned int D.13136;
  unsigned int startup_count.57;
  int D.13140;
  <unnamed type> D.13141;
  struct _WapiHandle_socket * socket_handle.58;
  int fd.59;
  int * D.13153;
  unsigned int errnum.60;
  unsigned int D.13155;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  void * handle;
  int ret;
  static const char __func__[15] = "_wapi_shutdown";

  try
    {
      D.13136 = (long unsigned int) fd;
      handle = (void *) D.13136;
      startup_count.57 = startup_count;
      if (startup_count.57 == 0) goto <D.13138>; else goto <D.13139>;
      <D.13138>:
      WSASetLastError (10093);
      D.13140 = -1;
      return D.13140;
      <D.13139>:
      D.13141 = _wapi_handle_type (handle);
      if (D.13141 != 7) goto <D.13142>; else goto <D.13143>;
      <D.13142>:
      WSASetLastError (10038);
      D.13140 = -1;
      return D.13140;
      <D.13143>:
      if (how == 0) goto <D.13144>; else goto <D.13146>;
      <D.13146>:
      if (how == 2) goto <D.13144>; else goto <D.13145>;
      <D.13144>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.13147>; else goto <D.13148>;
      <D.13147>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.13140 = -1;
      return D.13140;
      <D.13148>:
      socket_handle.58 = socket_handle;
      socket_handle.58->still_readable = 0;
      <D.13145>:
      fd.59 = (int) fd;
      ret = shutdown (fd.59, how);
      if (ret == -1) goto <D.13151>; else goto <D.13152>;
      <D.13151>:
      {
        gint errnum;

        D.13153 = __errno_location ();
        errnum = *D.13153;
        errnum.60 = (unsigned int) errnum;
        D.13155 = errno_to_WSA (errnum.60, &__func__);
        errnum = (gint) D.13155;
        WSASetLastError (errnum);
        D.13140 = -1;
        return D.13140;
      }
      <D.13152>:
      D.13140 = ret;
      return D.13140;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_socket (int domain, int type, int protocol, void * unused, guint32 unused2, guint32 unused3)
{
  int * D.13168;
  unsigned int errnum.61;
  unsigned int D.13170;
  guint32 D.13171;
  unsigned int fd.62;
  unsigned int _wapi_fd_reserve.63;
  unsigned int errnum.64;
  unsigned int D.13179;
  struct _WapiHandle_socket socket_handle;
  void * handle;
  int fd;
  static const char __func__[13] = "_wapi_socket";

  try
    {
      socket_handle = {};
      socket_handle.domain = domain;
      socket_handle.type = type;
      socket_handle.protocol = protocol;
      socket_handle.still_readable = 1;
      fd = socket (domain, type, protocol);
      if (fd == -1) goto <D.13158>; else goto <D.13159>;
      <D.13158>:
      if (domain == 2) goto <D.13160>; else goto <D.13161>;
      <D.13160>:
      if (type == 3) goto <D.13162>; else goto <D.13163>;
      <D.13162>:
      if (protocol == 0) goto <D.13164>; else goto <D.13165>;
      <D.13164>:
      socket_handle.protocol = 4;
      fd = socket (2, 3, 4);
      <D.13165>:
      <D.13163>:
      <D.13161>:
      <D.13159>:
      if (fd == -1) goto <D.13166>; else goto <D.13167>;
      <D.13166>:
      {
        gint errnum;

        D.13168 = __errno_location ();
        errnum = *D.13168;
        errnum.61 = (unsigned int) errnum;
        D.13170 = errno_to_WSA (errnum.61, &__func__);
        errnum = (gint) D.13170;
        WSASetLastError (errnum);
        D.13171 = 4294967295;
        return D.13171;
      }
      <D.13167>:
      fd.62 = (unsigned int) fd;
      _wapi_fd_reserve.63 = _wapi_fd_reserve;
      if (fd.62 >= _wapi_fd_reserve.63) goto <D.13174>; else goto <D.13175>;
      <D.13174>:
      WSASetLastError (10107);
      close (fd);
      D.13171 = 4294967295;
      return D.13171;
      <D.13175>:
      {
        int ret;
        int true;

        try
          {
            true = 1;
            ret = setsockopt (fd, 1, 2, &true, 4);
            if (ret == -1) goto <D.13176>; else goto <D.13177>;
            <D.13176>:
            {
              int errnum;

              D.13168 = __errno_location ();
              errnum = *D.13168;
              errnum.64 = (unsigned int) errnum;
              D.13179 = errno_to_WSA (errnum.64, &__func__);
              errnum = (int) D.13179;
              WSASetLastError (errnum);
              close (fd);
              D.13171 = 4294967295;
              return D.13171;
            }
            <D.13177>:
          }
        finally
          {
            true = {CLOBBER};
          }
      }
      mono_once (&socket_ops_once, socket_ops_init);
      handle = _wapi_handle_new_fd (7, fd, &socket_handle);
      if (handle == -1B) goto <D.13180>; else goto <D.13181>;
      <D.13180>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (10107);
      close (fd);
      D.13171 = 4294967295;
      return D.13171;
      <D.13181>:
      D.13171 = (guint32) fd;
      return D.13171;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


socket_ops_init ()
{

}


_wapi_gethostbyname (const char * hostname)
{
  unsigned int startup_count.65;
  struct hostent * D.13189;
  int * D.13192;
  int D.13193;
  struct hostent * he;
  static const char __func__[20] = "_wapi_gethostbyname";

  startup_count.65 = startup_count;
  if (startup_count.65 == 0) goto <D.13187>; else goto <D.13188>;
  <D.13187>:
  WSASetLastError (10093);
  D.13189 = 0B;
  return D.13189;
  <D.13188>:
  he = gethostbyname (hostname);
  if (he == 0B) goto <D.13190>; else goto <D.13191>;
  <D.13190>:
  D.13192 = __h_errno_location ();
  D.13193 = *D.13192;
  switch (D.13193) <default: <D.12550>, case 1: <D.12545>, case 2: <D.12549>, case 3: <D.12548>, case 4: <D.12547>>
  <D.12545>:
  WSASetLastError (11001);
  goto <D.12546>;
  <D.12547>:
  WSASetLastError (11004);
  goto <D.12546>;
  <D.12548>:
  WSASetLastError (11003);
  goto <D.12546>;
  <D.12549>:
  WSASetLastError (11002);
  goto <D.12546>;
  <D.12550>:
  D.13192 = __h_errno_location ();
  D.13193 = *D.13192;
  monoeg_g_log (0B, 16, "%s: Need to translate %d into winsock error", &__func__, D.13193);
  goto <D.12546>;
  <D.12546>:
  <D.13191>:
  D.13189 = he;
  return D.13189;
}


TransmitFile (guint32 socket, void * file, guint32 bytes_to_write, guint32 bytes_per_send, struct WapiOverlapped * ol, struct WapiTransmitFileBuffers * buffers, guint32 flags)
{
  long unsigned int D.13195;
  unsigned int startup_count.66;
  gboolean D.13199;
  <unnamed type> D.13200;
  void * D.13205;
  unsigned int D.13208;
  long unsigned int D.13211;
  void * D.13218;
  unsigned int D.13221;
  long unsigned int D.13224;
  unsigned int D.13227;
  void * sock;
  gint ret;

  D.13195 = (long unsigned int) socket;
  sock = (void *) D.13195;
  startup_count.66 = startup_count;
  if (startup_count.66 == 0) goto <D.13197>; else goto <D.13198>;
  <D.13197>:
  WSASetLastError (10093);
  D.13199 = 0;
  return D.13199;
  <D.13198>:
  D.13200 = _wapi_handle_type (sock);
  if (D.13200 != 7) goto <D.13201>; else goto <D.13202>;
  <D.13201>:
  WSASetLastError (10038);
  D.13199 = 0;
  return D.13199;
  <D.13202>:
  if (buffers != 0B) goto <D.13203>; else goto <D.13204>;
  <D.13203>:
  D.13205 = buffers->Head;
  if (D.13205 != 0B) goto <D.13206>; else goto <D.13207>;
  <D.13206>:
  D.13208 = buffers->HeadLength;
  if (D.13208 != 0) goto <D.13209>; else goto <D.13210>;
  <D.13209>:
  D.13205 = buffers->Head;
  D.13208 = buffers->HeadLength;
  D.13211 = (long unsigned int) D.13208;
  ret = _wapi_send (socket, D.13205, D.13211, 0);
  if (ret == -1) goto <D.13212>; else goto <D.13213>;
  <D.13212>:
  D.13199 = 0;
  return D.13199;
  <D.13213>:
  <D.13210>:
  <D.13207>:
  <D.13204>:
  ret = wapi_sendfile (socket, file, bytes_to_write, bytes_per_send, flags);
  if (ret == -1) goto <D.13214>; else goto <D.13215>;
  <D.13214>:
  D.13199 = 0;
  return D.13199;
  <D.13215>:
  if (buffers != 0B) goto <D.13216>; else goto <D.13217>;
  <D.13216>:
  D.13218 = buffers->Tail;
  if (D.13218 != 0B) goto <D.13219>; else goto <D.13220>;
  <D.13219>:
  D.13221 = buffers->TailLength;
  if (D.13221 != 0) goto <D.13222>; else goto <D.13223>;
  <D.13222>:
  D.13218 = buffers->Tail;
  D.13221 = buffers->TailLength;
  D.13224 = (long unsigned int) D.13221;
  ret = _wapi_send (socket, D.13218, D.13224, 0);
  if (ret == -1) goto <D.13225>; else goto <D.13226>;
  <D.13225>:
  D.13199 = 0;
  return D.13199;
  <D.13226>:
  <D.13223>:
  <D.13220>:
  <D.13217>:
  D.13227 = flags & 1;
  if (D.13227 != 0) goto <D.13228>; else goto <D.13229>;
  <D.13228>:
  closesocket (socket);
  <D.13229>:
  D.13199 = 1;
  return D.13199;
}


wapi_sendfile (guint32 socket, void * fd, guint32 bytes_to_write, guint32 bytes_per_send, guint32 flags)
{
  long int fd.67;
  int * D.13234;
  unsigned int errnum.68;
  unsigned int D.13236;
  gint D.13237;
  int socket.69;
  long int D.13239;
  long unsigned int D.13240;
  int D.13243;
  int D.13245;
  unsigned int D.13248;
  gint file;
  gint n;
  gint errnum;
  gssize res;
  struct stat statbuf;
  static const char __func__[14] = "wapi_sendfile";

  try
    {
      fd.67 = (long int) fd;
      file = (gint) fd.67;
      n = fstat (file, &statbuf);
      if (n == -1) goto <D.13232>; else goto <D.13233>;
      <D.13232>:
      D.13234 = __errno_location ();
      errnum = *D.13234;
      errnum.68 = (unsigned int) errnum;
      D.13236 = errno_to_WSA (errnum.68, &__func__);
      errnum = (gint) D.13236;
      WSASetLastError (errnum);
      D.13237 = -1;
      return D.13237;
      <D.13233>:
      <D.12584>:
      socket.69 = (int) socket;
      D.13239 = statbuf.st_size;
      D.13240 = (long unsigned int) D.13239;
      res = sendfile (socket.69, file, 0B, D.13240);
      if (res != -1) goto <D.13242>; else goto <D.12585>;
      <D.13242>:
      D.13234 = __errno_location ();
      D.13243 = *D.13234;
      if (D.13243 == 4) goto <D.13241>; else goto <D.13244>;
      <D.13244>:
      D.13234 = __errno_location ();
      D.13243 = *D.13234;
      if (D.13243 == 11) goto <D.13241>; else goto <D.12585>;
      <D.13241>:
      D.13245 = _wapi_thread_cur_apc_pending ();
      if (D.13245 == 0) goto <D.12584>; else goto <D.12585>;
      <D.12585>:
      if (res == -1) goto <D.13246>; else goto <D.13247>;
      <D.13246>:
      D.13234 = __errno_location ();
      errnum = *D.13234;
      errnum.68 = (unsigned int) errnum;
      D.13248 = errno_to_WSA (errnum.68, &__func__);
      errnum = (gint) D.13248;
      WSASetLastError (errnum);
      D.13237 = -1;
      return D.13237;
      <D.13247>:
      D.13237 = 0;
      return D.13237;
    }
  finally
    {
      statbuf = {CLOBBER};
    }
}


fstat (int __fd, struct stat * __statbuf)
{
  int D.13251;

  D.13251 = __fxstat (1, __fd, __statbuf);
  return D.13251;
}


WSAIoctl (guint32 fd, gint32 command, gchar * input, gint i_len, gchar * output, gint o_len, glong * written, void * unused1, void * unused2)
{
  long unsigned int D.13253;
  unsigned int startup_count.70;
  int D.13257;
  <unnamed type> D.13258;
  unsigned int i_len.71;
  unsigned int o_len.72;
  struct WapiGuid * D.13271;
  int D.13272;
  void * * D.13275;
  void * D.13276;
  gchar * D.13281;
  gchar * D.13282;
  int fd.73;
  int * D.13286;
  unsigned int errnum.74;
  unsigned int D.13288;
  unsigned int onoff.75;
  unsigned int keepalivetime.76;
  unsigned int keepalivetime.77;
  unsigned int keepalivetime.78;
  unsigned int keepaliveinterval.79;
  unsigned int keepaliveinterval.80;
  unsigned int keepaliveinterval.81;
  unsigned int errnum.82;
  unsigned int D.13309;
  unsigned int i_len.83;
  long unsigned int D.13313;
  unsigned int errnum.84;
  unsigned int D.13317;
  long unsigned int D.13325;
  long int D.13326;
  void * handle;
  int ret;
  gchar * buffer;
  static const char __func__[9] = "WSAIoctl";

  D.13253 = (long unsigned int) fd;
  handle = (void *) D.13253;
  buffer = 0B;
  startup_count.70 = startup_count;
  if (startup_count.70 == 0) goto <D.13255>; else goto <D.13256>;
  <D.13255>:
  WSASetLastError (10093);
  D.13257 = -1;
  return D.13257;
  <D.13256>:
  D.13258 = _wapi_handle_type (handle);
  if (D.13258 != 7) goto <D.13259>; else goto <D.13260>;
  <D.13259>:
  WSASetLastError (10038);
  D.13257 = -1;
  return D.13257;
  <D.13260>:
  if (command == -939524090) goto <D.13261>; else goto <D.13262>;
  <D.13261>:
  {
    int i;
    struct WapiGuid * guid;

    i = 0;
    guid = input;
    i_len.71 = (unsigned int) i_len;
    if (i_len.71 <= 15) goto <D.13264>; else goto <D.13265>;
    <D.13264>:
    WSASetLastError (10022);
    D.13257 = -1;
    return D.13257;
    <D.13265>:
    o_len.72 = (unsigned int) o_len;
    if (o_len.72 <= 7) goto <D.13267>; else goto <D.13268>;
    <D.13267>:
    WSASetLastError (10022);
    D.13257 = -1;
    return D.13257;
    <D.13268>:
    if (output == 0B) goto <D.13269>; else goto <D.13270>;
    <D.13269>:
    WSASetLastError (10022);
    D.13257 = -1;
    return D.13257;
    <D.13270>:
    goto <D.12618>;
    <D.12617>:
    D.13271 = &extension_functions[i].guid;
    D.13272 = memcmp (guid, D.13271, 16);
    if (D.13272 == 0) goto <D.13273>; else goto <D.13274>;
    <D.13273>:
    D.13275 = &extension_functions[i].func;
    memcpy (output, D.13275, 8);
    *written = 8;
    D.13257 = 0;
    return D.13257;
    <D.13274>:
    i = i + 1;
    <D.12618>:
    D.13276 = extension_functions[i].func;
    if (D.13276 != 0B) goto <D.12617>; else goto <D.12619>;
    <D.12619>:
    WSASetLastError (10022);
    D.13257 = -1;
    return D.13257;
  }
  <D.13262>:
  if (command == -1744830460) goto <D.13277>; else goto <D.13278>;
  <D.13277>:
  {
    uint32_t onoff;
    uint32_t keepalivetime;
    uint32_t keepaliveinterval;

    try
      {
        i_len.71 = (unsigned int) i_len;
        if (i_len.71 <= 11) goto <D.13279>; else goto <D.13280>;
        <D.13279>:
        WSASetLastError (10022);
        D.13257 = -1;
        return D.13257;
        <D.13280>:
        memcpy (&onoff, input, 4);
        D.13281 = input + 4;
        memcpy (&keepalivetime, D.13281, 4);
        D.13282 = input + 8;
        memcpy (&keepaliveinterval, D.13282, 4);
        fd.73 = (int) fd;
        ret = setsockopt (fd.73, 1, 9, &onoff, 4);
        if (ret < 0) goto <D.13284>; else goto <D.13285>;
        <D.13284>:
        {
          gint errnum;

          D.13286 = __errno_location ();
          errnum = *D.13286;
          errnum.74 = (unsigned int) errnum;
          D.13288 = errno_to_WSA (errnum.74, &__func__);
          errnum = (gint) D.13288;
          WSASetLastError (errnum);
          D.13257 = -1;
          return D.13257;
        }
        <D.13285>:
        onoff.75 = onoff;
        if (onoff.75 != 0) goto <D.13290>; else goto <D.13291>;
        <D.13290>:
        {
          uint32_t rem;

          keepalivetime.76 = keepalivetime;
          rem = keepalivetime.76 % 1000;
          keepalivetime.76 = keepalivetime;
          keepalivetime.77 = keepalivetime.76 / 1000;
          keepalivetime = keepalivetime.77;
          keepalivetime.76 = keepalivetime;
          if (keepalivetime.76 == 0) goto <D.13294>; else goto <D.13296>;
          <D.13296>:
          if (rem > 499) goto <D.13294>; else goto <D.13295>;
          <D.13294>:
          keepalivetime.76 = keepalivetime;
          keepalivetime.78 = keepalivetime.76 + 1;
          keepalivetime = keepalivetime.78;
          <D.13295>:
          fd.73 = (int) fd;
          ret = setsockopt (fd.73, 6, 4, &keepalivetime, 4);
          if (ret == 0) goto <D.13298>; else goto <D.13299>;
          <D.13298>:
          keepaliveinterval.79 = keepaliveinterval;
          rem = keepaliveinterval.79 % 1000;
          keepaliveinterval.79 = keepaliveinterval;
          keepaliveinterval.80 = keepaliveinterval.79 / 1000;
          keepaliveinterval = keepaliveinterval.80;
          keepaliveinterval.79 = keepaliveinterval;
          if (keepaliveinterval.79 == 0) goto <D.13302>; else goto <D.13304>;
          <D.13304>:
          if (rem > 499) goto <D.13302>; else goto <D.13303>;
          <D.13302>:
          keepaliveinterval.79 = keepaliveinterval;
          keepaliveinterval.81 = keepaliveinterval.79 + 1;
          keepaliveinterval = keepaliveinterval.81;
          <D.13303>:
          fd.73 = (int) fd;
          ret = setsockopt (fd.73, 6, 5, &keepaliveinterval, 4);
          <D.13299>:
          if (ret != 0) goto <D.13306>; else goto <D.13307>;
          <D.13306>:
          {
            gint errnum;

            D.13286 = __errno_location ();
            errnum = *D.13286;
            errnum.82 = (unsigned int) errnum;
            D.13309 = errno_to_WSA (errnum.82, &__func__);
            errnum = (gint) D.13309;
            WSASetLastError (errnum);
            D.13257 = -1;
            return D.13257;
          }
          <D.13307>:
          D.13257 = 0;
          return D.13257;
        }
        <D.13291>:
        D.13257 = 0;
        return D.13257;
      }
    finally
      {
        onoff = {CLOBBER};
        keepalivetime = {CLOBBER};
        keepaliveinterval = {CLOBBER};
      }
  }
  <D.13278>:
  if (i_len > 0) goto <D.13310>; else goto <D.13311>;
  <D.13310>:
  i_len.83 = (unsigned int) i_len;
  buffer = monoeg_g_memdup (input, i_len.83);
  <D.13311>:
  fd.73 = (int) fd;
  D.13313 = (long unsigned int) command;
  ret = ioctl (fd.73, D.13313, buffer);
  if (ret == -1) goto <D.13314>; else goto <D.13315>;
  <D.13314>:
  {
    gint errnum;

    D.13286 = __errno_location ();
    errnum = *D.13286;
    errnum.84 = (unsigned int) errnum;
    D.13317 = errno_to_WSA (errnum.84, &__func__);
    errnum = (gint) D.13317;
    WSASetLastError (errnum);
    monoeg_g_free (buffer);
    D.13257 = -1;
    return D.13257;
  }
  <D.13315>:
  if (buffer == 0B) goto <D.13318>; else goto <D.13319>;
  <D.13318>:
  *written = 0;
  goto <D.13320>;
  <D.13319>:
  i_len = MIN_EXPR <i_len, o_len>;
  if (i_len > 0) goto <D.13321>; else goto <D.13322>;
  <D.13321>:
  if (output != 0B) goto <D.13323>; else goto <D.13324>;
  <D.13323>:
  D.13325 = (long unsigned int) i_len;
  memcpy (output, buffer, D.13325);
  <D.13324>:
  <D.13322>:
  monoeg_g_free (buffer);
  D.13326 = (long int) i_len;
  *written = D.13326;
  <D.13320>:
  D.13257 = 0;
  return D.13257;
}


wapi_disconnectex (guint32 fd, struct WapiOverlapped * overlapped, guint32 flags, guint32 reserved)
{
  gboolean D.13331;

  if (reserved != 0) goto <D.13329>; else goto <D.13330>;
  <D.13329>:
  WSASetLastError (10022);
  D.13331 = 0;
  return D.13331;
  <D.13330>:
  D.13331 = socket_disconnect (fd);
  return D.13331;
}


socket_disconnect (guint32 fd)
{
  long unsigned int D.13333;
  gboolean D.13336;
  struct _WapiHandle_socket * socket_handle.85;
  int D.13338;
  int D.13339;
  int D.13340;
  int * D.13343;
  unsigned int errnum.86;
  unsigned int D.13345;
  int fd.87;
  int D.13348;
  unsigned int errnum.88;
  unsigned int D.13352;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  void * handle;
  int newsock;
  int ret;
  static const char __func__[18] = "socket_disconnect";

  try
    {
      D.13333 = (long unsigned int) fd;
      handle = (void *) D.13333;
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.13334>; else goto <D.13335>;
      <D.13334>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.13336 = 0;
      return D.13336;
      <D.13335>:
      socket_handle.85 = socket_handle;
      D.13338 = socket_handle.85->domain;
      socket_handle.85 = socket_handle;
      D.13339 = socket_handle.85->type;
      socket_handle.85 = socket_handle;
      D.13340 = socket_handle.85->protocol;
      newsock = socket (D.13338, D.13339, D.13340);
      if (newsock == -1) goto <D.13341>; else goto <D.13342>;
      <D.13341>:
      {
        gint errnum;

        D.13343 = __errno_location ();
        errnum = *D.13343;
        errnum.86 = (unsigned int) errnum;
        D.13345 = errno_to_WSA (errnum.86, &__func__);
        errnum = (gint) D.13345;
        WSASetLastError (errnum);
        D.13336 = 0;
        return D.13336;
      }
      <D.13342>:
      <D.12562>:
      fd.87 = (int) fd;
      ret = dup2 (newsock, fd.87);
      if (ret == -1) goto <D.13347>; else goto <D.12563>;
      <D.13347>:
      D.13343 = __errno_location ();
      D.13348 = *D.13343;
      if (D.13348 == 11) goto <D.12562>; else goto <D.12563>;
      <D.12563>:
      if (ret == -1) goto <D.13349>; else goto <D.13350>;
      <D.13349>:
      {
        gint errnum;

        D.13343 = __errno_location ();
        errnum = *D.13343;
        errnum.88 = (unsigned int) errnum;
        D.13352 = errno_to_WSA (errnum.88, &__func__);
        errnum = (gint) D.13352;
        WSASetLastError (errnum);
        D.13336 = 0;
        return D.13336;
      }
      <D.13350>:
      close (newsock);
      D.13336 = 1;
      return D.13336;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.13355;
  long unsigned int D.13356;

  D.13356 = __builtin_object_size (__dest, 0);
  D.13355 = __builtin___memcpy_chk (__dest, __src, __len, D.13356);
  return D.13355;
}


ioctlsocket (guint32 fd, gint32 command, void * arg)
{
  long unsigned int D.13358;
  unsigned int startup_count.89;
  int D.13362;
  <unnamed type> D.13363;
  int fd.90;
  int D.13369;
  long unsigned int D.13373;
  int * D.13376;
  unsigned int errnum.91;
  unsigned int D.13378;
  void * handle;
  int ret;
  static const char __func__[12] = "ioctlsocket";

  D.13358 = (long unsigned int) fd;
  handle = (void *) D.13358;
  startup_count.89 = startup_count;
  if (startup_count.89 == 0) goto <D.13360>; else goto <D.13361>;
  <D.13360>:
  WSASetLastError (10093);
  D.13362 = -1;
  return D.13362;
  <D.13361>:
  D.13363 = _wapi_handle_type (handle);
  if (D.13363 != 7) goto <D.13364>; else goto <D.13365>;
  <D.13364>:
  WSASetLastError (10038);
  D.13362 = -1;
  return D.13362;
  <D.13365>:
  switch (command) <default: <D.12639>, case -2147195266: <D.12635>, case 35077: <D.12637>, case 1074030207: <D.12638>>
  <D.12635>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 3, 0);
  if (ret != -1) goto <D.13367>; else goto <D.13368>;
  <D.13367>:
  D.13369 = MEM[(gboolean *)arg];
  if (D.13369 != 0) goto <D.13370>; else goto <D.13371>;
  <D.13370>:
  ret = ret | 2048;
  goto <D.13372>;
  <D.13371>:
  ret = ret & -2049;
  <D.13372>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 4, ret);
  <D.13368>:
  goto <D.12636>;
  <D.12637>:
  fd.90 = (int) fd;
  D.13373 = (long unsigned int) command;
  ret = ioctl (fd.90, D.13373, arg);
  goto <D.12636>;
  <D.12638>:
  fd.90 = (int) fd;
  D.13373 = (long unsigned int) command;
  ret = ioctl (fd.90, D.13373, arg);
  goto <D.12636>;
  <D.12639>:
  WSASetLastError (10022);
  D.13362 = -1;
  return D.13362;
  <D.12636>:
  if (ret == -1) goto <D.13374>; else goto <D.13375>;
  <D.13374>:
  {
    gint errnum;

    D.13376 = __errno_location ();
    errnum = *D.13376;
    errnum.91 = (unsigned int) errnum;
    D.13378 = errno_to_WSA (errnum.91, &__func__);
    errnum = (gint) D.13378;
    WSASetLastError (errnum);
    D.13362 = -1;
    return D.13362;
  }
  <D.13375>:
  D.13362 = 0;
  return D.13362;
}


_wapi_select (int nfds, struct fd_set * readfds, struct fd_set * writefds, struct fd_set * exceptfds, struct timeval * timeout)
{
  unsigned int startup_count.92;
  int D.13383;
  long int D.12652;
  long int iftmp.93;
  int D.13389;
  long int iftmp.94;
  unsigned long __d.95;
  long int D.13398;
  int D.13399;
  long int D.13400;
  long int D.13401;
  long int D.12654;
  long int iftmp.96;
  int D.13404;
  long int iftmp.97;
  unsigned long __d.98;
  long int D.13413;
  long int D.13414;
  long int D.13415;
  long int D.12656;
  long int iftmp.99;
  int D.13418;
  long int iftmp.100;
  unsigned long __d.101;
  long int D.13427;
  long int D.13428;
  long int D.13429;
  int D.13432;
  int * D.13434;
  int D.13435;
  int D.13437;
  unsigned int errnum.102;
  unsigned int D.13441;
  int ret;
  int maxfd;
  static const char __func__[13] = "_wapi_select";

  startup_count.92 = startup_count;
  if (startup_count.92 == 0) goto <D.13381>; else goto <D.13382>;
  <D.13381>:
  WSASetLastError (10093);
  D.13383 = -1;
  return D.13383;
  <D.13382>:
  maxfd = 1023;
  goto <D.12659>;
  <D.12658>:
  if (readfds != 0B) goto <D.13387>; else goto <D.13384>;
  <D.13387>:
  {
    long int __d;

    __d = (long int) maxfd;
    D.13389 = __builtin_constant_p (__d);
    if (D.13389 != 0) goto <D.13390>; else goto <D.13391>;
    <D.13390>:
    __d.95 = (unsigned long) __d;
    if (__d.95 <= 1023) goto <D.13394>; else goto <D.13395>;
    <D.13394>:
    iftmp.94 = __d / 64;
    goto <D.13396>;
    <D.13395>:
    iftmp.94 = __fdelt_warn (__d);
    <D.13396>:
    iftmp.93 = iftmp.94;
    goto <D.13397>;
    <D.13391>:
    iftmp.93 = __fdelt_chk (__d);
    <D.13397>:
    D.12652 = iftmp.93;
  }
  D.13398 = readfds->fds_bits[D.12652];
  D.13399 = maxfd % 64;
  D.13400 = D.13398 >> D.13399;
  D.13401 = D.13400 & 1;
  if (D.13401 != 0) goto <D.12657>; else goto <D.13384>;
  <D.13384>:
  if (writefds != 0B) goto <D.13402>; else goto <D.13385>;
  <D.13402>:
  {
    long int __d;

    __d = (long int) maxfd;
    D.13404 = __builtin_constant_p (__d);
    if (D.13404 != 0) goto <D.13405>; else goto <D.13406>;
    <D.13405>:
    __d.98 = (unsigned long) __d;
    if (__d.98 <= 1023) goto <D.13409>; else goto <D.13410>;
    <D.13409>:
    iftmp.97 = __d / 64;
    goto <D.13411>;
    <D.13410>:
    iftmp.97 = __fdelt_warn (__d);
    <D.13411>:
    iftmp.96 = iftmp.97;
    goto <D.13412>;
    <D.13406>:
    iftmp.96 = __fdelt_chk (__d);
    <D.13412>:
    D.12654 = iftmp.96;
  }
  D.13413 = writefds->fds_bits[D.12654];
  D.13399 = maxfd % 64;
  D.13414 = D.13413 >> D.13399;
  D.13415 = D.13414 & 1;
  if (D.13415 != 0) goto <D.12657>; else goto <D.13385>;
  <D.13385>:
  if (exceptfds != 0B) goto <D.13416>; else goto <D.13386>;
  <D.13416>:
  {
    long int __d;

    __d = (long int) maxfd;
    D.13418 = __builtin_constant_p (__d);
    if (D.13418 != 0) goto <D.13419>; else goto <D.13420>;
    <D.13419>:
    __d.101 = (unsigned long) __d;
    if (__d.101 <= 1023) goto <D.13423>; else goto <D.13424>;
    <D.13423>:
    iftmp.100 = __d / 64;
    goto <D.13425>;
    <D.13424>:
    iftmp.100 = __fdelt_warn (__d);
    <D.13425>:
    iftmp.99 = iftmp.100;
    goto <D.13426>;
    <D.13420>:
    iftmp.99 = __fdelt_chk (__d);
    <D.13426>:
    D.12656 = iftmp.99;
  }
  D.13427 = exceptfds->fds_bits[D.12656];
  D.13399 = maxfd % 64;
  D.13428 = D.13427 >> D.13399;
  D.13429 = D.13428 & 1;
  if (D.13429 != 0) goto <D.12657>; else goto <D.13386>;
  <D.13386>:
  maxfd = maxfd + -1;
  <D.12659>:
  if (maxfd >= 0) goto <D.12658>; else goto <D.12657>;
  <D.12657>:
  if (maxfd == -1) goto <D.13430>; else goto <D.13431>;
  <D.13430>:
  WSASetLastError (10022);
  D.13383 = -1;
  return D.13383;
  <D.13431>:
  <D.12660>:
  D.13432 = maxfd + 1;
  ret = select (D.13432, readfds, writefds, exceptfds, timeout);
  if (ret == -1) goto <D.13433>; else goto <D.12661>;
  <D.13433>:
  D.13434 = __errno_location ();
  D.13435 = *D.13434;
  if (D.13435 == 4) goto <D.13436>; else goto <D.12661>;
  <D.13436>:
  D.13437 = _wapi_thread_cur_apc_pending ();
  if (D.13437 == 0) goto <D.12660>; else goto <D.12661>;
  <D.12661>:
  if (ret == -1) goto <D.13438>; else goto <D.13439>;
  <D.13438>:
  {
    gint errnum;

    D.13434 = __errno_location ();
    errnum = *D.13434;
    errnum.102 = (unsigned int) errnum;
    D.13441 = errno_to_WSA (errnum.102, &__func__);
    errnum = (gint) D.13441;
    WSASetLastError (errnum);
    D.13383 = -1;
    return D.13383;
  }
  <D.13439>:
  D.13383 = ret;
  return D.13383;
}


_wapi_FD_CLR (guint32 fd, struct fd_set * set)
{
  long unsigned int D.13443;
  <unnamed type> D.13446;
  long int D.12670;
  long int iftmp.103;
  int D.13450;
  long int iftmp.104;
  unsigned long __d.105;
  long int D.13459;
  long int D.13460;
  int fd.106;
  int D.13462;
  long int D.13463;
  long int D.13464;
  long int D.13465;
  void * handle;

  D.13443 = (long unsigned int) fd;
  handle = (void *) D.13443;
  if (fd > 1023) goto <D.13444>; else goto <D.13445>;
  <D.13444>:
  WSASetLastError (10022);
  return;
  <D.13445>:
  D.13446 = _wapi_handle_type (handle);
  if (D.13446 != 7) goto <D.13447>; else goto <D.13448>;
  <D.13447>:
  WSASetLastError (10038);
  return;
  <D.13448>:
  {
    long int __d;

    __d = (long int) fd;
    D.13450 = __builtin_constant_p (__d);
    if (D.13450 != 0) goto <D.13451>; else goto <D.13452>;
    <D.13451>:
    __d.105 = (unsigned long) __d;
    if (__d.105 <= 1023) goto <D.13455>; else goto <D.13456>;
    <D.13455>:
    iftmp.104 = __d / 64;
    goto <D.13457>;
    <D.13456>:
    iftmp.104 = __fdelt_warn (__d);
    <D.13457>:
    iftmp.103 = iftmp.104;
    goto <D.13458>;
    <D.13452>:
    iftmp.103 = __fdelt_chk (__d);
    <D.13458>:
    D.12670 = iftmp.103;
  }
  D.13459 = D.12670;
  D.13460 = set->fds_bits[D.13459];
  fd.106 = (int) fd;
  D.13462 = fd.106 & 63;
  D.13463 = 1 << D.13462;
  D.13464 = ~D.13463;
  D.13465 = D.13460 & D.13464;
  set->fds_bits[D.13459] = D.13465;
}


_wapi_FD_ISSET (guint32 fd, struct fd_set * set)
{
  long unsigned int D.13467;
  int D.13470;
  <unnamed type> D.13471;
  long int D.12677;
  long int iftmp.107;
  int D.13475;
  long int iftmp.108;
  unsigned long __d.109;
  long int D.13484;
  int fd.110;
  int D.13486;
  long int D.13487;
  long int D.13488;
  _Bool D.13489;
  void * handle;

  D.13467 = (long unsigned int) fd;
  handle = (void *) D.13467;
  if (fd > 1023) goto <D.13468>; else goto <D.13469>;
  <D.13468>:
  WSASetLastError (10022);
  D.13470 = 0;
  return D.13470;
  <D.13469>:
  D.13471 = _wapi_handle_type (handle);
  if (D.13471 != 7) goto <D.13472>; else goto <D.13473>;
  <D.13472>:
  WSASetLastError (10038);
  D.13470 = 0;
  return D.13470;
  <D.13473>:
  {
    long int __d;

    __d = (long int) fd;
    D.13475 = __builtin_constant_p (__d);
    if (D.13475 != 0) goto <D.13476>; else goto <D.13477>;
    <D.13476>:
    __d.109 = (unsigned long) __d;
    if (__d.109 <= 1023) goto <D.13480>; else goto <D.13481>;
    <D.13480>:
    iftmp.108 = __d / 64;
    goto <D.13482>;
    <D.13481>:
    iftmp.108 = __fdelt_warn (__d);
    <D.13482>:
    iftmp.107 = iftmp.108;
    goto <D.13483>;
    <D.13477>:
    iftmp.107 = __fdelt_chk (__d);
    <D.13483>:
    D.12677 = iftmp.107;
  }
  D.13484 = set->fds_bits[D.12677];
  fd.110 = (int) fd;
  D.13486 = fd.110 & 63;
  D.13487 = D.13484 >> D.13486;
  D.13488 = D.13487 & 1;
  D.13489 = D.13488 != 0;
  D.13470 = (int) D.13489;
  return D.13470;
}


_wapi_FD_SET (guint32 fd, struct fd_set * set)
{
  long unsigned int D.13491;
  <unnamed type> D.13494;
  long int D.12684;
  long int iftmp.111;
  int D.13498;
  long int iftmp.112;
  unsigned long __d.113;
  long int D.13507;
  long int D.13508;
  int fd.114;
  int D.13510;
  long int D.13511;
  long int D.13512;
  void * handle;

  D.13491 = (long unsigned int) fd;
  handle = (void *) D.13491;
  if (fd > 1023) goto <D.13492>; else goto <D.13493>;
  <D.13492>:
  WSASetLastError (10022);
  return;
  <D.13493>:
  D.13494 = _wapi_handle_type (handle);
  if (D.13494 != 7) goto <D.13495>; else goto <D.13496>;
  <D.13495>:
  WSASetLastError (10038);
  return;
  <D.13496>:
  {
    long int __d;

    __d = (long int) fd;
    D.13498 = __builtin_constant_p (__d);
    if (D.13498 != 0) goto <D.13499>; else goto <D.13500>;
    <D.13499>:
    __d.113 = (unsigned long) __d;
    if (__d.113 <= 1023) goto <D.13503>; else goto <D.13504>;
    <D.13503>:
    iftmp.112 = __d / 64;
    goto <D.13505>;
    <D.13504>:
    iftmp.112 = __fdelt_warn (__d);
    <D.13505>:
    iftmp.111 = iftmp.112;
    goto <D.13506>;
    <D.13500>:
    iftmp.111 = __fdelt_chk (__d);
    <D.13506>:
    D.12684 = iftmp.111;
  }
  D.13507 = D.12684;
  D.13508 = set->fds_bits[D.13507];
  fd.114 = (int) fd;
  D.13510 = fd.114 & 63;
  D.13511 = 1 << D.13510;
  D.13512 = D.13508 | D.13511;
  set->fds_bits[D.13507] = D.13512;
}


WSARecv (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * received, guint32 * flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.13514;
  long int D.13515;
  long int D.13516;
  _Bool D.13519;
  long int D.13520;
  long int D.13521;
  unsigned int D.13524;
  int D.13525;
  int D.13528;
  unsigned int ret.115;
  int D.13530;
  unsigned int D.13531;
  int ret;
  struct msghdr hdr;

  try
    {
      D.13514 = overlapped != 0B;
      D.13515 = (long int) D.13514;
      D.13516 = __builtin_expect (D.13515, 0);
      if (D.13516 != 0) goto <D.13517>; else goto <D.13518>;
      <D.13517>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1554, "overlapped == NULL");
      <D.13518>:
      D.13519 = complete != 0B;
      D.13520 = (long int) D.13519;
      D.13521 = __builtin_expect (D.13520, 0);
      if (D.13521 != 0) goto <D.13522>; else goto <D.13523>;
      <D.13522>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1555, "complete == NULL");
      <D.13523>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      D.13524 = *flags;
      D.13525 = (int) D.13524;
      ret = _wapi_recvmsg (fd, &hdr, D.13525);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.13526>; else goto <D.13527>;
      <D.13526>:
      D.13528 = ret;
      return D.13528;
      <D.13527>:
      ret.115 = (unsigned int) ret;
      *received = ret.115;
      D.13530 = hdr.msg_flags;
      D.13531 = (unsigned int) D.13530;
      *flags = D.13531;
      D.13528 = 0;
      return D.13528;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


wsabuf_to_msghdr (struct WapiWSABuf * buffers, guint32 count, struct msghdr * hdr)
{
  long unsigned int D.13534;
  long unsigned int D.13535;
  long unsigned int D.13536;
  void * D.13537;
  struct iovec * D.13538;
  long unsigned int D.13539;
  long unsigned int D.13540;
  struct iovec * D.13541;
  struct WapiWSABuf * D.13542;
  void * D.13543;
  unsigned int D.13544;
  long unsigned int D.13545;
  guint32 i;

  memset (hdr, 0, 56);
  D.13534 = (long unsigned int) count;
  hdr->msg_iovlen = D.13534;
  D.13535 = (long unsigned int) count;
  D.13536 = D.13535 * 16;
  D.13537 = monoeg_malloc0 (D.13536);
  hdr->msg_iov = D.13537;
  i = 0;
  goto <D.12692>;
  <D.12691>:
  D.13538 = hdr->msg_iov;
  D.13539 = (long unsigned int) i;
  D.13540 = D.13539 * 16;
  D.13541 = D.13538 + D.13540;
  D.13539 = (long unsigned int) i;
  D.13540 = D.13539 * 16;
  D.13542 = buffers + D.13540;
  D.13543 = D.13542->buf;
  D.13541->iov_base = D.13543;
  D.13538 = hdr->msg_iov;
  D.13539 = (long unsigned int) i;
  D.13540 = D.13539 * 16;
  D.13541 = D.13538 + D.13540;
  D.13539 = (long unsigned int) i;
  D.13540 = D.13539 * 16;
  D.13542 = buffers + D.13540;
  D.13544 = D.13542->len;
  D.13545 = (long unsigned int) D.13544;
  D.13541->iov_len = D.13545;
  i = i + 1;
  <D.12692>:
  if (i < count) goto <D.12691>; else goto <D.12693>;
  <D.12693>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.13548;
  int D.13553;
  void * D.13555;
  long unsigned int D.13556;

  D.13548 = __builtin_constant_p (__len);
  if (D.13548 != 0) goto <D.13549>; else goto <D.13550>;
  <D.13549>:
  if (__len == 0) goto <D.13551>; else goto <D.13552>;
  <D.13551>:
  D.13553 = __builtin_constant_p (__ch);
  if (D.13553 == 0) goto <D.13546>; else goto <D.13554>;
  <D.13554>:
  if (__ch != 0) goto <D.13546>; else goto <D.13547>;
  <D.13546>:
  __warn_memset_zero_len ();
  D.13555 = __dest;
  return D.13555;
  <D.13547>:
  <D.13552>:
  <D.13550>:
  D.13556 = __builtin_object_size (__dest, 0);
  D.13555 = __builtin___memset_chk (__dest, __ch, __len, D.13556);
  return D.13555;
}


_wapi_recvmsg (guint32 fd, struct msghdr * msg, int recv_flags)
{
  long unsigned int D.13558;
  unsigned int startup_count.116;
  int D.13562;
  <unnamed type> D.13563;
  int fd.117;
  long int D.13567;
  int * D.13569;
  int D.13570;
  int D.13572;
  struct _WapiHandle_socket * socket_handle.118;
  int D.13579;
  unsigned int errnum.119;
  unsigned int D.13583;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  int ret;
  static const char __func__[14] = "_wapi_recvmsg";

  try
    {
      D.13558 = (long unsigned int) fd;
      handle = (void *) D.13558;
      startup_count.116 = startup_count;
      if (startup_count.116 == 0) goto <D.13560>; else goto <D.13561>;
      <D.13560>:
      WSASetLastError (10093);
      D.13562 = -1;
      return D.13562;
      <D.13561>:
      D.13563 = _wapi_handle_type (handle);
      if (D.13563 != 7) goto <D.13564>; else goto <D.13565>;
      <D.13564>:
      WSASetLastError (10038);
      D.13562 = -1;
      return D.13562;
      <D.13565>:
      <D.12457>:
      fd.117 = (int) fd;
      D.13567 = recvmsg (fd.117, msg, recv_flags);
      ret = (int) D.13567;
      if (ret == -1) goto <D.13568>; else goto <D.12458>;
      <D.13568>:
      D.13569 = __errno_location ();
      D.13570 = *D.13569;
      if (D.13570 == 4) goto <D.13571>; else goto <D.12458>;
      <D.13571>:
      D.13572 = _wapi_thread_cur_apc_pending ();
      if (D.13572 == 0) goto <D.12457>; else goto <D.12458>;
      <D.12458>:
      if (ret == 0) goto <D.13573>; else goto <D.13574>;
      <D.13573>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.13575>; else goto <D.13577>;
      <D.13577>:
      socket_handle.118 = socket_handle;
      D.13579 = socket_handle.118->still_readable;
      if (D.13579 != 1) goto <D.13575>; else goto <D.13576>;
      <D.13575>:
      ret = -1;
      D.13569 = __errno_location ();
      *D.13569 = 4;
      <D.13576>:
      <D.13574>:
      if (ret == -1) goto <D.13580>; else goto <D.13581>;
      <D.13580>:
      {
        gint errnum;

        D.13569 = __errno_location ();
        errnum = *D.13569;
        errnum.119 = (unsigned int) errnum;
        D.13583 = errno_to_WSA (errnum.119, &__func__);
        errnum = (gint) D.13583;
        WSASetLastError (errnum);
        D.13562 = -1;
        return D.13562;
      }
      <D.13581>:
      D.13562 = ret;
      return D.13562;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


msghdr_iov_free (struct msghdr * hdr)
{
  struct iovec * D.13586;

  D.13586 = hdr->msg_iov;
  monoeg_g_free (D.13586);
}


WSASend (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * sent, guint32 flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.13587;
  long int D.13588;
  long int D.13589;
  _Bool D.13592;
  long int D.13593;
  long int D.13594;
  int flags.120;
  int D.13600;
  unsigned int ret.121;
  int ret;
  struct msghdr hdr;

  try
    {
      D.13587 = overlapped != 0B;
      D.13588 = (long int) D.13587;
      D.13589 = __builtin_expect (D.13588, 0);
      if (D.13589 != 0) goto <D.13590>; else goto <D.13591>;
      <D.13590>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1578, "overlapped == NULL");
      <D.13591>:
      D.13592 = complete != 0B;
      D.13593 = (long int) D.13592;
      D.13594 = __builtin_expect (D.13593, 0);
      if (D.13594 != 0) goto <D.13595>; else goto <D.13596>;
      <D.13595>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1579, "complete == NULL");
      <D.13596>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      flags.120 = (int) flags;
      ret = _wapi_sendmsg (fd, &hdr, flags.120);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.13598>; else goto <D.13599>;
      <D.13598>:
      D.13600 = ret;
      return D.13600;
      <D.13599>:
      ret.121 = (unsigned int) ret;
      *sent = ret.121;
      D.13600 = 0;
      return D.13600;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


_wapi_sendmsg (guint32 fd, const struct msghdr * msg, int send_flags)
{
  long unsigned int D.13604;
  unsigned int startup_count.122;
  int D.13608;
  <unnamed type> D.13609;
  int fd.123;
  long int D.13613;
  int * D.13615;
  int D.13616;
  int D.13618;
  unsigned int errnum.124;
  unsigned int D.13622;
  void * handle;
  int ret;
  static const char __func__[14] = "_wapi_sendmsg";

  D.13604 = (long unsigned int) fd;
  handle = (void *) D.13604;
  startup_count.122 = startup_count;
  if (startup_count.122 == 0) goto <D.13606>; else goto <D.13607>;
  <D.13606>:
  WSASetLastError (10093);
  D.13608 = -1;
  return D.13608;
  <D.13607>:
  D.13609 = _wapi_handle_type (handle);
  if (D.13609 != 7) goto <D.13610>; else goto <D.13611>;
  <D.13610>:
  WSASetLastError (10038);
  D.13608 = -1;
  return D.13608;
  <D.13611>:
  <D.12494>:
  fd.123 = (int) fd;
  D.13613 = sendmsg (fd.123, msg, send_flags);
  ret = (int) D.13613;
  if (ret == -1) goto <D.13614>; else goto <D.12495>;
  <D.13614>:
  D.13615 = __errno_location ();
  D.13616 = *D.13615;
  if (D.13616 == 4) goto <D.13617>; else goto <D.12495>;
  <D.13617>:
  D.13618 = _wapi_thread_cur_apc_pending ();
  if (D.13618 == 0) goto <D.12494>; else goto <D.12495>;
  <D.12495>:
  if (ret == -1) goto <D.13619>; else goto <D.13620>;
  <D.13619>:
  {
    gint errnum;

    D.13615 = __errno_location ();
    errnum = *D.13615;
    errnum.124 = (unsigned int) errnum;
    D.13622 = errno_to_WSA (errnum.124, &__func__);
    errnum = (gint) D.13622;
    WSASetLastError (errnum);
    D.13608 = -1;
    return D.13608;
  }
  <D.13620>:
  D.13608 = ret;
  return D.13608;
}