socket_close (void * handle, void * data)
{
  unsigned int startup_count.0;
  unsigned int in_cleanup.1;
  int handle.2;
  int * D.11795;
  int D.11796;
  int D.11798;
  unsigned int errnum.3;
  unsigned int D.11802;
  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.11788>; else goto <D.11789>;
  <D.11788>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.11791>; else goto <D.11792>;
  <D.11791>:
  WSASetLastError (10093);
  return;
  <D.11792>:
  <D.11789>:
  handle.2 = (int) handle;
  shutdown (handle.2, 0);
  <D.11387>:
  handle.2 = (int) handle;
  ret = close (handle.2);
  if (ret == -1) goto <D.11794>; else goto <D.11388>;
  <D.11794>:
  D.11795 = __errno_location ();
  D.11796 = *D.11795;
  if (D.11796 == 4) goto <D.11797>; else goto <D.11388>;
  <D.11797>:
  D.11798 = _wapi_thread_cur_apc_pending ();
  if (D.11798 == 0) goto <D.11387>; else goto <D.11388>;
  <D.11388>:
  if (ret == -1) goto <D.11799>; else goto <D.11800>;
  <D.11799>:
  {
    gint errnum;

    D.11795 = __errno_location ();
    errnum = *D.11795;
    errnum.3 = (unsigned int) errnum;
    D.11802 = errno_to_WSA (errnum.3, &__func__);
    errnum = (gint) D.11802;
    in_cleanup.1 = in_cleanup;
    if (in_cleanup.1 == 0) goto <D.11803>; else goto <D.11804>;
    <D.11803>:
    WSASetLastError (errnum);
    <D.11804>:
  }
  <D.11800>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.11805>; else goto <D.11806>;
  <D.11805>:
  socket_handle->saved_error = 0;
  <D.11806>:
}


WSAStartup (guint32 requested, struct WapiWSAData * data)
{
  int D.11810;
  unsigned int startup_count.4;
  unsigned int startup_count.5;
  short unsigned int D.11815;
  unsigned int D.11816;
  unsigned int D.11817;
  short unsigned int D.11818;
  char[257] * D.11819;
  char[129] * D.11820;

  if (data == 0B) goto <D.11808>; else goto <D.11809>;
  <D.11808>:
  D.11810 = 10014;
  return D.11810;
  <D.11809>:
  if (requested <= 1) goto <D.11811>; else goto <D.11812>;
  <D.11811>:
  D.11810 = 10092;
  return D.11810;
  <D.11812>:
  startup_count.4 = startup_count;
  startup_count.5 = startup_count.4 + 1;
  startup_count = startup_count.5;
  data->wHighVersion = 514;
  D.11815 = data->wHighVersion;
  D.11816 = (unsigned int) D.11815;
  D.11817 = MIN_EXPR <D.11816, requested>;
  D.11818 = (short unsigned int) D.11817;
  data->wVersion = D.11818;
  D.11819 = &data->szDescription;
  strncpy (D.11819, "WAPI", 256);
  D.11820 = &data->szSystemStatus;
  strncpy (D.11820, "groovy", 128);
  D.11810 = 0;
  return D.11810;
}


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

  D.11823 = __builtin_object_size (__dest, 1);
  D.11822 = __builtin___strncpy_chk (__dest, __src, __len, D.11823);
  return D.11822;
}


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

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


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

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


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

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


WSAGetLastError ()
{
  int D.11834;
  unsigned int D.11835;

  D.11835 = GetLastError ();
  D.11834 = (int) D.11835;
  return D.11834;
}


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

  handle = (void *) fd;
  D.11837 = _wapi_handle_type (handle);
  if (D.11837 != 7) goto <D.11838>; else goto <D.11839>;
  <D.11838>:
  WSASetLastError (10038);
  D.11840 = 0;
  return D.11840;
  <D.11839>:
  _wapi_handle_unref (handle);
  D.11840 = 0;
  return D.11840;
}


_wapi_handle_type (void * handle)
{
  unsigned int D.11845;
  struct _WapiHandleUnshared * D.11846;
  WapiHandleType D.11847;
  unsigned int D.11848;
  unsigned int D.11849;
  struct _WapiHandleUnshared * D.11850;
  guint32 idx;

  idx = (guint32) handle;
  if (idx > 4194303) goto <D.11842>; else goto <D.11844>;
  <D.11844>:
  D.11845 = idx / 256;
  D.11846 = _wapi_private_handles[D.11845];
  if (D.11846 == 0B) goto <D.11842>; else goto <D.11843>;
  <D.11842>:
  D.11847 = 0;
  return D.11847;
  <D.11843>:
  D.11845 = idx / 256;
  D.11846 = _wapi_private_handles[D.11845];
  D.11848 = idx & 255;
  D.11849 = D.11848 * 136;
  D.11850 = D.11846 + D.11849;
  D.11847 = D.11850->type;
  return D.11847;
}


_wapi_accept (guint32 fd, struct sockaddr * addr, socklen_t * addrlen)
{
  unsigned int startup_count.9;
  guint32 D.11855;
  unsigned int D.11858;
  <unnamed type> D.11861;
  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.11866;
  int fd.10;
  int * D.11869;
  int D.11870;
  int D.11872;
  unsigned int errnum.11;
  unsigned int D.11876;
  unsigned int new_fd.12;
  unsigned int _wapi_fd_reserve.13;
  struct _WapiHandle_socket * socket_handle.14;
  int D.11882;
  int D.11883;
  int D.11884;
  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.11853>; else goto <D.11854>;
      <D.11853>:
      WSASetLastError (10093);
      D.11855 = 4294967295;
      return D.11855;
      <D.11854>:
      if (addr != 0B) goto <D.11856>; else goto <D.11857>;
      <D.11856>:
      D.11858 = *addrlen;
      if (D.11858 <= 15) goto <D.11859>; else goto <D.11860>;
      <D.11859>:
      WSASetLastError (10014);
      D.11855 = 4294967295;
      return D.11855;
      <D.11860>:
      <D.11857>:
      D.11861 = _wapi_handle_type (handle);
      if (D.11861 != 7) goto <D.11862>; else goto <D.11863>;
      <D.11862>:
      WSASetLastError (10038);
      D.11855 = 4294967295;
      return D.11855;
      <D.11863>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.11864>; else goto <D.11865>;
      <D.11864>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.11855 = 4294967295;
      return D.11855;
      <D.11865>:
      <D.11424>:
      D.11866.__sockaddr__ = addr;
      fd.10 = (int) fd;
      new_fd = accept (fd.10, D.11866, addrlen);
      if (new_fd == -1) goto <D.11868>; else goto <D.11425>;
      <D.11868>:
      D.11869 = __errno_location ();
      D.11870 = *D.11869;
      if (D.11870 == 4) goto <D.11871>; else goto <D.11425>;
      <D.11871>:
      D.11872 = _wapi_thread_cur_apc_pending ();
      if (D.11872 == 0) goto <D.11424>; else goto <D.11425>;
      <D.11425>:
      if (new_fd == -1) goto <D.11873>; else goto <D.11874>;
      <D.11873>:
      {
        gint errnum;

        D.11869 = __errno_location ();
        errnum = *D.11869;
        errnum.11 = (unsigned int) errnum;
        D.11876 = errno_to_WSA (errnum.11, &__func__);
        errnum = (gint) D.11876;
        WSASetLastError (errnum);
        D.11855 = 4294967295;
        return D.11855;
      }
      <D.11874>:
      new_fd.12 = (unsigned int) new_fd;
      _wapi_fd_reserve.13 = _wapi_fd_reserve;
      if (new_fd.12 >= _wapi_fd_reserve.13) goto <D.11879>; else goto <D.11880>;
      <D.11879>:
      WSASetLastError (10107);
      close (new_fd);
      D.11855 = 4294967295;
      return D.11855;
      <D.11880>:
      socket_handle.14 = socket_handle;
      D.11882 = socket_handle.14->domain;
      new_socket_handle.domain = D.11882;
      socket_handle.14 = socket_handle;
      D.11883 = socket_handle.14->type;
      new_socket_handle.type = D.11883;
      socket_handle.14 = socket_handle;
      D.11884 = socket_handle.14->protocol;
      new_socket_handle.protocol = D.11884;
      new_socket_handle.still_readable = 1;
      new_handle = _wapi_handle_new_fd (7, new_fd, &new_socket_handle);
      if (new_handle == 4294967295B) goto <D.11885>; else goto <D.11886>;
      <D.11885>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (31);
      D.11855 = 4294967295;
      return D.11855;
      <D.11886>:
      D.11855 = (guint32) new_fd;
      return D.11855;
    }
  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.11892;
  <unnamed type> D.11893;
  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.11896;
  int fd.16;
  int * D.11900;
  unsigned int errnum.17;
  unsigned int D.11902;
  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.11890>; else goto <D.11891>;
  <D.11890>:
  WSASetLastError (10093);
  D.11892 = -1;
  return D.11892;
  <D.11891>:
  D.11893 = _wapi_handle_type (handle);
  if (D.11893 != 7) goto <D.11894>; else goto <D.11895>;
  <D.11894>:
  WSASetLastError (10038);
  D.11892 = -1;
  return D.11892;
  <D.11895>:
  D.11896.__sockaddr__ = my_addr;
  fd.16 = (int) fd;
  ret = bind (fd.16, D.11896, addrlen);
  if (ret == -1) goto <D.11898>; else goto <D.11899>;
  <D.11898>:
  {
    gint errnum;

    D.11900 = __errno_location ();
    errnum = *D.11900;
    errnum.17 = (unsigned int) errnum;
    D.11902 = errno_to_WSA (errnum.17, &__func__);
    errnum = (gint) D.11902;
    WSASetLastError (errnum);
    D.11892 = -1;
    return D.11892;
  }
  <D.11899>:
  D.11892 = ret;
  return D.11892;
}


