socket_close (void * handle, void * data)
{
  unsigned int startup_count.0;
  unsigned int in_cleanup.1;
  int handle.2;
  int * D.11840;
  int D.11841;
  int D.11843;
  unsigned int errnum.3;
  unsigned int D.11847;
  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.11833>; else goto <D.11834>;
  <D.11833>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.11836>; else goto <D.11837>;
  <D.11836>:
  WSASetLastError (10093);
  return;
  <D.11837>:
  <D.11834>:
  handle.2 = (int) handle;
  shutdown (handle.2, 0);
  <D.11432>:
  handle.2 = (int) handle;
  ret = close (handle.2);
  if (ret == -1) goto <D.11839>; else goto <D.11433>;
  <D.11839>:
  D.11840 = __errno_location ();
  D.11841 = *D.11840;
  if (D.11841 == 4) goto <D.11842>; else goto <D.11433>;
  <D.11842>:
  D.11843 = _wapi_thread_cur_apc_pending ();
  if (D.11843 == 0) goto <D.11432>; else goto <D.11433>;
  <D.11433>:
  if (ret == -1) goto <D.11844>; else goto <D.11845>;
  <D.11844>:
  {
    gint errnum;

    D.11840 = __errno_location ();
    errnum = *D.11840;
    errnum.3 = (unsigned int) errnum;
    D.11847 = errno_to_WSA (errnum.3, &__func__);
    errnum = (gint) D.11847;
    in_cleanup.1 = in_cleanup;
    if (in_cleanup.1 == 0) goto <D.11848>; else goto <D.11849>;
    <D.11848>:
    WSASetLastError (errnum);
    <D.11849>:
  }
  <D.11845>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.11850>; else goto <D.11851>;
  <D.11850>:
  socket_handle->saved_error = 0;
  <D.11851>:
}


WSAStartup (guint32 requested, struct WapiWSAData * data)
{
  int D.11855;
  unsigned int startup_count.4;
  unsigned int startup_count.5;
  short unsigned int D.11860;
  unsigned int D.11861;
  unsigned int D.11862;
  short unsigned int D.11863;
  char[257] * D.11864;
  char[129] * D.11865;

  if (data == 0B) goto <D.11853>; else goto <D.11854>;
  <D.11853>:
  D.11855 = 10014;
  return D.11855;
  <D.11854>:
  if (requested <= 1) goto <D.11856>; else goto <D.11857>;
  <D.11856>:
  D.11855 = 10092;
  return D.11855;
  <D.11857>:
  startup_count.4 = startup_count;
  startup_count.5 = startup_count.4 + 1;
  startup_count = startup_count.5;
  data->wHighVersion = 514;
  D.11860 = data->wHighVersion;
  D.11861 = (unsigned int) D.11860;
  D.11862 = MIN_EXPR <D.11861, requested>;
  D.11863 = (short unsigned int) D.11862;
  data->wVersion = D.11863;
  D.11864 = &data->szDescription;
  strncpy (D.11864, "WAPI", 256);
  D.11865 = &data->szSystemStatus;
  strncpy (D.11865, "groovy", 128);
  D.11855 = 0;
  return D.11855;
}


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

  D.11868 = __builtin_object_size (__dest, 1);
  D.11867 = __builtin___strncpy_chk (__dest, __src, __len, D.11868);
  return D.11867;
}


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

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


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

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


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

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


WSAGetLastError ()
{
  int D.11879;
  unsigned int D.11880;

  D.11880 = GetLastError ();
  D.11879 = (int) D.11880;
  return D.11879;
}


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

  handle = (void *) fd;
  D.11882 = _wapi_handle_type (handle);
  if (D.11882 != 7) goto <D.11883>; else goto <D.11884>;
  <D.11883>:
  WSASetLastError (10038);
  D.11885 = 0;
  return D.11885;
  <D.11884>:
  _wapi_handle_unref (handle);
  D.11885 = 0;
  return D.11885;
}


_wapi_handle_type (void * handle)
{
  unsigned int D.11891;
  struct _WapiHandleUnshared * D.11892;
  WapiHandleType D.11893;
  unsigned int D.11894;
  unsigned int D.11895;
  struct _WapiHandleUnshared * D.11896;
  guint32 idx;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.11887>; else goto <D.11889>;
  <D.11889>:
  if (idx > 268435455) goto <D.11887>; else goto <D.11890>;
  <D.11890>:
  D.11891 = idx / 256;
  D.11892 = _wapi_private_handles[D.11891];
  if (D.11892 == 0B) goto <D.11887>; else goto <D.11888>;
  <D.11887>:
  D.11893 = 0;
  return D.11893;
  <D.11888>:
  D.11891 = idx / 256;
  D.11892 = _wapi_private_handles[D.11891];
  D.11894 = idx & 255;
  D.11895 = D.11894 * 144;
  D.11896 = D.11892 + D.11895;
  D.11893 = D.11896->type;
  return D.11893;
}


_wapi_accept (guint32 fd, struct sockaddr * addr, socklen_t * addrlen)
{
  unsigned int startup_count.9;
  guint32 D.11901;
  unsigned int D.11904;
  <unnamed type> D.11907;
  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.11913;
  int * D.11915;
  int D.11916;
  int D.11918;
  unsigned int errnum.11;
  unsigned int D.11922;
  unsigned int new_fd.12;
  unsigned int _wapi_fd_reserve.13;
  struct _WapiHandle_socket * socket_handle.14;
  int D.11928;
  int D.11929;
  int D.11930;
  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.11899>; else goto <D.11900>;
      <D.11899>:
      WSASetLastError (10093);
      D.11901 = 4294967295;
      return D.11901;
      <D.11900>:
      if (addr != 0B) goto <D.11902>; else goto <D.11903>;
      <D.11902>:
      D.11904 = *addrlen;
      if (D.11904 <= 15) goto <D.11905>; else goto <D.11906>;
      <D.11905>:
      WSASetLastError (10014);
      D.11901 = 4294967295;
      return D.11901;
      <D.11906>:
      <D.11903>:
      D.11907 = _wapi_handle_type (handle);
      if (D.11907 != 7) goto <D.11908>; else goto <D.11909>;
      <D.11908>:
      WSASetLastError (10038);
      D.11901 = 4294967295;
      return D.11901;
      <D.11909>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.11910>; else goto <D.11911>;
      <D.11910>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.11901 = 4294967295;
      return D.11901;
      <D.11911>:
      <D.11469>:
      fd.10 = (int) fd;
      D.11913.__sockaddr__ = addr;
      new_fd = accept (fd.10, D.11913, addrlen);
      if (new_fd == -1) goto <D.11914>; else goto <D.11470>;
      <D.11914>:
      D.11915 = __errno_location ();
      D.11916 = *D.11915;
      if (D.11916 == 4) goto <D.11917>; else goto <D.11470>;
      <D.11917>:
      D.11918 = _wapi_thread_cur_apc_pending ();
      if (D.11918 == 0) goto <D.11469>; else goto <D.11470>;
      <D.11470>:
      if (new_fd == -1) goto <D.11919>; else goto <D.11920>;
      <D.11919>:
      {
        gint errnum;

        D.11915 = __errno_location ();
        errnum = *D.11915;
        errnum.11 = (unsigned int) errnum;
        D.11922 = errno_to_WSA (errnum.11, &__func__);
        errnum = (gint) D.11922;
        WSASetLastError (errnum);
        D.11901 = 4294967295;
        return D.11901;
      }
      <D.11920>:
      new_fd.12 = (unsigned int) new_fd;
      _wapi_fd_reserve.13 = _wapi_fd_reserve;
      if (new_fd.12 >= _wapi_fd_reserve.13) goto <D.11925>; else goto <D.11926>;
      <D.11925>:
      WSASetLastError (10107);
      close (new_fd);
      D.11901 = 4294967295;
      return D.11901;
      <D.11926>:
      socket_handle.14 = socket_handle;
      D.11928 = socket_handle.14->domain;
      new_socket_handle.domain = D.11928;
      socket_handle.14 = socket_handle;
      D.11929 = socket_handle.14->type;
      new_socket_handle.type = D.11929;
      socket_handle.14 = socket_handle;
      D.11930 = socket_handle.14->protocol;
      new_socket_handle.protocol = D.11930;
      new_socket_handle.still_readable = 1;
      new_handle = _wapi_handle_new_fd (7, new_fd, &new_socket_handle);
      if (new_handle == 4294967295B) goto <D.11931>; else goto <D.11932>;
      <D.11931>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (31);
      D.11901 = 4294967295;
      return D.11901;
      <D.11932>:
      D.11901 = (guint32) new_fd;
      return D.11901;
    }
  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.11938;
  <unnamed type> D.11939;
  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.11943;
  int * D.11946;
  unsigned int errnum.17;
  unsigned int D.11948;
  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.11936>; else goto <D.11937>;
  <D.11936>:
  WSASetLastError (10093);
  D.11938 = -1;
  return D.11938;
  <D.11937>:
  D.11939 = _wapi_handle_type (handle);
  if (D.11939 != 7) goto <D.11940>; else goto <D.11941>;
  <D.11940>:
  WSASetLastError (10038);
  D.11938 = -1;
  return D.11938;
  <D.11941>:
  fd.16 = (int) fd;
  D.11943.__sockaddr__ = my_addr;
  ret = bind (fd.16, D.11943, addrlen);
  if (ret == -1) goto <D.11944>; else goto <D.11945>;
  <D.11944>:
  {
    gint errnum;

    D.11946 = __errno_location ();
    errnum = *D.11946;
    errnum.17 = (unsigned int) errnum;
    D.11948 = errno_to_WSA (errnum.17, &__func__);
    errnum = (gint) D.11948;
    WSASetLastError (errnum);
    D.11938 = -1;
    return D.11938;
  }
  <D.11945>:
  D.11938 = ret;
  return D.11938;
}


