socket_close (void * handle, void * data)
{
  unsigned int startup_count.0;
  unsigned int in_cleanup.1;
  long int handle.2;
  int D.12326;
  int * D.12328;
  int D.12329;
  int D.12331;
  unsigned int errnum.3;
  unsigned int D.12335;
  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.12320>; else goto <D.12321>;
  <D.12320>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.12323>; else goto <D.12324>;
  <D.12323>:
  WSASetLastError (10093);
  return;
  <D.12324>:
  <D.12321>:
  handle.2 = (long int) handle;
  D.12326 = (int) handle.2;
  shutdown (D.12326, 0);
  <D.11919>:
  handle.2 = (long int) handle;
  D.12326 = (int) handle.2;
  ret = close (D.12326);
  if (ret == -1) goto <D.12327>; else goto <D.11920>;
  <D.12327>:
  D.12328 = __errno_location ();
  D.12329 = *D.12328;
  if (D.12329 == 4) goto <D.12330>; else goto <D.11920>;
  <D.12330>:
  D.12331 = _wapi_thread_cur_apc_pending ();
  if (D.12331 == 0) goto <D.11919>; else goto <D.11920>;
  <D.11920>:
  if (ret == -1) goto <D.12332>; else goto <D.12333>;
  <D.12332>:
  {
    gint errnum;

    D.12328 = __errno_location ();
    errnum = *D.12328;
    errnum.3 = (unsigned int) errnum;
    D.12335 = errno_to_WSA (errnum.3, &__func__);
    errnum = (gint) D.12335;
    in_cleanup.1 = in_cleanup;
    if (in_cleanup.1 == 0) goto <D.12336>; else goto <D.12337>;
    <D.12336>:
    WSASetLastError (errnum);
    <D.12337>:
  }
  <D.12333>:
  in_cleanup.1 = in_cleanup;
  if (in_cleanup.1 == 0) goto <D.12338>; else goto <D.12339>;
  <D.12338>:
  socket_handle->saved_error = 0;
  <D.12339>:
}


WSAStartup (guint32 requested, struct WapiWSAData * data)
{
  int D.12343;
  unsigned int startup_count.4;
  unsigned int D.12347;
  short unsigned int D.12348;
  unsigned int D.12349;
  unsigned int D.12350;
  short unsigned int D.12351;
  char[257] * D.12352;
  char[129] * D.12353;

  if (data == 0B) goto <D.12341>; else goto <D.12342>;
  <D.12341>:
  D.12343 = 10014;
  return D.12343;
  <D.12342>:
  if (requested <= 1) goto <D.12344>; else goto <D.12345>;
  <D.12344>:
  D.12343 = 10092;
  return D.12343;
  <D.12345>:
  startup_count.4 = startup_count;
  D.12347 = startup_count.4 + 1;
  startup_count = D.12347;
  data->wHighVersion = 514;
  D.12348 = data->wHighVersion;
  D.12349 = (unsigned int) D.12348;
  D.12350 = MIN_EXPR <D.12349, requested>;
  D.12351 = (short unsigned int) D.12350;
  data->wVersion = D.12351;
  D.12352 = &data->szDescription;
  strncpy (D.12352, "WAPI", 256);
  D.12353 = &data->szSystemStatus;
  strncpy (D.12353, "groovy", 128);
  D.12343 = 0;
  return D.12343;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.12355;
  long unsigned int D.12356;

  D.12356 = __builtin_object_size (__dest, 1);
  D.12355 = __builtin___strncpy_chk (__dest, __src, __len, D.12356);
  return D.12355;
}


WSACleanup ()
{
  unsigned int startup_count.5;
  unsigned int D.12359;
  int D.12362;

  startup_count.5 = startup_count;
  D.12359 = startup_count.5 + 4294967295;
  startup_count = D.12359;
  startup_count.5 = startup_count;
  if (startup_count.5 != 0) goto <D.12360>; else goto <D.12361>;
  <D.12360>:
  D.12362 = 0;
  return D.12362;
  <D.12361>:
  in_cleanup = 1;
  _wapi_handle_foreach (7, cleanup_close, 0B);
  in_cleanup = 0;
  D.12362 = 0;
  return D.12362;
}


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

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


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

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


WSAGetLastError ()
{
  int D.12367;
  unsigned int D.12368;

  D.12368 = GetLastError ();
  D.12367 = (int) D.12368;
  return D.12367;
}


closesocket (guint32 fd)
{
  long unsigned int D.12370;
  <unnamed type> D.12371;
  int D.12374;
  void * handle;

  D.12370 = (long unsigned int) fd;
  handle = (void *) D.12370;
  D.12371 = _wapi_handle_type (handle);
  if (D.12371 != 7) goto <D.12372>; else goto <D.12373>;
  <D.12372>:
  WSASetLastError (10038);
  D.12374 = 0;
  return D.12374;
  <D.12373>:
  _wapi_handle_unref (handle);
  D.12374 = 0;
  return D.12374;
}


_wapi_handle_type (void * handle)
{
  long int handle.7;
  unsigned int D.12381;
  struct _WapiHandleUnshared * D.12382;
  WapiHandleType D.12383;
  unsigned int D.12384;
  struct _WapiHandleUnshared * D.12385;
  long unsigned int D.12386;
  long unsigned int D.12387;
  long unsigned int D.12388;
  struct _WapiHandleUnshared * D.12389;
  guint32 idx;

  handle.7 = (long int) handle;
  idx = (guint32) handle.7;
  if (idx > 4194303) goto <D.12377>; else goto <D.12379>;
  <D.12379>:
  if (idx > 268435455) goto <D.12377>; else goto <D.12380>;
  <D.12380>:
  D.12381 = idx / 256;
  D.12382 = _wapi_private_handles[D.12381];
  if (D.12382 == 0B) goto <D.12377>; else goto <D.12378>;
  <D.12377>:
  D.12383 = 0;
  return D.12383;
  <D.12378>:
  D.12384 = idx / 256;
  D.12385 = _wapi_private_handles[D.12384];
  D.12386 = (long unsigned int) idx;
  D.12387 = D.12386 & 255;
  D.12388 = D.12387 * 200;
  D.12389 = D.12385 + D.12388;
  D.12383 = D.12389->type;
  return D.12383;
}


_wapi_accept (guint32 fd, struct sockaddr * addr, socklen_t * addrlen)
{
  long unsigned int D.12391;
  unsigned int startup_count.8;
  guint32 D.12395;
  unsigned int D.12398;
  <unnamed type> D.12401;
  int fd.9;
  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.12407;
  int * D.12409;
  int D.12410;
  int D.12412;
  unsigned int errnum.10;
  unsigned int D.12416;
  unsigned int new_fd.11;
  unsigned int _wapi_fd_reserve.12;
  struct _WapiHandle_socket * socket_handle.13;
  int D.12422;
  int D.12423;
  int D.12424;
  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.12391 = (long unsigned int) fd;
      handle = (void *) D.12391;
      new_socket_handle = {};
      startup_count.8 = startup_count;
      if (startup_count.8 == 0) goto <D.12393>; else goto <D.12394>;
      <D.12393>:
      WSASetLastError (10093);
      D.12395 = 4294967295;
      return D.12395;
      <D.12394>:
      if (addr != 0B) goto <D.12396>; else goto <D.12397>;
      <D.12396>:
      D.12398 = *addrlen;
      if (D.12398 <= 15) goto <D.12399>; else goto <D.12400>;
      <D.12399>:
      WSASetLastError (10014);
      D.12395 = 4294967295;
      return D.12395;
      <D.12400>:
      <D.12397>:
      D.12401 = _wapi_handle_type (handle);
      if (D.12401 != 7) goto <D.12402>; else goto <D.12403>;
      <D.12402>:
      WSASetLastError (10038);
      D.12395 = 4294967295;
      return D.12395;
      <D.12403>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12404>; else goto <D.12405>;
      <D.12404>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12395 = 4294967295;
      return D.12395;
      <D.12405>:
      <D.11956>:
      fd.9 = (int) fd;
      D.12407.__sockaddr__ = addr;
      new_fd = accept (fd.9, D.12407, addrlen);
      if (new_fd == -1) goto <D.12408>; else goto <D.11957>;
      <D.12408>:
      D.12409 = __errno_location ();
      D.12410 = *D.12409;
      if (D.12410 == 4) goto <D.12411>; else goto <D.11957>;
      <D.12411>:
      D.12412 = _wapi_thread_cur_apc_pending ();
      if (D.12412 == 0) goto <D.11956>; else goto <D.11957>;
      <D.11957>:
      if (new_fd == -1) goto <D.12413>; else goto <D.12414>;
      <D.12413>:
      {
        gint errnum;

        D.12409 = __errno_location ();
        errnum = *D.12409;
        errnum.10 = (unsigned int) errnum;
        D.12416 = errno_to_WSA (errnum.10, &__func__);
        errnum = (gint) D.12416;
        WSASetLastError (errnum);
        D.12395 = 4294967295;
        return D.12395;
      }
      <D.12414>:
      new_fd.11 = (unsigned int) new_fd;
      _wapi_fd_reserve.12 = _wapi_fd_reserve;
      if (new_fd.11 >= _wapi_fd_reserve.12) goto <D.12419>; else goto <D.12420>;
      <D.12419>:
      WSASetLastError (10107);
      close (new_fd);
      D.12395 = 4294967295;
      return D.12395;
      <D.12420>:
      socket_handle.13 = socket_handle;
      D.12422 = socket_handle.13->domain;
      new_socket_handle.domain = D.12422;
      socket_handle.13 = socket_handle;
      D.12423 = socket_handle.13->type;
      new_socket_handle.type = D.12423;
      socket_handle.13 = socket_handle;
      D.12424 = socket_handle.13->protocol;
      new_socket_handle.protocol = D.12424;
      new_socket_handle.still_readable = 1;
      new_handle = _wapi_handle_new_fd (7, new_fd, &new_socket_handle);
      if (new_handle == -1B) goto <D.12425>; else goto <D.12426>;
      <D.12425>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (31);
      D.12395 = 4294967295;
      return D.12395;
      <D.12426>:
      D.12395 = (guint32) new_fd;
      return D.12395;
    }
  finally
    {
      socket_handle = {CLOBBER};
      new_socket_handle = {CLOBBER};
    }
}