_wapi_connect (guint32 fd, const struct sockaddr * serv_addr, socklen_t addrlen)
{
  unsigned int startup_count.18;
  int D.11907;
  <unnamed type> D.11908;
  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.11911;
  int fd.19;
  int D.11913;
  int * D.11916;
  int D.11917;
  unsigned int errnum.20;
  unsigned int D.11921;
  _Bool D.11928;
  _Bool D.11929;
  _Bool D.11930;
  struct _WapiHandle_socket * socket_handle.21;
  unsigned int D.11937;
  unsigned int D.11938;
  int D.11939;
  int D.11941;
  int D.11942;
  unsigned int D.11945;
  int so_error.22;
  unsigned int so_error.23;
  unsigned int D.11950;
  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.11905>; else goto <D.11906>;
      <D.11905>:
      WSASetLastError (10093);
      D.11907 = -1;
      return D.11907;
      <D.11906>:
      D.11908 = _wapi_handle_type (handle);
      if (D.11908 != 7) goto <D.11909>; else goto <D.11910>;
      <D.11909>:
      WSASetLastError (10038);
      D.11907 = -1;
      return D.11907;
      <D.11910>:
      D.11911.__sockaddr__ = serv_addr;
      fd.19 = (int) fd;
      D.11913 = connect (fd.19, D.11911, addrlen);
      if (D.11913 == -1) goto <D.11914>; else goto <D.11915>;
      <D.11914>:
      {
        struct mono_pollfd fds;
        int so_error;
        socklen_t len;

        try
          {
            D.11916 = __errno_location ();
            errnum = *D.11916;
            D.11916 = __errno_location ();
            D.11917 = *D.11916;
            if (D.11917 != 4) goto <D.11918>; else goto <D.11919>;
            <D.11918>:
            errnum.20 = (unsigned int) errnum;
            D.11921 = errno_to_WSA (errnum.20, &__func__);
            errnum = (gint) D.11921;
            if (errnum == 10036) goto <D.11922>; else goto <D.11923>;
            <D.11922>:
            errnum = 10035;
            <D.11923>:
            WSASetLastError (errnum);
            if (errnum != 10035) goto <D.11924>; else goto <D.11925>;
            <D.11924>:
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.11926>; else goto <D.11927>;
            <D.11926>:
            D.11928 = errnum != 10054;
            D.11929 = errnum != 10050;
            D.11930 = D.11928 & D.11929;
            if (D.11930 != 0) goto <D.11931>; else goto <D.11932>;
            <D.11931>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p (error %d)", &__func__, handle, errnum);
            <D.11932>:
            goto <D.11933>;
            <D.11927>:
            socket_handle.21 = socket_handle;
            socket_handle.21->saved_error = errnum;
            <D.11933>:
            <D.11925>:
            D.11907 = -1;
            return D.11907;
            <D.11919>:
            fd.19 = (int) fd;
            fds.fd = fd.19;
            fds.events = 4;
            goto <D.11450>;
            <D.11449>:
            D.11916 = __errno_location ();
            D.11917 = *D.11916;
            if (D.11917 != 4) goto <D.11935>; else goto <D.11936>;
            <D.11935>:
            D.11916 = __errno_location ();
            D.11917 = *D.11916;
            D.11937 = (unsigned int) D.11917;
            D.11938 = errno_to_WSA (D.11937, &__func__);
            errnum = (gint) D.11938;
            WSASetLastError (errnum);
            D.11907 = -1;
            return D.11907;
            <D.11936>:
            <D.11450>:
            D.11939 = mono_poll (&fds, 1, -1);
            if (D.11939 == -1) goto <D.11940>; else goto <D.11451>;
            <D.11940>:
            D.11941 = _wapi_thread_cur_apc_pending ();
            if (D.11941 == 0) goto <D.11449>; else goto <D.11451>;
            <D.11451>:
            len = 4;
            fd.19 = (int) fd;
            D.11942 = getsockopt (fd.19, 1, 4, &so_error, &len);
            if (D.11942 == -1) goto <D.11943>; else goto <D.11944>;
            <D.11943>:
            D.11916 = __errno_location ();
            D.11917 = *D.11916;
            D.11937 = (unsigned int) D.11917;
            D.11945 = errno_to_WSA (D.11937, &__func__);
            errnum = (gint) D.11945;
            WSASetLastError (errnum);
            D.11907 = -1;
            return D.11907;
            <D.11944>:
            so_error.22 = so_error;
            if (so_error.22 != 0) goto <D.11947>; else goto <D.11948>;
            <D.11947>:
            so_error.22 = so_error;
            so_error.23 = (unsigned int) so_error.22;
            D.11950 = errno_to_WSA (so_error.23, &__func__);
            errnum = (gint) D.11950;
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.11951>; else goto <D.11952>;
            <D.11951>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
            goto <D.11953>;
            <D.11952>:
            socket_handle.21 = socket_handle;
            socket_handle.21->saved_error = errnum;
            <D.11953>:
            WSASetLastError (errnum);
            D.11907 = -1;
            return D.11907;
            <D.11948>:
          }
        finally
          {
            fds = {CLOBBER};
            so_error = {CLOBBER};
            len = {CLOBBER};
          }
      }
      <D.11915>:
      D.11907 = 0;
      return D.11907;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_getpeername (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  unsigned int startup_count.24;
  int D.11961;
  <unnamed type> D.11962;
  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.11965;
  int fd.25;
  int * D.11969;
  unsigned int errnum.26;
  unsigned int D.11971;
  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.11959>; else goto <D.11960>;
  <D.11959>:
  WSASetLastError (10093);
  D.11961 = -1;
  return D.11961;
  <D.11960>:
  D.11962 = _wapi_handle_type (handle);
  if (D.11962 != 7) goto <D.11963>; else goto <D.11964>;
  <D.11963>:
  WSASetLastError (10038);
  D.11961 = -1;
  return D.11961;
  <D.11964>:
  D.11965.__sockaddr__ = name;
  fd.25 = (int) fd;
  ret = getpeername (fd.25, D.11965, namelen);
  if (ret == -1) goto <D.11967>; else goto <D.11968>;
  <D.11967>:
  {
    gint errnum;

    D.11969 = __errno_location ();
    errnum = *D.11969;
    errnum.26 = (unsigned int) errnum;
    D.11971 = errno_to_WSA (errnum.26, &__func__);
    errnum = (gint) D.11971;
    WSASetLastError (errnum);
    D.11961 = -1;
    return D.11961;
  }
  <D.11968>:
  D.11961 = ret;
  return D.11961;
}


_wapi_getsockname (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  unsigned int startup_count.27;
  int D.11976;
  <unnamed type> D.11977;
  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.11980;
  int fd.28;
  int * D.11984;
  unsigned int errnum.29;
  unsigned int D.11986;
  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.11974>; else goto <D.11975>;
  <D.11974>:
  WSASetLastError (10093);
  D.11976 = -1;
  return D.11976;
  <D.11975>:
  D.11977 = _wapi_handle_type (handle);
  if (D.11977 != 7) goto <D.11978>; else goto <D.11979>;
  <D.11978>:
  WSASetLastError (10038);
  D.11976 = -1;
  return D.11976;
  <D.11979>:
  D.11980.__sockaddr__ = name;
  fd.28 = (int) fd;
  ret = getsockname (fd.28, D.11980, namelen);
  if (ret == -1) goto <D.11982>; else goto <D.11983>;
  <D.11982>:
  {
    gint errnum;

    D.11984 = __errno_location ();
    errnum = *D.11984;
    errnum.29 = (unsigned int) errnum;
    D.11986 = errno_to_WSA (errnum.29, &__func__);
    errnum = (gint) D.11986;
    WSASetLastError (errnum);
    D.11976 = -1;
    return D.11976;
  }
  <D.11983>:
  D.11976 = ret;
  return D.11976;
}


_wapi_getsockopt (guint32 fd, int level, int optname, void * optval, socklen_t * optlen)
{
  unsigned int startup_count.30;
  int D.11991;
  <unnamed type> D.11992;
  unsigned int optname.31;
  unsigned int D.11998;
  int fd.32;
  int * D.12004;
  unsigned int errnum.33;
  unsigned int D.12006;
  long int D.12011;
  long int D.12012;
  long int D.12013;
  long int D.12014;
  long int D.12015;
  int D.12020;
  unsigned int D.12021;
  unsigned int D.12022;
  int D.12023;
  unsigned int D.12027;
  int D.12028;
  struct _WapiHandle_socket * socket_handle.34;
  int D.12031;
  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.11989>; else goto <D.11990>;
      <D.11989>:
      WSASetLastError (10093);
      D.11991 = -1;
      return D.11991;
      <D.11990>:
      D.11992 = _wapi_handle_type (handle);
      if (D.11992 != 7) goto <D.11993>; else goto <D.11994>;
      <D.11993>:
      WSASetLastError (10038);
      D.11991 = -1;
      return D.11991;
      <D.11994>:
      tmp_val = optval;
      if (level == 1) goto <D.11995>; else goto <D.11996>;
      <D.11995>:
      optname.31 = (unsigned int) optname;
      D.11998 = optname.31 + 4294967276;
      if (D.11998 <= 1) goto <D.11999>; else goto <D.12000>;
      <D.11999>:
      tmp_val = &tv;
      *optlen = 8;
      <D.12000>:
      <D.11996>:
      fd.32 = (int) fd;
      ret = getsockopt (fd.32, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.12002>; else goto <D.12003>;
      <D.12002>:
      {
        gint errnum;

        D.12004 = __errno_location ();
        errnum = *D.12004;
        errnum.33 = (unsigned int) errnum;
        D.12006 = errno_to_WSA (errnum.33, &__func__);
        errnum = (gint) D.12006;
        WSASetLastError (errnum);
        D.11991 = -1;
        return D.11991;
      }
      <D.12003>:
      if (level == 1) goto <D.12007>; else goto <D.12008>;
      <D.12007>:
      optname.31 = (unsigned int) optname;
      D.11998 = optname.31 + 4294967276;
      if (D.11998 <= 1) goto <D.12009>; else goto <D.12010>;
      <D.12009>:
      D.12011 = tv.tv_sec;
      D.12012 = D.12011 * 1000;
      D.12013 = tv.tv_usec;
      D.12014 = D.12013 / 1000;
      D.12015 = D.12012 + D.12014;
      MEM[(int *)optval] = D.12015;
      *optlen = 4;
      <D.12010>:
      <D.12008>:
      if (optname == 4) goto <D.12016>; else goto <D.12017>;
      <D.12016>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12018>; else goto <D.12019>;
      <D.12018>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      D.12020 = MEM[(int *)optval];
      D.12021 = (unsigned int) D.12020;
      D.12022 = errno_to_WSA (D.12021, &__func__);
      D.12023 = (int) D.12022;
      MEM[(int *)optval] = D.12023;
      goto <D.12024>;
      <D.12019>:
      D.12020 = MEM[(int *)optval];
      if (D.12020 != 0) goto <D.12025>; else goto <D.12026>;
      <D.12025>:
      D.12020 = MEM[(int *)optval];
      D.12021 = (unsigned int) D.12020;
      D.12027 = errno_to_WSA (D.12021, &__func__);
      D.12028 = (int) D.12027;
      MEM[(int *)optval] = D.12028;
      socket_handle.34 = socket_handle;
      D.12020 = MEM[(int *)optval];
      socket_handle.34->saved_error = D.12020;
      goto <D.12030>;
      <D.12026>:
      socket_handle.34 = socket_handle;
      D.12031 = socket_handle.34->saved_error;
      MEM[(int *)optval] = D.12031;
      <D.12030>:
      <D.12024>:
      <D.12017>:
      D.11991 = ret;
      return D.11991;
    }
  finally
    {
      tv = {CLOBBER};
      socket_handle = {CLOBBER};
    }
}


_wapi_listen (guint32 fd, int backlog)
{
  unsigned int startup_count.35;
  int D.12037;
  <unnamed type> D.12038;
  int fd.36;
  int * D.12044;
  unsigned int errnum.37;
  unsigned int D.12046;
  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.12035>; else goto <D.12036>;
  <D.12035>:
  WSASetLastError (10093);
  D.12037 = -1;
  return D.12037;
  <D.12036>:
  D.12038 = _wapi_handle_type (handle);
  if (D.12038 != 7) goto <D.12039>; else goto <D.12040>;
  <D.12039>:
  WSASetLastError (10038);
  D.12037 = -1;
  return D.12037;
  <D.12040>:
  fd.36 = (int) fd;
  ret = listen (fd.36, backlog);
  if (ret == -1) goto <D.12042>; else goto <D.12043>;
  <D.12042>:
  {
    gint errnum;

    D.12044 = __errno_location ();
    errnum = *D.12044;
    errnum.37 = (unsigned int) errnum;
    D.12046 = errno_to_WSA (errnum.37, &__func__);
    errnum = (gint) D.12046;
    WSASetLastError (errnum);
    D.12037 = -1;
    return D.12037;
  }
  <D.12043>:
  D.12037 = 0;
  return D.12037;
}


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

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


_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.12053;
  <unnamed type> D.12054;
  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.12057;
  int fd.39;
  int * D.12060;
  int D.12061;
  int D.12063;
  _Bool D.12064;
  _Bool D.12065;
  _Bool D.12066;
  struct _WapiHandle_socket * socket_handle.40;
  int D.12073;
  unsigned int errnum.41;
  unsigned int D.12077;
  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.12051>; else goto <D.12052>;
      <D.12051>:
      WSASetLastError (10093);
      D.12053 = -1;
      return D.12053;
      <D.12052>:
      D.12054 = _wapi_handle_type (handle);
      if (D.12054 != 7) goto <D.12055>; else goto <D.12056>;
      <D.12055>:
      WSASetLastError (10038);
      D.12053 = -1;
      return D.12053;
      <D.12056>:
      <D.11511>:
      D.12057.__sockaddr__ = from;
      fd.39 = (int) fd;
      ret = recvfrom (fd.39, buf, len, recv_flags, D.12057, fromlen);
      if (ret == -1) goto <D.12059>; else goto <D.11512>;
      <D.12059>:
      D.12060 = __errno_location ();
      D.12061 = *D.12060;
      if (D.12061 == 4) goto <D.12062>; else goto <D.11512>;
      <D.12062>:
      D.12063 = _wapi_thread_cur_apc_pending ();
      if (D.12063 == 0) goto <D.11511>; else goto <D.11512>;
      <D.11512>:
      D.12064 = ret == 0;
      D.12065 = len != 0;
      D.12066 = D.12064 & D.12065;
      if (D.12066 != 0) goto <D.12067>; else goto <D.12068>;
      <D.12067>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12069>; else goto <D.12071>;
      <D.12071>:
      socket_handle.40 = socket_handle;
      D.12073 = socket_handle.40->still_readable;
      if (D.12073 != 1) goto <D.12069>; else goto <D.12070>;
      <D.12069>:
      ret = -1;
      D.12060 = __errno_location ();
      *D.12060 = 4;
      <D.12070>:
      <D.12068>:
      if (ret == -1) goto <D.12074>; else goto <D.12075>;
      <D.12074>:
      {
        gint errnum;

        D.12060 = __errno_location ();
        errnum = *D.12060;
        errnum.41 = (unsigned int) errnum;
        D.12077 = errno_to_WSA (errnum.41, &__func__);
        errnum = (gint) D.12077;
        WSASetLastError (errnum);
        D.12053 = -1;
        return D.12053;
      }
      <D.12075>:
      D.12053 = ret;
      return D.12053;
    }
  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.12080;
  int D.12083;
  ssize_t D.12086;
  unsigned int D.12087;
  unsigned int D.12088;
  unsigned int D.12091;

  D.12080 = __builtin_object_size (__buf, 0);
  if (D.12080 != 4294967295) goto <D.12081>; else goto <D.12082>;
  <D.12081>:
  D.12083 = __builtin_constant_p (__n);
  if (D.12083 == 0) goto <D.12084>; else goto <D.12085>;
  <D.12084>:
  D.12087 = __builtin_object_size (__buf, 0);
  D.12086 = __recvfrom_chk (__fd, __buf, __n, D.12087, __flags, __addr, __addr_len);
  return D.12086;
  <D.12085>:
  D.12088 = __builtin_object_size (__buf, 0);
  if (D.12088 < __n) goto <D.12089>; else goto <D.12090>;
  <D.12089>:
  D.12091 = __builtin_object_size (__buf, 0);
  D.12086 = __recvfrom_chk_warn (__fd, __buf, __n, D.12091, __flags, __addr, __addr_len);
  return D.12086;
  <D.12090>:
  <D.12082>:
  D.12086 = __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
  return D.12086;
}