_wapi_connect (guint32 fd, const struct sockaddr * serv_addr, socklen_t addrlen)
{
  unsigned int startup_count.18;
  int D.11953;
  <unnamed type> D.11954;
  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.11958;
  int D.11959;
  int * D.11962;
  int D.11963;
  unsigned int errnum.20;
  unsigned int D.11967;
  struct _WapiHandle_socket * socket_handle.21;
  unsigned int D.11982;
  unsigned int D.11983;
  int D.11984;
  int D.11986;
  int D.11987;
  unsigned int D.11990;
  int so_error.22;
  unsigned int so_error.23;
  unsigned int D.11995;
  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.11951>; else goto <D.11952>;
      <D.11951>:
      WSASetLastError (10093);
      D.11953 = -1;
      return D.11953;
      <D.11952>:
      D.11954 = _wapi_handle_type (handle);
      if (D.11954 != 7) goto <D.11955>; else goto <D.11956>;
      <D.11955>:
      WSASetLastError (10038);
      D.11953 = -1;
      return D.11953;
      <D.11956>:
      fd.19 = (int) fd;
      D.11958.__sockaddr__ = serv_addr;
      D.11959 = connect (fd.19, D.11958, addrlen);
      if (D.11959 == -1) goto <D.11960>; else goto <D.11961>;
      <D.11960>:
      {
        struct mono_pollfd fds;
        int so_error;
        socklen_t len;

        try
          {
            D.11962 = __errno_location ();
            errnum = *D.11962;
            D.11962 = __errno_location ();
            D.11963 = *D.11962;
            if (D.11963 != 4) goto <D.11964>; else goto <D.11965>;
            <D.11964>:
            errnum.20 = (unsigned int) errnum;
            D.11967 = errno_to_WSA (errnum.20, &__func__);
            errnum = (gint) D.11967;
            if (errnum == 10036) goto <D.11968>; else goto <D.11969>;
            <D.11968>:
            errnum = 10035;
            <D.11969>:
            WSASetLastError (errnum);
            if (errnum != 10035) goto <D.11970>; else goto <D.11971>;
            <D.11970>:
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.11972>; else goto <D.11973>;
            <D.11972>:
            if (errnum != 10054) goto <D.11974>; else goto <D.11975>;
            <D.11974>:
            if (errnum != 10050) goto <D.11976>; else goto <D.11977>;
            <D.11976>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p (error %d)", &__func__, handle, errnum);
            <D.11977>:
            <D.11975>:
            goto <D.11978>;
            <D.11973>:
            socket_handle.21 = socket_handle;
            socket_handle.21->saved_error = errnum;
            <D.11978>:
            <D.11971>:
            D.11953 = -1;
            return D.11953;
            <D.11965>:
            fd.19 = (int) fd;
            fds.fd = fd.19;
            fds.events = 4;
            goto <D.11495>;
            <D.11494>:
            D.11962 = __errno_location ();
            D.11963 = *D.11962;
            if (D.11963 != 4) goto <D.11980>; else goto <D.11981>;
            <D.11980>:
            D.11962 = __errno_location ();
            D.11963 = *D.11962;
            D.11982 = (unsigned int) D.11963;
            D.11983 = errno_to_WSA (D.11982, &__func__);
            errnum = (gint) D.11983;
            WSASetLastError (errnum);
            D.11953 = -1;
            return D.11953;
            <D.11981>:
            <D.11495>:
            D.11984 = mono_poll (&fds, 1, -1);
            if (D.11984 == -1) goto <D.11985>; else goto <D.11496>;
            <D.11985>:
            D.11986 = _wapi_thread_cur_apc_pending ();
            if (D.11986 == 0) goto <D.11494>; else goto <D.11496>;
            <D.11496>:
            len = 4;
            fd.19 = (int) fd;
            D.11987 = getsockopt (fd.19, 65535, 4103, &so_error, &len);
            if (D.11987 == -1) goto <D.11988>; else goto <D.11989>;
            <D.11988>:
            D.11962 = __errno_location ();
            D.11963 = *D.11962;
            D.11982 = (unsigned int) D.11963;
            D.11990 = errno_to_WSA (D.11982, &__func__);
            errnum = (gint) D.11990;
            WSASetLastError (errnum);
            D.11953 = -1;
            return D.11953;
            <D.11989>:
            so_error.22 = so_error;
            if (so_error.22 != 0) goto <D.11992>; else goto <D.11993>;
            <D.11992>:
            so_error.22 = so_error;
            so_error.23 = (unsigned int) so_error.22;
            D.11995 = errno_to_WSA (so_error.23, &__func__);
            errnum = (gint) D.11995;
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.11996>; else goto <D.11997>;
            <D.11996>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
            goto <D.11998>;
            <D.11997>:
            socket_handle.21 = socket_handle;
            socket_handle.21->saved_error = errnum;
            <D.11998>:
            WSASetLastError (errnum);
            D.11953 = -1;
            return D.11953;
            <D.11993>:
          }
        finally
          {
            fds = {CLOBBER};
            so_error = {CLOBBER};
            len = {CLOBBER};
          }
      }
      <D.11961>:
      D.11953 = 0;
      return D.11953;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_getpeername (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  unsigned int startup_count.24;
  int D.12006;
  <unnamed type> D.12007;
  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.12011;
  int * D.12014;
  unsigned int errnum.26;
  unsigned int D.12016;
  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.12004>; else goto <D.12005>;
  <D.12004>:
  WSASetLastError (10093);
  D.12006 = -1;
  return D.12006;
  <D.12005>:
  D.12007 = _wapi_handle_type (handle);
  if (D.12007 != 7) goto <D.12008>; else goto <D.12009>;
  <D.12008>:
  WSASetLastError (10038);
  D.12006 = -1;
  return D.12006;
  <D.12009>:
  fd.25 = (int) fd;
  D.12011.__sockaddr__ = name;
  ret = getpeername (fd.25, D.12011, namelen);
  if (ret == -1) goto <D.12012>; else goto <D.12013>;
  <D.12012>:
  {
    gint errnum;

    D.12014 = __errno_location ();
    errnum = *D.12014;
    errnum.26 = (unsigned int) errnum;
    D.12016 = errno_to_WSA (errnum.26, &__func__);
    errnum = (gint) D.12016;
    WSASetLastError (errnum);
    D.12006 = -1;
    return D.12006;
  }
  <D.12013>:
  D.12006 = ret;
  return D.12006;
}


_wapi_getsockname (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  unsigned int startup_count.27;
  int D.12021;
  <unnamed type> D.12022;
  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.12026;
  int * D.12029;
  unsigned int errnum.29;
  unsigned int D.12031;
  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.12019>; else goto <D.12020>;
  <D.12019>:
  WSASetLastError (10093);
  D.12021 = -1;
  return D.12021;
  <D.12020>:
  D.12022 = _wapi_handle_type (handle);
  if (D.12022 != 7) goto <D.12023>; else goto <D.12024>;
  <D.12023>:
  WSASetLastError (10038);
  D.12021 = -1;
  return D.12021;
  <D.12024>:
  fd.28 = (int) fd;
  D.12026.__sockaddr__ = name;
  ret = getsockname (fd.28, D.12026, namelen);
  if (ret == -1) goto <D.12027>; else goto <D.12028>;
  <D.12027>:
  {
    gint errnum;

    D.12029 = __errno_location ();
    errnum = *D.12029;
    errnum.29 = (unsigned int) errnum;
    D.12031 = errno_to_WSA (errnum.29, &__func__);
    errnum = (gint) D.12031;
    WSASetLastError (errnum);
    D.12021 = -1;
    return D.12021;
  }
  <D.12028>:
  D.12021 = ret;
  return D.12021;
}


_wapi_getsockopt (guint32 fd, int level, int optname, void * optval, socklen_t * optlen)
{
  unsigned int startup_count.30;
  int D.12036;
  <unnamed type> D.12037;
  unsigned int optname.31;
  unsigned int D.12043;
  int fd.32;
  int * D.12049;
  unsigned int errnum.33;
  unsigned int D.12051;
  long int D.12056;
  long int D.12057;
  long int D.12058;
  long int D.12059;
  long int D.12060;
  int D.12065;
  unsigned int D.12066;
  unsigned int D.12067;
  int D.12068;
  unsigned int D.12072;
  int D.12073;
  struct _WapiHandle_socket * socket_handle.34;
  int D.12076;
  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.12034>; else goto <D.12035>;
      <D.12034>:
      WSASetLastError (10093);
      D.12036 = -1;
      return D.12036;
      <D.12035>:
      D.12037 = _wapi_handle_type (handle);
      if (D.12037 != 7) goto <D.12038>; else goto <D.12039>;
      <D.12038>:
      WSASetLastError (10038);
      D.12036 = -1;
      return D.12036;
      <D.12039>:
      tmp_val = optval;
      if (level == 65535) goto <D.12040>; else goto <D.12041>;
      <D.12040>:
      optname.31 = (unsigned int) optname;
      D.12043 = optname.31 + 4294963195;
      if (D.12043 <= 1) goto <D.12044>; else goto <D.12045>;
      <D.12044>:
      tmp_val = &tv;
      *optlen = 8;
      <D.12045>:
      <D.12041>:
      fd.32 = (int) fd;
      ret = getsockopt (fd.32, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.12047>; else goto <D.12048>;
      <D.12047>:
      {
        gint errnum;

        D.12049 = __errno_location ();
        errnum = *D.12049;
        errnum.33 = (unsigned int) errnum;
        D.12051 = errno_to_WSA (errnum.33, &__func__);
        errnum = (gint) D.12051;
        WSASetLastError (errnum);
        D.12036 = -1;
        return D.12036;
      }
      <D.12048>:
      if (level == 65535) goto <D.12052>; else goto <D.12053>;
      <D.12052>:
      optname.31 = (unsigned int) optname;
      D.12043 = optname.31 + 4294963195;
      if (D.12043 <= 1) goto <D.12054>; else goto <D.12055>;
      <D.12054>:
      D.12056 = tv.tv_sec;
      D.12057 = D.12056 * 1000;
      D.12058 = tv.tv_usec;
      D.12059 = D.12058 / 1000;
      D.12060 = D.12057 + D.12059;
      MEM[(int *)optval] = D.12060;
      *optlen = 4;
      <D.12055>:
      <D.12053>:
      if (optname == 4103) goto <D.12061>; else goto <D.12062>;
      <D.12061>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12063>; else goto <D.12064>;
      <D.12063>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      D.12065 = MEM[(int *)optval];
      D.12066 = (unsigned int) D.12065;
      D.12067 = errno_to_WSA (D.12066, &__func__);
      D.12068 = (int) D.12067;
      MEM[(int *)optval] = D.12068;
      goto <D.12069>;
      <D.12064>:
      D.12065 = MEM[(int *)optval];
      if (D.12065 != 0) goto <D.12070>; else goto <D.12071>;
      <D.12070>:
      D.12065 = MEM[(int *)optval];
      D.12066 = (unsigned int) D.12065;
      D.12072 = errno_to_WSA (D.12066, &__func__);
      D.12073 = (int) D.12072;
      MEM[(int *)optval] = D.12073;
      socket_handle.34 = socket_handle;
      D.12065 = MEM[(int *)optval];
      socket_handle.34->saved_error = D.12065;
      goto <D.12075>;
      <D.12071>:
      socket_handle.34 = socket_handle;
      D.12076 = socket_handle.34->saved_error;
      MEM[(int *)optval] = D.12076;
      <D.12075>:
      <D.12069>:
      <D.12062>:
      D.12036 = ret;
      return D.12036;
    }
  finally
    {
      tv = {CLOBBER};
      socket_handle = {CLOBBER};
    }
}


_wapi_listen (guint32 fd, int backlog)
{
  unsigned int startup_count.35;
  int D.12082;
  <unnamed type> D.12083;
  int fd.36;
  int * D.12089;
  unsigned int errnum.37;
  unsigned int D.12091;
  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.12080>; else goto <D.12081>;
  <D.12080>:
  WSASetLastError (10093);
  D.12082 = -1;
  return D.12082;
  <D.12081>:
  D.12083 = _wapi_handle_type (handle);
  if (D.12083 != 7) goto <D.12084>; else goto <D.12085>;
  <D.12084>:
  WSASetLastError (10038);
  D.12082 = -1;
  return D.12082;
  <D.12085>:
  fd.36 = (int) fd;
  ret = listen (fd.36, backlog);
  if (ret == -1) goto <D.12087>; else goto <D.12088>;
  <D.12087>:
  {
    gint errnum;

    D.12089 = __errno_location ();
    errnum = *D.12089;
    errnum.37 = (unsigned int) errnum;
    D.12091 = errno_to_WSA (errnum.37, &__func__);
    errnum = (gint) D.12091;
    WSASetLastError (errnum);
    D.12082 = -1;
    return D.12082;
  }
  <D.12088>:
  D.12082 = 0;
  return D.12082;
}


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

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


_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.12098;
  <unnamed type> D.12099;
  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.12103;
  int * D.12105;
  int D.12106;
  int D.12108;
  struct _WapiHandle_socket * socket_handle.40;
  int D.12117;
  unsigned int errnum.41;
  unsigned int D.12121;
  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.12096>; else goto <D.12097>;
      <D.12096>:
      WSASetLastError (10093);
      D.12098 = -1;
      return D.12098;
      <D.12097>:
      D.12099 = _wapi_handle_type (handle);
      if (D.12099 != 7) goto <D.12100>; else goto <D.12101>;
      <D.12100>:
      WSASetLastError (10038);
      D.12098 = -1;
      return D.12098;
      <D.12101>:
      <D.11556>:
      fd.39 = (int) fd;
      D.12103.__sockaddr__ = from;
      ret = recvfrom (fd.39, buf, len, recv_flags, D.12103, fromlen);
      if (ret == -1) goto <D.12104>; else goto <D.11557>;
      <D.12104>:
      D.12105 = __errno_location ();
      D.12106 = *D.12105;
      if (D.12106 == 4) goto <D.12107>; else goto <D.11557>;
      <D.12107>:
      D.12108 = _wapi_thread_cur_apc_pending ();
      if (D.12108 == 0) goto <D.11556>; else goto <D.11557>;
      <D.11557>:
      if (ret == 0) goto <D.12109>; else goto <D.12110>;
      <D.12109>:
      if (len != 0) goto <D.12111>; else goto <D.12112>;
      <D.12111>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12113>; else goto <D.12115>;
      <D.12115>:
      socket_handle.40 = socket_handle;
      D.12117 = socket_handle.40->still_readable;
      if (D.12117 != 1) goto <D.12113>; else goto <D.12114>;
      <D.12113>:
      ret = -1;
      D.12105 = __errno_location ();
      *D.12105 = 4;
      <D.12114>:
      <D.12112>:
      <D.12110>:
      if (ret == -1) goto <D.12118>; else goto <D.12119>;
      <D.12118>:
      {
        gint errnum;

        D.12105 = __errno_location ();
        errnum = *D.12105;
        errnum.41 = (unsigned int) errnum;
        D.12121 = errno_to_WSA (errnum.41, &__func__);
        errnum = (gint) D.12121;
        WSASetLastError (errnum);
        D.12098 = -1;
        return D.12098;
      }
      <D.12119>:
      D.12098 = ret;
      return D.12098;
    }
  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.12124;
  int D.12127;
  ssize_t D.12130;
  unsigned int D.12131;
  unsigned int D.12132;
  unsigned int D.12135;

  D.12124 = __builtin_object_size (__buf, 0);
  if (D.12124 != 4294967295) goto <D.12125>; else goto <D.12126>;
  <D.12125>:
  D.12127 = __builtin_constant_p (__n);
  if (D.12127 == 0) goto <D.12128>; else goto <D.12129>;
  <D.12128>:
  D.12131 = __builtin_object_size (__buf, 0);
  D.12130 = __recvfrom_chk (__fd, __buf, __n, D.12131, __flags, __addr, __addr_len);
  return D.12130;
  <D.12129>:
  D.12132 = __builtin_object_size (__buf, 0);
  if (D.12132 < __n) goto <D.12133>; else goto <D.12134>;
  <D.12133>:
  D.12135 = __builtin_object_size (__buf, 0);
  D.12130 = __recvfrom_chk_warn (__fd, __buf, __n, D.12135, __flags, __addr, __addr_len);
  return D.12130;
  <D.12134>:
  <D.12126>:
  D.12130 = __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
  return D.12130;
}


