ves_icall_System_Net_Sockets_Socket_Socket_internal (struct MonoObject * this, gint32 family, gint32 type, gint32 proto, gint32 * error)
{
  void * D.19668;
  int D.19675;
  long unsigned int D.19680;
  SOCKET sock;
  gint32 sock_family;
  gint32 sock_proto;
  gint32 sock_type;

  *error = 0;
  sock_family = convert_family (family);
  if (sock_family == -1) goto <D.19666>; else goto <D.19667>;
  <D.19666>:
  *error = 10047;
  D.19668 = 0B;
  return D.19668;
  <D.19667>:
  sock_proto = convert_proto (proto);
  if (sock_proto == -1) goto <D.19669>; else goto <D.19670>;
  <D.19669>:
  *error = 10043;
  D.19668 = 0B;
  return D.19668;
  <D.19670>:
  sock_type = convert_type (type);
  if (sock_type == -1) goto <D.19671>; else goto <D.19672>;
  <D.19671>:
  *error = 10044;
  D.19668 = 0B;
  return D.19668;
  <D.19672>:
  sock = _wapi_socket (sock_family, sock_type, sock_proto, 0B, 0, 1);
  if (sock == 4294967295) goto <D.19673>; else goto <D.19674>;
  <D.19673>:
  D.19675 = WSAGetLastError ();
  *error = D.19675;
  D.19668 = 0B;
  return D.19668;
  <D.19674>:
  if (sock_family == 2) goto <D.19676>; else goto <D.19677>;
  <D.19676>:
  if (sock_type == 2) goto <D.19678>; else goto <D.19679>;
  <D.19678>:
  D.19680 = (long unsigned int) sock;
  D.19668 = (void *) D.19680;
  return D.19668;
  <D.19679>:
  <D.19677>:
  if (sock_family == 10) goto <D.19681>; else goto <D.19682>;
  <D.19681>:
  if (sock_type == 2) goto <D.19683>; else goto <D.19684>;
  <D.19683>:
  D.19680 = (long unsigned int) sock;
  D.19668 = (void *) D.19680;
  return D.19668;
  <D.19684>:
  <D.19682>:
  D.19680 = (long unsigned int) sock;
  D.19668 = (void *) D.19680;
  return D.19668;
}


convert_family (MonoAddressFamily mono_family)
{
  gint32 D.19686;
  gint32 family;

  family = -1;
  switch (mono_family) <default: <D.18933>, case -1: <D.18904>, case 0: <D.18924>, case 1: <D.18925>, case 2: <D.18926>, case 3: <D.18905>, case 4: <D.18906>, case 5: <D.18907>, case 6: <D.18927>, case 7: <D.18908>, case 8: <D.18909>, case 9: <D.18910>, case 10: <D.18911>, case 11: <D.18928>, case 12: <D.18929>, case 13: <D.18912>, case 14: <D.18913>, case 15: <D.18914>, case 16: <D.18930>, case 17: <D.18915>, case 18: <D.18916>, case 19: <D.18917>, case 21: <D.18918>, case 22: <D.18919>, case 23: <D.18931>, case 24: <D.18920>, case 25: <D.18921>, case 26: <D.18932>, case 28: <D.18922>>
  <D.18904>:
  <D.18905>:
  <D.18906>:
  <D.18907>:
  <D.18908>:
  <D.18909>:
  <D.18910>:
  <D.18911>:
  <D.18912>:
  <D.18913>:
  <D.18914>:
  <D.18915>:
  <D.18916>:
  <D.18917>:
  <D.18918>:
  <D.18919>:
  <D.18920>:
  <D.18921>:
  <D.18922>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.AddressFamily has unsupported value 0x%x", mono_family);
  goto <D.18923>;
  <D.18924>:
  family = 0;
  goto <D.18923>;
  <D.18925>:
  family = 1;
  goto <D.18923>;
  <D.18926>:
  family = 2;
  goto <D.18923>;
  <D.18927>:
  family = 4;
  goto <D.18923>;
  <D.18928>:
  family = 22;
  goto <D.18923>;
  <D.18929>:
  family = 12;
  goto <D.18923>;
  <D.18930>:
  family = 5;
  goto <D.18923>;
  <D.18931>:
  family = 10;
  goto <D.18923>;
  <D.18932>:
  family = 23;
  goto <D.18923>;
  <D.18933>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.AddressFamily has unknown value 0x%x", mono_family);
  <D.18923>:
  D.19686 = family;
  return D.19686;
}


convert_proto (MonoProtocolType mono_proto)
{
  gint32 D.19688;
  gint32 proto;

  proto = -1;
  switch (mono_proto) <default: <D.18981>, case -1: <D.18980>, case 0: <D.18965>, case 1: <D.18967>, case 2: <D.18968>, case 3: <D.18969>, case 6: <D.18970>, case 12: <D.18971>, case 17: <D.18972>, case 22: <D.18973>, case 41: <D.18966>, case 77: <D.18975>, case 255: <D.18976>, case 1000: <D.18977>, case 1256: <D.18978>, case 1257: <D.18979>>
  <D.18965>:
  <D.18966>:
  <D.18967>:
  <D.18968>:
  <D.18969>:
  <D.18970>:
  <D.18971>:
  <D.18972>:
  <D.18973>:
  proto = mono_proto;
  goto <D.18974>;
  <D.18975>:
  <D.18976>:
  <D.18977>:
  <D.18978>:
  <D.18979>:
  <D.18980>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.ProtocolType has unsupported value 0x%x", mono_proto);
  goto <D.18974>;
  <D.18981>:
  goto <D.18974>;
  <D.18974>:
  D.19688 = proto;
  return D.19688;
}


convert_type (MonoSocketType mono_type)
{
  gint32 D.19691;
  gint32 type;

  type = -1;
  switch (mono_type) <default: <D.18960>, case -1: <D.18959>, case 1: <D.18953>, case 2: <D.18955>, case 3: <D.18956>, case 4: <D.18957>, case 5: <D.18958>>
  <D.18953>:
  type = 1;
  goto <D.18954>;
  <D.18955>:
  type = 2;
  goto <D.18954>;
  <D.18956>:
  type = 3;
  goto <D.18954>;
  <D.18957>:
  type = 4;
  goto <D.18954>;
  <D.18958>:
  type = 5;
  goto <D.18954>;
  <D.18959>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketType has unsupported value 0x%x", mono_type);
  goto <D.18954>;
  <D.18960>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketType has unknown value 0x%x", mono_type);
  <D.18954>:
  D.19691 = type;
  return D.19691;
}


ves_icall_System_Net_Sockets_Socket_Close_internal (SOCKET sock, gint32 * error)
{
  int sock.0;

  *error = 0;
  sock.0 = (int) sock;
  mono_thread_pool_remove_socket (sock.0);
  closesocket (sock);
}


ves_icall_System_Net_Sockets_SocketException_WSAGetLastError_internal ()
{
  gint32 D.19694;

  D.19694 = WSAGetLastError ();
  return D.19694;
}


ves_icall_System_Net_Sockets_Socket_Available_internal (SOCKET sock, gint32 * error)
{
  int D.19698;
  gint32 D.19699;
  int ret;
  int amount;

  try
    {
      *error = 0;
      ret = ioctlsocket (sock, 1074030207, &amount);
      if (ret == -1) goto <D.19696>; else goto <D.19697>;
      <D.19696>:
      D.19698 = WSAGetLastError ();
      *error = D.19698;
      D.19699 = 0;
      return D.19699;
      <D.19697>:
      D.19699 = amount;
      return D.19699;
    }
  finally
    {
      amount = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_Blocking_internal (SOCKET sock, gboolean block, gint32 * error)
{
  int block.1;
  _Bool D.19703;
  int block.2;
  int D.19707;
  int ret;

  *error = 0;
  block.1 = block;
  D.19703 = block.1 == 0;
  block.2 = (int) D.19703;
  block = block.2;
  ret = ioctlsocket (sock, -2147195266, &block);
  if (ret == -1) goto <D.19705>; else goto <D.19706>;
  <D.19705>:
  D.19707 = WSAGetLastError ();
  *error = D.19707;
  <D.19706>:
}


ves_icall_System_Net_Sockets_Socket_Accept_internal (SOCKET sock, gint32 * error, gboolean blocking)
{
  int D.19710;
  void * D.19711;
  long unsigned int D.19712;
  SOCKET newsock;

  *error = 0;
  newsock = _wapi_accept (sock, 0B, 0B);
  if (newsock == 4294967295) goto <D.19708>; else goto <D.19709>;
  <D.19708>:
  D.19710 = WSAGetLastError ();
  *error = D.19710;
  D.19711 = 0B;
  return D.19711;
  <D.19709>:
  D.19712 = (long unsigned int) newsock;
  D.19711 = (void *) D.19712;
  return D.19711;
}


ves_icall_System_Net_Sockets_Socket_Listen_internal (SOCKET sock, guint32 backlog, gint32 * error)
{
  int backlog.3;
  int D.19717;
  int ret;

  *error = 0;
  backlog.3 = (int) backlog;
  ret = _wapi_listen (sock, backlog.3);
  if (ret == -1) goto <D.19715>; else goto <D.19716>;
  <D.19715>:
  D.19717 = WSAGetLastError ();
  *error = D.19717;
  <D.19716>:
}


ves_icall_System_Net_Sockets_Socket_LocalEndPoint_internal (SOCKET sock, gint32 af, gint32 * error)
{
  int D.19718;
  int D.19719;
  unsigned int salen.4;
  unsigned int salen.5;
  struct MonoObject * D.19724;
  gchar * iftmp.6;
  long unsigned int D.19728;
  long unsigned int D.19730;
  int D.19733;
  int salen.7;
  gchar * sa;
  socklen_t salen;
  int ret;
  struct MonoObject * result;

  try
    {
      *error = 0;
      D.19718 = convert_family (af);
      D.19719 = get_sockaddr_size (D.19718);
      salen.4 = (unsigned int) D.19719;
      salen = salen.4;
      salen.5 = salen;
      if (salen.5 == 0) goto <D.19722>; else goto <D.19723>;
      <D.19722>:
      *error = 10047;
      D.19724 = 0B;
      return D.19724;
      <D.19723>:
      salen.5 = salen;
      if (salen.5 <= 128) goto <D.19726>; else goto <D.19727>;
      <D.19726>:
      salen.5 = salen;
      D.19728 = (long unsigned int) salen.5;
      iftmp.6 = __builtin_alloca (D.19728);
      goto <D.19729>;
      <D.19727>:
      salen.5 = salen;
      D.19730 = (long unsigned int) salen.5;
      iftmp.6 = monoeg_malloc0 (D.19730);
      <D.19729>:
      sa = iftmp.6;
      ret = _wapi_getsockname (sock, sa, &salen);
      if (ret == -1) goto <D.19731>; else goto <D.19732>;
      <D.19731>:
      D.19733 = WSAGetLastError ();
      *error = D.19733;
      salen.5 = salen;
      if (salen.5 > 128) goto <D.19734>; else goto <D.19735>;
      <D.19734>:
      monoeg_g_free (sa);
      <D.19735>:
      D.19724 = 0B;
      return D.19724;
      <D.19732>:
      salen.5 = salen;
      salen.7 = (int) salen.5;
      result = create_object_from_sockaddr (sa, salen.7, error);
      salen.5 = salen;
      if (salen.5 > 128) goto <D.19737>; else goto <D.19738>;
      <D.19737>:
      monoeg_g_free (sa);
      <D.19738>:
      D.19724 = result;
      return D.19724;
    }
  finally
    {
      salen = {CLOBBER};
    }
}


get_sockaddr_size (int family)
{
  int D.19749;
  int size;

  size = 0;
  if (family == 2) goto <D.19741>; else goto <D.19742>;
  <D.19741>:
  size = 16;
  goto <D.19743>;
  <D.19742>:
  if (family == 10) goto <D.19744>; else goto <D.19745>;
  <D.19744>:
  size = 28;
  goto <D.19746>;
  <D.19745>:
  if (family == 1) goto <D.19747>; else goto <D.19748>;
  <D.19747>:
  size = 110;
  <D.19748>:
  <D.19746>:
  <D.19743>:
  D.19749 = size;
  return D.19749;
}


create_object_from_sockaddr (struct sockaddr * saddr, int sa_size, gint32 * error)
{
  struct MonoClass * D.19751;
  struct MonoImage * D.19754;
  struct MonoClass * D.19755;
  _Bool D.19756;
  long int D.19757;
  long int D.19758;
  struct MonoClassField * D.19761;
  struct MonoClassField * D.19764;
  _Bool D.19765;
  long int D.19766;
  long int D.19767;
  struct MonoClass * D.19150;
  struct MonoClass * tmp_klass.8;
  struct MonoClass * D.19773;
  struct MonoClass * tmp_klass.9;
  _Bool D.19775;
  long int D.19776;
  long int D.19777;
  struct MonoVTable * D.19780;
  int D.19781;
  long unsigned int D.19782;
  short unsigned int D.19783;
  struct MonoObject * D.19786;
  unsigned char D.19787;
  int D.19788;
  unsigned char D.19789;
  short unsigned int port.10;
  unsigned int D.19792;
  struct MonoImage * D.19795;
  struct MonoException * D.19796;
  short unsigned int D.19797;
  unsigned char D.19798;
  unsigned char D.19799;
  unsigned int D.19800;
  unsigned char D.19801;
  unsigned int D.19802;
  unsigned char D.19803;
  unsigned int D.19804;
  unsigned char D.19805;
  unsigned char D.19806;
  short unsigned int port.11;
  struct MonoImage * D.19811;
  struct MonoException * D.19812;
  short unsigned int D.19813;
  unsigned char D.19814;
  unsigned char D.19815;
  struct in6_addr * D.19816;
  int D.19817;
  int D.19820;
  long unsigned int D.19821;
  unsigned char D.19823;
  unsigned int D.19824;
  unsigned char D.19825;
  unsigned int D.19826;
  unsigned char D.19827;
  unsigned int D.19828;
  unsigned char D.19829;
  unsigned int D.19830;
  unsigned char D.19831;
  int D.19834;
  long unsigned int D.19835;
  char D.19836;
  struct MonoDomain * domain;
  struct MonoObject * sockaddr_obj;
  struct MonoArray * data;
  MonoAddressFamily family;

  domain = mono_domain_get ();
  D.19751 = domain->sockaddr_class;
  if (D.19751 == 0B) goto <D.19752>; else goto <D.19753>;
  <D.19752>:
  D.19754 = get_socket_assembly ();
  D.19755 = mono_class_from_name (D.19754, "System.Net", "SocketAddress");
  domain->sockaddr_class = D.19755;
  D.19751 = domain->sockaddr_class;
  D.19756 = D.19751 == 0B;
  D.19757 = (long int) D.19756;
  D.19758 = __builtin_expect (D.19757, 0);
  if (D.19758 != 0) goto <D.19759>; else goto <D.19760>;
  <D.19759>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 935, "domain->sockaddr_class");
  <D.19760>:
  <D.19753>:
  D.19751 = domain->sockaddr_class;
  sockaddr_obj = mono_object_new (domain, D.19751);
  D.19761 = domain->sockaddr_data_field;
  if (D.19761 == 0B) goto <D.19762>; else goto <D.19763>;
  <D.19762>:
  D.19751 = domain->sockaddr_class;
  D.19764 = mono_class_get_field_from_name (D.19751, "data");
  domain->sockaddr_data_field = D.19764;
  D.19761 = domain->sockaddr_data_field;
  D.19765 = D.19761 == 0B;
  D.19766 = (long int) D.19765;
  D.19767 = __builtin_expect (D.19766, 0);
  if (D.19767 != 0) goto <D.19768>; else goto <D.19769>;
  <D.19768>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 942, "domain->sockaddr_data_field");
  <D.19769>:
  <D.19763>:
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.8 = tmp_klass;
      if (tmp_klass.8 == 0B) goto <D.19771>; else goto <D.19772>;
      <D.19771>:
      D.19773 = mono_get_byte_class ();
      tmp_klass.9 = mono_array_class_get (D.19773, 1);
      tmp_klass = tmp_klass.9;
      tmp_klass.8 = tmp_klass;
      D.19775 = tmp_klass.8 == 0B;
      D.19776 = (long int) D.19775;
      D.19777 = __builtin_expect (D.19776, 0);
      if (D.19777 != 0) goto <D.19778>; else goto <D.19779>;
      <D.19778>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 949, "tmp_klass");
      <D.19779>:
      <D.19772>:
    }
    D.19150 = tmp_klass;
  }
  D.19780 = mono_class_vtable (domain, D.19150);
  D.19781 = sa_size + 2;
  D.19782 = (long unsigned int) D.19781;
  data = mono_array_new_specific (D.19780, D.19782);
  D.19783 = saddr->sa_family;
  family = convert_to_mono_family (D.19783);
  if (family == -1) goto <D.19784>; else goto <D.19785>;
  <D.19784>:
  *error = 10047;
  D.19786 = 0B;
  return D.19786;
  <D.19785>:
  {
    guint8 * __p;

    __p = mono_array_addr_with_size (data, 1, 0);
    D.19787 = (unsigned char) family;
    *__p = D.19787;
  }
  {
    guint8 * __p;

    __p = mono_array_addr_with_size (data, 1, 1);
    D.19788 = family >> 8;
    D.19789 = (unsigned char) D.19788;
    *__p = D.19789;
  }
  D.19783 = saddr->sa_family;
  if (D.19783 == 2) goto <D.19790>; else goto <D.19791>;
  <D.19790>:
  {
    struct sockaddr_in * sa_in;
    guint16 port;
    guint32 address;

    sa_in = saddr;
    {
      short unsigned int __bsx;

      __bsx = sa_in->sin_port;
      port.10 = __bsx r>> 8;
    }
    port = port.10;
    D.19792 = sa_in->sin_addr.s_addr;
    address = __bswap_32 (D.19792);
    if (sa_size <= 7) goto <D.19793>; else goto <D.19794>;
    <D.19793>:
    D.19795 = mono_get_corlib ();
    D.19796 = mono_exception_from_name (D.19795, "System", "SystemException");
    mono_raise_exception (D.19796);
    <D.19794>:
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 2);
      D.19797 = port >> 8;
      D.19798 = (unsigned char) D.19797;
      *__p = D.19798;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 3);
      D.19799 = (unsigned char) port;
      *__p = D.19799;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 4);
      D.19800 = address >> 24;
      D.19801 = (unsigned char) D.19800;
      *__p = D.19801;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 5);
      D.19802 = address >> 16;
      D.19803 = (unsigned char) D.19802;
      *__p = D.19803;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 6);
      D.19804 = address >> 8;
      D.19805 = (unsigned char) D.19804;
      *__p = D.19805;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 7);
      D.19806 = (unsigned char) address;
      *__p = D.19806;
    }
    D.19761 = domain->sockaddr_data_field;
    mono_field_set_value (sockaddr_obj, D.19761, data);
    D.19786 = sockaddr_obj;
    return D.19786;
  }
  <D.19791>:
  D.19783 = saddr->sa_family;
  if (D.19783 == 10) goto <D.19807>; else goto <D.19808>;
  <D.19807>:
  {
    struct sockaddr_in6 * sa_in;
    int i;
    guint16 port;

    sa_in = saddr;
    {
      short unsigned int __bsx;

      __bsx = sa_in->sin6_port;
      port.11 = __bsx r>> 8;
    }
    port = port.11;
    if (sa_size <= 27) goto <D.19809>; else goto <D.19810>;
    <D.19809>:
    D.19811 = mono_get_corlib ();
    D.19812 = mono_exception_from_name (D.19811, "System", "SystemException");
    mono_raise_exception (D.19812);
    <D.19810>:
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 2);
      D.19813 = port >> 8;
      D.19814 = (unsigned char) D.19813;
      *__p = D.19814;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 3);
      D.19815 = (unsigned char) port;
      *__p = D.19815;
    }
    D.19816 = &sa_in->sin6_addr;
    D.19817 = is_ipv4_mapped_any (D.19816);
    if (D.19817 != 0) goto <D.19818>; else goto <D.19819>;
    <D.19818>:
    i = 0;
    goto <D.19173>;
    <D.19172>:
    {
      guint8 * __p;

      D.19820 = i + 8;
      D.19821 = (long unsigned int) D.19820;
      __p = mono_array_addr_with_size (data, 1, D.19821);
      *__p = 0;
    }
    i = i + 1;
    <D.19173>:
    if (i <= 15) goto <D.19172>; else goto <D.19174>;
    <D.19174>:
    goto <D.19822>;
    <D.19819>:
    i = 0;
    goto <D.19177>;
    <D.19176>:
    {
      guint8 * __p;

      D.19820 = i + 8;
      D.19821 = (long unsigned int) D.19820;
      __p = mono_array_addr_with_size (data, 1, D.19821);
      D.19823 = sa_in->sin6_addr.__in6_u.__u6_addr8[i];
      *__p = D.19823;
    }
    i = i + 1;
    <D.19177>:
    if (i <= 15) goto <D.19176>; else goto <D.19178>;
    <D.19178>:
    <D.19822>:
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 24);
      D.19824 = sa_in->sin6_scope_id;
      D.19825 = (unsigned char) D.19824;
      *__p = D.19825;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 25);
      D.19824 = sa_in->sin6_scope_id;
      D.19826 = D.19824 >> 8;
      D.19827 = (unsigned char) D.19826;
      *__p = D.19827;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 26);
      D.19824 = sa_in->sin6_scope_id;
      D.19828 = D.19824 >> 16;
      D.19829 = (unsigned char) D.19828;
      *__p = D.19829;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 27);
      D.19824 = sa_in->sin6_scope_id;
      D.19830 = D.19824 >> 24;
      D.19831 = (unsigned char) D.19830;
      *__p = D.19831;
    }
    D.19761 = domain->sockaddr_data_field;
    mono_field_set_value (sockaddr_obj, D.19761, data);
    D.19786 = sockaddr_obj;
    return D.19786;
  }
  <D.19808>:
  D.19783 = saddr->sa_family;
  if (D.19783 == 1) goto <D.19832>; else goto <D.19833>;
  <D.19832>:
  {
    int i;

    i = 0;
    goto <D.19186>;
    <D.19185>:
    {
      guint8 * __p;

      D.19834 = i + 2;
      D.19835 = (long unsigned int) D.19834;
      __p = mono_array_addr_with_size (data, 1, D.19835);
      D.19836 = saddr->sa_data[i];
      *__p = D.19836;
    }
    i = i + 1;
    <D.19186>:
    if (i < sa_size) goto <D.19185>; else goto <D.19187>;
    <D.19187>:
    D.19761 = domain->sockaddr_data_field;
    mono_field_set_value (sockaddr_obj, D.19761, data);
    D.19786 = sockaddr_obj;
    return D.19786;
  }
  <D.19833>:
  *error = 10047;
  D.19786 = 0B;
  return D.19786;
}


