socket_close (void * handle, void * data)
{
  unsigned int startup_count.0;
  unsigned int in_cleanup.1;
  int handle.2;
  int * D.14429;
  int D.14430;
  int D.14432;
  unsigned int errnum.3;
  unsigned int D.14436;
  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.14422>; else goto <D.14423>;
  <D.14422>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.14425>; else goto <D.14426>;
  <D.14425>:
  WSASetLastError (10093);
  return;
  <D.14426>:
  <D.14423>:
  handle.2 = (int) handle;
  shutdown (handle.2, 0);
  <D.14019>:
  handle.2 = (int) handle;
  ret = close (handle.2);
  if (ret == -1) goto <D.14428>; else goto <D.14020>;
  <D.14428>:
  D.14429 = __errno_location ();
  D.14430 = *D.14429;
  if (D.14430 == 4) goto <D.14431>; else goto <D.14020>;
  <D.14431>:
  D.14432 = _wapi_thread_cur_apc_pending ();
  if (D.14432 == 0) goto <D.14019>; else goto <D.14020>;
  <D.14020>:
  if (ret == -1) goto <D.14433>; else goto <D.14434>;
  <D.14433>:
  {
    gint errnum;

    D.14429 = __errno_location ();
    errnum = *D.14429;
    errnum.3 = (unsigned int) errnum;
    D.14436 = errno_to_WSA (errnum.3, &__func__);
    errnum = (gint) D.14436;
    in_cleanup.1 = in_cleanup;
    if (in_cleanup.1 == 0) goto <D.14437>; else goto <D.14438>;
    <D.14437>:
    WSASetLastError (errnum);
    <D.14438>:
  }
  <D.14434>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.14439>; else goto <D.14440>;
  <D.14439>:
  socket_handle->saved_error = 0;
  <D.14440>:
}


WSAStartup (guint32 requested, struct WapiWSAData * data)
{
  int D.14444;
  unsigned int startup_count.4;
  unsigned int startup_count.5;
  short unsigned int D.14449;
  unsigned int D.14450;
  unsigned int D.14451;
  short unsigned int D.14452;
  char[257] * D.14453;
  char[129] * D.14454;

  if (data == 0B) goto <D.14442>; else goto <D.14443>;
  <D.14442>:
  D.14444 = 10014;
  return D.14444;
  <D.14443>:
  if (requested <= 1) goto <D.14445>; else goto <D.14446>;
  <D.14445>:
  D.14444 = 10092;
  return D.14444;
  <D.14446>:
  startup_count.4 = startup_count;
  startup_count.5 = startup_count.4 + 1;
  startup_count = startup_count.5;
  data->wHighVersion = 514;
  D.14449 = data->wHighVersion;
  D.14450 = (unsigned int) D.14449;
  D.14451 = MIN_EXPR <D.14450, requested>;
  D.14452 = (short unsigned int) D.14451;
  data->wVersion = D.14452;
  D.14453 = &data->szDescription;
  strncpy (D.14453, "WAPI", 256);
  D.14454 = &data->szSystemStatus;
  strncpy (D.14454, "groovy", 128);
  D.14444 = 0;
  return D.14444;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.14456;
  unsigned int D.14457;

  D.14457 = __builtin_object_size (__dest, 1);
  D.14456 = __builtin___strncpy_chk (__dest, __src, __len, D.14457);
  return D.14456;
}


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

  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.14461>; else goto <D.14462>;
  <D.14461>:
  D.14463 = 0;
  return D.14463;
  <D.14462>:
  in_cleanup = 1;
  _wapi_handle_foreach (7, cleanup_close, 0B);
  in_cleanup = 0;
  D.14463 = 0;
  return D.14463;
}


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

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


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

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


WSAGetLastError ()
{
  int D.14468;
  unsigned int D.14469;

  D.14469 = GetLastError ();
  D.14468 = (int) D.14469;
  return D.14468;
}


closesocket (guint32 fd)
{
  <unnamed type> D.14471;
  int D.14474;
  void * handle;

  handle = (void *) fd;
  D.14471 = _wapi_handle_type (handle);
  if (D.14471 != 7) goto <D.14472>; else goto <D.14473>;
  <D.14472>:
  WSASetLastError (10038);
  D.14474 = 0;
  return D.14474;
  <D.14473>:
  _wapi_handle_unref (handle);
  D.14474 = 0;
  return D.14474;
}


_wapi_handle_type (void * handle)
{
  unsigned int D.14479;
  struct _WapiHandleUnshared * D.14480;
  WapiHandleType D.14481;
  unsigned int D.14482;
  unsigned int D.14483;
  struct _WapiHandleUnshared * D.14484;
  guint32 idx;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.14476>; else goto <D.14478>;
  <D.14478>:
  D.14479 = idx / 256;
  D.14480 = _wapi_private_handles[D.14479];
  if (D.14480 == 0B) goto <D.14476>; else goto <D.14477>;
  <D.14476>:
  D.14481 = 0;
  return D.14481;
  <D.14477>:
  D.14479 = idx / 256;
  D.14480 = _wapi_private_handles[D.14479];
  D.14482 = idx & 255;
  D.14483 = D.14482 * 144;
  D.14484 = D.14480 + D.14483;
  D.14481 = D.14484->type;
  return D.14481;
}


_wapi_accept (guint32 fd, struct sockaddr * addr, socklen_t * addrlen)
{
  unsigned int startup_count.9;
  guint32 D.14489;
  unsigned int D.14492;
  <unnamed type> D.14495;
  int fd.10;
  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.14501;
  int * D.14503;
  int D.14504;
  int D.14506;
  unsigned int errnum.11;
  unsigned int D.14510;
  unsigned int new_fd.12;
  unsigned int _wapi_fd_reserve.13;
  struct _WapiHandle_socket * socket_handle.14;
  int D.14516;
  int D.14517;
  int D.14518;
  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
    {
      handle = (void *) fd;
      new_socket_handle = {};
      startup_count.9 = startup_count;
      if (startup_count.9 == 0) goto <D.14487>; else goto <D.14488>;
      <D.14487>:
      WSASetLastError (10093);
      D.14489 = 4294967295;
      return D.14489;
      <D.14488>:
      if (addr != 0B) goto <D.14490>; else goto <D.14491>;
      <D.14490>:
      D.14492 = *addrlen;
      if (D.14492 <= 15) goto <D.14493>; else goto <D.14494>;
      <D.14493>:
      WSASetLastError (10014);
      D.14489 = 4294967295;
      return D.14489;
      <D.14494>:
      <D.14491>:
      D.14495 = _wapi_handle_type (handle);
      if (D.14495 != 7) goto <D.14496>; else goto <D.14497>;
      <D.14496>:
      WSASetLastError (10038);
      D.14489 = 4294967295;
      return D.14489;
      <D.14497>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.14498>; else goto <D.14499>;
      <D.14498>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.14489 = 4294967295;
      return D.14489;
      <D.14499>:
      <D.14056>:
      fd.10 = (int) fd;
      D.14501.__sockaddr__ = addr;
      new_fd = accept (fd.10, D.14501, addrlen);
      if (new_fd == -1) goto <D.14502>; else goto <D.14057>;
      <D.14502>:
      D.14503 = __errno_location ();
      D.14504 = *D.14503;
      if (D.14504 == 4) goto <D.14505>; else goto <D.14057>;
      <D.14505>:
      D.14506 = _wapi_thread_cur_apc_pending ();
      if (D.14506 == 0) goto <D.14056>; else goto <D.14057>;
      <D.14057>:
      if (new_fd == -1) goto <D.14507>; else goto <D.14508>;
      <D.14507>:
      {
        gint errnum;

        D.14503 = __errno_location ();
        errnum = *D.14503;
        errnum.11 = (unsigned int) errnum;
        D.14510 = errno_to_WSA (errnum.11, &__func__);
        errnum = (gint) D.14510;
        WSASetLastError (errnum);
        D.14489 = 4294967295;
        return D.14489;
      }
      <D.14508>:
      new_fd.12 = (unsigned int) new_fd;
      _wapi_fd_reserve.13 = _wapi_fd_reserve;
      if (new_fd.12 >= _wapi_fd_reserve.13) goto <D.14513>; else goto <D.14514>;
      <D.14513>:
      WSASetLastError (10107);
      close (new_fd);
      D.14489 = 4294967295;
      return D.14489;
      <D.14514>:
      socket_handle.14 = socket_handle;
      D.14516 = socket_handle.14->domain;
      new_socket_handle.domain = D.14516;
      socket_handle.14 = socket_handle;
      D.14517 = socket_handle.14->type;
      new_socket_handle.type = D.14517;
      socket_handle.14 = socket_handle;
      D.14518 = socket_handle.14->protocol;
      new_socket_handle.protocol = D.14518;
      new_socket_handle.still_readable = 1;
      new_handle = _wapi_handle_new_fd (7, new_fd, &new_socket_handle);
      if (new_handle == 4294967295B) goto <D.14519>; else goto <D.14520>;
      <D.14519>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (31);
      D.14489 = 4294967295;
      return D.14489;
      <D.14520>:
      D.14489 = (guint32) new_fd;
      return D.14489;
    }
  finally
    {
      socket_handle = {CLOBBER};
      new_socket_handle = {CLOBBER};
    }
}


_wapi_bind (guint32 fd, struct sockaddr * my_addr, socklen_t addrlen)
{
  unsigned int startup_count.15;
  int D.14526;
  <unnamed type> D.14527;
  int fd.16;
  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.14531;
  int * D.14534;
  unsigned int errnum.17;
  unsigned int D.14536;
  void * handle;
  int ret;
  static const char __func__[11] = "_wapi_bind";

  handle = (void *) fd;
  startup_count.15 = startup_count;
  if (startup_count.15 == 0) goto <D.14524>; else goto <D.14525>;
  <D.14524>:
  WSASetLastError (10093);
  D.14526 = -1;
  return D.14526;
  <D.14525>:
  D.14527 = _wapi_handle_type (handle);
  if (D.14527 != 7) goto <D.14528>; else goto <D.14529>;
  <D.14528>:
  WSASetLastError (10038);
  D.14526 = -1;
  return D.14526;
  <D.14529>:
  fd.16 = (int) fd;
  D.14531.__sockaddr__ = my_addr;
  ret = bind (fd.16, D.14531, addrlen);
  if (ret == -1) goto <D.14532>; else goto <D.14533>;
  <D.14532>:
  {
    gint errnum;

    D.14534 = __errno_location ();
    errnum = *D.14534;
    errnum.17 = (unsigned int) errnum;
    D.14536 = errno_to_WSA (errnum.17, &__func__);
    errnum = (gint) D.14536;
    WSASetLastError (errnum);
    D.14526 = -1;
    return D.14526;
  }
  <D.14533>:
  D.14526 = ret;
  return D.14526;
}