_wapi_send (guint32 fd, const void * msg, size_t len, int send_flags)
{
  unsigned int startup_count.42;
  int D.12140;
  <unnamed type> D.12141;
  int fd.43;
  int * D.12146;
  int D.12147;
  int D.12149;
  int D.12156;
  unsigned int errnum.44;
  unsigned int D.12160;
  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.12138>; else goto <D.12139>;
  <D.12138>:
  WSASetLastError (10093);
  D.12140 = -1;
  return D.12140;
  <D.12139>:
  D.12141 = _wapi_handle_type (handle);
  if (D.12141 != 7) goto <D.12142>; else goto <D.12143>;
  <D.12142>:
  WSASetLastError (10038);
  D.12140 = -1;
  return D.12140;
  <D.12143>:
  <D.11581>:
  fd.43 = (int) fd;
  ret = send (fd.43, msg, len, send_flags);
  if (ret == -1) goto <D.12145>; else goto <D.11582>;
  <D.12145>:
  D.12146 = __errno_location ();
  D.12147 = *D.12146;
  if (D.12147 == 4) goto <D.12148>; else goto <D.11582>;
  <D.12148>:
  D.12149 = _wapi_thread_cur_apc_pending ();
  if (D.12149 == 0) goto <D.11581>; else goto <D.11582>;
  <D.11582>:
  if (ret == -1) goto <D.12150>; else goto <D.12151>;
  <D.12150>:
  {
    gint errnum;

    D.12146 = __errno_location ();
    errnum = *D.12146;
    if (errnum == 11) goto <D.12152>; else goto <D.12153>;
    <D.12152>:
    fd.43 = (int) fd;
    ret = fcntl (fd.43, 3, 0);
    if (ret != -1) goto <D.12154>; else goto <D.12155>;
    <D.12154>:
    D.12156 = ret & 128;
    if (D.12156 == 0) goto <D.12157>; else goto <D.12158>;
    <D.12157>:
    errnum = 145;
    <D.12158>:
    <D.12155>:
    <D.12153>:
    errnum.44 = (unsigned int) errnum;
    D.12160 = errno_to_WSA (errnum.44, &__func__);
    errnum = (gint) D.12160;
    WSASetLastError (errnum);
    D.12140 = -1;
    return D.12140;
  }
  <D.12151>:
  D.12140 = ret;
  return D.12140;
}


