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

  egd.0 = egd;
  if (egd.0 != 0) goto <D.10659>; else goto <D.10662>;
  <D.10662>:
  file.1 = file;
  if (file.1 >= 0) goto <D.10659>; else goto <D.10660>;
  <D.10659>:
  D.10664 = 1;
  return D.10664;
  <D.10660>:
  file.2 = open ("/dev/urandom", 0);
  file = file.2;
  file.1 = file;
  if (file.1 < 0) goto <D.10666>; else goto <D.10667>;
  <D.10666>:
  file.3 = open ("/dev/random", 0);
  file = file.3;
  <D.10667>:
  file.1 = file;
  if (file.1 < 0) goto <D.10669>; else goto <D.10670>;
  <D.10669>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    D.10671 = socket_path != 0B;
    egd.4 = (int) D.10671;
    egd = egd.4;
  }
  <D.10670>:
  D.10664 = 1;
  return D.10664;
}


open (const char * __path, int __oflag)
{
  int D.10674;
  int D.10677;
  int D.10682;
  int D.10684;
  int D.10685;
  int D.10688;
  int D.10689;

  D.10674 = __builtin_va_arg_pack_len ();
  if (D.10674 > 1) goto <D.10675>; else goto <D.10676>;
  <D.10675>:
  __open_too_many_args ();
  <D.10676>:
  D.10677 = __builtin_constant_p (__oflag);
  if (D.10677 != 0) goto <D.10678>; else goto <D.10679>;
  <D.10678>:
  D.10682 = __oflag & 64;
  if (D.10682 != 0) goto <D.10680>; else goto <D.10683>;
  <D.10683>:
  D.10684 = __oflag & 4210688;
  if (D.10684 == 4210688) goto <D.10680>; else goto <D.10681>;
  <D.10680>:
  D.10685 = __builtin_va_arg_pack_len ();
  if (D.10685 <= 0) goto <D.10686>; else goto <D.10687>;
  <D.10686>:
  __open_missing_mode ();
  D.10688 = __open_2 (__path, __oflag);
  return D.10688;
  <D.10687>:
  <D.10681>:
  D.10688 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.10688;
  <D.10679>:
  D.10689 = __builtin_va_arg_pack_len ();
  if (D.10689 <= 0) goto <D.10690>; else goto <D.10691>;
  <D.10690>:
  D.10688 = __open_2 (__path, __oflag);
  return D.10688;
  <D.10691>:
  D.10688 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.10688;
}


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

  egd.6 = egd;
  if (egd.6 != 0) goto <D.10695>; else goto <D.10699>;
  <D.10699>:
  file.7 = file;
  if (file.7 >= 0) goto <D.10695>; else goto <D.10696>;
  <D.10695>:
  file.7 = file;
  iftmp.5 = (void *) file.7;
  goto <D.10697>;
  <D.10696>:
  iftmp.5 = 0B;
  <D.10697>:
  D.10693 = iftmp.5;
  return D.10693;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (void * handle, struct MonoArray * arry)
{
  int egd.8;
  void * D.10707;
  char * D.10708;
  unsigned int D.10709;
  int D.10710;
  sizetype count.9;
  void * D.10712;
  unsigned int count.10;
  unsigned int D.10714;
  int * D.10717;
  int D.10718;
  char * D.10723;
  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.10703>; else goto <D.10704>;
  <D.10703>:
  {
    const char * socket_path;

    socket_path = monoeg_g_getenv ("MONO_EGD_SOCKET");
    if (socket_path == 0B) goto <D.10705>; else goto <D.10706>;
    <D.10705>:
    D.10707 = 0B;
    return D.10707;
    <D.10706>:
    D.10708 = mono_array_addr_with_size (arry, 1, 0);
    D.10709 = mono_array_length (arry);
    D.10710 = (int) D.10709;
    get_entropy_from_server (socket_path, D.10708, D.10710);
    D.10707 = 4294967295B;
    return D.10707;
  }
  <D.10704>:
  {
    gint count;
    gint err;

    count = 0;
    <D.10652>:
    count.9 = (sizetype) count;
    D.10712 = buf + count.9;
    count.10 = (unsigned int) count;
    D.10714 = len - count.10;
    err = read (file, D.10712, D.10714);
    if (err < 0) goto <D.10715>; else goto <D.10716>;
    <D.10715>:
    D.10717 = __errno_location ();
    D.10718 = *D.10717;
    if (D.10718 == 4) goto <D.10719>; else goto <D.10720>;
    <D.10719>:
    // predicted unlikely by continue predictor.
    goto <D.10650>;
    <D.10720>:
    goto <D.10651>;
    <D.10716>:
    count = count + err;
    <D.10650>:
    count.10 = (unsigned int) count;
    if (count.10 < len) goto <D.10652>; else goto <D.10651>;
    <D.10651>:
    if (err < 0) goto <D.10721>; else goto <D.10722>;
    <D.10721>:
    D.10717 = __errno_location ();
    D.10718 = *D.10717;
    D.10723 = strerror (D.10718);
    monoeg_g_log (0B, 16, "Entropy error! Error in read (%s).", D.10723);
    D.10707 = 0B;
    return D.10707;
    <D.10722>:
  }
  D.10707 = handle;
  return D.10707;
}


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.10728;
  struct MonoException * D.10733;
  int D.10734;
  unsigned char D.10735;
  sizetype count.11;
  const void * D.10737;
  int D.10738;
  unsigned int D.10739;
  int * D.10743;
  int D.10744;
  struct MonoException * D.10747;
  void * D.10748;
  unsigned char D.10749;
  int D.10750;
  int D.10751;
  unsigned int D.10752;
  unsigned int received.12;
  struct MonoException * D.10760;
  int D.10761;
  int file;
  gint ret;
  guint offset;
  struct sockaddr_un egd_addr;

  try
    {
      offset = 0;
      file = socket (1, 1, 0);
      if (file < 0) goto <D.10725>; else goto <D.10726>;
      <D.10725>:
      ret = -1;
      goto <D.10727>;
      <D.10726>:
      egd_addr.sun_family = 1;
      strncpy (&egd_addr.sun_path, path, 4294967295);
      egd_addr.sun_path[-1] = 0;
      D.10728.__sockaddr__ = &egd_addr;
      ret = connect (file, D.10728, 110);
      <D.10727>:
      if (ret == -1) goto <D.10729>; else goto <D.10730>;
      <D.10729>:
      if (file >= 0) goto <D.10731>; else goto <D.10732>;
      <D.10731>:
      close (file);
      <D.10732>:
      monoeg_g_log (0B, 16, "Entropy problem! Can\'t create or connect to egd socket %s", path);
      D.10733 = mono_get_exception_execution_engine ("Failed to open egd socket");
      mono_raise_exception (D.10733);
      <D.10730>:
      goto <D.10629>;
      <D.10628>:
      {
        guchar request[2];
        gint count;

        try
          {
            count = 0;
            request[0] = 2;
            D.10734 = MIN_EXPR <len, 255>;
            D.10735 = (unsigned char) D.10734;
            request[1] = D.10735;
            goto <D.10621>;
            <D.10622>:
            {
              int sent;

              count.11 = (sizetype) count;
              D.10737 = &request + count.11;
              D.10738 = 2 - count;
              D.10739 = (unsigned int) D.10738;
              sent = write (file, D.10737, D.10739);
              if (sent >= 0) goto <D.10740>; else goto <D.10741>;
              <D.10740>:
              count = count + sent;
              goto <D.10742>;
              <D.10741>:
              D.10743 = __errno_location ();
              D.10744 = *D.10743;
              if (D.10744 == 4) goto <D.10745>; else goto <D.10746>;
              <D.10745>:
              // predicted unlikely by continue predictor.
              goto <D.10621>;
              <D.10746>:
              close (file);
              D.10743 = __errno_location ();
              D.10744 = *D.10743;
              monoeg_g_log (0B, 16, "Send egd request failed %d", D.10744);
              D.10747 = mono_get_exception_execution_engine ("Failed to send request to egd socket");
              mono_raise_exception (D.10747);
              <D.10742>:
            }
            <D.10621>:
            if (count <= 1) goto <D.10622>; else goto <D.10623>;
            <D.10623>:
            count = 0;
            goto <D.10625>;
            <D.10626>:
            {
              int received;

              D.10748 = buf + offset;
              D.10749 = request[1];
              D.10750 = (int) D.10749;
              D.10751 = D.10750 - count;
              D.10752 = (unsigned int) D.10751;
              received = read (file, D.10748, D.10752);
              if (received > 0) goto <D.10753>; else goto <D.10754>;
              <D.10753>:
              count = count + received;
              received.12 = (unsigned int) received;
              offset = offset + received.12;
              goto <D.10756>;
              <D.10754>:
              if (received < 0) goto <D.10758>; else goto <D.10757>;
              <D.10758>:
              D.10743 = __errno_location ();
              D.10744 = *D.10743;
              if (D.10744 == 4) goto <D.10759>; else goto <D.10757>;
              <D.10759>:
              // predicted unlikely by continue predictor.
              goto <D.10625>;
              <D.10757>:
              close (file);
              D.10743 = __errno_location ();
              D.10744 = *D.10743;
              monoeg_g_log (0B, 16, "Receive egd request failed %d", D.10744);
              D.10760 = mono_get_exception_execution_engine ("Failed to get response from egd socket");
              mono_raise_exception (D.10760);
              <D.10756>:
            }
            <D.10625>:
            D.10749 = request[1];
            D.10761 = (int) D.10749;
            if (D.10761 != count) goto <D.10626>; else goto <D.10627>;
            <D.10627>:
            D.10749 = request[1];
            D.10761 = (int) D.10749;
            len = len - D.10761;
          }
        finally
          {
            request = {CLOBBER};
          }
      }
      <D.10629>:
      if (len > 0) goto <D.10628>; else goto <D.10630>;
      <D.10630>:
      close (file);
    }
  finally
    {
      egd_addr = {CLOBBER};
    }
}


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

  D.10763 = __builtin_object_size (__dest, 1);
  D.10762 = __builtin___strncpy_chk (__dest, __src, __len, D.10763);
  return D.10762;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.10765;
  int D.10768;
  ssize_t D.10771;
  unsigned int D.10772;
  unsigned int D.10773;
  unsigned int D.10776;

  D.10765 = __builtin_object_size (__buf, 0);
  if (D.10765 != 4294967295) goto <D.10766>; else goto <D.10767>;
  <D.10766>:
  D.10768 = __builtin_constant_p (__nbytes);
  if (D.10768 == 0) goto <D.10769>; else goto <D.10770>;
  <D.10769>:
  D.10772 = __builtin_object_size (__buf, 0);
  D.10771 = __read_chk (__fd, __buf, __nbytes, D.10772);
  return D.10771;
  <D.10770>:
  D.10773 = __builtin_object_size (__buf, 0);
  if (D.10773 < __nbytes) goto <D.10774>; else goto <D.10775>;
  <D.10774>:
  D.10776 = __builtin_object_size (__buf, 0);
  D.10771 = __read_chk_warn (__fd, __buf, __nbytes, D.10776);
  return D.10771;
  <D.10775>:
  <D.10767>:
  D.10771 = __read_alias (__fd, __buf, __nbytes);
  return D.10771;
}


ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngClose (void * handle)
{

}