__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Socket_internal (struct MonoObject * this, gint32 family, gint32 type, gint32 proto, gint32 * error)
{
  void * D.19206;
  int D.19213;
  long unsigned int D.19218;
  SOCKET sock;
  gint32 sock_family;
  gint32 sock_proto;
  gint32 sock_type;

  *error = 0;
  sock_family = convert_family (family);
  if (sock_family == -1) goto <D.19204>; else goto <D.19205>;
  <D.19204>:
  *error = 10047;
  D.19206 = 0B;
  return D.19206;
  <D.19205>:
  sock_proto = convert_proto (proto);
  if (sock_proto == -1) goto <D.19207>; else goto <D.19208>;
  <D.19207>:
  *error = 10043;
  D.19206 = 0B;
  return D.19206;
  <D.19208>:
  sock_type = convert_type (type);
  if (sock_type == -1) goto <D.19209>; else goto <D.19210>;
  <D.19209>:
  *error = 10044;
  D.19206 = 0B;
  return D.19206;
  <D.19210>:
  sock = _wapi_socket (sock_family, sock_type, sock_proto, 0B, 0, 1);
  if (sock == 4294967295) goto <D.19211>; else goto <D.19212>;
  <D.19211>:
  D.19213 = WSAGetLastError ();
  *error = D.19213;
  D.19206 = 0B;
  return D.19206;
  <D.19212>:
  if (sock_family == 2) goto <D.19214>; else goto <D.19215>;
  <D.19214>:
  if (sock_type == 2) goto <D.19216>; else goto <D.19217>;
  <D.19216>:
  D.19218 = (long unsigned int) sock;
  D.19206 = (void *) D.19218;
  return D.19206;
  <D.19217>:
  <D.19215>:
  if (sock_family == 10) goto <D.19219>; else goto <D.19220>;
  <D.19219>:
  if (sock_type == 2) goto <D.19221>; else goto <D.19222>;
  <D.19221>:
  D.19218 = (long unsigned int) sock;
  D.19206 = (void *) D.19218;
  return D.19206;
  <D.19222>:
  <D.19220>:
  D.19218 = (long unsigned int) sock;
  D.19206 = (void *) D.19218;
  return D.19206;
}


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

  family = -1;
  switch (mono_family) <default: <D.18488>, case -1: <D.18459>, case 0: <D.18479>, case 1: <D.18480>, case 2: <D.18481>, case 3: <D.18460>, case 4: <D.18461>, case 5: <D.18462>, case 6: <D.18482>, case 7: <D.18463>, case 8: <D.18464>, case 9: <D.18465>, case 10: <D.18466>, case 11: <D.18483>, case 12: <D.18484>, case 13: <D.18467>, case 14: <D.18468>, case 15: <D.18469>, case 16: <D.18485>, case 17: <D.18470>, case 18: <D.18471>, case 19: <D.18472>, case 21: <D.18473>, case 22: <D.18474>, case 23: <D.18486>, case 24: <D.18475>, case 25: <D.18476>, case 26: <D.18487>, case 28: <D.18477>>
  <D.18459>:
  <D.18460>:
  <D.18461>:
  <D.18462>:
  <D.18463>:
  <D.18464>:
  <D.18465>:
  <D.18466>:
  <D.18467>:
  <D.18468>:
  <D.18469>:
  <D.18470>:
  <D.18471>:
  <D.18472>:
  <D.18473>:
  <D.18474>:
  <D.18475>:
  <D.18476>:
  <D.18477>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.AddressFamily has unsupported value 0x%x", mono_family);
  goto <D.18478>;
  <D.18479>:
  family = 0;
  goto <D.18478>;
  <D.18480>:
  family = 1;
  goto <D.18478>;
  <D.18481>:
  family = 2;
  goto <D.18478>;
  <D.18482>:
  family = 4;
  goto <D.18478>;
  <D.18483>:
  family = 22;
  goto <D.18478>;
  <D.18484>:
  family = 12;
  goto <D.18478>;
  <D.18485>:
  family = 5;
  goto <D.18478>;
  <D.18486>:
  family = 10;
  goto <D.18478>;
  <D.18487>:
  family = 23;
  goto <D.18478>;
  <D.18488>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.AddressFamily has unknown value 0x%x", mono_family);
  <D.18478>:
  D.19224 = family;
  return D.19224;
}


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

  proto = -1;
  switch (mono_proto) <default: <D.18536>, case -1: <D.18535>, case 0: <D.18520>, case 1: <D.18522>, case 2: <D.18523>, case 3: <D.18524>, case 6: <D.18525>, case 12: <D.18526>, case 17: <D.18527>, case 22: <D.18528>, case 41: <D.18521>, case 77: <D.18530>, case 255: <D.18531>, case 1000: <D.18532>, case 1256: <D.18533>, case 1257: <D.18534>>
  <D.18520>:
  <D.18521>:
  <D.18522>:
  <D.18523>:
  <D.18524>:
  <D.18525>:
  <D.18526>:
  <D.18527>:
  <D.18528>:
  proto = mono_proto;
  goto <D.18529>;
  <D.18530>:
  <D.18531>:
  <D.18532>:
  <D.18533>:
  <D.18534>:
  <D.18535>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.ProtocolType has unsupported value 0x%x", mono_proto);
  goto <D.18529>;
  <D.18536>:
  goto <D.18529>;
  <D.18529>:
  D.19226 = proto;
  return D.19226;
}


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

  type = -1;
  switch (mono_type) <default: <D.18515>, case -1: <D.18514>, case 1: <D.18508>, case 2: <D.18510>, case 3: <D.18511>, case 4: <D.18512>, case 5: <D.18513>>
  <D.18508>:
  type = 1;
  goto <D.18509>;
  <D.18510>:
  type = 2;
  goto <D.18509>;
  <D.18511>:
  type = 3;
  goto <D.18509>;
  <D.18512>:
  type = 4;
  goto <D.18509>;
  <D.18513>:
  type = 5;
  goto <D.18509>;
  <D.18514>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketType has unsupported value 0x%x", mono_type);
  goto <D.18509>;
  <D.18515>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketType has unknown value 0x%x", mono_type);
  <D.18509>:
  D.19229 = type;
  return D.19229;
}


__attribute__((visibility ("hidden")))
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);
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_SocketException_WSAGetLastError_internal ()
{
  gint32 D.19232;

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


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Available_internal (SOCKET sock, gint32 * error)
{
  int D.19236;
  gint32 D.19237;
  int ret;
  int amount;

  try
    {
      *error = 0;
      ret = ioctlsocket (sock, 21531, &amount);
      if (ret == -1) goto <D.19234>; else goto <D.19235>;
      <D.19234>:
      D.19236 = WSAGetLastError ();
      *error = D.19236;
      D.19237 = 0;
      return D.19237;
      <D.19235>:
      D.19237 = amount;
      return D.19237;
    }
  finally
    {
      amount = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Blocking_internal (SOCKET sock, gboolean block, gint32 * error)
{
  int block.1;
  _Bool D.19241;
  int block.2;
  int D.19245;
  int ret;

  *error = 0;
  block.1 = block;
  D.19241 = block.1 == 0;
  block.2 = (int) D.19241;
  block = block.2;
  ret = ioctlsocket (sock, 21537, &block);
  if (ret == -1) goto <D.19243>; else goto <D.19244>;
  <D.19243>:
  D.19245 = WSAGetLastError ();
  *error = D.19245;
  <D.19244>:
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Accept_internal (SOCKET sock, gint32 * error, gboolean blocking)
{
  int D.19248;
  void * D.19249;
  long unsigned int D.19250;
  SOCKET newsock;

  *error = 0;
  newsock = _wapi_accept (sock, 0B, 0B);
  if (newsock == 4294967295) goto <D.19246>; else goto <D.19247>;
  <D.19246>:
  D.19248 = WSAGetLastError ();
  *error = D.19248;
  D.19249 = 0B;
  return D.19249;
  <D.19247>:
  D.19250 = (long unsigned int) newsock;
  D.19249 = (void *) D.19250;
  return D.19249;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Listen_internal (SOCKET sock, guint32 backlog, gint32 * error)
{
  int backlog.3;
  int D.19255;
  int ret;

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


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_LocalEndPoint_internal (SOCKET sock, gint32 af, gint32 * error)
{
  int D.19256;
  int D.19257;
  unsigned int salen.4;
  unsigned int salen.5;
  struct MonoObject * D.19262;
  gchar * iftmp.6;
  long unsigned int D.19266;
  long unsigned int D.19268;
  int D.19271;
  int salen.7;
  gchar * sa;
  socklen_t salen;
  int ret;
  struct MonoObject * result;

  try
    {
      *error = 0;
      D.19256 = convert_family (af);
      D.19257 = get_sockaddr_size (D.19256);
      salen.4 = (unsigned int) D.19257;
      salen = salen.4;
      salen.5 = salen;
      if (salen.5 == 0) goto <D.19260>; else goto <D.19261>;
      <D.19260>:
      *error = 10047;
      D.19262 = 0B;
      return D.19262;
      <D.19261>:
      salen.5 = salen;
      if (salen.5 <= 128) goto <D.19264>; else goto <D.19265>;
      <D.19264>:
      salen.5 = salen;
      D.19266 = (long unsigned int) salen.5;
      iftmp.6 = __builtin_alloca (D.19266);
      goto <D.19267>;
      <D.19265>:
      salen.5 = salen;
      D.19268 = (long unsigned int) salen.5;
      iftmp.6 = monoeg_malloc0 (D.19268);
      <D.19267>:
      sa = iftmp.6;
      ret = _wapi_getsockname (sock, sa, &salen);
      if (ret == -1) goto <D.19269>; else goto <D.19270>;
      <D.19269>:
      D.19271 = WSAGetLastError ();
      *error = D.19271;
      salen.5 = salen;
      if (salen.5 > 128) goto <D.19272>; else goto <D.19273>;
      <D.19272>:
      monoeg_g_free (sa);
      <D.19273>:
      D.19262 = 0B;
      return D.19262;
      <D.19270>:
      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.19275>; else goto <D.19276>;
      <D.19275>:
      monoeg_g_free (sa);
      <D.19276>:
      D.19262 = result;
      return D.19262;
    }
  finally
    {
      salen = {CLOBBER};
    }
}


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

  size = 0;
  if (family == 2) goto <D.19279>; else goto <D.19280>;
  <D.19279>:
  size = 16;
  goto <D.19281>;
  <D.19280>:
  if (family == 10) goto <D.19282>; else goto <D.19283>;
  <D.19282>:
  size = 28;
  goto <D.19284>;
  <D.19283>:
  if (family == 1) goto <D.19285>; else goto <D.19286>;
  <D.19285>:
  size = 110;
  <D.19286>:
  <D.19284>:
  <D.19281>:
  D.19287 = size;
  return D.19287;
}


create_object_from_sockaddr (struct sockaddr * saddr, int sa_size, gint32 * error)
{
  struct MonoClass * D.19289;
  struct MonoImage * D.19292;
  struct MonoClass * D.19293;
  _Bool D.19294;
  long int D.19295;
  long int D.19296;
  struct MonoClassField * D.19299;
  struct MonoClassField * D.19302;
  _Bool D.19303;
  long int D.19304;
  long int D.19305;
  struct MonoClass * D.18705;
  struct MonoClass * tmp_klass.8;
  struct MonoClass * D.19311;
  struct MonoClass * tmp_klass.9;
  _Bool D.19313;
  long int D.19314;
  long int D.19315;
  struct MonoVTable * D.19318;
  int D.19319;
  long unsigned int D.19320;
  short unsigned int D.19321;
  struct MonoObject * D.19324;
  unsigned char D.19325;
  int D.19326;
  unsigned char D.19327;
  short unsigned int D.19330;
  unsigned int D.19331;
  struct MonoImage * D.19334;
  struct MonoException * D.19335;
  short unsigned int D.19336;
  unsigned char D.19337;
  unsigned char D.19338;
  unsigned int D.19339;
  unsigned char D.19340;
  unsigned int D.19341;
  unsigned char D.19342;
  unsigned int D.19343;
  unsigned char D.19344;
  unsigned char D.19345;
  short unsigned int D.19348;
  struct MonoImage * D.19351;
  struct MonoException * D.19352;
  short unsigned int D.19353;
  unsigned char D.19354;
  unsigned char D.19355;
  struct in6_addr * D.19356;
  int D.19357;
  int D.19360;
  long unsigned int D.19361;
  unsigned char D.19363;
  unsigned int D.19364;
  unsigned char D.19365;
  unsigned int D.19366;
  unsigned char D.19367;
  unsigned int D.19368;
  unsigned char D.19369;
  unsigned int D.19370;
  unsigned char D.19371;
  int D.19374;
  long unsigned int D.19375;
  char D.19376;
  struct MonoDomain * domain;
  struct MonoObject * sockaddr_obj;
  struct MonoArray * data;
  MonoAddressFamily family;

  domain = mono_domain_get ();
  D.19289 = domain->sockaddr_class;
  if (D.19289 == 0B) goto <D.19290>; else goto <D.19291>;
  <D.19290>:
  D.19292 = get_socket_assembly ();
  D.19293 = mono_class_from_name (D.19292, "System.Net", "SocketAddress");
  domain->sockaddr_class = D.19293;
  D.19289 = domain->sockaddr_class;
  D.19294 = D.19289 == 0B;
  D.19295 = (long int) D.19294;
  D.19296 = __builtin_expect (D.19295, 0);
  if (D.19296 != 0) goto <D.19297>; else goto <D.19298>;
  <D.19297>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 935, "domain->sockaddr_class");
  <D.19298>:
  <D.19291>:
  D.19289 = domain->sockaddr_class;
  sockaddr_obj = mono_object_new (domain, D.19289);
  D.19299 = domain->sockaddr_data_field;
  if (D.19299 == 0B) goto <D.19300>; else goto <D.19301>;
  <D.19300>:
  D.19289 = domain->sockaddr_class;
  D.19302 = mono_class_get_field_from_name (D.19289, "data");
  domain->sockaddr_data_field = D.19302;
  D.19299 = domain->sockaddr_data_field;
  D.19303 = D.19299 == 0B;
  D.19304 = (long int) D.19303;
  D.19305 = __builtin_expect (D.19304, 0);
  if (D.19305 != 0) goto <D.19306>; else goto <D.19307>;
  <D.19306>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 942, "domain->sockaddr_data_field");
  <D.19307>:
  <D.19301>:
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.8 = tmp_klass;
      if (tmp_klass.8 == 0B) goto <D.19309>; else goto <D.19310>;
      <D.19309>:
      D.19311 = mono_get_byte_class ();
      tmp_klass.9 = mono_array_class_get (D.19311, 1);
      tmp_klass = tmp_klass.9;
      tmp_klass.8 = tmp_klass;
      D.19313 = tmp_klass.8 == 0B;
      D.19314 = (long int) D.19313;
      D.19315 = __builtin_expect (D.19314, 0);
      if (D.19315 != 0) goto <D.19316>; else goto <D.19317>;
      <D.19316>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 949, "tmp_klass");
      <D.19317>:
      <D.19310>:
    }
    D.18705 = tmp_klass;
  }
  D.19318 = mono_class_vtable (domain, D.18705);
  D.19319 = sa_size + 2;
  D.19320 = (long unsigned int) D.19319;
  data = mono_array_new_specific (D.19318, D.19320);
  D.19321 = saddr->sa_family;
  family = convert_to_mono_family (D.19321);
  if (family == -1) goto <D.19322>; else goto <D.19323>;
  <D.19322>:
  *error = 10047;
  D.19324 = 0B;
  return D.19324;
  <D.19323>:
  {
    guint8 * __p;

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

    __p = mono_array_addr_with_size (data, 1, 1);
    D.19326 = family >> 8;
    D.19327 = (unsigned char) D.19326;
    *__p = D.19327;
  }
  D.19321 = saddr->sa_family;
  if (D.19321 == 2) goto <D.19328>; else goto <D.19329>;
  <D.19328>:
  {
    struct sockaddr_in * sa_in;
    guint16 port;
    guint32 address;

    sa_in = saddr;
    D.19330 = sa_in->sin_port;
    port = __uint16_identity (D.19330);
    D.19331 = sa_in->sin_addr.s_addr;
    address = __uint32_identity (D.19331);
    if (sa_size <= 7) goto <D.19332>; else goto <D.19333>;
    <D.19332>:
    D.19334 = mono_get_corlib ();
    D.19335 = mono_exception_from_name (D.19334, "System", "SystemException");
    mono_raise_exception (D.19335);
    <D.19333>:
    {
      guint8 * __p;

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

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

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

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

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

      __p = mono_array_addr_with_size (data, 1, 7);
      D.19345 = (unsigned char) address;
      *__p = D.19345;
    }
    D.19299 = domain->sockaddr_data_field;
    mono_field_set_value (sockaddr_obj, D.19299, data);
    D.19324 = sockaddr_obj;
    return D.19324;
  }
  <D.19329>:
  D.19321 = saddr->sa_family;
  if (D.19321 == 10) goto <D.19346>; else goto <D.19347>;
  <D.19346>:
  {
    struct sockaddr_in6 * sa_in;
    int i;
    guint16 port;

    sa_in = saddr;
    D.19348 = sa_in->sin6_port;
    port = __uint16_identity (D.19348);
    if (sa_size <= 27) goto <D.19349>; else goto <D.19350>;
    <D.19349>:
    D.19351 = mono_get_corlib ();
    D.19352 = mono_exception_from_name (D.19351, "System", "SystemException");
    mono_raise_exception (D.19352);
    <D.19350>:
    {
      guint8 * __p;

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

      __p = mono_array_addr_with_size (data, 1, 3);
      D.19355 = (unsigned char) port;
      *__p = D.19355;
    }
    D.19356 = &sa_in->sin6_addr;
    D.19357 = is_ipv4_mapped_any (D.19356);
    if (D.19357 != 0) goto <D.19358>; else goto <D.19359>;
    <D.19358>:
    i = 0;
    goto <D.18724>;
    <D.18723>:
    {
      guint8 * __p;

      D.19360 = i + 8;
      D.19361 = (long unsigned int) D.19360;
      __p = mono_array_addr_with_size (data, 1, D.19361);
      *__p = 0;
    }
    i = i + 1;
    <D.18724>:
    if (i <= 15) goto <D.18723>; else goto <D.18725>;
    <D.18725>:
    goto <D.19362>;
    <D.19359>:
    i = 0;
    goto <D.18728>;
    <D.18727>:
    {
      guint8 * __p;

      D.19360 = i + 8;
      D.19361 = (long unsigned int) D.19360;
      __p = mono_array_addr_with_size (data, 1, D.19361);
      D.19363 = sa_in->sin6_addr.__in6_u.__u6_addr8[i];
      *__p = D.19363;
    }
    i = i + 1;
    <D.18728>:
    if (i <= 15) goto <D.18727>; else goto <D.18729>;
    <D.18729>:
    <D.19362>:
    {
      guint8 * __p;

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

      __p = mono_array_addr_with_size (data, 1, 25);
      D.19364 = sa_in->sin6_scope_id;
      D.19366 = D.19364 >> 8;
      D.19367 = (unsigned char) D.19366;
      *__p = D.19367;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 26);
      D.19364 = sa_in->sin6_scope_id;
      D.19368 = D.19364 >> 16;
      D.19369 = (unsigned char) D.19368;
      *__p = D.19369;
    }
    {
      guint8 * __p;

      __p = mono_array_addr_with_size (data, 1, 27);
      D.19364 = sa_in->sin6_scope_id;
      D.19370 = D.19364 >> 24;
      D.19371 = (unsigned char) D.19370;
      *__p = D.19371;
    }
    D.19299 = domain->sockaddr_data_field;
    mono_field_set_value (sockaddr_obj, D.19299, data);
    D.19324 = sockaddr_obj;
    return D.19324;
  }
  <D.19347>:
  D.19321 = saddr->sa_family;
  if (D.19321 == 1) goto <D.19372>; else goto <D.19373>;
  <D.19372>:
  {
    int i;

    i = 0;
    goto <D.18737>;
    <D.18736>:
    {
      guint8 * __p;

      D.19374 = i + 2;
      D.19375 = (long unsigned int) D.19374;
      __p = mono_array_addr_with_size (data, 1, D.19375);
      D.19376 = saddr->sa_data[i];
      *__p = D.19376;
    }
    i = i + 1;
    <D.18737>:
    if (i < sa_size) goto <D.18736>; else goto <D.18738>;
    <D.18738>:
    D.19299 = domain->sockaddr_data_field;
    mono_field_set_value (sockaddr_obj, D.19299, data);
    D.19324 = sockaddr_obj;
    return D.19324;
  }
  <D.19373>:
  *error = 10047;
  D.19324 = 0B;
  return D.19324;
}