_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.12165;
  <unnamed type> D.12166;
  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.12170;
  int * D.12172;
  int D.12173;
  int D.12175;
  unsigned int errnum.47;
  unsigned int D.12179;
  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.12163>; else goto <D.12164>;
  <D.12163>:
  WSASetLastError (10093);
  D.12165 = -1;
  return D.12165;
  <D.12164>:
  D.12166 = _wapi_handle_type (handle);
  if (D.12166 != 7) goto <D.12167>; else goto <D.12168>;
  <D.12167>:
  WSASetLastError (10038);
  D.12165 = -1;
  return D.12165;
  <D.12168>:
  <D.11595>:
  fd.46 = (int) fd;
  D.12170.__sockaddr__ = to;
  ret = sendto (fd.46, msg, len, send_flags, D.12170, tolen);
  if (ret == -1) goto <D.12171>; else goto <D.11596>;
  <D.12171>:
  D.12172 = __errno_location ();
  D.12173 = *D.12172;
  if (D.12173 == 4) goto <D.12174>; else goto <D.11596>;
  <D.12174>:
  D.12175 = _wapi_thread_cur_apc_pending ();
  if (D.12175 == 0) goto <D.11595>; else goto <D.11596>;
  <D.11596>:
  if (ret == -1) goto <D.12176>; else goto <D.12177>;
  <D.12176>:
  {
    gint errnum;

    D.12172 = __errno_location ();
    errnum = *D.12172;
    errnum.47 = (unsigned int) errnum;
    D.12179 = errno_to_WSA (errnum.47, &__func__);
    errnum = (gint) D.12179;
    WSASetLastError (errnum);
    D.12165 = -1;
    return D.12165;
  }
  <D.12177>:
  D.12165 = ret;
  return D.12165;
}


_wapi_setsockopt (guint32 fd, int level, int optname, const void * optval, socklen_t optlen)
{
  unsigned int startup_count.48;
  int D.12184;
  <unnamed type> D.12185;
  unsigned int optname.49;
  unsigned int D.12192;
  int D.12194;
  int D.12195;
  int D.12196;
  unsigned int D.12199;
  int bufsize.50;
  int bufsize.51;
  int bufsize.52;
  int fd.53;
  int * D.12208;
  unsigned int errnum.54;
  unsigned int D.12210;
  int D.12215;
  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.12182>; else goto <D.12183>;
      <D.12182>:
      WSASetLastError (10093);
      D.12184 = -1;
      return D.12184;
      <D.12183>:
      D.12185 = _wapi_handle_type (handle);
      if (D.12185 != 7) goto <D.12186>; else goto <D.12187>;
      <D.12186>:
      WSASetLastError (10038);
      D.12184 = -1;
      return D.12184;
      <D.12187>:
      tmp_val = optval;
      if (level == 65535) goto <D.12190>; else goto <D.12188>;
      <D.12190>:
      optname.49 = (unsigned int) optname;
      D.12192 = optname.49 + 4294963195;
      if (D.12192 <= 1) goto <D.12193>; else goto <D.12188>;
      <D.12193>:
      {
        int ms;

        ms = MEM[(int *)optval];
        D.12194 = ms / 1000;
        tv.tv_sec = D.12194;
        D.12195 = ms % 1000;
        D.12196 = D.12195 * 1000;
        tv.tv_usec = D.12196;
        tmp_val = &tv;
        optlen = 8;
      }
      goto <D.12189>;
      <D.12188>:
      if (level == 65535) goto <D.12197>; else goto <D.12198>;
      <D.12197>:
      optname.49 = (unsigned int) optname;
      D.12199 = optname.49 + 4294963199;
      if (D.12199 <= 1) goto <D.12200>; else goto <D.12201>;
      <D.12200>:
      bufsize.50 = MEM[(int *)optval];
      bufsize = bufsize.50;
      bufsize.51 = bufsize;
      bufsize.52 = bufsize.51 / 2;
      bufsize = bufsize.52;
      tmp_val = &bufsize;
      <D.12201>:
      <D.12198>:
      <D.12189>:
      fd.53 = (int) fd;
      ret = setsockopt (fd.53, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.12206>; else goto <D.12207>;
      <D.12206>:
      {
        gint errnum;

        D.12208 = __errno_location ();
        errnum = *D.12208;
        errnum.54 = (unsigned int) errnum;
        D.12210 = errno_to_WSA (errnum.54, &__func__);
        errnum = (gint) D.12210;
        WSASetLastError (errnum);
        D.12184 = -1;
        return D.12184;
      }
      <D.12207>:
      if (level == 65535) goto <D.12211>; else goto <D.12212>;
      <D.12211>:
      if (optname == 4) goto <D.12213>; else goto <D.12214>;
      <D.12213>:
      {
        int type;
        socklen_t type_len;

        try
          {
            type_len = 4;
            fd.53 = (int) fd;
            D.12215 = getsockopt (fd.53, level, 4104, &type, &type_len);
            if (D.12215 == 0) goto <D.12216>; else goto <D.12217>;
            <D.12216>:
            type.55 = type;
            if (type.55 == 1) goto <D.12219>; else goto <D.12220>;
            <D.12219>:
            fd.53 = (int) fd;
            setsockopt (fd.53, level, 512, tmp_val, optlen);
            <D.12220>:
            <D.12217>:
          }
        finally
          {
            type = {CLOBBER};
            type_len = {CLOBBER};
          }
      }
      <D.12214>:
      <D.12212>:
      D.12184 = ret;
      return D.12184;
    }
  finally
    {
      bufsize = {CLOBBER};
      tv = {CLOBBER};
    }
}


_wapi_shutdown (guint32 fd, int how)
{
  unsigned int startup_count.56;
  int D.12226;
  <unnamed type> D.12227;
  struct _WapiHandle_socket * socket_handle.57;
  int fd.58;
  int * D.12239;
  unsigned int errnum.59;
  unsigned int D.12241;
  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.12224>; else goto <D.12225>;
      <D.12224>:
      WSASetLastError (10093);
      D.12226 = -1;
      return D.12226;
      <D.12225>:
      D.12227 = _wapi_handle_type (handle);
      if (D.12227 != 7) goto <D.12228>; else goto <D.12229>;
      <D.12228>:
      WSASetLastError (10038);
      D.12226 = -1;
      return D.12226;
      <D.12229>:
      if (how == 0) goto <D.12230>; else goto <D.12232>;
      <D.12232>:
      if (how == 2) goto <D.12230>; else goto <D.12231>;
      <D.12230>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12233>; else goto <D.12234>;
      <D.12233>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12226 = -1;
      return D.12226;
      <D.12234>:
      socket_handle.57 = socket_handle;
      socket_handle.57->still_readable = 0;
      <D.12231>:
      fd.58 = (int) fd;
      ret = shutdown (fd.58, how);
      if (ret == -1) goto <D.12237>; else goto <D.12238>;
      <D.12237>:
      {
        gint errnum;

        D.12239 = __errno_location ();
        errnum = *D.12239;
        errnum.59 = (unsigned int) errnum;
        D.12241 = errno_to_WSA (errnum.59, &__func__);
        errnum = (gint) D.12241;
        WSASetLastError (errnum);
        D.12226 = -1;
        return D.12226;
      }
      <D.12238>:
      D.12226 = ret;
      return D.12226;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_socket (int domain, int type, int protocol, void * unused, guint32 unused2, guint32 unused3)
{
  int * D.12254;
  unsigned int errnum.60;
  unsigned int D.12256;
  guint32 D.12257;
  unsigned int fd.61;
  unsigned int _wapi_fd_reserve.62;
  unsigned int errnum.63;
  unsigned int D.12265;
  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.12244>; else goto <D.12245>;
      <D.12244>:
      if (domain == 2) goto <D.12246>; else goto <D.12247>;
      <D.12246>:
      if (type == 3) goto <D.12248>; else goto <D.12249>;
      <D.12248>:
      if (protocol == 0) goto <D.12250>; else goto <D.12251>;
      <D.12250>:
      socket_handle.protocol = 4;
      fd = socket (2, 3, 4);
      <D.12251>:
      <D.12249>:
      <D.12247>:
      <D.12245>:
      if (fd == -1) goto <D.12252>; else goto <D.12253>;
      <D.12252>:
      {
        gint errnum;

        D.12254 = __errno_location ();
        errnum = *D.12254;
        errnum.60 = (unsigned int) errnum;
        D.12256 = errno_to_WSA (errnum.60, &__func__);
        errnum = (gint) D.12256;
        WSASetLastError (errnum);
        D.12257 = 4294967295;
        return D.12257;
      }
      <D.12253>:
      fd.61 = (unsigned int) fd;
      _wapi_fd_reserve.62 = _wapi_fd_reserve;
      if (fd.61 >= _wapi_fd_reserve.62) goto <D.12260>; else goto <D.12261>;
      <D.12260>:
      WSASetLastError (10107);
      close (fd);
      D.12257 = 4294967295;
      return D.12257;
      <D.12261>:
      {
        int ret;
        int true;

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

              D.12254 = __errno_location ();
              errnum = *D.12254;
              errnum.63 = (unsigned int) errnum;
              D.12265 = errno_to_WSA (errnum.63, &__func__);
              errnum = (int) D.12265;
              WSASetLastError (errnum);
              close (fd);
              D.12257 = 4294967295;
              return D.12257;
            }
            <D.12263>:
          }
        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.12266>; else goto <D.12267>;
      <D.12266>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (10107);
      close (fd);
      D.12257 = 4294967295;
      return D.12257;
      <D.12267>:
      D.12257 = (guint32) fd;
      return D.12257;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


socket_ops_init ()
{

}


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

  startup_count.64 = startup_count;
  if (startup_count.64 == 0) goto <D.12273>; else goto <D.12274>;
  <D.12273>:
  WSASetLastError (10093);
  D.12275 = 0B;
  return D.12275;
  <D.12274>:
  he = gethostbyname (hostname);
  if (he == 0B) goto <D.12276>; else goto <D.12277>;
  <D.12276>:
  D.12278 = __h_errno_location ();
  D.12279 = *D.12278;
  switch (D.12279) <default: <D.11662>, case 1: <D.11657>, case 2: <D.11661>, case 3: <D.11660>, case 4: <D.11659>>
  <D.11657>:
  WSASetLastError (11001);
  goto <D.11658>;
  <D.11659>:
  WSASetLastError (11004);
  goto <D.11658>;
  <D.11660>:
  WSASetLastError (11003);
  goto <D.11658>;
  <D.11661>:
  WSASetLastError (11002);
  goto <D.11658>;
  <D.11662>:
  D.12278 = __h_errno_location ();
  D.12279 = *D.12278;
  monoeg_g_log (0B, 16, "%s: Need to translate %d into winsock error", &__func__, D.12279);
  goto <D.11658>;
  <D.11658>:
  <D.12277>:
  D.12275 = he;
  return D.12275;
}


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.12284;
  <unnamed type> D.12285;
  void * D.12290;
  unsigned int D.12293;
  void * D.12302;
  unsigned int D.12305;
  unsigned int D.12310;
  void * sock;
  gint ret;

  sock = (void *) socket;
  startup_count.65 = startup_count;
  if (startup_count.65 == 0) goto <D.12282>; else goto <D.12283>;
  <D.12282>:
  WSASetLastError (10093);
  D.12284 = 0;
  return D.12284;
  <D.12283>:
  D.12285 = _wapi_handle_type (sock);
  if (D.12285 != 7) goto <D.12286>; else goto <D.12287>;
  <D.12286>:
  WSASetLastError (10038);
  D.12284 = 0;
  return D.12284;
  <D.12287>:
  if (buffers != 0B) goto <D.12288>; else goto <D.12289>;
  <D.12288>:
  D.12290 = buffers->Head;
  if (D.12290 != 0B) goto <D.12291>; else goto <D.12292>;
  <D.12291>:
  D.12293 = buffers->HeadLength;
  if (D.12293 != 0) goto <D.12294>; else goto <D.12295>;
  <D.12294>:
  D.12290 = buffers->Head;
  D.12293 = buffers->HeadLength;
  ret = _wapi_send (socket, D.12290, D.12293, 0);
  if (ret == -1) goto <D.12296>; else goto <D.12297>;
  <D.12296>:
  D.12284 = 0;
  return D.12284;
  <D.12297>:
  <D.12295>:
  <D.12292>:
  <D.12289>:
  ret = wapi_sendfile (socket, file, bytes_to_write, bytes_per_send, flags);
  if (ret == -1) goto <D.12298>; else goto <D.12299>;
  <D.12298>:
  D.12284 = 0;
  return D.12284;
  <D.12299>:
  if (buffers != 0B) goto <D.12300>; else goto <D.12301>;
  <D.12300>:
  D.12302 = buffers->Tail;
  if (D.12302 != 0B) goto <D.12303>; else goto <D.12304>;
  <D.12303>:
  D.12305 = buffers->TailLength;
  if (D.12305 != 0) goto <D.12306>; else goto <D.12307>;
  <D.12306>:
  D.12302 = buffers->Tail;
  D.12305 = buffers->TailLength;
  ret = _wapi_send (socket, D.12302, D.12305, 0);
  if (ret == -1) goto <D.12308>; else goto <D.12309>;
  <D.12308>:
  D.12284 = 0;
  return D.12284;
  <D.12309>:
  <D.12307>:
  <D.12304>:
  <D.12301>:
  D.12310 = flags & 1;
  if (D.12310 != 0) goto <D.12311>; else goto <D.12312>;
  <D.12311>:
  closesocket (socket);
  <D.12312>:
  D.12284 = 1;
  return D.12284;
}


