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

  egd.0 = egd;
  if (egd.0 != 0) goto <D.8046>; else goto <D.8049>;
  <D.8049>:
  file.1 = file;
  if (file.1 >= 0) goto <D.8046>; else goto <D.8047>;
  <D.8046>:
  D.8051 = 1;
  return D.8051;
  <D.8047>:
  file.2 = open ("/dev/urandom", 0);
  file = file.2;
  file.1 = file;
  if (file.1 < 0) goto <D.8053>; else goto <D.8054>;
  <D.8053>:
  file.3 = open ("/dev/random", 0);
  file = file.3;
  <D.8054>:
  file.1 = file;
  if (file.1 < 0) goto <D.8056>; else goto <D.8057>;
  <D.8056>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    D.8058 = socket_path != 0B;
    egd.4 = (int) D.8058;
    egd = egd.4;
  }
  <D.8057>:
  D.8051 = 1;
  return D.8051;
}


open (const char * __path, int __oflag)
{
  int D.8061;
  int D.8064;
  int D.8069;
  int D.8071;
  int D.8072;
  int D.8075;
  int D.8076;

  D.8061 = __builtin_va_arg_pack_len ();
  if (D.8061 > 1) goto <D.8062>; else goto <D.8063>;
  <D.8062>:
  __open_too_many_args ();
  <D.8063>:
  D.8064 = __builtin_constant_p (__oflag);
  if (D.8064 != 0) goto <D.8065>; else goto <D.8066>;
  <D.8065>:
  D.8069 = __oflag & 64;
  if (D.8069 != 0) goto <D.8067>; else goto <D.8070>;
  <D.8070>:
  D.8071 = __oflag & 4259840;
  if (D.8071 == 4259840) goto <D.8067>; else goto <D.8068>;
  <D.8067>:
  D.8072 = __builtin_va_arg_pack_len ();
  if (D.8072 <= 0) goto <D.8073>; else goto <D.8074>;
  <D.8073>:
  __open_missing_mode ();
  D.8075 = __open_2 (__path, __oflag);
  return D.8075;
  <D.8074>:
  <D.8068>:
  D.8075 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8075;
  <D.8066>:
  D.8076 = __builtin_va_arg_pack_len ();
  if (D.8076 <= 0) goto <D.8077>; else goto <D.8078>;
  <D.8077>:
  D.8075 = __open_2 (__path, __oflag);
  return D.8075;
  <D.8078>:
  D.8075 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8075;
}


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

  egd.6 = egd;
  if (egd.6 != 0) goto <D.8082>; else goto <D.8086>;
  <D.8086>:
  file.7 = file;
  if (file.7 >= 0) goto <D.8082>; else goto <D.8083>;
  <D.8082>:
  file.7 = file;
  iftmp.5 = (void *) file.7;
  goto <D.8084>;
  <D.8083>:
  iftmp.5 = 0B;
  <D.8084>:
  D.8080 = iftmp.5;
  return D.8080;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (void * handle, struct MonoArray * arry)
{
  int egd.8;
  void * D.8094;
  unsigned int D.8095;
  int D.8096;
  char * D.8097;
  unsigned int count.9;
  unsigned int D.8099;
  sizetype count.10;
  void * D.8101;
  int * D.8104;
  int D.8105;
  char * D.8110;
  gint file;
  guint32 len;
  guchar * buf;

  file = (gint) handle;
  len = mono_array_length (arry);
  buf = mono_array_addr_with_size (arry, 1, 0);
  egd.8 = egd;
  if (egd.8 != 0) goto <D.8090>; else goto <D.8091>;
  <D.8090>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    if (socket_path == 0B) goto <D.8092>; else goto <D.8093>;
    <D.8092>:
    D.8094 = 0B;
    return D.8094;
    <D.8093>:
    D.8095 = mono_array_length (arry);
    D.8096 = (int) D.8095;
    D.8097 = mono_array_addr_with_size (arry, 1, 0);
    get_entropy_from_server (socket_path, D.8097, D.8096);
    D.8094 = 4294967295B;
    return D.8094;
  }
  <D.8091>:
  {
    gint count;
    gint err;

    count = 0;
    <D.8041>:
    count.9 = (unsigned int) count;
    D.8099 = len - count.9;
    count.10 = (sizetype) count;
    D.8101 = buf + count.10;
    err = read (file, D.8101, D.8099);
    if (err < 0) goto <D.8102>; else goto <D.8103>;
    <D.8102>:
    D.8104 = __errno_location ();
    D.8105 = *D.8104;
    if (D.8105 == 4) goto <D.8106>; else goto <D.8107>;
    <D.8106>:
    // predicted unlikely by continue predictor.
    goto <D.8039>;
    <D.8107>:
    goto <D.8040>;
    <D.8103>:
    count = count + err;
    <D.8039>:
    count.9 = (unsigned int) count;
    if (count.9 < len) goto <D.8041>; else goto <D.8040>;
    <D.8040>:
    if (err < 0) goto <D.8108>; else goto <D.8109>;
    <D.8108>:
    D.8104 = __errno_location ();
    D.8105 = *D.8104;
    D.8110 = strerror (D.8105);
    monoeg_g_log (0B, 16, "Entropy error! Error in read (%s).", D.8110);
    D.8094 = 0B;
    return D.8094;
    <D.8109>:
  }
  D.8094 = handle;
  return D.8094;
}


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.8115;
  struct MonoException * D.8120;
  int D.8121;
  unsigned char D.8122;
  int D.8123;
  unsigned int D.8124;
  sizetype count.11;
  const void * D.8126;
  int * D.8130;
  int D.8131;
  struct MonoException * D.8134;
  unsigned char D.8135;
  int D.8136;
  int D.8137;
  unsigned int D.8138;
  void * D.8139;
  unsigned int received.12;
  struct MonoException * D.8147;
  int D.8148;
  int file;
  gint ret;
  guint offset;
  struct sockaddr_un egd_addr;

  try
    {
      offset = 0;
      file = socket (1, 1, 0);
      if (file < 0) goto <D.8112>; else goto <D.8113>;
      <D.8112>:
      ret = -1;
      goto <D.8114>;
      <D.8113>:
      egd_addr.sun_family = 1;
      strncpy (&egd_addr.sun_path, path, 4294967295);
      egd_addr.sun_path[-1] = 0;
      D.8115.__sockaddr__ = &egd_addr;
      ret = connect (file, D.8115, 110);
      <D.8114>:
      if (ret == -1) goto <D.8116>; else goto <D.8117>;
      <D.8116>:
      if (file >= 0) goto <D.8118>; else goto <D.8119>;
      <D.8118>:
      close (file);
      <D.8119>:
      monoeg_g_log (0B, 16, "Entropy problem! Can\'t create or connect to egd socket %s", path);
      D.8120 = mono_get_exception_execution_engine ("Failed to open egd socket");
      mono_raise_exception (D.8120);
      <D.8117>:
      goto <D.8018>;
      <D.8017>:
      {
        guchar request[2];
        gint count;

        try
          {
            count = 0;
            request[0] = 2;
            D.8121 = MIN_EXPR <len, 255>;
            D.8122 = (unsigned char) D.8121;
            request[1] = D.8122;
            goto <D.8010>;
            <D.8011>:
            {
              int sent;

              D.8123 = 2 - count;
              D.8124 = (unsigned int) D.8123;
              count.11 = (sizetype) count;
              D.8126 = &request + count.11;
              sent = write (file, D.8126, D.8124);
              if (sent >= 0) goto <D.8127>; else goto <D.8128>;
              <D.8127>:
              count = count + sent;
              goto <D.8129>;
              <D.8128>:
              D.8130 = __errno_location ();
              D.8131 = *D.8130;
              if (D.8131 == 4) goto <D.8132>; else goto <D.8133>;
              <D.8132>:
              // predicted unlikely by continue predictor.
              goto <D.8010>;
              <D.8133>:
              close (file);
              D.8130 = __errno_location ();
              D.8131 = *D.8130;
              monoeg_g_log (0B, 16, "Send egd request failed %d", D.8131);
              D.8134 = mono_get_exception_execution_engine ("Failed to send request to egd socket");
              mono_raise_exception (D.8134);
              <D.8129>:
            }
            <D.8010>:
            if (count <= 1) goto <D.8011>; else goto <D.8012>;
            <D.8012>:
            count = 0;
            goto <D.8014>;
            <D.8015>:
            {
              int received;

              D.8135 = request[1];
              D.8136 = (int) D.8135;
              D.8137 = D.8136 - count;
              D.8138 = (unsigned int) D.8137;
              D.8139 = buf + offset;
              received = read (file, D.8139, D.8138);
              if (received > 0) goto <D.8140>; else goto <D.8141>;
              <D.8140>:
              count = count + received;
              received.12 = (unsigned int) received;
              offset = offset + received.12;
              goto <D.8143>;
              <D.8141>:
              if (received < 0) goto <D.8145>; else goto <D.8144>;
              <D.8145>:
              D.8130 = __errno_location ();
              D.8131 = *D.8130;
              if (D.8131 == 4) goto <D.8146>; else goto <D.8144>;
              <D.8146>:
              // predicted unlikely by continue predictor.
              goto <D.8014>;
              <D.8144>:
              close (file);
              D.8130 = __errno_location ();
              D.8131 = *D.8130;
              monoeg_g_log (0B, 16, "Receive egd request failed %d", D.8131);
              D.8147 = mono_get_exception_execution_engine ("Failed to get response from egd socket");
              mono_raise_exception (D.8147);
              <D.8143>:
            }
            <D.8014>:
            D.8135 = request[1];
            D.8148 = (int) D.8135;
            if (D.8148 != count) goto <D.8015>; else goto <D.8016>;
            <D.8016>:
            D.8135 = request[1];
            D.8148 = (int) D.8135;
            len = len - D.8148;
          }
        finally
          {
            request = {CLOBBER};
          }
      }
      <D.8018>:
      if (len > 0) goto <D.8017>; else goto <D.8019>;
      <D.8019>:
      close (file);
    }
  finally
    {
      egd_addr = {CLOBBER};
    }
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.8149;
  unsigned int D.8150;

  D.8150 = __builtin_object_size (__dest, 1);
  D.8149 = __builtin___strncpy_chk (__dest, __src, __len, D.8150);
  return D.8149;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.8152;
  int D.8155;
  ssize_t D.8158;
  unsigned int D.8159;
  unsigned int D.8160;
  unsigned int D.8163;

  D.8152 = __builtin_object_size (__buf, 0);
  if (D.8152 != 4294967295) goto <D.8153>; else goto <D.8154>;
  <D.8153>:
  D.8155 = __builtin_constant_p (__nbytes);
  if (D.8155 == 0) goto <D.8156>; else goto <D.8157>;
  <D.8156>:
  D.8159 = __builtin_object_size (__buf, 0);
  D.8158 = __read_chk (__fd, __buf, __nbytes, D.8159);
  return D.8158;
  <D.8157>:
  D.8160 = __builtin_object_size (__buf, 0);
  if (D.8160 < __nbytes) goto <D.8161>; else goto <D.8162>;
  <D.8161>:
  D.8163 = __builtin_object_size (__buf, 0);
  D.8158 = __read_chk_warn (__fd, __buf, __nbytes, D.8163);
  return D.8158;
  <D.8162>:
  <D.8154>:
  D.8158 = __read_alias (__fd, __buf, __nbytes);
  return D.8158;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngClose (void * handle)
{

}