get_socket_assembly ()
{
  struct MonoImage * D.19378;
  struct MonoImage * D.19385;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.19378 = domain->socket_assembly;
  if (D.19378 == 0B) goto <D.19379>; else goto <D.19380>;
  <D.19379>:
  {
    struct MonoImage * socket_assembly;

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

      sa = mono_assembly_open ("System.dll", 0B);
      if (sa == 0B) goto <D.19383>; else goto <D.19384>;
      <D.19383>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "socket-io.c", 689);
      <D.19384>:
      socket_assembly = mono_assembly_get_image (sa);
    }
    <D.19382>:
    domain->socket_assembly = socket_assembly;
  }
  <D.19380>:
  D.19385 = domain->socket_assembly;
  return D.19385;
}


convert_to_mono_family (guint16 af_family)
{
  int D.19387;
  MonoAddressFamily D.19388;
  MonoAddressFamily family;

  family = -1;
  D.19387 = (int) af_family;
  switch (D.19387) <default: <D.18503>, case 0: <D.18493>, case 1: <D.18495>, case 2: <D.18496>, case 4: <D.18497>, case 5: <D.18500>, case 10: <D.18501>, case 12: <D.18499>, case 22: <D.18498>, case 23: <D.18502>>
  <D.18493>:
  family = 0;
  goto <D.18494>;
  <D.18495>:
  family = 1;
  goto <D.18494>;
  <D.18496>:
  family = 2;
  goto <D.18494>;
  <D.18497>:
  family = 6;
  goto <D.18494>;
  <D.18498>:
  family = 11;
  goto <D.18494>;
  <D.18499>:
  family = 12;
  goto <D.18494>;
  <D.18500>:
  family = 16;
  goto <D.18494>;
  <D.18501>:
  family = 23;
  goto <D.18494>;
  <D.18502>:
  family = 26;
  goto <D.18494>;
  <D.18503>:
  D.19387 = (int) af_family;
  monoeg_g_log (0B, 16, "unknown address family 0x%x", D.19387);
  <D.18494>:
  D.19388 = family;
  return D.19388;
}


__uint32_identity (__uint32_t __x)
{
  __uint32_t D.19390;

  D.19390 = __x;
  return D.19390;
}


__uint16_identity (__uint16_t __x)
{
  __uint16_t D.19392;

  D.19392 = __x;
  return D.19392;
}