get_socket_assembly ()
{
  struct MonoImage * D.19838;
  struct MonoImage * D.19845;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.19838 = domain->socket_assembly;
  if (D.19838 == 0B) goto <D.19839>; else goto <D.19840>;
  <D.19839>:
  {
    struct MonoImage * socket_assembly;

    socket_assembly = mono_image_loaded ("System");
    if (socket_assembly == 0B) goto <D.19841>; else goto <D.19842>;
    <D.19841>:
    {
      struct MonoAssembly * sa;

      sa = mono_assembly_open ("System.dll", 0B);
      if (sa == 0B) goto <D.19843>; else goto <D.19844>;
      <D.19843>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "socket-io.c", 689);
      <D.19844>:
      socket_assembly = mono_assembly_get_image (sa);
    }
    <D.19842>:
    mono_memory_barrier ();
    domain->socket_assembly = socket_assembly;
  }
  <D.19840>:
  D.19845 = domain->socket_assembly;
  return D.19845;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


convert_to_mono_family (guint16 af_family)
{
  int D.19847;
  MonoAddressFamily D.19848;
  MonoAddressFamily family;

  family = -1;
  D.19847 = (int) af_family;
  switch (D.19847) <default: <D.18948>, case 0: <D.18938>, case 1: <D.18940>, case 2: <D.18941>, case 4: <D.18942>, case 5: <D.18945>, case 10: <D.18946>, case 12: <D.18944>, case 22: <D.18943>, case 23: <D.18947>>
  <D.18938>:
  family = 0;
  goto <D.18939>;
  <D.18940>:
  family = 1;
  goto <D.18939>;
  <D.18941>:
  family = 2;
  goto <D.18939>;
  <D.18942>:
  family = 6;
  goto <D.18939>;
  <D.18943>:
  family = 11;
  goto <D.18939>;
  <D.18944>:
  family = 12;
  goto <D.18939>;
  <D.18945>:
  family = 16;
  goto <D.18939>;
  <D.18946>:
  family = 23;
  goto <D.18939>;
  <D.18947>:
  family = 26;
  goto <D.18939>;
  <D.18948>:
  D.19847 = (int) af_family;
  monoeg_g_log (0B, 16, "unknown address family 0x%x", D.19847);
  <D.18939>:
  D.19848 = family;
  return D.19848;
}


__bswap_32 (unsigned int __bsx)
{
  unsigned int D.19850;

  D.19850 = __builtin_bswap32 (__bsx);
  return D.19850;
}


is_ipv4_mapped_any (const struct in6_addr * addr)
{
  unsigned char D.19852;
  gboolean D.19855;
  unsigned int D.19856;
  unsigned int D.19857;
  int i;

  i = 0;
  goto <D.19135>;
  <D.19134>:
  D.19852 = addr->__in6_u.__u6_addr8[i];
  if (D.19852 != 0) goto <D.19853>; else goto <D.19854>;
  <D.19853>:
  D.19855 = 0;
  return D.19855;
  <D.19854>:
  i = i + 1;
  <D.19135>:
  if (i <= 9) goto <D.19134>; else goto <D.19136>;
  <D.19136>:
  D.19856 = BIT_FIELD_REF <*addr, 32, 64>;
  D.19857 = D.19856 & 4294901760;
  if (D.19857 != 4294901760) goto <D.19858>; else goto <D.19859>;
  <D.19858>:
  D.19855 = 0;
  return D.19855;
  <D.19859>:
  i = 12;
  goto <D.19138>;
  <D.19137>:
  D.19852 = addr->__in6_u.__u6_addr8[i];
  if (D.19852 != 0) goto <D.19860>; else goto <D.19861>;
  <D.19860>:
  D.19855 = 0;
  return D.19855;
  <D.19861>:
  i = i + 1;
  <D.19138>:
  if (i <= 15) goto <D.19137>; else goto <D.19139>;
  <D.19139>:
  D.19855 = 1;
  return D.19855;
}