wapi_sendfile (guint32 socket, void * fd, guint32 bytes_to_write, guint32 bytes_per_send, guint32 flags)
{
  int * D.12316;
  unsigned int errnum.66;
  unsigned int D.12318;
  gint D.12319;
  int socket.67;
  long long int D.12321;
  unsigned int D.12322;
  int D.12325;
  int D.12327;
  unsigned int D.12330;
  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.12314>; else goto <D.12315>;
      <D.12314>:
      D.12316 = __errno_location ();
      errnum = *D.12316;
      errnum.66 = (unsigned int) errnum;
      D.12318 = errno_to_WSA (errnum.66, &__func__);
      errnum = (gint) D.12318;
      WSASetLastError (errnum);
      D.12319 = -1;
      return D.12319;
      <D.12315>:
      <D.11696>:
      socket.67 = (int) socket;
      D.12321 = statbuf.st_size;
      D.12322 = (unsigned int) D.12321;
      res = sendfile (socket.67, file, 0B, D.12322);
      if (res != -1) goto <D.12324>; else goto <D.11697>;
      <D.12324>:
      D.12316 = __errno_location ();
      D.12325 = *D.12316;
      if (D.12325 == 4) goto <D.12323>; else goto <D.12326>;
      <D.12326>:
      D.12316 = __errno_location ();
      D.12325 = *D.12316;
      if (D.12325 == 11) goto <D.12323>; else goto <D.11697>;
      <D.12323>:
      D.12327 = _wapi_thread_cur_apc_pending ();
      if (D.12327 == 0) goto <D.11696>; else goto <D.11697>;
      <D.11697>:
      if (res == -1) goto <D.12328>; else goto <D.12329>;
      <D.12328>:
      D.12316 = __errno_location ();
      errnum = *D.12316;
      errnum.66 = (unsigned int) errnum;
      D.12330 = errno_to_WSA (errnum.66, &__func__);
      errnum = (gint) D.12330;
      WSASetLastError (errnum);
      D.12319 = -1;
      return D.12319;
      <D.12329>:
      D.12319 = 0;
      return D.12319;
    }
  finally
    {
      statbuf = {CLOBBER};
    }
}


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

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


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.12338;
  <unnamed type> D.12339;
  unsigned int i_len.69;
  unsigned int o_len.70;
  struct WapiGuid * D.12352;
  int D.12353;
  void * * D.12356;
  void * D.12357;
  gchar * D.12362;
  gchar * D.12363;
  int fd.71;
  int * D.12367;
  unsigned int errnum.72;
  unsigned int D.12369;
  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.12390;
  unsigned int i_len.81;
  long unsigned int command.82;
  unsigned int errnum.83;
  unsigned int D.12398;
  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.12336>; else goto <D.12337>;
  <D.12336>:
  WSASetLastError (10093);
  D.12338 = -1;
  return D.12338;
  <D.12337>:
  D.12339 = _wapi_handle_type (handle);
  if (D.12339 != 7) goto <D.12340>; else goto <D.12341>;
  <D.12340>:
  WSASetLastError (10038);
  D.12338 = -1;
  return D.12338;
  <D.12341>:
  if (command == -939524090) goto <D.12342>; else goto <D.12343>;
  <D.12342>:
  {
    int i;
    struct WapiGuid * guid;

    i = 0;
    guid = input;
    i_len.69 = (unsigned int) i_len;
    if (i_len.69 <= 15) goto <D.12345>; else goto <D.12346>;
    <D.12345>:
    WSASetLastError (10022);
    D.12338 = -1;
    return D.12338;
    <D.12346>:
    o_len.70 = (unsigned int) o_len;
    if (o_len.70 <= 3) goto <D.12348>; else goto <D.12349>;
    <D.12348>:
    WSASetLastError (10022);
    D.12338 = -1;
    return D.12338;
    <D.12349>:
    if (output == 0B) goto <D.12350>; else goto <D.12351>;
    <D.12350>:
    WSASetLastError (10022);
    D.12338 = -1;
    return D.12338;
    <D.12351>:
    goto <D.11730>;
    <D.11729>:
    D.12352 = &extension_functions[i].guid;
    D.12353 = memcmp (guid, D.12352, 16);
    if (D.12353 == 0) goto <D.12354>; else goto <D.12355>;
    <D.12354>:
    D.12356 = &extension_functions[i].func;
    memcpy (output, D.12356, 4);
    *written = 4;
    D.12338 = 0;
    return D.12338;
    <D.12355>:
    i = i + 1;
    <D.11730>:
    D.12357 = extension_functions[i].func;
    if (D.12357 != 0B) goto <D.11729>; else goto <D.11731>;
    <D.11731>:
    WSASetLastError (10022);
    D.12338 = -1;
    return D.12338;
  }
  <D.12343>:
  if (command == -1744830460) goto <D.12358>; else goto <D.12359>;
  <D.12358>:
  {
    uint32_t onoff;
    uint32_t keepalivetime;
    uint32_t keepaliveinterval;

    try
      {
        i_len.69 = (unsigned int) i_len;
        if (i_len.69 <= 11) goto <D.12360>; else goto <D.12361>;
        <D.12360>:
        WSASetLastError (10022);
        D.12338 = -1;
        return D.12338;
        <D.12361>:
        memcpy (&onoff, input, 4);
        D.12362 = input + 4;
        memcpy (&keepalivetime, D.12362, 4);
        D.12363 = input + 8;
        memcpy (&keepaliveinterval, D.12363, 4);
        fd.71 = (int) fd;
        ret = setsockopt (fd.71, 65535, 8, &onoff, 4);
        if (ret < 0) goto <D.12365>; else goto <D.12366>;
        <D.12365>:
        {
          gint errnum;

          D.12367 = __errno_location ();
          errnum = *D.12367;
          errnum.72 = (unsigned int) errnum;
          D.12369 = errno_to_WSA (errnum.72, &__func__);
          errnum = (gint) D.12369;
          WSASetLastError (errnum);
          D.12338 = -1;
          return D.12338;
        }
        <D.12366>:
        onoff.73 = onoff;
        if (onoff.73 != 0) goto <D.12371>; else goto <D.12372>;
        <D.12371>:
        {
          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.12375>; else goto <D.12377>;
          <D.12377>:
          if (rem > 499) goto <D.12375>; else goto <D.12376>;
          <D.12375>:
          keepalivetime.74 = keepalivetime;
          keepalivetime.76 = keepalivetime.74 + 1;
          keepalivetime = keepalivetime.76;
          <D.12376>:
          fd.71 = (int) fd;
          ret = setsockopt (fd.71, 6, 4, &keepalivetime, 4);
          if (ret == 0) goto <D.12379>; else goto <D.12380>;
          <D.12379>:
          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.12383>; else goto <D.12385>;
          <D.12385>:
          if (rem > 499) goto <D.12383>; else goto <D.12384>;
          <D.12383>:
          keepaliveinterval.77 = keepaliveinterval;
          keepaliveinterval.79 = keepaliveinterval.77 + 1;
          keepaliveinterval = keepaliveinterval.79;
          <D.12384>:
          fd.71 = (int) fd;
          ret = setsockopt (fd.71, 6, 5, &keepaliveinterval, 4);
          <D.12380>:
          if (ret != 0) goto <D.12387>; else goto <D.12388>;
          <D.12387>:
          {
            gint errnum;

            D.12367 = __errno_location ();
            errnum = *D.12367;
            errnum.80 = (unsigned int) errnum;
            D.12390 = errno_to_WSA (errnum.80, &__func__);
            errnum = (gint) D.12390;
            WSASetLastError (errnum);
            D.12338 = -1;
            return D.12338;
          }
          <D.12388>:
          D.12338 = 0;
          return D.12338;
        }
        <D.12372>:
        D.12338 = 0;
        return D.12338;
      }
    finally
      {
        onoff = {CLOBBER};
        keepalivetime = {CLOBBER};
        keepaliveinterval = {CLOBBER};
      }
  }
  <D.12359>:
  if (i_len > 0) goto <D.12391>; else goto <D.12392>;
  <D.12391>:
  i_len.81 = (unsigned int) i_len;
  buffer = monoeg_g_memdup (input, i_len.81);
  <D.12392>:
  fd.71 = (int) fd;
  command.82 = (long unsigned int) command;
  ret = ioctl (fd.71, command.82, buffer);
  if (ret == -1) goto <D.12395>; else goto <D.12396>;
  <D.12395>:
  {
    gint errnum;

    D.12367 = __errno_location ();
    errnum = *D.12367;
    errnum.83 = (unsigned int) errnum;
    D.12398 = errno_to_WSA (errnum.83, &__func__);
    errnum = (gint) D.12398;
    WSASetLastError (errnum);
    monoeg_g_free (buffer);
    D.12338 = -1;
    return D.12338;
  }
  <D.12396>:
  if (buffer == 0B) goto <D.12399>; else goto <D.12400>;
  <D.12399>:
  *written = 0;
  goto <D.12401>;
  <D.12400>:
  i_len = MIN_EXPR <i_len, o_len>;
  if (i_len > 0) goto <D.12402>; else goto <D.12403>;
  <D.12402>:
  if (output != 0B) goto <D.12404>; else goto <D.12405>;
  <D.12404>:
  i_len.84 = (unsigned int) i_len;
  memcpy (output, buffer, i_len.84);
  <D.12405>:
  <D.12403>:
  monoeg_g_free (buffer);
  *written = i_len;
  <D.12401>:
  D.12338 = 0;
  return D.12338;
}


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

  if (reserved != 0) goto <D.12409>; else goto <D.12410>;
  <D.12409>:
  WSASetLastError (10022);
  D.12411 = 0;
  return D.12411;
  <D.12410>:
  D.12411 = socket_disconnect (fd);
  return D.12411;
}