_wapi_connect (guint32 fd, const struct sockaddr * serv_addr, socklen_t addrlen)
{
  unsigned int startup_count.18;
  int D.14541;
  <unnamed type> D.14542;
  int fd.19;
  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.14546;
  int D.14547;
  int * D.14550;
  int D.14551;
  unsigned int errnum.20;
  unsigned int D.14555;
  _Bool D.14562;
  _Bool D.14563;
  _Bool D.14564;
  struct _WapiHandle_socket * socket_handle.21;
  unsigned int D.14571;
  unsigned int D.14572;
  int D.14573;
  int D.14575;
  int D.14576;
  unsigned int D.14579;
  int so_error.22;
  unsigned int so_error.23;
  unsigned int D.14584;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  gint errnum;
  static const char __func__[14] = "_wapi_connect";

  try
    {
      handle = (void *) fd;
      startup_count.18 = startup_count;
      if (startup_count.18 == 0) goto <D.14539>; else goto <D.14540>;
      <D.14539>:
      WSASetLastError (10093);
      D.14541 = -1;
      return D.14541;
      <D.14540>:
      D.14542 = _wapi_handle_type (handle);
      if (D.14542 != 7) goto <D.14543>; else goto <D.14544>;
      <D.14543>:
      WSASetLastError (10038);
      D.14541 = -1;
      return D.14541;
      <D.14544>:
      fd.19 = (int) fd;
      D.14546.__sockaddr__ = serv_addr;
      D.14547 = connect (fd.19, D.14546, addrlen);
      if (D.14547 == -1) goto <D.14548>; else goto <D.14549>;
      <D.14548>:
      {
        struct mono_pollfd fds;
        int so_error;
        socklen_t len;

        try
          {
            D.14550 = __errno_location ();
            errnum = *D.14550;
            D.14550 = __errno_location ();
            D.14551 = *D.14550;
            if (D.14551 != 4) goto <D.14552>; else goto <D.14553>;
            <D.14552>:
            errnum.20 = (unsigned int) errnum;
            D.14555 = errno_to_WSA (errnum.20, &__func__);
            errnum = (gint) D.14555;
            if (errnum == 10036) goto <D.14556>; else goto <D.14557>;
            <D.14556>:
            errnum = 10035;
            <D.14557>:
            WSASetLastError (errnum);
            if (errnum != 10035) goto <D.14558>; else goto <D.14559>;
            <D.14558>:
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.14560>; else goto <D.14561>;
            <D.14560>:
            D.14562 = errnum != 10054;
            D.14563 = errnum != 10050;
            D.14564 = D.14562 & D.14563;
            if (D.14564 != 0) goto <D.14565>; else goto <D.14566>;
            <D.14565>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p (error %d)", &__func__, handle, errnum);
            <D.14566>:
            goto <D.14567>;
            <D.14561>:
            socket_handle.21 = socket_handle;
            socket_handle.21->saved_error = errnum;
            <D.14567>:
            <D.14559>:
            D.14541 = -1;
            return D.14541;
            <D.14553>:
            fd.19 = (int) fd;
            fds.fd = fd.19;
            fds.events = 4;
            goto <D.14082>;
            <D.14081>:
            D.14550 = __errno_location ();
            D.14551 = *D.14550;
            if (D.14551 != 4) goto <D.14569>; else goto <D.14570>;
            <D.14569>:
            D.14550 = __errno_location ();
            D.14551 = *D.14550;
            D.14571 = (unsigned int) D.14551;
            D.14572 = errno_to_WSA (D.14571, &__func__);
            errnum = (gint) D.14572;
            WSASetLastError (errnum);
            D.14541 = -1;
            return D.14541;
            <D.14570>:
            <D.14082>:
            D.14573 = mono_poll (&fds, 1, -1);
            if (D.14573 == -1) goto <D.14574>; else goto <D.14083>;
            <D.14574>:
            D.14575 = _wapi_thread_cur_apc_pending ();
            if (D.14575 == 0) goto <D.14081>; else goto <D.14083>;
            <D.14083>:
            len = 4;
            fd.19 = (int) fd;
            D.14576 = getsockopt (fd.19, 1, 4, &so_error, &len);
            if (D.14576 == -1) goto <D.14577>; else goto <D.14578>;
            <D.14577>:
            D.14550 = __errno_location ();
            D.14551 = *D.14550;
            D.14571 = (unsigned int) D.14551;
            D.14579 = errno_to_WSA (D.14571, &__func__);
            errnum = (gint) D.14579;
            WSASetLastError (errnum);
            D.14541 = -1;
            return D.14541;
            <D.14578>:
            so_error.22 = so_error;
            if (so_error.22 != 0) goto <D.14581>; else goto <D.14582>;
            <D.14581>:
            so_error.22 = so_error;
            so_error.23 = (unsigned int) so_error.22;
            D.14584 = errno_to_WSA (so_error.23, &__func__);
            errnum = (gint) D.14584;
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.14585>; else goto <D.14586>;
            <D.14585>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
            goto <D.14587>;
            <D.14586>:
            socket_handle.21 = socket_handle;
            socket_handle.21->saved_error = errnum;
            <D.14587>:
            WSASetLastError (errnum);
            D.14541 = -1;
            return D.14541;
            <D.14582>:
          }
        finally
          {
            fds = {CLOBBER};
            so_error = {CLOBBER};
            len = {CLOBBER};
          }
      }
      <D.14549>:
      D.14541 = 0;
      return D.14541;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_getpeername (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  unsigned int startup_count.24;
  int D.14595;
  <unnamed type> D.14596;
  int fd.25;
  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.14600;
  int * D.14603;
  unsigned int errnum.26;
  unsigned int D.14605;
  void * handle;
  int ret;
  static const char __func__[18] = "_wapi_getpeername";

  handle = (void *) fd;
  startup_count.24 = startup_count;
  if (startup_count.24 == 0) goto <D.14593>; else goto <D.14594>;
  <D.14593>:
  WSASetLastError (10093);
  D.14595 = -1;
  return D.14595;
  <D.14594>:
  D.14596 = _wapi_handle_type (handle);
  if (D.14596 != 7) goto <D.14597>; else goto <D.14598>;
  <D.14597>:
  WSASetLastError (10038);
  D.14595 = -1;
  return D.14595;
  <D.14598>:
  fd.25 = (int) fd;
  D.14600.__sockaddr__ = name;
  ret = getpeername (fd.25, D.14600, namelen);
  if (ret == -1) goto <D.14601>; else goto <D.14602>;
  <D.14601>:
  {
    gint errnum;

    D.14603 = __errno_location ();
    errnum = *D.14603;
    errnum.26 = (unsigned int) errnum;
    D.14605 = errno_to_WSA (errnum.26, &__func__);
    errnum = (gint) D.14605;
    WSASetLastError (errnum);
    D.14595 = -1;
    return D.14595;
  }
  <D.14602>:
  D.14595 = ret;
  return D.14595;
}


_wapi_getsockname (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  unsigned int startup_count.27;
  int D.14610;
  <unnamed type> D.14611;
  int fd.28;
  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.14615;
  int * D.14618;
  unsigned int errnum.29;
  unsigned int D.14620;
  void * handle;
  int ret;
  static const char __func__[18] = "_wapi_getsockname";

  handle = (void *) fd;
  startup_count.27 = startup_count;
  if (startup_count.27 == 0) goto <D.14608>; else goto <D.14609>;
  <D.14608>:
  WSASetLastError (10093);
  D.14610 = -1;
  return D.14610;
  <D.14609>:
  D.14611 = _wapi_handle_type (handle);
  if (D.14611 != 7) goto <D.14612>; else goto <D.14613>;
  <D.14612>:
  WSASetLastError (10038);
  D.14610 = -1;
  return D.14610;
  <D.14613>:
  fd.28 = (int) fd;
  D.14615.__sockaddr__ = name;
  ret = getsockname (fd.28, D.14615, namelen);
  if (ret == -1) goto <D.14616>; else goto <D.14617>;
  <D.14616>:
  {
    gint errnum;

    D.14618 = __errno_location ();
    errnum = *D.14618;
    errnum.29 = (unsigned int) errnum;
    D.14620 = errno_to_WSA (errnum.29, &__func__);
    errnum = (gint) D.14620;
    WSASetLastError (errnum);
    D.14610 = -1;
    return D.14610;
  }
  <D.14617>:
  D.14610 = ret;
  return D.14610;
}


_wapi_getsockopt (guint32 fd, int level, int optname, void * optval, socklen_t * optlen)
{
  unsigned int startup_count.30;
  int D.14625;
  <unnamed type> D.14626;
  unsigned int optname.31;
  unsigned int D.14632;
  int fd.32;
  int * D.14638;
  unsigned int errnum.33;
  unsigned int D.14640;
  long int D.14645;
  long int D.14646;
  long int D.14647;
  long int D.14648;
  long int D.14649;
  int D.14654;
  unsigned int D.14655;
  unsigned int D.14656;
  int D.14657;
  unsigned int D.14661;
  int D.14662;
  struct _WapiHandle_socket * socket_handle.34;
  int D.14665;
  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
    {
      handle = (void *) fd;
      startup_count.30 = startup_count;
      if (startup_count.30 == 0) goto <D.14623>; else goto <D.14624>;
      <D.14623>:
      WSASetLastError (10093);
      D.14625 = -1;
      return D.14625;
      <D.14624>:
      D.14626 = _wapi_handle_type (handle);
      if (D.14626 != 7) goto <D.14627>; else goto <D.14628>;
      <D.14627>:
      WSASetLastError (10038);
      D.14625 = -1;
      return D.14625;
      <D.14628>:
      tmp_val = optval;
      if (level == 1) goto <D.14629>; else goto <D.14630>;
      <D.14629>:
      optname.31 = (unsigned int) optname;
      D.14632 = optname.31 + 4294967276;
      if (D.14632 <= 1) goto <D.14633>; else goto <D.14634>;
      <D.14633>:
      tmp_val = &tv;
      *optlen = 8;
      <D.14634>:
      <D.14630>:
      fd.32 = (int) fd;
      ret = getsockopt (fd.32, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.14636>; else goto <D.14637>;
      <D.14636>:
      {
        gint errnum;

        D.14638 = __errno_location ();
        errnum = *D.14638;
        errnum.33 = (unsigned int) errnum;
        D.14640 = errno_to_WSA (errnum.33, &__func__);
        errnum = (gint) D.14640;
        WSASetLastError (errnum);
        D.14625 = -1;
        return D.14625;
      }
      <D.14637>:
      if (level == 1) goto <D.14641>; else goto <D.14642>;
      <D.14641>:
      optname.31 = (unsigned int) optname;
      D.14632 = optname.31 + 4294967276;
      if (D.14632 <= 1) goto <D.14643>; else goto <D.14644>;
      <D.14643>:
      D.14645 = tv.tv_sec;
      D.14646 = D.14645 * 1000;
      D.14647 = tv.tv_usec;
      D.14648 = D.14647 / 1000;
      D.14649 = D.14646 + D.14648;
      MEM[(int *)optval] = D.14649;
      *optlen = 4;
      <D.14644>:
      <D.14642>:
      if (optname == 4) goto <D.14650>; else goto <D.14651>;
      <D.14650>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.14652>; else goto <D.14653>;
      <D.14652>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      D.14654 = MEM[(int *)optval];
      D.14655 = (unsigned int) D.14654;
      D.14656 = errno_to_WSA (D.14655, &__func__);
      D.14657 = (int) D.14656;
      MEM[(int *)optval] = D.14657;
      goto <D.14658>;
      <D.14653>:
      D.14654 = MEM[(int *)optval];
      if (D.14654 != 0) goto <D.14659>; else goto <D.14660>;
      <D.14659>:
      D.14654 = MEM[(int *)optval];
      D.14655 = (unsigned int) D.14654;
      D.14661 = errno_to_WSA (D.14655, &__func__);
      D.14662 = (int) D.14661;
      MEM[(int *)optval] = D.14662;
      socket_handle.34 = socket_handle;
      D.14654 = MEM[(int *)optval];
      socket_handle.34->saved_error = D.14654;
      goto <D.14664>;
      <D.14660>:
      socket_handle.34 = socket_handle;
      D.14665 = socket_handle.34->saved_error;
      MEM[(int *)optval] = D.14665;
      <D.14664>:
      <D.14658>:
      <D.14651>:
      D.14625 = ret;
      return D.14625;
    }
  finally
    {
      tv = {CLOBBER};
      socket_handle = {CLOBBER};
    }
}


_wapi_listen (guint32 fd, int backlog)
{
  unsigned int startup_count.35;
  int D.14671;
  <unnamed type> D.14672;
  int fd.36;
  int * D.14678;
  unsigned int errnum.37;
  unsigned int D.14680;
  void * handle;
  int ret;
  static const char __func__[13] = "_wapi_listen";

  handle = (void *) fd;
  startup_count.35 = startup_count;
  if (startup_count.35 == 0) goto <D.14669>; else goto <D.14670>;
  <D.14669>:
  WSASetLastError (10093);
  D.14671 = -1;
  return D.14671;
  <D.14670>:
  D.14672 = _wapi_handle_type (handle);
  if (D.14672 != 7) goto <D.14673>; else goto <D.14674>;
  <D.14673>:
  WSASetLastError (10038);
  D.14671 = -1;
  return D.14671;
  <D.14674>:
  fd.36 = (int) fd;
  ret = listen (fd.36, backlog);
  if (ret == -1) goto <D.14676>; else goto <D.14677>;
  <D.14676>:
  {
    gint errnum;

    D.14678 = __errno_location ();
    errnum = *D.14678;
    errnum.37 = (unsigned int) errnum;
    D.14680 = errno_to_WSA (errnum.37, &__func__);
    errnum = (gint) D.14680;
    WSASetLastError (errnum);
    D.14671 = -1;
    return D.14671;
  }
  <D.14677>:
  D.14671 = 0;
  return D.14671;
}


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

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


_wapi_recvfrom (guint32 fd, void * buf, size_t len, int recv_flags, struct sockaddr * from, socklen_t * fromlen)
{
  unsigned int startup_count.38;
  int D.14687;
  <unnamed type> D.14688;
  int fd.39;
  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.14692;
  int * D.14694;
  int D.14695;
  int D.14697;
  _Bool D.14698;
  _Bool D.14699;
  _Bool D.14700;
  struct _WapiHandle_socket * socket_handle.40;
  int D.14707;
  unsigned int errnum.41;
  unsigned int D.14711;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  int ret;
  static const char __func__[15] = "_wapi_recvfrom";

  try
    {
      handle = (void *) fd;
      startup_count.38 = startup_count;
      if (startup_count.38 == 0) goto <D.14685>; else goto <D.14686>;
      <D.14685>:
      WSASetLastError (10093);
      D.14687 = -1;
      return D.14687;
      <D.14686>:
      D.14688 = _wapi_handle_type (handle);
      if (D.14688 != 7) goto <D.14689>; else goto <D.14690>;
      <D.14689>:
      WSASetLastError (10038);
      D.14687 = -1;
      return D.14687;
      <D.14690>:
      <D.14143>:
      fd.39 = (int) fd;
      D.14692.__sockaddr__ = from;
      ret = recvfrom (fd.39, buf, len, recv_flags, D.14692, fromlen);
      if (ret == -1) goto <D.14693>; else goto <D.14144>;
      <D.14693>:
      D.14694 = __errno_location ();
      D.14695 = *D.14694;
      if (D.14695 == 4) goto <D.14696>; else goto <D.14144>;
      <D.14696>:
      D.14697 = _wapi_thread_cur_apc_pending ();
      if (D.14697 == 0) goto <D.14143>; else goto <D.14144>;
      <D.14144>:
      D.14698 = ret == 0;
      D.14699 = len != 0;
      D.14700 = D.14698 & D.14699;
      if (D.14700 != 0) goto <D.14701>; else goto <D.14702>;
      <D.14701>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.14703>; else goto <D.14705>;
      <D.14705>:
      socket_handle.40 = socket_handle;
      D.14707 = socket_handle.40->still_readable;
      if (D.14707 != 1) goto <D.14703>; else goto <D.14704>;
      <D.14703>:
      ret = -1;
      D.14694 = __errno_location ();
      *D.14694 = 4;
      <D.14704>:
      <D.14702>:
      if (ret == -1) goto <D.14708>; else goto <D.14709>;
      <D.14708>:
      {
        gint errnum;

        D.14694 = __errno_location ();
        errnum = *D.14694;
        errnum.41 = (unsigned int) errnum;
        D.14711 = errno_to_WSA (errnum.41, &__func__);
        errnum = (gint) D.14711;
        WSASetLastError (errnum);
        D.14687 = -1;
        return D.14687;
      }
      <D.14709>:
      D.14687 = ret;
      return D.14687;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


recvfrom (int __fd, void * restrict __buf, size_t __n, int __flags, union __SOCKADDR_ARG __addr, socklen_t * restrict __addr_len)
{
  unsigned int D.14714;
  int D.14717;
  ssize_t D.14720;
  unsigned int D.14721;
  unsigned int D.14722;
  unsigned int D.14725;

  D.14714 = __builtin_object_size (__buf, 0);
  if (D.14714 != 4294967295) goto <D.14715>; else goto <D.14716>;
  <D.14715>:
  D.14717 = __builtin_constant_p (__n);
  if (D.14717 == 0) goto <D.14718>; else goto <D.14719>;
  <D.14718>:
  D.14721 = __builtin_object_size (__buf, 0);
  D.14720 = __recvfrom_chk (__fd, __buf, __n, D.14721, __flags, __addr, __addr_len);
  return D.14720;
  <D.14719>:
  D.14722 = __builtin_object_size (__buf, 0);
  if (D.14722 < __n) goto <D.14723>; else goto <D.14724>;
  <D.14723>:
  D.14725 = __builtin_object_size (__buf, 0);
  D.14720 = __recvfrom_chk_warn (__fd, __buf, __n, D.14725, __flags, __addr, __addr_len);
  return D.14720;
  <D.14724>:
  <D.14716>:
  D.14720 = __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
  return D.14720;
}


_wapi_send (guint32 fd, const void * msg, size_t len, int send_flags)
{
  unsigned int startup_count.42;
  int D.14730;
  <unnamed type> D.14731;
  int fd.43;
  int * D.14736;
  int D.14737;
  int D.14739;
  int D.14746;
  unsigned int errnum.44;
  unsigned int D.14750;
  void * handle;
  int ret;
  static const char __func__[11] = "_wapi_send";

  handle = (void *) fd;
  startup_count.42 = startup_count;
  if (startup_count.42 == 0) goto <D.14728>; else goto <D.14729>;
  <D.14728>:
  WSASetLastError (10093);
  D.14730 = -1;
  return D.14730;
  <D.14729>:
  D.14731 = _wapi_handle_type (handle);
  if (D.14731 != 7) goto <D.14732>; else goto <D.14733>;
  <D.14732>:
  WSASetLastError (10038);
  D.14730 = -1;
  return D.14730;
  <D.14733>:
  <D.14168>:
  fd.43 = (int) fd;
  ret = send (fd.43, msg, len, send_flags);
  if (ret == -1) goto <D.14735>; else goto <D.14169>;
  <D.14735>:
  D.14736 = __errno_location ();
  D.14737 = *D.14736;
  if (D.14737 == 4) goto <D.14738>; else goto <D.14169>;
  <D.14738>:
  D.14739 = _wapi_thread_cur_apc_pending ();
  if (D.14739 == 0) goto <D.14168>; else goto <D.14169>;
  <D.14169>:
  if (ret == -1) goto <D.14740>; else goto <D.14741>;
  <D.14740>:
  {
    gint errnum;

    D.14736 = __errno_location ();
    errnum = *D.14736;
    if (errnum == 11) goto <D.14742>; else goto <D.14743>;
    <D.14742>:
    fd.43 = (int) fd;
    ret = fcntl (fd.43, 3, 0);
    if (ret != -1) goto <D.14744>; else goto <D.14745>;
    <D.14744>:
    D.14746 = ret & 2048;
    if (D.14746 == 0) goto <D.14747>; else goto <D.14748>;
    <D.14747>:
    errnum = 110;
    <D.14748>:
    <D.14745>:
    <D.14743>:
    errnum.44 = (unsigned int) errnum;
    D.14750 = errno_to_WSA (errnum.44, &__func__);
    errnum = (gint) D.14750;
    WSASetLastError (errnum);
    D.14730 = -1;
    return D.14730;
  }
  <D.14741>:
  D.14730 = ret;
  return D.14730;
}


_wapi_sendto (guint32 fd, const void * msg, size_t len, int send_flags, const struct sockaddr * to, socklen_t tolen)
{
  unsigned int startup_count.45;
  int D.14755;
  <unnamed type> D.14756;
  int fd.46;
  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.14760;
  int * D.14762;
  int D.14763;
  int D.14765;
  unsigned int errnum.47;
  unsigned int D.14769;
  void * handle;
  int ret;
  static const char __func__[13] = "_wapi_sendto";

  handle = (void *) fd;
  startup_count.45 = startup_count;
  if (startup_count.45 == 0) goto <D.14753>; else goto <D.14754>;
  <D.14753>:
  WSASetLastError (10093);
  D.14755 = -1;
  return D.14755;
  <D.14754>:
  D.14756 = _wapi_handle_type (handle);
  if (D.14756 != 7) goto <D.14757>; else goto <D.14758>;
  <D.14757>:
  WSASetLastError (10038);
  D.14755 = -1;
  return D.14755;
  <D.14758>:
  <D.14182>:
  fd.46 = (int) fd;
  D.14760.__sockaddr__ = to;
  ret = sendto (fd.46, msg, len, send_flags, D.14760, tolen);
  if (ret == -1) goto <D.14761>; else goto <D.14183>;
  <D.14761>:
  D.14762 = __errno_location ();
  D.14763 = *D.14762;
  if (D.14763 == 4) goto <D.14764>; else goto <D.14183>;
  <D.14764>:
  D.14765 = _wapi_thread_cur_apc_pending ();
  if (D.14765 == 0) goto <D.14182>; else goto <D.14183>;
  <D.14183>:
  if (ret == -1) goto <D.14766>; else goto <D.14767>;
  <D.14766>:
  {
    gint errnum;

    D.14762 = __errno_location ();
    errnum = *D.14762;
    errnum.47 = (unsigned int) errnum;
    D.14769 = errno_to_WSA (errnum.47, &__func__);
    errnum = (gint) D.14769;
    WSASetLastError (errnum);
    D.14755 = -1;
    return D.14755;
  }
  <D.14767>:
  D.14755 = ret;
  return D.14755;
}


_wapi_setsockopt (guint32 fd, int level, int optname, const void * optval, socklen_t optlen)
{
  unsigned int startup_count.48;
  int D.14774;
  <unnamed type> D.14775;
  unsigned int optname.49;
  unsigned int D.14782;
  int D.14784;
  int D.14785;
  int D.14786;
  unsigned int D.14789;
  int bufsize.50;
  int bufsize.51;
  int bufsize.52;
  int fd.53;
  int * D.14798;
  unsigned int errnum.54;
  unsigned int D.14800;
  _Bool D.14801;
  _Bool D.14802;
  _Bool D.14803;
  int D.14806;
  int type.55;
  void * handle;
  int ret;
  const void * tmp_val;
  int bufsize;
  struct timeval tv;
  static const char __func__[17] = "_wapi_setsockopt";

  try
    {
      handle = (void *) fd;
      bufsize = 0;
      startup_count.48 = startup_count;
      if (startup_count.48 == 0) goto <D.14772>; else goto <D.14773>;
      <D.14772>:
      WSASetLastError (10093);
      D.14774 = -1;
      return D.14774;
      <D.14773>:
      D.14775 = _wapi_handle_type (handle);
      if (D.14775 != 7) goto <D.14776>; else goto <D.14777>;
      <D.14776>:
      WSASetLastError (10038);
      D.14774 = -1;
      return D.14774;
      <D.14777>:
      tmp_val = optval;
      if (level == 1) goto <D.14780>; else goto <D.14778>;
      <D.14780>:
      optname.49 = (unsigned int) optname;
      D.14782 = optname.49 + 4294967276;
      if (D.14782 <= 1) goto <D.14783>; else goto <D.14778>;
      <D.14783>:
      {
        int ms;

        ms = MEM[(int *)optval];
        D.14784 = ms / 1000;
        tv.tv_sec = D.14784;
        D.14785 = ms % 1000;
        D.14786 = D.14785 * 1000;
        tv.tv_usec = D.14786;
        tmp_val = &tv;
        optlen = 8;
      }
      goto <D.14779>;
      <D.14778>:
      if (level == 1) goto <D.14787>; else goto <D.14788>;
      <D.14787>:
      optname.49 = (unsigned int) optname;
      D.14789 = optname.49 + 4294967289;
      if (D.14789 <= 1) goto <D.14790>; else goto <D.14791>;
      <D.14790>:
      bufsize.50 = MEM[(int *)optval];
      bufsize = bufsize.50;
      bufsize.51 = bufsize;
      bufsize.52 = bufsize.51 / 2;
      bufsize = bufsize.52;
      tmp_val = &bufsize;
      <D.14791>:
      <D.14788>:
      <D.14779>:
      fd.53 = (int) fd;
      ret = setsockopt (fd.53, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.14796>; else goto <D.14797>;
      <D.14796>:
      {
        gint errnum;

        D.14798 = __errno_location ();
        errnum = *D.14798;
        errnum.54 = (unsigned int) errnum;
        D.14800 = errno_to_WSA (errnum.54, &__func__);
        errnum = (gint) D.14800;
        WSASetLastError (errnum);
        D.14774 = -1;
        return D.14774;
      }
      <D.14797>:
      D.14801 = level == 1;
      D.14802 = optname == 2;
      D.14803 = D.14801 & D.14802;
      if (D.14803 != 0) goto <D.14804>; else goto <D.14805>;
      <D.14804>:
      {
        int type;
        socklen_t type_len;

        try
          {
            type_len = 4;
            fd.53 = (int) fd;
            D.14806 = getsockopt (fd.53, level, 3, &type, &type_len);
            if (D.14806 == 0) goto <D.14807>; else goto <D.14808>;
            <D.14807>:
            type.55 = type;
            if (type.55 == 2) goto <D.14810>; else goto <D.14811>;
            <D.14810>:
            fd.53 = (int) fd;
            setsockopt (fd.53, level, 15, tmp_val, optlen);
            <D.14811>:
            <D.14808>:
          }
        finally
          {
            type = {CLOBBER};
            type_len = {CLOBBER};
          }
      }
      <D.14805>:
      D.14774 = ret;
      return D.14774;
    }
  finally
    {
      bufsize = {CLOBBER};
      tv = {CLOBBER};
    }
}


_wapi_shutdown (guint32 fd, int how)
{
  unsigned int startup_count.56;
  int D.14817;
  <unnamed type> D.14818;
  _Bool D.14821;
  _Bool D.14822;
  _Bool D.14823;
  struct _WapiHandle_socket * socket_handle.57;
  int fd.58;
  int * D.14832;
  unsigned int errnum.59;
  unsigned int D.14834;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  void * handle;
  int ret;
  static const char __func__[15] = "_wapi_shutdown";

  try
    {
      handle = (void *) fd;
      startup_count.56 = startup_count;
      if (startup_count.56 == 0) goto <D.14815>; else goto <D.14816>;
      <D.14815>:
      WSASetLastError (10093);
      D.14817 = -1;
      return D.14817;
      <D.14816>:
      D.14818 = _wapi_handle_type (handle);
      if (D.14818 != 7) goto <D.14819>; else goto <D.14820>;
      <D.14819>:
      WSASetLastError (10038);
      D.14817 = -1;
      return D.14817;
      <D.14820>:
      D.14821 = how == 0;
      D.14822 = how == 2;
      D.14823 = D.14821 | D.14822;
      if (D.14823 != 0) goto <D.14824>; else goto <D.14825>;
      <D.14824>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.14826>; else goto <D.14827>;
      <D.14826>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.14817 = -1;
      return D.14817;
      <D.14827>:
      socket_handle.57 = socket_handle;
      socket_handle.57->still_readable = 0;
      <D.14825>:
      fd.58 = (int) fd;
      ret = shutdown (fd.58, how);
      if (ret == -1) goto <D.14830>; else goto <D.14831>;
      <D.14830>:
      {
        gint errnum;

        D.14832 = __errno_location ();
        errnum = *D.14832;
        errnum.59 = (unsigned int) errnum;
        D.14834 = errno_to_WSA (errnum.59, &__func__);
        errnum = (gint) D.14834;
        WSASetLastError (errnum);
        D.14817 = -1;
        return D.14817;
      }
      <D.14831>:
      D.14817 = ret;
      return D.14817;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_socket (int domain, int type, int protocol, void * unused, guint32 unused2, guint32 unused3)
{
  _Bool D.14837;
  _Bool D.14838;
  _Bool D.14839;
  _Bool D.14842;
  _Bool D.14843;
  _Bool D.14844;
  int * D.14849;
  unsigned int errnum.60;
  unsigned int D.14851;
  guint32 D.14852;
  unsigned int fd.61;
  unsigned int _wapi_fd_reserve.62;
  unsigned int errnum.63;
  unsigned int D.14860;
  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);
      D.14837 = fd == -1;
      D.14838 = domain == 2;
      D.14839 = D.14837 & D.14838;
      if (D.14839 != 0) goto <D.14840>; else goto <D.14841>;
      <D.14840>:
      D.14842 = type == 3;
      D.14843 = protocol == 0;
      D.14844 = D.14842 & D.14843;
      if (D.14844 != 0) goto <D.14845>; else goto <D.14846>;
      <D.14845>:
      socket_handle.protocol = 4;
      fd = socket (2, 3, 4);
      <D.14846>:
      <D.14841>:
      if (fd == -1) goto <D.14847>; else goto <D.14848>;
      <D.14847>:
      {
        gint errnum;

        D.14849 = __errno_location ();
        errnum = *D.14849;
        errnum.60 = (unsigned int) errnum;
        D.14851 = errno_to_WSA (errnum.60, &__func__);
        errnum = (gint) D.14851;
        WSASetLastError (errnum);
        D.14852 = 4294967295;
        return D.14852;
      }
      <D.14848>:
      fd.61 = (unsigned int) fd;
      _wapi_fd_reserve.62 = _wapi_fd_reserve;
      if (fd.61 >= _wapi_fd_reserve.62) goto <D.14855>; else goto <D.14856>;
      <D.14855>:
      WSASetLastError (10107);
      close (fd);
      D.14852 = 4294967295;
      return D.14852;
      <D.14856>:
      {
        int ret;
        int true;

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

              D.14849 = __errno_location ();
              errnum = *D.14849;
              errnum.63 = (unsigned int) errnum;
              D.14860 = errno_to_WSA (errnum.63, &__func__);
              errnum = (int) D.14860;
              WSASetLastError (errnum);
              close (fd);
              D.14852 = 4294967295;
              return D.14852;
            }
            <D.14858>:
          }
        finally
          {
            true = {CLOBBER};
          }
      }
      mono_once (&socket_ops_once, socket_ops_init);
      handle = _wapi_handle_new_fd (7, fd, &socket_handle);
      if (handle == 4294967295B) goto <D.14861>; else goto <D.14862>;
      <D.14861>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (10107);
      close (fd);
      D.14852 = 4294967295;
      return D.14852;
      <D.14862>:
      D.14852 = (guint32) fd;
      return D.14852;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


socket_ops_init ()
{

}


_wapi_gethostbyname (const char * hostname)
{
  unsigned int startup_count.64;
  struct hostent * D.14870;
  int * D.14873;
  int D.14874;
  struct hostent * he;
  static const char __func__[20] = "_wapi_gethostbyname";

  startup_count.64 = startup_count;
  if (startup_count.64 == 0) goto <D.14868>; else goto <D.14869>;
  <D.14868>:
  WSASetLastError (10093);
  D.14870 = 0B;
  return D.14870;
  <D.14869>:
  he = gethostbyname (hostname);
  if (he == 0B) goto <D.14871>; else goto <D.14872>;
  <D.14871>:
  D.14873 = __h_errno_location ();
  D.14874 = *D.14873;
  switch (D.14874) <default: <D.14249>, case 1: <D.14244>, case 2: <D.14248>, case 3: <D.14247>, case 4: <D.14246>>
  <D.14244>:
  WSASetLastError (11001);
  goto <D.14245>;
  <D.14246>:
  WSASetLastError (11004);
  goto <D.14245>;
  <D.14247>:
  WSASetLastError (11003);
  goto <D.14245>;
  <D.14248>:
  WSASetLastError (11002);
  goto <D.14245>;
  <D.14249>:
  D.14873 = __h_errno_location ();
  D.14874 = *D.14873;
  monoeg_g_log (0B, 16, "%s: Need to translate %d into winsock error", &__func__, D.14874);
  goto <D.14245>;
  <D.14245>:
  <D.14872>:
  D.14870 = he;
  return D.14870;
}


TransmitFile (guint32 socket, void * file, guint32 bytes_to_write, guint32 bytes_per_send, struct WapiOverlapped * ol, struct WapiTransmitFileBuffers * buffers, guint32 flags)
{
  unsigned int startup_count.65;
  gboolean D.14879;
  <unnamed type> D.14880;
  void * D.14885;
  unsigned int D.14888;
  void * D.14897;
  unsigned int D.14900;
  unsigned int D.14905;
  void * sock;
  gint ret;

  sock = (void *) socket;
  startup_count.65 = startup_count;
  if (startup_count.65 == 0) goto <D.14877>; else goto <D.14878>;
  <D.14877>:
  WSASetLastError (10093);
  D.14879 = 0;
  return D.14879;
  <D.14878>:
  D.14880 = _wapi_handle_type (sock);
  if (D.14880 != 7) goto <D.14881>; else goto <D.14882>;
  <D.14881>:
  WSASetLastError (10038);
  D.14879 = 0;
  return D.14879;
  <D.14882>:
  if (buffers != 0B) goto <D.14883>; else goto <D.14884>;
  <D.14883>:
  D.14885 = buffers->Head;
  if (D.14885 != 0B) goto <D.14886>; else goto <D.14887>;
  <D.14886>:
  D.14888 = buffers->HeadLength;
  if (D.14888 != 0) goto <D.14889>; else goto <D.14890>;
  <D.14889>:
  D.14885 = buffers->Head;
  D.14888 = buffers->HeadLength;
  ret = _wapi_send (socket, D.14885, D.14888, 0);
  if (ret == -1) goto <D.14891>; else goto <D.14892>;
  <D.14891>:
  D.14879 = 0;
  return D.14879;
  <D.14892>:
  <D.14890>:
  <D.14887>:
  <D.14884>:
  ret = wapi_sendfile (socket, file, bytes_to_write, bytes_per_send, flags);
  if (ret == -1) goto <D.14893>; else goto <D.14894>;
  <D.14893>:
  D.14879 = 0;
  return D.14879;
  <D.14894>:
  if (buffers != 0B) goto <D.14895>; else goto <D.14896>;
  <D.14895>:
  D.14897 = buffers->Tail;
  if (D.14897 != 0B) goto <D.14898>; else goto <D.14899>;
  <D.14898>:
  D.14900 = buffers->TailLength;
  if (D.14900 != 0) goto <D.14901>; else goto <D.14902>;
  <D.14901>:
  D.14897 = buffers->Tail;
  D.14900 = buffers->TailLength;
  ret = _wapi_send (socket, D.14897, D.14900, 0);
  if (ret == -1) goto <D.14903>; else goto <D.14904>;
  <D.14903>:
  D.14879 = 0;
  return D.14879;
  <D.14904>:
  <D.14902>:
  <D.14899>:
  <D.14896>:
  D.14905 = flags & 1;
  if (D.14905 != 0) goto <D.14906>; else goto <D.14907>;
  <D.14906>:
  closesocket (socket);
  <D.14907>:
  D.14879 = 1;
  return D.14879;
}


wapi_sendfile (guint32 socket, void * fd, guint32 bytes_to_write, guint32 bytes_per_send, guint32 flags)
{
  int * D.14911;
  unsigned int errnum.66;
  unsigned int D.14913;
  gint D.14914;
  int socket.67;
  long long int D.14916;
  unsigned int D.14917;
  int D.14919;
  _Bool D.14920;
  _Bool D.14921;
  _Bool D.14922;
  int D.14924;
  unsigned int D.14927;
  gint file;
  gint n;
  gint errnum;
  gssize res;
  struct stat statbuf;
  static const char __func__[14] = "wapi_sendfile";

  try
    {
      file = (gint) fd;
      n = fstat (file, &statbuf);
      if (n == -1) goto <D.14909>; else goto <D.14910>;
      <D.14909>:
      D.14911 = __errno_location ();
      errnum = *D.14911;
      errnum.66 = (unsigned int) errnum;
      D.14913 = errno_to_WSA (errnum.66, &__func__);
      errnum = (gint) D.14913;
      WSASetLastError (errnum);
      D.14914 = -1;
      return D.14914;
      <D.14910>:
      <D.14283>:
      socket.67 = (int) socket;
      D.14916 = statbuf.st_size;
      D.14917 = (unsigned int) D.14916;
      res = sendfile (socket.67, file, 0B, D.14917);
      if (res != -1) goto <D.14918>; else goto <D.14284>;
      <D.14918>:
      D.14911 = __errno_location ();
      D.14919 = *D.14911;
      D.14920 = D.14919 == 4;
      D.14921 = D.14919 == 11;
      D.14922 = D.14920 | D.14921;
      if (D.14922 != 0) goto <D.14923>; else goto <D.14284>;
      <D.14923>:
      D.14924 = _wapi_thread_cur_apc_pending ();
      if (D.14924 == 0) goto <D.14283>; else goto <D.14284>;
      <D.14284>:
      if (res == -1) goto <D.14925>; else goto <D.14926>;
      <D.14925>:
      D.14911 = __errno_location ();
      errnum = *D.14911;
      errnum.66 = (unsigned int) errnum;
      D.14927 = errno_to_WSA (errnum.66, &__func__);
      errnum = (gint) D.14927;
      WSASetLastError (errnum);
      D.14914 = -1;
      return D.14914;
      <D.14926>:
      D.14914 = 0;
      return D.14914;
    }
  finally
    {
      statbuf = {CLOBBER};
    }
}


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

  D.14930 = __fxstat (3, __fd, __statbuf);
  return D.14930;
}


WSAIoctl (guint32 fd, gint32 command, gchar * input, gint i_len, gchar * output, gint o_len, glong * written, void * unused1, void * unused2)
{
  unsigned int startup_count.68;
  int D.14935;
  <unnamed type> D.14936;
  unsigned int i_len.69;
  unsigned int o_len.70;
  struct WapiGuid * D.14949;
  int D.14950;
  void * * D.14953;
  void * D.14954;
  gchar * D.14959;
  gchar * D.14960;
  int fd.71;
  int * D.14964;
  unsigned int errnum.72;
  unsigned int D.14966;
  unsigned int onoff.73;
  unsigned int keepalivetime.74;
  unsigned int keepalivetime.75;
  unsigned int keepalivetime.76;
  unsigned int keepaliveinterval.77;
  unsigned int keepaliveinterval.78;
  unsigned int keepaliveinterval.79;
  unsigned int errnum.80;
  unsigned int D.14987;
  unsigned int i_len.81;
  long unsigned int command.82;
  unsigned int errnum.83;
  unsigned int D.14995;
  _Bool D.14999;
  _Bool D.15000;
  _Bool D.15001;
  unsigned int i_len.84;
  void * handle;
  int ret;
  gchar * buffer;
  static const char __func__[9] = "WSAIoctl";

  handle = (void *) fd;
  buffer = 0B;
  startup_count.68 = startup_count;
  if (startup_count.68 == 0) goto <D.14933>; else goto <D.14934>;
  <D.14933>:
  WSASetLastError (10093);
  D.14935 = -1;
  return D.14935;
  <D.14934>:
  D.14936 = _wapi_handle_type (handle);
  if (D.14936 != 7) goto <D.14937>; else goto <D.14938>;
  <D.14937>:
  WSASetLastError (10038);
  D.14935 = -1;
  return D.14935;
  <D.14938>:
  if (command == -939524090) goto <D.14939>; else goto <D.14940>;
  <D.14939>:
  {
    int i;
    struct WapiGuid * guid;

    i = 0;
    guid = input;
    i_len.69 = (unsigned int) i_len;
    if (i_len.69 <= 15) goto <D.14942>; else goto <D.14943>;
    <D.14942>:
    WSASetLastError (10022);
    D.14935 = -1;
    return D.14935;
    <D.14943>:
    o_len.70 = (unsigned int) o_len;
    if (o_len.70 <= 3) goto <D.14945>; else goto <D.14946>;
    <D.14945>:
    WSASetLastError (10022);
    D.14935 = -1;
    return D.14935;
    <D.14946>:
    if (output == 0B) goto <D.14947>; else goto <D.14948>;
    <D.14947>:
    WSASetLastError (10022);
    D.14935 = -1;
    return D.14935;
    <D.14948>:
    goto <D.14317>;
    <D.14316>:
    D.14949 = &extension_functions[i].guid;
    D.14950 = memcmp (guid, D.14949, 16);
    if (D.14950 == 0) goto <D.14951>; else goto <D.14952>;
    <D.14951>:
    D.14953 = &extension_functions[i].func;
    memcpy (output, D.14953, 4);
    *written = 4;
    D.14935 = 0;
    return D.14935;
    <D.14952>:
    i = i + 1;
    <D.14317>:
    D.14954 = extension_functions[i].func;
    if (D.14954 != 0B) goto <D.14316>; else goto <D.14318>;
    <D.14318>:
    WSASetLastError (10022);
    D.14935 = -1;
    return D.14935;
  }
  <D.14940>:
  if (command == -1744830460) goto <D.14955>; else goto <D.14956>;
  <D.14955>:
  {
    uint32_t onoff;
    uint32_t keepalivetime;
    uint32_t keepaliveinterval;

    try
      {
        i_len.69 = (unsigned int) i_len;
        if (i_len.69 <= 11) goto <D.14957>; else goto <D.14958>;
        <D.14957>:
        WSASetLastError (10022);
        D.14935 = -1;
        return D.14935;
        <D.14958>:
        memcpy (&onoff, input, 4);
        D.14959 = input + 4;
        memcpy (&keepalivetime, D.14959, 4);
        D.14960 = input + 8;
        memcpy (&keepaliveinterval, D.14960, 4);
        fd.71 = (int) fd;
        ret = setsockopt (fd.71, 1, 9, &onoff, 4);
        if (ret < 0) goto <D.14962>; else goto <D.14963>;
        <D.14962>:
        {
          gint errnum;

          D.14964 = __errno_location ();
          errnum = *D.14964;
          errnum.72 = (unsigned int) errnum;
          D.14966 = errno_to_WSA (errnum.72, &__func__);
          errnum = (gint) D.14966;
          WSASetLastError (errnum);
          D.14935 = -1;
          return D.14935;
        }
        <D.14963>:
        onoff.73 = onoff;
        if (onoff.73 != 0) goto <D.14968>; else goto <D.14969>;
        <D.14968>:
        {
          uint32_t rem;

          keepalivetime.74 = keepalivetime;
          rem = keepalivetime.74 % 1000;
          keepalivetime.74 = keepalivetime;
          keepalivetime.75 = keepalivetime.74 / 1000;
          keepalivetime = keepalivetime.75;
          keepalivetime.74 = keepalivetime;
          if (keepalivetime.74 == 0) goto <D.14972>; else goto <D.14974>;
          <D.14974>:
          if (rem > 499) goto <D.14972>; else goto <D.14973>;
          <D.14972>:
          keepalivetime.74 = keepalivetime;
          keepalivetime.76 = keepalivetime.74 + 1;
          keepalivetime = keepalivetime.76;
          <D.14973>:
          fd.71 = (int) fd;
          ret = setsockopt (fd.71, 6, 4, &keepalivetime, 4);
          if (ret == 0) goto <D.14976>; else goto <D.14977>;
          <D.14976>:
          keepaliveinterval.77 = keepaliveinterval;
          rem = keepaliveinterval.77 % 1000;
          keepaliveinterval.77 = keepaliveinterval;
          keepaliveinterval.78 = keepaliveinterval.77 / 1000;
          keepaliveinterval = keepaliveinterval.78;
          keepaliveinterval.77 = keepaliveinterval;
          if (keepaliveinterval.77 == 0) goto <D.14980>; else goto <D.14982>;
          <D.14982>:
          if (rem > 499) goto <D.14980>; else goto <D.14981>;
          <D.14980>:
          keepaliveinterval.77 = keepaliveinterval;
          keepaliveinterval.79 = keepaliveinterval.77 + 1;
          keepaliveinterval = keepaliveinterval.79;
          <D.14981>:
          fd.71 = (int) fd;
          ret = setsockopt (fd.71, 6, 5, &keepaliveinterval, 4);
          <D.14977>:
          if (ret != 0) goto <D.14984>; else goto <D.14985>;
          <D.14984>:
          {
            gint errnum;

            D.14964 = __errno_location ();
            errnum = *D.14964;
            errnum.80 = (unsigned int) errnum;
            D.14987 = errno_to_WSA (errnum.80, &__func__);
            errnum = (gint) D.14987;
            WSASetLastError (errnum);
            D.14935 = -1;
            return D.14935;
          }
          <D.14985>:
          D.14935 = 0;
          return D.14935;
        }
        <D.14969>:
        D.14935 = 0;
        return D.14935;
      }
    finally
      {
        onoff = {CLOBBER};
        keepalivetime = {CLOBBER};
        keepaliveinterval = {CLOBBER};
      }
  }
  <D.14956>:
  if (i_len > 0) goto <D.14988>; else goto <D.14989>;
  <D.14988>:
  i_len.81 = (unsigned int) i_len;
  buffer = monoeg_g_memdup (input, i_len.81);
  <D.14989>:
  fd.71 = (int) fd;
  command.82 = (long unsigned int) command;
  ret = ioctl (fd.71, command.82, buffer);
  if (ret == -1) goto <D.14992>; else goto <D.14993>;
  <D.14992>:
  {
    gint errnum;

    D.14964 = __errno_location ();
    errnum = *D.14964;
    errnum.83 = (unsigned int) errnum;
    D.14995 = errno_to_WSA (errnum.83, &__func__);
    errnum = (gint) D.14995;
    WSASetLastError (errnum);
    monoeg_g_free (buffer);
    D.14935 = -1;
    return D.14935;
  }
  <D.14993>:
  if (buffer == 0B) goto <D.14996>; else goto <D.14997>;
  <D.14996>:
  *written = 0;
  goto <D.14998>;
  <D.14997>:
  i_len = MIN_EXPR <i_len, o_len>;
  D.14999 = i_len > 0;
  D.15000 = output != 0B;
  D.15001 = D.14999 & D.15000;
  if (D.15001 != 0) goto <D.15002>; else goto <D.15003>;
  <D.15002>:
  i_len.84 = (unsigned int) i_len;
  memcpy (output, buffer, i_len.84);
  <D.15003>:
  monoeg_g_free (buffer);
  *written = i_len;
  <D.14998>:
  D.14935 = 0;
  return D.14935;
}


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

  if (reserved != 0) goto <D.15007>; else goto <D.15008>;
  <D.15007>:
  WSASetLastError (10022);
  D.15009 = 0;
  return D.15009;
  <D.15008>:
  D.15009 = socket_disconnect (fd);
  return D.15009;
}


socket_disconnect (guint32 fd)
{
  gboolean D.15013;
  struct _WapiHandle_socket * socket_handle.85;
  int D.15015;
  int D.15016;
  int D.15017;
  int * D.15020;
  unsigned int errnum.86;
  unsigned int D.15022;
  int fd.87;
  int D.15025;
  unsigned int errnum.88;
  unsigned int D.15029;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  void * handle;
  int newsock;
  int ret;
  static const char __func__[18] = "socket_disconnect";

  try
    {
      handle = (void *) fd;
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.15011>; else goto <D.15012>;
      <D.15011>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.15013 = 0;
      return D.15013;
      <D.15012>:
      socket_handle.85 = socket_handle;
      D.15015 = socket_handle.85->domain;
      socket_handle.85 = socket_handle;
      D.15016 = socket_handle.85->type;
      socket_handle.85 = socket_handle;
      D.15017 = socket_handle.85->protocol;
      newsock = socket (D.15015, D.15016, D.15017);
      if (newsock == -1) goto <D.15018>; else goto <D.15019>;
      <D.15018>:
      {
        gint errnum;

        D.15020 = __errno_location ();
        errnum = *D.15020;
        errnum.86 = (unsigned int) errnum;
        D.15022 = errno_to_WSA (errnum.86, &__func__);
        errnum = (gint) D.15022;
        WSASetLastError (errnum);
        D.15013 = 0;
        return D.15013;
      }
      <D.15019>:
      <D.14261>:
      fd.87 = (int) fd;
      ret = dup2 (newsock, fd.87);
      if (ret == -1) goto <D.15024>; else goto <D.14262>;
      <D.15024>:
      D.15020 = __errno_location ();
      D.15025 = *D.15020;
      if (D.15025 == 11) goto <D.14261>; else goto <D.14262>;
      <D.14262>:
      if (ret == -1) goto <D.15026>; else goto <D.15027>;
      <D.15026>:
      {
        gint errnum;

        D.15020 = __errno_location ();
        errnum = *D.15020;
        errnum.88 = (unsigned int) errnum;
        D.15029 = errno_to_WSA (errnum.88, &__func__);
        errnum = (gint) D.15029;
        WSASetLastError (errnum);
        D.15013 = 0;
        return D.15013;
      }
      <D.15027>:
      close (newsock);
      D.15013 = 1;
      return D.15013;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.15032;
  unsigned int D.15033;

  D.15033 = __builtin_object_size (__dest, 0);
  D.15032 = __builtin___memcpy_chk (__dest, __src, __len, D.15033);
  return D.15032;
}


ioctlsocket (guint32 fd, gint32 command, void * arg)
{
  unsigned int startup_count.89;
  int D.15038;
  <unnamed type> D.15039;
  int fd.90;
  int D.15045;
  long unsigned int command.91;
  int * D.15052;
  unsigned int errnum.92;
  unsigned int D.15054;
  void * handle;
  int ret;
  static const char __func__[12] = "ioctlsocket";

  handle = (void *) fd;
  startup_count.89 = startup_count;
  if (startup_count.89 == 0) goto <D.15036>; else goto <D.15037>;
  <D.15036>:
  WSASetLastError (10093);
  D.15038 = -1;
  return D.15038;
  <D.15037>:
  D.15039 = _wapi_handle_type (handle);
  if (D.15039 != 7) goto <D.15040>; else goto <D.15041>;
  <D.15040>:
  WSASetLastError (10038);
  D.15038 = -1;
  return D.15038;
  <D.15041>:
  switch (command) <default: <D.14338>, case 21531: <D.14337>, case 21537: <D.14334>, case 35077: <D.14336>>
  <D.14334>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 3, 0);
  if (ret != -1) goto <D.15043>; else goto <D.15044>;
  <D.15043>:
  D.15045 = MEM[(gboolean *)arg];
  if (D.15045 != 0) goto <D.15046>; else goto <D.15047>;
  <D.15046>:
  ret = ret | 2048;
  goto <D.15048>;
  <D.15047>:
  ret = ret & -2049;
  <D.15048>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 4, ret);
  <D.15044>:
  goto <D.14335>;
  <D.14336>:
  fd.90 = (int) fd;
  command.91 = (long unsigned int) command;
  ret = ioctl (fd.90, command.91, arg);
  goto <D.14335>;
  <D.14337>:
  fd.90 = (int) fd;
  command.91 = (long unsigned int) command;
  ret = ioctl (fd.90, command.91, arg);
  goto <D.14335>;
  <D.14338>:
  WSASetLastError (10022);
  D.15038 = -1;
  return D.15038;
  <D.14335>:
  if (ret == -1) goto <D.15050>; else goto <D.15051>;
  <D.15050>:
  {
    gint errnum;

    D.15052 = __errno_location ();
    errnum = *D.15052;
    errnum.92 = (unsigned int) errnum;
    D.15054 = errno_to_WSA (errnum.92, &__func__);
    errnum = (gint) D.15054;
    WSASetLastError (errnum);
    D.15038 = -1;
    return D.15038;
  }
  <D.15051>:
  D.15038 = 0;
  return D.15038;
}


_wapi_select (int nfds, struct fd_set * readfds, struct fd_set * writefds, struct fd_set * exceptfds, struct timeval * timeout)
{
  unsigned int startup_count.93;
  int D.15059;
  long int D.14351;
  long int iftmp.94;
  int D.15065;
  long int iftmp.95;
  unsigned int __d.96;
  long int D.15074;
  int D.15075;
  long unsigned int D.15076;
  long int D.15077;
  long int D.15078;
  long int D.14353;
  long int iftmp.97;
  int D.15081;
  long int iftmp.98;
  unsigned int __d.99;
  long int D.15090;
  long int D.15091;
  long int D.14355;
  long int iftmp.100;
  int D.15094;
  long int iftmp.101;
  unsigned int __d.102;
  long int D.15103;
  long int D.15104;
  int D.15107;
  int * D.15109;
  int D.15110;
  int D.15112;
  unsigned int errnum.103;
  unsigned int D.15116;
  int ret;
  int maxfd;
  static const char __func__[13] = "_wapi_select";

  startup_count.93 = startup_count;
  if (startup_count.93 == 0) goto <D.15057>; else goto <D.15058>;
  <D.15057>:
  WSASetLastError (10093);
  D.15059 = -1;
  return D.15059;
  <D.15058>:
  maxfd = 1023;
  goto <D.14358>;
  <D.14357>:
  if (readfds != 0B) goto <D.15063>; else goto <D.15060>;
  <D.15063>:
  {
    long int __d;

    __d = maxfd;
    D.15065 = __builtin_constant_p (__d);
    if (D.15065 != 0) goto <D.15066>; else goto <D.15067>;
    <D.15066>:
    __d.96 = (unsigned int) __d;
    if (__d.96 <= 1023) goto <D.15070>; else goto <D.15071>;
    <D.15070>:
    iftmp.95 = __d / 32;
    goto <D.15072>;
    <D.15071>:
    iftmp.95 = __fdelt_warn (__d);
    <D.15072>:
    iftmp.94 = iftmp.95;
    goto <D.15073>;
    <D.15067>:
    iftmp.94 = __fdelt_chk (__d);
    <D.15073>:
    D.14351 = iftmp.94;
  }
  D.15074 = readfds->fds_bits[D.14351];
  D.15075 = maxfd % 32;
  D.15076 = 1 << D.15075;
  D.15077 = (long int) D.15076;
  D.15078 = D.15074 & D.15077;
  if (D.15078 != 0) goto <D.14356>; else goto <D.15060>;
  <D.15060>:
  if (writefds != 0B) goto <D.15079>; else goto <D.15061>;
  <D.15079>:
  {
    long int __d;

    __d = maxfd;
    D.15081 = __builtin_constant_p (__d);
    if (D.15081 != 0) goto <D.15082>; else goto <D.15083>;
    <D.15082>:
    __d.99 = (unsigned int) __d;
    if (__d.99 <= 1023) goto <D.15086>; else goto <D.15087>;
    <D.15086>:
    iftmp.98 = __d / 32;
    goto <D.15088>;
    <D.15087>:
    iftmp.98 = __fdelt_warn (__d);
    <D.15088>:
    iftmp.97 = iftmp.98;
    goto <D.15089>;
    <D.15083>:
    iftmp.97 = __fdelt_chk (__d);
    <D.15089>:
    D.14353 = iftmp.97;
  }
  D.15090 = writefds->fds_bits[D.14353];
  D.15075 = maxfd % 32;
  D.15076 = 1 << D.15075;
  D.15077 = (long int) D.15076;
  D.15091 = D.15090 & D.15077;
  if (D.15091 != 0) goto <D.14356>; else goto <D.15061>;
  <D.15061>:
  if (exceptfds != 0B) goto <D.15092>; else goto <D.15062>;
  <D.15092>:
  {
    long int __d;

    __d = maxfd;
    D.15094 = __builtin_constant_p (__d);
    if (D.15094 != 0) goto <D.15095>; else goto <D.15096>;
    <D.15095>:
    __d.102 = (unsigned int) __d;
    if (__d.102 <= 1023) goto <D.15099>; else goto <D.15100>;
    <D.15099>:
    iftmp.101 = __d / 32;
    goto <D.15101>;
    <D.15100>:
    iftmp.101 = __fdelt_warn (__d);
    <D.15101>:
    iftmp.100 = iftmp.101;
    goto <D.15102>;
    <D.15096>:
    iftmp.100 = __fdelt_chk (__d);
    <D.15102>:
    D.14355 = iftmp.100;
  }
  D.15103 = exceptfds->fds_bits[D.14355];
  D.15075 = maxfd % 32;
  D.15076 = 1 << D.15075;
  D.15077 = (long int) D.15076;
  D.15104 = D.15103 & D.15077;
  if (D.15104 != 0) goto <D.14356>; else goto <D.15062>;
  <D.15062>:
  maxfd = maxfd + -1;
  <D.14358>:
  if (maxfd >= 0) goto <D.14357>; else goto <D.14356>;
  <D.14356>:
  if (maxfd == -1) goto <D.15105>; else goto <D.15106>;
  <D.15105>:
  WSASetLastError (10022);
  D.15059 = -1;
  return D.15059;
  <D.15106>:
  <D.14359>:
  D.15107 = maxfd + 1;
  ret = select (D.15107, readfds, writefds, exceptfds, timeout);
  if (ret == -1) goto <D.15108>; else goto <D.14360>;
  <D.15108>:
  D.15109 = __errno_location ();
  D.15110 = *D.15109;
  if (D.15110 == 4) goto <D.15111>; else goto <D.14360>;
  <D.15111>:
  D.15112 = _wapi_thread_cur_apc_pending ();
  if (D.15112 == 0) goto <D.14359>; else goto <D.14360>;
  <D.14360>:
  if (ret == -1) goto <D.15113>; else goto <D.15114>;
  <D.15113>:
  {
    gint errnum;

    D.15109 = __errno_location ();
    errnum = *D.15109;
    errnum.103 = (unsigned int) errnum;
    D.15116 = errno_to_WSA (errnum.103, &__func__);
    errnum = (gint) D.15116;
    WSASetLastError (errnum);
    D.15059 = -1;
    return D.15059;
  }
  <D.15114>:
  D.15059 = ret;
  return D.15059;
}


_wapi_FD_CLR (guint32 fd, struct fd_set * set)
{
  <unnamed type> D.15120;
  long int D.14369;
  long int iftmp.104;
  int D.15124;
  long int iftmp.105;
  unsigned int __d.106;
  long int D.15133;
  long int D.15134;
  int fd.107;
  int D.15136;
  long unsigned int D.15137;
  long int D.15138;
  long int D.15139;
  long int D.15140;
  void * handle;

  handle = (void *) fd;
  if (fd > 1023) goto <D.15118>; else goto <D.15119>;
  <D.15118>:
  WSASetLastError (10022);
  return;
  <D.15119>:
  D.15120 = _wapi_handle_type (handle);
  if (D.15120 != 7) goto <D.15121>; else goto <D.15122>;
  <D.15121>:
  WSASetLastError (10038);
  return;
  <D.15122>:
  {
    long int __d;

    __d = (long int) fd;
    D.15124 = __builtin_constant_p (__d);
    if (D.15124 != 0) goto <D.15125>; else goto <D.15126>;
    <D.15125>:
    __d.106 = (unsigned int) __d;
    if (__d.106 <= 1023) goto <D.15129>; else goto <D.15130>;
    <D.15129>:
    iftmp.105 = __d / 32;
    goto <D.15131>;
    <D.15130>:
    iftmp.105 = __fdelt_warn (__d);
    <D.15131>:
    iftmp.104 = iftmp.105;
    goto <D.15132>;
    <D.15126>:
    iftmp.104 = __fdelt_chk (__d);
    <D.15132>:
    D.14369 = iftmp.104;
  }
  D.15133 = D.14369;
  D.15134 = set->fds_bits[D.15133];
  fd.107 = (int) fd;
  D.15136 = fd.107 & 31;
  D.15137 = 1 << D.15136;
  D.15138 = (long int) D.15137;
  D.15139 = ~D.15138;
  D.15140 = D.15134 & D.15139;
  set->fds_bits[D.15133] = D.15140;
}


_wapi_FD_ISSET (guint32 fd, struct fd_set * set)
{
  int D.15144;
  <unnamed type> D.15145;
  long int D.14376;
  long int iftmp.108;
  int D.15149;
  long int iftmp.109;
  unsigned int __d.110;
  long int D.15158;
  int fd.111;
  int D.15160;
  long unsigned int D.15161;
  long int D.15162;
  long int D.15163;
  _Bool D.15164;
  void * handle;

  handle = (void *) fd;
  if (fd > 1023) goto <D.15142>; else goto <D.15143>;
  <D.15142>:
  WSASetLastError (10022);
  D.15144 = 0;
  return D.15144;
  <D.15143>:
  D.15145 = _wapi_handle_type (handle);
  if (D.15145 != 7) goto <D.15146>; else goto <D.15147>;
  <D.15146>:
  WSASetLastError (10038);
  D.15144 = 0;
  return D.15144;
  <D.15147>:
  {
    long int __d;

    __d = (long int) fd;
    D.15149 = __builtin_constant_p (__d);
    if (D.15149 != 0) goto <D.15150>; else goto <D.15151>;
    <D.15150>:
    __d.110 = (unsigned int) __d;
    if (__d.110 <= 1023) goto <D.15154>; else goto <D.15155>;
    <D.15154>:
    iftmp.109 = __d / 32;
    goto <D.15156>;
    <D.15155>:
    iftmp.109 = __fdelt_warn (__d);
    <D.15156>:
    iftmp.108 = iftmp.109;
    goto <D.15157>;
    <D.15151>:
    iftmp.108 = __fdelt_chk (__d);
    <D.15157>:
    D.14376 = iftmp.108;
  }
  D.15158 = set->fds_bits[D.14376];
  fd.111 = (int) fd;
  D.15160 = fd.111 & 31;
  D.15161 = 1 << D.15160;
  D.15162 = (long int) D.15161;
  D.15163 = D.15158 & D.15162;
  D.15164 = D.15163 != 0;
  D.15144 = (int) D.15164;
  return D.15144;
}


_wapi_FD_SET (guint32 fd, struct fd_set * set)
{
  <unnamed type> D.15168;
  long int D.14383;
  long int iftmp.112;
  int D.15172;
  long int iftmp.113;
  unsigned int __d.114;
  long int D.15181;
  long int D.15182;
  int fd.115;
  int D.15184;
  long unsigned int D.15185;
  long int D.15186;
  long int D.15187;
  void * handle;

  handle = (void *) fd;
  if (fd > 1023) goto <D.15166>; else goto <D.15167>;
  <D.15166>:
  WSASetLastError (10022);
  return;
  <D.15167>:
  D.15168 = _wapi_handle_type (handle);
  if (D.15168 != 7) goto <D.15169>; else goto <D.15170>;
  <D.15169>:
  WSASetLastError (10038);
  return;
  <D.15170>:
  {
    long int __d;

    __d = (long int) fd;
    D.15172 = __builtin_constant_p (__d);
    if (D.15172 != 0) goto <D.15173>; else goto <D.15174>;
    <D.15173>:
    __d.114 = (unsigned int) __d;
    if (__d.114 <= 1023) goto <D.15177>; else goto <D.15178>;
    <D.15177>:
    iftmp.113 = __d / 32;
    goto <D.15179>;
    <D.15178>:
    iftmp.113 = __fdelt_warn (__d);
    <D.15179>:
    iftmp.112 = iftmp.113;
    goto <D.15180>;
    <D.15174>:
    iftmp.112 = __fdelt_chk (__d);
    <D.15180>:
    D.14383 = iftmp.112;
  }
  D.15181 = D.14383;
  D.15182 = set->fds_bits[D.15181];
  fd.115 = (int) fd;
  D.15184 = fd.115 & 31;
  D.15185 = 1 << D.15184;
  D.15186 = (long int) D.15185;
  D.15187 = D.15182 | D.15186;
  set->fds_bits[D.15181] = D.15187;
}


WSARecv (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * received, guint32 * flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.15189;
  long int D.15190;
  long int D.15191;
  _Bool D.15194;
  long int D.15195;
  long int D.15196;
  unsigned int D.15199;
  int D.15200;
  int D.15203;
  unsigned int ret.116;
  int D.15205;
  unsigned int D.15206;
  int ret;
  struct msghdr hdr;

  try
    {
      D.15189 = overlapped != 0B;
      D.15190 = (long int) D.15189;
      D.15191 = __builtin_expect (D.15190, 0);
      if (D.15191 != 0) goto <D.15192>; else goto <D.15193>;
      <D.15192>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1554, "overlapped == NULL");
      <D.15193>:
      D.15194 = complete != 0B;
      D.15195 = (long int) D.15194;
      D.15196 = __builtin_expect (D.15195, 0);
      if (D.15196 != 0) goto <D.15197>; else goto <D.15198>;
      <D.15197>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1555, "complete == NULL");
      <D.15198>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      D.15199 = *flags;
      D.15200 = (int) D.15199;
      ret = _wapi_recvmsg (fd, &hdr, D.15200);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.15201>; else goto <D.15202>;
      <D.15201>:
      D.15203 = ret;
      return D.15203;
      <D.15202>:
      ret.116 = (unsigned int) ret;
      *received = ret.116;
      D.15205 = hdr.msg_flags;
      D.15206 = (unsigned int) D.15205;
      *flags = D.15206;
      D.15203 = 0;
      return D.15203;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


wsabuf_to_msghdr (struct WapiWSABuf * buffers, guint32 count, struct msghdr * hdr)
{
  unsigned int D.15209;
  void * D.15210;
  struct iovec * D.15211;
  unsigned int D.15212;
  struct iovec * D.15213;
  struct WapiWSABuf * D.15214;
  void * D.15215;
  unsigned int D.15216;
  guint32 i;

  memset (hdr, 0, 28);
  hdr->msg_iovlen = count;
  D.15209 = count * 8;
  D.15210 = monoeg_malloc0 (D.15209);
  hdr->msg_iov = D.15210;
  i = 0;
  goto <D.14391>;
  <D.14390>:
  D.15211 = hdr->msg_iov;
  D.15212 = i * 8;
  D.15213 = D.15211 + D.15212;
  D.15212 = i * 8;
  D.15214 = buffers + D.15212;
  D.15215 = D.15214->buf;
  D.15213->iov_base = D.15215;
  D.15211 = hdr->msg_iov;
  D.15212 = i * 8;
  D.15213 = D.15211 + D.15212;
  D.15212 = i * 8;
  D.15214 = buffers + D.15212;
  D.15216 = D.15214->len;
  D.15213->iov_len = D.15216;
  i = i + 1;
  <D.14391>:
  if (i < count) goto <D.14390>; else goto <D.14392>;
  <D.14392>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.15219;
  int D.15224;
  void * D.15226;
  unsigned int D.15227;

  D.15219 = __builtin_constant_p (__len);
  if (D.15219 != 0) goto <D.15220>; else goto <D.15221>;
  <D.15220>:
  if (__len == 0) goto <D.15222>; else goto <D.15223>;
  <D.15222>:
  D.15224 = __builtin_constant_p (__ch);
  if (D.15224 == 0) goto <D.15217>; else goto <D.15225>;
  <D.15225>:
  if (__ch != 0) goto <D.15217>; else goto <D.15218>;
  <D.15217>:
  __warn_memset_zero_len ();
  D.15226 = __dest;
  return D.15226;
  <D.15218>:
  <D.15223>:
  <D.15221>:
  D.15227 = __builtin_object_size (__dest, 0);
  D.15226 = __builtin___memset_chk (__dest, __ch, __len, D.15227);
  return D.15226;
}


_wapi_recvmsg (guint32 fd, struct msghdr * msg, int recv_flags)
{
  unsigned int startup_count.117;
  int D.15232;
  <unnamed type> D.15233;
  int fd.118;
  int * D.15238;
  int D.15239;
  int D.15241;
  struct _WapiHandle_socket * socket_handle.119;
  int D.15248;
  unsigned int errnum.120;
  unsigned int D.15252;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  int ret;
  static const char __func__[14] = "_wapi_recvmsg";

  try
    {
      handle = (void *) fd;
      startup_count.117 = startup_count;
      if (startup_count.117 == 0) goto <D.15230>; else goto <D.15231>;
      <D.15230>:
      WSASetLastError (10093);
      D.15232 = -1;
      return D.15232;
      <D.15231>:
      D.15233 = _wapi_handle_type (handle);
      if (D.15233 != 7) goto <D.15234>; else goto <D.15235>;
      <D.15234>:
      WSASetLastError (10038);
      D.15232 = -1;
      return D.15232;
      <D.15235>:
      <D.14156>:
      fd.118 = (int) fd;
      ret = recvmsg (fd.118, msg, recv_flags);
      if (ret == -1) goto <D.15237>; else goto <D.14157>;
      <D.15237>:
      D.15238 = __errno_location ();
      D.15239 = *D.15238;
      if (D.15239 == 4) goto <D.15240>; else goto <D.14157>;
      <D.15240>:
      D.15241 = _wapi_thread_cur_apc_pending ();
      if (D.15241 == 0) goto <D.14156>; else goto <D.14157>;
      <D.14157>:
      if (ret == 0) goto <D.15242>; else goto <D.15243>;
      <D.15242>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.15244>; else goto <D.15246>;
      <D.15246>:
      socket_handle.119 = socket_handle;
      D.15248 = socket_handle.119->still_readable;
      if (D.15248 != 1) goto <D.15244>; else goto <D.15245>;
      <D.15244>:
      ret = -1;
      D.15238 = __errno_location ();
      *D.15238 = 4;
      <D.15245>:
      <D.15243>:
      if (ret == -1) goto <D.15249>; else goto <D.15250>;
      <D.15249>:
      {
        gint errnum;

        D.15238 = __errno_location ();
        errnum = *D.15238;
        errnum.120 = (unsigned int) errnum;
        D.15252 = errno_to_WSA (errnum.120, &__func__);
        errnum = (gint) D.15252;
        WSASetLastError (errnum);
        D.15232 = -1;
        return D.15232;
      }
      <D.15250>:
      D.15232 = ret;
      return D.15232;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


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

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


WSASend (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * sent, guint32 flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.15256;
  long int D.15257;
  long int D.15258;
  _Bool D.15261;
  long int D.15262;
  long int D.15263;
  int flags.121;
  int D.15269;
  unsigned int ret.122;
  int ret;
  struct msghdr hdr;

  try
    {
      D.15256 = overlapped != 0B;
      D.15257 = (long int) D.15256;
      D.15258 = __builtin_expect (D.15257, 0);
      if (D.15258 != 0) goto <D.15259>; else goto <D.15260>;
      <D.15259>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1578, "overlapped == NULL");
      <D.15260>:
      D.15261 = complete != 0B;
      D.15262 = (long int) D.15261;
      D.15263 = __builtin_expect (D.15262, 0);
      if (D.15263 != 0) goto <D.15264>; else goto <D.15265>;
      <D.15264>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1579, "complete == NULL");
      <D.15265>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      flags.121 = (int) flags;
      ret = _wapi_sendmsg (fd, &hdr, flags.121);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.15267>; else goto <D.15268>;
      <D.15267>:
      D.15269 = ret;
      return D.15269;
      <D.15268>:
      ret.122 = (unsigned int) ret;
      *sent = ret.122;
      D.15269 = 0;
      return D.15269;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


_wapi_sendmsg (guint32 fd, const struct msghdr * msg, int send_flags)
{
  unsigned int startup_count.123;
  int D.15276;
  <unnamed type> D.15277;
  int fd.124;
  int * D.15282;
  int D.15283;
  int D.15285;
  unsigned int errnum.125;
  unsigned int D.15289;
  void * handle;
  int ret;
  static const char __func__[14] = "_wapi_sendmsg";

  handle = (void *) fd;
  startup_count.123 = startup_count;
  if (startup_count.123 == 0) goto <D.15274>; else goto <D.15275>;
  <D.15274>:
  WSASetLastError (10093);
  D.15276 = -1;
  return D.15276;
  <D.15275>:
  D.15277 = _wapi_handle_type (handle);
  if (D.15277 != 7) goto <D.15278>; else goto <D.15279>;
  <D.15278>:
  WSASetLastError (10038);
  D.15276 = -1;
  return D.15276;
  <D.15279>:
  <D.14193>:
  fd.124 = (int) fd;
  ret = sendmsg (fd.124, msg, send_flags);
  if (ret == -1) goto <D.15281>; else goto <D.14194>;
  <D.15281>:
  D.15282 = __errno_location ();
  D.15283 = *D.15282;
  if (D.15283 == 4) goto <D.15284>; else goto <D.14194>;
  <D.15284>:
  D.15285 = _wapi_thread_cur_apc_pending ();
  if (D.15285 == 0) goto <D.14193>; else goto <D.14194>;
  <D.14194>:
  if (ret == -1) goto <D.15286>; else goto <D.15287>;
  <D.15286>:
  {
    gint errnum;

    D.15282 = __errno_location ();
    errnum = *D.15282;
    errnum.125 = (unsigned int) errnum;
    D.15289 = errno_to_WSA (errnum.125, &__func__);
    errnum = (gint) D.15289;
    WSASetLastError (errnum);
    D.15276 = -1;
    return D.15276;
  }
  <D.15287>:
  D.15276 = ret;
  return D.15276;
}