socket_close (void * handle, void * data)
{
  unsigned int startup_count.0;
  unsigned int in_cleanup.1;
  long int handle.2;
  int D.12142;
  int * D.12144;
  int D.12145;
  int D.12147;
  unsigned int errnum.3;
  unsigned int D.12151;
  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.12136>; else goto <D.12137>;
  <D.12136>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.12139>; else goto <D.12140>;
  <D.12139>:
  WSASetLastError (10093);
  return;
  <D.12140>:
  <D.12137>:
  handle.2 = (long int) handle;
  D.12142 = (int) handle.2;
  shutdown (D.12142, 0);
  <D.11735>:
  handle.2 = (long int) handle;
  D.12142 = (int) handle.2;
  ret = close (D.12142);
  if (ret == -1) goto <D.12143>; else goto <D.11736>;
  <D.12143>:
  D.12144 = __errno_location ();
  D.12145 = *D.12144;
  if (D.12145 == 4) goto <D.12146>; else goto <D.11736>;
  <D.12146>:
  D.12147 = _wapi_thread_cur_apc_pending ();
  if (D.12147 == 0) goto <D.11735>; else goto <D.11736>;
  <D.11736>:
  if (ret == -1) goto <D.12148>; else goto <D.12149>;
  <D.12148>:
  {
    gint errnum;

    D.12144 = __errno_location ();
    errnum = *D.12144;
    errnum.3 = (unsigned int) errnum;
    D.12151 = errno_to_WSA (errnum.3, &__func__);
    errnum = (gint) D.12151;
    in_cleanup.1 = in_cleanup;
    if (in_cleanup.1 == 0) goto <D.12152>; else goto <D.12153>;
    <D.12152>:
    WSASetLastError (errnum);
    <D.12153>:
  }
  <D.12149>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.12154>; else goto <D.12155>;
  <D.12154>:
  socket_handle->saved_error = 0;
  <D.12155>:
}


WSAStartup (guint32 requested, struct WapiWSAData * data)
{
  int D.12159;
  unsigned int startup_count.4;
  unsigned int startup_count.5;
  short unsigned int D.12164;
  unsigned int D.12165;
  unsigned int D.12166;
  short unsigned int D.12167;
  char[257] * D.12168;
  char[129] * D.12169;

  if (data == 0B) goto <D.12157>; else goto <D.12158>;
  <D.12157>:
  D.12159 = 10014;
  return D.12159;
  <D.12158>:
  if (requested <= 1) goto <D.12160>; else goto <D.12161>;
  <D.12160>:
  D.12159 = 10092;
  return D.12159;
  <D.12161>:
  startup_count.4 = startup_count;
  startup_count.5 = startup_count.4 + 1;
  startup_count = startup_count.5;
  data->wHighVersion = 514;
  D.12164 = data->wHighVersion;
  D.12165 = (unsigned int) D.12164;
  D.12166 = MIN_EXPR <D.12165, requested>;
  D.12167 = (short unsigned int) D.12166;
  data->wVersion = D.12167;
  D.12168 = &data->szDescription;
  strncpy (D.12168, "WAPI", 256);
  D.12169 = &data->szSystemStatus;
  strncpy (D.12169, "groovy", 128);
  D.12159 = 0;
  return D.12159;
}


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

  D.12172 = __builtin_object_size (__dest, 1);
  D.12171 = __builtin___strncpy_chk (__dest, __src, __len, D.12172);
  return D.12171;
}


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

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


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

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


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

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


WSAGetLastError ()
{
  int D.12183;
  unsigned int D.12184;

  D.12184 = GetLastError ();
  D.12183 = (int) D.12184;
  return D.12183;
}


closesocket (guint32 fd)
{
  long unsigned int D.12186;
  <unnamed type> D.12187;
  int D.12190;
  void * handle;

  D.12186 = (long unsigned int) fd;
  handle = (void *) D.12186;
  D.12187 = _wapi_handle_type (handle);
  if (D.12187 != 7) goto <D.12188>; else goto <D.12189>;
  <D.12188>:
  WSASetLastError (10038);
  D.12190 = 0;
  return D.12190;
  <D.12189>:
  _wapi_handle_unref (handle);
  D.12190 = 0;
  return D.12190;
}


_wapi_handle_type (void * handle)
{
  long int handle.9;
  unsigned int D.12196;
  struct _WapiHandleUnshared * D.12197;
  WapiHandleType D.12198;
  unsigned int D.12199;
  struct _WapiHandleUnshared * D.12200;
  long unsigned int D.12201;
  long unsigned int D.12202;
  long unsigned int D.12203;
  struct _WapiHandleUnshared * D.12204;
  guint32 idx;

  handle.9 = (long int) handle;
  idx = (guint32) handle.9;
  if (idx > 4194303) goto <D.12193>; else goto <D.12195>;
  <D.12195>:
  D.12196 = idx / 256;
  D.12197 = _wapi_private_handles[D.12196];
  if (D.12197 == 0B) goto <D.12193>; else goto <D.12194>;
  <D.12193>:
  D.12198 = 0;
  return D.12198;
  <D.12194>:
  D.12199 = idx / 256;
  D.12200 = _wapi_private_handles[D.12199];
  D.12201 = (long unsigned int) idx;
  D.12202 = D.12201 & 255;
  D.12203 = D.12202 * 200;
  D.12204 = D.12200 + D.12203;
  D.12198 = D.12204->type;
  return D.12198;
}


_wapi_accept (guint32 fd, struct sockaddr * addr, socklen_t * addrlen)
{
  long unsigned int D.12206;
  unsigned int startup_count.10;
  guint32 D.12210;
  unsigned int D.12213;
  <unnamed type> D.12216;
  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.12221;
  int fd.11;
  int * D.12224;
  int D.12225;
  int D.12227;
  unsigned int errnum.12;
  unsigned int D.12231;
  unsigned int new_fd.13;
  unsigned int _wapi_fd_reserve.14;
  struct _WapiHandle_socket * socket_handle.15;
  int D.12237;
  int D.12238;
  int D.12239;
  void * handle;
  void * new_handle;
  struct _WapiHandle_socket * socket_handle;
  struct _WapiHandle_socket new_socket_handle;
  gboolean ok;
  int new_fd;
  static const char __func__[13] = "_wapi_accept";

  try
    {
      D.12206 = (long unsigned int) fd;
      handle = (void *) D.12206;
      new_socket_handle = {};
      startup_count.10 = startup_count;
      if (startup_count.10 == 0) goto <D.12208>; else goto <D.12209>;
      <D.12208>:
      WSASetLastError (10093);
      D.12210 = 4294967295;
      return D.12210;
      <D.12209>:
      if (addr != 0B) goto <D.12211>; else goto <D.12212>;
      <D.12211>:
      D.12213 = *addrlen;
      if (D.12213 <= 15) goto <D.12214>; else goto <D.12215>;
      <D.12214>:
      WSASetLastError (10014);
      D.12210 = 4294967295;
      return D.12210;
      <D.12215>:
      <D.12212>:
      D.12216 = _wapi_handle_type (handle);
      if (D.12216 != 7) goto <D.12217>; else goto <D.12218>;
      <D.12217>:
      WSASetLastError (10038);
      D.12210 = 4294967295;
      return D.12210;
      <D.12218>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12219>; else goto <D.12220>;
      <D.12219>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12210 = 4294967295;
      return D.12210;
      <D.12220>:
      <D.11772>:
      D.12221.__sockaddr__ = addr;
      fd.11 = (int) fd;
      new_fd = accept (fd.11, D.12221, addrlen);
      if (new_fd == -1) goto <D.12223>; else goto <D.11773>;
      <D.12223>:
      D.12224 = __errno_location ();
      D.12225 = *D.12224;
      if (D.12225 == 4) goto <D.12226>; else goto <D.11773>;
      <D.12226>:
      D.12227 = _wapi_thread_cur_apc_pending ();
      if (D.12227 == 0) goto <D.11772>; else goto <D.11773>;
      <D.11773>:
      if (new_fd == -1) goto <D.12228>; else goto <D.12229>;
      <D.12228>:
      {
        gint errnum;

        D.12224 = __errno_location ();
        errnum = *D.12224;
        errnum.12 = (unsigned int) errnum;
        D.12231 = errno_to_WSA (errnum.12, &__func__);
        errnum = (gint) D.12231;
        WSASetLastError (errnum);
        D.12210 = 4294967295;
        return D.12210;
      }
      <D.12229>:
      new_fd.13 = (unsigned int) new_fd;
      _wapi_fd_reserve.14 = _wapi_fd_reserve;
      if (new_fd.13 >= _wapi_fd_reserve.14) goto <D.12234>; else goto <D.12235>;
      <D.12234>:
      WSASetLastError (10107);
      close (new_fd);
      D.12210 = 4294967295;
      return D.12210;
      <D.12235>:
      socket_handle.15 = socket_handle;
      D.12237 = socket_handle.15->domain;
      new_socket_handle.domain = D.12237;
      socket_handle.15 = socket_handle;
      D.12238 = socket_handle.15->type;
      new_socket_handle.type = D.12238;
      socket_handle.15 = socket_handle;
      D.12239 = socket_handle.15->protocol;
      new_socket_handle.protocol = D.12239;
      new_socket_handle.still_readable = 1;
      new_handle = _wapi_handle_new_fd (7, new_fd, &new_socket_handle);
      if (new_handle == -1B) goto <D.12240>; else goto <D.12241>;
      <D.12240>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (31);
      D.12210 = 4294967295;
      return D.12210;
      <D.12241>:
      D.12210 = (guint32) new_fd;
      return D.12210;
    }
  finally
    {
      socket_handle = {CLOBBER};
      new_socket_handle = {CLOBBER};
    }
}


_wapi_bind (guint32 fd, struct sockaddr * my_addr, socklen_t addrlen)
{
  long unsigned int D.12244;
  unsigned int startup_count.16;
  int D.12248;
  <unnamed type> D.12249;
  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.12252;
  int fd.17;
  int * D.12256;
  unsigned int errnum.18;
  unsigned int D.12258;
  void * handle;
  int ret;
  static const char __func__[11] = "_wapi_bind";

  D.12244 = (long unsigned int) fd;
  handle = (void *) D.12244;
  startup_count.16 = startup_count;
  if (startup_count.16 == 0) goto <D.12246>; else goto <D.12247>;
  <D.12246>:
  WSASetLastError (10093);
  D.12248 = -1;
  return D.12248;
  <D.12247>:
  D.12249 = _wapi_handle_type (handle);
  if (D.12249 != 7) goto <D.12250>; else goto <D.12251>;
  <D.12250>:
  WSASetLastError (10038);
  D.12248 = -1;
  return D.12248;
  <D.12251>:
  D.12252.__sockaddr__ = my_addr;
  fd.17 = (int) fd;
  ret = bind (fd.17, D.12252, addrlen);
  if (ret == -1) goto <D.12254>; else goto <D.12255>;
  <D.12254>:
  {
    gint errnum;

    D.12256 = __errno_location ();
    errnum = *D.12256;
    errnum.18 = (unsigned int) errnum;
    D.12258 = errno_to_WSA (errnum.18, &__func__);
    errnum = (gint) D.12258;
    WSASetLastError (errnum);
    D.12248 = -1;
    return D.12248;
  }
  <D.12255>:
  D.12248 = ret;
  return D.12248;
}


