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

  egd.0 = egd;
  if (egd.0 != 0) goto <D.8912>; else goto <D.8915>;
  <D.8915>:
  file.1 = file;
  if (file.1 >= 0) goto <D.8912>; else goto <D.8913>;
  <D.8912>:
  D.8917 = 1;
  return D.8917;
  <D.8913>:
  file.2 = open ("/dev/urandom", 0);
  file = file.2;
  file.1 = file;
  if (file.1 < 0) goto <D.8919>; else goto <D.8920>;
  <D.8919>:
  file.3 = open ("/dev/random", 0);
  file = file.3;
  <D.8920>:
  file.1 = file;
  if (file.1 < 0) goto <D.8922>; else goto <D.8923>;
  <D.8922>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    D.8924 = socket_path != 0B;
    egd.4 = (int) D.8924;
    egd = egd.4;
  }
  <D.8923>:
  D.8917 = 1;
  return D.8917;
}


open (const char * __path, int __oflag)
{
  int D.8927;
  int D.8930;
  int D.8935;
  int D.8937;
  int D.8938;
  int D.8941;
  int D.8942;

  D.8927 = __builtin_va_arg_pack_len ();
  if (D.8927 > 1) goto <D.8928>; else goto <D.8929>;
  <D.8928>:
  __open_too_many_args ();
  <D.8929>:
  D.8930 = __builtin_constant_p (__oflag);
  if (D.8930 != 0) goto <D.8931>; else goto <D.8932>;
  <D.8931>:
  D.8935 = __oflag & 64;
  if (D.8935 != 0) goto <D.8933>; else goto <D.8936>;
  <D.8936>:
  D.8937 = __oflag & 4259840;
  if (D.8937 == 4259840) goto <D.8933>; else goto <D.8934>;
  <D.8933>:
  D.8938 = __builtin_va_arg_pack_len ();
  if (D.8938 <= 0) goto <D.8939>; else goto <D.8940>;
  <D.8939>:
  __open_missing_mode ();
  D.8941 = __open_2 (__path, __oflag);
  return D.8941;
  <D.8940>:
  <D.8934>:
  D.8941 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8941;
  <D.8932>:
  D.8942 = __builtin_va_arg_pack_len ();
  if (D.8942 <= 0) goto <D.8943>; else goto <D.8944>;
  <D.8943>:
  D.8941 = __open_2 (__path, __oflag);
  return D.8941;
  <D.8944>:
  D.8941 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8941;
}


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

  egd.6 = egd;
  if (egd.6 != 0) goto <D.8948>; else goto <D.8952>;
  <D.8952>:
  file.7 = file;
  if (file.7 >= 0) goto <D.8948>; else goto <D.8949>;
  <D.8948>:
  file.7 = file;
  D.8954 = (long int) file.7;
  iftmp.5 = (void *) D.8954;
  goto <D.8950>;
  <D.8949>:
  iftmp.5 = 0B;
  <D.8950>:
  D.8946 = iftmp.5;
  return D.8946;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (void * handle, struct MonoArray * arry)
{
  long int handle.8;
  long unsigned int D.8957;
  int egd.9;
  void * D.8963;
  char * D.8964;
  long unsigned int D.8965;
  int D.8966;
  sizetype D.8967;
  void * D.8968;
  unsigned int count.10;
  unsigned int D.8970;
  long unsigned int D.8971;
  long int D.8972;
  int * D.8975;
  int D.8976;
  char * D.8981;
  gint file;
  guint32 len;
  guchar * buf;

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

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    if (socket_path == 0B) goto <D.8961>; else goto <D.8962>;
    <D.8961>:
    D.8963 = 0B;
    return D.8963;
    <D.8962>:
    D.8964 = mono_array_addr_with_size (arry, 1, 0);
    D.8965 = mono_array_length (arry);
    D.8966 = (int) D.8965;
    get_entropy_from_server (socket_path, D.8964, D.8966);
    D.8963 = -1B;
    return D.8963;
  }
  <D.8960>:
  {
    gint count;
    gint err;

    count = 0;
    <D.8907>:
    D.8967 = (sizetype) count;
    D.8968 = buf + D.8967;
    count.10 = (unsigned int) count;
    D.8970 = len - count.10;
    D.8971 = (long unsigned int) D.8970;
    D.8972 = read (file, D.8968, D.8971);
    err = (gint) D.8972;
    if (err < 0) goto <D.8973>; else goto <D.8974>;
    <D.8973>:
    D.8975 = __errno_location ();
    D.8976 = *D.8975;
    if (D.8976 == 4) goto <D.8977>; else goto <D.8978>;
    <D.8977>:
    // predicted unlikely by continue predictor.
    goto <D.8905>;
    <D.8978>:
    goto <D.8906>;
    <D.8974>:
    count = count + err;
    <D.8905>:
    count.10 = (unsigned int) count;
    if (count.10 < len) goto <D.8907>; else goto <D.8906>;
    <D.8906>:
    if (err < 0) goto <D.8979>; else goto <D.8980>;
    <D.8979>:
    D.8975 = __errno_location ();
    D.8976 = *D.8975;
    D.8981 = strerror (D.8976);
    monoeg_g_log (0B, 16, "Entropy error! Error in read (%s).", D.8981);
    D.8963 = 0B;
    return D.8963;
    <D.8980>:
  }
  D.8963 = handle;
  return D.8963;
}


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.8986;
  struct MonoException * D.8991;
  int D.8992;
  unsigned char D.8993;
  sizetype D.8994;
  const void * D.8995;
  int D.8996;
  long unsigned int D.8997;
  long int D.8998;
  int * D.9002;
  int D.9003;
  struct MonoException * D.9006;
  sizetype D.9007;
  void * D.9008;
  unsigned char D.9009;
  int D.9010;
  int D.9011;
  long unsigned int D.9012;
  long int D.9013;
  unsigned int received.11;
  struct MonoException * D.9021;
  int D.9022;
  int file;
  gint ret;
  guint offset;
  struct sockaddr_un egd_addr;

  try
    {
      offset = 0;
      file = socket (1, 1, 0);
      if (file < 0) goto <D.8983>; else goto <D.8984>;
      <D.8983>:
      ret = -1;
      goto <D.8985>;
      <D.8984>:
      egd_addr.sun_family = 1;
      strncpy (&egd_addr.sun_path, path, 18446744073709551615);
      egd_addr.sun_path[-1] = 0;
      D.8986.__sockaddr__ = &egd_addr;
      ret = connect (file, D.8986, 110);
      <D.8985>:
      if (ret == -1) goto <D.8987>; else goto <D.8988>;
      <D.8987>:
      if (file >= 0) goto <D.8989>; else goto <D.8990>;
      <D.8989>:
      close (file);
      <D.8990>:
      monoeg_g_log (0B, 16, "Entropy problem! Can\'t create or connect to egd socket %s", path);
      D.8991 = mono_get_exception_execution_engine ("Failed to open egd socket");
      mono_raise_exception (D.8991);
      <D.8988>:
      goto <D.8884>;
      <D.8883>:
      {
        guchar request[2];
        gint count;

        try
          {
            count = 0;
            request[0] = 2;
            D.8992 = MIN_EXPR <len, 255>;
            D.8993 = (unsigned char) D.8992;
            request[1] = D.8993;
            goto <D.8876>;
            <D.8877>:
            {
              int sent;

              D.8994 = (sizetype) count;
              D.8995 = &request + D.8994;
              D.8996 = 2 - count;
              D.8997 = (long unsigned int) D.8996;
              D.8998 = write (file, D.8995, D.8997);
              sent = (int) D.8998;
              if (sent >= 0) goto <D.8999>; else goto <D.9000>;
              <D.8999>:
              count = count + sent;
              goto <D.9001>;
              <D.9000>:
              D.9002 = __errno_location ();
              D.9003 = *D.9002;
              if (D.9003 == 4) goto <D.9004>; else goto <D.9005>;
              <D.9004>:
              // predicted unlikely by continue predictor.
              goto <D.8876>;
              <D.9005>:
              close (file);
              D.9002 = __errno_location ();
              D.9003 = *D.9002;
              monoeg_g_log (0B, 16, "Send egd request failed %d", D.9003);
              D.9006 = mono_get_exception_execution_engine ("Failed to send request to egd socket");
              mono_raise_exception (D.9006);
              <D.9001>:
            }
            <D.8876>:
            if (count <= 1) goto <D.8877>; else goto <D.8878>;
            <D.8878>:
            count = 0;
            goto <D.8880>;
            <D.8881>:
            {
              int received;

              D.9007 = (sizetype) offset;
              D.9008 = buf + D.9007;
              D.9009 = request[1];
              D.9010 = (int) D.9009;
              D.9011 = D.9010 - count;
              D.9012 = (long unsigned int) D.9011;
              D.9013 = read (file, D.9008, D.9012);
              received = (int) D.9013;
              if (received > 0) goto <D.9014>; else goto <D.9015>;
              <D.9014>:
              count = count + received;
              received.11 = (unsigned int) received;
              offset = offset + received.11;
              goto <D.9017>;
              <D.9015>:
              if (received < 0) goto <D.9019>; else goto <D.9018>;
              <D.9019>:
              D.9002 = __errno_location ();
              D.9003 = *D.9002;
              if (D.9003 == 4) goto <D.9020>; else goto <D.9018>;
              <D.9020>:
              // predicted unlikely by continue predictor.
              goto <D.8880>;
              <D.9018>:
              close (file);
              D.9002 = __errno_location ();
              D.9003 = *D.9002;
              monoeg_g_log (0B, 16, "Receive egd request failed %d", D.9003);
              D.9021 = mono_get_exception_execution_engine ("Failed to get response from egd socket");
              mono_raise_exception (D.9021);
              <D.9017>:
            }
            <D.8880>:
            D.9009 = request[1];
            D.9022 = (int) D.9009;
            if (D.9022 != count) goto <D.8881>; else goto <D.8882>;
            <D.8882>:
            D.9009 = request[1];
            D.9022 = (int) D.9009;
            len = len - D.9022;
          }
        finally
          {
            request = {CLOBBER};
          }
      }
      <D.8884>:
      if (len > 0) goto <D.8883>; else goto <D.8885>;
      <D.8885>:
      close (file);
    }
  finally
    {
      egd_addr = {CLOBBER};
    }
}


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

  D.9024 = __builtin_object_size (__dest, 1);
  D.9023 = __builtin___strncpy_chk (__dest, __src, __len, D.9024);
  return D.9023;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.9026;
  int D.9029;
  ssize_t D.9032;
  long unsigned int D.9033;
  long unsigned int D.9034;
  long unsigned int D.9037;

  D.9026 = __builtin_object_size (__buf, 0);
  if (D.9026 != 18446744073709551615) goto <D.9027>; else goto <D.9028>;
  <D.9027>:
  D.9029 = __builtin_constant_p (__nbytes);
  if (D.9029 == 0) goto <D.9030>; else goto <D.9031>;
  <D.9030>:
  D.9033 = __builtin_object_size (__buf, 0);
  D.9032 = __read_chk (__fd, __buf, __nbytes, D.9033);
  return D.9032;
  <D.9031>:
  D.9034 = __builtin_object_size (__buf, 0);
  if (D.9034 < __nbytes) goto <D.9035>; else goto <D.9036>;
  <D.9035>:
  D.9037 = __builtin_object_size (__buf, 0);
  D.9032 = __read_chk_warn (__fd, __buf, __nbytes, D.9037);
  return D.9032;
  <D.9036>:
  <D.9028>:
  D.9032 = __read_alias (__fd, __buf, __nbytes);
  return D.9032;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngClose (void * handle)
{

}