_wapi_bind (guint32 fd, struct sockaddr * my_addr, socklen_t addrlen)
{
  long unsigned int D.12429;
  unsigned int startup_count.14;
  int D.12433;
  <unnamed type> D.12434;
  int fd.15;
  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.12438;
  int * D.12441;
  unsigned int errnum.16;
  unsigned int D.12443;
  void * handle;
  int ret;
  static const char __func__[11] = "_wapi_bind";

  D.12429 = (long unsigned int) fd;
  handle = (void *) D.12429;
  startup_count.14 = startup_count;
  if (startup_count.14 == 0) goto <D.12431>; else goto <D.12432>;
  <D.12431>:
  WSASetLastError (10093);
  D.12433 = -1;
  return D.12433;
  <D.12432>:
  D.12434 = _wapi_handle_type (handle);
  if (D.12434 != 7) goto <D.12435>; else goto <D.12436>;
  <D.12435>:
  WSASetLastError (10038);
  D.12433 = -1;
  return D.12433;
  <D.12436>:
  fd.15 = (int) fd;
  D.12438.__sockaddr__ = my_addr;
  ret = bind (fd.15, D.12438, addrlen);
  if (ret == -1) goto <D.12439>; else goto <D.12440>;
  <D.12439>:
  {
    gint errnum;

    D.12441 = __errno_location ();
    errnum = *D.12441;
    errnum.16 = (unsigned int) errnum;
    D.12443 = errno_to_WSA (errnum.16, &__func__);
    errnum = (gint) D.12443;
    WSASetLastError (errnum);
    D.12433 = -1;
    return D.12433;
  }
  <D.12440>:
  D.12433 = ret;
  return D.12433;
}