_wapi_send (guint32 fd, const void * msg, size_t len, int send_flags)
{
  unsigned int startup_count.42;
  int D.12096;
  <unnamed type> D.12097;
  int fd.43;
  int * D.12102;
  int D.12103;
  int D.12105;
  int D.12112;
  unsigned int errnum.44;
  unsigned int D.12116;
  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.12094>; else goto <D.12095>;
  <D.12094>:
  WSASetLastError (10093);
  D.12096 = -1;
  return D.12096;
  <D.12095>:
  D.12097 = _wapi_handle_type (handle);
  if (D.12097 != 7) goto <D.12098>; else goto <D.12099>;
  <D.12098>:
  WSASetLastError (10038);
  D.12096 = -1;
  return D.12096;
  <D.12099>:
  <D.11536>:
  fd.43 = (int) fd;
  ret = send (fd.43, msg, len, send_flags);
  if (ret == -1) goto <D.12101>; else goto <D.11537>;
  <D.12101>:
  D.12102 = __errno_location ();
  D.12103 = *D.12102;
  if (D.12103 == 4) goto <D.12104>; else goto <D.11537>;
  <D.12104>:
  D.12105 = _wapi_thread_cur_apc_pending ();
  if (D.12105 == 0) goto <D.11536>; else goto <D.11537>;
  <D.11537>:
  if (ret == -1) goto <D.12106>; else goto <D.12107>;
  <D.12106>:
  {
    gint errnum;

    D.12102 = __errno_location ();
    errnum = *D.12102;
    if (errnum == 11) goto <D.12108>; else goto <D.12109>;
    <D.12108>:
    fd.43 = (int) fd;
    ret = fcntl (fd.43, 3, 0);
    if (ret != -1) goto <D.12110>; else goto <D.12111>;
    <D.12110>:
    D.12112 = ret & 2048;
    if (D.12112 == 0) goto <D.12113>; else goto <D.12114>;
    <D.12113>:
    errnum = 110;
    <D.12114>:
    <D.12111>:
    <D.12109>:
    errnum.44 = (unsigned int) errnum;
    D.12116 = errno_to_WSA (errnum.44, &__func__);
    errnum = (gint) D.12116;
    WSASetLastError (errnum);
    D.12096 = -1;
    return D.12096;
  }
  <D.12107>:
  D.12096 = ret;
  return D.12096;
}