is_ipv4_mapped_any (const struct in6_addr * addr)
{
  unsigned char D.19394;
  gboolean D.19397;
  unsigned int D.19398;
  unsigned int D.19399;
  int i;

  i = 0;
  goto <D.18690>;
  <D.18689>:
  D.19394 = addr->__in6_u.__u6_addr8[i];
  if (D.19394 != 0) goto <D.19395>; else goto <D.19396>;
  <D.19395>:
  D.19397 = 0;
  return D.19397;
  <D.19396>:
  i = i + 1;
  <D.18690>:
  if (i <= 9) goto <D.18689>; else goto <D.18691>;
  <D.18691>:
  D.19398 = BIT_FIELD_REF <MEM[(void *)addr], 32, 64>;
  D.19399 = D.19398 & 65535;
  if (D.19399 != 65535) goto <D.19400>; else goto <D.19401>;
  <D.19400>:
  D.19397 = 0;
  return D.19397;
  <D.19401>:
  i = 12;
  goto <D.18693>;
  <D.18692>:
  D.19394 = addr->__in6_u.__u6_addr8[i];
  if (D.19394 != 0) goto <D.19402>; else goto <D.19403>;
  <D.19402>:
  D.19397 = 0;
  return D.19397;
  <D.19403>:
  i = i + 1;
  <D.18693>:
  if (i <= 15) goto <D.18692>; else goto <D.18694>;
  <D.18694>:
  D.19397 = 1;
  return D.19397;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_RemoteEndPoint_internal (SOCKET sock, gint32 af, gint32 * error)
{
  int D.19405;
  int D.19406;
  unsigned int salen.10;
  unsigned int salen.11;
  struct MonoObject * D.19411;
  gchar * iftmp.12;
  long unsigned int D.19415;
  long unsigned int D.19417;
  int D.19420;
  int salen.13;
  gchar * sa;
  socklen_t salen;
  int ret;
  struct MonoObject * result;

  try
    {
      *error = 0;
      D.19405 = convert_family (af);
      D.19406 = get_sockaddr_size (D.19405);
      salen.10 = (unsigned int) D.19406;
      salen = salen.10;
      salen.11 = salen;
      if (salen.11 == 0) goto <D.19409>; else goto <D.19410>;
      <D.19409>:
      *error = 10047;
      D.19411 = 0B;
      return D.19411;
      <D.19410>:
      salen.11 = salen;
      if (salen.11 <= 128) goto <D.19413>; else goto <D.19414>;
      <D.19413>:
      salen.11 = salen;
      D.19415 = (long unsigned int) salen.11;
      iftmp.12 = __builtin_alloca (D.19415);
      goto <D.19416>;
      <D.19414>:
      salen.11 = salen;
      D.19417 = (long unsigned int) salen.11;
      iftmp.12 = monoeg_malloc0 (D.19417);
      <D.19416>:
      sa = iftmp.12;
      ret = _wapi_getpeername (sock, sa, &salen);
      if (ret == -1) goto <D.19418>; else goto <D.19419>;
      <D.19418>:
      D.19420 = WSAGetLastError ();
      *error = D.19420;
      salen.11 = salen;
      if (salen.11 > 128) goto <D.19421>; else goto <D.19422>;
      <D.19421>:
      monoeg_g_free (sa);
      <D.19422>:
      D.19411 = 0B;
      return D.19411;
      <D.19419>:
      salen.11 = salen;
      salen.13 = (int) salen.11;
      result = create_object_from_sockaddr (sa, salen.13, error);
      salen.11 = salen;
      if (salen.11 > 128) goto <D.19424>; else goto <D.19425>;
      <D.19424>:
      monoeg_g_free (sa);
      <D.19425>:
      D.19411 = result;
      return D.19411;
    }
  finally
    {
      salen = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Bind_internal (SOCKET sock, struct MonoObject * sockaddr, gint32 * error)
{
  int D.19428;
  unsigned int sa_size.14;
  int D.19434;
  struct sockaddr * sa;
  socklen_t sa_size;
  int ret;

  try
    {
      *error = 0;
      sa = create_sockaddr_from_object (sockaddr, &sa_size, error);
      D.19428 = *error;
      if (D.19428 != 0) goto <D.19429>; else goto <D.19430>;
      <D.19429>:
      return;
      <D.19430>:
      sa_size.14 = sa_size;
      ret = _wapi_bind (sock, sa, sa_size.14);
      if (ret == -1) goto <D.19432>; else goto <D.19433>;
      <D.19432>:
      D.19434 = WSAGetLastError ();
      *error = D.19434;
      <D.19433>:
      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.19438;
  struct MonoClass * D.19439;
  int D.19440;
  sizetype D.19441;
  struct MonoArray * * D.19442;
  long unsigned int D.19443;
  struct MonoImage * D.19446;
  struct MonoException * D.19447;
  char * D.19448;
  unsigned char D.19449;
  int D.19450;
  char * D.19451;
  unsigned char D.19452;
  int D.19453;
  int D.19454;
  int D.19455;
  struct MonoImage * D.19460;
  struct MonoException * D.19461;
  char * D.19462;
  unsigned char D.19463;
  short unsigned int D.19464;
  short unsigned int D.19465;
  char * D.19466;
  unsigned char D.19467;
  short unsigned int D.19468;
  char * D.19469;
  unsigned char D.19470;
  int D.19471;
  int D.19472;
  char * D.19473;
  unsigned char D.19474;
  int D.19475;
  int D.19476;
  int D.19477;
  char * D.19478;
  unsigned char D.19479;
  int D.19480;
  int D.19481;
  int D.19482;
  char * D.19483;
  unsigned char D.19484;
  int D.19485;
  int D.19486;
  short unsigned int D.19487;
  unsigned int D.19488;
  short unsigned int D.19489;
  struct sockaddr * D.19490;
  struct MonoImage * D.19495;
  struct MonoException * D.19496;
  char * D.19497;
  unsigned char D.19498;
  short unsigned int D.19499;
  char * D.19500;
  unsigned char D.19501;
  short unsigned int D.19502;
  short unsigned int D.19503;
  char * D.19504;
  unsigned char D.19505;
  int D.19506;
  char * D.19507;
  unsigned char D.19508;
  int D.19509;
  int D.19510;
  int D.19511;
  char * D.19512;
  unsigned char D.19513;
  int D.19514;
  int D.19515;
  int D.19516;
  char * D.19517;
  unsigned char D.19518;
  int D.19519;
  int D.19520;
  int D.19521;
  short unsigned int D.19522;
  int D.19523;
  long unsigned int D.19524;
  char * D.19525;
  unsigned char D.19526;
  struct MonoException * D.19531;
  int D.19532;
  long unsigned int D.19533;
  char * D.19534;
  unsigned char D.19535;
  int D.19536;
  unsigned int len.15;
  struct MonoClassField * field;
  struct MonoArray * data;
  gint32 family;
  int len;

  D.19438 = saddr_obj->vtable;
  D.19439 = D.19438->klass;
  field = mono_class_get_field_from_name (D.19439, "data");
  D.19440 = field->offset;
  D.19441 = (sizetype) D.19440;
  D.19442 = saddr_obj + D.19441;
  data = *D.19442;
  D.19443 = mono_array_length (data);
  len = (int) D.19443;
  if (len <= 1) goto <D.19444>; else goto <D.19445>;
  <D.19444>:
  D.19446 = mono_get_corlib ();
  D.19447 = mono_exception_from_name (D.19446, "System", "SystemException");
  mono_raise_exception (D.19447);
  <D.19445>:
  D.19448 = mono_array_addr_with_size (data, 1, 0);
  D.19449 = MEM[(guint8 *)D.19448];
  D.19450 = (int) D.19449;
  D.19451 = mono_array_addr_with_size (data, 1, 1);
  D.19452 = MEM[(guint8 *)D.19451];
  D.19453 = (int) D.19452;
  D.19454 = D.19453 << 8;
  D.19455 = D.19450 + D.19454;
  family = convert_family (D.19455);
  if (family == 2) goto <D.19456>; else goto <D.19457>;
  <D.19456>:
  {
    struct sockaddr_in * sa;
    guint16 port;
    guint32 address;

    if (len <= 7) goto <D.19458>; else goto <D.19459>;
    <D.19458>:
    D.19460 = mono_get_corlib ();
    D.19461 = mono_exception_from_name (D.19460, "System", "SystemException");
    mono_raise_exception (D.19461);
    <D.19459>:
    sa = monoeg_malloc0 (16);
    D.19462 = mono_array_addr_with_size (data, 1, 2);
    D.19463 = MEM[(guint8 *)D.19462];
    D.19464 = (short unsigned int) D.19463;
    D.19465 = D.19464 << 8;
    D.19466 = mono_array_addr_with_size (data, 1, 3);
    D.19467 = MEM[(guint8 *)D.19466];
    D.19468 = (short unsigned int) D.19467;
    port = D.19465 + D.19468;
    D.19469 = mono_array_addr_with_size (data, 1, 4);
    D.19470 = MEM[(guint8 *)D.19469];
    D.19471 = (int) D.19470;
    D.19472 = D.19471 << 24;
    D.19473 = mono_array_addr_with_size (data, 1, 5);
    D.19474 = MEM[(guint8 *)D.19473];
    D.19475 = (int) D.19474;
    D.19476 = D.19475 << 16;
    D.19477 = D.19472 + D.19476;
    D.19478 = mono_array_addr_with_size (data, 1, 6);
    D.19479 = MEM[(guint8 *)D.19478];
    D.19480 = (int) D.19479;
    D.19481 = D.19480 << 8;
    D.19482 = D.19477 + D.19481;
    D.19483 = mono_array_addr_with_size (data, 1, 7);
    D.19484 = MEM[(guint8 *)D.19483];
    D.19485 = (int) D.19484;
    D.19486 = D.19482 + D.19485;
    address = (guint32) D.19486;
    D.19487 = (short unsigned int) family;
    sa->sin_family = D.19487;
    D.19488 = __uint32_identity (address);
    sa->sin_addr.s_addr = D.19488;
    D.19489 = __uint16_identity (port);
    sa->sin_port = D.19489;
    *sa_size = 16;
    D.19490 = sa;
    return D.19490;
  }
  <D.19457>:
  if (family == 10) goto <D.19491>; else goto <D.19492>;
  <D.19491>:
  {
    struct sockaddr_in6 * sa;
    int i;
    guint16 port;
    guint32 scopeid;

    if (len <= 27) goto <D.19493>; else goto <D.19494>;
    <D.19493>:
    D.19495 = mono_get_corlib ();
    D.19496 = mono_exception_from_name (D.19495, "System", "SystemException");
    mono_raise_exception (D.19496);
    <D.19494>:
    sa = monoeg_malloc0 (28);
    D.19497 = mono_array_addr_with_size (data, 1, 3);
    D.19498 = MEM[(guint8 *)D.19497];
    D.19499 = (short unsigned int) D.19498;
    D.19500 = mono_array_addr_with_size (data, 1, 2);
    D.19501 = MEM[(guint8 *)D.19500];
    D.19502 = (short unsigned int) D.19501;
    D.19503 = D.19502 << 8;
    port = D.19499 + D.19503;
    D.19504 = mono_array_addr_with_size (data, 1, 24);
    D.19505 = MEM[(guint8 *)D.19504];
    D.19506 = (int) D.19505;
    D.19507 = mono_array_addr_with_size (data, 1, 25);
    D.19508 = MEM[(guint8 *)D.19507];
    D.19509 = (int) D.19508;
    D.19510 = D.19509 << 8;
    D.19511 = D.19506 + D.19510;
    D.19512 = mono_array_addr_with_size (data, 1, 26);
    D.19513 = MEM[(guint8 *)D.19512];
    D.19514 = (int) D.19513;
    D.19515 = D.19514 << 16;
    D.19516 = D.19511 + D.19515;
    D.19517 = mono_array_addr_with_size (data, 1, 27);
    D.19518 = MEM[(guint8 *)D.19517];
    D.19519 = (int) D.19518;
    D.19520 = D.19519 << 24;
    D.19521 = D.19516 + D.19520;
    scopeid = (guint32) D.19521;
    D.19487 = (short unsigned int) family;
    sa->sin6_family = D.19487;
    D.19522 = __uint16_identity (port);
    sa->sin6_port = D.19522;
    sa->sin6_scope_id = scopeid;
    i = 0;
    goto <D.18778>;
    <D.18777>:
    D.19523 = i + 8;
    D.19524 = (long unsigned int) D.19523;
    D.19525 = mono_array_addr_with_size (data, 1, D.19524);
    D.19526 = MEM[(guint8 *)D.19525];
    sa->sin6_addr.__in6_u.__u6_addr8[i] = D.19526;
    i = i + 1;
    <D.18778>:
    if (i <= 15) goto <D.18777>; else goto <D.18779>;
    <D.18779>:
    *sa_size = 28;
    D.19490 = sa;
    return D.19490;
  }
  <D.19492>:
  if (family == 1) goto <D.19527>; else goto <D.19528>;
  <D.19527>:
  {
    struct sockaddr_un * sock_un;
    int i;

    if (len > 1) goto <D.19529>; else goto <D.19530>;
    <D.19529>:
    D.19531 = mono_get_exception_index_out_of_range ();
    mono_raise_exception (D.19531);
    <D.19530>:
    sock_un = monoeg_malloc0 (110);
    D.19487 = (short unsigned int) family;
    sock_un->sun_family = D.19487;
    i = 0;
    goto <D.18783>;
    <D.18782>:
    D.19532 = i + 2;
    D.19533 = (long unsigned int) D.19532;
    D.19534 = mono_array_addr_with_size (data, 1, D.19533);
    D.19535 = MEM[(guint8 *)D.19534];
    sock_un->sun_path[i] = D.19535;
    i = i + 1;
    <D.18783>:
    D.19536 = len + -2;
    if (D.19536 > i) goto <D.18782>; else goto <D.18784>;
    <D.18784>:
    len.15 = (unsigned int) len;
    *sa_size = len.15;
    D.19490 = sock_un;
    return D.19490;
  }
  <D.19528>:
  *error = 10047;
  D.19490 = 0B;
  return D.19490;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Poll_internal (SOCKET sock, gint mode, gint timeout, gint32 * error)
{
  int sock.16;
  short int iftmp.17;
  short int iftmp.18;
  int iftmp.19;
  int * D.19556;
  long int D.19557;
  unsigned int D.19558;
  unsigned int D.19559;
  unsigned int D.19560;
  int D.19561;
  int D.19566;
  MonoBoolean D.19573;
  unsigned int D.19577;
  unsigned int D.19578;
  int D.19579;
  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.16 = (int) sock;
  pfds->fd = sock.16;
  if (mode != 0) goto <D.19541>; else goto <D.19542>;
  <D.19541>:
  if (mode == 1) goto <D.19544>; else goto <D.19545>;
  <D.19544>:
  iftmp.18 = 4;
  goto <D.19546>;
  <D.19545>:
  iftmp.18 = 56;
  <D.19546>:
  iftmp.17 = iftmp.18;
  goto <D.19547>;
  <D.19542>:
  iftmp.17 = 1;
  <D.19547>:
  pfds->events = iftmp.17;
  if (timeout >= 0) goto <D.19549>; else goto <D.19550>;
  <D.19549>:
  iftmp.19 = timeout / 1000;
  goto <D.19551>;
  <D.19550>:
  iftmp.19 = -1;
  <D.19551>:
  timeout = iftmp.19;
  start = time (0B);
  <D.18810>:
  *error = 0;
  ret = mono_poll (pfds, 1, timeout);
  if (timeout > 0) goto <D.19552>; else goto <D.19553>;
  <D.19552>:
  if (ret < 0) goto <D.19554>; else goto <D.19555>;
  <D.19554>:
  {
    int err;
    int sec;

    D.19556 = __errno_location ();
    err = *D.19556;
    D.19557 = time (0B);
    D.19558 = (unsigned int) D.19557;
    D.19559 = (unsigned int) start;
    D.19560 = D.19558 - D.19559;
    sec = (int) D.19560;
    D.19561 = sec * -1000;
    timeout = D.19561 + timeout;
    if (timeout < 0) goto <D.19562>; else goto <D.19563>;
    <D.19562>:
    timeout = 0;
    <D.19563>:
    D.19556 = __errno_location ();
    *D.19556 = err;
  }
  <D.19555>:
  <D.19553>:
  if (ret == -1) goto <D.19564>; else goto <D.19565>;
  <D.19564>:
  D.19556 = __errno_location ();
  D.19566 = *D.19556;
  if (D.19566 == 4) goto <D.19567>; else goto <D.19568>;
  <D.19567>:
  {
    int leave;

    leave = 0;
    if (thread == 0B) goto <D.19569>; else goto <D.19570>;
    <D.19569>:
    thread = mono_thread_internal_current ();
    <D.19570>:
    leave = mono_thread_test_state (thread, 129);
    if (leave != 0) goto <D.19571>; else goto <D.19572>;
    <D.19571>:
    monoeg_g_free (pfds);
    D.19573 = 0;
    return D.19573;
    <D.19572>:
    mono_thread_interruption_checkpoint ();
    D.19556 = __errno_location ();
    *D.19556 = 4;
  }
  <D.19568>:
  <D.19565>:
  if (ret == -1) goto <D.19574>; else goto <D.18811>;
  <D.19574>:
  D.19556 = __errno_location ();
  D.19566 = *D.19556;
  if (D.19566 == 4) goto <D.18810>; else goto <D.18811>;
  <D.18811>:
  if (ret == -1) goto <D.19575>; else goto <D.19576>;
  <D.19575>:
  D.19556 = __errno_location ();
  D.19566 = *D.19556;
  D.19577 = (unsigned int) D.19566;
  D.19578 = errno_to_WSA (D.19577, &__func__);
  D.19579 = (int) D.19578;
  *error = D.19579;
  monoeg_g_free (pfds);
  D.19573 = 0;
  return D.19573;
  <D.19576>:
  monoeg_g_free (pfds);
  if (ret == 0) goto <D.19580>; else goto <D.19581>;
  <D.19580>:
  D.19573 = 0;
  return D.19573;
  <D.19581>:
  D.19573 = 1;
  return D.19573;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Connect_internal (SOCKET sock, struct MonoObject * sockaddr, gint32 * error)
{
  int D.19583;
  unsigned int sa_size.20;
  int D.19589;
  struct sockaddr * sa;
  socklen_t sa_size;
  int ret;

  try
    {
      *error = 0;
      sa = create_sockaddr_from_object (sockaddr, &sa_size, error);
      D.19583 = *error;
      if (D.19583 != 0) goto <D.19584>; else goto <D.19585>;
      <D.19584>:
      return;
      <D.19585>:
      sa_size.20 = sa_size;
      ret = _wapi_connect (sock, sa, sa_size.20);
      if (ret == -1) goto <D.19587>; else goto <D.19588>;
      <D.19587>:
      D.19589 = WSAGetLastError ();
      *error = D.19589;
      <D.19588>:
      monoeg_g_free (sa);
    }
  finally
    {
      sa_size = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Disconnect_internal (SOCKET sock, MonoBoolean reuse, gint32 * error)
{
  gboolean (*<T1b8b>) (guint32, struct WapiOverlapped *, guint32, WapiTransmitFileFlags) _wapi_disconnectex.21;
  gboolean (*<T1b92>) (guint32, void *, guint32, guint32, struct WapiOverlapped *, struct WapiTransmitFileBuffers *, WapiTransmitFileFlags) _wapi_transmitfile.22;
  int D.19609;
  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.19595>; else goto <D.19596>;
      <D.19595>:
      _wapi_disconnectex = 0B;
      ret = WSAIoctl (sock, -939524090, &trans_guid, 16, &_wapi_transmitfile, 8, &output_bytes, 0B, 0B);
      if (ret != 0) goto <D.19597>; else goto <D.19598>;
      <D.19597>:
      _wapi_transmitfile = 0B;
      <D.19598>:
      <D.19596>:
      _wapi_disconnectex.21 = _wapi_disconnectex;
      if (_wapi_disconnectex.21 != 0B) goto <D.19600>; else goto <D.19601>;
      <D.19600>:
      _wapi_disconnectex.21 = _wapi_disconnectex;
      bret = _wapi_disconnectex.21 (sock, 0B, 2, 0);
      goto <D.19602>;
      <D.19601>:
      _wapi_transmitfile.22 = _wapi_transmitfile;
      if (_wapi_transmitfile.22 != 0B) goto <D.19604>; else goto <D.19605>;
      <D.19604>:
      _wapi_transmitfile.22 = _wapi_transmitfile;
      bret = _wapi_transmitfile.22 (sock, 0B, 0, 0, 0B, 0B, 3);
      goto <D.19606>;
      <D.19605>:
      *error = 50;
      return;
      <D.19606>:
      <D.19602>:
      if (bret == 0) goto <D.19607>; else goto <D.19608>;
      <D.19607>:
      D.19609 = WSAGetLastError ();
      *error = D.19609;
      <D.19608>:
    }
  finally
    {
      output_bytes = {CLOBBER};
      disco_guid = {CLOBBER};
      trans_guid = {CLOBBER};
      _wapi_disconnectex = {CLOBBER};
      _wapi_transmitfile = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
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.19613;
  int D.19614;
  gint32 D.19617;
  long unsigned int D.19618;
  long unsigned int D.19621;
  int D.19624;
  int ret;
  guchar * buf;
  gint32 alen;
  int recvflags;

  recvflags = 0;
  *error = 0;
  D.19613 = mono_array_length (buffer);
  alen = (gint32) D.19613;
  D.19614 = alen - count;
  if (D.19614 < offset) goto <D.19615>; else goto <D.19616>;
  <D.19615>:
  D.19617 = 0;
  return D.19617;
  <D.19616>:
  D.19618 = (long unsigned int) offset;
  buf = mono_array_addr_with_size (buffer, 1, D.19618);
  recvflags = convert_socketflags (flags);
  if (recvflags == -1) goto <D.19619>; else goto <D.19620>;
  <D.19619>:
  *error = 10045;
  D.19617 = 0;
  return D.19617;
  <D.19620>:
  D.19621 = (long unsigned int) count;
  ret = _wapi_recv (sock, buf, D.19621, recvflags);
  if (ret == -1) goto <D.19622>; else goto <D.19623>;
  <D.19622>:
  D.19624 = WSAGetLastError ();
  *error = D.19624;
  D.19617 = 0;
  return D.19617;
  <D.19623>:
  D.19617 = ret;
  return D.19617;
}


convert_socketflags (gint32 sflags)
{
  gint32 D.19628;
  int D.19629;
  int D.19632;
  int D.19635;
  int D.19638;
  int D.19641;
  gint32 flags;

  flags = 0;
  if (sflags == 0) goto <D.19626>; else goto <D.19627>;
  <D.19626>:
  D.19628 = 0;
  return D.19628;
  <D.19627>:
  D.19629 = sflags & -32792;
  if (D.19629 != 0) goto <D.19630>; else goto <D.19631>;
  <D.19630>:
  D.19628 = -1;
  return D.19628;
  <D.19631>:
  D.19632 = sflags & 1;
  if (D.19632 != 0) goto <D.19633>; else goto <D.19634>;
  <D.19633>:
  flags = flags | 1;
  <D.19634>:
  D.19635 = sflags & 2;
  if (D.19635 != 0) goto <D.19636>; else goto <D.19637>;
  <D.19636>:
  flags = flags | 2;
  <D.19637>:
  D.19638 = sflags & 4;
  if (D.19638 != 0) goto <D.19639>; else goto <D.19640>;
  <D.19639>:
  flags = flags | 4;
  <D.19640>:
  D.19641 = sflags & 32768;
  if (D.19641 != 0) goto <D.19642>; else goto <D.19643>;
  <D.19642>:
  flags = flags | 32768;
  <D.19643>:
  D.19628 = flags;
  return D.19628;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Receive_array_internal (SOCKET sock, struct MonoArray * buffers, gint32 flags, gint32 * error)
{
  long unsigned int D.19645;
  int D.19646;
  unsigned int recvflags.23;
  unsigned int recvflags.24;
  gint32 D.19651;
  unsigned int count.25;
  int D.19655;
  unsigned int recv.26;
  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.19645 = mono_array_length (buffers);
      count = (int) D.19645;
      D.19646 = convert_socketflags (flags);
      recvflags.23 = (unsigned int) D.19646;
      recvflags = recvflags.23;
      recvflags.24 = recvflags;
      if (recvflags.24 == 4294967295) goto <D.19649>; else goto <D.19650>;
      <D.19649>:
      *error = 10045;
      D.19651 = 0;
      return D.19651;
      <D.19650>:
      count.25 = (unsigned int) count;
      ret = WSARecv (sock, wsabufs, count.25, &recv, &recvflags, 0B, 0B);
      if (ret == -1) goto <D.19653>; else goto <D.19654>;
      <D.19653>:
      D.19655 = WSAGetLastError ();
      *error = D.19655;
      D.19651 = 0;
      return D.19651;
      <D.19654>:
      recv.26 = recv;
      D.19651 = (gint32) recv.26;
      return D.19651;
    }
  finally
    {
      recv = {CLOBBER};
      recvflags = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
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.19659;
  int D.19660;
  gint32 D.19663;
  struct MonoObject * D.19664;
  int D.19665;
  long unsigned int D.19668;
  long unsigned int D.19671;
  int D.19674;
  unsigned int sa_size.27;
  int sa_size.28;
  struct MonoObject * D.19679;
  int ret;
  guchar * buf;
  gint32 alen;
  int recvflags;
  struct sockaddr * sa;
  socklen_t sa_size;

  try
    {
      recvflags = 0;
      *error = 0;
      D.19659 = mono_array_length (buffer);
      alen = (gint32) D.19659;
      D.19660 = alen - count;
      if (D.19660 < offset) goto <D.19661>; else goto <D.19662>;
      <D.19661>:
      D.19663 = 0;
      return D.19663;
      <D.19662>:
      D.19664 = *sockaddr;
      sa = create_sockaddr_from_object (D.19664, &sa_size, error);
      D.19665 = *error;
      if (D.19665 != 0) goto <D.19666>; else goto <D.19667>;
      <D.19666>:
      D.19663 = 0;
      return D.19663;
      <D.19667>:
      D.19668 = (long unsigned int) offset;
      buf = mono_array_addr_with_size (buffer, 1, D.19668);
      recvflags = convert_socketflags (flags);
      if (recvflags == -1) goto <D.19669>; else goto <D.19670>;
      <D.19669>:
      *error = 10045;
      D.19663 = 0;
      return D.19663;
      <D.19670>:
      D.19671 = (long unsigned int) count;
      ret = _wapi_recvfrom (sock, buf, D.19671, recvflags, sa, &sa_size);
      if (ret == -1) goto <D.19672>; else goto <D.19673>;
      <D.19672>:
      monoeg_g_free (sa);
      D.19674 = WSAGetLastError ();
      *error = D.19674;
      D.19663 = 0;
      return D.19663;
      <D.19673>:
      sa_size.27 = sa_size;
      if (sa_size.27 != 0) goto <D.19676>; else goto <D.19677>;
      <D.19676>:
      sa_size.27 = sa_size;
      sa_size.28 = (int) sa_size.27;
      D.19679 = create_object_from_sockaddr (sa, sa_size.28, error);
      *sockaddr = D.19679;
      goto <D.19680>;
      <D.19677>:
      *sockaddr = 0B;
      <D.19680>:
      monoeg_g_free (sa);
      D.19663 = ret;
      return D.19663;
    }
  finally
    {
      sa_size = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
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.19683;
  int D.19684;
  gint32 D.19687;
  long unsigned int D.19688;
  long unsigned int D.19691;
  int D.19694;
  int ret;
  guchar * buf;
  gint32 alen;
  int sendflags;

  sendflags = 0;
  *error = 0;
  D.19683 = mono_array_length (buffer);
  alen = (gint32) D.19683;
  D.19684 = alen - count;
  if (D.19684 < offset) goto <D.19685>; else goto <D.19686>;
  <D.19685>:
  D.19687 = 0;
  return D.19687;
  <D.19686>:
  D.19688 = (long unsigned int) offset;
  buf = mono_array_addr_with_size (buffer, 1, D.19688);
  sendflags = convert_socketflags (flags);
  if (sendflags == -1) goto <D.19689>; else goto <D.19690>;
  <D.19689>:
  *error = 10045;
  D.19687 = 0;
  return D.19687;
  <D.19690>:
  D.19691 = (long unsigned int) count;
  ret = _wapi_send (sock, buf, D.19691, sendflags);
  if (ret == -1) goto <D.19692>; else goto <D.19693>;
  <D.19692>:
  D.19694 = WSAGetLastError ();
  *error = D.19694;
  D.19687 = 0;
  return D.19687;
  <D.19693>:
  D.19687 = ret;
  return D.19687;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Send_array_internal (SOCKET sock, struct MonoArray * buffers, gint32 flags, gint32 * error)
{
  long unsigned int D.19696;
  int D.19697;
  gint32 D.19700;
  unsigned int count.29;
  int D.19704;
  unsigned int sent.30;
  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.19696 = mono_array_length (buffers);
      count = (int) D.19696;
      D.19697 = convert_socketflags (flags);
      sendflags = (DWORD) D.19697;
      if (sendflags == 4294967295) goto <D.19698>; else goto <D.19699>;
      <D.19698>:
      *error = 10045;
      D.19700 = 0;
      return D.19700;
      <D.19699>:
      count.29 = (unsigned int) count;
      ret = WSASend (sock, wsabufs, count.29, &sent, sendflags, 0B, 0B);
      if (ret == -1) goto <D.19702>; else goto <D.19703>;
      <D.19702>:
      D.19704 = WSAGetLastError ();
      *error = D.19704;
      D.19700 = 0;
      return D.19700;
      <D.19703>:
      sent.30 = sent;
      D.19700 = (gint32) sent.30;
      return D.19700;
    }
  finally
    {
      sent = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
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.19708;
  int D.19709;
  gint32 D.19712;
  int D.19713;
  long unsigned int D.19716;
  long unsigned int D.19719;
  unsigned int sa_size.31;
  int D.19723;
  int ret;
  guchar * buf;
  gint32 alen;
  int sendflags;
  struct sockaddr * sa;
  socklen_t sa_size;

  try
    {
      sendflags = 0;
      *error = 0;
      D.19708 = mono_array_length (buffer);
      alen = (gint32) D.19708;
      D.19709 = alen - count;
      if (D.19709 < offset) goto <D.19710>; else goto <D.19711>;
      <D.19710>:
      D.19712 = 0;
      return D.19712;
      <D.19711>:
      sa = create_sockaddr_from_object (sockaddr, &sa_size, error);
      D.19713 = *error;
      if (D.19713 != 0) goto <D.19714>; else goto <D.19715>;
      <D.19714>:
      D.19712 = 0;
      return D.19712;
      <D.19715>:
      D.19716 = (long unsigned int) offset;
      buf = mono_array_addr_with_size (buffer, 1, D.19716);
      sendflags = convert_socketflags (flags);
      if (sendflags == -1) goto <D.19717>; else goto <D.19718>;
      <D.19717>:
      *error = 10045;
      D.19712 = 0;
      return D.19712;
      <D.19718>:
      D.19719 = (long unsigned int) count;
      sa_size.31 = sa_size;
      ret = _wapi_sendto (sock, buf, D.19719, sendflags, sa, sa_size.31);
      if (ret == -1) goto <D.19721>; else goto <D.19722>;
      <D.19721>:
      D.19723 = WSAGetLastError ();
      *error = D.19723;
      <D.19722>:
      monoeg_g_free (sa);
      D.19712 = ret;
      return D.19712;
    }
  finally
    {
      sa_size = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Select_internal (struct MonoArray * * sockets, gint32 timeout, gint32 * error)
{
  struct MonoArray * D.19726;
  long unsigned int D.19727;
  long unsigned int D.19728;
  long unsigned int D.19729;
  long unsigned int D.19730;
  char * D.19731;
  long unsigned int D.19736;
  long unsigned int D.19737;
  struct mono_pollfd * D.19738;
  unsigned int D.19739;
  int D.19740;
  short int iftmp.32;
  short int iftmp.33;
  int iftmp.34;
  unsigned int nfds.35;
  int * D.19758;
  long int D.19759;
  unsigned int D.19760;
  unsigned int D.19761;
  unsigned int D.19762;
  int D.19763;
  int D.19768;
  unsigned int D.19778;
  unsigned int D.19779;
  int D.19780;
  struct MonoVTable * D.19783;
  long unsigned int D.19784;
  long unsigned int socks_size.36;
  struct MonoDomain * D.19786;
  char * D.19787;
  int D.19790;
  long unsigned int D.19791;
  long unsigned int D.19792;
  short int D.19793;
  int D.19799;
  int D.19800;
  int idx.37;
  long unsigned int D.19803;
  int D.19807;
  int idx.38;
  long unsigned int D.19810;
  int D.19811;
  int idx.39;
  long unsigned int D.19815;
  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.19726 = *sockets;
      D.19727 = mono_array_length (D.19726);
      count = (int) D.19727;
      nfds = count + -3;
      D.19728 = (long unsigned int) nfds;
      D.19729 = D.19728 * 8;
      pfds = monoeg_malloc0 (D.19729);
      idx = 0;
      mode = idx;
      i = 0;
      goto <D.18934>;
      <D.18933>:
      D.19726 = *sockets;
      D.19730 = (long unsigned int) i;
      D.19731 = mono_array_addr_with_size (D.19726, 8, D.19730);
      obj = MEM[(struct MonoObject * *)D.19731];
      if (obj == 0B) goto <D.19732>; else goto <D.19733>;
      <D.19732>:
      mode = mode + 1;
      // predicted unlikely by continue predictor.
      goto <D.18932>;
      <D.19733>:
      if (idx >= nfds) goto <D.19734>; else goto <D.19735>;
      <D.19734>:
      monoeg_g_free (pfds);
      *error = 10014;
      return;
      <D.19735>:
      D.19736 = (long unsigned int) idx;
      D.19737 = D.19736 * 8;
      D.19738 = pfds + D.19737;
      D.19739 = Socket_to_SOCKET (obj);
      D.19740 = (int) D.19739;
      D.19738->fd = D.19740;
      D.19736 = (long unsigned int) idx;
      D.19737 = D.19736 * 8;
      D.19738 = pfds + D.19737;
      if (mode != 0) goto <D.19742>; else goto <D.19743>;
      <D.19742>:
      if (mode == 1) goto <D.19745>; else goto <D.19746>;
      <D.19745>:
      iftmp.33 = 4;
      goto <D.19747>;
      <D.19746>:
      iftmp.33 = 56;
      <D.19747>:
      iftmp.32 = iftmp.33;
      goto <D.19748>;
      <D.19743>:
      iftmp.32 = 1;
      <D.19748>:
      D.19738->events = iftmp.32;
      idx = idx + 1;
      <D.18932>:
      i = i + 1;
      <D.18934>:
      if (i < count) goto <D.18933>; else goto <D.18935>;
      <D.18935>:
      if (timeout >= 0) goto <D.19750>; else goto <D.19751>;
      <D.19750>:
      iftmp.34 = timeout / 1000;
      goto <D.19752>;
      <D.19751>:
      iftmp.34 = -1;
      <D.19752>:
      timeout = iftmp.34;
      start = time (0B);
      <D.18939>:
      *error = 0;
      nfds.35 = (unsigned int) nfds;
      ret = mono_poll (pfds, nfds.35, timeout);
      if (timeout > 0) goto <D.19754>; else goto <D.19755>;
      <D.19754>:
      if (ret < 0) goto <D.19756>; else goto <D.19757>;
      <D.19756>:
      {
        int err;
        int sec;

        D.19758 = __errno_location ();
        err = *D.19758;
        D.19759 = time (0B);
        D.19760 = (unsigned int) D.19759;
        D.19761 = (unsigned int) start;
        D.19762 = D.19760 - D.19761;
        sec = (int) D.19762;
        D.19763 = sec * -1000;
        timeout = D.19763 + timeout;
        if (timeout < 0) goto <D.19764>; else goto <D.19765>;
        <D.19764>:
        timeout = 0;
        <D.19765>:
        D.19758 = __errno_location ();
        *D.19758 = err;
      }
      <D.19757>:
      <D.19755>:
      if (ret == -1) goto <D.19766>; else goto <D.19767>;
      <D.19766>:
      D.19758 = __errno_location ();
      D.19768 = *D.19758;
      if (D.19768 == 4) goto <D.19769>; else goto <D.19770>;
      <D.19769>:
      {
        int leave;

        leave = 0;
        if (thread == 0B) goto <D.19771>; else goto <D.19772>;
        <D.19771>:
        thread = mono_thread_internal_current ();
        <D.19772>:
        leave = mono_thread_test_state (thread, 129);
        if (leave != 0) goto <D.19773>; else goto <D.19774>;
        <D.19773>:
        monoeg_g_free (pfds);
        *sockets = 0B;
        return;
        <D.19774>:
        mono_thread_interruption_checkpoint ();
        D.19758 = __errno_location ();
        *D.19758 = 4;
      }
      <D.19770>:
      <D.19767>:
      if (ret == -1) goto <D.19775>; else goto <D.18940>;
      <D.19775>:
      D.19758 = __errno_location ();
      D.19768 = *D.19758;
      if (D.19768 == 4) goto <D.18939>; else goto <D.18940>;
      <D.18940>:
      if (ret == -1) goto <D.19776>; else goto <D.19777>;
      <D.19776>:
      D.19758 = __errno_location ();
      D.19768 = *D.19758;
      D.19778 = (unsigned int) D.19768;
      D.19779 = errno_to_WSA (D.19778, &__func__);
      D.19780 = (int) D.19779;
      *error = D.19780;
      monoeg_g_free (pfds);
      return;
      <D.19777>:
      if (ret == 0) goto <D.19781>; else goto <D.19782>;
      <D.19781>:
      monoeg_g_free (pfds);
      *sockets = 0B;
      return;
      <D.19782>:
      D.19726 = *sockets;
      D.19783 = MEM[(struct MonoObject *)D.19726].vtable;
      sock_arr_class = D.19783->klass;
      D.19784 = (long unsigned int) ret;
      socks_size.36 = D.19784 + 3;
      socks_size = socks_size.36;
      D.19786 = mono_domain_get ();
      socks = mono_array_new_full (D.19786, sock_arr_class, &socks_size, 0B);
      idx = 0;
      mode = idx;
      i = 0;
      goto <D.18948>;
      <D.18947>:
      {
        struct mono_pollfd * pfd;

        D.19726 = *sockets;
        D.19730 = (long unsigned int) i;
        D.19787 = mono_array_addr_with_size (D.19726, 8, D.19730);
        obj = MEM[(struct MonoObject * *)D.19787];
        if (obj == 0B) goto <D.19788>; else goto <D.19789>;
        <D.19788>:
        mode = mode + 1;
        idx = idx + 1;
        // predicted unlikely by continue predictor.
        goto <D.18943>;
        <D.19789>:
        D.19790 = i - mode;
        D.19791 = (long unsigned int) D.19790;
        D.19792 = D.19791 * 8;
        pfd = pfds + D.19792;
        D.19793 = pfd->revents;
        if (D.19793 == 0) goto <D.19794>; else goto <D.19795>;
        <D.19794>:
        // predicted unlikely by continue predictor.
        goto <D.18943>;
        <D.19795>:
        ret = ret + -1;
        if (mode == 0) goto <D.19798>; else goto <D.19796>;
        <D.19798>:
        D.19793 = pfd->revents;
        D.19799 = (int) D.19793;
        D.19800 = D.19799 & 57;
        if (D.19800 != 0) goto <D.19801>; else goto <D.19796>;
        <D.19801>:
        {
          void * * __p;

          idx.37 = idx;
          idx = idx.37 + 1;
          D.19803 = (long unsigned int) idx.37;
          __p = mono_array_addr_with_size (socks, 8, D.19803);
          mono_gc_wbarrier_set_arrayref (socks, __p, obj);
        }
        goto <D.19797>;
        <D.19796>:
        if (mode == 1) goto <D.19806>; else goto <D.19804>;
        <D.19806>:
        D.19793 = pfd->revents;
        D.19799 = (int) D.19793;
        D.19807 = D.19799 & 60;
        if (D.19807 != 0) goto <D.19808>; else goto <D.19804>;
        <D.19808>:
        {
          void * * __p;

          idx.38 = idx;
          idx = idx.38 + 1;
          D.19810 = (long unsigned int) idx.38;
          __p = mono_array_addr_with_size (socks, 8, D.19810);
          mono_gc_wbarrier_set_arrayref (socks, __p, obj);
        }
        goto <D.19805>;
        <D.19804>:
        D.19793 = pfd->revents;
        D.19799 = (int) D.19793;
        D.19811 = D.19799 & 56;
        if (D.19811 != 0) goto <D.19812>; else goto <D.19813>;
        <D.19812>:
        {
          void * * __p;

          idx.39 = idx;
          idx = idx.39 + 1;
          D.19815 = (long unsigned int) idx.39;
          __p = mono_array_addr_with_size (socks, 8, D.19815);
          mono_gc_wbarrier_set_arrayref (socks, __p, obj);
        }
        <D.19813>:
        <D.19805>:
        <D.19797>:
      }
      <D.18943>:
      i = i + 1;
      <D.18948>:
      if (i < count) goto <D.19816>; else goto <D.18949>;
      <D.19816>:
      if (ret > 0) goto <D.18947>; else goto <D.18949>;
      <D.18949>:
      *sockets = socks;
      monoeg_g_free (pfds);
    }
  finally
    {
      socks_size = {CLOBBER};
    }
}


Socket_to_SOCKET (struct MonoObject * sockobj)
{
  struct MonoVTable * D.19820;
  struct MonoClass * D.19821;
  int D.19822;
  sizetype D.19823;
  void * * D.19824;
  void * D.19825;
  long int D.19826;
  SOCKET D.19827;
  SOCKET sock;
  struct MonoClassField * field;

  D.19820 = sockobj->vtable;
  D.19821 = D.19820->klass;
  field = mono_class_get_field_from_name (D.19821, "socket");
  D.19822 = field->offset;
  D.19823 = (sizetype) D.19822;
  D.19824 = sockobj + D.19823;
  D.19825 = *D.19824;
  D.19826 = (long int) D.19825;
  sock = (SOCKET) D.19826;
  D.19827 = sock;
  return D.19827;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (SOCKET sock, gint32 level, gint32 name, struct MonoObject * * obj_val, gint32 * error)
{
  <unnamed type> level.40;
  struct MonoObject * D.19838;
  int system_level.41;
  int system_name.42;
  int D.19843;
  struct MonoImage * D.19844;
  int D.19845;
  sizetype D.19846;
  guint8 * D.19847;
  int D.19848;
  unsigned char D.19849;
  guint32 * D.19850;
  int D.19851;
  unsigned int D.19852;
  _Bool D.19853;
  int D.19854;
  int time_ms.43;
  struct MonoImage * mono_posix_image.44;
  struct MonoImage * mono_posix_image.45;
  struct MonoImage * mono_posix_image.46;
  int D.19865;
  unsigned int D.19866;
  int D.19867;
  unsigned int D.19868;
  int D.19869;
  int val.47;
  _Bool D.19875;
  int val.48;
  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.19831>; else goto <D.19829>;
      <D.19831>:
      if (name == -5) goto <D.19832>; else goto <D.19829>;
      <D.19832>:
      system_level = 1;
      system_name = 2;
      ret = 0;
      goto <D.19830>;
      <D.19829>:
      level.40 = (<unnamed type>) level;
      ret = convert_sockopt_level_and_name (level.40, name, &system_level, &system_name);
      <D.19830>:
      if (ret == -1) goto <D.19834>; else goto <D.19835>;
      <D.19834>:
      *error = 10042;
      return;
      <D.19835>:
      if (ret == -2) goto <D.19836>; else goto <D.19837>;
      <D.19836>:
      D.19838 = int_to_object (domain, 0);
      *obj_val = D.19838;
      return;
      <D.19837>:
      switch (name) <default: <D.18982>, case -129: <D.18977>, case 128: <D.18976>, case 4101: <D.18979>, case 4102: <D.18980>, case 10001: <D.18981>>
      <D.18976>:
      <D.18977>:
      system_level.41 = system_level;
      system_name.42 = system_name;
      ret = _wapi_getsockopt (sock, system_level.41, system_name.42, &linger, &lingersize);
      goto <D.18978>;
      <D.18979>:
      <D.18980>:
      system_level.41 = system_level;
      system_name.42 = system_name;
      ret = _wapi_getsockopt (sock, system_level.41, system_name.42, &time_ms, &time_ms_size);
      goto <D.18978>;
      <D.18981>:
      system_level.41 = system_level;
      system_name.42 = system_name;
      ret = _wapi_getsockopt (sock, system_level.41, system_name.42, &cred, &credsize);
      goto <D.18978>;
      <D.18982>:
      system_level.41 = system_level;
      system_name.42 = system_name;
      ret = _wapi_getsockopt (sock, system_level.41, system_name.42, &val, &valsize);
      <D.18978>:
      if (ret == -1) goto <D.19841>; else goto <D.19842>;
      <D.19841>:
      D.19843 = WSAGetLastError ();
      *error = D.19843;
      return;
      <D.19842>:
      switch (name) <default: <D.18992>, case -129: <D.18985>, case 128: <D.18983>, case 4101: <D.18986>, case 4102: <D.18987>, case 10001: <D.18988>>
      <D.18983>:
      D.19844 = get_socket_assembly ();
      obj_class = mono_class_from_name (D.19844, "System.Net.Sockets", "LingerOption");
      obj = mono_object_new (domain, obj_class);
      field = mono_class_get_field_from_name (obj_class, "enabled");
      D.19845 = field->offset;
      D.19846 = (sizetype) D.19845;
      D.19847 = obj + D.19846;
      D.19848 = linger.l_onoff;
      D.19849 = (unsigned char) D.19848;
      *D.19847 = D.19849;
      field = mono_class_get_field_from_name (obj_class, "seconds");
      D.19845 = field->offset;
      D.19846 = (sizetype) D.19845;
      D.19850 = obj + D.19846;
      D.19851 = linger.l_linger;
      D.19852 = (unsigned int) D.19851;
      *D.19850 = D.19852;
      goto <D.18984>;
      <D.18985>:
      D.19848 = linger.l_onoff;
      D.19853 = D.19848 == 0;
      D.19854 = (int) D.19853;
      obj = int_to_object (domain, D.19854);
      goto <D.18984>;
      <D.18986>:
      <D.18987>:
      time_ms.43 = time_ms;
      obj = int_to_object (domain, time_ms.43);
      goto <D.18984>;
      <D.18988>:
      {
        static struct MonoImage * mono_posix_image = 0B;
        struct MonoPeerCredData * cred_data;

        mono_posix_image.44 = mono_posix_image;
        if (mono_posix_image.44 == 0B) goto <D.19857>; else goto <D.19858>;
        <D.19857>:
        mono_posix_image.45 = mono_image_loaded ("Mono.Posix");
        mono_posix_image = mono_posix_image.45;
        mono_posix_image.44 = mono_posix_image;
        if (mono_posix_image.44 == 0B) goto <D.19860>; else goto <D.19861>;
        <D.19860>:
        {
          struct MonoAssembly * sa;

          sa = mono_assembly_open ("Mono.Posix.dll", 0B);
          if (sa == 0B) goto <D.19862>; else goto <D.19863>;
          <D.19862>:
          *error = 10042;
          return;
          <D.19863>:
          mono_posix_image.46 = mono_assembly_get_image (sa);
          mono_posix_image = mono_posix_image.46;
        }
        <D.19861>:
        <D.19858>:
        mono_posix_image.44 = mono_posix_image;
        obj_class = mono_class_from_name (mono_posix_image.44, "Mono.Posix", "PeerCredData");
        obj = mono_object_new (domain, obj_class);
        cred_data = obj;
        D.19865 = cred.pid;
        cred_data->pid = D.19865;
        D.19866 = cred.uid;
        D.19867 = (int) D.19866;
        cred_data->uid = D.19867;
        D.19868 = cred.gid;
        D.19869 = (int) D.19868;
        cred_data->gid = D.19869;
        goto <D.18984>;
      }
      <D.18992>:
      if (level == 65535) goto <D.19870>; else goto <D.19871>;
      <D.19870>:
      if (name == -5) goto <D.19872>; else goto <D.19873>;
      <D.19872>:
      val.47 = val;
      D.19875 = val.47 == 0;
      val.48 = (int) D.19875;
      val = val.48;
      <D.19873>:
      <D.19871>:
      val.47 = val;
      obj = int_to_object (domain, val.47);
      <D.18984>:
      *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.19880;
  int cached.49;
  int iftmp.50;
  int proto.51;

  switch (mono_level) <default: <D.18620>, case 0: <D.18572>, case 6: <D.18609>, case 17: <D.18616>, case 41: <D.18590>, case 65535: <D.18547>>
  <D.18547>:
  *system_level = 1;
  switch (mono_name) <default: <D.18570>, case -129: <D.18548>, case -5: <D.18567>, case 1: <D.18550>, case 2: <D.18551>, case 4: <D.18552>, case 8: <D.18553>, case 16: <D.18554>, case 32: <D.18555>, case 64: <D.18568>, case 128: <D.18556>, case 256: <D.18557>, case 4097: <D.18558>, case 4098: <D.18559>, case 4099: <D.18560>, case 4100: <D.18561>, case 4101: <D.18562>, case 4102: <D.18563>, case 4103: <D.18564>, case 4104: <D.18565>, case 10001: <D.18566>, case 2147483647: <D.18569>>
  <D.18548>:
  *system_name = 13;
  goto <D.18549>;
  <D.18550>:
  *system_name = 1;
  goto <D.18549>;
  <D.18551>:
  *system_name = 30;
  goto <D.18549>;
  <D.18552>:
  *system_name = 2;
  goto <D.18549>;
  <D.18553>:
  *system_name = 9;
  goto <D.18549>;
  <D.18554>:
  *system_name = 5;
  goto <D.18549>;
  <D.18555>:
  *system_name = 6;
  goto <D.18549>;
  <D.18556>:
  *system_name = 13;
  goto <D.18549>;
  <D.18557>:
  *system_name = 10;
  goto <D.18549>;
  <D.18558>:
  *system_name = 7;
  goto <D.18549>;
  <D.18559>:
  *system_name = 8;
  goto <D.18549>;
  <D.18560>:
  *system_name = 19;
  goto <D.18549>;
  <D.18561>:
  *system_name = 18;
  goto <D.18549>;
  <D.18562>:
  *system_name = 21;
  goto <D.18549>;
  <D.18563>:
  *system_name = 20;
  goto <D.18549>;
  <D.18564>:
  *system_name = 4;
  goto <D.18549>;
  <D.18565>:
  *system_name = 3;
  goto <D.18549>;
  <D.18566>:
  *system_name = 17;
  goto <D.18549>;
  <D.18567>:
  <D.18568>:
  <D.18569>:
  *system_name = 128;
  goto <D.18549>;
  <D.18570>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at Socket level", mono_name);
  D.19880 = -1;
  return D.19880;
  <D.18549>:
  goto <D.18571>;
  <D.18572>:
  *system_level = 0;
  switch (mono_name) <default: <D.18589>, case 1: <D.18573>, case 2: <D.18575>, case 3: <D.18576>, case 4: <D.18577>, case 9: <D.18578>, case 10: <D.18579>, case 11: <D.18580>, case 12: <D.18581>, case 13: <D.18582>, case 14: <D.18584>, case 15: <D.18585>, case 16: <D.18586>, case 17: <D.18587>, case 18: <D.18588>, case 19: <D.18583>>
  <D.18573>:
  *system_name = 4;
  goto <D.18574>;
  <D.18575>:
  *system_name = 3;
  goto <D.18574>;
  <D.18576>:
  *system_name = 1;
  goto <D.18574>;
  <D.18577>:
  *system_name = 2;
  goto <D.18574>;
  <D.18578>:
  *system_name = 32;
  goto <D.18574>;
  <D.18579>:
  *system_name = 33;
  goto <D.18574>;
  <D.18580>:
  *system_name = 34;
  goto <D.18574>;
  <D.18581>:
  *system_name = 35;
  goto <D.18574>;
  <D.18582>:
  *system_name = 36;
  goto <D.18574>;
  <D.18583>:
  *system_name = 8;
  goto <D.18574>;
  <D.18584>:
  *system_name = 10;
  goto <D.18574>;
  <D.18585>:
  <D.18586>:
  <D.18587>:
  <D.18588>:
  <D.18589>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at IP level", mono_name);
  D.19880 = -1;
  return D.19880;
  <D.18574>:
  goto <D.18571>;
  <D.18590>:
  *system_level = 41;
  switch (mono_name) <default: <D.18608>, case 1: <D.18601>, case 2: <D.18600>, case 3: <D.18602>, case 4: <D.18591>, case 9: <D.18594>, case 10: <D.18595>, case 11: <D.18596>, case 12: <D.18597>, case 13: <D.18598>, case 14: <D.18603>, case 15: <D.18604>, case 16: <D.18605>, case 17: <D.18606>, case 18: <D.18607>, case 19: <D.18599>, case 21: <D.18592>>
  <D.18591>:
  <D.18592>:
  *system_name = 16;
  goto <D.18593>;
  <D.18594>:
  *system_name = 17;
  goto <D.18593>;
  <D.18595>:
  *system_name = 18;
  goto <D.18593>;
  <D.18596>:
  *system_name = 19;
  goto <D.18593>;
  <D.18597>:
  *system_name = 20;
  goto <D.18593>;
  <D.18598>:
  *system_name = 21;
  goto <D.18593>;
  <D.18599>:
  *system_name = 50;
  goto <D.18593>;
  <D.18600>:
  <D.18601>:
  <D.18602>:
  <D.18603>:
  <D.18604>:
  <D.18605>:
  <D.18606>:
  <D.18607>:
  <D.18608>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at IPv6 level", mono_name);
  D.19880 = -1;
  return D.19880;
  <D.18593>:
  goto <D.18571>;
  <D.18609>:
  if (1 != 0) goto <D.19881>; else goto <D.19882>;
  <D.19881>:
  {
    static int cached = 0;
    static int proto;

    cached.49 = cached;
    if (cached.49 == 0) goto <D.19884>; else goto <D.19885>;
    <D.19884>:
    {
      struct protoent * pent;

      pent = getprotobyname ("TCP");
      if (pent != 0B) goto <D.19887>; else goto <D.19888>;
      <D.19887>:
      iftmp.50 = pent->p_proto;
      goto <D.19889>;
      <D.19888>:
      iftmp.50 = 6;
      <D.19889>:
      proto = iftmp.50;
      cached = 1;
    }
    <D.19885>:
    proto.51 = proto;
    *system_level = proto.51;
  }
  <D.19882>:
  switch (mono_name) <default: <D.18615>, case 1: <D.18613>>
  <D.18613>:
  *system_name = 1;
  goto <D.18614>;
  <D.18615>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at TCP level", mono_name);
  D.19880 = -1;
  return D.19880;
  <D.18614>:
  goto <D.18571>;
  <D.18616>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionLevel has unsupported value 0x%x", mono_level);
  switch (mono_name) <default: <D.18619>, case 1: <D.18617>, case 20: <D.18618>>
  <D.18617>:
  <D.18618>:
  <D.18619>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionName 0x%x is not supported at UDP level", mono_name);
  D.19880 = -1;
  return D.19880;
  D.19880 = -1;
  return D.19880;
  <D.18620>:
  monoeg_g_log (0B, 16, "System.Net.Sockets.SocketOptionLevel has unknown value 0x%x", mono_level);
  D.19880 = -1;
  return D.19880;
  <D.18571>:
  D.19880 = 0;
  return D.19880;
}


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

  D.19894 = mono_get_int32_class ();
  D.19893 = mono_value_box (domain, D.19894, &val);
  return D.19893;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_GetSocketOption_arr_internal (SOCKET sock, gint32 level, gint32 name, struct MonoArray * * byte_val, gint32 * error)
{
  <unnamed type> level.52;
  struct MonoArray * D.19901;
  long unsigned int D.19902;
  unsigned int valsize.53;
  int system_level.54;
  int system_name.55;
  int D.19908;
  int system_level;
  int system_name;
  int ret;
  guchar * buf;
  socklen_t valsize;

  try
    {
      *error = 0;
      level.52 = (<unnamed type>) level;
      ret = convert_sockopt_level_and_name (level.52, name, &system_level, &system_name);
      if (ret == -1) goto <D.19897>; else goto <D.19898>;
      <D.19897>:
      *error = 10042;
      return;
      <D.19898>:
      if (ret == -2) goto <D.19899>; else goto <D.19900>;
      <D.19899>:
      return;
      <D.19900>:
      D.19901 = *byte_val;
      D.19902 = mono_array_length (D.19901);
      valsize.53 = (unsigned int) D.19902;
      valsize = valsize.53;
      D.19901 = *byte_val;
      buf = mono_array_addr_with_size (D.19901, 1, 0);
      system_level.54 = system_level;
      system_name.55 = system_name;
      ret = _wapi_getsockopt (sock, system_level.54, system_name.55, buf, &valsize);
      if (ret == -1) goto <D.19906>; else goto <D.19907>;
      <D.19906>:
      D.19908 = WSAGetLastError ();
      *error = D.19908;
      <D.19907>:
    }
  finally
    {
      system_level = {CLOBBER};
      system_name = {CLOBBER};
      valsize = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
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.56;
  int int_val.57;
  _Bool D.19918;
  int int_val.58;
  struct MonoVTable * D.19926;
  struct MonoClass * D.19927;
  int D.19928;
  sizetype D.19929;
  guint8 * D.19930;
  unsigned char D.19931;
  int D.19932;
  guint32 * D.19933;
  unsigned int D.19934;
  int D.19935;
  int system_level.59;
  int system_name.60;
  unsigned int valsize.61;
  void * * D.19941;
  guint64 * D.19944;
  long unsigned int D.19945;
  unsigned int D.19946;
  gint32 * D.19954;
  int D.19955;
  long unsigned int D.19959;
  unsigned char D.19962;
  _Bool D.19963;
  int D.19964;
  unsigned int valsize.62;
  unsigned int int_val.63;
  unsigned int D.19969;
  int D.19976;
  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.56 = (<unnamed type>) level;
      ret = convert_sockopt_level_and_name (level.56, name, &system_level, &system_name);
      if (level == 65535) goto <D.19913>; else goto <D.19914>;
      <D.19913>:
      if (name == -5) goto <D.19915>; else goto <D.19916>;
      <D.19915>:
      system_name = 2;
      int_val.57 = int_val;
      D.19918 = int_val.57 == 0;
      int_val.58 = (int) D.19918;
      int_val = int_val.58;
      ret = 0;
      <D.19916>:
      <D.19914>:
      if (ret == -1) goto <D.19920>; else goto <D.19921>;
      <D.19920>:
      *error = 10042;
      return;
      <D.19921>:
      if (ret == -2) goto <D.19922>; else goto <D.19923>;
      <D.19922>:
      return;
      <D.19923>:
      if (obj_val != 0B) goto <D.19924>; else goto <D.19925>;
      <D.19924>:
      {
        struct MonoClassField * field;
        int valsize;

        switch (name) <default: <D.19044>, case 12: <D.19039>, case 13: <D.19040>, case 128: <D.19037>>
        <D.19037>:
        D.19926 = obj_val->vtable;
        D.19927 = D.19926->klass;
        field = mono_class_get_field_from_name (D.19927, "enabled");
        D.19928 = field->offset;
        D.19929 = (sizetype) D.19928;
        D.19930 = obj_val + D.19929;
        D.19931 = *D.19930;
        D.19932 = (int) D.19931;
        linger.l_onoff = D.19932;
        D.19926 = obj_val->vtable;
        D.19927 = D.19926->klass;
        field = mono_class_get_field_from_name (D.19927, "seconds");
        D.19928 = field->offset;
        D.19929 = (sizetype) D.19928;
        D.19933 = obj_val + D.19929;
        D.19934 = *D.19933;
        D.19935 = (int) D.19934;
        linger.l_linger = D.19935;
        valsize = 8;
        system_level.59 = system_level;
        system_name.60 = system_name;
        valsize.61 = (unsigned int) valsize;
        ret = _wapi_setsockopt (sock, system_level.59, system_name.60, &linger, valsize.61);
        goto <D.19038>;
        <D.19039>:
        <D.19040>:
        {
          struct MonoObject * address;

          address = 0B;
          system_level.59 = system_level;
          if (system_level.59 == sol_ipv6) goto <D.19939>; else goto <D.19940>;
          <D.19939>:
          {
            struct ipv6_mreq mreq6;

            try
              {
                D.19926 = obj_val->vtable;
                D.19927 = D.19926->klass;
                field = mono_class_get_field_from_name (D.19927, "group");
                D.19928 = field->offset;
                D.19929 = (sizetype) D.19928;
                D.19941 = obj_val + D.19929;
                address = *D.19941;
                if (address != 0B) goto <D.19942>; else goto <D.19943>;
                <D.19942>:
                mreq6.ipv6mr_multiaddr = ipaddress_to_struct_in6_addr (address);
                <D.19943>:
                D.19926 = obj_val->vtable;
                D.19927 = D.19926->klass;
                field = mono_class_get_field_from_name (D.19927, "ifIndex");
                D.19928 = field->offset;
                D.19929 = (sizetype) D.19928;
                D.19944 = obj_val + D.19929;
                D.19945 = *D.19944;
                D.19946 = (unsigned int) D.19945;
                mreq6.ipv6mr_interface = D.19946;
                system_level.59 = system_level;
                system_name.60 = system_name;
                ret = _wapi_setsockopt (sock, system_level.59, system_name.60, &mreq6, 20);
              }
            finally
              {
                mreq6 = {CLOBBER};
              }
          }
          goto <D.19947>;
          <D.19940>:
          system_level.59 = system_level;
          if (system_level.59 == sol_ip) goto <D.19948>; else goto <D.19949>;
          <D.19948>:
          {
            struct ip_mreqn mreq;

            try
              {
                mreq = {};
                D.19926 = obj_val->vtable;
                D.19927 = D.19926->klass;
                field = mono_class_get_field_from_name (D.19927, "group");
                D.19928 = field->offset;
                D.19929 = (sizetype) D.19928;
                D.19941 = obj_val + D.19929;
                address = *D.19941;
                if (address != 0B) goto <D.19950>; else goto <D.19951>;
                <D.19950>:
                mreq.imr_multiaddr = ipaddress_to_struct_in_addr (address);
                <D.19951>:
                D.19926 = obj_val->vtable;
                D.19927 = D.19926->klass;
                field = mono_class_get_field_from_name (D.19927, "local");
                D.19928 = field->offset;
                D.19929 = (sizetype) D.19928;
                D.19941 = obj_val + D.19929;
                address = *D.19941;
                if (address != 0B) goto <D.19952>; else goto <D.19953>;
                <D.19952>:
                mreq.imr_address = ipaddress_to_struct_in_addr (address);
                <D.19953>:
                D.19926 = obj_val->vtable;
                D.19927 = D.19926->klass;
                field = mono_class_get_field_from_name (D.19927, "iface_index");
                D.19928 = field->offset;
                D.19929 = (sizetype) D.19928;
                D.19954 = obj_val + D.19929;
                D.19955 = *D.19954;
                mreq.imr_ifindex = D.19955;
                system_level.59 = system_level;
                system_name.60 = system_name;
                ret = _wapi_setsockopt (sock, system_level.59, system_name.60, &mreq, 12);
              }
            finally
              {
                mreq = {CLOBBER};
              }
          }
          <D.19949>:
          <D.19947>:
          goto <D.19038>;
        }
        <D.19044>:
        *error = 10022;
        return;
        <D.19038>:
      }
      goto <D.19956>;
      <D.19925>:
      if (byte_val != 0B) goto <D.19957>; else goto <D.19958>;
      <D.19957>:
      {
        int valsize;
        guchar * buf;

        D.19959 = mono_array_length (byte_val);
        valsize = (int) D.19959;
        buf = mono_array_addr_with_size (byte_val, 1, 0);
        switch (name) <default: <D.19049>, case -129: <D.19047>>
        <D.19047>:
        if (valsize == 1) goto <D.19960>; else goto <D.19961>;
        <D.19960>:
        D.19962 = *buf;
        D.19963 = D.19962 == 0;
        D.19964 = (int) D.19963;
        linger.l_onoff = D.19964;
        linger.l_linger = 0;
        system_level.59 = system_level;
        system_name.60 = system_name;
        ret = _wapi_setsockopt (sock, system_level.59, system_name.60, &linger, 8);
        goto <D.19965>;
        <D.19961>:
        *error = 10022;
        <D.19965>:
        goto <D.19048>;
        <D.19049>:
        system_level.59 = system_level;
        system_name.60 = system_name;
        valsize.62 = (unsigned int) valsize;
        ret = _wapi_setsockopt (sock, system_level.59, system_name.60, buf, valsize.62);
        goto <D.19048>;
        <D.19048>:
      }
      goto <D.19967>;
      <D.19958>:
      switch (name) <default: <D.19055>, case -129: <D.19050>, case 9: <D.19052>, case 14: <D.19054>>
      <D.19050>:
      int_val.57 = int_val;
      D.19918 = int_val.57 == 0;
      int_val.58 = (int) D.19918;
      linger.l_onoff = int_val.58;
      linger.l_linger = 0;
      system_level.59 = system_level;
      system_name.60 = system_name;
      ret = _wapi_setsockopt (sock, system_level.59, system_name.60, &linger, 8);
      goto <D.19051>;
      <D.19052>:
      int_val.57 = int_val;
      int_val = int_val.57;
      int_val.57 = int_val;
      int_val.63 = (unsigned int) int_val.57;
      D.19969 = int_val.63 & 4278190080;
      if (D.19969 == 0) goto <D.19970>; else goto <D.19971>;
      <D.19970>:
      {
        struct ip_mreqn mreq;

        try
          {
            mreq = {};
            int_val.57 = int_val;
            mreq.imr_ifindex = int_val.57;
            system_level.59 = system_level;
            system_name.60 = system_name;
            ret = _wapi_setsockopt (sock, system_level.59, system_name.60, &mreq, 12);
            goto <D.19051>;
          }
        finally
          {
            mreq = {CLOBBER};
          }
      }
      <D.19971>:
      int_val.57 = int_val;
      int_val = int_val.57;
      system_level.59 = system_level;
      system_name.60 = system_name;
      ret = _wapi_setsockopt (sock, system_level.59, system_name.60, &int_val, 4);
      goto <D.19051>;
      <D.19054>:
      int_val.57 = int_val;
      if (int_val.57 == 1) goto <D.19972>; else goto <D.19973>;
      <D.19972>:
      int_val = 2;
      <D.19973>:
      <D.19055>:
      system_level.59 = system_level;
      system_name.60 = system_name;
      ret = _wapi_setsockopt (sock, system_level.59, system_name.60, &int_val, 4);
      <D.19051>:
      <D.19967>:
      <D.19956>:
      if (ret == -1) goto <D.19974>; else goto <D.19975>;
      <D.19974>:
      D.19976 = WSAGetLastError ();
      *error = D.19976;
      <D.19975>:
    }
  finally
    {
      linger = {CLOBBER};
      system_level = {CLOBBER};
      system_name = {CLOBBER};
    }
}


ipaddress_to_struct_in6_addr (struct MonoObject * ipaddr)
{
  struct MonoVTable * D.19982;
  struct MonoClass * D.19983;
  int D.19984;
  sizetype D.19985;
  struct MonoArray * * D.19986;
  long unsigned int D.19987;
  char * D.19988;
  short unsigned int D.19989;
  struct in6_addr in6addr;
  struct MonoClassField * field;
  struct MonoArray * data;
  int i;

  try
    {
      D.19982 = ipaddr->vtable;
      D.19983 = D.19982->klass;
      field = mono_class_get_field_from_name (D.19983, "m_Numbers");
      D.19984 = field->offset;
      D.19985 = (sizetype) D.19984;
      D.19986 = ipaddr + D.19985;
      data = *D.19986;
      i = 0;
      goto <D.19018>;
      <D.19017>:
      D.19987 = (long unsigned int) i;
      D.19988 = mono_array_addr_with_size (data, 2, D.19987);
      D.19989 = MEM[(guint16 *)D.19988];
      in6addr.__in6_u.__u6_addr16[i] = D.19989;
      i = i + 1;
      <D.19018>:
      if (i <= 7) goto <D.19017>; else goto <D.19019>;
      <D.19019>:
      <retval> = in6addr;
      return <retval>;
    }
  finally
    {
      in6addr = {CLOBBER};
    }
}


ipaddress_to_struct_in_addr (struct MonoObject * ipaddr)
{
  struct MonoVTable * D.19993;
  struct MonoClass * D.19994;
  int D.19995;
  sizetype D.19996;
  guint64 * D.19997;
  long unsigned int D.19998;
  unsigned int D.19999;
  unsigned int D.20000;
  unsigned int D.20001;
  unsigned int D.20002;
  unsigned int D.20003;
  unsigned int D.20004;
  unsigned int D.20005;
  unsigned int D.20006;
  unsigned int D.20007;
  unsigned int D.20008;
  struct in_addr inaddr;
  struct MonoClassField * field;

  try
    {
      D.19993 = ipaddr->vtable;
      D.19994 = D.19993->klass;
      field = mono_class_get_field_from_name (D.19994, "m_Address");
      D.19995 = field->offset;
      D.19996 = (sizetype) D.19995;
      D.19997 = ipaddr + D.19996;
      D.19998 = *D.19997;
      D.19999 = (unsigned int) D.19998;
      D.20000 = D.19999 << 24;
      D.19995 = field->offset;
      D.19996 = (sizetype) D.19995;
      D.19997 = ipaddr + D.19996;
      D.19998 = *D.19997;
      D.19999 = (unsigned int) D.19998;
      D.20001 = D.19999 >> 8;
      D.20002 = D.20001 & 65280;
      D.20003 = D.20000 | D.20002;
      D.19995 = field->offset;
      D.19996 = (sizetype) D.19995;
      D.19997 = ipaddr + D.19996;
      D.19998 = *D.19997;
      D.19999 = (unsigned int) D.19998;
      D.20004 = D.19999 << 8;
      D.20005 = D.20004 & 16711680;
      D.20006 = D.20003 | D.20005;
      D.19995 = field->offset;
      D.19996 = (sizetype) D.19995;
      D.19997 = ipaddr + D.19996;
      D.19998 = *D.19997;
      D.19999 = (unsigned int) D.19998;
      D.20007 = D.19999 >> 24;
      D.20008 = D.20006 | D.20007;
      inaddr.s_addr = D.20008;
      <retval> = inaddr;
      return <retval>;
    }
  finally
    {
      inaddr = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_Shutdown_internal (SOCKET sock, gint32 how, gint32 * error)
{
  int D.20013;
  int ret;

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


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_WSAIoctl (SOCKET sock, gint32 code, struct MonoArray * input, struct MonoArray * output, gint32 * error)
{
  int D.20016;
  long unsigned int D.20020;
  long unsigned int D.20024;
  int D.20027;
  long int output_bytes.64;
  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 == 21537) goto <D.20014>; else goto <D.20015>;
      <D.20014>:
      D.20016 = -1;
      return D.20016;
      <D.20015>:
      if (input == 0B) goto <D.20017>; else goto <D.20018>;
      <D.20017>:
      i_buffer = 0B;
      i_len = 0;
      goto <D.20019>;
      <D.20018>:
      i_buffer = mono_array_addr_with_size (input, 1, 0);
      D.20020 = mono_array_length (input);
      i_len = (gint) D.20020;
      <D.20019>:
      if (output == 0B) goto <D.20021>; else goto <D.20022>;
      <D.20021>:
      o_buffer = 0B;
      o_len = 0;
      goto <D.20023>;
      <D.20022>:
      o_buffer = mono_array_addr_with_size (output, 1, 0);
      D.20024 = mono_array_length (output);
      o_len = (gint) D.20024;
      <D.20023>:
      ret = WSAIoctl (sock, code, i_buffer, i_len, o_buffer, o_len, &output_bytes, 0B, 0B);
      if (ret == -1) goto <D.20025>; else goto <D.20026>;
      <D.20025>:
      D.20027 = WSAGetLastError ();
      *error = D.20027;
      D.20016 = -1;
      return D.20016;
      <D.20026>:
      output_bytes.64 = output_bytes;
      D.20016 = (int) output_bytes.64;
      return D.20016;
    }
  finally
    {
      output_bytes = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
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.20031;
  int D.20036;
  int D.20039;
  int D.20042;
  int D.20045;
  MonoBoolean D.20048;
  struct addrinfo * info.65;
  int D.20050;
  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.20031 = *hostname;
      if (D.20031 == 0) goto <D.20032>; else goto <D.20033>;
      <D.20032>:
      add_local_ips = 1;
      *h_name = host;
      <D.20033>:
      if (add_local_ips == 0) goto <D.20034>; else goto <D.20035>;
      <D.20034>:
      D.20036 = gethostname (&this_hostname, 256);
      if (D.20036 != -1) goto <D.20037>; else goto <D.20038>;
      <D.20037>:
      D.20039 = strcmp (hostname, &this_hostname);
      if (D.20039 == 0) goto <D.20040>; else goto <D.20041>;
      <D.20040>:
      add_local_ips = 1;
      *h_name = host;
      <D.20041>:
      <D.20038>:
      <D.20035>:
      memset (&hints, 0, 48);
      D.20042 = get_family_hint ();
      hints.ai_family = D.20042;
      hints.ai_socktype = 1;
      hints.ai_flags = 2;
      D.20031 = *hostname;
      if (D.20031 != 0) goto <D.20043>; else goto <D.20044>;
      <D.20043>:
      D.20045 = getaddrinfo (hostname, 0B, &hints, &info);
      if (D.20045 == -1) goto <D.20046>; else goto <D.20047>;
      <D.20046>:
      D.20048 = 0;
      return D.20048;
      <D.20047>:
      <D.20044>:
      monoeg_g_free (hostname);
      info.65 = info;
      D.20050 = addrinfo_to_IPHostEntry (info.65, h_name, h_aliases, h_addr_list, add_local_ips);
      D.20048 = (MonoBoolean) D.20050;
      return D.20048;
    }
  finally
    {
      this_hostname = {CLOBBER};
      info = {CLOBBER};
      hints = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
gethostname (char * __buf, size_t __buflen)
{
  long unsigned int D.20053;
  int D.20056;
  int D.20059;
  long unsigned int D.20060;
  long unsigned int D.20061;
  long unsigned int D.20064;

  D.20053 = __builtin_object_size (__buf, 1);
  if (D.20053 != 18446744073709551615) goto <D.20054>; else goto <D.20055>;
  <D.20054>:
  D.20056 = __builtin_constant_p (__buflen);
  if (D.20056 == 0) goto <D.20057>; else goto <D.20058>;
  <D.20057>:
  D.20060 = __builtin_object_size (__buf, 1);
  D.20059 = __gethostname_chk (__buf, __buflen, D.20060);
  return D.20059;
  <D.20058>:
  D.20061 = __builtin_object_size (__buf, 1);
  if (D.20061 < __buflen) goto <D.20062>; else goto <D.20063>;
  <D.20062>:
  D.20064 = __builtin_object_size (__buf, 1);
  D.20059 = __gethostname_chk_warn (__buf, __buflen, D.20064);
  return D.20059;
  <D.20063>:
  <D.20055>:
  D.20059 = __gethostname_alias (__buf, __buflen);
  return D.20059;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.66;
  int iftmp.67;
  int D.20074;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.20067>; else goto <D.20068>;
  <D.20067>:
  if (__ret == 1) goto <D.20070>; else goto <D.20071>;
  <D.20070>:
  iftmp.67 = -1;
  goto <D.20072>;
  <D.20071>:
  iftmp.67 = 1;
  <D.20072>:
  iftmp.66 = iftmp.67;
  goto <D.20073>;
  <D.20068>:
  iftmp.66 = 0;
  <D.20073>:
  __ret = iftmp.66;
  D.20074 = __ret;
  return D.20074;
}


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

  D.20077 = __builtin_object_size (__dest, 0);
  D.20076 = __builtin___memset_chk (__dest, __ch, __len, D.20077);
  return D.20076;
}


get_family_hint ()
{
  unsigned char D.20079;
  struct MonoImage * D.20082;
  struct MonoDomain * D.20083;
  _Bool D.20084;
  long int D.20085;
  long int D.20086;
  union mono_mutex_t * D.20089;
  _Bool D.20092;
  long int D.20093;
  long int D.20094;
  int ipv4_enabled.68;
  int ipv6_enabled.69;
  _Bool D.20108;
  long int D.20109;
  long int D.20110;
  int D.20113;
  gint32 D.20114;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.20079 = domain->inet_family_hint;
  if (D.20079 == 0) goto <D.20080>; else goto <D.20081>;
  <D.20080>:
  {
    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.20082 = get_socket_assembly ();
        socket_class = mono_class_from_name (D.20082, "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.20083 = mono_domain_get ();
        vtable = mono_class_vtable (D.20083, socket_class);
        D.20084 = vtable == 0B;
        D.20085 = (long int) D.20084;
        D.20086 = __builtin_expect (D.20085, 0);
        if (D.20086 != 0) goto <D.20087>; else goto <D.20088>;
        <D.20087>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 715, "vtable");
        <D.20088>:
        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.20089 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.20089);
          if (ret != 0) goto <D.20090>; else goto <D.20091>;
          <D.20090>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20091>:
          D.20092 = ret != 0;
          D.20093 = (long int) D.20092;
          D.20094 = __builtin_expect (D.20093, 0);
          if (D.20094 != 0) goto <D.20095>; else goto <D.20096>;
          <D.20095>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 721, "ret == 0");
          <D.20096>:
        }
        ipv4_enabled.68 = ipv4_enabled;
        if (ipv4_enabled.68 == 1) goto <D.20100>; else goto <D.20097>;
        <D.20100>:
        ipv6_enabled.69 = ipv6_enabled;
        if (ipv6_enabled.69 == 1) goto <D.20102>; else goto <D.20097>;
        <D.20102>:
        domain->inet_family_hint = 1;
        goto <D.20098>;
        <D.20097>:
        ipv4_enabled.68 = ipv4_enabled;
        if (ipv4_enabled.68 == 1) goto <D.20103>; else goto <D.20104>;
        <D.20103>:
        domain->inet_family_hint = 2;
        goto <D.20105>;
        <D.20104>:
        domain->inet_family_hint = 3;
        <D.20105>:
        <D.20098>:
        {
          int ret;

          D.20089 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.20089);
          if (ret != 0) goto <D.20106>; else goto <D.20107>;
          <D.20106>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20107>:
          D.20108 = ret != 0;
          D.20109 = (long int) D.20108;
          D.20110 = __builtin_expect (D.20109, 0);
          if (D.20110 != 0) goto <D.20111>; else goto <D.20112>;
          <D.20111>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "socket-io.c", 729, "ret == 0");
          <D.20112>:
        }
      }
    finally
      {
        ipv6_enabled = {CLOBBER};
        ipv4_enabled = {CLOBBER};
      }
  }
  <D.20081>:
  D.20079 = domain->inet_family_hint;
  D.20113 = (int) D.20079;
  switch (D.20113) <default: <D.18642>, case 1: <D.18639>, case 2: <D.18640>, case 3: <D.18641>>
  <D.18639>:
  D.20114 = 0;
  return D.20114;
  <D.18640>:
  D.20114 = 2;
  return D.20114;
  <D.18641>:
  D.20114 = 10;
  return D.20114;
  <D.18642>:
  D.20114 = 0;
  return D.20114;
}


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.20116;
  struct MonoArray * D.20117;
  int nlocal_in.70;
  int nlocal_in6.71;
  struct MonoClass * D.20125;
  int D.20126;
  long unsigned int D.20127;
  struct MonoArray * D.20128;
  long unsigned int D.20131;
  long unsigned int D.20132;
  struct in_addr * D.20133;
  struct MonoArray * D.20134;
  long unsigned int D.20135;
  long unsigned int D.20138;
  long unsigned int D.20139;
  struct in6_addr * D.20140;
  gboolean D.20145;
  int D.20146;
  struct MonoClass * D.20151;
  long unsigned int D.20152;
  struct MonoArray * D.20153;
  struct sockaddr * D.20160;
  struct in_addr * D.20161;
  struct in6_addr * D.20163;
  char * D.20169;
  struct MonoString * D.20172;
  struct MonoString * D.20174;
  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.20116 = mono_get_string_class ();
      D.20117 = mono_array_new (domain, D.20116, 0);
      *h_aliases = D.20117;
      if (add_local_ips != 0) goto <D.20118>; else goto <D.20119>;
      <D.20118>:
      local_in = get_local_ips (2, &nlocal_in);
      local_in6 = get_local_ips (10, &nlocal_in6);
      nlocal_in.70 = nlocal_in;
      if (nlocal_in.70 != 0) goto <D.20120>; else goto <D.20123>;
      <D.20123>:
      nlocal_in6.71 = nlocal_in6;
      if (nlocal_in6.71 != 0) goto <D.20120>; else goto <D.20121>;
      <D.20120>:
      D.20125 = mono_get_string_class ();
      nlocal_in.70 = nlocal_in;
      nlocal_in6.71 = nlocal_in6;
      D.20126 = nlocal_in.70 + nlocal_in6.71;
      D.20127 = (long unsigned int) D.20126;
      D.20128 = mono_array_new (domain, D.20125, D.20127);
      *h_addr_list = D.20128;
      nlocal_in.70 = nlocal_in;
      if (nlocal_in.70 != 0) goto <D.20129>; else goto <D.20130>;
      <D.20129>:
      {
        struct MonoString * addr_string;
        char addr[16];
        int i;

        try
          {
            i = 0;
            goto <D.19127>;
            <D.19126>:
            D.20131 = (long unsigned int) i;
            D.20132 = D.20131 * 4;
            D.20133 = local_in + D.20132;
            inet_ntop (2, D.20133, &addr, 16);
            addr_string = mono_string_new (domain, &addr);
            {
              void * * __p;

              D.20134 = *h_addr_list;
              D.20135 = (long unsigned int) addr_index;
              __p = mono_array_addr_with_size (D.20134, 8, D.20135);
              D.20134 = *h_addr_list;
              mono_gc_wbarrier_set_arrayref (D.20134, __p, addr_string);
            }
            addr_index = addr_index + 1;
            i = i + 1;
            <D.19127>:
            nlocal_in.70 = nlocal_in;
            if (i < nlocal_in.70) goto <D.19126>; else goto <D.19128>;
            <D.19128>:
          }
        finally
          {
            addr = {CLOBBER};
          }
      }
      <D.20130>:
      nlocal_in6.71 = nlocal_in6;
      if (nlocal_in6.71 != 0) goto <D.20136>; else goto <D.20137>;
      <D.20136>:
      {
        struct MonoString * addr_string;
        const char * ret;
        char addr[48];
        int i;

        try
          {
            i = 0;
            goto <D.19135>;
            <D.19134>:
            D.20138 = (long unsigned int) i;
            D.20139 = D.20138 * 16;
            D.20140 = local_in6 + D.20139;
            ret = inet_ntop (10, D.20140, &addr, 48);
            if (ret != 0B) goto <D.20141>; else goto <D.20142>;
            <D.20141>:
            addr_string = mono_string_new (domain, &addr);
            {
              void * * __p;

              D.20134 = *h_addr_list;
              D.20135 = (long unsigned int) addr_index;
              __p = mono_array_addr_with_size (D.20134, 8, D.20135);
              D.20134 = *h_addr_list;
              mono_gc_wbarrier_set_arrayref (D.20134, __p, addr_string);
            }
            addr_index = addr_index + 1;
            <D.20142>:
            i = i + 1;
            <D.19135>:
            nlocal_in6.71 = nlocal_in6;
            if (i < nlocal_in6.71) goto <D.19134>; else goto <D.19136>;
            <D.19136>:
          }
        finally
          {
            addr = {CLOBBER};
          }
      }
      <D.20137>:
      monoeg_g_free (local_in);
      monoeg_g_free (local_in6);
      if (info != 0B) goto <D.20143>; else goto <D.20144>;
      <D.20143>:
      freeaddrinfo (info);
      <D.20144>:
      D.20145 = 1;
      return D.20145;
      <D.20121>:
      monoeg_g_free (local_in);
      monoeg_g_free (local_in6);
      <D.20119>:
      count = 0;
      ai = info;
      goto <D.19139>;
      <D.19138>:
      D.20146 = ai->ai_family;
      if (D.20146 != 2) goto <D.20147>; else goto <D.20148>;
      <D.20147>:
      D.20146 = ai->ai_family;
      if (D.20146 != 10) goto <D.20149>; else goto <D.20150>;
      <D.20149>:
      // predicted unlikely by continue predictor.
      goto <D.19137>;
      <D.20150>:
      <D.20148>:
      count = count + 1;
      <D.19137>:
      ai = ai->ai_next;
      <D.19139>:
      if (ai != 0B) goto <D.19138>; else goto <D.19140>;
      <D.19140>:
      D.20151 = mono_get_string_class ();
      D.20152 = (long unsigned int) count;
      D.20153 = mono_array_new (domain, D.20151, D.20152);
      *h_addr_list = D.20153;
      ai = info;
      i = 0;
      goto <D.19147>;
      <D.19146>:
      {
        struct MonoString * addr_string;
        const char * ret;
        char buffer[48];

        try
          {
            D.20146 = ai->ai_family;
            if (D.20146 != 2) goto <D.20154>; else goto <D.20155>;
            <D.20154>:
            D.20146 = ai->ai_family;
            if (D.20146 != 10) goto <D.20156>; else goto <D.20157>;
            <D.20156>:
            // predicted unlikely by continue predictor.
            goto <D.19144>;
            <D.20157>:
            <D.20155>:
            D.20146 = ai->ai_family;
            if (D.20146 == 2) goto <D.20158>; else goto <D.20159>;
            <D.20158>:
            D.20146 = ai->ai_family;
            D.20160 = ai->ai_addr;
            D.20161 = &MEM[(struct sockaddr_in *)D.20160].sin_addr;
            ret = inet_ntop (D.20146, D.20161, &buffer, 16);
            goto <D.20162>;
            <D.20159>:
            D.20146 = ai->ai_family;
            D.20160 = ai->ai_addr;
            D.20163 = &MEM[(struct sockaddr_in6 *)D.20160].sin6_addr;
            ret = inet_ntop (D.20146, D.20163, &buffer, 48);
            <D.20162>:
            if (ret != 0B) goto <D.20164>; else goto <D.20165>;
            <D.20164>:
            addr_string = mono_string_new (domain, &buffer);
            goto <D.20166>;
            <D.20165>:
            addr_string = mono_string_new (domain, "");
            <D.20166>:
            {
              void * * __p;

              D.20134 = *h_addr_list;
              D.20135 = (long unsigned int) addr_index;
              __p = mono_array_addr_with_size (D.20134, 8, D.20135);
              D.20134 = *h_addr_list;
              mono_gc_wbarrier_set_arrayref (D.20134, __p, addr_string);
            }
            if (i == 0) goto <D.20167>; else goto <D.20168>;
            <D.20167>:
            i = i + 1;
            D.20169 = ai->ai_canonname;
            if (D.20169 != 0B) goto <D.20170>; else goto <D.20171>;
            <D.20170>:
            D.20169 = ai->ai_canonname;
            D.20172 = mono_string_new (domain, D.20169);
            *h_name = D.20172;
            goto <D.20173>;
            <D.20171>:
            D.20174 = mono_string_new (domain, &buffer);
            *h_name = D.20174;
            <D.20173>:
            <D.20168>:
            addr_index = addr_index + 1;
          }
        finally
          {
            buffer = {CLOBBER};
          }
      }
      <D.19144>:
      ai = ai->ai_next;
      <D.19147>:
      if (ai != 0B) goto <D.19146>; else goto <D.19148>;
      <D.19148>:
      if (info != 0B) goto <D.20175>; else goto <D.20176>;
      <D.20175>:
      freeaddrinfo (info);
      <D.20176>:
      D.20145 = 1;
      return D.20145;
    }
  finally
    {
      nlocal_in = {CLOBBER};
      nlocal_in6 = {CLOBBER};
    }
}


get_local_ips (int family, int * nips)
{
  void * D.20187;
  unsigned int max_ifaces.72;
  unsigned int D.20189;
  int D.20190;
  int D.20191;
  long unsigned int D.20192;
  void * D.20193;
  int D.20194;
  char * D.20197;
  long unsigned int D.20198;
  long unsigned int D.20199;
  char[16] * D.20202;
  int D.20203;
  short int D.20206;
  int D.20207;
  int D.20208;
  int D.20211;
  int D.20214;
  int D.20215;
  long unsigned int D.20216;
  char D.20217;
  int D.20220;
  struct sockaddr * D.20223;
  sizetype D.20224;
  void * D.20225;
  int D.20226;
  const void * D.20229;
  long unsigned int D.20230;
  sizetype D.20231;
  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.20181>; else goto <D.20182>;
      <D.20181>:
      addr_size = 4;
      offset = 4;
      goto <D.20183>;
      <D.20182>:
      if (family == 10) goto <D.20184>; else goto <D.20185>;
      <D.20184>:
      addr_size = 16;
      offset = 8;
      goto <D.20186>;
      <D.20185>:
      D.20187 = 0B;
      return D.20187;
      <D.20186>:
      <D.20183>:
      fd = socket (family, 1, 0);
      max_ifaces.72 = (unsigned int) max_ifaces;
      D.20189 = max_ifaces.72 * 40;
      D.20190 = (int) D.20189;
      ifc.ifc_len = D.20190;
      D.20191 = ifc.ifc_len;
      D.20192 = (long unsigned int) D.20191;
      D.20193 = monoeg_malloc (D.20192);
      ifc.ifc_ifcu.ifcu_buf = D.20193;
      D.20194 = ioctl (fd, 35090, &ifc);
      if (D.20194 < 0) goto <D.20195>; else goto <D.20196>;
      <D.20195>:
      close (fd);
      D.20197 = ifc.ifc_ifcu.ifcu_buf;
      monoeg_g_free (D.20197);
      D.20187 = 0B;
      return D.20187;
      <D.20196>:
      D.20191 = ifc.ifc_len;
      D.20198 = (long unsigned int) D.20191;
      D.20199 = D.20198 / 40;
      count = (int) D.20199;
      *nips = count;
      if (count == 0) goto <D.20200>; else goto <D.20201>;
      <D.20200>:
      D.20197 = ifc.ifc_ifcu.ifcu_buf;
      monoeg_g_free (D.20197);
      close (fd);
      D.20187 = 0B;
      return D.20187;
      <D.20201>:
      i = 0;
      ifr = ifc.ifc_ifcu.ifcu_req;
      goto <D.19100>;
      <D.19099>:
      D.20202 = &ifr->ifr_ifrn.ifrn_name;
      strcpy (&iflags.ifr_ifrn.ifrn_name, D.20202);
      D.20203 = ioctl (fd, 35091, &iflags);
      if (D.20203 < 0) goto <D.20204>; else goto <D.20205>;
      <D.20204>:
      // predicted unlikely by continue predictor.
      goto <D.19098>;
      <D.20205>:
      D.20206 = iflags.ifr_ifru.ifru_flags;
      D.20207 = (int) D.20206;
      D.20208 = D.20207 & 1;
      if (D.20208 == 0) goto <D.20209>; else goto <D.20210>;
      <D.20209>:
      ifr->ifr_ifrn.ifrn_name[0] = 0;
      // predicted unlikely by continue predictor.
      goto <D.19098>;
      <D.20210>:
      D.20206 = iflags.ifr_ifru.ifru_flags;
      D.20207 = (int) D.20206;
      D.20211 = D.20207 & 8;
      if (D.20211 == 0) goto <D.20212>; else goto <D.20213>;
      <D.20212>:
      ignore_loopback = 1;
      <D.20213>:
      <D.19098>:
      i = i + 1;
      ifr = ifr + 40;
      <D.19100>:
      D.20214 = *nips;
      if (D.20214 > i) goto <D.19099>; else goto <D.19101>;
      <D.19101>:
      close (fd);
      D.20215 = addr_size * count;
      D.20216 = (long unsigned int) D.20215;
      result = monoeg_malloc (D.20216);
      tmp_ptr = result;
      i = 0;
      ifr = ifc.ifc_ifcu.ifcu_req;
      goto <D.19104>;
      <D.19103>:
      D.20217 = ifr->ifr_ifrn.ifrn_name[0];
      if (D.20217 == 0) goto <D.20218>; else goto <D.20219>;
      <D.20218>:
      D.20214 = *nips;
      D.20220 = D.20214 + -1;
      *nips = D.20220;
      // predicted unlikely by continue predictor.
      goto <D.19102>;
      <D.20219>:
      if (ignore_loopback != 0) goto <D.20221>; else goto <D.20222>;
      <D.20221>:
      D.20223 = &ifr->ifr_ifru.ifru_addr;
      D.20224 = (sizetype) offset;
      D.20225 = D.20223 + D.20224;
      D.20226 = is_loopback (family, D.20225);
      if (D.20226 != 0) goto <D.20227>; else goto <D.20228>;
      <D.20227>:
      D.20214 = *nips;
      D.20220 = D.20214 + -1;
      *nips = D.20220;
      // predicted unlikely by continue predictor.
      goto <D.19102>;
      <D.20228>:
      <D.20222>:
      D.20223 = &ifr->ifr_ifru.ifru_addr;
      D.20224 = (sizetype) offset;
      D.20229 = D.20223 + D.20224;
      D.20230 = (long unsigned int) addr_size;
      memcpy (tmp_ptr, D.20229, D.20230);
      D.20231 = (sizetype) addr_size;
      tmp_ptr = tmp_ptr + D.20231;
      <D.19102>:
      i = i + 1;
      ifr = ifr + 40;
      <D.19104>:
      if (i < count) goto <D.19103>; else goto <D.19105>;
      <D.19105>:
      D.20197 = ifc.ifc_ifcu.ifcu_buf;
      monoeg_g_free (D.20197);
      D.20187 = result;
      return D.20187;
    }
  finally
    {
      ifc = {CLOBBER};
      iflags = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.20234;
  long unsigned int D.20235;

  D.20235 = __builtin_object_size (__dest, 1);
  D.20234 = __builtin___strcpy_chk (__dest, __src, D.20235);
  return D.20234;
}


is_loopback (int family, void * ad)
{
  gboolean D.20239;
  char D.20240;
  _Bool D.20241;
  int D.19081;
  int iftmp.73;
  unsigned int D.20245;
  unsigned int D.20247;
  unsigned int D.20249;
  unsigned int D.20251;
  unsigned int D.20252;
  char * ptr;

  ptr = ad;
  if (family == 2) goto <D.20237>; else goto <D.20238>;
  <D.20237>:
  D.20240 = *ptr;
  D.20241 = D.20240 == 127;
  D.20239 = (gboolean) D.20241;
  return D.20239;
  <D.20238>:
  {
    const struct in6_addr * __a;

    __a = ptr;
    D.20245 = __a->__in6_u.__u6_addr32[0];
    if (D.20245 == 0) goto <D.20246>; else goto <D.20243>;
    <D.20246>:
    D.20247 = __a->__in6_u.__u6_addr32[1];
    if (D.20247 == 0) goto <D.20248>; else goto <D.20243>;
    <D.20248>:
    D.20249 = __a->__in6_u.__u6_addr32[2];
    if (D.20249 == 0) goto <D.20250>; else goto <D.20243>;
    <D.20250>:
    D.20251 = __a->__in6_u.__u6_addr32[3];
    D.20252 = __uint32_identity (1);
    if (D.20251 == D.20252) goto <D.20253>; else goto <D.20243>;
    <D.20253>:
    iftmp.73 = 1;
    goto <D.20244>;
    <D.20243>:
    iftmp.73 = 0;
    <D.20244>:
    D.19081 = iftmp.73;
  }
  D.20239 = D.19081;
  return D.20239;
  D.20239 = 0;
  return D.20239;
}


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

  D.20256 = __builtin_object_size (__dest, 0);
  D.20255 = __builtin___memcpy_chk (__dest, __src, __len, D.20256);
  return D.20255;
}


__attribute__((visibility ("hidden")))
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.20258;
  int D.20261;
  MonoBoolean D.20264;
  int D.20268;
  int D.20274;
  int D.20277;
  int D.20278;
  struct addrinfo * info.74;
  int D.20282;
  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.20258 = inet_pton (2, address, &saddr.sin_addr);
      if (D.20258 <= 0) goto <D.20259>; else goto <D.20260>;
      <D.20259>:
      D.20261 = inet_pton (10, address, &saddr6.sin6_addr);
      if (D.20261 <= 0) goto <D.20262>; else goto <D.20263>;
      <D.20262>:
      monoeg_g_free (address);
      D.20264 = 0;
      return D.20264;
      <D.20263>:
      family = 10;
      saddr6.sin6_family = 10;
      goto <D.20265>;
      <D.20260>:
      family = 2;
      saddr.sin_family = 2;
      <D.20265>:
      monoeg_g_free (address);
      if (family == 2) goto <D.20266>; else goto <D.20267>;
      <D.20266>:
      D.20268 = getnameinfo (&saddr, 16, &hostname, 1025, 0B, 0, flags);
      if (D.20268 != 0) goto <D.20269>; else goto <D.20270>;
      <D.20269>:
      D.20264 = 0;
      return D.20264;
      <D.20270>:
      goto <D.20271>;
      <D.20267>:
      if (family == 10) goto <D.20272>; else goto <D.20273>;
      <D.20272>:
      D.20274 = getnameinfo (&saddr6, 28, &hostname, 1025, 0B, 0, flags);
      if (D.20274 != 0) goto <D.20275>; else goto <D.20276>;
      <D.20275>:
      D.20264 = 0;
      return D.20264;
      <D.20276>:
      <D.20273>:
      <D.20271>:
      memset (&hints, 0, 48);
      D.20277 = get_family_hint ();
      hints.ai_family = D.20277;
      hints.ai_socktype = 1;
      hints.ai_flags = 34;
      D.20278 = getaddrinfo (&hostname, 0B, &hints, &info);
      if (D.20278 == -1) goto <D.20279>; else goto <D.20280>;
      <D.20279>:
      D.20264 = 0;
      return D.20264;
      <D.20280>:
      info.74 = info;
      D.20282 = addrinfo_to_IPHostEntry (info.74, h_name, h_aliases, h_addr_list, 0);
      D.20264 = (MonoBoolean) D.20282;
      return D.20264;
    }
  finally
    {
      saddr = {CLOBBER};
      saddr6 = {CLOBBER};
      info = {CLOBBER};
      hints = {CLOBBER};
      hostname = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Dns_GetHostName_internal (struct MonoString * * h_name)
{
  MonoBoolean D.20287;
  struct MonoDomain * D.20288;
  struct MonoString * D.20289;
  gchar hostname[256];
  int ret;

  try
    {
      ret = gethostname (&hostname, 256);
      if (ret == -1) goto <D.20285>; else goto <D.20286>;
      <D.20285>:
      D.20287 = 0;
      return D.20287;
      <D.20286>:
      D.20288 = mono_domain_get ();
      D.20289 = mono_string_new (D.20288, &hostname);
      *h_name = D.20289;
      D.20287 = 1;
      return D.20287;
    }
  finally
    {
      hostname = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Net_Sockets_Socket_SendFile (SOCKET sock, struct MonoString * filename, struct MonoArray * pre_buffer, struct MonoArray * post_buffer, gint flags)
{
  gboolean D.20294;
  int error.75;
  unsigned int error.76;
  char * D.20301;
  long unsigned int D.20302;
  unsigned int D.20303;
  char * D.20306;
  long unsigned int D.20307;
  unsigned int D.20308;
  unsigned int flags.77;
  int D.20310;
  void * file;
  gint32 error;
  struct TRANSMIT_FILE_BUFFERS buffers;

  try
    {
      if (filename == 0B) goto <D.20292>; else goto <D.20293>;
      <D.20292>:
      D.20294 = 0;
      return D.20294;
      <D.20293>:
      file = ves_icall_System_IO_MonoIO_Open (filename, 3, 1, 1, 0, &error);
      if (file == -1B) goto <D.20295>; else goto <D.20296>;
      <D.20295>:
      error.75 = error;
      error.76 = (unsigned int) error.75;
      SetLastError (error.76);
      D.20294 = 0;
      return D.20294;
      <D.20296>:
      memset (&buffers, 0, 32);
      if (pre_buffer != 0B) goto <D.20299>; else goto <D.20300>;
      <D.20299>:
      D.20301 = mono_array_addr_with_size (pre_buffer, 1, 0);
      buffers.Head = D.20301;
      D.20302 = mono_array_length (pre_buffer);
      D.20303 = (unsigned int) D.20302;
      buffers.HeadLength = D.20303;
      <D.20300>:
      if (post_buffer != 0B) goto <D.20304>; else goto <D.20305>;
      <D.20304>:
      D.20306 = mono_array_addr_with_size (post_buffer, 1, 0);
      buffers.Tail = D.20306;
      D.20307 = mono_array_length (post_buffer);
      D.20308 = (unsigned int) D.20307;
      buffers.TailLength = D.20308;
      <D.20305>:
      flags.77 = (unsigned int) flags;
      D.20310 = TransmitFile (sock, file, 0, 0, 0B, &buffers, flags.77);
      if (D.20310 == 0) goto <D.20311>; else goto <D.20312>;
      <D.20311>:
      CloseHandle (file);
      D.20294 = 0;
      return D.20294;
      <D.20312>:
      CloseHandle (file);
      D.20294 = 1;
      return D.20294;
    }
  finally
    {
      error = {CLOBBER};
      buffers = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
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.20315>; else goto <D.20316>;
      <D.20315>:
      monoeg_g_log (0B, 4, "%s: Couldn\'t initialise networking", &__func__);
      <D.19195>:
      goto <D.19195>;
      exit (-1);
      <D.20316>:
    }
  finally
    {
      wsadata = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_network_cleanup ()
{
  WSACleanup ();
}


__attribute__((visibility ("hidden")))
icall_cancel_blocking_socket_operation (struct MonoThread * thread)
{
  int D.20317;
  long unsigned int D.20320;
  int D.20322;
  struct MonoInternalThread * internal;

  internal = thread->internal_thread;
  D.20317 = mono_thread_info_new_interrupt_enabled ();
  if (D.20317 != 0) goto <D.20318>; else goto <D.20319>;
  <D.20318>:
  D.20320 = internal->tid;
  mono_thread_info_abort_socket_syscall_for_close (D.20320);
  goto <D.20321>;
  <D.20319>:
  internal->ignore_next_signal = 1;
  D.20322 = mono_thread_get_abort_signal ();
  mono_thread_kill (internal, D.20322);
  <D.20321>:
}