__attribute__((visibility ("hidden")))
ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngOpen ()
{
  int egd.0;
  int file.1;
  MonoBoolean D.8570;
  int D.8571;
  int D.8574;
  _Bool D.8577;
  int D.8578;

  egd.0 = egd;
  if (egd.0 != 0) goto <D.8565>; else goto <D.8568>;
  <D.8568>:
  file.1 = file;
  if (file.1 >= 0) goto <D.8565>; else goto <D.8566>;
  <D.8565>:
  D.8570 = 1;
  return D.8570;
  <D.8566>:
  D.8571 = open ("/dev/urandom", 0);
  file = D.8571;
  file.1 = file;
  if (file.1 < 0) goto <D.8572>; else goto <D.8573>;
  <D.8572>:
  D.8574 = open ("/dev/random", 0);
  file = D.8574;
  <D.8573>:
  file.1 = file;
  if (file.1 < 0) goto <D.8575>; else goto <D.8576>;
  <D.8575>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    D.8577 = socket_path != 0B;
    D.8578 = (int) D.8577;
    egd = D.8578;
  }
  <D.8576>:
  D.8570 = 1;
  return D.8570;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
open (const char * __path, int __oflag)
{
  int D.8580;
  int D.8583;
  int D.8588;
  int D.8590;
  int D.8591;
  int D.8594;
  int D.8595;

  D.8580 = __builtin_va_arg_pack_len ();
  if (D.8580 > 1) goto <D.8581>; else goto <D.8582>;
  <D.8581>:
  __open_too_many_args ();
  <D.8582>:
  D.8583 = __builtin_constant_p (__oflag);
  if (D.8583 != 0) goto <D.8584>; else goto <D.8585>;
  <D.8584>:
  D.8588 = __oflag & 64;
  if (D.8588 != 0) goto <D.8586>; else goto <D.8589>;
  <D.8589>:
  D.8590 = __oflag & 4259840;
  if (D.8590 == 4259840) goto <D.8586>; else goto <D.8587>;
  <D.8586>:
  D.8591 = __builtin_va_arg_pack_len ();
  if (D.8591 <= 0) goto <D.8592>; else goto <D.8593>;
  <D.8592>:
  __open_missing_mode ();
  D.8594 = __open_2 (__path, __oflag);
  return D.8594;
  <D.8593>:
  <D.8587>:
  D.8594 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8594;
  <D.8585>:
  D.8595 = __builtin_va_arg_pack_len ();
  if (D.8595 <= 0) goto <D.8596>; else goto <D.8597>;
  <D.8596>:
  D.8594 = __open_2 (__path, __oflag);
  return D.8594;
  <D.8597>:
  D.8594 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8594;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngInitialize (struct MonoArray * seed)
{
  void * D.8599;
  void * iftmp.2;
  int egd.3;
  int file.4;
  long int D.8607;

  egd.3 = egd;
  if (egd.3 != 0) goto <D.8601>; else goto <D.8605>;
  <D.8605>:
  file.4 = file;
  if (file.4 >= 0) goto <D.8601>; else goto <D.8602>;
  <D.8601>:
  file.4 = file;
  D.8607 = (long int) file.4;
  iftmp.2 = (void *) D.8607;
  goto <D.8603>;
  <D.8602>:
  iftmp.2 = 0B;
  <D.8603>:
  D.8599 = iftmp.2;
  return D.8599;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (void * handle, struct MonoArray * arry)
{
  long int handle.5;
  long unsigned int D.8610;
  int egd.6;
  void * D.8616;
  char * D.8617;
  long unsigned int D.8618;
  int D.8619;
  sizetype D.8620;
  guchar * D.8621;
  unsigned int count.7;
  unsigned int D.8623;
  long unsigned int D.8624;
  long int D.8625;
  int * D.8628;
  int D.8629;
  char * D.8634;
  gint file;
  guint32 len;
  guchar * buf;

  handle.5 = (long int) handle;
  file = (gint) handle.5;
  D.8610 = mono_array_length (arry);
  len = (guint32) D.8610;
  buf = mono_array_addr_with_size (arry, 1, 0);
  egd.6 = egd;
  if (egd.6 != 0) goto <D.8612>; else goto <D.8613>;
  <D.8612>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    if (socket_path == 0B) goto <D.8614>; else goto <D.8615>;
    <D.8614>:
    D.8616 = 0B;
    return D.8616;
    <D.8615>:
    D.8617 = mono_array_addr_with_size (arry, 1, 0);
    D.8618 = mono_array_length (arry);
    D.8619 = (int) D.8618;
    get_entropy_from_server (socket_path, D.8617, D.8619);
    D.8616 = -1B;
    return D.8616;
  }
  <D.8613>:
  {
    gint count;
    gint err;

    count = 0;
    <D.8560>:
    D.8620 = (sizetype) count;
    D.8621 = buf + D.8620;
    count.7 = (unsigned int) count;
    D.8623 = len - count.7;
    D.8624 = (long unsigned int) D.8623;
    D.8625 = read (file, D.8621, D.8624);
    err = (gint) D.8625;
    if (err < 0) goto <D.8626>; else goto <D.8627>;
    <D.8626>:
    D.8628 = __errno_location ();
    D.8629 = *D.8628;
    if (D.8629 == 4) goto <D.8630>; else goto <D.8631>;
    <D.8630>:
    // predicted unlikely by continue predictor.
    goto <D.8558>;
    <D.8631>:
    goto <D.8559>;
    <D.8627>:
    count = count + err;
    <D.8558>:
    count.7 = (unsigned int) count;
    if (count.7 < len) goto <D.8560>; else goto <D.8559>;
    <D.8559>:
    if (err < 0) goto <D.8632>; else goto <D.8633>;
    <D.8632>:
    D.8628 = __errno_location ();
    D.8629 = *D.8628;
    D.8634 = strerror (D.8629);
    monoeg_g_log (0B, 16, "Entropy error! Error in read (%s).", D.8634);
    D.8616 = 0B;
    return D.8616;
    <D.8633>:
  }
  D.8616 = handle;
  return D.8616;
}


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.8639;
  struct MonoException * D.8644;
  int D.8645;
  unsigned char D.8646;
  sizetype D.8647;
  const void * D.8648;
  int D.8649;
  long unsigned int D.8650;
  long int D.8651;
  int * D.8655;
  int D.8656;
  struct MonoException * D.8659;
  sizetype D.8660;
  guchar * D.8661;
  unsigned char D.8662;
  int D.8663;
  int D.8664;
  long unsigned int D.8665;
  long int D.8666;
  unsigned int received.8;
  struct MonoException * D.8674;
  int D.8675;
  int file;
  gint ret;
  guint offset;
  struct sockaddr_un egd_addr;

  try
    {
      offset = 0;
      file = socket (1, 1, 0);
      if (file < 0) goto <D.8636>; else goto <D.8637>;
      <D.8636>:
      ret = -1;
      goto <D.8638>;
      <D.8637>:
      egd_addr.sun_family = 1;
      strncpy (&egd_addr.sun_path, path, 18446744073709551615);
      egd_addr.sun_path[-1] = 0;
      D.8639.__sockaddr__ = &egd_addr;
      ret = connect (file, D.8639, 110);
      <D.8638>:
      if (ret == -1) goto <D.8640>; else goto <D.8641>;
      <D.8640>:
      if (file >= 0) goto <D.8642>; else goto <D.8643>;
      <D.8642>:
      close (file);
      <D.8643>:
      monoeg_g_log (0B, 16, "Entropy problem! Can\'t create or connect to egd socket %s", path);
      D.8644 = mono_get_exception_execution_engine ("Failed to open egd socket");
      mono_raise_exception (D.8644);
      <D.8641>:
      goto <D.8537>;
      <D.8536>:
      {
        guchar request[2];
        gint count;

        try
          {
            count = 0;
            request[0] = 2;
            D.8645 = MIN_EXPR <len, 255>;
            D.8646 = (unsigned char) D.8645;
            request[1] = D.8646;
            goto <D.8529>;
            <D.8530>:
            {
              int sent;

              D.8647 = (sizetype) count;
              D.8648 = &request + D.8647;
              D.8649 = 2 - count;
              D.8650 = (long unsigned int) D.8649;
              D.8651 = write (file, D.8648, D.8650);
              sent = (int) D.8651;
              if (sent >= 0) goto <D.8652>; else goto <D.8653>;
              <D.8652>:
              count = count + sent;
              goto <D.8654>;
              <D.8653>:
              D.8655 = __errno_location ();
              D.8656 = *D.8655;
              if (D.8656 == 4) goto <D.8657>; else goto <D.8658>;
              <D.8657>:
              // predicted unlikely by continue predictor.
              goto <D.8529>;
              <D.8658>:
              close (file);
              D.8655 = __errno_location ();
              D.8656 = *D.8655;
              monoeg_g_log (0B, 16, "Send egd request failed %d", D.8656);
              D.8659 = mono_get_exception_execution_engine ("Failed to send request to egd socket");
              mono_raise_exception (D.8659);
              <D.8654>:
            }
            <D.8529>:
            if (count <= 1) goto <D.8530>; else goto <D.8531>;
            <D.8531>:
            count = 0;
            goto <D.8533>;
            <D.8534>:
            {
              int received;

              D.8660 = (sizetype) offset;
              D.8661 = buf + D.8660;
              D.8662 = request[1];
              D.8663 = (int) D.8662;
              D.8664 = D.8663 - count;
              D.8665 = (long unsigned int) D.8664;
              D.8666 = read (file, D.8661, D.8665);
              received = (int) D.8666;
              if (received > 0) goto <D.8667>; else goto <D.8668>;
              <D.8667>:
              count = count + received;
              received.8 = (unsigned int) received;
              offset = offset + received.8;
              goto <D.8670>;
              <D.8668>:
              if (received < 0) goto <D.8672>; else goto <D.8671>;
              <D.8672>:
              D.8655 = __errno_location ();
              D.8656 = *D.8655;
              if (D.8656 == 4) goto <D.8673>; else goto <D.8671>;
              <D.8673>:
              // predicted unlikely by continue predictor.
              goto <D.8533>;
              <D.8671>:
              close (file);
              D.8655 = __errno_location ();
              D.8656 = *D.8655;
              monoeg_g_log (0B, 16, "Receive egd request failed %d", D.8656);
              D.8674 = mono_get_exception_execution_engine ("Failed to get response from egd socket");
              mono_raise_exception (D.8674);
              <D.8670>:
            }
            <D.8533>:
            D.8662 = request[1];
            D.8675 = (int) D.8662;
            if (D.8675 != count) goto <D.8534>; else goto <D.8535>;
            <D.8535>:
            D.8662 = request[1];
            D.8675 = (int) D.8662;
            len = len - D.8675;
          }
        finally
          {
            request = {CLOBBER};
          }
      }
      <D.8537>:
      if (len > 0) goto <D.8536>; else goto <D.8538>;
      <D.8538>:
      close (file);
    }
  finally
    {
      egd_addr = {CLOBBER};
    }
}


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

  D.8677 = __builtin_object_size (__dest, 1);
  D.8676 = __builtin___strncpy_chk (__dest, __src, __len, D.8677);
  return D.8676;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.8679;
  int D.8682;
  ssize_t D.8685;
  long unsigned int D.8686;
  long unsigned int D.8687;
  long unsigned int D.8690;

  D.8679 = __builtin_object_size (__buf, 0);
  if (D.8679 != 18446744073709551615) goto <D.8680>; else goto <D.8681>;
  <D.8680>:
  D.8682 = __builtin_constant_p (__nbytes);
  if (D.8682 == 0) goto <D.8683>; else goto <D.8684>;
  <D.8683>:
  D.8686 = __builtin_object_size (__buf, 0);
  D.8685 = __read_chk (__fd, __buf, __nbytes, D.8686);
  return D.8685;
  <D.8684>:
  D.8687 = __builtin_object_size (__buf, 0);
  if (D.8687 < __nbytes) goto <D.8688>; else goto <D.8689>;
  <D.8688>:
  D.8690 = __builtin_object_size (__buf, 0);
  D.8685 = __read_chk_warn (__fd, __buf, __nbytes, D.8690);
  return D.8685;
  <D.8689>:
  <D.8681>:
  D.8685 = __read_alias (__fd, __buf, __nbytes);
  return D.8685;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngClose (void * handle)
{

}