ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngOpen ()
{
  int egd.0;
  int file.1;
  MonoBoolean D.8399;
  int file.2;
  int file.3;
  _Bool D.8406;
  int egd.4;

  egd.0 = egd;
  if (egd.0 != 0) goto <D.8394>; else goto <D.8397>;
  <D.8397>:
  file.1 = file;
  if (file.1 >= 0) goto <D.8394>; else goto <D.8395>;
  <D.8394>:
  D.8399 = 1;
  return D.8399;
  <D.8395>:
  file.2 = open ("/dev/urandom", 0);
  file = file.2;
  file.1 = file;
  if (file.1 < 0) goto <D.8401>; else goto <D.8402>;
  <D.8401>:
  file.3 = open ("/dev/random", 0);
  file = file.3;
  <D.8402>:
  file.1 = file;
  if (file.1 < 0) goto <D.8404>; else goto <D.8405>;
  <D.8404>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    D.8406 = socket_path != 0B;
    egd.4 = (int) D.8406;
    egd = egd.4;
  }
  <D.8405>:
  D.8399 = 1;
  return D.8399;
}


open (const char * __path, int __oflag)
{
  int D.8409;
  int D.8412;
  int D.8417;
  int D.8419;
  int D.8420;
  int D.8423;
  int D.8424;

  D.8409 = __builtin_va_arg_pack_len ();
  if (D.8409 > 1) goto <D.8410>; else goto <D.8411>;
  <D.8410>:
  __open_too_many_args ();
  <D.8411>:
  D.8412 = __builtin_constant_p (__oflag);
  if (D.8412 != 0) goto <D.8413>; else goto <D.8414>;
  <D.8413>:
  D.8417 = __oflag & 64;
  if (D.8417 != 0) goto <D.8415>; else goto <D.8418>;
  <D.8418>:
  D.8419 = __oflag & 4259840;
  if (D.8419 == 4259840) goto <D.8415>; else goto <D.8416>;
  <D.8415>:
  D.8420 = __builtin_va_arg_pack_len ();
  if (D.8420 <= 0) goto <D.8421>; else goto <D.8422>;
  <D.8421>:
  __open_missing_mode ();
  D.8423 = __open_2 (__path, __oflag);
  return D.8423;
  <D.8422>:
  <D.8416>:
  D.8423 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8423;
  <D.8414>:
  D.8424 = __builtin_va_arg_pack_len ();
  if (D.8424 <= 0) goto <D.8425>; else goto <D.8426>;
  <D.8425>:
  D.8423 = __open_2 (__path, __oflag);
  return D.8423;
  <D.8426>:
  D.8423 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8423;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngInitialize (struct MonoArray * seed)
{
  void * D.8428;
  void * iftmp.5;
  int egd.6;
  int file.7;
  long int D.8436;

  egd.6 = egd;
  if (egd.6 != 0) goto <D.8430>; else goto <D.8434>;
  <D.8434>:
  file.7 = file;
  if (file.7 >= 0) goto <D.8430>; else goto <D.8431>;
  <D.8430>:
  file.7 = file;
  D.8436 = (long int) file.7;
  iftmp.5 = (void *) D.8436;
  goto <D.8432>;
  <D.8431>:
  iftmp.5 = 0B;
  <D.8432>:
  D.8428 = iftmp.5;
  return D.8428;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (void * handle, struct MonoArray * arry)
{
  long int handle.8;
  long unsigned int D.8439;
  int egd.9;
  void * D.8445;
  long unsigned int D.8446;
  int D.8447;
  char * D.8448;
  unsigned int count.10;
  unsigned int D.8450;
  long unsigned int D.8451;
  sizetype D.8452;
  void * D.8453;
  long int D.8454;
  int * D.8457;
  int D.8458;
  char * D.8463;
  gint file;
  guint32 len;
  guchar * buf;

  handle.8 = (long int) handle;
  file = (gint) handle.8;
  D.8439 = mono_array_length (arry);
  len = (guint32) D.8439;
  buf = mono_array_addr_with_size (arry, 1, 0);
  egd.9 = egd;
  if (egd.9 != 0) goto <D.8441>; else goto <D.8442>;
  <D.8441>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    if (socket_path == 0B) goto <D.8443>; else goto <D.8444>;
    <D.8443>:
    D.8445 = 0B;
    return D.8445;
    <D.8444>:
    D.8446 = mono_array_length (arry);
    D.8447 = (int) D.8446;
    D.8448 = mono_array_addr_with_size (arry, 1, 0);
    get_entropy_from_server (socket_path, D.8448, D.8447);
    D.8445 = -1B;
    return D.8445;
  }
  <D.8442>:
  {
    gint count;
    gint err;

    count = 0;
    <D.8389>:
    count.10 = (unsigned int) count;
    D.8450 = len - count.10;
    D.8451 = (long unsigned int) D.8450;
    D.8452 = (sizetype) count;
    D.8453 = buf + D.8452;
    D.8454 = read (file, D.8453, D.8451);
    err = (gint) D.8454;
    if (err < 0) goto <D.8455>; else goto <D.8456>;
    <D.8455>:
    D.8457 = __errno_location ();
    D.8458 = *D.8457;
    if (D.8458 == 4) goto <D.8459>; else goto <D.8460>;
    <D.8459>:
    // predicted unlikely by continue predictor.
    goto <D.8387>;
    <D.8460>:
    goto <D.8388>;
    <D.8456>:
    count = count + err;
    <D.8387>:
    count.10 = (unsigned int) count;
    if (count.10 < len) goto <D.8389>; else goto <D.8388>;
    <D.8388>:
    if (err < 0) goto <D.8461>; else goto <D.8462>;
    <D.8461>:
    D.8457 = __errno_location ();
    D.8458 = *D.8457;
    D.8463 = strerror (D.8458);
    monoeg_g_log (0B, 16, "Entropy error! Error in read (%s).", D.8463);
    D.8445 = 0B;
    return D.8445;
    <D.8462>:
  }
  D.8445 = handle;
  return D.8445;
}


get_entropy_from_server (const char * path, guchar * buf, int len)
{
  union 
{
  const struct sockaddr * restrict __sockaddr__;
  const struct sockaddr_at * restrict __sockaddr_at__;
  const struct sockaddr_ax25 * restrict __sockaddr_ax25__;
  const struct sockaddr_dl * restrict __sockaddr_dl__;
  const struct sockaddr_eon * restrict __sockaddr_eon__;
  const struct sockaddr_in * restrict __sockaddr_in__;
  const struct sockaddr_in6 * restrict __sockaddr_in6__;
  const struct sockaddr_inarp * restrict __sockaddr_inarp__;
  const struct sockaddr_ipx * restrict __sockaddr_ipx__;
  const struct sockaddr_iso * restrict __sockaddr_iso__;
  const struct sockaddr_ns * restrict __sockaddr_ns__;
  const struct sockaddr_un * restrict __sockaddr_un__;
  const struct sockaddr_x25 * restrict __sockaddr_x25__;
} D.8468;
  struct MonoException * D.8473;
  int D.8474;
  unsigned char D.8475;
  int D.8476;
  long unsigned int D.8477;
  sizetype D.8478;
  const void * D.8479;
  long int D.8480;
  int * D.8484;
  int D.8485;
  struct MonoException * D.8488;
  unsigned char D.8489;
  int D.8490;
  int D.8491;
  long unsigned int D.8492;
  sizetype D.8493;
  void * D.8494;
  long int D.8495;
  unsigned int received.11;
  struct MonoException * D.8503;
  int D.8504;
  int file;
  gint ret;
  guint offset;
  struct sockaddr_un egd_addr;

  try
    {
      offset = 0;
      file = socket (1, 1, 0);
      if (file < 0) goto <D.8465>; else goto <D.8466>;
      <D.8465>:
      ret = -1;
      goto <D.8467>;
      <D.8466>:
      egd_addr.sun_family = 1;
      strncpy (&egd_addr.sun_path, path, 107);
      egd_addr.sun_path[107] = 0;
      D.8468.__sockaddr__ = &egd_addr;
      ret = connect (file, D.8468, 110);
      <D.8467>:
      if (ret == -1) goto <D.8469>; else goto <D.8470>;
      <D.8469>:
      if (file >= 0) goto <D.8471>; else goto <D.8472>;
      <D.8471>:
      close (file);
      <D.8472>:
      monoeg_g_log (0B, 16, "Entropy problem! Can\'t create or connect to egd socket %s", path);
      D.8473 = mono_get_exception_execution_engine ("Failed to open egd socket");
      mono_raise_exception (D.8473);
      <D.8470>:
      goto <D.8366>;
      <D.8365>:
      {
        guchar request[2];
        gint count;

        try
          {
            count = 0;
            request[0] = 2;
            D.8474 = MIN_EXPR <len, 255>;
            D.8475 = (unsigned char) D.8474;
            request[1] = D.8475;
            goto <D.8358>;
            <D.8359>:
            {
              int sent;

              D.8476 = 2 - count;
              D.8477 = (long unsigned int) D.8476;
              D.8478 = (sizetype) count;
              D.8479 = &request + D.8478;
              D.8480 = write (file, D.8479, D.8477);
              sent = (int) D.8480;
              if (sent >= 0) goto <D.8481>; else goto <D.8482>;
              <D.8481>:
              count = count + sent;
              goto <D.8483>;
              <D.8482>:
              D.8484 = __errno_location ();
              D.8485 = *D.8484;
              if (D.8485 == 4) goto <D.8486>; else goto <D.8487>;
              <D.8486>:
              // predicted unlikely by continue predictor.
              goto <D.8358>;
              <D.8487>:
              close (file);
              D.8484 = __errno_location ();
              D.8485 = *D.8484;
              monoeg_g_log (0B, 16, "Send egd request failed %d", D.8485);
              D.8488 = mono_get_exception_execution_engine ("Failed to send request to egd socket");
              mono_raise_exception (D.8488);
              <D.8483>:
            }
            <D.8358>:
            if (count <= 1) goto <D.8359>; else goto <D.8360>;
            <D.8360>:
            count = 0;
            goto <D.8362>;
            <D.8363>:
            {
              int received;

              D.8489 = request[1];
              D.8490 = (int) D.8489;
              D.8491 = D.8490 - count;
              D.8492 = (long unsigned int) D.8491;
              D.8493 = (sizetype) offset;
              D.8494 = buf + D.8493;
              D.8495 = read (file, D.8494, D.8492);
              received = (int) D.8495;
              if (received > 0) goto <D.8496>; else goto <D.8497>;
              <D.8496>:
              count = count + received;
              received.11 = (unsigned int) received;
              offset = offset + received.11;
              goto <D.8499>;
              <D.8497>:
              if (received < 0) goto <D.8501>; else goto <D.8500>;
              <D.8501>:
              D.8484 = __errno_location ();
              D.8485 = *D.8484;
              if (D.8485 == 4) goto <D.8502>; else goto <D.8500>;
              <D.8502>:
              // predicted unlikely by continue predictor.
              goto <D.8362>;
              <D.8500>:
              close (file);
              D.8484 = __errno_location ();
              D.8485 = *D.8484;
              monoeg_g_log (0B, 16, "Receive egd request failed %d", D.8485);
              D.8503 = mono_get_exception_execution_engine ("Failed to get response from egd socket");
              mono_raise_exception (D.8503);
              <D.8499>:
            }
            <D.8362>:
            D.8489 = request[1];
            D.8504 = (int) D.8489;
            if (D.8504 != count) goto <D.8363>; else goto <D.8364>;
            <D.8364>:
            D.8489 = request[1];
            D.8504 = (int) D.8489;
            len = len - D.8504;
          }
        finally
          {
            request = {CLOBBER};
          }
      }
      <D.8366>:
      if (len > 0) goto <D.8365>; else goto <D.8367>;
      <D.8367>:
      close (file);
    }
  finally
    {
      egd_addr = {CLOBBER};
    }
}


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

  D.8506 = __builtin_object_size (__dest, 1);
  D.8505 = __builtin___strncpy_chk (__dest, __src, __len, D.8506);
  return D.8505;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.8508;
  int D.8511;
  ssize_t D.8514;
  long unsigned int D.8515;
  long unsigned int D.8516;
  long unsigned int D.8519;

  D.8508 = __builtin_object_size (__buf, 0);
  if (D.8508 != 18446744073709551615) goto <D.8509>; else goto <D.8510>;
  <D.8509>:
  D.8511 = __builtin_constant_p (__nbytes);
  if (D.8511 == 0) goto <D.8512>; else goto <D.8513>;
  <D.8512>:
  D.8515 = __builtin_object_size (__buf, 0);
  D.8514 = __read_chk (__fd, __buf, __nbytes, D.8515);
  return D.8514;
  <D.8513>:
  D.8516 = __builtin_object_size (__buf, 0);
  if (D.8516 < __nbytes) goto <D.8517>; else goto <D.8518>;
  <D.8517>:
  D.8519 = __builtin_object_size (__buf, 0);
  D.8514 = __read_chk_warn (__fd, __buf, __nbytes, D.8519);
  return D.8514;
  <D.8518>:
  <D.8510>:
  D.8514 = __read_alias (__fd, __buf, __nbytes);
  return D.8514;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngClose (void * handle)
{

}