_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.12121;
  <unnamed type> D.12122;
  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.12125;
  int fd.46;
  int * D.12128;
  int D.12129;
  int D.12131;
  unsigned int errnum.47;
  unsigned int D.12135;
  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.12119>; else goto <D.12120>;
  <D.12119>:
  WSASetLastError (10093);
  D.12121 = -1;
  return D.12121;
  <D.12120>:
  D.12122 = _wapi_handle_type (handle);
  if (D.12122 != 7) goto <D.12123>; else goto <D.12124>;
  <D.12123>:
  WSASetLastError (10038);
  D.12121 = -1;
  return D.12121;
  <D.12124>:
  <D.11550>:
  D.12125.__sockaddr__ = to;
  fd.46 = (int) fd;
  ret = sendto (fd.46, msg, len, send_flags, D.12125, tolen);
  if (ret == -1) goto <D.12127>; else goto <D.11551>;
  <D.12127>:
  D.12128 = __errno_location ();
  D.12129 = *D.12128;
  if (D.12129 == 4) goto <D.12130>; else goto <D.11551>;
  <D.12130>:
  D.12131 = _wapi_thread_cur_apc_pending ();
  if (D.12131 == 0) goto <D.11550>; else goto <D.11551>;
  <D.11551>:
  if (ret == -1) goto <D.12132>; else goto <D.12133>;
  <D.12132>:
  {
    gint errnum;

    D.12128 = __errno_location ();
    errnum = *D.12128;
    errnum.47 = (unsigned int) errnum;
    D.12135 = errno_to_WSA (errnum.47, &__func__);
    errnum = (gint) D.12135;
    WSASetLastError (errnum);
    D.12121 = -1;
    return D.12121;
  }
  <D.12133>:
  D.12121 = ret;
  return D.12121;
}


_wapi_setsockopt (guint32 fd, int level, int optname, const void * optval, socklen_t optlen)
{
  unsigned int startup_count.48;
  int D.12140;
  <unnamed type> D.12141;
  unsigned int optname.49;
  unsigned int D.12148;
  int D.12150;
  int D.12151;
  int D.12152;
  unsigned int D.12155;
  int bufsize.50;
  int bufsize.51;
  int bufsize.52;
  int fd.53;
  int * D.12164;
  unsigned int errnum.54;
  unsigned int D.12166;
  _Bool D.12167;
  _Bool D.12168;
  _Bool D.12169;
  int D.12172;
  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.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>:
      tmp_val = optval;
      if (level == 1) goto <D.12146>; else goto <D.12144>;
      <D.12146>:
      optname.49 = (unsigned int) optname;
      D.12148 = optname.49 + 4294967276;
      if (D.12148 <= 1) goto <D.12149>; else goto <D.12144>;
      <D.12149>:
      {
        int ms;

        ms = MEM[(int *)optval];
        D.12150 = ms / 1000;
        tv.tv_sec = D.12150;
        D.12151 = ms % 1000;
        D.12152 = D.12151 * 1000;
        tv.tv_usec = D.12152;
        tmp_val = &tv;
        optlen = 8;
      }
      goto <D.12145>;
      <D.12144>:
      if (level == 1) goto <D.12153>; else goto <D.12154>;
      <D.12153>:
      optname.49 = (unsigned int) optname;
      D.12155 = optname.49 + 4294967289;
      if (D.12155 <= 1) goto <D.12156>; else goto <D.12157>;
      <D.12156>:
      bufsize.50 = MEM[(int *)optval];
      bufsize = bufsize.50;
      bufsize.51 = bufsize;
      bufsize.52 = bufsize.51 / 2;
      bufsize = bufsize.52;
      tmp_val = &bufsize;
      <D.12157>:
      <D.12154>:
      <D.12145>:
      fd.53 = (int) fd;
      ret = setsockopt (fd.53, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.12162>; else goto <D.12163>;
      <D.12162>:
      {
        gint errnum;

        D.12164 = __errno_location ();
        errnum = *D.12164;
        errnum.54 = (unsigned int) errnum;
        D.12166 = errno_to_WSA (errnum.54, &__func__);
        errnum = (gint) D.12166;
        WSASetLastError (errnum);
        D.12140 = -1;
        return D.12140;
      }
      <D.12163>:
      D.12167 = level == 1;
      D.12168 = optname == 2;
      D.12169 = D.12167 & D.12168;
      if (D.12169 != 0) goto <D.12170>; else goto <D.12171>;
      <D.12170>:
      {
        int type;
        socklen_t type_len;

        try
          {
            type_len = 4;
            fd.53 = (int) fd;
            D.12172 = getsockopt (fd.53, level, 3, &type, &type_len);
            if (D.12172 == 0) goto <D.12173>; else goto <D.12174>;
            <D.12173>:
            type.55 = type;
            if (type.55 == 2) goto <D.12176>; else goto <D.12177>;
            <D.12176>:
            fd.53 = (int) fd;
            setsockopt (fd.53, level, 15, tmp_val, optlen);
            <D.12177>:
            <D.12174>:
          }
        finally
          {
            type = {CLOBBER};
            type_len = {CLOBBER};
          }
      }
      <D.12171>:
      D.12140 = ret;
      return D.12140;
    }
  finally
    {
      bufsize = {CLOBBER};
      tv = {CLOBBER};
    }
}


