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

  egd.0 = egd;
  if (egd.0 != 0) goto <D.8069>; else goto <D.8072>;
  <D.8072>:
  file.1 = file;
  if (file.1 >= 0) goto <D.8069>; else goto <D.8070>;
  <D.8069>:
  D.8074 = 1;
  return D.8074;
  <D.8070>:
  file.2 = open ("/dev/urandom", 0);
  file = file.2;
  file.1 = file;
  if (file.1 < 0) goto <D.8076>; else goto <D.8077>;
  <D.8076>:
  file.3 = open ("/dev/random", 0);
  file = file.3;
  <D.8077>:
  file.1 = file;
  if (file.1 < 0) goto <D.8079>; else goto <D.8080>;
  <D.8079>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    D.8081 = socket_path != 0B;
    egd.4 = (int) D.8081;
    egd = egd.4;
  }
  <D.8080>:
  D.8074 = 1;
  return D.8074;
}


open (const char * __path, int __oflag)
{
  int D.8084;
  int D.8087;
  int D.8092;
  int D.8094;
  int D.8095;
  int D.8098;
  int D.8099;

  D.8084 = __builtin_va_arg_pack_len ();
  if (D.8084 > 1) goto <D.8085>; else goto <D.8086>;
  <D.8085>:
  __open_too_many_args ();
  <D.8086>:
  D.8087 = __builtin_constant_p (__oflag);
  if (D.8087 != 0) goto <D.8088>; else goto <D.8089>;
  <D.8088>:
  D.8092 = __oflag & 256;
  if (D.8092 != 0) goto <D.8090>; else goto <D.8093>;
  <D.8093>:
  D.8094 = __oflag & 4259840;
  if (D.8094 == 4259840) goto <D.8090>; else goto <D.8091>;
  <D.8090>:
  D.8095 = __builtin_va_arg_pack_len ();
  if (D.8095 <= 0) goto <D.8096>; else goto <D.8097>;
  <D.8096>:
  __open_missing_mode ();
  D.8098 = __open_2 (__path, __oflag);
  return D.8098;
  <D.8097>:
  <D.8091>:
  D.8098 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8098;
  <D.8089>:
  D.8099 = __builtin_va_arg_pack_len ();
  if (D.8099 <= 0) goto <D.8100>; else goto <D.8101>;
  <D.8100>:
  D.8098 = __open_2 (__path, __oflag);
  return D.8098;
  <D.8101>:
  D.8098 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8098;
}


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

  egd.6 = egd;
  if (egd.6 != 0) goto <D.8105>; else goto <D.8109>;
  <D.8109>:
  file.7 = file;
  if (file.7 >= 0) goto <D.8105>; else goto <D.8106>;
  <D.8105>:
  file.7 = file;
  iftmp.5 = (void *) file.7;
  goto <D.8107>;
  <D.8106>:
  iftmp.5 = 0B;
  <D.8107>:
  D.8103 = iftmp.5;
  return D.8103;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (void * handle, struct MonoArray * arry)
{
  int egd.8;
  void * D.8117;
  char * D.8118;
  unsigned int D.8119;
  int D.8120;
  sizetype count.9;
  void * D.8122;
  unsigned int count.10;
  unsigned int D.8124;
  int * D.8127;
  int D.8128;
  char * D.8133;
  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.8113>; else goto <D.8114>;
  <D.8113>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    if (socket_path == 0B) goto <D.8115>; else goto <D.8116>;
    <D.8115>:
    D.8117 = 0B;
    return D.8117;
    <D.8116>:
    D.8118 = mono_array_addr_with_size (arry, 1, 0);
    D.8119 = mono_array_length (arry);
    D.8120 = (int) D.8119;
    get_entropy_from_server (socket_path, D.8118, D.8120);
    D.8117 = 4294967295B;
    return D.8117;
  }
  <D.8114>:
  {
    gint count;
    gint err;

    count = 0;
    <D.8064>:
    count.9 = (sizetype) count;
    D.8122 = buf + count.9;
    count.10 = (unsigned int) count;
    D.8124 = len - count.10;
    err = read (file, D.8122, D.8124);
    if (err < 0) goto <D.8125>; else goto <D.8126>;
    <D.8125>:
    D.8127 = __errno_location ();
    D.8128 = *D.8127;
    if (D.8128 == 4) goto <D.8129>; else goto <D.8130>;
    <D.8129>:
    // predicted unlikely by continue predictor.
    goto <D.8062>;
    <D.8130>:
    goto <D.8063>;
    <D.8126>:
    count = count + err;
    <D.8062>:
    count.10 = (unsigned int) count;
    if (count.10 < len) goto <D.8064>; else goto <D.8063>;
    <D.8063>:
    if (err < 0) goto <D.8131>; else goto <D.8132>;
    <D.8131>:
    D.8127 = __errno_location ();
    D.8128 = *D.8127;
    D.8133 = strerror (D.8128);
    monoeg_g_log (0B, 16, "Entropy error! Error in read (%s).", D.8133);
    D.8117 = 0B;
    return D.8117;
    <D.8132>:
  }
  D.8117 = handle;
  return D.8117;
}


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.8138;
  struct MonoException * D.8143;
  int D.8144;
  unsigned char D.8145;
  sizetype count.11;
  const void * D.8147;
  int D.8148;
  unsigned int D.8149;
  int * D.8153;
  int D.8154;
  struct MonoException * D.8157;
  void * D.8158;
  unsigned char D.8159;
  int D.8160;
  int D.8161;
  unsigned int D.8162;
  unsigned int received.12;
  struct MonoException * D.8170;
  int D.8171;
  int file;
  gint ret;
  guint offset;
  struct sockaddr_un egd_addr;

  try
    {
      offset = 0;
      file = socket (1, 2, 0);
      if (file < 0) goto <D.8135>; else goto <D.8136>;
      <D.8135>:
      ret = -1;
      goto <D.8137>;
      <D.8136>:
      egd_addr.sun_family = 1;
      strncpy (&egd_addr.sun_path, path, 4294967295);
      egd_addr.sun_path[-1] = 0;
      D.8138.__sockaddr__ = &egd_addr;
      ret = connect (file, D.8138, 110);
      <D.8137>:
      if (ret == -1) goto <D.8139>; else goto <D.8140>;
      <D.8139>:
      if (file >= 0) goto <D.8141>; else goto <D.8142>;
      <D.8141>:
      close (file);
      <D.8142>:
      monoeg_g_log (0B, 16, "Entropy problem! Can\'t create or connect to egd socket %s", path);
      D.8143 = mono_get_exception_execution_engine ("Failed to open egd socket");
      mono_raise_exception (D.8143);
      <D.8140>:
      goto <D.8041>;
      <D.8040>:
      {
        guchar request[2];
        gint count;

        try
          {
            count = 0;
            request[0] = 2;
            D.8144 = MIN_EXPR <len, 255>;
            D.8145 = (unsigned char) D.8144;
            request[1] = D.8145;
            goto <D.8033>;
            <D.8034>:
            {
              int sent;

              count.11 = (sizetype) count;
              D.8147 = &request + count.11;
              D.8148 = 2 - count;
              D.8149 = (unsigned int) D.8148;
              sent = write (file, D.8147, D.8149);
              if (sent >= 0) goto <D.8150>; else goto <D.8151>;
              <D.8150>:
              count = count + sent;
              goto <D.8152>;
              <D.8151>:
              D.8153 = __errno_location ();
              D.8154 = *D.8153;
              if (D.8154 == 4) goto <D.8155>; else goto <D.8156>;
              <D.8155>:
              // predicted unlikely by continue predictor.
              goto <D.8033>;
              <D.8156>:
              close (file);
              D.8153 = __errno_location ();
              D.8154 = *D.8153;
              monoeg_g_log (0B, 16, "Send egd request failed %d", D.8154);
              D.8157 = mono_get_exception_execution_engine ("Failed to send request to egd socket");
              mono_raise_exception (D.8157);
              <D.8152>:
            }
            <D.8033>:
            if (count <= 1) goto <D.8034>; else goto <D.8035>;
            <D.8035>:
            count = 0;
            goto <D.8037>;
            <D.8038>:
            {
              int received;

              D.8158 = buf + offset;
              D.8159 = request[1];
              D.8160 = (int) D.8159;
              D.8161 = D.8160 - count;
              D.8162 = (unsigned int) D.8161;
              received = read (file, D.8158, D.8162);
              if (received > 0) goto <D.8163>; else goto <D.8164>;
              <D.8163>:
              count = count + received;
              received.12 = (unsigned int) received;
              offset = offset + received.12;
              goto <D.8166>;
              <D.8164>:
              if (received < 0) goto <D.8168>; else goto <D.8167>;
              <D.8168>:
              D.8153 = __errno_location ();
              D.8154 = *D.8153;
              if (D.8154 == 4) goto <D.8169>; else goto <D.8167>;
              <D.8169>:
              // predicted unlikely by continue predictor.
              goto <D.8037>;
              <D.8167>:
              close (file);
              D.8153 = __errno_location ();
              D.8154 = *D.8153;
              monoeg_g_log (0B, 16, "Receive egd request failed %d", D.8154);
              D.8170 = mono_get_exception_execution_engine ("Failed to get response from egd socket");
              mono_raise_exception (D.8170);
              <D.8166>:
            }
            <D.8037>:
            D.8159 = request[1];
            D.8171 = (int) D.8159;
            if (D.8171 != count) goto <D.8038>; else goto <D.8039>;
            <D.8039>:
            D.8159 = request[1];
            D.8171 = (int) D.8159;
            len = len - D.8171;
          }
        finally
          {
            request = {CLOBBER};
          }
      }
      <D.8041>:
      if (len > 0) goto <D.8040>; else goto <D.8042>;
      <D.8042>:
      close (file);
    }
  finally
    {
      egd_addr = {CLOBBER};
    }
}


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

  D.8173 = __builtin_object_size (__dest, 1);
  D.8172 = __builtin___strncpy_chk (__dest, __src, __len, D.8173);
  return D.8172;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.8175;
  int D.8178;
  ssize_t D.8181;
  unsigned int D.8182;
  unsigned int D.8183;
  unsigned int D.8186;

  D.8175 = __builtin_object_size (__buf, 0);
  if (D.8175 != 4294967295) goto <D.8176>; else goto <D.8177>;
  <D.8176>:
  D.8178 = __builtin_constant_p (__nbytes);
  if (D.8178 == 0) goto <D.8179>; else goto <D.8180>;
  <D.8179>:
  D.8182 = __builtin_object_size (__buf, 0);
  D.8181 = __read_chk (__fd, __buf, __nbytes, D.8182);
  return D.8181;
  <D.8180>:
  D.8183 = __builtin_object_size (__buf, 0);
  if (D.8183 < __nbytes) goto <D.8184>; else goto <D.8185>;
  <D.8184>:
  D.8186 = __builtin_object_size (__buf, 0);
  D.8181 = __read_chk_warn (__fd, __buf, __nbytes, D.8186);
  return D.8181;
  <D.8185>:
  <D.8177>:
  D.8181 = __read_alias (__fd, __buf, __nbytes);
  return D.8181;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngClose (void * handle)
{

}