socket_disconnect (guint32 fd)
{
  gboolean D.12415;
  struct _WapiHandle_socket * socket_handle.85;
  int D.12417;
  int D.12418;
  int D.12419;
  int * D.12422;
  unsigned int errnum.86;
  unsigned int D.12424;
  int fd.87;
  int D.12427;
  unsigned int errnum.88;
  unsigned int D.12431;
  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.12413>; else goto <D.12414>;
      <D.12413>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12415 = 0;
      return D.12415;
      <D.12414>:
      socket_handle.85 = socket_handle;
      D.12417 = socket_handle.85->domain;
      socket_handle.85 = socket_handle;
      D.12418 = socket_handle.85->type;
      socket_handle.85 = socket_handle;
      D.12419 = socket_handle.85->protocol;
      newsock = socket (D.12417, D.12418, D.12419);
      if (newsock == -1) goto <D.12420>; else goto <D.12421>;
      <D.12420>:
      {
        gint errnum;

        D.12422 = __errno_location ();
        errnum = *D.12422;
        errnum.86 = (unsigned int) errnum;
        D.12424 = errno_to_WSA (errnum.86, &__func__);
        errnum = (gint) D.12424;
        WSASetLastError (errnum);
        D.12415 = 0;
        return D.12415;
      }
      <D.12421>:
      <D.11674>:
      fd.87 = (int) fd;
      ret = dup2 (newsock, fd.87);
      if (ret == -1) goto <D.12426>; else goto <D.11675>;
      <D.12426>:
      D.12422 = __errno_location ();
      D.12427 = *D.12422;
      if (D.12427 == 11) goto <D.11674>; else goto <D.11675>;
      <D.11675>:
      if (ret == -1) goto <D.12428>; else goto <D.12429>;
      <D.12428>:
      {
        gint errnum;

        D.12422 = __errno_location ();
        errnum = *D.12422;
        errnum.88 = (unsigned int) errnum;
        D.12431 = errno_to_WSA (errnum.88, &__func__);
        errnum = (gint) D.12431;
        WSASetLastError (errnum);
        D.12415 = 0;
        return D.12415;
      }
      <D.12429>:
      close (newsock);
      D.12415 = 1;
      return D.12415;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


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

  D.12435 = __builtin_object_size (__dest, 0);
  D.12434 = __builtin___memcpy_chk (__dest, __src, __len, D.12435);
  return D.12434;
}


ioctlsocket (guint32 fd, gint32 command, void * arg)
{
  unsigned int startup_count.89;
  int D.12440;
  <unnamed type> D.12441;
  int fd.90;
  int D.12447;
  long unsigned int command.91;
  int * D.12454;
  unsigned int errnum.92;
  unsigned int D.12456;
  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.12438>; else goto <D.12439>;
  <D.12438>:
  WSASetLastError (10093);
  D.12440 = -1;
  return D.12440;
  <D.12439>:
  D.12441 = _wapi_handle_type (handle);
  if (D.12441 != 7) goto <D.12442>; else goto <D.12443>;
  <D.12442>:
  WSASetLastError (10038);
  D.12440 = -1;
  return D.12440;
  <D.12443>:
  switch (command) <default: <D.11751>, case 18047: <D.11750>, case 26238: <D.11747>, case 1074033415: <D.11749>>
  <D.11747>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 3, 0);
  if (ret != -1) goto <D.12445>; else goto <D.12446>;
  <D.12445>:
  D.12447 = MEM[(gboolean *)arg];
  if (D.12447 != 0) goto <D.12448>; else goto <D.12449>;
  <D.12448>:
  ret = ret | 128;
  goto <D.12450>;
  <D.12449>:
  ret = ret & -129;
  <D.12450>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 4, ret);
  <D.12446>:
  goto <D.11748>;
  <D.11749>:
  fd.90 = (int) fd;
  command.91 = (long unsigned int) command;
  ret = ioctl (fd.90, command.91, arg);
  goto <D.11748>;
  <D.11750>:
  fd.90 = (int) fd;
  command.91 = (long unsigned int) command;
  ret = ioctl (fd.90, command.91, arg);
  goto <D.11748>;
  <D.11751>:
  WSASetLastError (10022);
  D.12440 = -1;
  return D.12440;
  <D.11748>:
  if (ret == -1) goto <D.12452>; else goto <D.12453>;
  <D.12452>:
  {
    gint errnum;

    D.12454 = __errno_location ();
    errnum = *D.12454;
    errnum.92 = (unsigned int) errnum;
    D.12456 = errno_to_WSA (errnum.92, &__func__);
    errnum = (gint) D.12456;
    WSASetLastError (errnum);
    D.12440 = -1;
    return D.12440;
  }
  <D.12453>:
  D.12440 = 0;
  return D.12440;
}