_wapi_shutdown (guint32 fd, int how)
{
  unsigned int startup_count.56;
  int D.12183;
  <unnamed type> D.12184;
  _Bool D.12187;
  _Bool D.12188;
  _Bool D.12189;
  struct _WapiHandle_socket * socket_handle.57;
  int fd.58;
  int * D.12198;
  unsigned int errnum.59;
  unsigned int D.12200;
  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.12181>; else goto <D.12182>;
      <D.12181>:
      WSASetLastError (10093);
      D.12183 = -1;
      return D.12183;
      <D.12182>:
      D.12184 = _wapi_handle_type (handle);
      if (D.12184 != 7) goto <D.12185>; else goto <D.12186>;
      <D.12185>:
      WSASetLastError (10038);
      D.12183 = -1;
      return D.12183;
      <D.12186>:
      D.12187 = how == 0;
      D.12188 = how == 2;
      D.12189 = D.12187 | D.12188;
      if (D.12189 != 0) goto <D.12190>; else goto <D.12191>;
      <D.12190>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12192>; else goto <D.12193>;
      <D.12192>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12183 = -1;
      return D.12183;
      <D.12193>:
      socket_handle.57 = socket_handle;
      socket_handle.57->still_readable = 0;
      <D.12191>:
      fd.58 = (int) fd;
      ret = shutdown (fd.58, how);
      if (ret == -1) goto <D.12196>; else goto <D.12197>;
      <D.12196>:
      {
        gint errnum;

        D.12198 = __errno_location ();
        errnum = *D.12198;
        errnum.59 = (unsigned int) errnum;
        D.12200 = errno_to_WSA (errnum.59, &__func__);
        errnum = (gint) D.12200;
        WSASetLastError (errnum);
        D.12183 = -1;
        return D.12183;
      }
      <D.12197>:
      D.12183 = ret;
      return D.12183;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_socket (int domain, int type, int protocol, void * unused, guint32 unused2, guint32 unused3)
{
  _Bool D.12203;
  _Bool D.12204;
  _Bool D.12205;
  _Bool D.12208;
  _Bool D.12209;
  _Bool D.12210;
  int * D.12215;
  unsigned int errnum.60;
  unsigned int D.12217;
  guint32 D.12218;
  unsigned int fd.61;
  unsigned int _wapi_fd_reserve.62;
  unsigned int errnum.63;
  unsigned int D.12226;
  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.12203 = fd == -1;
      D.12204 = domain == 2;
      D.12205 = D.12203 & D.12204;
      if (D.12205 != 0) goto <D.12206>; else goto <D.12207>;
      <D.12206>:
      D.12208 = type == 3;
      D.12209 = protocol == 0;
      D.12210 = D.12208 & D.12209;
      if (D.12210 != 0) goto <D.12211>; else goto <D.12212>;
      <D.12211>:
      socket_handle.protocol = 4;
      fd = socket (2, 3, 4);
      <D.12212>:
      <D.12207>:
      if (fd == -1) goto <D.12213>; else goto <D.12214>;
      <D.12213>:
      {
        gint errnum;

        D.12215 = __errno_location ();
        errnum = *D.12215;
        errnum.60 = (unsigned int) errnum;
        D.12217 = errno_to_WSA (errnum.60, &__func__);
        errnum = (gint) D.12217;
        WSASetLastError (errnum);
        D.12218 = 4294967295;
        return D.12218;
      }
      <D.12214>:
      fd.61 = (unsigned int) fd;
      _wapi_fd_reserve.62 = _wapi_fd_reserve;
      if (fd.61 >= _wapi_fd_reserve.62) goto <D.12221>; else goto <D.12222>;
      <D.12221>:
      WSASetLastError (10107);
      close (fd);
      D.12218 = 4294967295;
      return D.12218;
      <D.12222>:
      {
        int ret;
        int true;

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

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


socket_ops_init ()
{

}


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

  startup_count.64 = startup_count;
  if (startup_count.64 == 0) goto <D.12234>; else goto <D.12235>;
  <D.12234>:
  WSASetLastError (10093);
  D.12236 = 0B;
  return D.12236;
  <D.12235>:
  he = gethostbyname (hostname);
  if (he == 0B) goto <D.12237>; else goto <D.12238>;
  <D.12237>:
  D.12239 = __h_errno_location ();
  D.12240 = *D.12239;
  switch (D.12240) <default: <D.11617>, case 1: <D.11612>, case 2: <D.11616>, case 3: <D.11615>, case 4: <D.11614>>
  <D.11612>:
  WSASetLastError (11001);
  goto <D.11613>;
  <D.11614>:
  WSASetLastError (11004);
  goto <D.11613>;
  <D.11615>:
  WSASetLastError (11003);
  goto <D.11613>;
  <D.11616>:
  WSASetLastError (11002);
  goto <D.11613>;
  <D.11617>:
  D.12239 = __h_errno_location ();
  D.12240 = *D.12239;
  monoeg_g_log (0B, 16, "%s: Need to translate %d into winsock error", &__func__, D.12240);
  goto <D.11613>;
  <D.11613>:
  <D.12238>:
  D.12236 = he;
  return D.12236;
}


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.12245;
  <unnamed type> D.12246;
  void * D.12251;
  unsigned int D.12254;
  void * D.12263;
  unsigned int D.12266;
  unsigned int D.12271;
  void * sock;
  gint ret;

  sock = (void *) socket;
  startup_count.65 = startup_count;
  if (startup_count.65 == 0) goto <D.12243>; else goto <D.12244>;
  <D.12243>:
  WSASetLastError (10093);
  D.12245 = 0;
  return D.12245;
  <D.12244>:
  D.12246 = _wapi_handle_type (sock);
  if (D.12246 != 7) goto <D.12247>; else goto <D.12248>;
  <D.12247>:
  WSASetLastError (10038);
  D.12245 = 0;
  return D.12245;
  <D.12248>:
  if (buffers != 0B) goto <D.12249>; else goto <D.12250>;
  <D.12249>:
  D.12251 = buffers->Head;
  if (D.12251 != 0B) goto <D.12252>; else goto <D.12253>;
  <D.12252>:
  D.12254 = buffers->HeadLength;
  if (D.12254 != 0) goto <D.12255>; else goto <D.12256>;
  <D.12255>:
  D.12254 = buffers->HeadLength;
  D.12251 = buffers->Head;
  ret = _wapi_send (socket, D.12251, D.12254, 0);
  if (ret == -1) goto <D.12257>; else goto <D.12258>;
  <D.12257>:
  D.12245 = 0;
  return D.12245;
  <D.12258>:
  <D.12256>:
  <D.12253>:
  <D.12250>:
  ret = wapi_sendfile (socket, file, bytes_to_write, bytes_per_send, flags);
  if (ret == -1) goto <D.12259>; else goto <D.12260>;
  <D.12259>:
  D.12245 = 0;
  return D.12245;
  <D.12260>:
  if (buffers != 0B) goto <D.12261>; else goto <D.12262>;
  <D.12261>:
  D.12263 = buffers->Tail;
  if (D.12263 != 0B) goto <D.12264>; else goto <D.12265>;
  <D.12264>:
  D.12266 = buffers->TailLength;
  if (D.12266 != 0) goto <D.12267>; else goto <D.12268>;
  <D.12267>:
  D.12266 = buffers->TailLength;
  D.12263 = buffers->Tail;
  ret = _wapi_send (socket, D.12263, D.12266, 0);
  if (ret == -1) goto <D.12269>; else goto <D.12270>;
  <D.12269>:
  D.12245 = 0;
  return D.12245;
  <D.12270>:
  <D.12268>:
  <D.12265>:
  <D.12262>:
  D.12271 = flags & 1;
  if (D.12271 != 0) goto <D.12272>; else goto <D.12273>;
  <D.12272>:
  closesocket (socket);
  <D.12273>:
  D.12245 = 1;
  return D.12245;
}


wapi_sendfile (guint32 socket, void * fd, guint32 bytes_to_write, guint32 bytes_per_send, guint32 flags)
{
  int * D.12277;
  unsigned int errnum.66;
  unsigned int D.12279;
  gint D.12280;
  long long int D.12281;
  unsigned int D.12282;
  int socket.67;
  int D.12285;
  _Bool D.12286;
  _Bool D.12287;
  _Bool D.12288;
  int D.12290;
  unsigned int D.12293;
  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.12275>; else goto <D.12276>;
      <D.12275>:
      D.12277 = __errno_location ();
      errnum = *D.12277;
      errnum.66 = (unsigned int) errnum;
      D.12279 = errno_to_WSA (errnum.66, &__func__);
      errnum = (gint) D.12279;
      WSASetLastError (errnum);
      D.12280 = -1;
      return D.12280;
      <D.12276>:
      <D.11651>:
      D.12281 = statbuf.st_size;
      D.12282 = (unsigned int) D.12281;
      socket.67 = (int) socket;
      res = sendfile (socket.67, file, 0B, D.12282);
      if (res != -1) goto <D.12284>; else goto <D.11652>;
      <D.12284>:
      D.12277 = __errno_location ();
      D.12285 = *D.12277;
      D.12286 = D.12285 == 4;
      D.12287 = D.12285 == 11;
      D.12288 = D.12286 | D.12287;
      if (D.12288 != 0) goto <D.12289>; else goto <D.11652>;
      <D.12289>:
      D.12290 = _wapi_thread_cur_apc_pending ();
      if (D.12290 == 0) goto <D.11651>; else goto <D.11652>;
      <D.11652>:
      if (res == -1) goto <D.12291>; else goto <D.12292>;
      <D.12291>:
      D.12277 = __errno_location ();
      errnum = *D.12277;
      errnum.66 = (unsigned int) errnum;
      D.12293 = errno_to_WSA (errnum.66, &__func__);
      errnum = (gint) D.12293;
      WSASetLastError (errnum);
      D.12280 = -1;
      return D.12280;
      <D.12292>:
      D.12280 = 0;
      return D.12280;
    }
  finally
    {
      statbuf = {CLOBBER};
    }
}


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

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


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.12301;
  <unnamed type> D.12302;
  unsigned int i_len.69;
  unsigned int o_len.70;
  struct WapiGuid * D.12315;
  int D.12316;
  void * * D.12319;
  void * D.12320;
  gchar * D.12325;
  gchar * D.12326;
  int fd.71;
  int * D.12330;
  unsigned int errnum.72;
  unsigned int D.12332;
  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.12353;
  unsigned int i_len.81;
  long unsigned int command.82;
  unsigned int errnum.83;
  unsigned int D.12361;
  _Bool D.12365;
  _Bool D.12366;
  _Bool D.12367;
  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.12299>; else goto <D.12300>;
  <D.12299>:
  WSASetLastError (10093);
  D.12301 = -1;
  return D.12301;
  <D.12300>:
  D.12302 = _wapi_handle_type (handle);
  if (D.12302 != 7) goto <D.12303>; else goto <D.12304>;
  <D.12303>:
  WSASetLastError (10038);
  D.12301 = -1;
  return D.12301;
  <D.12304>:
  if (command == -939524090) goto <D.12305>; else goto <D.12306>;
  <D.12305>:
  {
    int i;
    struct WapiGuid * guid;

    i = 0;
    guid = input;
    i_len.69 = (unsigned int) i_len;
    if (i_len.69 <= 15) goto <D.12308>; else goto <D.12309>;
    <D.12308>:
    WSASetLastError (10022);
    D.12301 = -1;
    return D.12301;
    <D.12309>:
    o_len.70 = (unsigned int) o_len;
    if (o_len.70 <= 3) goto <D.12311>; else goto <D.12312>;
    <D.12311>:
    WSASetLastError (10022);
    D.12301 = -1;
    return D.12301;
    <D.12312>:
    if (output == 0B) goto <D.12313>; else goto <D.12314>;
    <D.12313>:
    WSASetLastError (10022);
    D.12301 = -1;
    return D.12301;
    <D.12314>:
    goto <D.11685>;
    <D.11684>:
    D.12315 = &extension_functions[i].guid;
    D.12316 = memcmp (guid, D.12315, 16);
    if (D.12316 == 0) goto <D.12317>; else goto <D.12318>;
    <D.12317>:
    D.12319 = &extension_functions[i].func;
    memcpy (output, D.12319, 4);
    *written = 4;
    D.12301 = 0;
    return D.12301;
    <D.12318>:
    i = i + 1;
    <D.11685>:
    D.12320 = extension_functions[i].func;
    if (D.12320 != 0B) goto <D.11684>; else goto <D.11686>;
    <D.11686>:
    WSASetLastError (10022);
    D.12301 = -1;
    return D.12301;
  }
  <D.12306>:
  if (command == -1744830460) goto <D.12321>; else goto <D.12322>;
  <D.12321>:
  {
    uint32_t onoff;
    uint32_t keepalivetime;
    uint32_t keepaliveinterval;

    try
      {
        i_len.69 = (unsigned int) i_len;
        if (i_len.69 <= 11) goto <D.12323>; else goto <D.12324>;
        <D.12323>:
        WSASetLastError (10022);
        D.12301 = -1;
        return D.12301;
        <D.12324>:
        memcpy (&onoff, input, 4);
        D.12325 = input + 4;
        memcpy (&keepalivetime, D.12325, 4);
        D.12326 = input + 8;
        memcpy (&keepaliveinterval, D.12326, 4);
        fd.71 = (int) fd;
        ret = setsockopt (fd.71, 1, 9, &onoff, 4);
        if (ret < 0) goto <D.12328>; else goto <D.12329>;
        <D.12328>:
        {
          gint errnum;

          D.12330 = __errno_location ();
          errnum = *D.12330;
          errnum.72 = (unsigned int) errnum;
          D.12332 = errno_to_WSA (errnum.72, &__func__);
          errnum = (gint) D.12332;
          WSASetLastError (errnum);
          D.12301 = -1;
          return D.12301;
        }
        <D.12329>:
        onoff.73 = onoff;
        if (onoff.73 != 0) goto <D.12334>; else goto <D.12335>;
        <D.12334>:
        {
          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.12338>; else goto <D.12340>;
          <D.12340>:
          if (rem > 499) goto <D.12338>; else goto <D.12339>;
          <D.12338>:
          keepalivetime.74 = keepalivetime;
          keepalivetime.76 = keepalivetime.74 + 1;
          keepalivetime = keepalivetime.76;
          <D.12339>:
          fd.71 = (int) fd;
          ret = setsockopt (fd.71, 6, 4, &keepalivetime, 4);
          if (ret == 0) goto <D.12342>; else goto <D.12343>;
          <D.12342>:
          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.12346>; else goto <D.12348>;
          <D.12348>:
          if (rem > 499) goto <D.12346>; else goto <D.12347>;
          <D.12346>:
          keepaliveinterval.77 = keepaliveinterval;
          keepaliveinterval.79 = keepaliveinterval.77 + 1;
          keepaliveinterval = keepaliveinterval.79;
          <D.12347>:
          fd.71 = (int) fd;
          ret = setsockopt (fd.71, 6, 5, &keepaliveinterval, 4);
          <D.12343>:
          if (ret != 0) goto <D.12350>; else goto <D.12351>;
          <D.12350>:
          {
            gint errnum;

            D.12330 = __errno_location ();
            errnum = *D.12330;
            errnum.80 = (unsigned int) errnum;
            D.12353 = errno_to_WSA (errnum.80, &__func__);
            errnum = (gint) D.12353;
            WSASetLastError (errnum);
            D.12301 = -1;
            return D.12301;
          }
          <D.12351>:
          D.12301 = 0;
          return D.12301;
        }
        <D.12335>:
        D.12301 = 0;
        return D.12301;
      }
    finally
      {
        onoff = {CLOBBER};
        keepalivetime = {CLOBBER};
        keepaliveinterval = {CLOBBER};
      }
  }
  <D.12322>:
  if (i_len > 0) goto <D.12354>; else goto <D.12355>;
  <D.12354>:
  i_len.81 = (unsigned int) i_len;
  buffer = monoeg_g_memdup (input, i_len.81);
  <D.12355>:
  command.82 = (long unsigned int) command;
  fd.71 = (int) fd;
  ret = ioctl (fd.71, command.82, buffer);
  if (ret == -1) goto <D.12358>; else goto <D.12359>;
  <D.12358>:
  {
    gint errnum;

    D.12330 = __errno_location ();
    errnum = *D.12330;
    errnum.83 = (unsigned int) errnum;
    D.12361 = errno_to_WSA (errnum.83, &__func__);
    errnum = (gint) D.12361;
    WSASetLastError (errnum);
    monoeg_g_free (buffer);
    D.12301 = -1;
    return D.12301;
  }
  <D.12359>:
  if (buffer == 0B) goto <D.12362>; else goto <D.12363>;
  <D.12362>:
  *written = 0;
  goto <D.12364>;
  <D.12363>:
  i_len = MIN_EXPR <i_len, o_len>;
  D.12365 = i_len > 0;
  D.12366 = output != 0B;
  D.12367 = D.12365 & D.12366;
  if (D.12367 != 0) goto <D.12368>; else goto <D.12369>;
  <D.12368>:
  i_len.84 = (unsigned int) i_len;
  memcpy (output, buffer, i_len.84);
  <D.12369>:
  monoeg_g_free (buffer);
  *written = i_len;
  <D.12364>:
  D.12301 = 0;
  return D.12301;
}


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

  if (reserved != 0) goto <D.12373>; else goto <D.12374>;
  <D.12373>:
  WSASetLastError (10022);
  D.12375 = 0;
  return D.12375;
  <D.12374>:
  D.12375 = socket_disconnect (fd);
  return D.12375;
}