_wapi_connect (guint32 fd, const struct sockaddr * serv_addr, socklen_t addrlen)
{
  long unsigned int D.12260;
  unsigned int startup_count.19;
  int D.12264;
  <unnamed type> D.12265;
  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.12268;
  int fd.20;
  int D.12270;
  int * D.12273;
  int D.12274;
  unsigned int errnum.21;
  unsigned int D.12278;
  _Bool D.12285;
  _Bool D.12286;
  _Bool D.12287;
  struct _WapiHandle_socket * socket_handle.22;
  unsigned int D.12294;
  unsigned int D.12295;
  int D.12296;
  int D.12298;
  int D.12299;
  unsigned int D.12302;
  int so_error.23;
  unsigned int so_error.24;
  unsigned int D.12307;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  gint errnum;
  static const char __func__[14] = "_wapi_connect";

  try
    {
      D.12260 = (long unsigned int) fd;
      handle = (void *) D.12260;
      startup_count.19 = startup_count;
      if (startup_count.19 == 0) goto <D.12262>; else goto <D.12263>;
      <D.12262>:
      WSASetLastError (10093);
      D.12264 = -1;
      return D.12264;
      <D.12263>:
      D.12265 = _wapi_handle_type (handle);
      if (D.12265 != 7) goto <D.12266>; else goto <D.12267>;
      <D.12266>:
      WSASetLastError (10038);
      D.12264 = -1;
      return D.12264;
      <D.12267>:
      D.12268.__sockaddr__ = serv_addr;
      fd.20 = (int) fd;
      D.12270 = connect (fd.20, D.12268, addrlen);
      if (D.12270 == -1) goto <D.12271>; else goto <D.12272>;
      <D.12271>:
      {
        struct mono_pollfd fds;
        int so_error;
        socklen_t len;

        try
          {
            D.12273 = __errno_location ();
            errnum = *D.12273;
            D.12273 = __errno_location ();
            D.12274 = *D.12273;
            if (D.12274 != 4) goto <D.12275>; else goto <D.12276>;
            <D.12275>:
            errnum.21 = (unsigned int) errnum;
            D.12278 = errno_to_WSA (errnum.21, &__func__);
            errnum = (gint) D.12278;
            if (errnum == 10036) goto <D.12279>; else goto <D.12280>;
            <D.12279>:
            errnum = 10035;
            <D.12280>:
            WSASetLastError (errnum);
            if (errnum != 10035) goto <D.12281>; else goto <D.12282>;
            <D.12281>:
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.12283>; else goto <D.12284>;
            <D.12283>:
            D.12285 = errnum != 10054;
            D.12286 = errnum != 10050;
            D.12287 = D.12285 & D.12286;
            if (D.12287 != 0) goto <D.12288>; else goto <D.12289>;
            <D.12288>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p (error %d)", &__func__, handle, errnum);
            <D.12289>:
            goto <D.12290>;
            <D.12284>:
            socket_handle.22 = socket_handle;
            socket_handle.22->saved_error = errnum;
            <D.12290>:
            <D.12282>:
            D.12264 = -1;
            return D.12264;
            <D.12276>:
            fd.20 = (int) fd;
            fds.fd = fd.20;
            fds.events = 4;
            goto <D.11798>;
            <D.11797>:
            D.12273 = __errno_location ();
            D.12274 = *D.12273;
            if (D.12274 != 4) goto <D.12292>; else goto <D.12293>;
            <D.12292>:
            D.12273 = __errno_location ();
            D.12274 = *D.12273;
            D.12294 = (unsigned int) D.12274;
            D.12295 = errno_to_WSA (D.12294, &__func__);
            errnum = (gint) D.12295;
            WSASetLastError (errnum);
            D.12264 = -1;
            return D.12264;
            <D.12293>:
            <D.11798>:
            D.12296 = mono_poll (&fds, 1, -1);
            if (D.12296 == -1) goto <D.12297>; else goto <D.11799>;
            <D.12297>:
            D.12298 = _wapi_thread_cur_apc_pending ();
            if (D.12298 == 0) goto <D.11797>; else goto <D.11799>;
            <D.11799>:
            len = 4;
            fd.20 = (int) fd;
            D.12299 = getsockopt (fd.20, 1, 4, &so_error, &len);
            if (D.12299 == -1) goto <D.12300>; else goto <D.12301>;
            <D.12300>:
            D.12273 = __errno_location ();
            D.12274 = *D.12273;
            D.12294 = (unsigned int) D.12274;
            D.12302 = errno_to_WSA (D.12294, &__func__);
            errnum = (gint) D.12302;
            WSASetLastError (errnum);
            D.12264 = -1;
            return D.12264;
            <D.12301>:
            so_error.23 = so_error;
            if (so_error.23 != 0) goto <D.12304>; else goto <D.12305>;
            <D.12304>:
            so_error.23 = so_error;
            so_error.24 = (unsigned int) so_error.23;
            D.12307 = errno_to_WSA (so_error.24, &__func__);
            errnum = (gint) D.12307;
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.12308>; else goto <D.12309>;
            <D.12308>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
            goto <D.12310>;
            <D.12309>:
            socket_handle.22 = socket_handle;
            socket_handle.22->saved_error = errnum;
            <D.12310>:
            WSASetLastError (errnum);
            D.12264 = -1;
            return D.12264;
            <D.12305>:
          }
        finally
          {
            fds = {CLOBBER};
            so_error = {CLOBBER};
            len = {CLOBBER};
          }
      }
      <D.12272>:
      D.12264 = 0;
      return D.12264;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_getpeername (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  long unsigned int D.12315;
  unsigned int startup_count.25;
  int D.12319;
  <unnamed type> D.12320;
  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.12323;
  int fd.26;
  int * D.12327;
  unsigned int errnum.27;
  unsigned int D.12329;
  void * handle;
  int ret;
  static const char __func__[18] = "_wapi_getpeername";

  D.12315 = (long unsigned int) fd;
  handle = (void *) D.12315;
  startup_count.25 = startup_count;
  if (startup_count.25 == 0) goto <D.12317>; else goto <D.12318>;
  <D.12317>:
  WSASetLastError (10093);
  D.12319 = -1;
  return D.12319;
  <D.12318>:
  D.12320 = _wapi_handle_type (handle);
  if (D.12320 != 7) goto <D.12321>; else goto <D.12322>;
  <D.12321>:
  WSASetLastError (10038);
  D.12319 = -1;
  return D.12319;
  <D.12322>:
  D.12323.__sockaddr__ = name;
  fd.26 = (int) fd;
  ret = getpeername (fd.26, D.12323, namelen);
  if (ret == -1) goto <D.12325>; else goto <D.12326>;
  <D.12325>:
  {
    gint errnum;

    D.12327 = __errno_location ();
    errnum = *D.12327;
    errnum.27 = (unsigned int) errnum;
    D.12329 = errno_to_WSA (errnum.27, &__func__);
    errnum = (gint) D.12329;
    WSASetLastError (errnum);
    D.12319 = -1;
    return D.12319;
  }
  <D.12326>:
  D.12319 = ret;
  return D.12319;
}


_wapi_getsockname (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  long unsigned int D.12331;
  unsigned int startup_count.28;
  int D.12335;
  <unnamed type> D.12336;
  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.12339;
  int fd.29;
  int * D.12343;
  unsigned int errnum.30;
  unsigned int D.12345;
  void * handle;
  int ret;
  static const char __func__[18] = "_wapi_getsockname";

  D.12331 = (long unsigned int) fd;
  handle = (void *) D.12331;
  startup_count.28 = startup_count;
  if (startup_count.28 == 0) goto <D.12333>; else goto <D.12334>;
  <D.12333>:
  WSASetLastError (10093);
  D.12335 = -1;
  return D.12335;
  <D.12334>:
  D.12336 = _wapi_handle_type (handle);
  if (D.12336 != 7) goto <D.12337>; else goto <D.12338>;
  <D.12337>:
  WSASetLastError (10038);
  D.12335 = -1;
  return D.12335;
  <D.12338>:
  D.12339.__sockaddr__ = name;
  fd.29 = (int) fd;
  ret = getsockname (fd.29, D.12339, namelen);
  if (ret == -1) goto <D.12341>; else goto <D.12342>;
  <D.12341>:
  {
    gint errnum;

    D.12343 = __errno_location ();
    errnum = *D.12343;
    errnum.30 = (unsigned int) errnum;
    D.12345 = errno_to_WSA (errnum.30, &__func__);
    errnum = (gint) D.12345;
    WSASetLastError (errnum);
    D.12335 = -1;
    return D.12335;
  }
  <D.12342>:
  D.12335 = ret;
  return D.12335;
}


_wapi_getsockopt (guint32 fd, int level, int optname, void * optval, socklen_t * optlen)
{
  long unsigned int D.12347;
  unsigned int startup_count.31;
  int D.12351;
  <unnamed type> D.12352;
  unsigned int optname.32;
  unsigned int D.12358;
  int fd.33;
  int * D.12364;
  unsigned int errnum.34;
  unsigned int D.12366;
  long int D.12371;
  unsigned int D.12372;
  unsigned int D.12373;
  long int D.12374;
  long int D.12375;
  unsigned int D.12376;
  unsigned int D.12377;
  int D.12378;
  int D.12383;
  unsigned int D.12384;
  unsigned int D.12385;
  int D.12386;
  unsigned int D.12390;
  int D.12391;
  struct _WapiHandle_socket * socket_handle.35;
  int D.12394;
  void * handle;
  int ret;
  struct timeval tv;
  void * tmp_val;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  static const char __func__[17] = "_wapi_getsockopt";

  try
    {
      D.12347 = (long unsigned int) fd;
      handle = (void *) D.12347;
      startup_count.31 = startup_count;
      if (startup_count.31 == 0) goto <D.12349>; else goto <D.12350>;
      <D.12349>:
      WSASetLastError (10093);
      D.12351 = -1;
      return D.12351;
      <D.12350>:
      D.12352 = _wapi_handle_type (handle);
      if (D.12352 != 7) goto <D.12353>; else goto <D.12354>;
      <D.12353>:
      WSASetLastError (10038);
      D.12351 = -1;
      return D.12351;
      <D.12354>:
      tmp_val = optval;
      if (level == 1) goto <D.12355>; else goto <D.12356>;
      <D.12355>:
      optname.32 = (unsigned int) optname;
      D.12358 = optname.32 + 4294967276;
      if (D.12358 <= 1) goto <D.12359>; else goto <D.12360>;
      <D.12359>:
      tmp_val = &tv;
      *optlen = 16;
      <D.12360>:
      <D.12356>:
      fd.33 = (int) fd;
      ret = getsockopt (fd.33, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.12362>; else goto <D.12363>;
      <D.12362>:
      {
        gint errnum;

        D.12364 = __errno_location ();
        errnum = *D.12364;
        errnum.34 = (unsigned int) errnum;
        D.12366 = errno_to_WSA (errnum.34, &__func__);
        errnum = (gint) D.12366;
        WSASetLastError (errnum);
        D.12351 = -1;
        return D.12351;
      }
      <D.12363>:
      if (level == 1) goto <D.12367>; else goto <D.12368>;
      <D.12367>:
      optname.32 = (unsigned int) optname;
      D.12358 = optname.32 + 4294967276;
      if (D.12358 <= 1) goto <D.12369>; else goto <D.12370>;
      <D.12369>:
      D.12371 = tv.tv_sec;
      D.12372 = (unsigned int) D.12371;
      D.12373 = D.12372 * 1000;
      D.12374 = tv.tv_usec;
      D.12375 = D.12374 / 1000;
      D.12376 = (unsigned int) D.12375;
      D.12377 = D.12373 + D.12376;
      D.12378 = (int) D.12377;
      MEM[(int *)optval] = D.12378;
      *optlen = 4;
      <D.12370>:
      <D.12368>:
      if (optname == 4) goto <D.12379>; else goto <D.12380>;
      <D.12379>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12381>; else goto <D.12382>;
      <D.12381>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      D.12383 = MEM[(int *)optval];
      D.12384 = (unsigned int) D.12383;
      D.12385 = errno_to_WSA (D.12384, &__func__);
      D.12386 = (int) D.12385;
      MEM[(int *)optval] = D.12386;
      goto <D.12387>;
      <D.12382>:
      D.12383 = MEM[(int *)optval];
      if (D.12383 != 0) goto <D.12388>; else goto <D.12389>;
      <D.12388>:
      D.12383 = MEM[(int *)optval];
      D.12384 = (unsigned int) D.12383;
      D.12390 = errno_to_WSA (D.12384, &__func__);
      D.12391 = (int) D.12390;
      MEM[(int *)optval] = D.12391;
      socket_handle.35 = socket_handle;
      D.12383 = MEM[(int *)optval];
      socket_handle.35->saved_error = D.12383;
      goto <D.12393>;
      <D.12389>:
      socket_handle.35 = socket_handle;
      D.12394 = socket_handle.35->saved_error;
      MEM[(int *)optval] = D.12394;
      <D.12393>:
      <D.12387>:
      <D.12380>:
      D.12351 = ret;
      return D.12351;
    }
  finally
    {
      tv = {CLOBBER};
      socket_handle = {CLOBBER};
    }
}


_wapi_listen (guint32 fd, int backlog)
{
  long unsigned int D.12397;
  unsigned int startup_count.36;
  int D.12401;
  <unnamed type> D.12402;
  int fd.37;
  int * D.12408;
  unsigned int errnum.38;
  unsigned int D.12410;
  void * handle;
  int ret;
  static const char __func__[13] = "_wapi_listen";

  D.12397 = (long unsigned int) fd;
  handle = (void *) D.12397;
  startup_count.36 = startup_count;
  if (startup_count.36 == 0) goto <D.12399>; else goto <D.12400>;
  <D.12399>:
  WSASetLastError (10093);
  D.12401 = -1;
  return D.12401;
  <D.12400>:
  D.12402 = _wapi_handle_type (handle);
  if (D.12402 != 7) goto <D.12403>; else goto <D.12404>;
  <D.12403>:
  WSASetLastError (10038);
  D.12401 = -1;
  return D.12401;
  <D.12404>:
  fd.37 = (int) fd;
  ret = listen (fd.37, backlog);
  if (ret == -1) goto <D.12406>; else goto <D.12407>;
  <D.12406>:
  {
    gint errnum;

    D.12408 = __errno_location ();
    errnum = *D.12408;
    errnum.38 = (unsigned int) errnum;
    D.12410 = errno_to_WSA (errnum.38, &__func__);
    errnum = (gint) D.12410;
    WSASetLastError (errnum);
    D.12401 = -1;
    return D.12401;
  }
  <D.12407>:
  D.12401 = 0;
  return D.12401;
}


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

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


_wapi_recvfrom (guint32 fd, void * buf, size_t len, int recv_flags, struct sockaddr * from, socklen_t * fromlen)
{
  long unsigned int D.12414;
  unsigned int startup_count.39;
  int D.12418;
  <unnamed type> D.12419;
  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.12422;
  int fd.40;
  long int D.12424;
  int * D.12426;
  int D.12427;
  int D.12429;
  _Bool D.12430;
  _Bool D.12431;
  _Bool D.12432;
  struct _WapiHandle_socket * socket_handle.41;
  int D.12439;
  unsigned int errnum.42;
  unsigned int D.12443;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  int ret;
  static const char __func__[15] = "_wapi_recvfrom";

  try
    {
      D.12414 = (long unsigned int) fd;
      handle = (void *) D.12414;
      startup_count.39 = startup_count;
      if (startup_count.39 == 0) goto <D.12416>; else goto <D.12417>;
      <D.12416>:
      WSASetLastError (10093);
      D.12418 = -1;
      return D.12418;
      <D.12417>:
      D.12419 = _wapi_handle_type (handle);
      if (D.12419 != 7) goto <D.12420>; else goto <D.12421>;
      <D.12420>:
      WSASetLastError (10038);
      D.12418 = -1;
      return D.12418;
      <D.12421>:
      <D.11859>:
      D.12422.__sockaddr__ = from;
      fd.40 = (int) fd;
      D.12424 = recvfrom (fd.40, buf, len, recv_flags, D.12422, fromlen);
      ret = (int) D.12424;
      if (ret == -1) goto <D.12425>; else goto <D.11860>;
      <D.12425>:
      D.12426 = __errno_location ();
      D.12427 = *D.12426;
      if (D.12427 == 4) goto <D.12428>; else goto <D.11860>;
      <D.12428>:
      D.12429 = _wapi_thread_cur_apc_pending ();
      if (D.12429 == 0) goto <D.11859>; else goto <D.11860>;
      <D.11860>:
      D.12430 = ret == 0;
      D.12431 = len != 0;
      D.12432 = D.12430 & D.12431;
      if (D.12432 != 0) goto <D.12433>; else goto <D.12434>;
      <D.12433>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12435>; else goto <D.12437>;
      <D.12437>:
      socket_handle.41 = socket_handle;
      D.12439 = socket_handle.41->still_readable;
      if (D.12439 != 1) goto <D.12435>; else goto <D.12436>;
      <D.12435>:
      ret = -1;
      D.12426 = __errno_location ();
      *D.12426 = 4;
      <D.12436>:
      <D.12434>:
      if (ret == -1) goto <D.12440>; else goto <D.12441>;
      <D.12440>:
      {
        gint errnum;

        D.12426 = __errno_location ();
        errnum = *D.12426;
        errnum.42 = (unsigned int) errnum;
        D.12443 = errno_to_WSA (errnum.42, &__func__);
        errnum = (gint) D.12443;
        WSASetLastError (errnum);
        D.12418 = -1;
        return D.12418;
      }
      <D.12441>:
      D.12418 = ret;
      return D.12418;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


recvfrom (int __fd, void * restrict __buf, size_t __n, int __flags, union __SOCKADDR_ARG __addr, socklen_t * restrict __addr_len)
{
  long unsigned int D.12446;
  int D.12449;
  ssize_t D.12452;
  long unsigned int D.12453;
  long unsigned int D.12454;
  long unsigned int D.12457;

  D.12446 = __builtin_object_size (__buf, 0);
  if (D.12446 != 18446744073709551615) goto <D.12447>; else goto <D.12448>;
  <D.12447>:
  D.12449 = __builtin_constant_p (__n);
  if (D.12449 == 0) goto <D.12450>; else goto <D.12451>;
  <D.12450>:
  D.12453 = __builtin_object_size (__buf, 0);
  D.12452 = __recvfrom_chk (__fd, __buf, __n, D.12453, __flags, __addr, __addr_len);
  return D.12452;
  <D.12451>:
  D.12454 = __builtin_object_size (__buf, 0);
  if (D.12454 < __n) goto <D.12455>; else goto <D.12456>;
  <D.12455>:
  D.12457 = __builtin_object_size (__buf, 0);
  D.12452 = __recvfrom_chk_warn (__fd, __buf, __n, D.12457, __flags, __addr, __addr_len);
  return D.12452;
  <D.12456>:
  <D.12448>:
  D.12452 = __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
  return D.12452;
}


_wapi_send (guint32 fd, const void * msg, size_t len, int send_flags)
{
  long unsigned int D.12459;
  unsigned int startup_count.43;
  int D.12463;
  <unnamed type> D.12464;
  int fd.44;
  long int D.12468;
  int * D.12470;
  int D.12471;
  int D.12473;
  int D.12480;
  unsigned int errnum.45;
  unsigned int D.12484;
  void * handle;
  int ret;
  static const char __func__[11] = "_wapi_send";

  D.12459 = (long unsigned int) fd;
  handle = (void *) D.12459;
  startup_count.43 = startup_count;
  if (startup_count.43 == 0) goto <D.12461>; else goto <D.12462>;
  <D.12461>:
  WSASetLastError (10093);
  D.12463 = -1;
  return D.12463;
  <D.12462>:
  D.12464 = _wapi_handle_type (handle);
  if (D.12464 != 7) goto <D.12465>; else goto <D.12466>;
  <D.12465>:
  WSASetLastError (10038);
  D.12463 = -1;
  return D.12463;
  <D.12466>:
  <D.11884>:
  fd.44 = (int) fd;
  D.12468 = send (fd.44, msg, len, send_flags);
  ret = (int) D.12468;
  if (ret == -1) goto <D.12469>; else goto <D.11885>;
  <D.12469>:
  D.12470 = __errno_location ();
  D.12471 = *D.12470;
  if (D.12471 == 4) goto <D.12472>; else goto <D.11885>;
  <D.12472>:
  D.12473 = _wapi_thread_cur_apc_pending ();
  if (D.12473 == 0) goto <D.11884>; else goto <D.11885>;
  <D.11885>:
  if (ret == -1) goto <D.12474>; else goto <D.12475>;
  <D.12474>:
  {
    gint errnum;

    D.12470 = __errno_location ();
    errnum = *D.12470;
    if (errnum == 11) goto <D.12476>; else goto <D.12477>;
    <D.12476>:
    fd.44 = (int) fd;
    ret = fcntl (fd.44, 3, 0);
    if (ret != -1) goto <D.12478>; else goto <D.12479>;
    <D.12478>:
    D.12480 = ret & 2048;
    if (D.12480 == 0) goto <D.12481>; else goto <D.12482>;
    <D.12481>:
    errnum = 110;
    <D.12482>:
    <D.12479>:
    <D.12477>:
    errnum.45 = (unsigned int) errnum;
    D.12484 = errno_to_WSA (errnum.45, &__func__);
    errnum = (gint) D.12484;
    WSASetLastError (errnum);
    D.12463 = -1;
    return D.12463;
  }
  <D.12475>:
  D.12463 = ret;
  return D.12463;
}


_wapi_sendto (guint32 fd, const void * msg, size_t len, int send_flags, const struct sockaddr * to, socklen_t tolen)
{
  long unsigned int D.12486;
  unsigned int startup_count.46;
  int D.12490;
  <unnamed type> D.12491;
  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.12494;
  int fd.47;
  long int D.12496;
  int * D.12498;
  int D.12499;
  int D.12501;
  unsigned int errnum.48;
  unsigned int D.12505;
  void * handle;
  int ret;
  static const char __func__[13] = "_wapi_sendto";

  D.12486 = (long unsigned int) fd;
  handle = (void *) D.12486;
  startup_count.46 = startup_count;
  if (startup_count.46 == 0) goto <D.12488>; else goto <D.12489>;
  <D.12488>:
  WSASetLastError (10093);
  D.12490 = -1;
  return D.12490;
  <D.12489>:
  D.12491 = _wapi_handle_type (handle);
  if (D.12491 != 7) goto <D.12492>; else goto <D.12493>;
  <D.12492>:
  WSASetLastError (10038);
  D.12490 = -1;
  return D.12490;
  <D.12493>:
  <D.11898>:
  D.12494.__sockaddr__ = to;
  fd.47 = (int) fd;
  D.12496 = sendto (fd.47, msg, len, send_flags, D.12494, tolen);
  ret = (int) D.12496;
  if (ret == -1) goto <D.12497>; else goto <D.11899>;
  <D.12497>:
  D.12498 = __errno_location ();
  D.12499 = *D.12498;
  if (D.12499 == 4) goto <D.12500>; else goto <D.11899>;
  <D.12500>:
  D.12501 = _wapi_thread_cur_apc_pending ();
  if (D.12501 == 0) goto <D.11898>; else goto <D.11899>;
  <D.11899>:
  if (ret == -1) goto <D.12502>; else goto <D.12503>;
  <D.12502>:
  {
    gint errnum;

    D.12498 = __errno_location ();
    errnum = *D.12498;
    errnum.48 = (unsigned int) errnum;
    D.12505 = errno_to_WSA (errnum.48, &__func__);
    errnum = (gint) D.12505;
    WSASetLastError (errnum);
    D.12490 = -1;
    return D.12490;
  }
  <D.12503>:
  D.12490 = ret;
  return D.12490;
}


_wapi_setsockopt (guint32 fd, int level, int optname, const void * optval, socklen_t optlen)
{
  long unsigned int D.12507;
  unsigned int startup_count.49;
  int D.12511;
  <unnamed type> D.12512;
  unsigned int optname.50;
  unsigned int D.12519;
  int D.12521;
  long int D.12522;
  int D.12523;
  int D.12524;
  long int D.12525;
  unsigned int D.12528;
  int bufsize.51;
  int bufsize.52;
  int bufsize.53;
  int fd.54;
  int * D.12537;
  unsigned int errnum.55;
  unsigned int D.12539;
  _Bool D.12540;
  _Bool D.12541;
  _Bool D.12542;
  int D.12545;
  int type.56;
  void * handle;
  int ret;
  const void * tmp_val;
  int bufsize;
  struct timeval tv;
  static const char __func__[17] = "_wapi_setsockopt";

  try
    {
      D.12507 = (long unsigned int) fd;
      handle = (void *) D.12507;
      bufsize = 0;
      startup_count.49 = startup_count;
      if (startup_count.49 == 0) goto <D.12509>; else goto <D.12510>;
      <D.12509>:
      WSASetLastError (10093);
      D.12511 = -1;
      return D.12511;
      <D.12510>:
      D.12512 = _wapi_handle_type (handle);
      if (D.12512 != 7) goto <D.12513>; else goto <D.12514>;
      <D.12513>:
      WSASetLastError (10038);
      D.12511 = -1;
      return D.12511;
      <D.12514>:
      tmp_val = optval;
      if (level == 1) goto <D.12517>; else goto <D.12515>;
      <D.12517>:
      optname.50 = (unsigned int) optname;
      D.12519 = optname.50 + 4294967276;
      if (D.12519 <= 1) goto <D.12520>; else goto <D.12515>;
      <D.12520>:
      {
        int ms;

        ms = MEM[(int *)optval];
        D.12521 = ms / 1000;
        D.12522 = (long int) D.12521;
        tv.tv_sec = D.12522;
        D.12523 = ms % 1000;
        D.12524 = D.12523 * 1000;
        D.12525 = (long int) D.12524;
        tv.tv_usec = D.12525;
        tmp_val = &tv;
        optlen = 16;
      }
      goto <D.12516>;
      <D.12515>:
      if (level == 1) goto <D.12526>; else goto <D.12527>;
      <D.12526>:
      optname.50 = (unsigned int) optname;
      D.12528 = optname.50 + 4294967289;
      if (D.12528 <= 1) goto <D.12529>; else goto <D.12530>;
      <D.12529>:
      bufsize.51 = MEM[(int *)optval];
      bufsize = bufsize.51;
      bufsize.52 = bufsize;
      bufsize.53 = bufsize.52 / 2;
      bufsize = bufsize.53;
      tmp_val = &bufsize;
      <D.12530>:
      <D.12527>:
      <D.12516>:
      fd.54 = (int) fd;
      ret = setsockopt (fd.54, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.12535>; else goto <D.12536>;
      <D.12535>:
      {
        gint errnum;

        D.12537 = __errno_location ();
        errnum = *D.12537;
        errnum.55 = (unsigned int) errnum;
        D.12539 = errno_to_WSA (errnum.55, &__func__);
        errnum = (gint) D.12539;
        WSASetLastError (errnum);
        D.12511 = -1;
        return D.12511;
      }
      <D.12536>:
      D.12540 = level == 1;
      D.12541 = optname == 2;
      D.12542 = D.12540 & D.12541;
      if (D.12542 != 0) goto <D.12543>; else goto <D.12544>;
      <D.12543>:
      {
        int type;
        socklen_t type_len;

        try
          {
            type_len = 4;
            fd.54 = (int) fd;
            D.12545 = getsockopt (fd.54, level, 3, &type, &type_len);
            if (D.12545 == 0) goto <D.12546>; else goto <D.12547>;
            <D.12546>:
            type.56 = type;
            if (type.56 == 2) goto <D.12549>; else goto <D.12550>;
            <D.12549>:
            fd.54 = (int) fd;
            setsockopt (fd.54, level, 15, tmp_val, optlen);
            <D.12550>:
            <D.12547>:
          }
        finally
          {
            type = {CLOBBER};
            type_len = {CLOBBER};
          }
      }
      <D.12544>:
      D.12511 = ret;
      return D.12511;
    }
  finally
    {
      bufsize = {CLOBBER};
      tv = {CLOBBER};
    }
}


_wapi_shutdown (guint32 fd, int how)
{
  long unsigned int D.12553;
  unsigned int startup_count.57;
  int D.12557;
  <unnamed type> D.12558;
  _Bool D.12561;
  _Bool D.12562;
  _Bool D.12563;
  struct _WapiHandle_socket * socket_handle.58;
  int fd.59;
  int * D.12572;
  unsigned int errnum.60;
  unsigned int D.12574;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  void * handle;
  int ret;
  static const char __func__[15] = "_wapi_shutdown";

  try
    {
      D.12553 = (long unsigned int) fd;
      handle = (void *) D.12553;
      startup_count.57 = startup_count;
      if (startup_count.57 == 0) goto <D.12555>; else goto <D.12556>;
      <D.12555>:
      WSASetLastError (10093);
      D.12557 = -1;
      return D.12557;
      <D.12556>:
      D.12558 = _wapi_handle_type (handle);
      if (D.12558 != 7) goto <D.12559>; else goto <D.12560>;
      <D.12559>:
      WSASetLastError (10038);
      D.12557 = -1;
      return D.12557;
      <D.12560>:
      D.12561 = how == 0;
      D.12562 = how == 2;
      D.12563 = D.12561 | D.12562;
      if (D.12563 != 0) goto <D.12564>; else goto <D.12565>;
      <D.12564>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12566>; else goto <D.12567>;
      <D.12566>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12557 = -1;
      return D.12557;
      <D.12567>:
      socket_handle.58 = socket_handle;
      socket_handle.58->still_readable = 0;
      <D.12565>:
      fd.59 = (int) fd;
      ret = shutdown (fd.59, how);
      if (ret == -1) goto <D.12570>; else goto <D.12571>;
      <D.12570>:
      {
        gint errnum;

        D.12572 = __errno_location ();
        errnum = *D.12572;
        errnum.60 = (unsigned int) errnum;
        D.12574 = errno_to_WSA (errnum.60, &__func__);
        errnum = (gint) D.12574;
        WSASetLastError (errnum);
        D.12557 = -1;
        return D.12557;
      }
      <D.12571>:
      D.12557 = ret;
      return D.12557;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_socket (int domain, int type, int protocol, void * unused, guint32 unused2, guint32 unused3)
{
  _Bool D.12577;
  _Bool D.12578;
  _Bool D.12579;
  _Bool D.12582;
  _Bool D.12583;
  _Bool D.12584;
  int * D.12589;
  unsigned int errnum.61;
  unsigned int D.12591;
  guint32 D.12592;
  unsigned int fd.62;
  unsigned int _wapi_fd_reserve.63;
  unsigned int errnum.64;
  unsigned int D.12600;
  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.12577 = fd == -1;
      D.12578 = domain == 2;
      D.12579 = D.12577 & D.12578;
      if (D.12579 != 0) goto <D.12580>; else goto <D.12581>;
      <D.12580>:
      D.12582 = type == 3;
      D.12583 = protocol == 0;
      D.12584 = D.12582 & D.12583;
      if (D.12584 != 0) goto <D.12585>; else goto <D.12586>;
      <D.12585>:
      socket_handle.protocol = 4;
      fd = socket (2, 3, 4);
      <D.12586>:
      <D.12581>:
      if (fd == -1) goto <D.12587>; else goto <D.12588>;
      <D.12587>:
      {
        gint errnum;

        D.12589 = __errno_location ();
        errnum = *D.12589;
        errnum.61 = (unsigned int) errnum;
        D.12591 = errno_to_WSA (errnum.61, &__func__);
        errnum = (gint) D.12591;
        WSASetLastError (errnum);
        D.12592 = 4294967295;
        return D.12592;
      }
      <D.12588>:
      fd.62 = (unsigned int) fd;
      _wapi_fd_reserve.63 = _wapi_fd_reserve;
      if (fd.62 >= _wapi_fd_reserve.63) goto <D.12595>; else goto <D.12596>;
      <D.12595>:
      WSASetLastError (10107);
      close (fd);
      D.12592 = 4294967295;
      return D.12592;
      <D.12596>:
      {
        int ret;
        int true;

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

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


socket_ops_init ()
{

}


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

  startup_count.65 = startup_count;
  if (startup_count.65 == 0) goto <D.12608>; else goto <D.12609>;
  <D.12608>:
  WSASetLastError (10093);
  D.12610 = 0B;
  return D.12610;
  <D.12609>:
  he = gethostbyname (hostname);
  if (he == 0B) goto <D.12611>; else goto <D.12612>;
  <D.12611>:
  D.12613 = __h_errno_location ();
  D.12614 = *D.12613;
  switch (D.12614) <default: <D.11965>, case 1: <D.11960>, case 2: <D.11964>, case 3: <D.11963>, case 4: <D.11962>>
  <D.11960>:
  WSASetLastError (11001);
  goto <D.11961>;
  <D.11962>:
  WSASetLastError (11004);
  goto <D.11961>;
  <D.11963>:
  WSASetLastError (11003);
  goto <D.11961>;
  <D.11964>:
  WSASetLastError (11002);
  goto <D.11961>;
  <D.11965>:
  D.12613 = __h_errno_location ();
  D.12614 = *D.12613;
  monoeg_g_log (0B, 16, "%s: Need to translate %d into winsock error", &__func__, D.12614);
  goto <D.11961>;
  <D.11961>:
  <D.12612>:
  D.12610 = he;
  return D.12610;
}


TransmitFile (guint32 socket, void * file, guint32 bytes_to_write, guint32 bytes_per_send, struct WapiOverlapped * ol, struct WapiTransmitFileBuffers * buffers, guint32 flags)
{
  long unsigned int D.12616;
  unsigned int startup_count.66;
  gboolean D.12620;
  <unnamed type> D.12621;
  void * D.12626;
  unsigned int D.12629;
  long unsigned int D.12632;
  void * D.12639;
  unsigned int D.12642;
  long unsigned int D.12645;
  unsigned int D.12648;
  void * sock;
  gint ret;

  D.12616 = (long unsigned int) socket;
  sock = (void *) D.12616;
  startup_count.66 = startup_count;
  if (startup_count.66 == 0) goto <D.12618>; else goto <D.12619>;
  <D.12618>:
  WSASetLastError (10093);
  D.12620 = 0;
  return D.12620;
  <D.12619>:
  D.12621 = _wapi_handle_type (sock);
  if (D.12621 != 7) goto <D.12622>; else goto <D.12623>;
  <D.12622>:
  WSASetLastError (10038);
  D.12620 = 0;
  return D.12620;
  <D.12623>:
  if (buffers != 0B) goto <D.12624>; else goto <D.12625>;
  <D.12624>:
  D.12626 = buffers->Head;
  if (D.12626 != 0B) goto <D.12627>; else goto <D.12628>;
  <D.12627>:
  D.12629 = buffers->HeadLength;
  if (D.12629 != 0) goto <D.12630>; else goto <D.12631>;
  <D.12630>:
  D.12629 = buffers->HeadLength;
  D.12632 = (long unsigned int) D.12629;
  D.12626 = buffers->Head;
  ret = _wapi_send (socket, D.12626, D.12632, 0);
  if (ret == -1) goto <D.12633>; else goto <D.12634>;
  <D.12633>:
  D.12620 = 0;
  return D.12620;
  <D.12634>:
  <D.12631>:
  <D.12628>:
  <D.12625>:
  ret = wapi_sendfile (socket, file, bytes_to_write, bytes_per_send, flags);
  if (ret == -1) goto <D.12635>; else goto <D.12636>;
  <D.12635>:
  D.12620 = 0;
  return D.12620;
  <D.12636>:
  if (buffers != 0B) goto <D.12637>; else goto <D.12638>;
  <D.12637>:
  D.12639 = buffers->Tail;
  if (D.12639 != 0B) goto <D.12640>; else goto <D.12641>;
  <D.12640>:
  D.12642 = buffers->TailLength;
  if (D.12642 != 0) goto <D.12643>; else goto <D.12644>;
  <D.12643>:
  D.12642 = buffers->TailLength;
  D.12645 = (long unsigned int) D.12642;
  D.12639 = buffers->Tail;
  ret = _wapi_send (socket, D.12639, D.12645, 0);
  if (ret == -1) goto <D.12646>; else goto <D.12647>;
  <D.12646>:
  D.12620 = 0;
  return D.12620;
  <D.12647>:
  <D.12644>:
  <D.12641>:
  <D.12638>:
  D.12648 = flags & 1;
  if (D.12648 != 0) goto <D.12649>; else goto <D.12650>;
  <D.12649>:
  closesocket (socket);
  <D.12650>:
  D.12620 = 1;
  return D.12620;
}


wapi_sendfile (guint32 socket, void * fd, guint32 bytes_to_write, guint32 bytes_per_send, guint32 flags)
{
  long int fd.67;
  int * D.12655;
  unsigned int errnum.68;
  unsigned int D.12657;
  gint D.12658;
  long int D.12659;
  long unsigned int D.12660;
  int socket.69;
  int D.12663;
  _Bool D.12664;
  _Bool D.12665;
  _Bool D.12666;
  int D.12668;
  unsigned int D.12671;
  gint file;
  gint n;
  gint errnum;
  gssize res;
  struct stat statbuf;
  static const char __func__[14] = "wapi_sendfile";

  try
    {
      fd.67 = (long int) fd;
      file = (gint) fd.67;
      n = fstat (file, &statbuf);
      if (n == -1) goto <D.12653>; else goto <D.12654>;
      <D.12653>:
      D.12655 = __errno_location ();
      errnum = *D.12655;
      errnum.68 = (unsigned int) errnum;
      D.12657 = errno_to_WSA (errnum.68, &__func__);
      errnum = (gint) D.12657;
      WSASetLastError (errnum);
      D.12658 = -1;
      return D.12658;
      <D.12654>:
      <D.11999>:
      D.12659 = statbuf.st_size;
      D.12660 = (long unsigned int) D.12659;
      socket.69 = (int) socket;
      res = sendfile (socket.69, file, 0B, D.12660);
      if (res != -1) goto <D.12662>; else goto <D.12000>;
      <D.12662>:
      D.12655 = __errno_location ();
      D.12663 = *D.12655;
      D.12664 = D.12663 == 4;
      D.12665 = D.12663 == 11;
      D.12666 = D.12664 | D.12665;
      if (D.12666 != 0) goto <D.12667>; else goto <D.12000>;
      <D.12667>:
      D.12668 = _wapi_thread_cur_apc_pending ();
      if (D.12668 == 0) goto <D.11999>; else goto <D.12000>;
      <D.12000>:
      if (res == -1) goto <D.12669>; else goto <D.12670>;
      <D.12669>:
      D.12655 = __errno_location ();
      errnum = *D.12655;
      errnum.68 = (unsigned int) errnum;
      D.12671 = errno_to_WSA (errnum.68, &__func__);
      errnum = (gint) D.12671;
      WSASetLastError (errnum);
      D.12658 = -1;
      return D.12658;
      <D.12670>:
      D.12658 = 0;
      return D.12658;
    }
  finally
    {
      statbuf = {CLOBBER};
    }
}


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

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


WSAIoctl (guint32 fd, gint32 command, gchar * input, gint i_len, gchar * output, gint o_len, glong * written, void * unused1, void * unused2)
{
  long unsigned int D.12676;
  unsigned int startup_count.70;
  int D.12680;
  <unnamed type> D.12681;
  unsigned int i_len.71;
  unsigned int o_len.72;
  struct WapiGuid * D.12694;
  int D.12695;
  void * * D.12698;
  void * D.12699;
  gchar * D.12704;
  gchar * D.12705;
  int fd.73;
  int * D.12709;
  unsigned int errnum.74;
  unsigned int D.12711;
  unsigned int onoff.75;
  unsigned int keepalivetime.76;
  unsigned int keepalivetime.77;
  unsigned int keepalivetime.78;
  unsigned int keepaliveinterval.79;
  unsigned int keepaliveinterval.80;
  unsigned int keepaliveinterval.81;
  unsigned int errnum.82;
  unsigned int D.12732;
  unsigned int i_len.83;
  long unsigned int D.12736;
  unsigned int errnum.84;
  unsigned int D.12740;
  _Bool D.12744;
  _Bool D.12745;
  _Bool D.12746;
  long unsigned int D.12749;
  long int D.12750;
  void * handle;
  int ret;
  gchar * buffer;
  static const char __func__[9] = "WSAIoctl";

  D.12676 = (long unsigned int) fd;
  handle = (void *) D.12676;
  buffer = 0B;
  startup_count.70 = startup_count;
  if (startup_count.70 == 0) goto <D.12678>; else goto <D.12679>;
  <D.12678>:
  WSASetLastError (10093);
  D.12680 = -1;
  return D.12680;
  <D.12679>:
  D.12681 = _wapi_handle_type (handle);
  if (D.12681 != 7) goto <D.12682>; else goto <D.12683>;
  <D.12682>:
  WSASetLastError (10038);
  D.12680 = -1;
  return D.12680;
  <D.12683>:
  if (command == -939524090) goto <D.12684>; else goto <D.12685>;
  <D.12684>:
  {
    int i;
    struct WapiGuid * guid;

    i = 0;
    guid = input;
    i_len.71 = (unsigned int) i_len;
    if (i_len.71 <= 15) goto <D.12687>; else goto <D.12688>;
    <D.12687>:
    WSASetLastError (10022);
    D.12680 = -1;
    return D.12680;
    <D.12688>:
    o_len.72 = (unsigned int) o_len;
    if (o_len.72 <= 7) goto <D.12690>; else goto <D.12691>;
    <D.12690>:
    WSASetLastError (10022);
    D.12680 = -1;
    return D.12680;
    <D.12691>:
    if (output == 0B) goto <D.12692>; else goto <D.12693>;
    <D.12692>:
    WSASetLastError (10022);
    D.12680 = -1;
    return D.12680;
    <D.12693>:
    goto <D.12033>;
    <D.12032>:
    D.12694 = &extension_functions[i].guid;
    D.12695 = memcmp (guid, D.12694, 16);
    if (D.12695 == 0) goto <D.12696>; else goto <D.12697>;
    <D.12696>:
    D.12698 = &extension_functions[i].func;
    memcpy (output, D.12698, 8);
    *written = 8;
    D.12680 = 0;
    return D.12680;
    <D.12697>:
    i = i + 1;
    <D.12033>:
    D.12699 = extension_functions[i].func;
    if (D.12699 != 0B) goto <D.12032>; else goto <D.12034>;
    <D.12034>:
    WSASetLastError (10022);
    D.12680 = -1;
    return D.12680;
  }
  <D.12685>:
  if (command == -1744830460) goto <D.12700>; else goto <D.12701>;
  <D.12700>:
  {
    uint32_t onoff;
    uint32_t keepalivetime;
    uint32_t keepaliveinterval;

    try
      {
        i_len.71 = (unsigned int) i_len;
        if (i_len.71 <= 11) goto <D.12702>; else goto <D.12703>;
        <D.12702>:
        WSASetLastError (10022);
        D.12680 = -1;
        return D.12680;
        <D.12703>:
        memcpy (&onoff, input, 4);
        D.12704 = input + 4;
        memcpy (&keepalivetime, D.12704, 4);
        D.12705 = input + 8;
        memcpy (&keepaliveinterval, D.12705, 4);
        fd.73 = (int) fd;
        ret = setsockopt (fd.73, 1, 9, &onoff, 4);
        if (ret < 0) goto <D.12707>; else goto <D.12708>;
        <D.12707>:
        {
          gint errnum;

          D.12709 = __errno_location ();
          errnum = *D.12709;
          errnum.74 = (unsigned int) errnum;
          D.12711 = errno_to_WSA (errnum.74, &__func__);
          errnum = (gint) D.12711;
          WSASetLastError (errnum);
          D.12680 = -1;
          return D.12680;
        }
        <D.12708>:
        onoff.75 = onoff;
        if (onoff.75 != 0) goto <D.12713>; else goto <D.12714>;
        <D.12713>:
        {
          uint32_t rem;

          keepalivetime.76 = keepalivetime;
          rem = keepalivetime.76 % 1000;
          keepalivetime.76 = keepalivetime;
          keepalivetime.77 = keepalivetime.76 / 1000;
          keepalivetime = keepalivetime.77;
          keepalivetime.76 = keepalivetime;
          if (keepalivetime.76 == 0) goto <D.12717>; else goto <D.12719>;
          <D.12719>:
          if (rem > 499) goto <D.12717>; else goto <D.12718>;
          <D.12717>:
          keepalivetime.76 = keepalivetime;
          keepalivetime.78 = keepalivetime.76 + 1;
          keepalivetime = keepalivetime.78;
          <D.12718>:
          fd.73 = (int) fd;
          ret = setsockopt (fd.73, 6, 4, &keepalivetime, 4);
          if (ret == 0) goto <D.12721>; else goto <D.12722>;
          <D.12721>:
          keepaliveinterval.79 = keepaliveinterval;
          rem = keepaliveinterval.79 % 1000;
          keepaliveinterval.79 = keepaliveinterval;
          keepaliveinterval.80 = keepaliveinterval.79 / 1000;
          keepaliveinterval = keepaliveinterval.80;
          keepaliveinterval.79 = keepaliveinterval;
          if (keepaliveinterval.79 == 0) goto <D.12725>; else goto <D.12727>;
          <D.12727>:
          if (rem > 499) goto <D.12725>; else goto <D.12726>;
          <D.12725>:
          keepaliveinterval.79 = keepaliveinterval;
          keepaliveinterval.81 = keepaliveinterval.79 + 1;
          keepaliveinterval = keepaliveinterval.81;
          <D.12726>:
          fd.73 = (int) fd;
          ret = setsockopt (fd.73, 6, 5, &keepaliveinterval, 4);
          <D.12722>:
          if (ret != 0) goto <D.12729>; else goto <D.12730>;
          <D.12729>:
          {
            gint errnum;

            D.12709 = __errno_location ();
            errnum = *D.12709;
            errnum.82 = (unsigned int) errnum;
            D.12732 = errno_to_WSA (errnum.82, &__func__);
            errnum = (gint) D.12732;
            WSASetLastError (errnum);
            D.12680 = -1;
            return D.12680;
          }
          <D.12730>:
          D.12680 = 0;
          return D.12680;
        }
        <D.12714>:
        D.12680 = 0;
        return D.12680;
      }
    finally
      {
        onoff = {CLOBBER};
        keepalivetime = {CLOBBER};
        keepaliveinterval = {CLOBBER};
      }
  }
  <D.12701>:
  if (i_len > 0) goto <D.12733>; else goto <D.12734>;
  <D.12733>:
  i_len.83 = (unsigned int) i_len;
  buffer = monoeg_g_memdup (input, i_len.83);
  <D.12734>:
  D.12736 = (long unsigned int) command;
  fd.73 = (int) fd;
  ret = ioctl (fd.73, D.12736, buffer);
  if (ret == -1) goto <D.12737>; else goto <D.12738>;
  <D.12737>:
  {
    gint errnum;

    D.12709 = __errno_location ();
    errnum = *D.12709;
    errnum.84 = (unsigned int) errnum;
    D.12740 = errno_to_WSA (errnum.84, &__func__);
    errnum = (gint) D.12740;
    WSASetLastError (errnum);
    monoeg_g_free (buffer);
    D.12680 = -1;
    return D.12680;
  }
  <D.12738>:
  if (buffer == 0B) goto <D.12741>; else goto <D.12742>;
  <D.12741>:
  *written = 0;
  goto <D.12743>;
  <D.12742>:
  i_len = MIN_EXPR <i_len, o_len>;
  D.12744 = i_len > 0;
  D.12745 = output != 0B;
  D.12746 = D.12744 & D.12745;
  if (D.12746 != 0) goto <D.12747>; else goto <D.12748>;
  <D.12747>:
  D.12749 = (long unsigned int) i_len;
  memcpy (output, buffer, D.12749);
  <D.12748>:
  monoeg_g_free (buffer);
  D.12750 = (long int) i_len;
  *written = D.12750;
  <D.12743>:
  D.12680 = 0;
  return D.12680;
}


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

  if (reserved != 0) goto <D.12753>; else goto <D.12754>;
  <D.12753>:
  WSASetLastError (10022);
  D.12755 = 0;
  return D.12755;
  <D.12754>:
  D.12755 = socket_disconnect (fd);
  return D.12755;
}


socket_disconnect (guint32 fd)
{
  long unsigned int D.12757;
  gboolean D.12760;
  struct _WapiHandle_socket * socket_handle.85;
  int D.12762;
  int D.12763;
  int D.12764;
  int * D.12767;
  unsigned int errnum.86;
  unsigned int D.12769;
  int fd.87;
  int D.12772;
  unsigned int errnum.88;
  unsigned int D.12776;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  void * handle;
  int newsock;
  int ret;
  static const char __func__[18] = "socket_disconnect";

  try
    {
      D.12757 = (long unsigned int) fd;
      handle = (void *) D.12757;
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12758>; else goto <D.12759>;
      <D.12758>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12760 = 0;
      return D.12760;
      <D.12759>:
      socket_handle.85 = socket_handle;
      D.12762 = socket_handle.85->protocol;
      socket_handle.85 = socket_handle;
      D.12763 = socket_handle.85->type;
      socket_handle.85 = socket_handle;
      D.12764 = socket_handle.85->domain;
      newsock = socket (D.12764, D.12763, D.12762);
      if (newsock == -1) goto <D.12765>; else goto <D.12766>;
      <D.12765>:
      {
        gint errnum;

        D.12767 = __errno_location ();
        errnum = *D.12767;
        errnum.86 = (unsigned int) errnum;
        D.12769 = errno_to_WSA (errnum.86, &__func__);
        errnum = (gint) D.12769;
        WSASetLastError (errnum);
        D.12760 = 0;
        return D.12760;
      }
      <D.12766>:
      <D.11977>:
      fd.87 = (int) fd;
      ret = dup2 (newsock, fd.87);
      if (ret == -1) goto <D.12771>; else goto <D.11978>;
      <D.12771>:
      D.12767 = __errno_location ();
      D.12772 = *D.12767;
      if (D.12772 == 11) goto <D.11977>; else goto <D.11978>;
      <D.11978>:
      if (ret == -1) goto <D.12773>; else goto <D.12774>;
      <D.12773>:
      {
        gint errnum;

        D.12767 = __errno_location ();
        errnum = *D.12767;
        errnum.88 = (unsigned int) errnum;
        D.12776 = errno_to_WSA (errnum.88, &__func__);
        errnum = (gint) D.12776;
        WSASetLastError (errnum);
        D.12760 = 0;
        return D.12760;
      }
      <D.12774>:
      close (newsock);
      D.12760 = 1;
      return D.12760;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


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

  D.12780 = __builtin_object_size (__dest, 0);
  D.12779 = __builtin___memcpy_chk (__dest, __src, __len, D.12780);
  return D.12779;
}


ioctlsocket (guint32 fd, gint32 command, void * arg)
{
  long unsigned int D.12782;
  unsigned int startup_count.89;
  int D.12786;
  <unnamed type> D.12787;
  int fd.90;
  int D.12793;
  long unsigned int D.12797;
  int * D.12800;
  unsigned int errnum.91;
  unsigned int D.12802;
  void * handle;
  int ret;
  static const char __func__[12] = "ioctlsocket";

  D.12782 = (long unsigned int) fd;
  handle = (void *) D.12782;
  startup_count.89 = startup_count;
  if (startup_count.89 == 0) goto <D.12784>; else goto <D.12785>;
  <D.12784>:
  WSASetLastError (10093);
  D.12786 = -1;
  return D.12786;
  <D.12785>:
  D.12787 = _wapi_handle_type (handle);
  if (D.12787 != 7) goto <D.12788>; else goto <D.12789>;
  <D.12788>:
  WSASetLastError (10038);
  D.12786 = -1;
  return D.12786;
  <D.12789>:
  switch (command) <default: <D.12054>, case 21531: <D.12053>, case 21537: <D.12050>, case 35077: <D.12052>>
  <D.12050>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 3, 0);
  if (ret != -1) goto <D.12791>; else goto <D.12792>;
  <D.12791>:
  D.12793 = MEM[(gboolean *)arg];
  if (D.12793 != 0) goto <D.12794>; else goto <D.12795>;
  <D.12794>:
  ret = ret | 2048;
  goto <D.12796>;
  <D.12795>:
  ret = ret & -2049;
  <D.12796>:
  fd.90 = (int) fd;
  ret = fcntl (fd.90, 4, ret);
  <D.12792>:
  goto <D.12051>;
  <D.12052>:
  D.12797 = (long unsigned int) command;
  fd.90 = (int) fd;
  ret = ioctl (fd.90, D.12797, arg);
  goto <D.12051>;
  <D.12053>:
  D.12797 = (long unsigned int) command;
  fd.90 = (int) fd;
  ret = ioctl (fd.90, D.12797, arg);
  goto <D.12051>;
  <D.12054>:
  WSASetLastError (10022);
  D.12786 = -1;
  return D.12786;
  <D.12051>:
  if (ret == -1) goto <D.12798>; else goto <D.12799>;
  <D.12798>:
  {
    gint errnum;

    D.12800 = __errno_location ();
    errnum = *D.12800;
    errnum.91 = (unsigned int) errnum;
    D.12802 = errno_to_WSA (errnum.91, &__func__);
    errnum = (gint) D.12802;
    WSASetLastError (errnum);
    D.12786 = -1;
    return D.12786;
  }
  <D.12799>:
  D.12786 = 0;
  return D.12786;
}


_wapi_select (int nfds, struct fd_set * readfds, struct fd_set * writefds, struct fd_set * exceptfds, struct timeval * timeout)
{
  unsigned int startup_count.92;
  int D.12807;
  long int D.12067;
  long int iftmp.93;
  int D.12813;
  long int iftmp.94;
  unsigned long __d.95;
  long int D.12822;
  int D.12823;
  long int D.12824;
  long int D.12825;
  long int D.12069;
  long int iftmp.96;
  int D.12828;
  long int iftmp.97;
  unsigned long __d.98;
  long int D.12837;
  long int D.12838;
  long int D.12839;
  long int D.12071;
  long int iftmp.99;
  int D.12842;
  long int iftmp.100;
  unsigned long __d.101;
  long int D.12851;
  long int D.12852;
  long int D.12853;
  int D.12856;
  int * D.12858;
  int D.12859;
  int D.12861;
  unsigned int errnum.102;
  unsigned int D.12865;
  int ret;
  int maxfd;
  static const char __func__[13] = "_wapi_select";

  startup_count.92 = startup_count;
  if (startup_count.92 == 0) goto <D.12805>; else goto <D.12806>;
  <D.12805>:
  WSASetLastError (10093);
  D.12807 = -1;
  return D.12807;
  <D.12806>:
  maxfd = 1023;
  goto <D.12074>;
  <D.12073>:
  if (readfds != 0B) goto <D.12811>; else goto <D.12808>;
  <D.12811>:
  {
    long int __d;

    __d = (long int) maxfd;
    D.12813 = __builtin_constant_p (__d);
    if (D.12813 != 0) goto <D.12814>; else goto <D.12815>;
    <D.12814>:
    __d.95 = (unsigned long) __d;
    if (__d.95 <= 1023) goto <D.12818>; else goto <D.12819>;
    <D.12818>:
    iftmp.94 = __d / 64;
    goto <D.12820>;
    <D.12819>:
    iftmp.94 = __fdelt_warn (__d);
    <D.12820>:
    iftmp.93 = iftmp.94;
    goto <D.12821>;
    <D.12815>:
    iftmp.93 = __fdelt_chk (__d);
    <D.12821>:
    D.12067 = iftmp.93;
  }
  D.12822 = readfds->fds_bits[D.12067];
  D.12823 = maxfd % 64;
  D.12824 = D.12822 >> D.12823;
  D.12825 = D.12824 & 1;
  if (D.12825 != 0) goto <D.12072>; else goto <D.12808>;
  <D.12808>:
  if (writefds != 0B) goto <D.12826>; else goto <D.12809>;
  <D.12826>:
  {
    long int __d;

    __d = (long int) maxfd;
    D.12828 = __builtin_constant_p (__d);
    if (D.12828 != 0) goto <D.12829>; else goto <D.12830>;
    <D.12829>:
    __d.98 = (unsigned long) __d;
    if (__d.98 <= 1023) goto <D.12833>; else goto <D.12834>;
    <D.12833>:
    iftmp.97 = __d / 64;
    goto <D.12835>;
    <D.12834>:
    iftmp.97 = __fdelt_warn (__d);
    <D.12835>:
    iftmp.96 = iftmp.97;
    goto <D.12836>;
    <D.12830>:
    iftmp.96 = __fdelt_chk (__d);
    <D.12836>:
    D.12069 = iftmp.96;
  }
  D.12837 = writefds->fds_bits[D.12069];
  D.12823 = maxfd % 64;
  D.12838 = D.12837 >> D.12823;
  D.12839 = D.12838 & 1;
  if (D.12839 != 0) goto <D.12072>; else goto <D.12809>;
  <D.12809>:
  if (exceptfds != 0B) goto <D.12840>; else goto <D.12810>;
  <D.12840>:
  {
    long int __d;

    __d = (long int) maxfd;
    D.12842 = __builtin_constant_p (__d);
    if (D.12842 != 0) goto <D.12843>; else goto <D.12844>;
    <D.12843>:
    __d.101 = (unsigned long) __d;
    if (__d.101 <= 1023) goto <D.12847>; else goto <D.12848>;
    <D.12847>:
    iftmp.100 = __d / 64;
    goto <D.12849>;
    <D.12848>:
    iftmp.100 = __fdelt_warn (__d);
    <D.12849>:
    iftmp.99 = iftmp.100;
    goto <D.12850>;
    <D.12844>:
    iftmp.99 = __fdelt_chk (__d);
    <D.12850>:
    D.12071 = iftmp.99;
  }
  D.12851 = exceptfds->fds_bits[D.12071];
  D.12823 = maxfd % 64;
  D.12852 = D.12851 >> D.12823;
  D.12853 = D.12852 & 1;
  if (D.12853 != 0) goto <D.12072>; else goto <D.12810>;
  <D.12810>:
  maxfd = maxfd + -1;
  <D.12074>:
  if (maxfd >= 0) goto <D.12073>; else goto <D.12072>;
  <D.12072>:
  if (maxfd == -1) goto <D.12854>; else goto <D.12855>;
  <D.12854>:
  WSASetLastError (10022);
  D.12807 = -1;
  return D.12807;
  <D.12855>:
  <D.12075>:
  D.12856 = maxfd + 1;
  ret = select (D.12856, readfds, writefds, exceptfds, timeout);
  if (ret == -1) goto <D.12857>; else goto <D.12076>;
  <D.12857>:
  D.12858 = __errno_location ();
  D.12859 = *D.12858;
  if (D.12859 == 4) goto <D.12860>; else goto <D.12076>;
  <D.12860>:
  D.12861 = _wapi_thread_cur_apc_pending ();
  if (D.12861 == 0) goto <D.12075>; else goto <D.12076>;
  <D.12076>:
  if (ret == -1) goto <D.12862>; else goto <D.12863>;
  <D.12862>:
  {
    gint errnum;

    D.12858 = __errno_location ();
    errnum = *D.12858;
    errnum.102 = (unsigned int) errnum;
    D.12865 = errno_to_WSA (errnum.102, &__func__);
    errnum = (gint) D.12865;
    WSASetLastError (errnum);
    D.12807 = -1;
    return D.12807;
  }
  <D.12863>:
  D.12807 = ret;
  return D.12807;
}


_wapi_FD_CLR (guint32 fd, struct fd_set * set)
{
  long unsigned int D.12867;
  <unnamed type> D.12870;
  long int D.12085;
  long int iftmp.103;
  int D.12874;
  long int iftmp.104;
  unsigned long __d.105;
  long int D.12883;
  long int D.12884;
  int fd.106;
  int D.12886;
  long int D.12887;
  long int D.12888;
  long int D.12889;
  void * handle;

  D.12867 = (long unsigned int) fd;
  handle = (void *) D.12867;
  if (fd > 1023) goto <D.12868>; else goto <D.12869>;
  <D.12868>:
  WSASetLastError (10022);
  return;
  <D.12869>:
  D.12870 = _wapi_handle_type (handle);
  if (D.12870 != 7) goto <D.12871>; else goto <D.12872>;
  <D.12871>:
  WSASetLastError (10038);
  return;
  <D.12872>:
  {
    long int __d;

    __d = (long int) fd;
    D.12874 = __builtin_constant_p (__d);
    if (D.12874 != 0) goto <D.12875>; else goto <D.12876>;
    <D.12875>:
    __d.105 = (unsigned long) __d;
    if (__d.105 <= 1023) goto <D.12879>; else goto <D.12880>;
    <D.12879>:
    iftmp.104 = __d / 64;
    goto <D.12881>;
    <D.12880>:
    iftmp.104 = __fdelt_warn (__d);
    <D.12881>:
    iftmp.103 = iftmp.104;
    goto <D.12882>;
    <D.12876>:
    iftmp.103 = __fdelt_chk (__d);
    <D.12882>:
    D.12085 = iftmp.103;
  }
  D.12883 = D.12085;
  D.12884 = set->fds_bits[D.12883];
  fd.106 = (int) fd;
  D.12886 = fd.106 & 63;
  D.12887 = 1 << D.12886;
  D.12888 = ~D.12887;
  D.12889 = D.12884 & D.12888;
  set->fds_bits[D.12883] = D.12889;
}


_wapi_FD_ISSET (guint32 fd, struct fd_set * set)
{
  long unsigned int D.12891;
  int D.12894;
  <unnamed type> D.12895;
  long int D.12092;
  long int iftmp.107;
  int D.12899;
  long int iftmp.108;
  unsigned long __d.109;
  long int D.12908;
  int fd.110;
  int D.12910;
  long int D.12911;
  long int D.12912;
  _Bool D.12913;
  void * handle;

  D.12891 = (long unsigned int) fd;
  handle = (void *) D.12891;
  if (fd > 1023) goto <D.12892>; else goto <D.12893>;
  <D.12892>:
  WSASetLastError (10022);
  D.12894 = 0;
  return D.12894;
  <D.12893>:
  D.12895 = _wapi_handle_type (handle);
  if (D.12895 != 7) goto <D.12896>; else goto <D.12897>;
  <D.12896>:
  WSASetLastError (10038);
  D.12894 = 0;
  return D.12894;
  <D.12897>:
  {
    long int __d;

    __d = (long int) fd;
    D.12899 = __builtin_constant_p (__d);
    if (D.12899 != 0) goto <D.12900>; else goto <D.12901>;
    <D.12900>:
    __d.109 = (unsigned long) __d;
    if (__d.109 <= 1023) goto <D.12904>; else goto <D.12905>;
    <D.12904>:
    iftmp.108 = __d / 64;
    goto <D.12906>;
    <D.12905>:
    iftmp.108 = __fdelt_warn (__d);
    <D.12906>:
    iftmp.107 = iftmp.108;
    goto <D.12907>;
    <D.12901>:
    iftmp.107 = __fdelt_chk (__d);
    <D.12907>:
    D.12092 = iftmp.107;
  }
  D.12908 = set->fds_bits[D.12092];
  fd.110 = (int) fd;
  D.12910 = fd.110 & 63;
  D.12911 = D.12908 >> D.12910;
  D.12912 = D.12911 & 1;
  D.12913 = D.12912 != 0;
  D.12894 = (int) D.12913;
  return D.12894;
}


_wapi_FD_SET (guint32 fd, struct fd_set * set)
{
  long unsigned int D.12915;
  <unnamed type> D.12918;
  long int D.12099;
  long int iftmp.111;
  int D.12922;
  long int iftmp.112;
  unsigned long __d.113;
  long int D.12931;
  long int D.12932;
  int fd.114;
  int D.12934;
  long int D.12935;
  long int D.12936;
  void * handle;

  D.12915 = (long unsigned int) fd;
  handle = (void *) D.12915;
  if (fd > 1023) goto <D.12916>; else goto <D.12917>;
  <D.12916>:
  WSASetLastError (10022);
  return;
  <D.12917>:
  D.12918 = _wapi_handle_type (handle);
  if (D.12918 != 7) goto <D.12919>; else goto <D.12920>;
  <D.12919>:
  WSASetLastError (10038);
  return;
  <D.12920>:
  {
    long int __d;

    __d = (long int) fd;
    D.12922 = __builtin_constant_p (__d);
    if (D.12922 != 0) goto <D.12923>; else goto <D.12924>;
    <D.12923>:
    __d.113 = (unsigned long) __d;
    if (__d.113 <= 1023) goto <D.12927>; else goto <D.12928>;
    <D.12927>:
    iftmp.112 = __d / 64;
    goto <D.12929>;
    <D.12928>:
    iftmp.112 = __fdelt_warn (__d);
    <D.12929>:
    iftmp.111 = iftmp.112;
    goto <D.12930>;
    <D.12924>:
    iftmp.111 = __fdelt_chk (__d);
    <D.12930>:
    D.12099 = iftmp.111;
  }
  D.12931 = D.12099;
  D.12932 = set->fds_bits[D.12931];
  fd.114 = (int) fd;
  D.12934 = fd.114 & 63;
  D.12935 = 1 << D.12934;
  D.12936 = D.12932 | D.12935;
  set->fds_bits[D.12931] = D.12936;
}


WSARecv (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * received, guint32 * flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.12938;
  long int D.12939;
  long int D.12940;
  _Bool D.12943;
  long int D.12944;
  long int D.12945;
  unsigned int D.12948;
  int D.12949;
  int D.12952;
  unsigned int ret.115;
  int D.12954;
  unsigned int D.12955;
  int ret;
  struct msghdr hdr;

  try
    {
      D.12938 = overlapped != 0B;
      D.12939 = (long int) D.12938;
      D.12940 = __builtin_expect (D.12939, 0);
      if (D.12940 != 0) goto <D.12941>; else goto <D.12942>;
      <D.12941>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1554, "overlapped == NULL");
      <D.12942>:
      D.12943 = complete != 0B;
      D.12944 = (long int) D.12943;
      D.12945 = __builtin_expect (D.12944, 0);
      if (D.12945 != 0) goto <D.12946>; else goto <D.12947>;
      <D.12946>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1555, "complete == NULL");
      <D.12947>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      D.12948 = *flags;
      D.12949 = (int) D.12948;
      ret = _wapi_recvmsg (fd, &hdr, D.12949);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.12950>; else goto <D.12951>;
      <D.12950>:
      D.12952 = ret;
      return D.12952;
      <D.12951>:
      ret.115 = (unsigned int) ret;
      *received = ret.115;
      D.12954 = hdr.msg_flags;
      D.12955 = (unsigned int) D.12954;
      *flags = D.12955;
      D.12952 = 0;
      return D.12952;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


wsabuf_to_msghdr (struct WapiWSABuf * buffers, guint32 count, struct msghdr * hdr)
{
  long unsigned int D.12958;
  long unsigned int D.12959;
  long unsigned int D.12960;
  void * D.12961;
  struct iovec * D.12962;
  long unsigned int D.12963;
  long unsigned int D.12964;
  struct iovec * D.12965;
  struct WapiWSABuf * D.12966;
  void * D.12967;
  unsigned int D.12968;
  long unsigned int D.12969;
  guint32 i;

  memset (hdr, 0, 56);
  D.12958 = (long unsigned int) count;
  hdr->msg_iovlen = D.12958;
  D.12959 = (long unsigned int) count;
  D.12960 = D.12959 * 16;
  D.12961 = monoeg_malloc0 (D.12960);
  hdr->msg_iov = D.12961;
  i = 0;
  goto <D.12107>;
  <D.12106>:
  D.12962 = hdr->msg_iov;
  D.12963 = (long unsigned int) i;
  D.12964 = D.12963 * 16;
  D.12965 = D.12962 + D.12964;
  D.12963 = (long unsigned int) i;
  D.12964 = D.12963 * 16;
  D.12966 = buffers + D.12964;
  D.12967 = D.12966->buf;
  D.12965->iov_base = D.12967;
  D.12962 = hdr->msg_iov;
  D.12963 = (long unsigned int) i;
  D.12964 = D.12963 * 16;
  D.12965 = D.12962 + D.12964;
  D.12963 = (long unsigned int) i;
  D.12964 = D.12963 * 16;
  D.12966 = buffers + D.12964;
  D.12968 = D.12966->len;
  D.12969 = (long unsigned int) D.12968;
  D.12965->iov_len = D.12969;
  i = i + 1;
  <D.12107>:
  if (i < count) goto <D.12106>; else goto <D.12108>;
  <D.12108>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.12972;
  int D.12977;
  void * D.12979;
  long unsigned int D.12980;

  D.12972 = __builtin_constant_p (__len);
  if (D.12972 != 0) goto <D.12973>; else goto <D.12974>;
  <D.12973>:
  if (__len == 0) goto <D.12975>; else goto <D.12976>;
  <D.12975>:
  D.12977 = __builtin_constant_p (__ch);
  if (D.12977 == 0) goto <D.12970>; else goto <D.12978>;
  <D.12978>:
  if (__ch != 0) goto <D.12970>; else goto <D.12971>;
  <D.12970>:
  __warn_memset_zero_len ();
  D.12979 = __dest;
  return D.12979;
  <D.12971>:
  <D.12976>:
  <D.12974>:
  D.12980 = __builtin_object_size (__dest, 0);
  D.12979 = __builtin___memset_chk (__dest, __ch, __len, D.12980);
  return D.12979;
}


_wapi_recvmsg (guint32 fd, struct msghdr * msg, int recv_flags)
{
  long unsigned int D.12982;
  unsigned int startup_count.116;
  int D.12986;
  <unnamed type> D.12987;
  int fd.117;
  long int D.12991;
  int * D.12993;
  int D.12994;
  int D.12996;
  struct _WapiHandle_socket * socket_handle.118;
  int D.13003;
  unsigned int errnum.119;
  unsigned int D.13007;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  int ret;
  static const char __func__[14] = "_wapi_recvmsg";

  try
    {
      D.12982 = (long unsigned int) fd;
      handle = (void *) D.12982;
      startup_count.116 = startup_count;
      if (startup_count.116 == 0) goto <D.12984>; else goto <D.12985>;
      <D.12984>:
      WSASetLastError (10093);
      D.12986 = -1;
      return D.12986;
      <D.12985>:
      D.12987 = _wapi_handle_type (handle);
      if (D.12987 != 7) goto <D.12988>; else goto <D.12989>;
      <D.12988>:
      WSASetLastError (10038);
      D.12986 = -1;
      return D.12986;
      <D.12989>:
      <D.11872>:
      fd.117 = (int) fd;
      D.12991 = recvmsg (fd.117, msg, recv_flags);
      ret = (int) D.12991;
      if (ret == -1) goto <D.12992>; else goto <D.11873>;
      <D.12992>:
      D.12993 = __errno_location ();
      D.12994 = *D.12993;
      if (D.12994 == 4) goto <D.12995>; else goto <D.11873>;
      <D.12995>:
      D.12996 = _wapi_thread_cur_apc_pending ();
      if (D.12996 == 0) goto <D.11872>; else goto <D.11873>;
      <D.11873>:
      if (ret == 0) goto <D.12997>; else goto <D.12998>;
      <D.12997>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12999>; else goto <D.13001>;
      <D.13001>:
      socket_handle.118 = socket_handle;
      D.13003 = socket_handle.118->still_readable;
      if (D.13003 != 1) goto <D.12999>; else goto <D.13000>;
      <D.12999>:
      ret = -1;
      D.12993 = __errno_location ();
      *D.12993 = 4;
      <D.13000>:
      <D.12998>:
      if (ret == -1) goto <D.13004>; else goto <D.13005>;
      <D.13004>:
      {
        gint errnum;

        D.12993 = __errno_location ();
        errnum = *D.12993;
        errnum.119 = (unsigned int) errnum;
        D.13007 = errno_to_WSA (errnum.119, &__func__);
        errnum = (gint) D.13007;
        WSASetLastError (errnum);
        D.12986 = -1;
        return D.12986;
      }
      <D.13005>:
      D.12986 = ret;
      return D.12986;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


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

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


WSASend (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * sent, guint32 flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.13011;
  long int D.13012;
  long int D.13013;
  _Bool D.13016;
  long int D.13017;
  long int D.13018;
  int flags.120;
  int D.13024;
  unsigned int ret.121;
  int ret;
  struct msghdr hdr;

  try
    {
      D.13011 = overlapped != 0B;
      D.13012 = (long int) D.13011;
      D.13013 = __builtin_expect (D.13012, 0);
      if (D.13013 != 0) goto <D.13014>; else goto <D.13015>;
      <D.13014>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1578, "overlapped == NULL");
      <D.13015>:
      D.13016 = complete != 0B;
      D.13017 = (long int) D.13016;
      D.13018 = __builtin_expect (D.13017, 0);
      if (D.13018 != 0) goto <D.13019>; else goto <D.13020>;
      <D.13019>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1579, "complete == NULL");
      <D.13020>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      flags.120 = (int) flags;
      ret = _wapi_sendmsg (fd, &hdr, flags.120);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.13022>; else goto <D.13023>;
      <D.13022>:
      D.13024 = ret;
      return D.13024;
      <D.13023>:
      ret.121 = (unsigned int) ret;
      *sent = ret.121;
      D.13024 = 0;
      return D.13024;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


_wapi_sendmsg (guint32 fd, const struct msghdr * msg, int send_flags)
{
  long unsigned int D.13028;
  unsigned int startup_count.122;
  int D.13032;
  <unnamed type> D.13033;
  int fd.123;
  long int D.13037;
  int * D.13039;
  int D.13040;
  int D.13042;
  unsigned int errnum.124;
  unsigned int D.13046;
  void * handle;
  int ret;
  static const char __func__[14] = "_wapi_sendmsg";

  D.13028 = (long unsigned int) fd;
  handle = (void *) D.13028;
  startup_count.122 = startup_count;
  if (startup_count.122 == 0) goto <D.13030>; else goto <D.13031>;
  <D.13030>:
  WSASetLastError (10093);
  D.13032 = -1;
  return D.13032;
  <D.13031>:
  D.13033 = _wapi_handle_type (handle);
  if (D.13033 != 7) goto <D.13034>; else goto <D.13035>;
  <D.13034>:
  WSASetLastError (10038);
  D.13032 = -1;
  return D.13032;
  <D.13035>:
  <D.11909>:
  fd.123 = (int) fd;
  D.13037 = sendmsg (fd.123, msg, send_flags);
  ret = (int) D.13037;
  if (ret == -1) goto <D.13038>; else goto <D.11910>;
  <D.13038>:
  D.13039 = __errno_location ();
  D.13040 = *D.13039;
  if (D.13040 == 4) goto <D.13041>; else goto <D.11910>;
  <D.13041>:
  D.13042 = _wapi_thread_cur_apc_pending ();
  if (D.13042 == 0) goto <D.11909>; else goto <D.11910>;
  <D.11910>:
  if (ret == -1) goto <D.13043>; else goto <D.13044>;
  <D.13043>:
  {
    gint errnum;

    D.13039 = __errno_location ();
    errnum = *D.13039;
    errnum.124 = (unsigned int) errnum;
    D.13046 = errno_to_WSA (errnum.124, &__func__);
    errnum = (gint) D.13046;
    WSASetLastError (errnum);
    D.13032 = -1;
    return D.13032;
  }
  <D.13044>:
  D.13032 = ret;
  return D.13032;
}