_wapi_connect (guint32 fd, const struct sockaddr * serv_addr, socklen_t addrlen)
{
  long unsigned int D.12445;
  unsigned int startup_count.17;
  int D.12449;
  <unnamed type> D.12450;
  int fd.18;
  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.12454;
  int D.12455;
  int * D.12458;
  int D.12459;
  unsigned int errnum.19;
  unsigned int D.12463;
  struct _WapiHandle_socket * socket_handle.20;
  unsigned int D.12478;
  unsigned int D.12479;
  int D.12480;
  int D.12482;
  int D.12483;
  unsigned int D.12486;
  int so_error.21;
  unsigned int so_error.22;
  unsigned int D.12491;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  gint errnum;
  static const char __func__[14] = "_wapi_connect";

  try
    {
      D.12445 = (long unsigned int) fd;
      handle = (void *) D.12445;
      startup_count.17 = startup_count;
      if (startup_count.17 == 0) goto <D.12447>; else goto <D.12448>;
      <D.12447>:
      WSASetLastError (10093);
      D.12449 = -1;
      return D.12449;
      <D.12448>:
      D.12450 = _wapi_handle_type (handle);
      if (D.12450 != 7) goto <D.12451>; else goto <D.12452>;
      <D.12451>:
      WSASetLastError (10038);
      D.12449 = -1;
      return D.12449;
      <D.12452>:
      fd.18 = (int) fd;
      D.12454.__sockaddr__ = serv_addr;
      D.12455 = connect (fd.18, D.12454, addrlen);
      if (D.12455 == -1) goto <D.12456>; else goto <D.12457>;
      <D.12456>:
      {
        struct mono_pollfd fds;
        int so_error;
        socklen_t len;

        try
          {
            D.12458 = __errno_location ();
            errnum = *D.12458;
            D.12458 = __errno_location ();
            D.12459 = *D.12458;
            if (D.12459 != 4) goto <D.12460>; else goto <D.12461>;
            <D.12460>:
            errnum.19 = (unsigned int) errnum;
            D.12463 = errno_to_WSA (errnum.19, &__func__);
            errnum = (gint) D.12463;
            if (errnum == 10036) goto <D.12464>; else goto <D.12465>;
            <D.12464>:
            errnum = 10035;
            <D.12465>:
            WSASetLastError (errnum);
            if (errnum != 10035) goto <D.12466>; else goto <D.12467>;
            <D.12466>:
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.12468>; else goto <D.12469>;
            <D.12468>:
            if (errnum != 10054) goto <D.12470>; else goto <D.12471>;
            <D.12470>:
            if (errnum != 10050) goto <D.12472>; else goto <D.12473>;
            <D.12472>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p (error %d)", &__func__, handle, errnum);
            <D.12473>:
            <D.12471>:
            goto <D.12474>;
            <D.12469>:
            socket_handle.20 = socket_handle;
            socket_handle.20->saved_error = errnum;
            <D.12474>:
            <D.12467>:
            D.12449 = -1;
            return D.12449;
            <D.12461>:
            fd.18 = (int) fd;
            fds.fd = fd.18;
            fds.events = 4;
            goto <D.11982>;
            <D.11981>:
            D.12458 = __errno_location ();
            D.12459 = *D.12458;
            if (D.12459 != 4) goto <D.12476>; else goto <D.12477>;
            <D.12476>:
            D.12458 = __errno_location ();
            D.12459 = *D.12458;
            D.12478 = (unsigned int) D.12459;
            D.12479 = errno_to_WSA (D.12478, &__func__);
            errnum = (gint) D.12479;
            WSASetLastError (errnum);
            D.12449 = -1;
            return D.12449;
            <D.12477>:
            <D.11982>:
            D.12480 = mono_poll (&fds, 1, -1);
            if (D.12480 == -1) goto <D.12481>; else goto <D.11983>;
            <D.12481>:
            D.12482 = _wapi_thread_cur_apc_pending ();
            if (D.12482 == 0) goto <D.11981>; else goto <D.11983>;
            <D.11983>:
            len = 4;
            fd.18 = (int) fd;
            D.12483 = getsockopt (fd.18, 1, 4, &so_error, &len);
            if (D.12483 == -1) goto <D.12484>; else goto <D.12485>;
            <D.12484>:
            D.12458 = __errno_location ();
            D.12459 = *D.12458;
            D.12478 = (unsigned int) D.12459;
            D.12486 = errno_to_WSA (D.12478, &__func__);
            errnum = (gint) D.12486;
            WSASetLastError (errnum);
            D.12449 = -1;
            return D.12449;
            <D.12485>:
            so_error.21 = so_error;
            if (so_error.21 != 0) goto <D.12488>; else goto <D.12489>;
            <D.12488>:
            so_error.21 = so_error;
            so_error.22 = (unsigned int) so_error.21;
            D.12491 = errno_to_WSA (so_error.22, &__func__);
            errnum = (gint) D.12491;
            ok = _wapi_lookup_handle (handle, 7, &socket_handle);
            if (ok == 0) goto <D.12492>; else goto <D.12493>;
            <D.12492>:
            monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
            goto <D.12494>;
            <D.12493>:
            socket_handle.20 = socket_handle;
            socket_handle.20->saved_error = errnum;
            <D.12494>:
            WSASetLastError (errnum);
            D.12449 = -1;
            return D.12449;
            <D.12489>:
          }
        finally
          {
            fds = {CLOBBER};
            so_error = {CLOBBER};
            len = {CLOBBER};
          }
      }
      <D.12457>:
      D.12449 = 0;
      return D.12449;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_getpeername (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  long unsigned int D.12499;
  unsigned int startup_count.23;
  int D.12503;
  <unnamed type> D.12504;
  int fd.24;
  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.12508;
  int * D.12511;
  unsigned int errnum.25;
  unsigned int D.12513;
  void * handle;
  int ret;
  static const char __func__[18] = "_wapi_getpeername";

  D.12499 = (long unsigned int) fd;
  handle = (void *) D.12499;
  startup_count.23 = startup_count;
  if (startup_count.23 == 0) goto <D.12501>; else goto <D.12502>;
  <D.12501>:
  WSASetLastError (10093);
  D.12503 = -1;
  return D.12503;
  <D.12502>:
  D.12504 = _wapi_handle_type (handle);
  if (D.12504 != 7) goto <D.12505>; else goto <D.12506>;
  <D.12505>:
  WSASetLastError (10038);
  D.12503 = -1;
  return D.12503;
  <D.12506>:
  fd.24 = (int) fd;
  D.12508.__sockaddr__ = name;
  ret = getpeername (fd.24, D.12508, namelen);
  if (ret == -1) goto <D.12509>; else goto <D.12510>;
  <D.12509>:
  {
    gint errnum;

    D.12511 = __errno_location ();
    errnum = *D.12511;
    errnum.25 = (unsigned int) errnum;
    D.12513 = errno_to_WSA (errnum.25, &__func__);
    errnum = (gint) D.12513;
    WSASetLastError (errnum);
    D.12503 = -1;
    return D.12503;
  }
  <D.12510>:
  D.12503 = ret;
  return D.12503;
}


_wapi_getsockname (guint32 fd, struct sockaddr * name, socklen_t * namelen)
{
  long unsigned int D.12515;
  unsigned int startup_count.26;
  int D.12519;
  <unnamed type> D.12520;
  int fd.27;
  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.12524;
  int * D.12527;
  unsigned int errnum.28;
  unsigned int D.12529;
  void * handle;
  int ret;
  static const char __func__[18] = "_wapi_getsockname";

  D.12515 = (long unsigned int) fd;
  handle = (void *) D.12515;
  startup_count.26 = startup_count;
  if (startup_count.26 == 0) goto <D.12517>; else goto <D.12518>;
  <D.12517>:
  WSASetLastError (10093);
  D.12519 = -1;
  return D.12519;
  <D.12518>:
  D.12520 = _wapi_handle_type (handle);
  if (D.12520 != 7) goto <D.12521>; else goto <D.12522>;
  <D.12521>:
  WSASetLastError (10038);
  D.12519 = -1;
  return D.12519;
  <D.12522>:
  fd.27 = (int) fd;
  D.12524.__sockaddr__ = name;
  ret = getsockname (fd.27, D.12524, namelen);
  if (ret == -1) goto <D.12525>; else goto <D.12526>;
  <D.12525>:
  {
    gint errnum;

    D.12527 = __errno_location ();
    errnum = *D.12527;
    errnum.28 = (unsigned int) errnum;
    D.12529 = errno_to_WSA (errnum.28, &__func__);
    errnum = (gint) D.12529;
    WSASetLastError (errnum);
    D.12519 = -1;
    return D.12519;
  }
  <D.12526>:
  D.12519 = ret;
  return D.12519;
}


_wapi_getsockopt (guint32 fd, int level, int optname, void * optval, socklen_t * optlen)
{
  long unsigned int D.12531;
  unsigned int startup_count.29;
  int D.12535;
  <unnamed type> D.12536;
  unsigned int optname.30;
  unsigned int D.12542;
  int fd.31;
  int * D.12548;
  unsigned int errnum.32;
  unsigned int D.12550;
  long int D.12555;
  unsigned int D.12556;
  unsigned int D.12557;
  long int D.12558;
  long int D.12559;
  unsigned int D.12560;
  unsigned int D.12561;
  int D.12562;
  int D.12567;
  unsigned int D.12568;
  unsigned int D.12569;
  int D.12570;
  unsigned int D.12574;
  int D.12575;
  struct _WapiHandle_socket * socket_handle.33;
  int D.12578;
  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.12531 = (long unsigned int) fd;
      handle = (void *) D.12531;
      startup_count.29 = startup_count;
      if (startup_count.29 == 0) goto <D.12533>; else goto <D.12534>;
      <D.12533>:
      WSASetLastError (10093);
      D.12535 = -1;
      return D.12535;
      <D.12534>:
      D.12536 = _wapi_handle_type (handle);
      if (D.12536 != 7) goto <D.12537>; else goto <D.12538>;
      <D.12537>:
      WSASetLastError (10038);
      D.12535 = -1;
      return D.12535;
      <D.12538>:
      tmp_val = optval;
      if (level == 1) goto <D.12539>; else goto <D.12540>;
      <D.12539>:
      optname.30 = (unsigned int) optname;
      D.12542 = optname.30 + 4294967276;
      if (D.12542 <= 1) goto <D.12543>; else goto <D.12544>;
      <D.12543>:
      tmp_val = &tv;
      *optlen = 16;
      <D.12544>:
      <D.12540>:
      fd.31 = (int) fd;
      ret = getsockopt (fd.31, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.12546>; else goto <D.12547>;
      <D.12546>:
      {
        gint errnum;

        D.12548 = __errno_location ();
        errnum = *D.12548;
        errnum.32 = (unsigned int) errnum;
        D.12550 = errno_to_WSA (errnum.32, &__func__);
        errnum = (gint) D.12550;
        WSASetLastError (errnum);
        D.12535 = -1;
        return D.12535;
      }
      <D.12547>:
      if (level == 1) goto <D.12551>; else goto <D.12552>;
      <D.12551>:
      optname.30 = (unsigned int) optname;
      D.12542 = optname.30 + 4294967276;
      if (D.12542 <= 1) goto <D.12553>; else goto <D.12554>;
      <D.12553>:
      D.12555 = tv.tv_sec;
      D.12556 = (unsigned int) D.12555;
      D.12557 = D.12556 * 1000;
      D.12558 = tv.tv_usec;
      D.12559 = D.12558 / 1000;
      D.12560 = (unsigned int) D.12559;
      D.12561 = D.12557 + D.12560;
      D.12562 = (int) D.12561;
      MEM[(int *)optval] = D.12562;
      *optlen = 4;
      <D.12554>:
      <D.12552>:
      if (optname == 4) goto <D.12563>; else goto <D.12564>;
      <D.12563>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12565>; else goto <D.12566>;
      <D.12565>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      D.12567 = MEM[(int *)optval];
      D.12568 = (unsigned int) D.12567;
      D.12569 = errno_to_WSA (D.12568, &__func__);
      D.12570 = (int) D.12569;
      MEM[(int *)optval] = D.12570;
      goto <D.12571>;
      <D.12566>:
      D.12567 = MEM[(int *)optval];
      if (D.12567 != 0) goto <D.12572>; else goto <D.12573>;
      <D.12572>:
      D.12567 = MEM[(int *)optval];
      D.12568 = (unsigned int) D.12567;
      D.12574 = errno_to_WSA (D.12568, &__func__);
      D.12575 = (int) D.12574;
      MEM[(int *)optval] = D.12575;
      socket_handle.33 = socket_handle;
      D.12567 = MEM[(int *)optval];
      socket_handle.33->saved_error = D.12567;
      goto <D.12577>;
      <D.12573>:
      socket_handle.33 = socket_handle;
      D.12578 = socket_handle.33->saved_error;
      MEM[(int *)optval] = D.12578;
      <D.12577>:
      <D.12571>:
      <D.12564>:
      D.12535 = ret;
      return D.12535;
    }
  finally
    {
      tv = {CLOBBER};
      socket_handle = {CLOBBER};
    }
}


_wapi_listen (guint32 fd, int backlog)
{
  long unsigned int D.12581;
  unsigned int startup_count.34;
  int D.12585;
  <unnamed type> D.12586;
  int fd.35;
  int * D.12592;
  unsigned int errnum.36;
  unsigned int D.12594;
  void * handle;
  int ret;
  static const char __func__[13] = "_wapi_listen";

  D.12581 = (long unsigned int) fd;
  handle = (void *) D.12581;
  startup_count.34 = startup_count;
  if (startup_count.34 == 0) goto <D.12583>; else goto <D.12584>;
  <D.12583>:
  WSASetLastError (10093);
  D.12585 = -1;
  return D.12585;
  <D.12584>:
  D.12586 = _wapi_handle_type (handle);
  if (D.12586 != 7) goto <D.12587>; else goto <D.12588>;
  <D.12587>:
  WSASetLastError (10038);
  D.12585 = -1;
  return D.12585;
  <D.12588>:
  fd.35 = (int) fd;
  ret = listen (fd.35, backlog);
  if (ret == -1) goto <D.12590>; else goto <D.12591>;
  <D.12590>:
  {
    gint errnum;

    D.12592 = __errno_location ();
    errnum = *D.12592;
    errnum.36 = (unsigned int) errnum;
    D.12594 = errno_to_WSA (errnum.36, &__func__);
    errnum = (gint) D.12594;
    WSASetLastError (errnum);
    D.12585 = -1;
    return D.12585;
  }
  <D.12591>:
  D.12585 = 0;
  return D.12585;
}


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

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


_wapi_recvfrom (guint32 fd, void * buf, size_t len, int recv_flags, struct sockaddr * from, socklen_t * fromlen)
{
  long unsigned int D.12598;
  unsigned int startup_count.37;
  int D.12602;
  <unnamed type> D.12603;
  int fd.38;
  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.12607;
  long int D.12608;
  int * D.12610;
  int D.12611;
  int D.12613;
  struct _WapiHandle_socket * socket_handle.39;
  int D.12622;
  unsigned int errnum.40;
  unsigned int D.12626;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  int ret;
  static const char __func__[15] = "_wapi_recvfrom";

  try
    {
      D.12598 = (long unsigned int) fd;
      handle = (void *) D.12598;
      startup_count.37 = startup_count;
      if (startup_count.37 == 0) goto <D.12600>; else goto <D.12601>;
      <D.12600>:
      WSASetLastError (10093);
      D.12602 = -1;
      return D.12602;
      <D.12601>:
      D.12603 = _wapi_handle_type (handle);
      if (D.12603 != 7) goto <D.12604>; else goto <D.12605>;
      <D.12604>:
      WSASetLastError (10038);
      D.12602 = -1;
      return D.12602;
      <D.12605>:
      <D.12043>:
      fd.38 = (int) fd;
      D.12607.__sockaddr__ = from;
      D.12608 = recvfrom (fd.38, buf, len, recv_flags, D.12607, fromlen);
      ret = (int) D.12608;
      if (ret == -1) goto <D.12609>; else goto <D.12044>;
      <D.12609>:
      D.12610 = __errno_location ();
      D.12611 = *D.12610;
      if (D.12611 == 4) goto <D.12612>; else goto <D.12044>;
      <D.12612>:
      D.12613 = _wapi_thread_cur_apc_pending ();
      if (D.12613 == 0) goto <D.12043>; else goto <D.12044>;
      <D.12044>:
      if (ret == 0) goto <D.12614>; else goto <D.12615>;
      <D.12614>:
      if (len != 0) goto <D.12616>; else goto <D.12617>;
      <D.12616>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12618>; else goto <D.12620>;
      <D.12620>:
      socket_handle.39 = socket_handle;
      D.12622 = socket_handle.39->still_readable;
      if (D.12622 != 1) goto <D.12618>; else goto <D.12619>;
      <D.12618>:
      ret = -1;
      D.12610 = __errno_location ();
      *D.12610 = 4;
      <D.12619>:
      <D.12617>:
      <D.12615>:
      if (ret == -1) goto <D.12623>; else goto <D.12624>;
      <D.12623>:
      {
        gint errnum;

        D.12610 = __errno_location ();
        errnum = *D.12610;
        errnum.40 = (unsigned int) errnum;
        D.12626 = errno_to_WSA (errnum.40, &__func__);
        errnum = (gint) D.12626;
        WSASetLastError (errnum);
        D.12602 = -1;
        return D.12602;
      }
      <D.12624>:
      D.12602 = ret;
      return D.12602;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
recvfrom (int __fd, void * restrict __buf, size_t __n, int __flags, union __SOCKADDR_ARG __addr, socklen_t * restrict __addr_len)
{
  long unsigned int D.12629;
  int D.12632;
  ssize_t D.12635;
  long unsigned int D.12636;
  long unsigned int D.12637;
  long unsigned int D.12640;

  D.12629 = __builtin_object_size (__buf, 0);
  if (D.12629 != 18446744073709551615) goto <D.12630>; else goto <D.12631>;
  <D.12630>:
  D.12632 = __builtin_constant_p (__n);
  if (D.12632 == 0) goto <D.12633>; else goto <D.12634>;
  <D.12633>:
  D.12636 = __builtin_object_size (__buf, 0);
  D.12635 = __recvfrom_chk (__fd, __buf, __n, D.12636, __flags, __addr, __addr_len);
  return D.12635;
  <D.12634>:
  D.12637 = __builtin_object_size (__buf, 0);
  if (D.12637 < __n) goto <D.12638>; else goto <D.12639>;
  <D.12638>:
  D.12640 = __builtin_object_size (__buf, 0);
  D.12635 = __recvfrom_chk_warn (__fd, __buf, __n, D.12640, __flags, __addr, __addr_len);
  return D.12635;
  <D.12639>:
  <D.12631>:
  D.12635 = __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
  return D.12635;
}


_wapi_send (guint32 fd, const void * msg, size_t len, int send_flags)
{
  long unsigned int D.12642;
  unsigned int startup_count.41;
  int D.12646;
  <unnamed type> D.12647;
  int fd.42;
  long int D.12651;
  int * D.12653;
  int D.12654;
  int D.12656;
  int D.12663;
  unsigned int errnum.43;
  unsigned int D.12667;
  void * handle;
  int ret;
  static const char __func__[11] = "_wapi_send";

  D.12642 = (long unsigned int) fd;
  handle = (void *) D.12642;
  startup_count.41 = startup_count;
  if (startup_count.41 == 0) goto <D.12644>; else goto <D.12645>;
  <D.12644>:
  WSASetLastError (10093);
  D.12646 = -1;
  return D.12646;
  <D.12645>:
  D.12647 = _wapi_handle_type (handle);
  if (D.12647 != 7) goto <D.12648>; else goto <D.12649>;
  <D.12648>:
  WSASetLastError (10038);
  D.12646 = -1;
  return D.12646;
  <D.12649>:
  <D.12068>:
  fd.42 = (int) fd;
  D.12651 = send (fd.42, msg, len, send_flags);
  ret = (int) D.12651;
  if (ret == -1) goto <D.12652>; else goto <D.12069>;
  <D.12652>:
  D.12653 = __errno_location ();
  D.12654 = *D.12653;
  if (D.12654 == 4) goto <D.12655>; else goto <D.12069>;
  <D.12655>:
  D.12656 = _wapi_thread_cur_apc_pending ();
  if (D.12656 == 0) goto <D.12068>; else goto <D.12069>;
  <D.12069>:
  if (ret == -1) goto <D.12657>; else goto <D.12658>;
  <D.12657>:
  {
    gint errnum;

    D.12653 = __errno_location ();
    errnum = *D.12653;
    if (errnum == 11) goto <D.12659>; else goto <D.12660>;
    <D.12659>:
    fd.42 = (int) fd;
    ret = fcntl (fd.42, 3, 0);
    if (ret != -1) goto <D.12661>; else goto <D.12662>;
    <D.12661>:
    D.12663 = ret & 2048;
    if (D.12663 == 0) goto <D.12664>; else goto <D.12665>;
    <D.12664>:
    errnum = 110;
    <D.12665>:
    <D.12662>:
    <D.12660>:
    errnum.43 = (unsigned int) errnum;
    D.12667 = errno_to_WSA (errnum.43, &__func__);
    errnum = (gint) D.12667;
    WSASetLastError (errnum);
    D.12646 = -1;
    return D.12646;
  }
  <D.12658>:
  D.12646 = ret;
  return D.12646;
}


_wapi_sendto (guint32 fd, const void * msg, size_t len, int send_flags, const struct sockaddr * to, socklen_t tolen)
{
  long unsigned int D.12669;
  unsigned int startup_count.44;
  int D.12673;
  <unnamed type> D.12674;
  int fd.45;
  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.12678;
  long int D.12679;
  int * D.12681;
  int D.12682;
  int D.12684;
  unsigned int errnum.46;
  unsigned int D.12688;
  void * handle;
  int ret;
  static const char __func__[13] = "_wapi_sendto";

  D.12669 = (long unsigned int) fd;
  handle = (void *) D.12669;
  startup_count.44 = startup_count;
  if (startup_count.44 == 0) goto <D.12671>; else goto <D.12672>;
  <D.12671>:
  WSASetLastError (10093);
  D.12673 = -1;
  return D.12673;
  <D.12672>:
  D.12674 = _wapi_handle_type (handle);
  if (D.12674 != 7) goto <D.12675>; else goto <D.12676>;
  <D.12675>:
  WSASetLastError (10038);
  D.12673 = -1;
  return D.12673;
  <D.12676>:
  <D.12082>:
  fd.45 = (int) fd;
  D.12678.__sockaddr__ = to;
  D.12679 = sendto (fd.45, msg, len, send_flags, D.12678, tolen);
  ret = (int) D.12679;
  if (ret == -1) goto <D.12680>; else goto <D.12083>;
  <D.12680>:
  D.12681 = __errno_location ();
  D.12682 = *D.12681;
  if (D.12682 == 4) goto <D.12683>; else goto <D.12083>;
  <D.12683>:
  D.12684 = _wapi_thread_cur_apc_pending ();
  if (D.12684 == 0) goto <D.12082>; else goto <D.12083>;
  <D.12083>:
  if (ret == -1) goto <D.12685>; else goto <D.12686>;
  <D.12685>:
  {
    gint errnum;

    D.12681 = __errno_location ();
    errnum = *D.12681;
    errnum.46 = (unsigned int) errnum;
    D.12688 = errno_to_WSA (errnum.46, &__func__);
    errnum = (gint) D.12688;
    WSASetLastError (errnum);
    D.12673 = -1;
    return D.12673;
  }
  <D.12686>:
  D.12673 = ret;
  return D.12673;
}


_wapi_setsockopt (guint32 fd, int level, int optname, const void * optval, socklen_t optlen)
{
  long unsigned int D.12690;
  unsigned int startup_count.47;
  int D.12694;
  <unnamed type> D.12695;
  unsigned int optname.48;
  unsigned int D.12702;
  int D.12704;
  long int D.12705;
  int D.12706;
  int D.12707;
  long int D.12708;
  unsigned int D.12711;
  int bufsize.49;
  int bufsize.50;
  int bufsize.51;
  int fd.52;
  int * D.12720;
  unsigned int errnum.53;
  unsigned int D.12722;
  int D.12727;
  int type.54;
  void * handle;
  int ret;
  const void * tmp_val;
  int bufsize;
  struct timeval tv;
  static const char __func__[17] = "_wapi_setsockopt";

  try
    {
      D.12690 = (long unsigned int) fd;
      handle = (void *) D.12690;
      bufsize = 0;
      startup_count.47 = startup_count;
      if (startup_count.47 == 0) goto <D.12692>; else goto <D.12693>;
      <D.12692>:
      WSASetLastError (10093);
      D.12694 = -1;
      return D.12694;
      <D.12693>:
      D.12695 = _wapi_handle_type (handle);
      if (D.12695 != 7) goto <D.12696>; else goto <D.12697>;
      <D.12696>:
      WSASetLastError (10038);
      D.12694 = -1;
      return D.12694;
      <D.12697>:
      tmp_val = optval;
      if (level == 1) goto <D.12700>; else goto <D.12698>;
      <D.12700>:
      optname.48 = (unsigned int) optname;
      D.12702 = optname.48 + 4294967276;
      if (D.12702 <= 1) goto <D.12703>; else goto <D.12698>;
      <D.12703>:
      {
        int ms;

        ms = MEM[(int *)optval];
        D.12704 = ms / 1000;
        D.12705 = (long int) D.12704;
        tv.tv_sec = D.12705;
        D.12706 = ms % 1000;
        D.12707 = D.12706 * 1000;
        D.12708 = (long int) D.12707;
        tv.tv_usec = D.12708;
        tmp_val = &tv;
        optlen = 16;
      }
      goto <D.12699>;
      <D.12698>:
      if (level == 1) goto <D.12709>; else goto <D.12710>;
      <D.12709>:
      optname.48 = (unsigned int) optname;
      D.12711 = optname.48 + 4294967289;
      if (D.12711 <= 1) goto <D.12712>; else goto <D.12713>;
      <D.12712>:
      bufsize.49 = MEM[(int *)optval];
      bufsize = bufsize.49;
      bufsize.50 = bufsize;
      bufsize.51 = bufsize.50 / 2;
      bufsize = bufsize.51;
      tmp_val = &bufsize;
      <D.12713>:
      <D.12710>:
      <D.12699>:
      fd.52 = (int) fd;
      ret = setsockopt (fd.52, level, optname, tmp_val, optlen);
      if (ret == -1) goto <D.12718>; else goto <D.12719>;
      <D.12718>:
      {
        gint errnum;

        D.12720 = __errno_location ();
        errnum = *D.12720;
        errnum.53 = (unsigned int) errnum;
        D.12722 = errno_to_WSA (errnum.53, &__func__);
        errnum = (gint) D.12722;
        WSASetLastError (errnum);
        D.12694 = -1;
        return D.12694;
      }
      <D.12719>:
      if (level == 1) goto <D.12723>; else goto <D.12724>;
      <D.12723>:
      if (optname == 2) goto <D.12725>; else goto <D.12726>;
      <D.12725>:
      {
        int type;
        socklen_t type_len;

        try
          {
            type_len = 4;
            fd.52 = (int) fd;
            D.12727 = getsockopt (fd.52, level, 3, &type, &type_len);
            if (D.12727 == 0) goto <D.12728>; else goto <D.12729>;
            <D.12728>:
            type.54 = type;
            if (type.54 == 2) goto <D.12731>; else goto <D.12732>;
            <D.12731>:
            fd.52 = (int) fd;
            setsockopt (fd.52, level, 15, tmp_val, optlen);
            <D.12732>:
            <D.12729>:
          }
        finally
          {
            type = {CLOBBER};
            type_len = {CLOBBER};
          }
      }
      <D.12726>:
      <D.12724>:
      D.12694 = ret;
      return D.12694;
    }
  finally
    {
      bufsize = {CLOBBER};
      tv = {CLOBBER};
    }
}


_wapi_shutdown (guint32 fd, int how)
{
  long unsigned int D.12735;
  unsigned int startup_count.55;
  int D.12739;
  <unnamed type> D.12740;
  struct _WapiHandle_socket * socket_handle.56;
  int fd.57;
  int * D.12752;
  unsigned int errnum.58;
  unsigned int D.12754;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  void * handle;
  int ret;
  static const char __func__[15] = "_wapi_shutdown";

  try
    {
      D.12735 = (long unsigned int) fd;
      handle = (void *) D.12735;
      startup_count.55 = startup_count;
      if (startup_count.55 == 0) goto <D.12737>; else goto <D.12738>;
      <D.12737>:
      WSASetLastError (10093);
      D.12739 = -1;
      return D.12739;
      <D.12738>:
      D.12740 = _wapi_handle_type (handle);
      if (D.12740 != 7) goto <D.12741>; else goto <D.12742>;
      <D.12741>:
      WSASetLastError (10038);
      D.12739 = -1;
      return D.12739;
      <D.12742>:
      if (how == 0) goto <D.12743>; else goto <D.12745>;
      <D.12745>:
      if (how == 2) goto <D.12743>; else goto <D.12744>;
      <D.12743>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12746>; else goto <D.12747>;
      <D.12746>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12739 = -1;
      return D.12739;
      <D.12747>:
      socket_handle.56 = socket_handle;
      socket_handle.56->still_readable = 0;
      <D.12744>:
      fd.57 = (int) fd;
      ret = shutdown (fd.57, how);
      if (ret == -1) goto <D.12750>; else goto <D.12751>;
      <D.12750>:
      {
        gint errnum;

        D.12752 = __errno_location ();
        errnum = *D.12752;
        errnum.58 = (unsigned int) errnum;
        D.12754 = errno_to_WSA (errnum.58, &__func__);
        errnum = (gint) D.12754;
        WSASetLastError (errnum);
        D.12739 = -1;
        return D.12739;
      }
      <D.12751>:
      D.12739 = ret;
      return D.12739;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


_wapi_socket (int domain, int type, int protocol, void * unused, guint32 unused2, guint32 unused3)
{
  int * D.12767;
  unsigned int errnum.59;
  unsigned int D.12769;
  guint32 D.12770;
  unsigned int fd.60;
  unsigned int _wapi_fd_reserve.61;
  unsigned int errnum.62;
  unsigned int D.12778;
  struct _WapiHandle_socket socket_handle;
  void * handle;
  int fd;
  static const char __func__[13] = "_wapi_socket";

  try
    {
      socket_handle = {};
      socket_handle.domain = domain;
      socket_handle.type = type;
      socket_handle.protocol = protocol;
      socket_handle.still_readable = 1;
      fd = socket (domain, type, protocol);
      if (fd == -1) goto <D.12757>; else goto <D.12758>;
      <D.12757>:
      if (domain == 2) goto <D.12759>; else goto <D.12760>;
      <D.12759>:
      if (type == 3) goto <D.12761>; else goto <D.12762>;
      <D.12761>:
      if (protocol == 0) goto <D.12763>; else goto <D.12764>;
      <D.12763>:
      socket_handle.protocol = 4;
      fd = socket (2, 3, 4);
      <D.12764>:
      <D.12762>:
      <D.12760>:
      <D.12758>:
      if (fd == -1) goto <D.12765>; else goto <D.12766>;
      <D.12765>:
      {
        gint errnum;

        D.12767 = __errno_location ();
        errnum = *D.12767;
        errnum.59 = (unsigned int) errnum;
        D.12769 = errno_to_WSA (errnum.59, &__func__);
        errnum = (gint) D.12769;
        WSASetLastError (errnum);
        D.12770 = 4294967295;
        return D.12770;
      }
      <D.12766>:
      fd.60 = (unsigned int) fd;
      _wapi_fd_reserve.61 = _wapi_fd_reserve;
      if (fd.60 >= _wapi_fd_reserve.61) goto <D.12773>; else goto <D.12774>;
      <D.12773>:
      WSASetLastError (10107);
      close (fd);
      D.12770 = 4294967295;
      return D.12770;
      <D.12774>:
      {
        int ret;
        int true;

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

              D.12767 = __errno_location ();
              errnum = *D.12767;
              errnum.62 = (unsigned int) errnum;
              D.12778 = errno_to_WSA (errnum.62, &__func__);
              errnum = (int) D.12778;
              WSASetLastError (errnum);
              close (fd);
              D.12770 = 4294967295;
              return D.12770;
            }
            <D.12776>:
          }
        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.12779>; else goto <D.12780>;
      <D.12779>:
      monoeg_g_log (0B, 16, "%s: error creating socket handle", &__func__);
      WSASetLastError (10107);
      close (fd);
      D.12770 = 4294967295;
      return D.12770;
      <D.12780>:
      D.12770 = (guint32) fd;
      return D.12770;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


socket_ops_init ()
{

}


_wapi_gethostbyname (const char * hostname)
{
  unsigned int startup_count.63;
  struct hostent * D.12788;
  int * D.12791;
  int D.12792;
  struct hostent * he;
  static const char __func__[20] = "_wapi_gethostbyname";

  startup_count.63 = startup_count;
  if (startup_count.63 == 0) goto <D.12786>; else goto <D.12787>;
  <D.12786>:
  WSASetLastError (10093);
  D.12788 = 0B;
  return D.12788;
  <D.12787>:
  he = gethostbyname (hostname);
  if (he == 0B) goto <D.12789>; else goto <D.12790>;
  <D.12789>:
  D.12791 = __h_errno_location ();
  D.12792 = *D.12791;
  switch (D.12792) <default: <D.12149>, case 1: <D.12144>, case 2: <D.12148>, case 3: <D.12147>, case 4: <D.12146>>
  <D.12144>:
  WSASetLastError (11001);
  goto <D.12145>;
  <D.12146>:
  WSASetLastError (11004);
  goto <D.12145>;
  <D.12147>:
  WSASetLastError (11003);
  goto <D.12145>;
  <D.12148>:
  WSASetLastError (11002);
  goto <D.12145>;
  <D.12149>:
  D.12791 = __h_errno_location ();
  D.12792 = *D.12791;
  monoeg_g_log (0B, 16, "%s: Need to translate %d into winsock error", &__func__, D.12792);
  goto <D.12145>;
  <D.12145>:
  <D.12790>:
  D.12788 = he;
  return D.12788;
}


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.12794;
  unsigned int startup_count.64;
  gboolean D.12798;
  <unnamed type> D.12799;
  void * D.12804;
  unsigned int D.12807;
  long unsigned int D.12810;
  void * D.12817;
  unsigned int D.12820;
  long unsigned int D.12823;
  unsigned int D.12826;
  void * sock;
  gint ret;

  D.12794 = (long unsigned int) socket;
  sock = (void *) D.12794;
  startup_count.64 = startup_count;
  if (startup_count.64 == 0) goto <D.12796>; else goto <D.12797>;
  <D.12796>:
  WSASetLastError (10093);
  D.12798 = 0;
  return D.12798;
  <D.12797>:
  D.12799 = _wapi_handle_type (sock);
  if (D.12799 != 7) goto <D.12800>; else goto <D.12801>;
  <D.12800>:
  WSASetLastError (10038);
  D.12798 = 0;
  return D.12798;
  <D.12801>:
  if (buffers != 0B) goto <D.12802>; else goto <D.12803>;
  <D.12802>:
  D.12804 = buffers->Head;
  if (D.12804 != 0B) goto <D.12805>; else goto <D.12806>;
  <D.12805>:
  D.12807 = buffers->HeadLength;
  if (D.12807 != 0) goto <D.12808>; else goto <D.12809>;
  <D.12808>:
  D.12804 = buffers->Head;
  D.12807 = buffers->HeadLength;
  D.12810 = (long unsigned int) D.12807;
  ret = _wapi_send (socket, D.12804, D.12810, 0);
  if (ret == -1) goto <D.12811>; else goto <D.12812>;
  <D.12811>:
  D.12798 = 0;
  return D.12798;
  <D.12812>:
  <D.12809>:
  <D.12806>:
  <D.12803>:
  ret = wapi_sendfile (socket, file, bytes_to_write, bytes_per_send, flags);
  if (ret == -1) goto <D.12813>; else goto <D.12814>;
  <D.12813>:
  D.12798 = 0;
  return D.12798;
  <D.12814>:
  if (buffers != 0B) goto <D.12815>; else goto <D.12816>;
  <D.12815>:
  D.12817 = buffers->Tail;
  if (D.12817 != 0B) goto <D.12818>; else goto <D.12819>;
  <D.12818>:
  D.12820 = buffers->TailLength;
  if (D.12820 != 0) goto <D.12821>; else goto <D.12822>;
  <D.12821>:
  D.12817 = buffers->Tail;
  D.12820 = buffers->TailLength;
  D.12823 = (long unsigned int) D.12820;
  ret = _wapi_send (socket, D.12817, D.12823, 0);
  if (ret == -1) goto <D.12824>; else goto <D.12825>;
  <D.12824>:
  D.12798 = 0;
  return D.12798;
  <D.12825>:
  <D.12822>:
  <D.12819>:
  <D.12816>:
  D.12826 = flags & 1;
  if (D.12826 != 0) goto <D.12827>; else goto <D.12828>;
  <D.12827>:
  closesocket (socket);
  <D.12828>:
  D.12798 = 1;
  return D.12798;
}


wapi_sendfile (guint32 socket, void * fd, guint32 bytes_to_write, guint32 bytes_per_send, guint32 flags)
{
  long int fd.65;
  int * D.12833;
  unsigned int errnum.66;
  unsigned int D.12835;
  gint D.12836;
  int socket.67;
  long int D.12838;
  long unsigned int D.12839;
  int D.12842;
  int D.12844;
  unsigned int D.12847;
  gint file;
  gint n;
  gint errnum;
  gssize res;
  struct stat statbuf;
  static const char __func__[14] = "wapi_sendfile";

  try
    {
      fd.65 = (long int) fd;
      file = (gint) fd.65;
      n = fstat (file, &statbuf);
      if (n == -1) goto <D.12831>; else goto <D.12832>;
      <D.12831>:
      D.12833 = __errno_location ();
      errnum = *D.12833;
      errnum.66 = (unsigned int) errnum;
      D.12835 = errno_to_WSA (errnum.66, &__func__);
      errnum = (gint) D.12835;
      WSASetLastError (errnum);
      D.12836 = -1;
      return D.12836;
      <D.12832>:
      <D.12183>:
      socket.67 = (int) socket;
      D.12838 = statbuf.st_size;
      D.12839 = (long unsigned int) D.12838;
      res = sendfile (socket.67, file, 0B, D.12839);
      if (res != -1) goto <D.12841>; else goto <D.12184>;
      <D.12841>:
      D.12833 = __errno_location ();
      D.12842 = *D.12833;
      if (D.12842 == 4) goto <D.12840>; else goto <D.12843>;
      <D.12843>:
      D.12833 = __errno_location ();
      D.12842 = *D.12833;
      if (D.12842 == 11) goto <D.12840>; else goto <D.12184>;
      <D.12840>:
      D.12844 = _wapi_thread_cur_apc_pending ();
      if (D.12844 == 0) goto <D.12183>; else goto <D.12184>;
      <D.12184>:
      if (res == -1) goto <D.12845>; else goto <D.12846>;
      <D.12845>:
      D.12833 = __errno_location ();
      errnum = *D.12833;
      errnum.66 = (unsigned int) errnum;
      D.12847 = errno_to_WSA (errnum.66, &__func__);
      errnum = (gint) D.12847;
      WSASetLastError (errnum);
      D.12836 = -1;
      return D.12836;
      <D.12846>:
      D.12836 = 0;
      return D.12836;
    }
  finally
    {
      statbuf = {CLOBBER};
    }
}


__attribute__((__gnu_inline__, __leaf__, __nothrow__))
fstat (int __fd, struct stat * __statbuf)
{
  int D.12850;

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


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.12852;
  unsigned int startup_count.68;
  int D.12856;
  <unnamed type> D.12857;
  unsigned int i_len.69;
  unsigned int o_len.70;
  struct WapiGuid * D.12870;
  int D.12871;
  void * * D.12874;
  void * D.12875;
  gchar * D.12880;
  gchar * D.12881;
  int fd.71;
  int * D.12885;
  unsigned int errnum.72;
  unsigned int D.12887;
  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.12908;
  unsigned int i_len.81;
  long unsigned int D.12912;
  unsigned int errnum.82;
  unsigned int D.12916;
  long unsigned int D.12924;
  long int D.12925;
  void * handle;
  int ret;
  gchar * buffer;
  static const char __func__[9] = "WSAIoctl";

  D.12852 = (long unsigned int) fd;
  handle = (void *) D.12852;
  buffer = 0B;
  startup_count.68 = startup_count;
  if (startup_count.68 == 0) goto <D.12854>; else goto <D.12855>;
  <D.12854>:
  WSASetLastError (10093);
  D.12856 = -1;
  return D.12856;
  <D.12855>:
  D.12857 = _wapi_handle_type (handle);
  if (D.12857 != 7) goto <D.12858>; else goto <D.12859>;
  <D.12858>:
  WSASetLastError (10038);
  D.12856 = -1;
  return D.12856;
  <D.12859>:
  if (command == -939524090) goto <D.12860>; else goto <D.12861>;
  <D.12860>:
  {
    int i;
    struct WapiGuid * guid;

    i = 0;
    guid = input;
    i_len.69 = (unsigned int) i_len;
    if (i_len.69 <= 15) goto <D.12863>; else goto <D.12864>;
    <D.12863>:
    WSASetLastError (10022);
    D.12856 = -1;
    return D.12856;
    <D.12864>:
    o_len.70 = (unsigned int) o_len;
    if (o_len.70 <= 7) goto <D.12866>; else goto <D.12867>;
    <D.12866>:
    WSASetLastError (10022);
    D.12856 = -1;
    return D.12856;
    <D.12867>:
    if (output == 0B) goto <D.12868>; else goto <D.12869>;
    <D.12868>:
    WSASetLastError (10022);
    D.12856 = -1;
    return D.12856;
    <D.12869>:
    goto <D.12217>;
    <D.12216>:
    D.12870 = &extension_functions[i].guid;
    D.12871 = memcmp (guid, D.12870, 16);
    if (D.12871 == 0) goto <D.12872>; else goto <D.12873>;
    <D.12872>:
    D.12874 = &extension_functions[i].func;
    memcpy (output, D.12874, 8);
    *written = 8;
    D.12856 = 0;
    return D.12856;
    <D.12873>:
    i = i + 1;
    <D.12217>:
    D.12875 = extension_functions[i].func;
    if (D.12875 != 0B) goto <D.12216>; else goto <D.12218>;
    <D.12218>:
    WSASetLastError (10022);
    D.12856 = -1;
    return D.12856;
  }
  <D.12861>:
  if (command == -1744830460) goto <D.12876>; else goto <D.12877>;
  <D.12876>:
  {
    uint32_t onoff;
    uint32_t keepalivetime;
    uint32_t keepaliveinterval;

    try
      {
        i_len.69 = (unsigned int) i_len;
        if (i_len.69 <= 11) goto <D.12878>; else goto <D.12879>;
        <D.12878>:
        WSASetLastError (10022);
        D.12856 = -1;
        return D.12856;
        <D.12879>:
        memcpy (&onoff, input, 4);
        D.12880 = input + 4;
        memcpy (&keepalivetime, D.12880, 4);
        D.12881 = input + 8;
        memcpy (&keepaliveinterval, D.12881, 4);
        fd.71 = (int) fd;
        ret = setsockopt (fd.71, 1, 9, &onoff, 4);
        if (ret < 0) goto <D.12883>; else goto <D.12884>;
        <D.12883>:
        {
          gint errnum;

          D.12885 = __errno_location ();
          errnum = *D.12885;
          errnum.72 = (unsigned int) errnum;
          D.12887 = errno_to_WSA (errnum.72, &__func__);
          errnum = (gint) D.12887;
          WSASetLastError (errnum);
          D.12856 = -1;
          return D.12856;
        }
        <D.12884>:
        onoff.73 = onoff;
        if (onoff.73 != 0) goto <D.12889>; else goto <D.12890>;
        <D.12889>:
        {
          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.12893>; else goto <D.12895>;
          <D.12895>:
          if (rem > 499) goto <D.12893>; else goto <D.12894>;
          <D.12893>:
          keepalivetime.74 = keepalivetime;
          keepalivetime.76 = keepalivetime.74 + 1;
          keepalivetime = keepalivetime.76;
          <D.12894>:
          fd.71 = (int) fd;
          ret = setsockopt (fd.71, 6, 4, &keepalivetime, 4);
          if (ret == 0) goto <D.12897>; else goto <D.12898>;
          <D.12897>:
          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.12901>; else goto <D.12903>;
          <D.12903>:
          if (rem > 499) goto <D.12901>; else goto <D.12902>;
          <D.12901>:
          keepaliveinterval.77 = keepaliveinterval;
          keepaliveinterval.79 = keepaliveinterval.77 + 1;
          keepaliveinterval = keepaliveinterval.79;
          <D.12902>:
          fd.71 = (int) fd;
          ret = setsockopt (fd.71, 6, 5, &keepaliveinterval, 4);
          <D.12898>:
          if (ret != 0) goto <D.12905>; else goto <D.12906>;
          <D.12905>:
          {
            gint errnum;

            D.12885 = __errno_location ();
            errnum = *D.12885;
            errnum.80 = (unsigned int) errnum;
            D.12908 = errno_to_WSA (errnum.80, &__func__);
            errnum = (gint) D.12908;
            WSASetLastError (errnum);
            D.12856 = -1;
            return D.12856;
          }
          <D.12906>:
          D.12856 = 0;
          return D.12856;
        }
        <D.12890>:
        D.12856 = 0;
        return D.12856;
      }
    finally
      {
        onoff = {CLOBBER};
        keepalivetime = {CLOBBER};
        keepaliveinterval = {CLOBBER};
      }
  }
  <D.12877>:
  if (i_len > 0) goto <D.12909>; else goto <D.12910>;
  <D.12909>:
  i_len.81 = (unsigned int) i_len;
  buffer = monoeg_g_memdup (input, i_len.81);
  <D.12910>:
  fd.71 = (int) fd;
  D.12912 = (long unsigned int) command;
  ret = ioctl (fd.71, D.12912, buffer);
  if (ret == -1) goto <D.12913>; else goto <D.12914>;
  <D.12913>:
  {
    gint errnum;

    D.12885 = __errno_location ();
    errnum = *D.12885;
    errnum.82 = (unsigned int) errnum;
    D.12916 = errno_to_WSA (errnum.82, &__func__);
    errnum = (gint) D.12916;
    WSASetLastError (errnum);
    monoeg_g_free (buffer);
    D.12856 = -1;
    return D.12856;
  }
  <D.12914>:
  if (buffer == 0B) goto <D.12917>; else goto <D.12918>;
  <D.12917>:
  *written = 0;
  goto <D.12919>;
  <D.12918>:
  i_len = MIN_EXPR <i_len, o_len>;
  if (i_len > 0) goto <D.12920>; else goto <D.12921>;
  <D.12920>:
  if (output != 0B) goto <D.12922>; else goto <D.12923>;
  <D.12922>:
  D.12924 = (long unsigned int) i_len;
  memcpy (output, buffer, D.12924);
  <D.12923>:
  <D.12921>:
  monoeg_g_free (buffer);
  D.12925 = (long int) i_len;
  *written = D.12925;
  <D.12919>:
  D.12856 = 0;
  return D.12856;
}


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

  if (reserved != 0) goto <D.12928>; else goto <D.12929>;
  <D.12928>:
  WSASetLastError (10022);
  D.12930 = 0;
  return D.12930;
  <D.12929>:
  D.12930 = socket_disconnect (fd);
  return D.12930;
}


socket_disconnect (guint32 fd)
{
  long unsigned int D.12932;
  gboolean D.12935;
  struct _WapiHandle_socket * socket_handle.83;
  int D.12937;
  int D.12938;
  int D.12939;
  int * D.12942;
  unsigned int errnum.84;
  unsigned int D.12944;
  int fd.85;
  int D.12947;
  unsigned int errnum.86;
  unsigned int D.12951;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  void * handle;
  int newsock;
  int ret;
  static const char __func__[18] = "socket_disconnect";

  try
    {
      D.12932 = (long unsigned int) fd;
      handle = (void *) D.12932;
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.12933>; else goto <D.12934>;
      <D.12933>:
      monoeg_g_log (0B, 16, "%s: error looking up socket handle %p", &__func__, handle);
      WSASetLastError (10038);
      D.12935 = 0;
      return D.12935;
      <D.12934>:
      socket_handle.83 = socket_handle;
      D.12937 = socket_handle.83->domain;
      socket_handle.83 = socket_handle;
      D.12938 = socket_handle.83->type;
      socket_handle.83 = socket_handle;
      D.12939 = socket_handle.83->protocol;
      newsock = socket (D.12937, D.12938, D.12939);
      if (newsock == -1) goto <D.12940>; else goto <D.12941>;
      <D.12940>:
      {
        gint errnum;

        D.12942 = __errno_location ();
        errnum = *D.12942;
        errnum.84 = (unsigned int) errnum;
        D.12944 = errno_to_WSA (errnum.84, &__func__);
        errnum = (gint) D.12944;
        WSASetLastError (errnum);
        D.12935 = 0;
        return D.12935;
      }
      <D.12941>:
      <D.12161>:
      fd.85 = (int) fd;
      ret = dup2 (newsock, fd.85);
      if (ret == -1) goto <D.12946>; else goto <D.12162>;
      <D.12946>:
      D.12942 = __errno_location ();
      D.12947 = *D.12942;
      if (D.12947 == 11) goto <D.12161>; else goto <D.12162>;
      <D.12162>:
      if (ret == -1) goto <D.12948>; else goto <D.12949>;
      <D.12948>:
      {
        gint errnum;

        D.12942 = __errno_location ();
        errnum = *D.12942;
        errnum.86 = (unsigned int) errnum;
        D.12951 = errno_to_WSA (errnum.86, &__func__);
        errnum = (gint) D.12951;
        WSASetLastError (errnum);
        D.12935 = 0;
        return D.12935;
      }
      <D.12949>:
      close (newsock);
      D.12935 = 1;
      return D.12935;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.12954;
  long unsigned int D.12955;

  D.12955 = __builtin_object_size (__dest, 0);
  D.12954 = __builtin___memcpy_chk (__dest, __src, __len, D.12955);
  return D.12954;
}


ioctlsocket (guint32 fd, gint32 command, void * arg)
{
  long unsigned int D.12957;
  unsigned int startup_count.87;
  int D.12961;
  <unnamed type> D.12962;
  int fd.88;
  int D.12968;
  long unsigned int D.12972;
  int * D.12975;
  unsigned int errnum.89;
  unsigned int D.12977;
  void * handle;
  int ret;
  static const char __func__[12] = "ioctlsocket";

  D.12957 = (long unsigned int) fd;
  handle = (void *) D.12957;
  startup_count.87 = startup_count;
  if (startup_count.87 == 0) goto <D.12959>; else goto <D.12960>;
  <D.12959>:
  WSASetLastError (10093);
  D.12961 = -1;
  return D.12961;
  <D.12960>:
  D.12962 = _wapi_handle_type (handle);
  if (D.12962 != 7) goto <D.12963>; else goto <D.12964>;
  <D.12963>:
  WSASetLastError (10038);
  D.12961 = -1;
  return D.12961;
  <D.12964>:
  switch (command) <default: <D.12238>, case 21531: <D.12237>, case 21537: <D.12234>, case 35077: <D.12236>>
  <D.12234>:
  fd.88 = (int) fd;
  ret = fcntl (fd.88, 3, 0);
  if (ret != -1) goto <D.12966>; else goto <D.12967>;
  <D.12966>:
  D.12968 = MEM[(gboolean *)arg];
  if (D.12968 != 0) goto <D.12969>; else goto <D.12970>;
  <D.12969>:
  ret = ret | 2048;
  goto <D.12971>;
  <D.12970>:
  ret = ret & -2049;
  <D.12971>:
  fd.88 = (int) fd;
  ret = fcntl (fd.88, 4, ret);
  <D.12967>:
  goto <D.12235>;
  <D.12236>:
  fd.88 = (int) fd;
  D.12972 = (long unsigned int) command;
  ret = ioctl (fd.88, D.12972, arg);
  goto <D.12235>;
  <D.12237>:
  fd.88 = (int) fd;
  D.12972 = (long unsigned int) command;
  ret = ioctl (fd.88, D.12972, arg);
  goto <D.12235>;
  <D.12238>:
  WSASetLastError (10022);
  D.12961 = -1;
  return D.12961;
  <D.12235>:
  if (ret == -1) goto <D.12973>; else goto <D.12974>;
  <D.12973>:
  {
    gint errnum;

    D.12975 = __errno_location ();
    errnum = *D.12975;
    errnum.89 = (unsigned int) errnum;
    D.12977 = errno_to_WSA (errnum.89, &__func__);
    errnum = (gint) D.12977;
    WSASetLastError (errnum);
    D.12961 = -1;
    return D.12961;
  }
  <D.12974>:
  D.12961 = 0;
  return D.12961;
}


_wapi_select (int nfds, struct fd_set * readfds, struct fd_set * writefds, struct fd_set * exceptfds, struct timeval * timeout)
{
  unsigned int startup_count.90;
  int D.12982;
  long int D.12251;
  long int iftmp.91;
  int D.12988;
  long int iftmp.92;
  unsigned long __d.93;
  long int D.12997;
  int D.12998;
  long unsigned int D.12999;
  long int D.13000;
  long int D.13001;
  long int D.12253;
  long int iftmp.94;
  int D.13004;
  long int iftmp.95;
  unsigned long __d.96;
  long int D.13013;
  long int D.13014;
  long int D.12255;
  long int iftmp.97;
  int D.13017;
  long int iftmp.98;
  unsigned long __d.99;
  long int D.13026;
  long int D.13027;
  int D.13030;
  int * D.13032;
  int D.13033;
  int D.13035;
  unsigned int errnum.100;
  unsigned int D.13039;
  int ret;
  int maxfd;
  static const char __func__[13] = "_wapi_select";

  startup_count.90 = startup_count;
  if (startup_count.90 == 0) goto <D.12980>; else goto <D.12981>;
  <D.12980>:
  WSASetLastError (10093);
  D.12982 = -1;
  return D.12982;
  <D.12981>:
  maxfd = 1023;
  goto <D.12258>;
  <D.12257>:
  if (readfds != 0B) goto <D.12986>; else goto <D.12983>;
  <D.12986>:
  {
    long int __d;

    __d = (long int) maxfd;
    D.12988 = __builtin_constant_p (__d);
    if (D.12988 != 0) goto <D.12989>; else goto <D.12990>;
    <D.12989>:
    __d.93 = (unsigned long) __d;
    if (__d.93 <= 1023) goto <D.12993>; else goto <D.12994>;
    <D.12993>:
    iftmp.92 = __d / 64;
    goto <D.12995>;
    <D.12994>:
    iftmp.92 = __fdelt_warn (__d);
    <D.12995>:
    iftmp.91 = iftmp.92;
    goto <D.12996>;
    <D.12990>:
    iftmp.91 = __fdelt_chk (__d);
    <D.12996>:
    D.12251 = iftmp.91;
  }
  D.12997 = readfds->fds_bits[D.12251];
  D.12998 = maxfd % 64;
  D.12999 = 1 << D.12998;
  D.13000 = (long int) D.12999;
  D.13001 = D.12997 & D.13000;
  if (D.13001 != 0) goto <D.12256>; else goto <D.12983>;
  <D.12983>:
  if (writefds != 0B) goto <D.13002>; else goto <D.12984>;
  <D.13002>:
  {
    long int __d;

    __d = (long int) maxfd;
    D.13004 = __builtin_constant_p (__d);
    if (D.13004 != 0) goto <D.13005>; else goto <D.13006>;
    <D.13005>:
    __d.96 = (unsigned long) __d;
    if (__d.96 <= 1023) goto <D.13009>; else goto <D.13010>;
    <D.13009>:
    iftmp.95 = __d / 64;
    goto <D.13011>;
    <D.13010>:
    iftmp.95 = __fdelt_warn (__d);
    <D.13011>:
    iftmp.94 = iftmp.95;
    goto <D.13012>;
    <D.13006>:
    iftmp.94 = __fdelt_chk (__d);
    <D.13012>:
    D.12253 = iftmp.94;
  }
  D.13013 = writefds->fds_bits[D.12253];
  D.12998 = maxfd % 64;
  D.12999 = 1 << D.12998;
  D.13000 = (long int) D.12999;
  D.13014 = D.13013 & D.13000;
  if (D.13014 != 0) goto <D.12256>; else goto <D.12984>;
  <D.12984>:
  if (exceptfds != 0B) goto <D.13015>; else goto <D.12985>;
  <D.13015>:
  {
    long int __d;

    __d = (long int) maxfd;
    D.13017 = __builtin_constant_p (__d);
    if (D.13017 != 0) goto <D.13018>; else goto <D.13019>;
    <D.13018>:
    __d.99 = (unsigned long) __d;
    if (__d.99 <= 1023) goto <D.13022>; else goto <D.13023>;
    <D.13022>:
    iftmp.98 = __d / 64;
    goto <D.13024>;
    <D.13023>:
    iftmp.98 = __fdelt_warn (__d);
    <D.13024>:
    iftmp.97 = iftmp.98;
    goto <D.13025>;
    <D.13019>:
    iftmp.97 = __fdelt_chk (__d);
    <D.13025>:
    D.12255 = iftmp.97;
  }
  D.13026 = exceptfds->fds_bits[D.12255];
  D.12998 = maxfd % 64;
  D.12999 = 1 << D.12998;
  D.13000 = (long int) D.12999;
  D.13027 = D.13026 & D.13000;
  if (D.13027 != 0) goto <D.12256>; else goto <D.12985>;
  <D.12985>:
  maxfd = maxfd + -1;
  <D.12258>:
  if (maxfd >= 0) goto <D.12257>; else goto <D.12256>;
  <D.12256>:
  if (maxfd == -1) goto <D.13028>; else goto <D.13029>;
  <D.13028>:
  WSASetLastError (10022);
  D.12982 = -1;
  return D.12982;
  <D.13029>:
  <D.12259>:
  D.13030 = maxfd + 1;
  ret = select (D.13030, readfds, writefds, exceptfds, timeout);
  if (ret == -1) goto <D.13031>; else goto <D.12260>;
  <D.13031>:
  D.13032 = __errno_location ();
  D.13033 = *D.13032;
  if (D.13033 == 4) goto <D.13034>; else goto <D.12260>;
  <D.13034>:
  D.13035 = _wapi_thread_cur_apc_pending ();
  if (D.13035 == 0) goto <D.12259>; else goto <D.12260>;
  <D.12260>:
  if (ret == -1) goto <D.13036>; else goto <D.13037>;
  <D.13036>:
  {
    gint errnum;

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


_wapi_FD_CLR (guint32 fd, struct fd_set * set)
{
  long unsigned int D.13041;
  <unnamed type> D.13044;
  long int D.12269;
  long int iftmp.101;
  int D.13048;
  long int iftmp.102;
  unsigned long __d.103;
  long int D.13057;
  long int D.13058;
  unsigned int D.13059;
  long unsigned int D.13060;
  long int D.13061;
  long int D.13062;
  long int D.13063;
  void * handle;

  D.13041 = (long unsigned int) fd;
  handle = (void *) D.13041;
  if (fd > 1023) goto <D.13042>; else goto <D.13043>;
  <D.13042>:
  WSASetLastError (10022);
  return;
  <D.13043>:
  D.13044 = _wapi_handle_type (handle);
  if (D.13044 != 7) goto <D.13045>; else goto <D.13046>;
  <D.13045>:
  WSASetLastError (10038);
  return;
  <D.13046>:
  {
    long int __d;

    __d = (long int) fd;
    D.13048 = __builtin_constant_p (__d);
    if (D.13048 != 0) goto <D.13049>; else goto <D.13050>;
    <D.13049>:
    __d.103 = (unsigned long) __d;
    if (__d.103 <= 1023) goto <D.13053>; else goto <D.13054>;
    <D.13053>:
    iftmp.102 = __d / 64;
    goto <D.13055>;
    <D.13054>:
    iftmp.102 = __fdelt_warn (__d);
    <D.13055>:
    iftmp.101 = iftmp.102;
    goto <D.13056>;
    <D.13050>:
    iftmp.101 = __fdelt_chk (__d);
    <D.13056>:
    D.12269 = iftmp.101;
  }
  D.13057 = D.12269;
  D.13058 = set->fds_bits[D.13057];
  D.13059 = fd & 63;
  D.13060 = 1 << D.13059;
  D.13061 = (long int) D.13060;
  D.13062 = ~D.13061;
  D.13063 = D.13058 & D.13062;
  set->fds_bits[D.13057] = D.13063;
}


_wapi_FD_ISSET (guint32 fd, struct fd_set * set)
{
  long unsigned int D.13065;
  int D.13068;
  <unnamed type> D.13069;
  long int D.12276;
  long int iftmp.104;
  int D.13073;
  long int iftmp.105;
  unsigned long __d.106;
  long int D.13082;
  unsigned int D.13083;
  long unsigned int D.13084;
  long int D.13085;
  long int D.13086;
  _Bool D.13087;
  void * handle;

  D.13065 = (long unsigned int) fd;
  handle = (void *) D.13065;
  if (fd > 1023) goto <D.13066>; else goto <D.13067>;
  <D.13066>:
  WSASetLastError (10022);
  D.13068 = 0;
  return D.13068;
  <D.13067>:
  D.13069 = _wapi_handle_type (handle);
  if (D.13069 != 7) goto <D.13070>; else goto <D.13071>;
  <D.13070>:
  WSASetLastError (10038);
  D.13068 = 0;
  return D.13068;
  <D.13071>:
  {
    long int __d;

    __d = (long int) fd;
    D.13073 = __builtin_constant_p (__d);
    if (D.13073 != 0) goto <D.13074>; else goto <D.13075>;
    <D.13074>:
    __d.106 = (unsigned long) __d;
    if (__d.106 <= 1023) goto <D.13078>; else goto <D.13079>;
    <D.13078>:
    iftmp.105 = __d / 64;
    goto <D.13080>;
    <D.13079>:
    iftmp.105 = __fdelt_warn (__d);
    <D.13080>:
    iftmp.104 = iftmp.105;
    goto <D.13081>;
    <D.13075>:
    iftmp.104 = __fdelt_chk (__d);
    <D.13081>:
    D.12276 = iftmp.104;
  }
  D.13082 = set->fds_bits[D.12276];
  D.13083 = fd & 63;
  D.13084 = 1 << D.13083;
  D.13085 = (long int) D.13084;
  D.13086 = D.13082 & D.13085;
  D.13087 = D.13086 != 0;
  D.13068 = (int) D.13087;
  return D.13068;
}


_wapi_FD_SET (guint32 fd, struct fd_set * set)
{
  long unsigned int D.13089;
  <unnamed type> D.13092;
  long int D.12283;
  long int iftmp.107;
  int D.13096;
  long int iftmp.108;
  unsigned long __d.109;
  long int D.13105;
  long int D.13106;
  unsigned int D.13107;
  long unsigned int D.13108;
  long int D.13109;
  long int D.13110;
  void * handle;

  D.13089 = (long unsigned int) fd;
  handle = (void *) D.13089;
  if (fd > 1023) goto <D.13090>; else goto <D.13091>;
  <D.13090>:
  WSASetLastError (10022);
  return;
  <D.13091>:
  D.13092 = _wapi_handle_type (handle);
  if (D.13092 != 7) goto <D.13093>; else goto <D.13094>;
  <D.13093>:
  WSASetLastError (10038);
  return;
  <D.13094>:
  {
    long int __d;

    __d = (long int) fd;
    D.13096 = __builtin_constant_p (__d);
    if (D.13096 != 0) goto <D.13097>; else goto <D.13098>;
    <D.13097>:
    __d.109 = (unsigned long) __d;
    if (__d.109 <= 1023) goto <D.13101>; else goto <D.13102>;
    <D.13101>:
    iftmp.108 = __d / 64;
    goto <D.13103>;
    <D.13102>:
    iftmp.108 = __fdelt_warn (__d);
    <D.13103>:
    iftmp.107 = iftmp.108;
    goto <D.13104>;
    <D.13098>:
    iftmp.107 = __fdelt_chk (__d);
    <D.13104>:
    D.12283 = iftmp.107;
  }
  D.13105 = D.12283;
  D.13106 = set->fds_bits[D.13105];
  D.13107 = fd & 63;
  D.13108 = 1 << D.13107;
  D.13109 = (long int) D.13108;
  D.13110 = D.13106 | D.13109;
  set->fds_bits[D.13105] = D.13110;
}


WSARecv (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * received, guint32 * flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.13112;
  long int D.13113;
  long int D.13114;
  _Bool D.13117;
  long int D.13118;
  long int D.13119;
  unsigned int D.13122;
  int D.13123;
  int D.13126;
  unsigned int ret.110;
  int D.13128;
  unsigned int D.13129;
  int ret;
  struct msghdr hdr;

  try
    {
      D.13112 = overlapped != 0B;
      D.13113 = (long int) D.13112;
      D.13114 = __builtin_expect (D.13113, 0);
      if (D.13114 != 0) goto <D.13115>; else goto <D.13116>;
      <D.13115>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1554, "overlapped == NULL");
      <D.13116>:
      D.13117 = complete != 0B;
      D.13118 = (long int) D.13117;
      D.13119 = __builtin_expect (D.13118, 0);
      if (D.13119 != 0) goto <D.13120>; else goto <D.13121>;
      <D.13120>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1555, "complete == NULL");
      <D.13121>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      D.13122 = *flags;
      D.13123 = (int) D.13122;
      ret = _wapi_recvmsg (fd, &hdr, D.13123);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.13124>; else goto <D.13125>;
      <D.13124>:
      D.13126 = ret;
      return D.13126;
      <D.13125>:
      ret.110 = (unsigned int) ret;
      *received = ret.110;
      D.13128 = hdr.msg_flags;
      D.13129 = (unsigned int) D.13128;
      *flags = D.13129;
      D.13126 = 0;
      return D.13126;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


wsabuf_to_msghdr (struct WapiWSABuf * buffers, guint32 count, struct msghdr * hdr)
{
  long unsigned int D.13132;
  long unsigned int D.13133;
  long unsigned int D.13134;
  void * D.13135;
  struct iovec * D.13136;
  long unsigned int D.13137;
  long unsigned int D.13138;
  struct iovec * D.13139;
  struct WapiWSABuf * D.13140;
  void * D.13141;
  unsigned int D.13142;
  long unsigned int D.13143;
  guint32 i;

  memset (hdr, 0, 56);
  D.13132 = (long unsigned int) count;
  hdr->msg_iovlen = D.13132;
  D.13133 = (long unsigned int) count;
  D.13134 = D.13133 * 16;
  D.13135 = monoeg_malloc0 (D.13134);
  hdr->msg_iov = D.13135;
  i = 0;
  goto <D.12291>;
  <D.12290>:
  D.13136 = hdr->msg_iov;
  D.13137 = (long unsigned int) i;
  D.13138 = D.13137 * 16;
  D.13139 = D.13136 + D.13138;
  D.13137 = (long unsigned int) i;
  D.13138 = D.13137 * 16;
  D.13140 = buffers + D.13138;
  D.13141 = D.13140->buf;
  D.13139->iov_base = D.13141;
  D.13136 = hdr->msg_iov;
  D.13137 = (long unsigned int) i;
  D.13138 = D.13137 * 16;
  D.13139 = D.13136 + D.13138;
  D.13137 = (long unsigned int) i;
  D.13138 = D.13137 * 16;
  D.13140 = buffers + D.13138;
  D.13142 = D.13140->len;
  D.13143 = (long unsigned int) D.13142;
  D.13139->iov_len = D.13143;
  i = i + 1;
  <D.12291>:
  if (i < count) goto <D.12290>; else goto <D.12292>;
  <D.12292>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.13144;
  long unsigned int D.13145;

  D.13145 = __builtin_object_size (__dest, 0);
  D.13144 = __builtin___memset_chk (__dest, __ch, __len, D.13145);
  return D.13144;
}


_wapi_recvmsg (guint32 fd, struct msghdr * msg, int recv_flags)
{
  long unsigned int D.13147;
  unsigned int startup_count.111;
  int D.13151;
  <unnamed type> D.13152;
  int fd.112;
  long int D.13156;
  int * D.13158;
  int D.13159;
  int D.13161;
  struct _WapiHandle_socket * socket_handle.113;
  int D.13168;
  unsigned int errnum.114;
  unsigned int D.13172;
  void * handle;
  struct _WapiHandle_socket * socket_handle;
  gboolean ok;
  int ret;
  static const char __func__[14] = "_wapi_recvmsg";

  try
    {
      D.13147 = (long unsigned int) fd;
      handle = (void *) D.13147;
      startup_count.111 = startup_count;
      if (startup_count.111 == 0) goto <D.13149>; else goto <D.13150>;
      <D.13149>:
      WSASetLastError (10093);
      D.13151 = -1;
      return D.13151;
      <D.13150>:
      D.13152 = _wapi_handle_type (handle);
      if (D.13152 != 7) goto <D.13153>; else goto <D.13154>;
      <D.13153>:
      WSASetLastError (10038);
      D.13151 = -1;
      return D.13151;
      <D.13154>:
      <D.12056>:
      fd.112 = (int) fd;
      D.13156 = recvmsg (fd.112, msg, recv_flags);
      ret = (int) D.13156;
      if (ret == -1) goto <D.13157>; else goto <D.12057>;
      <D.13157>:
      D.13158 = __errno_location ();
      D.13159 = *D.13158;
      if (D.13159 == 4) goto <D.13160>; else goto <D.12057>;
      <D.13160>:
      D.13161 = _wapi_thread_cur_apc_pending ();
      if (D.13161 == 0) goto <D.12056>; else goto <D.12057>;
      <D.12057>:
      if (ret == 0) goto <D.13162>; else goto <D.13163>;
      <D.13162>:
      ok = _wapi_lookup_handle (handle, 7, &socket_handle);
      if (ok == 0) goto <D.13164>; else goto <D.13166>;
      <D.13166>:
      socket_handle.113 = socket_handle;
      D.13168 = socket_handle.113->still_readable;
      if (D.13168 != 1) goto <D.13164>; else goto <D.13165>;
      <D.13164>:
      ret = -1;
      D.13158 = __errno_location ();
      *D.13158 = 4;
      <D.13165>:
      <D.13163>:
      if (ret == -1) goto <D.13169>; else goto <D.13170>;
      <D.13169>:
      {
        gint errnum;

        D.13158 = __errno_location ();
        errnum = *D.13158;
        errnum.114 = (unsigned int) errnum;
        D.13172 = errno_to_WSA (errnum.114, &__func__);
        errnum = (gint) D.13172;
        WSASetLastError (errnum);
        D.13151 = -1;
        return D.13151;
      }
      <D.13170>:
      D.13151 = ret;
      return D.13151;
    }
  finally
    {
      socket_handle = {CLOBBER};
    }
}


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

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


WSASend (guint32 fd, struct WapiWSABuf * buffers, guint32 count, guint32 * sent, guint32 flags, struct WapiOverlapped * overlapped, void (*WapiOverlappedCB) (guint32, guint32, struct WapiOverlapped *) * complete)
{
  _Bool D.13176;
  long int D.13177;
  long int D.13178;
  _Bool D.13181;
  long int D.13182;
  long int D.13183;
  int flags.115;
  int D.13189;
  unsigned int ret.116;
  int ret;
  struct msghdr hdr;

  try
    {
      D.13176 = overlapped != 0B;
      D.13177 = (long int) D.13176;
      D.13178 = __builtin_expect (D.13177, 0);
      if (D.13178 != 0) goto <D.13179>; else goto <D.13180>;
      <D.13179>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1578, "overlapped == NULL");
      <D.13180>:
      D.13181 = complete != 0B;
      D.13182 = (long int) D.13181;
      D.13183 = __builtin_expect (D.13182, 0);
      if (D.13183 != 0) goto <D.13184>; else goto <D.13185>;
      <D.13184>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sockets.c", 1579, "complete == NULL");
      <D.13185>:
      wsabuf_to_msghdr (buffers, count, &hdr);
      flags.115 = (int) flags;
      ret = _wapi_sendmsg (fd, &hdr, flags.115);
      msghdr_iov_free (&hdr);
      if (ret == -1) goto <D.13187>; else goto <D.13188>;
      <D.13187>:
      D.13189 = ret;
      return D.13189;
      <D.13188>:
      ret.116 = (unsigned int) ret;
      *sent = ret.116;
      D.13189 = 0;
      return D.13189;
    }
  finally
    {
      hdr = {CLOBBER};
    }
}


_wapi_sendmsg (guint32 fd, const struct msghdr * msg, int send_flags)
{
  long unsigned int D.13193;
  unsigned int startup_count.117;
  int D.13197;
  <unnamed type> D.13198;
  int fd.118;
  long int D.13202;
  int * D.13204;
  int D.13205;
  int D.13207;
  unsigned int errnum.119;
  unsigned int D.13211;
  void * handle;
  int ret;
  static const char __func__[14] = "_wapi_sendmsg";

  D.13193 = (long unsigned int) fd;
  handle = (void *) D.13193;
  startup_count.117 = startup_count;
  if (startup_count.117 == 0) goto <D.13195>; else goto <D.13196>;
  <D.13195>:
  WSASetLastError (10093);
  D.13197 = -1;
  return D.13197;
  <D.13196>:
  D.13198 = _wapi_handle_type (handle);
  if (D.13198 != 7) goto <D.13199>; else goto <D.13200>;
  <D.13199>:
  WSASetLastError (10038);
  D.13197 = -1;
  return D.13197;
  <D.13200>:
  <D.12093>:
  fd.118 = (int) fd;
  D.13202 = sendmsg (fd.118, msg, send_flags);
  ret = (int) D.13202;
  if (ret == -1) goto <D.13203>; else goto <D.12094>;
  <D.13203>:
  D.13204 = __errno_location ();
  D.13205 = *D.13204;
  if (D.13205 == 4) goto <D.13206>; else goto <D.12094>;
  <D.13206>:
  D.13207 = _wapi_thread_cur_apc_pending ();
  if (D.13207 == 0) goto <D.12093>; else goto <D.12094>;
  <D.12094>:
  if (ret == -1) goto <D.13208>; else goto <D.13209>;
  <D.13208>:
  {
    gint errnum;

    D.13204 = __errno_location ();
    errnum = *D.13204;
    errnum.119 = (unsigned int) errnum;
    D.13211 = errno_to_WSA (errnum.119, &__func__);
    errnum = (gint) D.13211;
    WSASetLastError (errnum);
    D.13197 = -1;
    return D.13197;
  }
  <D.13209>:
  D.13197 = ret;
  return D.13197;
}