socket_disconnect (guint32 fd)
{
  gboolean D.12379;
  struct _WapiHandle_socket * socket_handle.85;
  int D.12381;
  int D.12382;
  int D.12383;
  int * D.12386;
  unsigned int errnum.86;
  unsigned int D.12388;
  int fd.87;
  int D.12391;
  unsigned int errnum.88;
  unsigned int D.12395;
  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.12377>; else goto <D.12378>;
      <D.12377>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12379 = 0;
      return D.12379;
      <D.12378>:
      socket_handle.85 = socket_handle;
      D.12381 = socket_handle.85->protocol;
      socket_handle.85 = socket_handle;
      D.12382 = socket_handle.85->type;
      socket_handle.85 = socket_handle;
      D.12383 = socket_handle.85->domain;
      newsock = socket (D.12383, D.12382, D.12381);
      if (newsock == -1) goto <D.12384>; else goto <D.12385>;
      <D.12384>:
      {
        gint errnum;

        D.12386 = __errno_location ();
        errnum = *D.12386;
        errnum.86 = (unsigned int) errnum;
        D.12388 = errno_to_WSA (errnum.86, &__func__);
        errnum = (gint) D.12388;
        WSASetLastError (errnum);
        D.12379 = 0;
        return D.12379;
      }
      <D.12385>:
      <D.11629>:
      fd.87 = (int) fd;
      ret = dup2 (newsock, fd.87);
      if (ret == -1) goto <D.12390>; else goto <D.11630>;
      <D.12390>:
      D.12386 = __errno_location ();
      D.12391 = *D.12386;
      if (D.12391 == 11) goto <D.11629>; else goto <D.11630>;
      <D.11630>:
      if (ret == -1) goto <D.12392>; else goto <D.12393>;
      <D.12392>:
      {
        gint errnum;

        D.12386 = __errno_location ();
        errnum = *D.12386;
        errnum.88 = (unsigned int) errnum;
        D.12395 = errno_to_WSA (errnum.88, &__func__);
        errnum = (gint) D.12395;
        WSASetLastError (errnum);
        D.12379 = 0;
        return D.12379;
      }
      <D.12393>:
      close (newsock);
      D.12379 = 1;
      return D.12379;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


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

  D.12399 = __builtin_object_size (__dest, 0);
  D.12398 = __builtin___memcpy_chk (__dest, __src, __len, D.12399);
  return D.12398;
}


ioctlsocket (guint32 fd, gint32 command, void * arg)
{
  unsigned int startup_count.89;
  int D.12404;
  <unnamed type> D.12405;
  int fd.90;
  int D.12411;
  long unsigned int command.91;
  int * D.12418;
  unsigned int errnum.92;
  unsigned int D.12420;
  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.12402>; else goto <D.12403>;
  <D.12402>:
  WSASetLastError (10093);
  D.12404 = -1;
  return D.12404;
  <D.12403>:
  D.12405 = _wapi_handle_type (handle);
  if (D.12405 != 7) goto <D.12406>; else goto <D.12407>;
  <D.12406>:
  WSASetLastError (10038);
  D.12404 = -1;
  return D.12404;
  <D.12407>:
  switch (command) <default: <D.11706>, case 21531: <D.11705>, case 21537: <D.11702>, case 35077: <D.11704>>
  <D.11702>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 3, 0);
  if (ret != -1) goto <D.12409>; else goto <D.12410>;
  <D.12409>:
  D.12411 = MEM[(gboolean *)arg];
  if (D.12411 != 0) goto <D.12412>; else goto <D.12413>;
  <D.12412>:
  ret = ret | 2048;
  goto <D.12414>;
  <D.12413>:
  ret = ret & -2049;
  <D.12414>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 4, ret);
  <D.12410>:
  goto <D.11703>;
  <D.11704>:
  command.91 = (long unsigned int) command;
  fd.90 = (int) fd;
  ret = ioctl (fd.90, command.91, arg);
  goto <D.11703>;
  <D.11705>:
  command.91 = (long unsigned int) command;
  fd.90 = (int) fd;
  ret = ioctl (fd.90, command.91, arg);
  goto <D.11703>;
  <D.11706>:
  WSASetLastError (10022);
  D.12404 = -1;
  return D.12404;
  <D.11703>:
  if (ret == -1) goto <D.12416>; else goto <D.12417>;
  <D.12416>:
  {
    gint errnum;

    D.12418 = __errno_location ();
    errnum = *D.12418;
    errnum.92 = (unsigned int) errnum;
    D.12420 = errno_to_WSA (errnum.92, &__func__);
    errnum = (gint) D.12420;
    WSASetLastError (errnum);
    D.12404 = -1;
    return D.12404;
  }
  <D.12417>:
  D.12404 = 0;
  return D.12404;
}