_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.12461;
  long int D.11764;
  long int iftmp.94;
  int D.12467;
  long int iftmp.95;
  unsigned int __d.96;
  long int D.12476;
  int D.12477;
  long int D.12478;
  long int D.12479;
  long int D.11766;
  long int iftmp.97;
  int D.12482;
  long int iftmp.98;
  unsigned int __d.99;
  long int D.12491;
  long int D.12492;
  long int D.12493;
  long int D.11768;
  long int iftmp.100;
  int D.12496;
  long int iftmp.101;
  unsigned int __d.102;
  long int D.12505;
  long int D.12506;
  long int D.12507;
  int D.12510;
  int * D.12512;
  int D.12513;
  int D.12515;
  unsigned int errnum.103;
  unsigned int D.12519;
  int ret;
  int maxfd;
  static const char __func__[13] = "_wapi_select";

  startup_count.93 = startup_count;
  if (startup_count.93 == 0) goto <D.12459>; else goto <D.12460>;
  <D.12459>:
  WSASetLastError (10093);
  D.12461 = -1;
  return D.12461;
  <D.12460>:
  maxfd = 1023;
  goto <D.11771>;
  <D.11770>:
  if (readfds != 0B) goto <D.12465>; else goto <D.12462>;
  <D.12465>:
  {
    long int __d;

    __d = maxfd;
    D.12467 = __builtin_constant_p (__d);
    if (D.12467 != 0) goto <D.12468>; else goto <D.12469>;
    <D.12468>:
    __d.96 = (unsigned int) __d;
    if (__d.96 <= 1023) goto <D.12472>; else goto <D.12473>;
    <D.12472>:
    iftmp.95 = __d / 32;
    goto <D.12474>;
    <D.12473>:
    iftmp.95 = __fdelt_warn (__d);
    <D.12474>:
    iftmp.94 = iftmp.95;
    goto <D.12475>;
    <D.12469>:
    iftmp.94 = __fdelt_chk (__d);
    <D.12475>:
    D.11764 = iftmp.94;
  }
  D.12476 = readfds->fds_bits[D.11764];
  D.12477 = maxfd % 32;
  D.12478 = D.12476 >> D.12477;
  D.12479 = D.12478 & 1;
  if (D.12479 != 0) goto <D.11769>; else goto <D.12462>;
  <D.12462>:
  if (writefds != 0B) goto <D.12480>; else goto <D.12463>;
  <D.12480>:
  {
    long int __d;

    __d = maxfd;
    D.12482 = __builtin_constant_p (__d);
    if (D.12482 != 0) goto <D.12483>; else goto <D.12484>;
    <D.12483>:
    __d.99 = (unsigned int) __d;
    if (__d.99 <= 1023) goto <D.12487>; else goto <D.12488>;
    <D.12487>:
    iftmp.98 = __d / 32;
    goto <D.12489>;
    <D.12488>:
    iftmp.98 = __fdelt_warn (__d);
    <D.12489>:
    iftmp.97 = iftmp.98;
    goto <D.12490>;
    <D.12484>:
    iftmp.97 = __fdelt_chk (__d);
    <D.12490>:
    D.11766 = iftmp.97;
  }
  D.12491 = writefds->fds_bits[D.11766];
  D.12477 = maxfd % 32;
  D.12492 = D.12491 >> D.12477;
  D.12493 = D.12492 & 1;
  if (D.12493 != 0) goto <D.11769>; else goto <D.12463>;
  <D.12463>:
  if (exceptfds != 0B) goto <D.12494>; else goto <D.12464>;
  <D.12494>:
  {
    long int __d;

    __d = maxfd;
    D.12496 = __builtin_constant_p (__d);
    if (D.12496 != 0) goto <D.12497>; else goto <D.12498>;
    <D.12497>:
    __d.102 = (unsigned int) __d;
    if (__d.102 <= 1023) goto <D.12501>; else goto <D.12502>;
    <D.12501>:
    iftmp.101 = __d / 32;
    goto <D.12503>;
    <D.12502>:
    iftmp.101 = __fdelt_warn (__d);
    <D.12503>:
    iftmp.100 = iftmp.101;
    goto <D.12504>;
    <D.12498>:
    iftmp.100 = __fdelt_chk (__d);
    <D.12504>:
    D.11768 = iftmp.100;
  }
  D.12505 = exceptfds->fds_bits[D.11768];
  D.12477 = maxfd % 32;
  D.12506 = D.12505 >> D.12477;
  D.12507 = D.12506 & 1;
  if (D.12507 != 0) goto <D.11769>; else goto <D.12464>;
  <D.12464>:
  maxfd = maxfd + -1;
  <D.11771>:
  if (maxfd >= 0) goto <D.11770>; else goto <D.11769>;
  <D.11769>:
  if (maxfd == -1) goto <D.12508>; else goto <D.12509>;
  <D.12508>:
  WSASetLastError (10022);
  D.12461 = -1;
  return D.12461;
  <D.12509>:
  <D.11772>:
  D.12510 = maxfd + 1;
  ret = select (D.12510, readfds, writefds, exceptfds, timeout);
  if (ret == -1) goto <D.12511>; else goto <D.11773>;
  <D.12511>:
  D.12512 = __errno_location ();
  D.12513 = *D.12512;
  if (D.12513 == 4) goto <D.12514>; else goto <D.11773>;
  <D.12514>:
  D.12515 = _wapi_thread_cur_apc_pending ();
  if (D.12515 == 0) goto <D.11772>; else goto <D.11773>;
  <D.11773>:
  if (ret == -1) goto <D.12516>; else goto <D.12517>;
  <D.12516>:
  {
    gint errnum;

    D.12512 = __errno_location ();
    errnum = *D.12512;
    errnum.103 = (unsigned int) errnum;
    D.12519 = errno_to_WSA (errnum.103, &__func__);
    errnum = (gint) D.12519;
    WSASetLastError (errnum);
    D.12461 = -1;
    return D.12461;
  }
  <D.12517>:
  D.12461 = ret;
  return D.12461;
}


_wapi_FD_CLR (guint32 fd, struct fd_set * set)
{
  <unnamed type> D.12523;
  long int D.11782;
  long int iftmp.104;
  int D.12527;
  long int iftmp.105;
  unsigned int __d.106;
  long int D.12536;
  long int D.12537;
  int fd.107;
  int D.12539;
  long int D.12540;
  long int D.12541;
  long int D.12542;
  void * handle;

  handle = (void *) fd;
  if (fd > 1023) goto <D.12521>; else goto <D.12522>;
  <D.12521>:
  WSASetLastError (10022);
  return;
  <D.12522>:
  D.12523 = _wapi_handle_type (handle);
  if (D.12523 != 7) goto <D.12524>; else goto <D.12525>;
  <D.12524>:
  WSASetLastError (10038);
  return;
  <D.12525>:
  {
    long int __d;

    __d = (long int) fd;
    D.12527 = __builtin_constant_p (__d);
    if (D.12527 != 0) goto <D.12528>; else goto <D.12529>;
    <D.12528>:
    __d.106 = (unsigned int) __d;
    if (__d.106 <= 1023) goto <D.12532>; else goto <D.12533>;
    <D.12532>:
    iftmp.105 = __d / 32;
    goto <D.12534>;
    <D.12533>:
    iftmp.105 = __fdelt_warn (__d);
    <D.12534>:
    iftmp.104 = iftmp.105;
    goto <D.12535>;
    <D.12529>:
    iftmp.104 = __fdelt_chk (__d);
    <D.12535>:
    D.11782 = iftmp.104;
  }
  D.12536 = D.11782;
  D.12537 = set->fds_bits[D.12536];
  fd.107 = (int) fd;
  D.12539 = fd.107 & 31;
  D.12540 = 1 << D.12539;
  D.12541 = ~D.12540;
  D.12542 = D.12537 & D.12541;
  set->fds_bits[D.12536] = D.12542;
}


_wapi_FD_ISSET (guint32 fd, struct fd_set * set)
{
  int D.12546;
  <unnamed type> D.12547;
  long int D.11789;
  long int iftmp.108;
  int D.12551;
  long int iftmp.109;
  unsigned int __d.110;
  long int D.12560;
  int fd.111;
  int D.12562;
  long int D.12563;
  long int D.12564;
  _Bool D.12565;
  void * handle;

  handle = (void *) fd;
  if (fd > 1023) goto <D.12544>; else goto <D.12545>;
  <D.12544>:
  WSASetLastError (10022);
  D.12546 = 0;
  return D.12546;
  <D.12545>:
  D.12547 = _wapi_handle_type (handle);
  if (D.12547 != 7) goto <D.12548>; else goto <D.12549>;
  <D.12548>:
  WSASetLastError (10038);
  D.12546 = 0;
  return D.12546;
  <D.12549>:
  {
    long int __d;

    __d = (long int) fd;
    D.12551 = __builtin_constant_p (__d);
    if (D.12551 != 0) goto <D.12552>; else goto <D.12553>;
    <D.12552>:
    __d.110 = (unsigned int) __d;
    if (__d.110 <= 1023) goto <D.12556>; else goto <D.12557>;
    <D.12556>:
    iftmp.109 = __d / 32;
    goto <D.12558>;
    <D.12557>:
    iftmp.109 = __fdelt_warn (__d);
    <D.12558>:
    iftmp.108 = iftmp.109;
    goto <D.12559>;
    <D.12553>:
    iftmp.108 = __fdelt_chk (__d);
    <D.12559>:
    D.11789 = iftmp.108;
  }
  D.12560 = set->fds_bits[D.11789];
  fd.111 = (int) fd;
  D.12562 = fd.111 & 31;
  D.12563 = D.12560 >> D.12562;
  D.12564 = D.12563 & 1;
  D.12565 = D.12564 != 0;
  D.12546 = (int) D.12565;
  return D.12546;
}


_wapi_FD_SET (guint32 fd, struct fd_set * set)
{
  <unnamed type> D.12569;
  long int D.11796;
  long int iftmp.112;
  int D.12573;
  long int iftmp.113;
  unsigned int __d.114;
  long int D.12582;
  long int D.12583;
  int fd.115;
  int D.12585;
  long int D.12586;
  long int D.12587;
  void * handle;

  handle = (void *) fd;
  if (fd > 1023) goto <D.12567>; else goto <D.12568>;
  <D.12567>:
  WSASetLastError (10022);
  return;
  <D.12568>:
  D.12569 = _wapi_handle_type (handle);
  if (D.12569 != 7) goto <D.12570>; else goto <D.12571>;
  <D.12570>:
  WSASetLastError (10038);
  return;
  <D.12571>:
  {
    long int __d;

    __d = (long int) fd;
    D.12573 = __builtin_constant_p (__d);
    if (D.12573 != 0) goto <D.12574>; else goto <D.12575>;
    <D.12574>:
    __d.114 = (unsigned int) __d;
    if (__d.114 <= 1023) goto <D.12578>; else goto <D.12579>;
    <D.12578>:
    iftmp.113 = __d / 32;
    goto <D.12580>;
    <D.12579>:
    iftmp.113 = __fdelt_warn (__d);
    <D.12580>:
    iftmp.112 = iftmp.113;
    goto <D.12581>;
    <D.12575>:
    iftmp.112 = __fdelt_chk (__d);
    <D.12581>:
    D.11796 = iftmp.112;
  }
  D.12582 = D.11796;
  D.12583 = set->fds_bits[D.12582];
  fd.115 = (int) fd;
  D.12585 = fd.115 & 31;
  D.12586 = 1 << D.12585;
  D.12587 = D.12583 | D.12586;
  set->fds_bits[D.12582] = D.12587;
}