ves_icall_System_Net_Sockets_Socket_RemoteEndPoint_internal (SOCKET sock, gint32 af, gint32 * error)
{
  int D.19863;
  int D.19864;
  unsigned int salen.12;
  unsigned int salen.13;
  struct MonoObject * D.19869;
  gchar * iftmp.14;
  long unsigned int D.19873;
  long unsigned int D.19875;
  int D.19878;
  int salen.15;
  gchar * sa;
  socklen_t salen;
  int ret;
  struct MonoObject * result;

  try
    {
      *error = 0;
      D.19863 = convert_family (af);
      D.19864 = get_sockaddr_size (D.19863);
      salen.12 = (unsigned int) D.19864;
      salen = salen.12;
      salen.13 = salen;
      if (salen.13 == 0) goto <D.19867>; else goto <D.19868>;
      <D.19867>:
      *error = 10047;
      D.19869 = 0B;
      return D.19869;
      <D.19868>:
      salen.13 = salen;
      if (salen.13 <= 128) goto <D.19871>; else goto <D.19872>;
      <D.19871>:
      salen.13 = salen;
      D.19873 = (long unsigned int) salen.13;
      iftmp.14 = __builtin_alloca (D.19873);
      goto <D.19874>;
      <D.19872>:
      salen.13 = salen;
      D.19875 = (long unsigned int) salen.13;
      iftmp.14 = monoeg_malloc0 (D.19875);
      <D.19874>:
      sa = iftmp.14;
      ret = _wapi_getpeername (sock, sa, &salen);
      if (ret == -1) goto <D.19876>; else goto <D.19877>;
      <D.19876>:
      D.19878 = WSAGetLastError ();
      *error = D.19878;
      salen.13 = salen;
      if (salen.13 > 128) goto <D.19879>; else goto <D.19880>;
      <D.19879>:
      monoeg_g_free (sa);
      <D.19880>:
      D.19869 = 0B;
      return D.19869;
      <D.19877>:
      salen.13 = salen;
      salen.15 = (int) salen.13;
      result = create_object_from_sockaddr (sa, salen.15, error);
      salen.13 = salen;
      if (salen.13 > 128) goto <D.19882>; else goto <D.19883>;
      <D.19882>:
      monoeg_g_free (sa);
      <D.19883>:
      D.19869 = result;
      return D.19869;
    }
  finally
    {
      salen = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_Bind_internal (SOCKET sock, struct MonoObject * sockaddr, gint32 * error)
{
  int D.19886;
  unsigned int sa_size.16;
  int D.19892;
  struct sockaddr * sa;
  socklen_t sa_size;
  int ret;

  try
    {
      *error = 0;
      sa = create_sockaddr_from_object (sockaddr, &sa_size, error);
      D.19886 = *error;
      if (D.19886 != 0) goto <D.19887>; else goto <D.19888>;
      <D.19887>:
      return;
      <D.19888>:
      sa_size.16 = sa_size;
      ret = _wapi_bind (sock, sa, sa_size.16);
      if (ret == -1) goto <D.19890>; else goto <D.19891>;
      <D.19890>:
      D.19892 = WSAGetLastError ();
      *error = D.19892;
      <D.19891>:
      monoeg_g_free (sa);
    }
  finally
    {
      sa_size = {CLOBBER};
    }
}


create_sockaddr_from_object (struct MonoObject * saddr_obj, socklen_t * sa_size, gint32 * error)
{
  struct MonoVTable * D.19896;
  struct MonoClass * D.19897;
  int D.19898;
  sizetype D.19899;
  struct MonoArray * * D.19900;
  long unsigned int D.19901;
  struct MonoImage * D.19904;
  struct MonoException * D.19905;
  char * D.19906;
  unsigned char D.19907;
  int D.19908;
  char * D.19909;
  unsigned char D.19910;
  int D.19911;
  int D.19912;
  int D.19913;
  struct MonoImage * D.19918;
  struct MonoException * D.19919;
  char * D.19920;
  unsigned char D.19921;
  short unsigned int D.19922;
  short unsigned int D.19923;
  char * D.19924;
  unsigned char D.19925;
  short unsigned int D.19926;
  char * D.19927;
  unsigned char D.19928;
  int D.19929;
  int D.19930;
  char * D.19931;
  unsigned char D.19932;
  int D.19933;
  int D.19934;
  int D.19935;
  char * D.19936;
  unsigned char D.19937;
  int D.19938;
  int D.19939;
  int D.19940;
  char * D.19941;
  unsigned char D.19942;
  int D.19943;
  int D.19944;
  short unsigned int D.19945;
  unsigned int D.19946;
  short unsigned int D.19223;
  struct sockaddr * D.19947;
  struct MonoImage * D.19952;
  struct MonoException * D.19953;
  char * D.19954;
  unsigned char D.19955;
  short unsigned int D.19956;
  char * D.19957;
  unsigned char D.19958;
  short unsigned int D.19959;
  short unsigned int D.19960;
  char * D.19961;
  unsigned char D.19962;
  int D.19963;
  char * D.19964;
  unsigned char D.19965;
  int D.19966;
  int D.19967;
  int D.19968;
  char * D.19969;
  unsigned char D.19970;
  int D.19971;
  int D.19972;
  int D.19973;
  char * D.19974;
  unsigned char D.19975;
  int D.19976;
  int D.19977;
  int D.19978;
  short unsigned int D.19229;
  int D.19979;
  long unsigned int D.19980;
  char * D.19981;
  unsigned char D.19982;
  struct MonoException * D.19987;
  int D.19988;
  long unsigned int D.19989;
  char * D.19990;
  unsigned char D.19991;
  int D.19992;
  unsigned int len.17;
  struct MonoClassField * field;
  struct MonoArray * data;
  gint32 family;
  int len;

  D.19896 = saddr_obj->vtable;
  D.19897 = D.19896->klass;
  field = mono_class_get_field_from_name (D.19897, "data");
  D.19898 = field->offset;
  D.19899 = (sizetype) D.19898;
  D.19900 = saddr_obj + D.19899;
  data = *D.19900;
  D.19901 = mono_array_length (data);
  len = (int) D.19901;
  if (len <= 1) goto <D.19902>; else goto <D.19903>;
  <D.19902>:
  D.19904 = mono_get_corlib ();
  D.19905 = mono_exception_from_name (D.19904, "System", "SystemException");
  mono_raise_exception (D.19905);
  <D.19903>:
  D.19906 = mono_array_addr_with_size (data, 1, 0);
  D.19907 = MEM[(guint8 *)D.19906];
  D.19908 = (int) D.19907;
  D.19909 = mono_array_addr_with_size (data, 1, 1);
  D.19910 = MEM[(guint8 *)D.19909];
  D.19911 = (int) D.19910;
  D.19912 = D.19911 << 8;
  D.19913 = D.19908 + D.19912;
  family = convert_family (D.19913);
  if (family == 2) goto <D.19914>; else goto <D.19915>;
  <D.19914>:
  {
    struct sockaddr_in * sa;
    guint16 port;
    guint32 address;

    if (len <= 7) goto <D.19916>; else goto <D.19917>;
    <D.19916>:
    D.19918 = mono_get_corlib ();
    D.19919 = mono_exception_from_name (D.19918, "System", "SystemException");
    mono_raise_exception (D.19919);
    <D.19917>:
    sa = monoeg_malloc0 (16);
    D.19920 = mono_array_addr_with_size (data, 1, 2);
    D.19921 = MEM[(guint8 *)D.19920];
    D.19922 = (short unsigned int) D.19921;
    D.19923 = D.19922 << 8;
    D.19924 = mono_array_addr_with_size (data, 1, 3);
    D.19925 = MEM[(guint8 *)D.19924];
    D.19926 = (short unsigned int) D.19925;
    port = D.19923 + D.19926;
    D.19927 = mono_array_addr_with_size (data, 1, 4);
    D.19928 = MEM[(guint8 *)D.19927];
    D.19929 = (int) D.19928;
    D.19930 = D.19929 << 24;
    D.19931 = mono_array_addr_with_size (data, 1, 5);
    D.19932 = MEM[(guint8 *)D.19931];
    D.19933 = (int) D.19932;
    D.19934 = D.19933 << 16;
    D.19935 = D.19930 + D.19934;
    D.19936 = mono_array_addr_with_size (data, 1, 6);
    D.19937 = MEM[(guint8 *)D.19936];
    D.19938 = (int) D.19937;
    D.19939 = D.19938 << 8;
    D.19940 = D.19935 + D.19939;
    D.19941 = mono_array_addr_with_size (data, 1, 7);
    D.19942 = MEM[(guint8 *)D.19941];
    D.19943 = (int) D.19942;
    D.19944 = D.19940 + D.19943;
    address = (guint32) D.19944;
    D.19945 = (short unsigned int) family;
    sa->sin_family = D.19945;
    D.19946 = __bswap_32 (address);
    sa->sin_addr.s_addr = D.19946;
    {
      short unsigned int __bsx;

      __bsx = port;
      D.19223 = __bsx r>> 8;
    }
    sa->sin_port = D.19223;
    *sa_size = 16;
    D.19947 = sa;
    return D.19947;
  }
  <D.19915>:
  if (family == 10) goto <D.19948>; else goto <D.19949>;
  <D.19948>:
  {
    struct sockaddr_in6 * sa;
    int i;
    guint16 port;
    guint32 scopeid;

    if (len <= 27) goto <D.19950>; else goto <D.19951>;
    <D.19950>:
    D.19952 = mono_get_corlib ();
    D.19953 = mono_exception_from_name (D.19952, "System", "SystemException");
    mono_raise_exception (D.19953);
    <D.19951>:
    sa = monoeg_malloc0 (28);
    D.19954 = mono_array_addr_with_size (data, 1, 3);
    D.19955 = MEM[(guint8 *)D.19954];
    D.19956 = (short unsigned int) D.19955;
    D.19957 = mono_array_addr_with_size (data, 1, 2);
    D.19958 = MEM[(guint8 *)D.19957];
    D.19959 = (short unsigned int) D.19958;
    D.19960 = D.19959 << 8;
    port = D.19956 + D.19960;
    D.19961 = mono_array_addr_with_size (data, 1, 24);
    D.19962 = MEM[(guint8 *)D.19961];
    D.19963 = (int) D.19962;
    D.19964 = mono_array_addr_with_size (data, 1, 25);
    D.19965 = MEM[(guint8 *)D.19964];
    D.19966 = (int) D.19965;
    D.19967 = D.19966 << 8;
    D.19968 = D.19963 + D.19967;
    D.19969 = mono_array_addr_with_size (data, 1, 26);
    D.19970 = MEM[(guint8 *)D.19969];
    D.19971 = (int) D.19970;
    D.19972 = D.19971 << 16;
    D.19973 = D.19968 + D.19972;
    D.19974 = mono_array_addr_with_size (data, 1, 27);
    D.19975 = MEM[(guint8 *)D.19974];
    D.19976 = (int) D.19975;
    D.19977 = D.19976 << 24;
    D.19978 = D.19973 + D.19977;
    scopeid = (guint32) D.19978;
    D.19945 = (short unsigned int) family;
    sa->sin6_family = D.19945;
    {
      short unsigned int __bsx;

      __bsx = port;
      D.19229 = __bsx r>> 8;
    }
    sa->sin6_port = D.19229;
    sa->sin6_scope_id = scopeid;
    i = 0;
    goto <D.19231>;
    <D.19230>:
    D.19979 = i + 8;
    D.19980 = (long unsigned int) D.19979;
    D.19981 = mono_array_addr_with_size (data, 1, D.19980);
    D.19982 = MEM[(guint8 *)D.19981];
    sa->sin6_addr.__in6_u.__u6_addr8[i] = D.19982;
    i = i + 1;
    <D.19231>:
    if (i <= 15) goto <D.19230>; else goto <D.19232>;
    <D.19232>:
    *sa_size = 28;
    D.19947 = sa;
    return D.19947;
  }
  <D.19949>:
  if (family == 1) goto <D.19983>; else goto <D.19984>;
  <D.19983>:
  {
    struct sockaddr_un * sock_un;
    int i;

    if (len > 1) goto <D.19985>; else goto <D.19986>;
    <D.19985>:
    D.19987 = mono_get_exception_index_out_of_range ();
    mono_raise_exception (D.19987);
    <D.19986>:
    sock_un = monoeg_malloc0 (110);
    D.19945 = (short unsigned int) family;
    sock_un->sun_family = D.19945;
    i = 0;
    goto <D.19236>;
    <D.19235>:
    D.19988 = i + 2;
    D.19989 = (long unsigned int) D.19988;
    D.19990 = mono_array_addr_with_size (data, 1, D.19989);
    D.19991 = MEM[(guint8 *)D.19990];
    sock_un->sun_path[i] = D.19991;
    i = i + 1;
    <D.19236>:
    D.19992 = len + -2;
    if (D.19992 > i) goto <D.19235>; else goto <D.19237>;
    <D.19237>:
    len.17 = (unsigned int) len;
    *sa_size = len.17;
    D.19947 = sock_un;
    return D.19947;
  }
  <D.19984>:
  *error = 10047;
  D.19947 = 0B;
  return D.19947;
}


ves_icall_System_Net_Sockets_Socket_Poll_internal (SOCKET sock, gint mode, gint timeout, gint32 * error)
{
  int sock.18;
  short int iftmp.19;
  short int iftmp.20;
  int iftmp.21;
  int * D.20012;
  long int D.20013;
  unsigned int D.20014;
  unsigned int D.20015;
  unsigned int D.20016;
  int D.20017;
  int D.20022;
  MonoBoolean D.20029;
  unsigned int D.20033;
  unsigned int D.20034;
  int D.20035;
  struct MonoInternalThread * thread;
  struct mono_pollfd * pfds;
  int ret;
  time_t start;
  static const char __func__[50] = "ves_icall_System_Net_Sockets_Socket_Poll_internal";

  thread = 0B;
  pfds = monoeg_malloc0 (8);
  sock.18 = (int) sock;
  pfds->fd = sock.18;
  if (mode != 0) goto <D.19997>; else goto <D.19998>;
  <D.19997>:
  if (mode == 1) goto <D.20000>; else goto <D.20001>;
  <D.20000>:
  iftmp.20 = 4;
  goto <D.20002>;
  <D.20001>:
  iftmp.20 = 56;
  <D.20002>:
  iftmp.19 = iftmp.20;
  goto <D.20003>;
  <D.19998>:
  iftmp.19 = 1;
  <D.20003>:
  pfds->events = iftmp.19;
  if (timeout >= 0) goto <D.20005>; else goto <D.20006>;
  <D.20005>:
  iftmp.21 = timeout / 1000;
  goto <D.20007>;
  <D.20006>:
  iftmp.21 = -1;
  <D.20007>:
  timeout = iftmp.21;
  start = time (0B);
  <D.19263>:
  *error = 0;
  ret = mono_poll (pfds, 1, timeout);
  if (timeout > 0) goto <D.20008>; else goto <D.20009>;
  <D.20008>:
  if (ret < 0) goto <D.20010>; else goto <D.20011>;
  <D.20010>:
  {
    int err;
    int sec;

    D.20012 = __errno_location ();
    err = *D.20012;
    D.20013 = time (0B);
    D.20014 = (unsigned int) D.20013;
    D.20015 = (unsigned int) start;
    D.20016 = D.20014 - D.20015;
    sec = (int) D.20016;
    D.20017 = sec * -1000;
    timeout = D.20017 + timeout;
    if (timeout < 0) goto <D.20018>; else goto <D.20019>;
    <D.20018>:
    timeout = 0;
    <D.20019>:
    D.20012 = __errno_location ();
    *D.20012 = err;
  }
  <D.20011>:
  <D.20009>:
  if (ret == -1) goto <D.20020>; else goto <D.20021>;
  <D.20020>:
  D.20012 = __errno_location ();
  D.20022 = *D.20012;
  if (D.20022 == 4) goto <D.20023>; else goto <D.20024>;
  <D.20023>:
  {
    int leave;

    leave = 0;
    if (thread == 0B) goto <D.20025>; else goto <D.20026>;
    <D.20025>:
    thread = mono_thread_internal_current ();
    <D.20026>:
    leave = mono_thread_test_state (thread, 129);
    if (leave != 0) goto <D.20027>; else goto <D.20028>;
    <D.20027>:
    monoeg_g_free (pfds);
    D.20029 = 0;
    return D.20029;
    <D.20028>:
    mono_thread_interruption_checkpoint ();
    D.20012 = __errno_location ();
    *D.20012 = 4;
  }
  <D.20024>:
  <D.20021>:
  if (ret == -1) goto <D.20030>; else goto <D.19264>;
  <D.20030>:
  D.20012 = __errno_location ();
  D.20022 = *D.20012;
  if (D.20022 == 4) goto <D.19263>; else goto <D.19264>;
  <D.19264>:
  if (ret == -1) goto <D.20031>; else goto <D.20032>;
  <D.20031>:
  D.20012 = __errno_location ();
  D.20022 = *D.20012;
  D.20033 = (unsigned int) D.20022;
  D.20034 = errno_to_WSA (D.20033, &__func__);
  D.20035 = (int) D.20034;
  *error = D.20035;
  monoeg_g_free (pfds);
  D.20029 = 0;
  return D.20029;
  <D.20032>:
  monoeg_g_free (pfds);
  if (ret == 0) goto <D.20036>; else goto <D.20037>;
  <D.20036>:
  D.20029 = 0;
  return D.20029;
  <D.20037>:
  D.20029 = 1;
  return D.20029;
}


ves_icall_System_Net_Sockets_Socket_Connect_internal (SOCKET sock, struct MonoObject * sockaddr, gint32 * error)
{
  int D.20039;
  unsigned int sa_size.22;
  int D.20045;
  struct sockaddr * sa;
  socklen_t sa_size;
  int ret;

  try
    {
      *error = 0;
      sa = create_sockaddr_from_object (sockaddr, &sa_size, error);
      D.20039 = *error;
      if (D.20039 != 0) goto <D.20040>; else goto <D.20041>;
      <D.20040>:
      return;
      <D.20041>:
      sa_size.22 = sa_size;
      ret = _wapi_connect (sock, sa, sa_size.22);
      if (ret == -1) goto <D.20043>; else goto <D.20044>;
      <D.20043>:
      D.20045 = WSAGetLastError ();
      *error = D.20045;
      <D.20044>:
      monoeg_g_free (sa);
    }
  finally
    {
      sa_size = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_Disconnect_internal (SOCKET sock, MonoBoolean reuse, gint32 * error)
{
  gboolean (*<T1acd>) (guint32, struct WapiOverlapped *, guint32, WapiTransmitFileFlags) _wapi_disconnectex.23;
  gboolean (*<T1ad4>) (guint32, void *, guint32, guint32, struct WapiOverlapped *, struct WapiTransmitFileBuffers *, WapiTransmitFileFlags) _wapi_transmitfile.24;
  int D.20065;
  int ret;
  glong output_bytes;
  struct GUID disco_guid;
  struct GUID trans_guid;
  gboolean (*LPFN_DISCONNECTEX) (guint32, struct WapiOverlapped *, guint32, WapiTransmitFileFlags) _wapi_disconnectex;
  gboolean (*LPFN_TRANSMITFILE) (guint32, void *, guint32, guint32, struct WapiOverlapped *, struct WapiTransmitFileBuffers *, WapiTransmitFileFlags) _wapi_transmitfile;
  gboolean bret;

  try
    {
      output_bytes = 0;
      disco_guid = *.LC0;
      trans_guid = *.LC1;
      _wapi_disconnectex = 0B;
      _wapi_transmitfile = 0B;
      *error = 0;
      ret = WSAIoctl (sock, -939524090, &disco_guid, 16, &_wapi_disconnectex, 8, &output_bytes, 0B, 0B);
      if (ret != 0) goto <D.20051>; else goto <D.20052>;
      <D.20051>:
      _wapi_disconnectex = 0B;
      ret = WSAIoctl (sock, -939524090, &trans_guid, 16, &_wapi_transmitfile, 8, &output_bytes, 0B, 0B);
      if (ret != 0) goto <D.20053>; else goto <D.20054>;
      <D.20053>:
      _wapi_transmitfile = 0B;
      <D.20054>:
      <D.20052>:
      _wapi_disconnectex.23 = _wapi_disconnectex;
      if (_wapi_disconnectex.23 != 0B) goto <D.20056>; else goto <D.20057>;
      <D.20056>:
      _wapi_disconnectex.23 = _wapi_disconnectex;
      bret = _wapi_disconnectex.23 (sock, 0B, 2, 0);
      goto <D.20058>;
      <D.20057>:
      _wapi_transmitfile.24 = _wapi_transmitfile;
      if (_wapi_transmitfile.24 != 0B) goto <D.20060>; else goto <D.20061>;
      <D.20060>:
      _wapi_transmitfile.24 = _wapi_transmitfile;
      bret = _wapi_transmitfile.24 (sock, 0B, 0, 0, 0B, 0B, 3);
      goto <D.20062>;
      <D.20061>:
      *error = 50;
      return;
      <D.20062>:
      <D.20058>:
      if (bret == 0) goto <D.20063>; else goto <D.20064>;
      <D.20063>:
      D.20065 = WSAGetLastError ();
      *error = D.20065;
      <D.20064>:
    }
  finally
    {
      output_bytes = {CLOBBER};
      disco_guid = {CLOBBER};
      trans_guid = {CLOBBER};
      _wapi_disconnectex = {CLOBBER};
      _wapi_transmitfile = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_Receive_internal (SOCKET sock, struct MonoArray * buffer, gint32 offset, gint32 count, gint32 flags, gint32 * error)
{
  long unsigned int D.20069;
  int D.20070;
  gint32 D.20073;
  long unsigned int D.20074;
  long unsigned int D.20077;
  int D.20080;
  int ret;
  guchar * buf;
  gint32 alen;
  int recvflags;

  recvflags = 0;
  *error = 0;
  D.20069 = mono_array_length (buffer);
  alen = (gint32) D.20069;
  D.20070 = alen - count;
  if (D.20070 < offset) goto <D.20071>; else goto <D.20072>;
  <D.20071>:
  D.20073 = 0;
  return D.20073;
  <D.20072>:
  D.20074 = (long unsigned int) offset;
  buf = mono_array_addr_with_size (buffer, 1, D.20074);
  recvflags = convert_socketflags (flags);
  if (recvflags == -1) goto <D.20075>; else goto <D.20076>;
  <D.20075>:
  *error = 10045;
  D.20073 = 0;
  return D.20073;
  <D.20076>:
  D.20077 = (long unsigned int) count;
  ret = _wapi_recv (sock, buf, D.20077, recvflags);
  if (ret == -1) goto <D.20078>; else goto <D.20079>;
  <D.20078>:
  D.20080 = WSAGetLastError ();
  *error = D.20080;
  D.20073 = 0;
  return D.20073;
  <D.20079>:
  D.20073 = ret;
  return D.20073;
}


convert_socketflags (gint32 sflags)
{
  gint32 D.20084;
  int D.20085;
  int D.20088;
  int D.20091;
  int D.20094;
  int D.20097;
  gint32 flags;

  flags = 0;
  if (sflags == 0) goto <D.20082>; else goto <D.20083>;
  <D.20082>:
  D.20084 = 0;
  return D.20084;
  <D.20083>:
  D.20085 = sflags & -32792;
  if (D.20085 != 0) goto <D.20086>; else goto <D.20087>;
  <D.20086>:
  D.20084 = -1;
  return D.20084;
  <D.20087>:
  D.20088 = sflags & 1;
  if (D.20088 != 0) goto <D.20089>; else goto <D.20090>;
  <D.20089>:
  flags = flags | 1;
  <D.20090>:
  D.20091 = sflags & 2;
  if (D.20091 != 0) goto <D.20092>; else goto <D.20093>;
  <D.20092>:
  flags = flags | 2;
  <D.20093>:
  D.20094 = sflags & 4;
  if (D.20094 != 0) goto <D.20095>; else goto <D.20096>;
  <D.20095>:
  flags = flags | 4;
  <D.20096>:
  D.20097 = sflags & 32768;
  if (D.20097 != 0) goto <D.20098>; else goto <D.20099>;
  <D.20098>:
  flags = flags | 32768;
  <D.20099>:
  D.20084 = flags;
  return D.20084;
}


ves_icall_System_Net_Sockets_Socket_Receive_array_internal (SOCKET sock, struct MonoArray * buffers, gint32 flags, gint32 * error)
{
  long unsigned int D.20101;
  int D.20102;
  unsigned int recvflags.25;
  unsigned int recvflags.26;
  gint32 D.20107;
  unsigned int count.27;
  int D.20111;
  unsigned int recv.28;
  int ret;
  int count;
  DWORD recv;
  struct WSABUF * wsabufs;
  DWORD recvflags;

  try
    {
      recvflags = 0;
      *error = 0;
      wsabufs = mono_array_addr_with_size (buffers, 16, 0);
      D.20101 = mono_array_length (buffers);
      count = (int) D.20101;
      D.20102 = convert_socketflags (flags);
      recvflags.25 = (unsigned int) D.20102;
      recvflags = recvflags.25;
      recvflags.26 = recvflags;
      if (recvflags.26 == 4294967295) goto <D.20105>; else goto <D.20106>;
      <D.20105>:
      *error = 10045;
      D.20107 = 0;
      return D.20107;
      <D.20106>:
      count.27 = (unsigned int) count;
      ret = WSARecv (sock, wsabufs, count.27, &recv, &recvflags, 0B, 0B);
      if (ret == -1) goto <D.20109>; else goto <D.20110>;
      <D.20109>:
      D.20111 = WSAGetLastError ();
      *error = D.20111;
      D.20107 = 0;
      return D.20107;
      <D.20110>:
      recv.28 = recv;
      D.20107 = (gint32) recv.28;
      return D.20107;
    }
  finally
    {
      recv = {CLOBBER};
      recvflags = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_RecvFrom_internal (SOCKET sock, struct MonoArray * buffer, gint32 offset, gint32 count, gint32 flags, struct MonoObject * * sockaddr, gint32 * error)
{
  long unsigned int D.20115;
  int D.20116;
  gint32 D.20119;
  struct MonoObject * D.20120;
  int D.20121;
  long unsigned int D.20124;
  long unsigned int D.20127;
  int D.20130;
  unsigned int sa_size.29;
  int sa_size.30;
  struct MonoObject * D.20135;
  int ret;
  guchar * buf;
  gint32 alen;
  int recvflags;
  struct sockaddr * sa;
  socklen_t sa_size;

  try
    {
      recvflags = 0;
      *error = 0;
      D.20115 = mono_array_length (buffer);
      alen = (gint32) D.20115;
      D.20116 = alen - count;
      if (D.20116 < offset) goto <D.20117>; else goto <D.20118>;
      <D.20117>:
      D.20119 = 0;
      return D.20119;
      <D.20118>:
      D.20120 = *sockaddr;
      sa = create_sockaddr_from_object (D.20120, &sa_size, error);
      D.20121 = *error;
      if (D.20121 != 0) goto <D.20122>; else goto <D.20123>;
      <D.20122>:
      D.20119 = 0;
      return D.20119;
      <D.20123>:
      D.20124 = (long unsigned int) offset;
      buf = mono_array_addr_with_size (buffer, 1, D.20124);
      recvflags = convert_socketflags (flags);
      if (recvflags == -1) goto <D.20125>; else goto <D.20126>;
      <D.20125>:
      *error = 10045;
      D.20119 = 0;
      return D.20119;
      <D.20126>:
      D.20127 = (long unsigned int) count;
      ret = _wapi_recvfrom (sock, buf, D.20127, recvflags, sa, &sa_size);
      if (ret == -1) goto <D.20128>; else goto <D.20129>;
      <D.20128>:
      monoeg_g_free (sa);
      D.20130 = WSAGetLastError ();
      *error = D.20130;
      D.20119 = 0;
      return D.20119;
      <D.20129>:
      sa_size.29 = sa_size;
      if (sa_size.29 != 0) goto <D.20132>; else goto <D.20133>;
      <D.20132>:
      sa_size.29 = sa_size;
      sa_size.30 = (int) sa_size.29;
      D.20135 = create_object_from_sockaddr (sa, sa_size.30, error);
      *sockaddr = D.20135;
      goto <D.20136>;
      <D.20133>:
      *sockaddr = 0B;
      <D.20136>:
      monoeg_g_free (sa);
      D.20119 = ret;
      return D.20119;
    }
  finally
    {
      sa_size = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_Send_internal (SOCKET sock, struct MonoArray * buffer, gint32 offset, gint32 count, gint32 flags, gint32 * error)
{
  long unsigned int D.20139;
  int D.20140;
  gint32 D.20143;
  long unsigned int D.20144;
  long unsigned int D.20147;
  int D.20150;
  int ret;
  guchar * buf;
  gint32 alen;
  int sendflags;

  sendflags = 0;
  *error = 0;
  D.20139 = mono_array_length (buffer);
  alen = (gint32) D.20139;
  D.20140 = alen - count;
  if (D.20140 < offset) goto <D.20141>; else goto <D.20142>;
  <D.20141>:
  D.20143 = 0;
  return D.20143;
  <D.20142>:
  D.20144 = (long unsigned int) offset;
  buf = mono_array_addr_with_size (buffer, 1, D.20144);
  sendflags = convert_socketflags (flags);
  if (sendflags == -1) goto <D.20145>; else goto <D.20146>;
  <D.20145>:
  *error = 10045;
  D.20143 = 0;
  return D.20143;
  <D.20146>:
  D.20147 = (long unsigned int) count;
  ret = _wapi_send (sock, buf, D.20147, sendflags);
  if (ret == -1) goto <D.20148>; else goto <D.20149>;
  <D.20148>:
  D.20150 = WSAGetLastError ();
  *error = D.20150;
  D.20143 = 0;
  return D.20143;
  <D.20149>:
  D.20143 = ret;
  return D.20143;
}


ves_icall_System_Net_Sockets_Socket_Send_array_internal (SOCKET sock, struct MonoArray * buffers, gint32 flags, gint32 * error)
{
  long unsigned int D.20152;
  int D.20153;
  gint32 D.20156;
  unsigned int count.31;
  int D.20160;
  unsigned int sent.32;
  int ret;
  int count;
  DWORD sent;
  struct WSABUF * wsabufs;
  DWORD sendflags;

  try
    {
      sendflags = 0;
      *error = 0;
      wsabufs = mono_array_addr_with_size (buffers, 16, 0);
      D.20152 = mono_array_length (buffers);
      count = (int) D.20152;
      D.20153 = convert_socketflags (flags);
      sendflags = (DWORD) D.20153;
      if (sendflags == 4294967295) goto <D.20154>; else goto <D.20155>;
      <D.20154>:
      *error = 10045;
      D.20156 = 0;
      return D.20156;
      <D.20155>:
      count.31 = (unsigned int) count;
      ret = WSASend (sock, wsabufs, count.31, &sent, sendflags, 0B, 0B);
      if (ret == -1) goto <D.20158>; else goto <D.20159>;
      <D.20158>:
      D.20160 = WSAGetLastError ();
      *error = D.20160;
      D.20156 = 0;
      return D.20156;
      <D.20159>:
      sent.32 = sent;
      D.20156 = (gint32) sent.32;
      return D.20156;
    }
  finally
    {
      sent = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_SendTo_internal (SOCKET sock, struct MonoArray * buffer, gint32 offset, gint32 count, gint32 flags, struct MonoObject * sockaddr, gint32 * error)
{
  long unsigned int D.20164;
  int D.20165;
  gint32 D.20168;
  int D.20169;
  long unsigned int D.20172;
  long unsigned int D.20175;
  unsigned int sa_size.33;
  int D.20179;
  int ret;
  guchar * buf;
  gint32 alen;
  int sendflags;
  struct sockaddr * sa;
  socklen_t sa_size;

  try
    {
      sendflags = 0;
      *error = 0;
      D.20164 = mono_array_length (buffer);
      alen = (gint32) D.20164;
      D.20165 = alen - count;
      if (D.20165 < offset) goto <D.20166>; else goto <D.20167>;
      <D.20166>:
      D.20168 = 0;
      return D.20168;
      <D.20167>:
      sa = create_sockaddr_from_object (sockaddr, &sa_size, error);
      D.20169 = *error;
      if (D.20169 != 0) goto <D.20170>; else goto <D.20171>;
      <D.20170>:
      D.20168 = 0;
      return D.20168;
      <D.20171>:
      D.20172 = (long unsigned int) offset;
      buf = mono_array_addr_with_size (buffer, 1, D.20172);
      sendflags = convert_socketflags (flags);
      if (sendflags == -1) goto <D.20173>; else goto <D.20174>;
      <D.20173>:
      *error = 10045;
      D.20168 = 0;
      return D.20168;
      <D.20174>:
      D.20175 = (long unsigned int) count;
      sa_size.33 = sa_size;
      ret = _wapi_sendto (sock, buf, D.20175, sendflags, sa, sa_size.33);
      if (ret == -1) goto <D.20177>; else goto <D.20178>;
      <D.20177>:
      D.20179 = WSAGetLastError ();
      *error = D.20179;
      <D.20178>:
      monoeg_g_free (sa);
      D.20168 = ret;
      return D.20168;
    }
  finally
    {
      sa_size = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_Select_internal (struct MonoArray * * sockets, gint32 timeout, gint32 * error)
{
  struct MonoArray * D.20182;
  long unsigned int D.20183;
  long unsigned int D.20184;
  long unsigned int D.20185;
  long unsigned int D.20186;
  char * D.20187;
  long unsigned int D.20192;
  long unsigned int D.20193;
  struct mono_pollfd * D.20194;
  unsigned int D.20195;
  int D.20196;
  short int iftmp.34;
  short int iftmp.35;
  int iftmp.36;
  unsigned int nfds.37;
  int * D.20214;
  long int D.20215;
  unsigned int D.20216;
  unsigned int D.20217;
  unsigned int D.20218;
  int D.20219;
  int D.20224;
  unsigned int D.20234;
  unsigned int D.20235;
  int D.20236;
  struct MonoVTable * D.20239;
  long unsigned int D.20240;
  long unsigned int socks_size.38;
  struct MonoDomain * D.20242;
  char * D.20243;
  int D.20246;
  long unsigned int D.20247;
  long unsigned int D.20248;
  short int D.20249;
  unsigned short D.20255;
  int D.20256;
  int D.20257;
  int idx.39;
  long unsigned int D.20260;
  int D.20264;
  int idx.40;
  long unsigned int D.20267;
  int D.20268;
  int idx.41;
  long unsigned int D.20272;
  struct MonoInternalThread * thread;
  struct MonoObject * obj;
  struct mono_pollfd * pfds;
  int nfds;
  int idx;
  int ret;
  int i;
  int count;
  int mode;
  struct MonoClass * sock_arr_class;
  struct MonoArray * socks;
  time_t start;
  uintptr_t socks_size;
  static const char __func__[52] = "ves_icall_System_Net_Sockets_Socket_Select_internal";

  try
    {
      thread = 0B;
      D.20182 = *sockets;
      D.20183 = mono_array_length (D.20182);
      count = (int) D.20183;
      nfds = count + -3;
      D.20184 = (long unsigned int) nfds;
      D.20185 = D.20184 * 8;
      pfds = monoeg_malloc0 (D.20185);
      idx = 0;
      mode = idx;
      i = 0;
      goto <D.19387>;
      <D.19386>:
      D.20182 = *sockets;
      D.20186 = (long unsigned int) i;
      D.20187 = mono_array_addr_with_size (D.20182, 8, D.20186);
      obj = MEM[(struct MonoObject * *)D.20187];
      if (obj == 0B) goto <D.20188>; else goto <D.20189>;
      <D.20188>:
      mode = mode + 1;
      // predicted unlikely by continue predictor.
      goto <D.19385>;
      <D.20189>:
      if (idx >= nfds) goto <D.20190>; else goto <D.20191>;
      <D.20190>:
      monoeg_g_free (pfds);
      *error = 10014;
      return;
      <D.20191>:
      D.20192 = (long unsigned int) idx;
      D.20193 = D.20192 * 8;
      D.20194 = pfds + D.20193;
      D.20195 = Socket_to_SOCKET (obj);
      D.20196 = (int) D.20195;
      D.20194->fd = D.20196;
      D.20192 = (long unsigned int) idx;
      D.20193 = D.20192 * 8;
      D.20194 = pfds + D.20193;
      if (mode != 0) goto <D.20198>; else goto <D.20199>;
      <D.20198>:
      if (mode == 1) goto <D.20201>; else goto <D.20202>;
      <D.20201>:
      iftmp.35 = 4;
      goto <D.20203>;
      <D.20202>:
      iftmp.35 = 56;
      <D.20203>:
      iftmp.34 = iftmp.35;
      goto <D.20204>;
      <D.20199>:
      iftmp.34 = 1;
      <D.20204>:
      D.20194->events = iftmp.34;
      idx = idx + 1;
      <D.19385>:
      i = i + 1;
      <D.19387>:
      if (i < count) goto <D.19386>; else goto <D.19388>;
      <D.19388>:
      if (timeout >= 0) goto <D.20206>; else goto <D.20207>;
      <D.20206>:
      iftmp.36 = timeout / 1000;
      goto <D.20208>;
      <D.20207>:
      iftmp.36 = -1;
      <D.20208>:
      timeout = iftmp.36;
      start = time (0B);
      <D.19392>:
      *error = 0;
      nfds.37 = (unsigned int) nfds;
      ret = mono_poll (pfds, nfds.37, timeout);
      if (timeout > 0) goto <D.20210>; else goto <D.20211>;
      <D.20210>:
      if (ret < 0) goto <D.20212>; else goto <D.20213>;
      <D.20212>:
      {
        int err;
        int sec;

        D.20214 = __errno_location ();
        err = *D.20214;
        D.20215 = time (0B);
        D.20216 = (unsigned int) D.20215;
        D.20217 = (unsigned int) start;
        D.20218 = D.20216 - D.20217;
        sec = (int) D.20218;
        D.20219 = sec * -1000;
        timeout = D.20219 + timeout;
        if (timeout < 0) goto <D.20220>; else goto <D.20221>;
        <D.20220>:
        timeout = 0;
        <D.20221>:
        D.20214 = __errno_location ();
        *D.20214 = err;
      }
      <D.20213>:
      <D.20211>:
      if (ret == -1) goto <D.20222>; else goto <D.20223>;
      <D.20222>:
      D.20214 = __errno_location ();
      D.20224 = *D.20214;
      if (D.20224 == 4) goto <D.20225>; else goto <D.20226>;
      <D.20225>:
      {
        int leave;

        leave = 0;
        if (thread == 0B) goto <D.20227>; else goto <D.20228>;
        <D.20227>:
        thread = mono_thread_internal_current ();
        <D.20228>:
        leave = mono_thread_test_state (thread, 129);
        if (leave != 0) goto <D.20229>; else goto <D.20230>;
        <D.20229>:
        monoeg_g_free (pfds);
        *sockets = 0B;
        return;
        <D.20230>:
        mono_thread_interruption_checkpoint ();
        D.20214 = __errno_location ();
        *D.20214 = 4;
      }
      <D.20226>:
      <D.20223>:
      if (ret == -1) goto <D.20231>; else goto <D.19393>;
      <D.20231>:
      D.20214 = __errno_location ();
      D.20224 = *D.20214;
      if (D.20224 == 4) goto <D.19392>; else goto <D.19393>;
      <D.19393>:
      if (ret == -1) goto <D.20232>; else goto <D.20233>;
      <D.20232>:
      D.20214 = __errno_location ();
      D.20224 = *D.20214;
      D.20234 = (unsigned int) D.20224;
      D.20235 = errno_to_WSA (D.20234, &__func__);
      D.20236 = (int) D.20235;
      *error = D.20236;
      monoeg_g_free (pfds);
      return;
      <D.20233>:
      if (ret == 0) goto <D.20237>; else goto <D.20238>;
      <D.20237>:
      monoeg_g_free (pfds);
      *sockets = 0B;
      return;
      <D.20238>:
      D.20182 = *sockets;
      D.20239 = MEM[(struct MonoObject *)D.20182].vtable;
      sock_arr_class = D.20239->klass;
      D.20240 = (long unsigned int) ret;
      socks_size.38 = D.20240 + 3;
      socks_size = socks_size.38;
      D.20242 = mono_domain_get ();
      socks = mono_array_new_full (D.20242, sock_arr_class, &socks_size, 0B);
      idx = 0;
      mode = idx;
      i = 0;
      goto <D.19401>;
      <D.19400>:
      {
        struct mono_pollfd * pfd;

        D.20182 = *sockets;
        D.20186 = (long unsigned int) i;
        D.20243 = mono_array_addr_with_size (D.20182, 8, D.20186);
        obj = MEM[(struct MonoObject * *)D.20243];
        if (obj == 0B) goto <D.20244>; else goto <D.20245>;
        <D.20244>:
        mode = mode + 1;
        idx = idx + 1;
        // predicted unlikely by continue predictor.
        goto <D.19396>;
        <D.20245>:
        D.20246 = i - mode;
        D.20247 = (long unsigned int) D.20246;
        D.20248 = D.20247 * 8;
        pfd = pfds + D.20248;
        D.20249 = pfd->revents;
        if (D.20249 == 0) goto <D.20250>; else goto <D.20251>;
        <D.20250>:
        // predicted unlikely by continue predictor.
        goto <D.19396>;
        <D.20251>:
        ret = ret + -1;
        if (mode == 0) goto <D.20254>; else goto <D.20252>;
        <D.20254>:
        D.20249 = pfd->revents;
        D.20255 = (unsigned short) D.20249;
        D.20256 = (int) D.20255;
        D.20257 = D.20256 & 57;
        if (D.20257 != 0) goto <D.20258>; else goto <D.20252>;
        <D.20258>:
        {
          void * * __p;

          idx.39 = idx;
          idx = idx.39 + 1;
          D.20260 = (long unsigned int) idx.39;
          __p = mono_array_addr_with_size (socks, 8, D.20260);
          mono_gc_wbarrier_set_arrayref (socks, __p, obj);
        }
        goto <D.20253>;
        <D.20252>:
        if (mode == 1) goto <D.20263>; else goto <D.20261>;
        <D.20263>:
        D.20249 = pfd->revents;
        D.20255 = (unsigned short) D.20249;
        D.20256 = (int) D.20255;
        D.20264 = D.20256 & 60;
        if (D.20264 != 0) goto <D.20265>; else goto <D.20261>;
        <D.20265>:
        {
          void * * __p;

          idx.40 = idx;
          idx = idx.40 + 1;
          D.20267 = (long unsigned int) idx.40;
          __p = mono_array_addr_with_size (socks, 8, D.20267);
          mono_gc_wbarrier_set_arrayref (socks, __p, obj);
        }
        goto <D.20262>;
        <D.20261>:
        D.20249 = pfd->revents;
        D.20255 = (unsigned short) D.20249;
        D.20256 = (int) D.20255;
        D.20268 = D.20256 & 56;
        if (D.20268 != 0) goto <D.20269>; else goto <D.20270>;
        <D.20269>:
        {
          void * * __p;

          idx.41 = idx;
          idx = idx.41 + 1;
          D.20272 = (long unsigned int) idx.41;
          __p = mono_array_addr_with_size (socks, 8, D.20272);
          mono_gc_wbarrier_set_arrayref (socks, __p, obj);
        }
        <D.20270>:
        <D.20262>:
        <D.20253>:
      }
      <D.19396>:
      i = i + 1;
      <D.19401>:
      if (i < count) goto <D.20273>; else goto <D.19402>;
      <D.20273>:
      if (ret > 0) goto <D.19400>; else goto <D.19402>;
      <D.19402>:
      *sockets = socks;
      monoeg_g_free (pfds);
    }
  finally
    {
      socks_size = {CLOBBER};
    }
}


Socket_to_SOCKET (struct MonoObject * sockobj)
{
  struct MonoVTable * D.20277;
  struct MonoClass * D.20278;
  int D.20279;
  sizetype D.20280;
  void * * D.20281;
  void * D.20282;
  long int D.20283;
  SOCKET D.20284;
  SOCKET sock;
  struct MonoClassField * field;

  D.20277 = sockobj->vtable;
  D.20278 = D.20277->klass;
  field = mono_class_get_field_from_name (D.20278, "socket");
  D.20279 = field->offset;
  D.20280 = (sizetype) D.20279;
  D.20281 = sockobj + D.20280;
  D.20282 = *D.20281;
  D.20283 = (long int) D.20282;
  sock = (SOCKET) D.20283;
  D.20284 = sock;
  return D.20284;
}


ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (SOCKET sock, gint32 level, gint32 name, struct MonoObject * * obj_val, gint32 * error)
{
  <unnamed type> level.42;
  struct MonoObject * D.20295;
  int system_level.43;
  int system_name.44;
  int D.20300;
  struct MonoImage * D.20301;
  int D.20302;
  sizetype D.20303;
  guint8 * D.20304;
  int D.20305;
  unsigned char D.20306;
  guint32 * D.20307;
  int D.20308;
  unsigned int D.20309;
  _Bool D.20310;
  int D.20311;
  int time_ms.45;
  struct MonoImage * mono_posix_image.46;
  struct MonoImage * mono_posix_image.47;
  struct MonoImage * mono_posix_image.48;
  int D.20322;
  unsigned int D.20323;
  int D.20324;
  unsigned int D.20325;
  int D.20326;
  int val.49;
  _Bool D.20332;
  int val.50;
  int system_level;
  int system_name;
  int ret;
  int val;
  socklen_t valsize;
  struct linger linger;
  socklen_t lingersize;
  int time_ms;
  socklen_t time_ms_size;
  struct ucred cred;
  socklen_t credsize;
  struct MonoDomain * domain;
  struct MonoObject * obj;
  struct MonoClass * obj_class;
  struct MonoClassField * field;

  try
    {
      valsize = 4;
      lingersize = 8;
      time_ms = 0;
      time_ms_size = 4;
      credsize = 12;
      domain = mono_domain_get ();
      *error = 0;
      if (level == 65535) goto <D.20288>; else goto <D.20286>;
      <D.20288>:
      if (name == -5) goto <D.20289>; else goto <D.20286>;
      <D.20289>:
      system_level = 1;
      system_name = 2;
      ret = 0;
      goto <D.20287>;
      <D.20286>:
      level.42 = (<unnamed type>) level;
      ret = convert_sockopt_level_and_name (level.42, name, &system_level, &system_name);
      <D.20287>:
      if (ret == -1) goto <D.20291>; else goto <D.20292>;
      <D.20291>:
      *error = 10042;
      return;
      <D.20292>:
      if (ret == -2) goto <D.20293>; else goto <D.20294>;
      <D.20293>:
      D.20295 = int_to_object (domain, 0);
      *obj_val = D.20295;
      return;
      <D.20294>:
      switch (name) <default: <D.19435>, case -129: <D.19430>, case 128: <D.19429>, case 4101: <D.19432>, case 4102: <D.19433>, case 10001: <D.19434>>
      <D.19429>:
      <D.19430>:
      system_level.43 = system_level;
      system_name.44 = system_name;
      ret = _wapi_getsockopt (sock, system_level.43, system_name.44, &linger, &lingersize);
      goto <D.19431>;
      <D.19432>:
      <D.19433>:
      system_level.43 = system_level;
      system_name.44 = system_name;
      ret = _wapi_getsockopt (sock, system_level.43, system_name.44, &time_ms, &time_ms_size);
      goto <D.19431>;
      <D.19434>:
      system_level.43 = system_level;
      system_name.44 = system_name;
      ret = _wapi_getsockopt (sock, system_level.43, system_name.44, &cred, &credsize);
      goto <D.19431>;
      <D.19435>:
      system_level.43 = system_level;
      system_name.44 = system_name;
      ret = _wapi_getsockopt (sock, system_level.43, system_name.44, &val, &valsize);
      <D.19431>:
      if (ret == -1) goto <D.20298>; else goto <D.20299>;
      <D.20298>:
      D.20300 = WSAGetLastError ();
      *error = D.20300;
      return;
      <D.20299>:
      switch (name) <default: <D.19445>, case -129: <D.19438>, case 128: <D.19436>, case 4101: <D.19439>, case 4102: <D.19440>, case 10001: <D.19441>>
      <D.19436>:
      D.20301 = get_socket_assembly ();
      obj_class = mono_class_from_name (D.20301, "System.Net.Sockets", "LingerOption");
      obj = mono_object_new (domain, obj_class);
      field = mono_class_get_field_from_name (obj_class, "enabled");
      D.20302 = field->offset;
      D.20303 = (sizetype) D.20302;
      D.20304 = obj + D.20303;
      D.20305 = linger.l_onoff;
      D.20306 = (unsigned char) D.20305;
      *D.20304 = D.20306;
      field = mono_class_get_field_from_name (obj_class, "seconds");
      D.20302 = field->offset;
      D.20303 = (sizetype) D.20302;
      D.20307 = obj + D.20303;
      D.20308 = linger.l_linger;
      D.20309 = (unsigned int) D.20308;
      *D.20307 = D.20309;
      goto <D.19437>;
      <D.19438>:
      D.20305 = linger.l_onoff;
      D.20310 = D.20305 == 0;
      D.20311 = (int) D.20310;
      obj = int_to_object (domain, D.20311);
      goto <D.19437>;
      <D.19439>:
      <D.19440>:
      time_ms.45 = time_ms;
      obj = int_to_object (domain, time_ms.45);
      goto <D.19437>;
      <D.19441>:
      {
        static struct MonoImage * mono_posix_image = 0B;
        struct MonoPeerCredData * cred_data;

        mono_posix_image.46 = mono_posix_image;
        if (mono_posix_image.46 == 0B) goto <D.20314>; else goto <D.20315>;
        <D.20314>:
        mono_posix_image.47 = mono_image_loaded ("Mono.Posix");
        mono_posix_image = mono_posix_image.47;
        mono_posix_image.46 = mono_posix_image;
        if (mono_posix_image.46 == 0B) goto <D.20317>; else goto <D.20318>;
        <D.20317>:
        {
          struct MonoAssembly * sa;

          sa = mono_assembly_open ("Mono.Posix.dll", 0B);
          if (sa == 0B) goto <D.20319>; else goto <D.20320>;
          <D.20319>:
          *error = 10042;
          return;
          <D.20320>:
          mono_posix_image.48 = mono_assembly_get_image (sa);
          mono_posix_image = mono_posix_image.48;
        }
        <D.20318>:
        <D.20315>:
        mono_posix_image.46 = mono_posix_image;
        obj_class = mono_class_from_name (mono_posix_image.46, "Mono.Posix", "PeerCredData");
        obj = mono_object_new (domain, obj_class);
        cred_data = obj;
        D.20322 = cred.pid;
        cred_data->pid = D.20322;
        D.20323 = cred.uid;
        D.20324 = (int) D.20323;
        cred_data->uid = D.20324;
        D.20325 = cred.gid;
        D.20326 = (int) D.20325;
        cred_data->gid = D.20326;
        goto <D.19437>;
      }
      <D.19445>:
      if (level == 65535) goto <D.20327>; else goto <D.20328>;
      <D.20327>:
      if (name == -5) goto <D.20329>; else goto <D.20330>;
      <D.20329>:
      val.49 = val;
      D.20332 = val.49 == 0;
      val.50 = (int) D.20332;
      val = val.50;
      <D.20330>:
      <D.20328>:
      val.49 = val;
      obj = int_to_object (domain, val.49);
      <D.19437>:
      *obj_val = obj;
    }
  finally
    {
      system_level = {CLOBBER};
      system_name = {CLOBBER};
      val = {CLOBBER};
      valsize = {CLOBBER};
      linger = {CLOBBER};
      lingersize = {CLOBBER};
      time_ms = {CLOBBER};
      time_ms_size = {CLOBBER};
      cred = {CLOBBER};
      credsize = {CLOBBER};
    }
}


convert_sockopt_level_and_name (MonoSocketOptionLevel mono_level, MonoSocketOptionName mono_name, int * system_level, int * system_name)
{
  gint32 D.20337;
  int cached.51;
  int iftmp.52;
  int proto.53;

  switch (mono_level) <default: <D.19065>, case 0: <D.19017>, case 6: <D.19054>, case 17: <D.19061>, case 41: <D.19035>, case 65535: <D.18992>>
  <D.18992>:
  *system_level = 1;
  switch (mono_name) <default: <D.19015>, case -129: <D.18993>, case -5: <D.19012>, case 1: <D.18995>, case 2: <D.18996>, case 4: <D.18997>, case 8: <D.18998>, case 16: <D.18999>, case 32: <D.19000>, case 64: <D.19013>, case 128: <D.19001>, case 256: <D.19002>, case 4097: <D.19003>, case 4098: <D.19004>, case 4099: <D.19005>, case 4100: <D.19006>, case 4101: <D.19007>, case 4102: <D.19008>, case 4103: <D.19009>, case 4104: <D.19010>, case 10001: <D.19011>, case 2147483647: <D.19014>>
  <D.18993>:
  *system_name = 13;
  goto <D.18994>;
  <D.18995>:
  *system_name = 1;
  goto <D.18994>;
  <D.18996>:
  *system_name = 30;
  goto <D.18994>;
  <D.18997>:
  *system_name = 2;
  goto <D.18994>;
  <D.18998>:
  *system_name = 9;
  goto <D.18994>;
  <D.18999>:
  *system_name = 5;
  goto <D.18994>;
  <D.19000>:
  *system_name = 6;
  goto <D.18994>;
  <D.19001>:
  *system_name = 13;
  goto <D.18994>;
  <D.19002>:
  *system_name = 10;
  goto <D.18994>;
  <D.19003>:
  *system_name = 7;
  goto <D.18994>;
  <D.19004>:
  *system_name = 8;
  goto <D.18994>;
  <D.19005>:
  *system_name = 17;
  goto <D.18994>;
  <D.19006>:
  *system_name = 16;
  goto <D.18994>;
  <D.19007>:
  *system_name = 19;
  goto <D.18994>;
  <D.19008>:
  *system_name = 18;
  goto <D.18994>;
  <D.19009>:
  *system_name = 4;
  goto <D.18994>;
  <D.19010>:
  *system_name = 3;
  goto <D.18994>;
  <D.19011>:
  *system_name = 21;
  goto <D.18994>;
  <D.19012>:
  <D.19013>:
  <D.19014>:
  *system_name = 128;
  goto <D.18994>;
  <D.19015>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at Socket level", mono_name);
  D.20337 = -1;
  return D.20337;
  <D.18994>:
  goto <D.19016>;
  <D.19017>:
  *system_level = 0;
  switch (mono_name) <default: <D.19034>, case 1: <D.19018>, case 2: <D.19020>, case 3: <D.19021>, case 4: <D.19022>, case 9: <D.19023>, case 10: <D.19024>, case 11: <D.19025>, case 12: <D.19026>, case 13: <D.19027>, case 14: <D.19029>, case 15: <D.19030>, case 16: <D.19031>, case 17: <D.19032>, case 18: <D.19033>, case 19: <D.19028>>
  <D.19018>:
  *system_name = 4;
  goto <D.19019>;
  <D.19020>:
  *system_name = 3;
  goto <D.19019>;
  <D.19021>:
  *system_name = 1;
  goto <D.19019>;
  <D.19022>:
  *system_name = 2;
  goto <D.19019>;
  <D.19023>:
  *system_name = 32;
  goto <D.19019>;
  <D.19024>:
  *system_name = 33;
  goto <D.19019>;
  <D.19025>:
  *system_name = 34;
  goto <D.19019>;
  <D.19026>:
  *system_name = 35;
  goto <D.19019>;
  <D.19027>:
  *system_name = 36;
  goto <D.19019>;
  <D.19028>:
  *system_name = 8;
  goto <D.19019>;
  <D.19029>:
  *system_name = 10;
  goto <D.19019>;
  <D.19030>:
  <D.19031>:
  <D.19032>:
  <D.19033>:
  <D.19034>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at IP level", mono_name);
  D.20337 = -1;
  return D.20337;
  <D.19019>:
  goto <D.19016>;
  <D.19035>:
  *system_level = 41;
  switch (mono_name) <default: <D.19053>, case 1: <D.19046>, case 2: <D.19045>, case 3: <D.19047>, case 4: <D.19036>, case 9: <D.19039>, case 10: <D.19040>, case 11: <D.19041>, case 12: <D.19042>, case 13: <D.19043>, case 14: <D.19048>, case 15: <D.19049>, case 16: <D.19050>, case 17: <D.19051>, case 18: <D.19052>, case 19: <D.19044>, case 21: <D.19037>>
  <D.19036>:
  <D.19037>:
  *system_name = 16;
  goto <D.19038>;
  <D.19039>:
  *system_name = 17;
  goto <D.19038>;
  <D.19040>:
  *system_name = 18;
  goto <D.19038>;
  <D.19041>:
  *system_name = 19;
  goto <D.19038>;
  <D.19042>:
  *system_name = 20;
  goto <D.19038>;
  <D.19043>:
  *system_name = 21;
  goto <D.19038>;
  <D.19044>:
  *system_name = 50;
  goto <D.19038>;
  <D.19045>:
  <D.19046>:
  <D.19047>:
  <D.19048>:
  <D.19049>:
  <D.19050>:
  <D.19051>:
  <D.19052>:
  <D.19053>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at IPv6 level", mono_name);
  D.20337 = -1;
  return D.20337;
  <D.19038>:
  goto <D.19016>;
  <D.19054>:
  if (1 != 0) goto <D.20338>; else goto <D.20339>;
  <D.20338>:
  {
    static int cached = 0;
    static int proto;

    cached.51 = cached;
    if (cached.51 == 0) goto <D.20341>; else goto <D.20342>;
    <D.20341>:
    {
      struct protoent * pent;

      pent = getprotobyname ("TCP");
      if (pent != 0B) goto <D.20344>; else goto <D.20345>;
      <D.20344>:
      iftmp.52 = pent->p_proto;
      goto <D.20346>;
      <D.20345>:
      iftmp.52 = 6;
      <D.20346>:
      proto = iftmp.52;
      cached = 1;
    }
    <D.20342>:
    proto.53 = proto;
    *system_level = proto.53;
  }
  <D.20339>:
  switch (mono_name) <default: <D.19060>, case 1: <D.19058>>
  <D.19058>:
  *system_name = 1;
  goto <D.19059>;
  <D.19060>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at TCP level", mono_name);
  D.20337 = -1;
  return D.20337;
  <D.19059>:
  goto <D.19016>;
  <D.19061>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionLevel has unsupported value 0x%x", mono_level);
  switch (mono_name) <default: <D.19064>, case 1: <D.19062>, case 20: <D.19063>>
  <D.19062>:
  <D.19063>:
  <D.19064>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at UDP level", mono_name);
  D.20337 = -1;
  return D.20337;
  D.20337 = -1;
  return D.20337;
  <D.19065>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionLevel has unknown value 0x%x", mono_level);
  D.20337 = -1;
  return D.20337;
  <D.19016>:
  D.20337 = 0;
  return D.20337;
}


int_to_object (struct MonoDomain * domain, int val)
{
  struct MonoObject * D.20350;
  struct MonoClass * D.20351;

  D.20351 = mono_get_int32_class ();
  D.20350 = mono_value_box (domain, D.20351, &val);
  return D.20350;
}


ves_icall_System_Net_Sockets_Socket_GetSocketOption_arr_internal (SOCKET sock, gint32 level, gint32 name, struct MonoArray * * byte_val, gint32 * error)
{
  <unnamed type> level.54;
  struct MonoArray * D.20358;
  long unsigned int D.20359;
  unsigned int valsize.55;
  int system_level.56;
  int system_name.57;
  int D.20365;
  int system_level;
  int system_name;
  int ret;
  guchar * buf;
  socklen_t valsize;

  try
    {
      *error = 0;
      level.54 = (<unnamed type>) level;
      ret = convert_sockopt_level_and_name (level.54, name, &system_level, &system_name);
      if (ret == -1) goto <D.20354>; else goto <D.20355>;
      <D.20354>:
      *error = 10042;
      return;
      <D.20355>:
      if (ret == -2) goto <D.20356>; else goto <D.20357>;
      <D.20356>:
      return;
      <D.20357>:
      D.20358 = *byte_val;
      D.20359 = mono_array_length (D.20358);
      valsize.55 = (unsigned int) D.20359;
      valsize = valsize.55;
      D.20358 = *byte_val;
      buf = mono_array_addr_with_size (D.20358, 1, 0);
      system_level.56 = system_level;
      system_name.57 = system_name;
      ret = _wapi_getsockopt (sock, system_level.56, system_name.57, buf, &valsize);
      if (ret == -1) goto <D.20363>; else goto <D.20364>;
      <D.20363>:
      D.20365 = WSAGetLastError ();
      *error = D.20365;
      <D.20364>:
    }
  finally
    {
      system_level = {CLOBBER};
      system_name = {CLOBBER};
      valsize = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_SetSocketOption_internal (SOCKET sock, gint32 level, gint32 name, struct MonoObject * obj_val, struct MonoArray * byte_val, gint32 int_val, gint32 * error)
{
  <unnamed type> level.58;
  int int_val.59;
  _Bool D.20375;
  int int_val.60;
  struct MonoVTable * D.20383;
  struct MonoClass * D.20384;
  int D.20385;
  sizetype D.20386;
  guint8 * D.20387;
  unsigned char D.20388;
  int D.20389;
  guint32 * D.20390;
  unsigned int D.20391;
  int D.20392;
  int system_level.61;
  int system_name.62;
  unsigned int valsize.63;
  void * * D.20398;
  guint64 * D.20401;
  long unsigned int D.20402;
  unsigned int D.20403;
  gint32 * D.20411;
  int D.20412;
  long unsigned int D.20416;
  unsigned char D.20419;
  _Bool D.20420;
  int D.20421;
  unsigned int valsize.64;
  unsigned int int_val.65;
  unsigned int D.20426;
  unsigned int D.20427;
  unsigned int D.20428;
  unsigned int D.20429;
  unsigned int D.20430;
  unsigned int D.20431;
  unsigned int D.20432;
  unsigned int D.20433;
  unsigned int D.20434;
  int int_val.66;
  unsigned int D.20436;
  int D.20443;
  struct linger linger;
  int system_level;
  int system_name;
  int ret;
  int sol_ip;
  int sol_ipv6;

  try
    {
      *error = 0;
      sol_ipv6 = 41;
      sol_ip = 0;
      level.58 = (<unnamed type>) level;
      ret = convert_sockopt_level_and_name (level.58, name, &system_level, &system_name);
      if (level == 65535) goto <D.20370>; else goto <D.20371>;
      <D.20370>:
      if (name == -5) goto <D.20372>; else goto <D.20373>;
      <D.20372>:
      system_name = 2;
      int_val.59 = int_val;
      D.20375 = int_val.59 == 0;
      int_val.60 = (int) D.20375;
      int_val = int_val.60;
      ret = 0;
      <D.20373>:
      <D.20371>:
      if (ret == -1) goto <D.20377>; else goto <D.20378>;
      <D.20377>:
      *error = 10042;
      return;
      <D.20378>:
      if (ret == -2) goto <D.20379>; else goto <D.20380>;
      <D.20379>:
      return;
      <D.20380>:
      if (obj_val != 0B) goto <D.20381>; else goto <D.20382>;
      <D.20381>:
      {
        struct MonoClassField * field;
        int valsize;

        switch (name) <default: <D.19497>, case 12: <D.19492>, case 13: <D.19493>, case 128: <D.19490>>
        <D.19490>:
        D.20383 = obj_val->vtable;
        D.20384 = D.20383->klass;
        field = mono_class_get_field_from_name (D.20384, "enabled");
        D.20385 = field->offset;
        D.20386 = (sizetype) D.20385;
        D.20387 = obj_val + D.20386;
        D.20388 = *D.20387;
        D.20389 = (int) D.20388;
        linger.l_onoff = D.20389;
        D.20383 = obj_val->vtable;
        D.20384 = D.20383->klass;
        field = mono_class_get_field_from_name (D.20384, "seconds");
        D.20385 = field->offset;
        D.20386 = (sizetype) D.20385;
        D.20390 = obj_val + D.20386;
        D.20391 = *D.20390;
        D.20392 = (int) D.20391;
        linger.l_linger = D.20392;
        valsize = 8;
        system_level.61 = system_level;
        system_name.62 = system_name;
        valsize.63 = (unsigned int) valsize;
        ret = _wapi_setsockopt (sock, system_level.61, system_name.62, &linger, valsize.63);
        goto <D.19491>;
        <D.19492>:
        <D.19493>:
        {
          struct MonoObject * address;

          address = 0B;
          system_level.61 = system_level;
          if (system_level.61 == sol_ipv6) goto <D.20396>; else goto <D.20397>;
          <D.20396>:
          {
            struct ipv6_mreq mreq6;

            try
              {
                D.20383 = obj_val->vtable;
                D.20384 = D.20383->klass;
                field = mono_class_get_field_from_name (D.20384, "group");
                D.20385 = field->offset;
                D.20386 = (sizetype) D.20385;
                D.20398 = obj_val + D.20386;
                address = *D.20398;
                if (address != 0B) goto <D.20399>; else goto <D.20400>;
                <D.20399>:
                mreq6.ipv6mr_multiaddr = ipaddress_to_struct_in6_addr (address);
                <D.20400>:
                D.20383 = obj_val->vtable;
                D.20384 = D.20383->klass;
                field = mono_class_get_field_from_name (D.20384, "ifIndex");
                D.20385 = field->offset;
                D.20386 = (sizetype) D.20385;
                D.20401 = obj_val + D.20386;
                D.20402 = *D.20401;
                D.20403 = (unsigned int) D.20402;
                mreq6.ipv6mr_interface = D.20403;
                system_level.61 = system_level;
                system_name.62 = system_name;
                ret = _wapi_setsockopt (sock, system_level.61, system_name.62, &mreq6, 20);
              }
            finally
              {
                mreq6 = {CLOBBER};
              }
          }
          goto <D.20404>;
          <D.20397>:
          system_level.61 = system_level;
          if (system_level.61 == sol_ip) goto <D.20405>; else goto <D.20406>;
          <D.20405>:
          {
            struct ip_mreqn mreq;

            try
              {
                mreq = {};
                D.20383 = obj_val->vtable;
                D.20384 = D.20383->klass;
                field = mono_class_get_field_from_name (D.20384, "group");
                D.20385 = field->offset;
                D.20386 = (sizetype) D.20385;
                D.20398 = obj_val + D.20386;
                address = *D.20398;
                if (address != 0B) goto <D.20407>; else goto <D.20408>;
                <D.20407>:
                mreq.imr_multiaddr = ipaddress_to_struct_in_addr (address);
                <D.20408>:
                D.20383 = obj_val->vtable;
                D.20384 = D.20383->klass;
                field = mono_class_get_field_from_name (D.20384, "local");
                D.20385 = field->offset;
                D.20386 = (sizetype) D.20385;
                D.20398 = obj_val + D.20386;
                address = *D.20398;
                if (address != 0B) goto <D.20409>; else goto <D.20410>;
                <D.20409>:
                mreq.imr_address = ipaddress_to_struct_in_addr (address);
                <D.20410>:
                D.20383 = obj_val->vtable;
                D.20384 = D.20383->klass;
                field = mono_class_get_field_from_name (D.20384, "iface_index");
                D.20385 = field->offset;
                D.20386 = (sizetype) D.20385;
                D.20411 = obj_val + D.20386;
                D.20412 = *D.20411;
                mreq.imr_ifindex = D.20412;
                system_level.61 = system_level;
                system_name.62 = system_name;
                ret = _wapi_setsockopt (sock, system_level.61, system_name.62, &mreq, 12);
              }
            finally
              {
                mreq = {CLOBBER};
              }
          }
          <D.20406>:
          <D.20404>:
          goto <D.19491>;
        }
        <D.19497>:
        *error = 10022;
        return;
        <D.19491>:
      }
      goto <D.20413>;
      <D.20382>:
      if (byte_val != 0B) goto <D.20414>; else goto <D.20415>;
      <D.20414>:
      {
        int valsize;
        guchar * buf;

        D.20416 = mono_array_length (byte_val);
        valsize = (int) D.20416;
        buf = mono_array_addr_with_size (byte_val, 1, 0);
        switch (name) <default: <D.19502>, case -129: <D.19500>>
        <D.19500>:
        if (valsize == 1) goto <D.20417>; else goto <D.20418>;
        <D.20417>:
        D.20419 = *buf;
        D.20420 = D.20419 == 0;
        D.20421 = (int) D.20420;
        linger.l_onoff = D.20421;
        linger.l_linger = 0;
        system_level.61 = system_level;
        system_name.62 = system_name;
        ret = _wapi_setsockopt (sock, system_level.61, system_name.62, &linger, 8);
        goto <D.20422>;
        <D.20418>:
        *error = 10022;
        <D.20422>:
        goto <D.19501>;
        <D.19502>:
        system_level.61 = system_level;
        system_name.62 = system_name;
        valsize.64 = (unsigned int) valsize;
        ret = _wapi_setsockopt (sock, system_level.61, system_name.62, buf, valsize.64);
        goto <D.19501>;
        <D.19501>:
      }
      goto <D.20424>;
      <D.20415>:
      switch (name) <default: <D.19508>, case -129: <D.19503>, case 9: <D.19505>, case 14: <D.19507>>
      <D.19503>:
      int_val.59 = int_val;
      D.20375 = int_val.59 == 0;
      int_val.60 = (int) D.20375;
      linger.l_onoff = int_val.60;
      linger.l_linger = 0;
      system_level.61 = system_level;
      system_name.62 = system_name;
      ret = _wapi_setsockopt (sock, system_level.61, system_name.62, &linger, 8);
      goto <D.19504>;
      <D.19505>:
      int_val.59 = int_val;
      int_val.65 = (unsigned int) int_val.59;
      D.20426 = int_val.65 << 24;
      int_val.59 = int_val;
      int_val.65 = (unsigned int) int_val.59;
      D.20427 = int_val.65 & 16711680;
      D.20428 = D.20427 >> 8;
      D.20429 = D.20426 | D.20428;
      int_val.59 = int_val;
      int_val.65 = (unsigned int) int_val.59;
      D.20430 = int_val.65 & 65280;
      D.20431 = D.20430 << 8;
      D.20432 = D.20429 | D.20431;
      int_val.59 = int_val;
      int_val.65 = (unsigned int) int_val.59;
      D.20433 = int_val.65 >> 24;
      D.20434 = D.20432 | D.20433;
      int_val.66 = (int) D.20434;
      int_val = int_val.66;
      int_val.59 = int_val;
      int_val.65 = (unsigned int) int_val.59;
      D.20436 = int_val.65 & 4278190080;
      if (D.20436 == 0) goto <D.20437>; else goto <D.20438>;
      <D.20437>:
      {
        struct ip_mreqn mreq;

        try
          {
            mreq = {};
            int_val.59 = int_val;
            mreq.imr_ifindex = int_val.59;
            system_level.61 = system_level;
            system_name.62 = system_name;
            ret = _wapi_setsockopt (sock, system_level.61, system_name.62, &mreq, 12);
            goto <D.19504>;
          }
        finally
          {
            mreq = {CLOBBER};
          }
      }
      <D.20438>:
      int_val.59 = int_val;
      int_val.65 = (unsigned int) int_val.59;
      D.20426 = int_val.65 << 24;
      int_val.59 = int_val;
      int_val.65 = (unsigned int) int_val.59;
      D.20427 = int_val.65 & 16711680;
      D.20428 = D.20427 >> 8;
      D.20429 = D.20426 | D.20428;
      int_val.59 = int_val;
      int_val.65 = (unsigned int) int_val.59;
      D.20430 = int_val.65 & 65280;
      D.20431 = D.20430 << 8;
      D.20432 = D.20429 | D.20431;
      int_val.59 = int_val;
      int_val.65 = (unsigned int) int_val.59;
      D.20433 = int_val.65 >> 24;
      D.20434 = D.20432 | D.20433;
      int_val.66 = (int) D.20434;
      int_val = int_val.66;
      system_level.61 = system_level;
      system_name.62 = system_name;
      ret = _wapi_setsockopt (sock, system_level.61, system_name.62, &int_val, 4);
      goto <D.19504>;
      <D.19507>:
      int_val.59 = int_val;
      if (int_val.59 == 1) goto <D.20439>; else goto <D.20440>;
      <D.20439>:
      int_val = 2;
      <D.20440>:
      <D.19508>:
      system_level.61 = system_level;
      system_name.62 = system_name;
      ret = _wapi_setsockopt (sock, system_level.61, system_name.62, &int_val, 4);
      <D.19504>:
      <D.20424>:
      <D.20413>:
      if (ret == -1) goto <D.20441>; else goto <D.20442>;
      <D.20441>:
      D.20443 = WSAGetLastError ();
      *error = D.20443;
      <D.20442>:
    }
  finally
    {
      linger = {CLOBBER};
      system_level = {CLOBBER};
      system_name = {CLOBBER};
    }
}


ipaddress_to_struct_in6_addr (struct MonoObject * ipaddr)
{
  struct MonoVTable * D.20448;
  struct MonoClass * D.20449;
  int D.20450;
  sizetype D.20451;
  struct MonoArray * * D.20452;
  long unsigned int D.20453;
  char * D.20454;
  short unsigned int D.20455;
  struct in6_addr D.20456;
  struct in6_addr in6addr;
  struct MonoClassField * field;
  struct MonoArray * data;
  int i;

  try
    {
      D.20448 = ipaddr->vtable;
      D.20449 = D.20448->klass;
      field = mono_class_get_field_from_name (D.20449, "m_Numbers");
      D.20450 = field->offset;
      D.20451 = (sizetype) D.20450;
      D.20452 = ipaddr + D.20451;
      data = *D.20452;
      i = 0;
      goto <D.19471>;
      <D.19470>:
      D.20453 = (long unsigned int) i;
      D.20454 = mono_array_addr_with_size (data, 2, D.20453);
      D.20455 = MEM[(guint16 *)D.20454];
      in6addr.__in6_u.__u6_addr16[i] = D.20455;
      i = i + 1;
      <D.19471>:
      if (i <= 7) goto <D.19470>; else goto <D.19472>;
      <D.19472>:
      D.20456 = in6addr;
      return D.20456;
    }
  finally
    {
      in6addr = {CLOBBER};
    }
}


ipaddress_to_struct_in_addr (struct MonoObject * ipaddr)
{
  struct MonoVTable * D.20459;
  struct MonoClass * D.20460;
  int D.20461;
  sizetype D.20462;
  guint64 * D.20463;
  long unsigned int D.20464;
  unsigned int D.20465;
  struct in_addr D.20466;
  struct in_addr inaddr;
  struct MonoClassField * field;

  try
    {
      D.20459 = ipaddr->vtable;
      D.20460 = D.20459->klass;
      field = mono_class_get_field_from_name (D.20460, "m_Address");
      D.20461 = field->offset;
      D.20462 = (sizetype) D.20461;
      D.20463 = ipaddr + D.20462;
      D.20464 = *D.20463;
      D.20465 = (unsigned int) D.20464;
      inaddr.s_addr = D.20465;
      D.20466 = inaddr;
      return D.20466;
    }
  finally
    {
      inaddr = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_Shutdown_internal (SOCKET sock, gint32 how, gint32 * error)
{
  int D.20471;
  int ret;

  *error = 0;
  ret = _wapi_shutdown (sock, how);
  if (ret == -1) goto <D.20469>; else goto <D.20470>;
  <D.20469>:
  D.20471 = WSAGetLastError ();
  *error = D.20471;
  <D.20470>:
}


ves_icall_System_Net_Sockets_Socket_WSAIoctl (SOCKET sock, gint32 code, struct MonoArray * input, struct MonoArray * output, gint32 * error)
{
  int D.20474;
  long unsigned int D.20478;
  long unsigned int D.20482;
  int D.20485;
  long int output_bytes.67;
  glong output_bytes;
  gchar * i_buffer;
  gchar * o_buffer;
  gint i_len;
  gint o_len;
  gint ret;

  try
    {
      output_bytes = 0;
      *error = 0;
      if (code == -2147195266) goto <D.20472>; else goto <D.20473>;
      <D.20472>:
      D.20474 = -1;
      return D.20474;
      <D.20473>:
      if (input == 0B) goto <D.20475>; else goto <D.20476>;
      <D.20475>:
      i_buffer = 0B;
      i_len = 0;
      goto <D.20477>;
      <D.20476>:
      i_buffer = mono_array_addr_with_size (input, 1, 0);
      D.20478 = mono_array_length (input);
      i_len = (gint) D.20478;
      <D.20477>:
      if (output == 0B) goto <D.20479>; else goto <D.20480>;
      <D.20479>:
      o_buffer = 0B;
      o_len = 0;
      goto <D.20481>;
      <D.20480>:
      o_buffer = mono_array_addr_with_size (output, 1, 0);
      D.20482 = mono_array_length (output);
      o_len = (gint) D.20482;
      <D.20481>:
      ret = WSAIoctl (sock, code, i_buffer, i_len, o_buffer, o_len, &output_bytes, 0B, 0B);
      if (ret == -1) goto <D.20483>; else goto <D.20484>;
      <D.20483>:
      D.20485 = WSAGetLastError ();
      *error = D.20485;
      D.20474 = -1;
      return D.20474;
      <D.20484>:
      output_bytes.67 = output_bytes;
      D.20474 = (int) output_bytes.67;
      return D.20474;
    }
  finally
    {
      output_bytes = {CLOBBER};
    }
}


ves_icall_System_Net_Dns_GetHostByName_internal (struct MonoString * host, struct MonoString * * h_name, struct MonoArray * * h_aliases, struct MonoArray * * h_addr_list)
{
  char D.20489;
  int D.20494;
  int D.19621;
  int D.20499;
  int D.20502;
  MonoBoolean D.20505;
  struct addrinfo * info.68;
  int D.20507;
  gboolean add_local_ips;
  gchar this_hostname[256];
  struct addrinfo * info;
  struct addrinfo hints;
  char * hostname;

  try
    {
      add_local_ips = 0;
      info = 0B;
      hostname = mono_string_to_utf8 (host);
      D.20489 = *hostname;
      if (D.20489 == 0) goto <D.20490>; else goto <D.20491>;
      <D.20490>:
      add_local_ips = 1;
      *h_name = host;
      <D.20491>:
      if (add_local_ips == 0) goto <D.20492>; else goto <D.20493>;
      <D.20492>:
      D.20494 = gethostname (&this_hostname, 256);
      if (D.20494 != -1) goto <D.20495>; else goto <D.20496>;
      <D.20495>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.19621 = __builtin_strcmp (hostname, &this_hostname);
      }
      if (D.19621 == 0) goto <D.20497>; else goto <D.20498>;
      <D.20497>:
      add_local_ips = 1;
      *h_name = host;
      <D.20498>:
      <D.20496>:
      <D.20493>:
      memset (&hints, 0, 48);
      D.20499 = get_family_hint ();
      hints.ai_family = D.20499;
      hints.ai_socktype = 1;
      hints.ai_flags = 2;
      D.20489 = *hostname;
      if (D.20489 != 0) goto <D.20500>; else goto <D.20501>;
      <D.20500>:
      D.20502 = getaddrinfo (hostname, 0B, &hints, &info);
      if (D.20502 == -1) goto <D.20503>; else goto <D.20504>;
      <D.20503>:
      D.20505 = 0;
      return D.20505;
      <D.20504>:
      <D.20501>:
      monoeg_g_free (hostname);
      info.68 = info;
      D.20507 = addrinfo_to_IPHostEntry (info.68, h_name, h_aliases, h_addr_list, add_local_ips);
      D.20505 = (MonoBoolean) D.20507;
      return D.20505;
    }
  finally
    {
      this_hostname = {CLOBBER};
      info = {CLOBBER};
      hints = {CLOBBER};
    }
}


gethostname (char * __buf, size_t __buflen)
{
  long unsigned int D.20510;
  int D.20513;
  int D.20516;
  long unsigned int D.20517;
  long unsigned int D.20518;
  long unsigned int D.20521;

  D.20510 = __builtin_object_size (__buf, 1);
  if (D.20510 != 18446744073709551615) goto <D.20511>; else goto <D.20512>;
  <D.20511>:
  D.20513 = __builtin_constant_p (__buflen);
  if (D.20513 == 0) goto <D.20514>; else goto <D.20515>;
  <D.20514>:
  D.20517 = __builtin_object_size (__buf, 1);
  D.20516 = __gethostname_chk (__buf, __buflen, D.20517);
  return D.20516;
  <D.20515>:
  D.20518 = __builtin_object_size (__buf, 1);
  if (D.20518 < __buflen) goto <D.20519>; else goto <D.20520>;
  <D.20519>:
  D.20521 = __builtin_object_size (__buf, 1);
  D.20516 = __gethostname_chk_warn (__buf, __buflen, D.20521);
  return D.20516;
  <D.20520>:
  <D.20512>:
  D.20516 = __gethostname_alias (__buf, __buflen);
  return D.20516;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.20525;
  int D.20530;
  void * D.20532;
  long unsigned int D.20533;

  D.20525 = __builtin_constant_p (__len);
  if (D.20525 != 0) goto <D.20526>; else goto <D.20527>;
  <D.20526>:
  if (__len == 0) goto <D.20528>; else goto <D.20529>;
  <D.20528>:
  D.20530 = __builtin_constant_p (__ch);
  if (D.20530 == 0) goto <D.20523>; else goto <D.20531>;
  <D.20531>:
  if (__ch != 0) goto <D.20523>; else goto <D.20524>;
  <D.20523>:
  __warn_memset_zero_len ();
  D.20532 = __dest;
  return D.20532;
  <D.20524>:
  <D.20529>:
  <D.20527>:
  D.20533 = __builtin_object_size (__dest, 0);
  D.20532 = __builtin___memset_chk (__dest, __ch, __len, D.20533);
  return D.20532;
}


get_family_hint ()
{
  unsigned char D.20535;
  struct MonoImage * D.20538;
  struct MonoDomain * D.20539;
  _Bool D.20540;
  long int D.20541;
  long int D.20542;
  union mono_mutex_t * D.20545;
  _Bool D.20548;
  long int D.20549;
  long int D.20550;
  int ipv4_enabled.69;
  int ipv6_enabled.70;
  _Bool D.20564;
  long int D.20565;
  long int D.20566;
  int D.20569;
  gint32 D.20570;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.20535 = domain->inet_family_hint;
  if (D.20535 == 0) goto <D.20536>; else goto <D.20537>;
  <D.20536>:
  {
    struct MonoClass * socket_class;
    struct MonoClassField * ipv6_field;
    struct MonoClassField * ipv4_field;
    gint32 ipv6_enabled;
    gint32 ipv4_enabled;
    struct MonoVTable * vtable;

    try
      {
        ipv6_enabled = -1;
        ipv4_enabled = -1;
        D.20538 = get_socket_assembly ();
        socket_class = mono_class_from_name (D.20538, "System.Net.Sockets", "Socket");
        ipv4_field = mono_class_get_field_from_name (socket_class, "ipv4Supported");
        ipv6_field = mono_class_get_field_from_name (socket_class, "ipv6Supported");
        D.20539 = mono_domain_get ();
        vtable = mono_class_vtable (D.20539, socket_class);
        D.20540 = vtable == 0B;
        D.20541 = (long int) D.20540;
        D.20542 = __builtin_expect (D.20541, 0);
        if (D.20542 != 0) goto <D.20543>; else goto <D.20544>;
        <D.20543>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 715, "vtable");
        <D.20544>:
        mono_runtime_class_init (vtable);
        mono_field_static_get_value (vtable, ipv4_field, &ipv4_enabled);
        mono_field_static_get_value (vtable, ipv6_field, &ipv6_enabled);
        {
          int ret;

          D.20545 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.20545);
          if (ret != 0) goto <D.20546>; else goto <D.20547>;
          <D.20546>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20547>:
          D.20548 = ret != 0;
          D.20549 = (long int) D.20548;
          D.20550 = __builtin_expect (D.20549, 0);
          if (D.20550 != 0) goto <D.20551>; else goto <D.20552>;
          <D.20551>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 721, "ret == 0");
          <D.20552>:
        }
        ipv4_enabled.69 = ipv4_enabled;
        if (ipv4_enabled.69 == 1) goto <D.20556>; else goto <D.20553>;
        <D.20556>:
        ipv6_enabled.70 = ipv6_enabled;
        if (ipv6_enabled.70 == 1) goto <D.20558>; else goto <D.20553>;
        <D.20558>:
        domain->inet_family_hint = 1;
        goto <D.20554>;
        <D.20553>:
        ipv4_enabled.69 = ipv4_enabled;
        if (ipv4_enabled.69 == 1) goto <D.20559>; else goto <D.20560>;
        <D.20559>:
        domain->inet_family_hint = 2;
        goto <D.20561>;
        <D.20560>:
        domain->inet_family_hint = 3;
        <D.20561>:
        <D.20554>:
        {
          int ret;

          D.20545 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.20545);
          if (ret != 0) goto <D.20562>; else goto <D.20563>;
          <D.20562>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20563>:
          D.20564 = ret != 0;
          D.20565 = (long int) D.20564;
          D.20566 = __builtin_expect (D.20565, 0);
          if (D.20566 != 0) goto <D.20567>; else goto <D.20568>;
          <D.20567>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 729, "ret == 0");
          <D.20568>:
        }
      }
    finally
      {
        ipv6_enabled = {CLOBBER};
        ipv4_enabled = {CLOBBER};
      }
  }
  <D.20537>:
  D.20535 = domain->inet_family_hint;
  D.20569 = (int) D.20535;
  switch (D.20569) <default: <D.19087>, case 1: <D.19084>, case 2: <D.19085>, case 3: <D.19086>>
  <D.19084>:
  D.20570 = 0;
  return D.20570;
  <D.19085>:
  D.20570 = 2;
  return D.20570;
  <D.19086>:
  D.20570 = 10;
  return D.20570;
  <D.19087>:
  D.20570 = 0;
  return D.20570;
}


addrinfo_to_IPHostEntry (struct addrinfo * info, struct MonoString * * h_name, struct MonoArray * * h_aliases, struct MonoArray * * h_addr_list, gboolean add_local_ips)
{
  struct MonoClass * D.20572;
  struct MonoArray * D.20573;
  int nlocal_in.71;
  int nlocal_in6.72;
  struct MonoClass * D.20581;
  int D.20582;
  long unsigned int D.20583;
  struct MonoArray * D.20584;
  long unsigned int D.20587;
  long unsigned int D.20588;
  struct in_addr * D.20589;
  struct MonoArray * D.20590;
  long unsigned int D.20591;
  long unsigned int D.20594;
  long unsigned int D.20595;
  struct in6_addr * D.20596;
  gboolean D.20601;
  int D.20602;
  struct MonoClass * D.20607;
  long unsigned int D.20608;
  struct MonoArray * D.20609;
  struct sockaddr * D.20616;
  struct in_addr * D.20617;
  struct in6_addr * D.20619;
  char * D.20625;
  struct MonoString * D.20628;
  struct MonoString * D.20630;
  gint32 count;
  gint32 i;
  struct addrinfo * ai;
  struct in_addr * local_in;
  int nlocal_in;
  struct in6_addr * local_in6;
  int nlocal_in6;
  int addr_index;
  struct MonoDomain * domain;

  try
    {
      ai = 0B;
      local_in = 0B;
      nlocal_in = 0;
      local_in6 = 0B;
      nlocal_in6 = 0;
      domain = mono_domain_get ();
      addr_index = 0;
      D.20572 = mono_get_string_class ();
      D.20573 = mono_array_new (domain, D.20572, 0);
      *h_aliases = D.20573;
      if (add_local_ips != 0) goto <D.20574>; else goto <D.20575>;
      <D.20574>:
      local_in = get_local_ips (2, &nlocal_in);
      local_in6 = get_local_ips (10, &nlocal_in6);
      nlocal_in.71 = nlocal_in;
      if (nlocal_in.71 != 0) goto <D.20576>; else goto <D.20579>;
      <D.20579>:
      nlocal_in6.72 = nlocal_in6;
      if (nlocal_in6.72 != 0) goto <D.20576>; else goto <D.20577>;
      <D.20576>:
      D.20581 = mono_get_string_class ();
      nlocal_in.71 = nlocal_in;
      nlocal_in6.72 = nlocal_in6;
      D.20582 = nlocal_in.71 + nlocal_in6.72;
      D.20583 = (long unsigned int) D.20582;
      D.20584 = mono_array_new (domain, D.20581, D.20583);
      *h_addr_list = D.20584;
      nlocal_in.71 = nlocal_in;
      if (nlocal_in.71 != 0) goto <D.20585>; else goto <D.20586>;
      <D.20585>:
      {
        struct MonoString * addr_string;
        char addr[16];
        int i;

        try
          {
            i = 0;
            goto <D.19580>;
            <D.19579>:
            D.20587 = (long unsigned int) i;
            D.20588 = D.20587 * 4;
            D.20589 = local_in + D.20588;
            inet_ntop (2, D.20589, &addr, 16);
            addr_string = mono_string_new (domain, &addr);
            {
              void * * __p;

              D.20590 = *h_addr_list;
              D.20591 = (long unsigned int) addr_index;
              __p = mono_array_addr_with_size (D.20590, 8, D.20591);
              D.20590 = *h_addr_list;
              mono_gc_wbarrier_set_arrayref (D.20590, __p, addr_string);
            }
            addr_index = addr_index + 1;
            i = i + 1;
            <D.19580>:
            nlocal_in.71 = nlocal_in;
            if (i < nlocal_in.71) goto <D.19579>; else goto <D.19581>;
            <D.19581>:
          }
        finally
          {
            addr = {CLOBBER};
          }
      }
      <D.20586>:
      nlocal_in6.72 = nlocal_in6;
      if (nlocal_in6.72 != 0) goto <D.20592>; else goto <D.20593>;
      <D.20592>:
      {
        struct MonoString * addr_string;
        const char * ret;
        char addr[48];
        int i;

        try
          {
            i = 0;
            goto <D.19588>;
            <D.19587>:
            D.20594 = (long unsigned int) i;
            D.20595 = D.20594 * 16;
            D.20596 = local_in6 + D.20595;
            ret = inet_ntop (10, D.20596, &addr, 48);
            if (ret != 0B) goto <D.20597>; else goto <D.20598>;
            <D.20597>:
            addr_string = mono_string_new (domain, &addr);
            {
              void * * __p;

              D.20590 = *h_addr_list;
              D.20591 = (long unsigned int) addr_index;
              __p = mono_array_addr_with_size (D.20590, 8, D.20591);
              D.20590 = *h_addr_list;
              mono_gc_wbarrier_set_arrayref (D.20590, __p, addr_string);
            }
            addr_index = addr_index + 1;
            <D.20598>:
            i = i + 1;
            <D.19588>:
            nlocal_in6.72 = nlocal_in6;
            if (i < nlocal_in6.72) goto <D.19587>; else goto <D.19589>;
            <D.19589>:
          }
        finally
          {
            addr = {CLOBBER};
          }
      }
      <D.20593>:
      monoeg_g_free (local_in);
      monoeg_g_free (local_in6);
      if (info != 0B) goto <D.20599>; else goto <D.20600>;
      <D.20599>:
      freeaddrinfo (info);
      <D.20600>:
      D.20601 = 1;
      return D.20601;
      <D.20577>:
      monoeg_g_free (local_in);
      monoeg_g_free (local_in6);
      <D.20575>:
      count = 0;
      ai = info;
      goto <D.19592>;
      <D.19591>:
      D.20602 = ai->ai_family;
      if (D.20602 != 2) goto <D.20603>; else goto <D.20604>;
      <D.20603>:
      D.20602 = ai->ai_family;
      if (D.20602 != 10) goto <D.20605>; else goto <D.20606>;
      <D.20605>:
      // predicted unlikely by continue predictor.
      goto <D.19590>;
      <D.20606>:
      <D.20604>:
      count = count + 1;
      <D.19590>:
      ai = ai->ai_next;
      <D.19592>:
      if (ai != 0B) goto <D.19591>; else goto <D.19593>;
      <D.19593>:
      D.20607 = mono_get_string_class ();
      D.20608 = (long unsigned int) count;
      D.20609 = mono_array_new (domain, D.20607, D.20608);
      *h_addr_list = D.20609;
      ai = info;
      i = 0;
      goto <D.19600>;
      <D.19599>:
      {
        struct MonoString * addr_string;
        const char * ret;
        char buffer[48];

        try
          {
            D.20602 = ai->ai_family;
            if (D.20602 != 2) goto <D.20610>; else goto <D.20611>;
            <D.20610>:
            D.20602 = ai->ai_family;
            if (D.20602 != 10) goto <D.20612>; else goto <D.20613>;
            <D.20612>:
            // predicted unlikely by continue predictor.
            goto <D.19597>;
            <D.20613>:
            <D.20611>:
            D.20602 = ai->ai_family;
            if (D.20602 == 2) goto <D.20614>; else goto <D.20615>;
            <D.20614>:
            D.20602 = ai->ai_family;
            D.20616 = ai->ai_addr;
            D.20617 = &MEM[(struct sockaddr_in *)D.20616].sin_addr;
            ret = inet_ntop (D.20602, D.20617, &buffer, 16);
            goto <D.20618>;
            <D.20615>:
            D.20602 = ai->ai_family;
            D.20616 = ai->ai_addr;
            D.20619 = &MEM[(struct sockaddr_in6 *)D.20616].sin6_addr;
            ret = inet_ntop (D.20602, D.20619, &buffer, 48);
            <D.20618>:
            if (ret != 0B) goto <D.20620>; else goto <D.20621>;
            <D.20620>:
            addr_string = mono_string_new (domain, &buffer);
            goto <D.20622>;
            <D.20621>:
            addr_string = mono_string_new (domain, "");
            <D.20622>:
            {
              void * * __p;

              D.20590 = *h_addr_list;
              D.20591 = (long unsigned int) addr_index;
              __p = mono_array_addr_with_size (D.20590, 8, D.20591);
              D.20590 = *h_addr_list;
              mono_gc_wbarrier_set_arrayref (D.20590, __p, addr_string);
            }
            if (i == 0) goto <D.20623>; else goto <D.20624>;
            <D.20623>:
            i = i + 1;
            D.20625 = ai->ai_canonname;
            if (D.20625 != 0B) goto <D.20626>; else goto <D.20627>;
            <D.20626>:
            D.20625 = ai->ai_canonname;
            D.20628 = mono_string_new (domain, D.20625);
            *h_name = D.20628;
            goto <D.20629>;
            <D.20627>:
            D.20630 = mono_string_new (domain, &buffer);
            *h_name = D.20630;
            <D.20629>:
            <D.20624>:
            addr_index = addr_index + 1;
          }
        finally
          {
            buffer = {CLOBBER};
          }
      }
      <D.19597>:
      ai = ai->ai_next;
      <D.19600>:
      if (ai != 0B) goto <D.19599>; else goto <D.19601>;
      <D.19601>:
      if (info != 0B) goto <D.20631>; else goto <D.20632>;
      <D.20631>:
      freeaddrinfo (info);
      <D.20632>:
      D.20601 = 1;
      return D.20601;
    }
  finally
    {
      nlocal_in = {CLOBBER};
      nlocal_in6 = {CLOBBER};
    }
}


get_local_ips (int family, int * nips)
{
  void * D.20643;
  unsigned int max_ifaces.73;
  unsigned int D.20645;
  int D.20646;
  int D.20647;
  long unsigned int D.20648;
  void * D.20649;
  int D.20650;
  char * D.20653;
  long unsigned int D.20654;
  long unsigned int D.20655;
  char[16] * D.20658;
  int D.20659;
  short int D.20662;
  unsigned short D.20663;
  int D.20664;
  int D.20665;
  int D.20668;
  int D.20671;
  int D.20672;
  long unsigned int D.20673;
  char D.20674;
  int D.20677;
  struct sockaddr * D.20680;
  sizetype D.20681;
  void * D.20682;
  int D.20683;
  char * D.20686;
  long unsigned int D.20687;
  sizetype D.20688;
  int addr_size;
  int offset;
  int fd;
  int i;
  int count;
  int max_ifaces;
  struct ifconf ifc;
  struct ifreq * ifr;
  struct ifreq iflags;
  char * result;
  char * tmp_ptr;
  gboolean ignore_loopback;

  try
    {
      max_ifaces = 50;
      ignore_loopback = 0;
      *nips = 0;
      if (family == 2) goto <D.20637>; else goto <D.20638>;
      <D.20637>:
      addr_size = 4;
      offset = 4;
      goto <D.20639>;
      <D.20638>:
      if (family == 10) goto <D.20640>; else goto <D.20641>;
      <D.20640>:
      addr_size = 16;
      offset = 8;
      goto <D.20642>;
      <D.20641>:
      D.20643 = 0B;
      return D.20643;
      <D.20642>:
      <D.20639>:
      fd = socket (family, 1, 0);
      max_ifaces.73 = (unsigned int) max_ifaces;
      D.20645 = max_ifaces.73 * 40;
      D.20646 = (int) D.20645;
      ifc.ifc_len = D.20646;
      D.20647 = ifc.ifc_len;
      D.20648 = (long unsigned int) D.20647;
      D.20649 = monoeg_malloc (D.20648);
      ifc.ifc_ifcu.ifcu_buf = D.20649;
      D.20650 = ioctl (fd, 35090, &ifc);
      if (D.20650 < 0) goto <D.20651>; else goto <D.20652>;
      <D.20651>:
      close (fd);
      D.20653 = ifc.ifc_ifcu.ifcu_buf;
      monoeg_g_free (D.20653);
      D.20643 = 0B;
      return D.20643;
      <D.20652>:
      D.20647 = ifc.ifc_len;
      D.20654 = (long unsigned int) D.20647;
      D.20655 = D.20654 / 40;
      count = (int) D.20655;
      *nips = count;
      if (count == 0) goto <D.20656>; else goto <D.20657>;
      <D.20656>:
      D.20653 = ifc.ifc_ifcu.ifcu_buf;
      monoeg_g_free (D.20653);
      close (fd);
      D.20643 = 0B;
      return D.20643;
      <D.20657>:
      i = 0;
      ifr = ifc.ifc_ifcu.ifcu_req;
      goto <D.19553>;
      <D.19552>:
      D.20658 = &ifr->ifr_ifrn.ifrn_name;
      strcpy (&iflags.ifr_ifrn.ifrn_name, D.20658);
      D.20659 = ioctl (fd, 35091, &iflags);
      if (D.20659 < 0) goto <D.20660>; else goto <D.20661>;
      <D.20660>:
      // predicted unlikely by continue predictor.
      goto <D.19551>;
      <D.20661>:
      D.20662 = iflags.ifr_ifru.ifru_flags;
      D.20663 = (unsigned short) D.20662;
      D.20664 = (int) D.20663;
      D.20665 = D.20664 & 1;
      if (D.20665 == 0) goto <D.20666>; else goto <D.20667>;
      <D.20666>:
      ifr->ifr_ifrn.ifrn_name[0] = 0;
      // predicted unlikely by continue predictor.
      goto <D.19551>;
      <D.20667>:
      D.20662 = iflags.ifr_ifru.ifru_flags;
      D.20663 = (unsigned short) D.20662;
      D.20664 = (int) D.20663;
      D.20668 = D.20664 & 8;
      if (D.20668 == 0) goto <D.20669>; else goto <D.20670>;
      <D.20669>:
      ignore_loopback = 1;
      <D.20670>:
      <D.19551>:
      i = i + 1;
      ifr = ifr + 40;
      <D.19553>:
      D.20671 = *nips;
      if (D.20671 > i) goto <D.19552>; else goto <D.19554>;
      <D.19554>:
      close (fd);
      D.20672 = addr_size * count;
      D.20673 = (long unsigned int) D.20672;
      result = monoeg_malloc (D.20673);
      tmp_ptr = result;
      i = 0;
      ifr = ifc.ifc_ifcu.ifcu_req;
      goto <D.19557>;
      <D.19556>:
      D.20674 = ifr->ifr_ifrn.ifrn_name[0];
      if (D.20674 == 0) goto <D.20675>; else goto <D.20676>;
      <D.20675>:
      D.20671 = *nips;
      D.20677 = D.20671 + -1;
      *nips = D.20677;
      // predicted unlikely by continue predictor.
      goto <D.19555>;
      <D.20676>:
      if (ignore_loopback != 0) goto <D.20678>; else goto <D.20679>;
      <D.20678>:
      D.20680 = &ifr->ifr_ifru.ifru_addr;
      D.20681 = (sizetype) offset;
      D.20682 = D.20680 + D.20681;
      D.20683 = is_loopback (family, D.20682);
      if (D.20683 != 0) goto <D.20684>; else goto <D.20685>;
      <D.20684>:
      D.20671 = *nips;
      D.20677 = D.20671 + -1;
      *nips = D.20677;
      // predicted unlikely by continue predictor.
      goto <D.19555>;
      <D.20685>:
      <D.20679>:
      D.20680 = &ifr->ifr_ifru.ifru_addr;
      D.20681 = (sizetype) offset;
      D.20686 = D.20680 + D.20681;
      D.20687 = (long unsigned int) addr_size;
      memcpy (tmp_ptr, D.20686, D.20687);
      D.20688 = (sizetype) addr_size;
      tmp_ptr = tmp_ptr + D.20688;
      <D.19555>:
      i = i + 1;
      ifr = ifr + 40;
      <D.19557>:
      if (i < count) goto <D.19556>; else goto <D.19558>;
      <D.19558>:
      D.20653 = ifc.ifc_ifcu.ifcu_buf;
      monoeg_g_free (D.20653);
      D.20643 = result;
      return D.20643;
    }
  finally
    {
      ifc = {CLOBBER};
      iflags = {CLOBBER};
    }
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.20691;
  long unsigned int D.20692;

  D.20692 = __builtin_object_size (__dest, 1);
  D.20691 = __builtin___strcpy_chk (__dest, __src, D.20692);
  return D.20691;
}


is_loopback (int family, void * ad)
{
  gboolean D.20696;
  char D.20697;
  _Bool D.20698;
  int D.19534;
  int iftmp.74;
  unsigned int D.20702;
  unsigned int D.20704;
  unsigned int D.20706;
  unsigned int D.20708;
  unsigned int D.20709;
  char * ptr;

  ptr = ad;
  if (family == 2) goto <D.20694>; else goto <D.20695>;
  <D.20694>:
  D.20697 = *ptr;
  D.20698 = D.20697 == 127;
  D.20696 = (gboolean) D.20698;
  return D.20696;
  <D.20695>:
  {
    const struct in6_addr * __a;

    __a = ptr;
    D.20702 = __a->__in6_u.__u6_addr32[0];
    if (D.20702 == 0) goto <D.20703>; else goto <D.20700>;
    <D.20703>:
    D.20704 = __a->__in6_u.__u6_addr32[1];
    if (D.20704 == 0) goto <D.20705>; else goto <D.20700>;
    <D.20705>:
    D.20706 = __a->__in6_u.__u6_addr32[2];
    if (D.20706 == 0) goto <D.20707>; else goto <D.20700>;
    <D.20707>:
    D.20708 = __a->__in6_u.__u6_addr32[3];
    D.20709 = __bswap_32 (1);
    if (D.20708 == D.20709) goto <D.20710>; else goto <D.20700>;
    <D.20710>:
    iftmp.74 = 1;
    goto <D.20701>;
    <D.20700>:
    iftmp.74 = 0;
    <D.20701>:
    D.19534 = iftmp.74;
  }
  D.20696 = D.19534;
  return D.20696;
  D.20696 = 0;
  return D.20696;
}


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

  D.20713 = __builtin_object_size (__dest, 0);
  D.20712 = __builtin___memcpy_chk (__dest, __src, __len, D.20713);
  return D.20712;
}


ves_icall_System_Net_Dns_GetHostByAddr_internal (struct MonoString * addr, struct MonoString * * h_name, struct MonoArray * * h_aliases, struct MonoArray * * h_addr_list)
{
  int D.20715;
  int D.20718;
  MonoBoolean D.20721;
  int D.20725;
  int D.20731;
  int D.20734;
  int D.20735;
  struct addrinfo * info.75;
  int D.20739;
  char * address;
  struct sockaddr_in saddr;
  struct sockaddr_in6 saddr6;
  struct addrinfo * info;
  struct addrinfo hints;
  gint32 family;
  char hostname[1025];
  int flags;

  try
    {
      info = 0B;
      hostname = {};
      flags = 0;
      address = mono_string_to_utf8 (addr);
      D.20715 = inet_pton (2, address, &saddr.sin_addr);
      if (D.20715 <= 0) goto <D.20716>; else goto <D.20717>;
      <D.20716>:
      D.20718 = inet_pton (10, address, &saddr6.sin6_addr);
      if (D.20718 <= 0) goto <D.20719>; else goto <D.20720>;
      <D.20719>:
      monoeg_g_free (address);
      D.20721 = 0;
      return D.20721;
      <D.20720>:
      family = 10;
      saddr6.sin6_family = 10;
      goto <D.20722>;
      <D.20717>:
      family = 2;
      saddr.sin_family = 2;
      <D.20722>:
      monoeg_g_free (address);
      if (family == 2) goto <D.20723>; else goto <D.20724>;
      <D.20723>:
      D.20725 = getnameinfo (&saddr, 16, &hostname, 1025, 0B, 0, flags);
      if (D.20725 != 0) goto <D.20726>; else goto <D.20727>;
      <D.20726>:
      D.20721 = 0;
      return D.20721;
      <D.20727>:
      goto <D.20728>;
      <D.20724>:
      if (family == 10) goto <D.20729>; else goto <D.20730>;
      <D.20729>:
      D.20731 = getnameinfo (&saddr6, 28, &hostname, 1025, 0B, 0, flags);
      if (D.20731 != 0) goto <D.20732>; else goto <D.20733>;
      <D.20732>:
      D.20721 = 0;
      return D.20721;
      <D.20733>:
      <D.20730>:
      <D.20728>:
      memset (&hints, 0, 48);
      D.20734 = get_family_hint ();
      hints.ai_family = D.20734;
      hints.ai_socktype = 1;
      hints.ai_flags = 34;
      D.20735 = getaddrinfo (&hostname, 0B, &hints, &info);
      if (D.20735 == -1) goto <D.20736>; else goto <D.20737>;
      <D.20736>:
      D.20721 = 0;
      return D.20721;
      <D.20737>:
      info.75 = info;
      D.20739 = addrinfo_to_IPHostEntry (info.75, h_name, h_aliases, h_addr_list, 0);
      D.20721 = (MonoBoolean) D.20739;
      return D.20721;
    }
  finally
    {
      saddr = {CLOBBER};
      saddr6 = {CLOBBER};
      info = {CLOBBER};
      hints = {CLOBBER};
      hostname = {CLOBBER};
    }
}


ves_icall_System_Net_Dns_GetHostName_internal (struct MonoString * * h_name)
{
  MonoBoolean D.20744;
  struct MonoDomain * D.20745;
  struct MonoString * D.20746;
  gchar hostname[256];
  int ret;

  try
    {
      ret = gethostname (&hostname, 256);
      if (ret == -1) goto <D.20742>; else goto <D.20743>;
      <D.20742>:
      D.20744 = 0;
      return D.20744;
      <D.20743>:
      D.20745 = mono_domain_get ();
      D.20746 = mono_string_new (D.20745, &hostname);
      *h_name = D.20746;
      D.20744 = 1;
      return D.20744;
    }
  finally
    {
      hostname = {CLOBBER};
    }
}


ves_icall_System_Net_Sockets_Socket_SendFile (SOCKET sock, struct MonoString * filename, struct MonoArray * pre_buffer, struct MonoArray * post_buffer, gint flags)
{
  gboolean D.20751;
  int error.76;
  unsigned int error.77;
  char * D.20758;
  long unsigned int D.20759;
  unsigned int D.20760;
  char * D.20763;
  long unsigned int D.20764;
  unsigned int D.20765;
  unsigned int flags.78;
  int D.20767;
  void * file;
  gint32 error;
  struct TRANSMIT_FILE_BUFFERS buffers;

  try
    {
      if (filename == 0B) goto <D.20749>; else goto <D.20750>;
      <D.20749>:
      D.20751 = 0;
      return D.20751;
      <D.20750>:
      file = ves_icall_System_IO_MonoIO_Open (filename, 3, 1, 1, 0, &error);
      if (file == -1B) goto <D.20752>; else goto <D.20753>;
      <D.20752>:
      error.76 = error;
      error.77 = (unsigned int) error.76;
      SetLastError (error.77);
      D.20751 = 0;
      return D.20751;
      <D.20753>:
      memset (&buffers, 0, 32);
      if (pre_buffer != 0B) goto <D.20756>; else goto <D.20757>;
      <D.20756>:
      D.20758 = mono_array_addr_with_size (pre_buffer, 1, 0);
      buffers.Head = D.20758;
      D.20759 = mono_array_length (pre_buffer);
      D.20760 = (unsigned int) D.20759;
      buffers.HeadLength = D.20760;
      <D.20757>:
      if (post_buffer != 0B) goto <D.20761>; else goto <D.20762>;
      <D.20761>:
      D.20763 = mono_array_addr_with_size (post_buffer, 1, 0);
      buffers.Tail = D.20763;
      D.20764 = mono_array_length (post_buffer);
      D.20765 = (unsigned int) D.20764;
      buffers.TailLength = D.20765;
      <D.20762>:
      flags.78 = (unsigned int) flags;
      D.20767 = TransmitFile (sock, file, 0, 0, 0B, &buffers, flags.78);
      if (D.20767 == 0) goto <D.20768>; else goto <D.20769>;
      <D.20768>:
      CloseHandle (file);
      D.20751 = 0;
      return D.20751;
      <D.20769>:
      CloseHandle (file);
      D.20751 = 1;
      return D.20751;
    }
  finally
    {
      error = {CLOBBER};
      buffers = {CLOBBER};
    }
}


mono_network_init ()
{
  struct WSADATA wsadata;
  int err;
  static const char __func__[18] = "mono_network_init";

  try
    {
      err = WSAStartup (2, &wsadata);
      if (err != 0) goto <D.20772>; else goto <D.20773>;
      <D.20772>:
      monoeg_g_log (0B, 4, "%s: Couldn\'t initialise networking", &__func__);
      <D.19657>:
      goto <D.19657>;
      exit (-1);
      <D.20773>:
    }
  finally
    {
      wsadata = {CLOBBER};
    }
}


mono_network_cleanup ()
{
  WSACleanup ();
}


icall_cancel_blocking_socket_operation (struct MonoThread * thread)
{
  int D.20774;
  long unsigned int D.20777;
  int D.20779;
  struct MonoInternalThread * internal;

  internal = thread->internal_thread;
  D.20774 = mono_thread_info_new_interrupt_enabled ();
  if (D.20774 != 0) goto <D.20775>; else goto <D.20776>;
  <D.20775>:
  D.20777 = internal->tid;
  mono_thread_info_abort_socket_syscall_for_close (D.20777);
  goto <D.20778>;
  <D.20776>:
  internal->ignore_next_signal = 1;
  D.20779 = mono_thread_get_abort_signal ();
  mono_thread_kill (internal, D.20779);
  <D.20778>:
}