_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.12425;
  long int D.11719;
  long int iftmp.94;
  int D.12431;
  long int iftmp.95;
  unsigned int __d.96;
  long int D.12440;
  int D.12441;
  long int D.12442;
  long int D.12443;
  long int D.11721;
  long int iftmp.97;
  int D.12446;
  long int iftmp.98;
  unsigned int __d.99;
  long int D.12455;
  long int D.12456;
  long int D.12457;
  long int D.11723;
  long int iftmp.100;
  int D.12460;
  long int iftmp.101;
  unsigned int __d.102;
  long int D.12469;
  long int D.12470;
  long int D.12471;
  int D.12474;
  int * D.12476;
  int D.12477;
  int D.12479;
  unsigned int errnum.103;
  unsigned int D.12483;
  int ret;
  int maxfd;
  static const char __func__[13] = "_wapi_select";

  startup_count.93 = startup_count;
  if (startup_count.93 == 0) goto <D.12423>; else goto <D.12424>;
  <D.12423>:
  WSASetLastError (10093);
  D.12425 = -1;
  return D.12425;
  <D.12424>:
  maxfd = 1023;
  goto <D.11726>;
  <D.11725>:
  if (readfds != 0B) goto <D.12429>; else goto <D.12426>;
  <D.12429>:
  {
    long int __d;

    __d = maxfd;
    D.12431 = __builtin_constant_p (__d);
    if (D.12431 != 0) goto <D.12432>; else goto <D.12433>;
    <D.12432>:
    __d.96 = (unsigned int) __d;
    if (__d.96 <= 1023) goto <D.12436>; else goto <D.12437>;
    <D.12436>:
    iftmp.95 = __d / 32;
    goto <D.12438>;
    <D.12437>:
    iftmp.95 = __fdelt_warn (__d);
    <D.12438>:
    iftmp.94 = iftmp.95;
    goto <D.12439>;
    <D.12433>:
    iftmp.94 = __fdelt_chk (__d);
    <D.12439>:
    D.11719 = iftmp.94;
  }
  D.12440 = readfds->fds_bits[D.11719];
  D.12441 = maxfd % 32;
  D.12442 = D.12440 >> D.12441;
  D.12443 = D.12442 & 1;
  if (D.12443 != 0) goto <D.11724>; else goto <D.12426>;
  <D.12426>:
  if (writefds != 0B) goto <D.12444>; else goto <D.12427>;
  <D.12444>:
  {
    long int __d;

    __d = maxfd;
    D.12446 = __builtin_constant_p (__d);
    if (D.12446 != 0) goto <D.12447>; else goto <D.12448>;
    <D.12447>:
    __d.99 = (unsigned int) __d;
    if (__d.99 <= 1023) goto <D.12451>; else goto <D.12452>;
    <D.12451>:
    iftmp.98 = __d / 32;
    goto <D.12453>;
    <D.12452>:
    iftmp.98 = __fdelt_warn (__d);
    <D.12453>:
    iftmp.97 = iftmp.98;
    goto <D.12454>;
    <D.12448>:
    iftmp.97 = __fdelt_chk (__d);
    <D.12454>:
    D.11721 = iftmp.97;
  }
  D.12455 = writefds->fds_bits[D.11721];
  D.12441 = maxfd % 32;
  D.12456 = D.12455 >> D.12441;
  D.12457 = D.12456 & 1;
  if (D.12457 != 0) goto <D.11724>; else goto <D.12427>;
  <D.12427>:
  if (exceptfds != 0B) goto <D.12458>; else goto <D.12428>;
  <D.12458>:
  {
    long int __d;

    __d = maxfd;
    D.12460 = __builtin_constant_p (__d);
    if (D.12460 != 0) goto <D.12461>; else goto <D.12462>;
    <D.12461>:
    __d.102 = (unsigned int) __d;
    if (__d.102 <= 1023) goto <D.12465>; else goto <D.12466>;
    <D.12465>:
    iftmp.101 = __d / 32;
    goto <D.12467>;
    <D.12466>:
    iftmp.101 = __fdelt_warn (__d);
    <D.12467>:
    iftmp.100 = iftmp.101;
    goto <D.12468>;
    <D.12462>:
    iftmp.100 = __fdelt_chk (__d);
    <D.12468>:
    D.11723 = iftmp.100;
  }
  D.12469 = exceptfds->fds_bits[D.11723];
  D.12441 = maxfd % 32;
  D.12470 = D.12469 >> D.12441;
  D.12471 = D.12470 & 1;
  if (D.12471 != 0) goto <D.11724>; else goto <D.12428>;
  <D.12428>:
  maxfd = maxfd + -1;
  <D.11726>:
  if (maxfd >= 0) goto <D.11725>; else goto <D.11724>;
  <D.11724>:
  if (maxfd == -1) goto <D.12472>; else goto <D.12473>;
  <D.12472>:
  WSASetLastError (10022);
  D.12425 = -1;
  return D.12425;
  <D.12473>:
  <D.11727>:
  D.12474 = maxfd + 1;
  ret = select (D.12474, readfds, writefds, exceptfds, timeout);
  if (ret == -1) goto <D.12475>; else goto <D.11728>;
  <D.12475>:
  D.12476 = __errno_location ();
  D.12477 = *D.12476;
  if (D.12477 == 4) goto <D.12478>; else goto <D.11728>;
  <D.12478>:
  D.12479 = _wapi_thread_cur_apc_pending ();
  if (D.12479 == 0) goto <D.11727>; else goto <D.11728>;
  <D.11728>:
  if (ret == -1) goto <D.12480>; else goto <D.12481>;
  <D.12480>:
  {
    gint errnum;

    D.12476 = __errno_location ();
    errnum = *D.12476;
    errnum.103 = (unsigned int) errnum;
    D.12483 = errno_to_WSA (errnum.103, &__func__);
    errnum = (gint) D.12483;
    WSASetLastError (errnum);
    D.12425 = -1;
    return D.12425;
  }
  <D.12481>:
  D.12425 = ret;
  return D.12425;
}


_wapi_FD_CLR (guint32 fd, struct fd_set * set)
{
  <unnamed type> D.12487;
  long int D.11737;
  long int iftmp.104;
  int D.12491;
  long int iftmp.105;
  unsigned int __d.106;
  long int D.12500;
  long int D.12501;
  int fd.107;
  int D.12503;
  long int D.12504;
  long int D.12505;
  long int D.12506;
  void * handle;

  handle = (void *) fd;
  if (fd > 1023) goto <D.12485>; else goto <D.12486>;
  <D.12485>:
  WSASetLastError (10022);
  return;
  <D.12486>:
  D.12487 = _wapi_handle_type (handle);
  if (D.12487 != 7) goto <D.12488>; else goto <D.12489>;
  <D.12488>:
  WSASetLastError (10038);
  return;
  <D.12489>:
  {
    long int __d;

    __d = (long int) fd;
    D.12491 = __builtin_constant_p (__d);
    if (D.12491 != 0) goto <D.12492>; else goto <D.12493>;
    <D.12492>:
    __d.106 = (unsigned int) __d;
    if (__d.106 <= 1023) goto <D.12496>; else goto <D.12497>;
    <D.12496>:
    iftmp.105 = __d / 32;
    goto <D.12498>;
    <D.12497>:
    iftmp.105 = __fdelt_warn (__d);
    <D.12498>:
    iftmp.104 = iftmp.105;
    goto <D.12499>;
    <D.12493>:
    iftmp.104 = __fdelt_chk (__d);
    <D.12499>:
    D.11737 = iftmp.104;
  }
  D.12500 = D.11737;
  D.12501 = set->fds_bits[D.12500];
  fd.107 = (int) fd;
  D.12503 = fd.107 & 31;
  D.12504 = 1 << D.12503;
  D.12505 = ~D.12504;
  D.12506 = D.12501 & D.12505;
  set->fds_bits[D.12500] = D.12506;
}


_wapi_FD_ISSET (guint32 fd, struct fd_set * set)
{
  int D.12510;
  <unnamed type> D.12511;
  long int D.11744;
  long int iftmp.108;
  int D.12515;
  long int iftmp.109;
  unsigned int __d.110;
  long int D.12524;
  int fd.111;
  int D.12526;
  long int D.12527;
  long int D.12528;
  _Bool D.12529;
  void * handle;

  handle = (void *) fd;
  if (fd > 1023) goto <D.12508>; else goto <D.12509>;
  <D.12508>:
  WSASetLastError (10022);
  D.12510 = 0;
  return D.12510;
  <D.12509>:
  D.12511 = _wapi_handle_type (handle);
  if (D.12511 != 7) goto <D.12512>; else goto <D.12513>;
  <D.12512>:
  WSASetLastError (10038);
  D.12510 = 0;
  return D.12510;
  <D.12513>:
  {
    long int __d;

    __d = (long int) fd;
    D.12515 = __builtin_constant_p (__d);
    if (D.12515 != 0) goto <D.12516>; else goto <D.12517>;
    <D.12516>:
    __d.110 = (unsigned int) __d;
    if (__d.110 <= 1023) goto <D.12520>; else goto <D.12521>;
    <D.12520>:
    iftmp.109 = __d / 32;
    goto <D.12522>;
    <D.12521>:
    iftmp.109 = __fdelt_warn (__d);
    <D.12522>:
    iftmp.108 = iftmp.109;
    goto <D.12523>;
    <D.12517>:
    iftmp.108 = __fdelt_chk (__d);
    <D.12523>:
    D.11744 = iftmp.108;
  }
  D.12524 = set->fds_bits[D.11744];
  fd.111 = (int) fd;
  D.12526 = fd.111 & 31;
  D.12527 = D.12524 >> D.12526;
  D.12528 = D.12527 & 1;
  D.12529 = D.12528 != 0;
  D.12510 = (int) D.12529;
  return D.12510;
}


_wapi_FD_SET (guint32 fd, struct fd_set * set)
{
  <unnamed type> D.12533;
  long int D.11751;
  long int iftmp.112;
  int D.12537;
  long int iftmp.113;
  unsigned int __d.114;
  long int D.12546;
  long int D.12547;
  int fd.115;
  int D.12549;
  long int D.12550;
  long int D.12551;
  void * handle;

  handle = (void *) fd;
  if (fd > 1023) goto <D.12531>; else goto <D.12532>;
  <D.12531>:
  WSASetLastError (10022);
  return;
  <D.12532>:
  D.12533 = _wapi_handle_type (handle);
  if (D.12533 != 7) goto <D.12534>; else goto <D.12535>;
  <D.12534>:
  WSASetLastError (10038);
  return;
  <D.12535>:
  {
    long int __d;

    __d = (long int) fd;
    D.12537 = __builtin_constant_p (__d);
    if (D.12537 != 0) goto <D.12538>; else goto <D.12539>;
    <D.12538>:
    __d.114 = (unsigned int) __d;
    if (__d.114 <= 1023) goto <D.12542>; else goto <D.12543>;
    <D.12542>:
    iftmp.113 = __d / 32;
    goto <D.12544>;
    <D.12543>:
    iftmp.113 = __fdelt_warn (__d);
    <D.12544>:
    iftmp.112 = iftmp.113;
    goto <D.12545>;
    <D.12539>:
    iftmp.112 = __fdelt_chk (__d);
    <D.12545>:
    D.11751 = iftmp.112;
  }
  D.12546 = D.11751;
  D.12547 = set->fds_bits[D.12546];
  fd.115 = (int) fd;
  D.12549 = fd.115 & 31;
  D.12550 = 1 << D.12549;
  D.12551 = D.12547 | D.12550;
  set->fds_bits[D.12546] = D.12551;
}