WSARecv (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * received, guint32 * flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.12589;
  long int D.12590;
  long int D.12591;
  _Bool D.12594;
  long int D.12595;
  long int D.12596;
  unsigned int D.12599;
  int D.12600;
  int D.12603;
  unsigned int ret.116;
  int D.12605;
  unsigned int D.12606;
  int ret;
  struct msghdr hdr;

  try
    {
      D.12589 = overlapped != 0B;
      D.12590 = (long int) D.12589;
      D.12591 = __builtin_expect (D.12590, 0);
      if (D.12591 != 0) goto <D.12592>; else goto <D.12593>;
      <D.12592>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1554, "overlapped == NULL");
      <D.12593>:
      D.12594 = complete != 0B;
      D.12595 = (long int) D.12594;
      D.12596 = __builtin_expect (D.12595, 0);
      if (D.12596 != 0) goto <D.12597>; else goto <D.12598>;
      <D.12597>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1555, "complete == NULL");
      <D.12598>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      D.12599 = *flags;
      D.12600 = (int) D.12599;
      ret = _wapi_recvmsg (fd, &hdr, D.12600);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.12601>; else goto <D.12602>;
      <D.12601>:
      D.12603 = ret;
      return D.12603;
      <D.12602>:
      ret.116 = (unsigned int) ret;
      *received = ret.116;
      D.12605 = hdr.msg_flags;
      D.12606 = (unsigned int) D.12605;
      *flags = D.12606;
      D.12603 = 0;
      return D.12603;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


wsabuf_to_msghdr (struct WapiWSABuf * buffers, guint32 count, struct msghdr * hdr)
{
  unsigned int D.12609;
  void * D.12610;
  struct iovec * D.12611;
  unsigned int D.12612;
  struct iovec * D.12613;
  struct WapiWSABuf * D.12614;
  void * D.12615;
  unsigned int D.12616;
  guint32 i;

  memset (hdr, 0, 28);
  hdr->msg_iovlen = count;
  D.12609 = count * 8;
  D.12610 = monoeg_malloc0 (D.12609);
  hdr->msg_iov = D.12610;
  i = 0;
  goto <D.11804>;
  <D.11803>:
  D.12611 = hdr->msg_iov;
  D.12612 = i * 8;
  D.12613 = D.12611 + D.12612;
  D.12612 = i * 8;
  D.12614 = buffers + D.12612;
  D.12615 = D.12614->buf;
  D.12613->iov_base = D.12615;
  D.12611 = hdr->msg_iov;
  D.12612 = i * 8;
  D.12613 = D.12611 + D.12612;
  D.12612 = i * 8;
  D.12614 = buffers + D.12612;
  D.12616 = D.12614->len;
  D.12613->iov_len = D.12616;
  i = i + 1;
  <D.11804>:
  if (i < count) goto <D.11803>; else goto <D.11805>;
  <D.11805>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.12619;
  int D.12624;
  void * D.12626;
  unsigned int D.12627;

  D.12619 = __builtin_constant_p (__len);
  if (D.12619 != 0) goto <D.12620>; else goto <D.12621>;
  <D.12620>:
  if (__len == 0) goto <D.12622>; else goto <D.12623>;
  <D.12622>:
  D.12624 = __builtin_constant_p (__ch);
  if (D.12624 == 0) goto <D.12617>; else goto <D.12625>;
  <D.12625>:
  if (__ch != 0) goto <D.12617>; else goto <D.12618>;
  <D.12617>:
  __warn_memset_zero_len ();
  D.12626 = __dest;
  return D.12626;
  <D.12618>:
  <D.12623>:
  <D.12621>:
  D.12627 = __builtin_object_size (__dest, 0);
  D.12626 = __builtin___memset_chk (__dest, __ch, __len, D.12627);
  return D.12626;
}


_wapi_recvmsg (guint32 fd, struct msghdr * msg, int recv_flags)
{
  unsigned int startup_count.117;
  int D.12632;
  <unnamed type> D.12633;
  int fd.118;
  int * D.12638;
  int D.12639;
  int D.12641;
  struct _WapiHandle_socket * socket_handle.119;
  int D.12648;
  unsigned int errnum.120;
  unsigned int D.12652;
  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.12630>; else goto <D.12631>;
      <D.12630>:
      WSASetLastError (10093);
      D.12632 = -1;
      return D.12632;
      <D.12631>:
      D.12633 = _wapi_handle_type (handle);
      if (D.12633 != 7) goto <D.12634>; else goto <D.12635>;
      <D.12634>:
      WSASetLastError (10038);
      D.12632 = -1;
      return D.12632;
      <D.12635>:
      <D.11569>:
      fd.118 = (int) fd;
      ret = recvmsg (fd.118, msg, recv_flags);
      if (ret == -1) goto <D.12637>; else goto <D.11570>;
      <D.12637>:
      D.12638 = __errno_location ();
      D.12639 = *D.12638;
      if (D.12639 == 4) goto <D.12640>; else goto <D.11570>;
      <D.12640>:
      D.12641 = _wapi_thread_cur_apc_pending ();
      if (D.12641 == 0) goto <D.11569>; else goto <D.11570>;
      <D.11570>:
      if (ret == 0) goto <D.12642>; else goto <D.12643>;
      <D.12642>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12644>; else goto <D.12646>;
      <D.12646>:
      socket_handle.119 = socket_handle;
      D.12648 = socket_handle.119->still_readable;
      if (D.12648 != 1) goto <D.12644>; else goto <D.12645>;
      <D.12644>:
      ret = -1;
      D.12638 = __errno_location ();
      *D.12638 = 4;
      <D.12645>:
      <D.12643>:
      if (ret == -1) goto <D.12649>; else goto <D.12650>;
      <D.12649>:
      {
        gint errnum;

        D.12638 = __errno_location ();
        errnum = *D.12638;
        errnum.120 = (unsigned int) errnum;
        D.12652 = errno_to_WSA (errnum.120, &__func__);
        errnum = (gint) D.12652;
        WSASetLastError (errnum);
        D.12632 = -1;
        return D.12632;
      }
      <D.12650>:
      D.12632 = ret;
      return D.12632;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


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

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


WSASend (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * sent, guint32 flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.12656;
  long int D.12657;
  long int D.12658;
  _Bool D.12661;
  long int D.12662;
  long int D.12663;
  int flags.121;
  int D.12669;
  unsigned int ret.122;
  int ret;
  struct msghdr hdr;

  try
    {
      D.12656 = overlapped != 0B;
      D.12657 = (long int) D.12656;
      D.12658 = __builtin_expect (D.12657, 0);
      if (D.12658 != 0) goto <D.12659>; else goto <D.12660>;
      <D.12659>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1578, "overlapped == NULL");
      <D.12660>:
      D.12661 = complete != 0B;
      D.12662 = (long int) D.12661;
      D.12663 = __builtin_expect (D.12662, 0);
      if (D.12663 != 0) goto <D.12664>; else goto <D.12665>;
      <D.12664>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1579, "complete == NULL");
      <D.12665>:
      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.12667>; else goto <D.12668>;
      <D.12667>:
      D.12669 = ret;
      return D.12669;
      <D.12668>:
      ret.122 = (unsigned int) ret;
      *sent = ret.122;
      D.12669 = 0;
      return D.12669;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


_wapi_sendmsg (guint32 fd, const struct msghdr * msg, int send_flags)
{
  unsigned int startup_count.123;
  int D.12676;
  <unnamed type> D.12677;
  int fd.124;
  int * D.12682;
  int D.12683;
  int D.12685;
  unsigned int errnum.125;
  unsigned int D.12689;
  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.12674>; else goto <D.12675>;
  <D.12674>:
  WSASetLastError (10093);
  D.12676 = -1;
  return D.12676;
  <D.12675>:
  D.12677 = _wapi_handle_type (handle);
  if (D.12677 != 7) goto <D.12678>; else goto <D.12679>;
  <D.12678>:
  WSASetLastError (10038);
  D.12676 = -1;
  return D.12676;
  <D.12679>:
  <D.11606>:
  fd.124 = (int) fd;
  ret = sendmsg (fd.124, msg, send_flags);
  if (ret == -1) goto <D.12681>; else goto <D.11607>;
  <D.12681>:
  D.12682 = __errno_location ();
  D.12683 = *D.12682;
  if (D.12683 == 4) goto <D.12684>; else goto <D.11607>;
  <D.12684>:
  D.12685 = _wapi_thread_cur_apc_pending ();
  if (D.12685 == 0) goto <D.11606>; else goto <D.11607>;
  <D.11607>:
  if (ret == -1) goto <D.12686>; else goto <D.12687>;
  <D.12686>:
  {
    gint errnum;

    D.12682 = __errno_location ();
    errnum = *D.12682;
    errnum.125 = (unsigned int) errnum;
    D.12689 = errno_to_WSA (errnum.125, &__func__);
    errnum = (gint) D.12689;
    WSASetLastError (errnum);
    D.12676 = -1;
    return D.12676;
  }
  <D.12687>:
  D.12676 = ret;
  return D.12676;
}