WSARecv (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * received, guint32 * flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.12553;
  long int D.12554;
  long int D.12555;
  _Bool D.12558;
  long int D.12559;
  long int D.12560;
  unsigned int D.12563;
  int D.12564;
  int D.12567;
  unsigned int ret.116;
  int D.12569;
  unsigned int D.12570;
  int ret;
  struct msghdr hdr;

  try
    {
      D.12553 = overlapped != 0B;
      D.12554 = (long int) D.12553;
      D.12555 = __builtin_expect (D.12554, 0);
      if (D.12555 != 0) goto <D.12556>; else goto <D.12557>;
      <D.12556>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1554, "overlapped == NULL");
      <D.12557>:
      D.12558 = complete != 0B;
      D.12559 = (long int) D.12558;
      D.12560 = __builtin_expect (D.12559, 0);
      if (D.12560 != 0) goto <D.12561>; else goto <D.12562>;
      <D.12561>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1555, "complete == NULL");
      <D.12562>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      D.12563 = *flags;
      D.12564 = (int) D.12563;
      ret = _wapi_recvmsg (fd, &hdr, D.12564);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.12565>; else goto <D.12566>;
      <D.12565>:
      D.12567 = ret;
      return D.12567;
      <D.12566>:
      ret.116 = (unsigned int) ret;
      *received = ret.116;
      D.12569 = hdr.msg_flags;
      D.12570 = (unsigned int) D.12569;
      *flags = D.12570;
      D.12567 = 0;
      return D.12567;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


wsabuf_to_msghdr (struct WapiWSABuf * buffers, guint32 count, struct msghdr * hdr)
{
  unsigned int D.12573;
  void * D.12574;
  struct iovec * D.12575;
  unsigned int D.12576;
  struct iovec * D.12577;
  struct WapiWSABuf * D.12578;
  void * D.12579;
  unsigned int D.12580;
  guint32 i;

  memset (hdr, 0, 28);
  hdr->msg_iovlen = count;
  D.12573 = count * 8;
  D.12574 = monoeg_malloc0 (D.12573);
  hdr->msg_iov = D.12574;
  i = 0;
  goto <D.11759>;
  <D.11758>:
  D.12575 = hdr->msg_iov;
  D.12576 = i * 8;
  D.12577 = D.12575 + D.12576;
  D.12576 = i * 8;
  D.12578 = buffers + D.12576;
  D.12579 = D.12578->buf;
  D.12577->iov_base = D.12579;
  D.12575 = hdr->msg_iov;
  D.12576 = i * 8;
  D.12577 = D.12575 + D.12576;
  D.12576 = i * 8;
  D.12578 = buffers + D.12576;
  D.12580 = D.12578->len;
  D.12577->iov_len = D.12580;
  i = i + 1;
  <D.11759>:
  if (i < count) goto <D.11758>; else goto <D.11760>;
  <D.11760>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.12583;
  int D.12588;
  void * D.12590;
  unsigned int D.12591;

  D.12583 = __builtin_constant_p (__len);
  if (D.12583 != 0) goto <D.12584>; else goto <D.12585>;
  <D.12584>:
  if (__len == 0) goto <D.12586>; else goto <D.12587>;
  <D.12586>:
  D.12588 = __builtin_constant_p (__ch);
  if (D.12588 == 0) goto <D.12581>; else goto <D.12589>;
  <D.12589>:
  if (__ch != 0) goto <D.12581>; else goto <D.12582>;
  <D.12581>:
  __warn_memset_zero_len ();
  D.12590 = __dest;
  return D.12590;
  <D.12582>:
  <D.12587>:
  <D.12585>:
  D.12591 = __builtin_object_size (__dest, 0);
  D.12590 = __builtin___memset_chk (__dest, __ch, __len, D.12591);
  return D.12590;
}


_wapi_recvmsg (guint32 fd, struct msghdr * msg, int recv_flags)
{
  unsigned int startup_count.117;
  int D.12596;
  <unnamed type> D.12597;
  int fd.118;
  int * D.12602;
  int D.12603;
  int D.12605;
  struct _WapiHandle_socket * socket_handle.119;
  int D.12612;
  unsigned int errnum.120;
  unsigned int D.12616;
  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.12594>; else goto <D.12595>;
      <D.12594>:
      WSASetLastError (10093);
      D.12596 = -1;
      return D.12596;
      <D.12595>:
      D.12597 = _wapi_handle_type (handle);
      if (D.12597 != 7) goto <D.12598>; else goto <D.12599>;
      <D.12598>:
      WSASetLastError (10038);
      D.12596 = -1;
      return D.12596;
      <D.12599>:
      <D.11524>:
      fd.118 = (int) fd;
      ret = recvmsg (fd.118, msg, recv_flags);
      if (ret == -1) goto <D.12601>; else goto <D.11525>;
      <D.12601>:
      D.12602 = __errno_location ();
      D.12603 = *D.12602;
      if (D.12603 == 4) goto <D.12604>; else goto <D.11525>;
      <D.12604>:
      D.12605 = _wapi_thread_cur_apc_pending ();
      if (D.12605 == 0) goto <D.11524>; else goto <D.11525>;
      <D.11525>:
      if (ret == 0) goto <D.12606>; else goto <D.12607>;
      <D.12606>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12608>; else goto <D.12610>;
      <D.12610>:
      socket_handle.119 = socket_handle;
      D.12612 = socket_handle.119->still_readable;
      if (D.12612 != 1) goto <D.12608>; else goto <D.12609>;
      <D.12608>:
      ret = -1;
      D.12602 = __errno_location ();
      *D.12602 = 4;
      <D.12609>:
      <D.12607>:
      if (ret == -1) goto <D.12613>; else goto <D.12614>;
      <D.12613>:
      {
        gint errnum;

        D.12602 = __errno_location ();
        errnum = *D.12602;
        errnum.120 = (unsigned int) errnum;
        D.12616 = errno_to_WSA (errnum.120, &__func__);
        errnum = (gint) D.12616;
        WSASetLastError (errnum);
        D.12596 = -1;
        return D.12596;
      }
      <D.12614>:
      D.12596 = ret;
      return D.12596;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


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

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


WSASend (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * sent, guint32 flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.12620;
  long int D.12621;
  long int D.12622;
  _Bool D.12625;
  long int D.12626;
  long int D.12627;
  int flags.121;
  int D.12633;
  unsigned int ret.122;
  int ret;
  struct msghdr hdr;

  try
    {
      D.12620 = overlapped != 0B;
      D.12621 = (long int) D.12620;
      D.12622 = __builtin_expect (D.12621, 0);
      if (D.12622 != 0) goto <D.12623>; else goto <D.12624>;
      <D.12623>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1578, "overlapped == NULL");
      <D.12624>:
      D.12625 = complete != 0B;
      D.12626 = (long int) D.12625;
      D.12627 = __builtin_expect (D.12626, 0);
      if (D.12627 != 0) goto <D.12628>; else goto <D.12629>;
      <D.12628>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1579, "complete == NULL");
      <D.12629>:
      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.12631>; else goto <D.12632>;
      <D.12631>:
      D.12633 = ret;
      return D.12633;
      <D.12632>:
      ret.122 = (unsigned int) ret;
      *sent = ret.122;
      D.12633 = 0;
      return D.12633;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


_wapi_sendmsg (guint32 fd, const struct msghdr * msg, int send_flags)
{
  unsigned int startup_count.123;
  int D.12640;
  <unnamed type> D.12641;
  int fd.124;
  int * D.12646;
  int D.12647;
  int D.12649;
  unsigned int errnum.125;
  unsigned int D.12653;
  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.12638>; else goto <D.12639>;
  <D.12638>:
  WSASetLastError (10093);
  D.12640 = -1;
  return D.12640;
  <D.12639>:
  D.12641 = _wapi_handle_type (handle);
  if (D.12641 != 7) goto <D.12642>; else goto <D.12643>;
  <D.12642>:
  WSASetLastError (10038);
  D.12640 = -1;
  return D.12640;
  <D.12643>:
  <D.11561>:
  fd.124 = (int) fd;
  ret = sendmsg (fd.124, msg, send_flags);
  if (ret == -1) goto <D.12645>; else goto <D.11562>;
  <D.12645>:
  D.12646 = __errno_location ();
  D.12647 = *D.12646;
  if (D.12647 == 4) goto <D.12648>; else goto <D.11562>;
  <D.12648>:
  D.12649 = _wapi_thread_cur_apc_pending ();
  if (D.12649 == 0) goto <D.11561>; else goto <D.11562>;
  <D.11562>:
  if (ret == -1) goto <D.12650>; else goto <D.12651>;
  <D.12650>:
  {
    gint errnum;

    D.12646 = __errno_location ();
    errnum = *D.12646;
    errnum.125 = (unsigned int) errnum;
    D.12653 = errno_to_WSA (errnum.125, &__func__);
    errnum = (gint) D.12653;
    WSASetLastError (errnum);
    D.12640 = -1;
    return D.12640;
  }
  <D.12651>:
  D.12640 = ret;
  return D.12640;
}