_wapi_open (const char * pathname, int flags, mode_t mode)
{
  int D.8675;
  int * D.8684;
  int D.8685;
  _Bool D.8686;
  _Bool D.8687;
  _Bool D.8688;
  int __mono_io_portability_helpers.0;
  int D.8696;
  int fd;
  gchar * located_filename;

  D.8675 = flags & 64;
  if (D.8675 != 0) goto <D.8676>; else goto <D.8677>;
  <D.8676>:
  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.8678>; else goto <D.8679>;
  <D.8678>:
  fd = open (pathname, flags, mode);
  goto <D.8680>;
  <D.8679>:
  fd = open (located_filename, flags, mode);
  monoeg_g_free (located_filename);
  <D.8680>:
  goto <D.8681>;
  <D.8677>:
  fd = open (pathname, flags, mode);
  if (fd == -1) goto <D.8682>; else goto <D.8683>;
  <D.8682>:
  D.8684 = __errno_location ();
  D.8685 = *D.8684;
  D.8686 = D.8685 == 2;
  D.8687 = D.8685 == 20;
  D.8688 = D.8686 | D.8687;
  if (D.8688 != 0) goto <D.8689>; else goto <D.8690>;
  <D.8689>:
  __mono_io_portability_helpers.0 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.0 > 0) goto <D.8692>; else goto <D.8693>;
  <D.8692>:
  {
    int saved_errno;

    D.8684 = __errno_location ();
    saved_errno = *D.8684;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8694>; else goto <D.8695>;
    <D.8694>:
    D.8684 = __errno_location ();
    *D.8684 = saved_errno;
    D.8696 = -1;
    return D.8696;
    <D.8695>:
    fd = open (located_filename, flags, mode);
    monoeg_g_free (located_filename);
  }
  <D.8693>:
  <D.8690>:
  <D.8683>:
  <D.8681>:
  D.8696 = fd;
  return D.8696;
}


open (const char * __path, int __oflag)
{
  int D.8698;
  int D.8701;
  int D.8706;
  int D.8708;
  int D.8709;
  int D.8712;
  int D.8713;

  D.8698 = __builtin_va_arg_pack_len ();
  if (D.8698 > 1) goto <D.8699>; else goto <D.8700>;
  <D.8699>:
  __open_too_many_args ();
  <D.8700>:
  D.8701 = __builtin_constant_p (__oflag);
  if (D.8701 != 0) goto <D.8702>; else goto <D.8703>;
  <D.8702>:
  D.8706 = __oflag & 64;
  if (D.8706 != 0) goto <D.8704>; else goto <D.8707>;
  <D.8707>:
  D.8708 = __oflag & 4259840;
  if (D.8708 == 4259840) goto <D.8704>; else goto <D.8705>;
  <D.8704>:
  D.8709 = __builtin_va_arg_pack_len ();
  if (D.8709 <= 0) goto <D.8710>; else goto <D.8711>;
  <D.8710>:
  __open_missing_mode ();
  D.8712 = __open_2 (__path, __oflag);
  return D.8712;
  <D.8711>:
  <D.8705>:
  D.8712 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8712;
  <D.8703>:
  D.8713 = __builtin_va_arg_pack_len ();
  if (D.8713 <= 0) goto <D.8714>; else goto <D.8715>;
  <D.8714>:
  D.8712 = __open_2 (__path, __oflag);
  return D.8712;
  <D.8715>:
  D.8712 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8712;
}


_wapi_access (const char * pathname, int mode)
{
  int * D.8719;
  int D.8720;
  _Bool D.8721;
  _Bool D.8722;
  _Bool D.8723;
  int __mono_io_portability_helpers.1;
  int D.8731;
  int ret;

  ret = access (pathname, mode);
  if (ret == -1) goto <D.8717>; else goto <D.8718>;
  <D.8717>:
  D.8719 = __errno_location ();
  D.8720 = *D.8719;
  D.8721 = D.8720 == 2;
  D.8722 = D.8720 == 20;
  D.8723 = D.8721 | D.8722;
  if (D.8723 != 0) goto <D.8724>; else goto <D.8725>;
  <D.8724>:
  __mono_io_portability_helpers.1 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.1 > 0) goto <D.8727>; else goto <D.8728>;
  <D.8727>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8719 = __errno_location ();
    saved_errno = *D.8719;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8729>; else goto <D.8730>;
    <D.8729>:
    D.8719 = __errno_location ();
    *D.8719 = saved_errno;
    D.8731 = -1;
    return D.8731;
    <D.8730>:
    ret = access (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.8728>:
  <D.8725>:
  <D.8718>:
  D.8731 = ret;
  return D.8731;
}


_wapi_chmod (const char * pathname, mode_t mode)
{
  int * D.8735;
  int D.8736;
  _Bool D.8737;
  _Bool D.8738;
  _Bool D.8739;
  int __mono_io_portability_helpers.2;
  int D.8747;
  int ret;

  ret = chmod (pathname, mode);
  if (ret == -1) goto <D.8733>; else goto <D.8734>;
  <D.8733>:
  D.8735 = __errno_location ();
  D.8736 = *D.8735;
  D.8737 = D.8736 == 2;
  D.8738 = D.8736 == 20;
  D.8739 = D.8737 | D.8738;
  if (D.8739 != 0) goto <D.8740>; else goto <D.8741>;
  <D.8740>:
  __mono_io_portability_helpers.2 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.2 > 0) goto <D.8743>; else goto <D.8744>;
  <D.8743>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8735 = __errno_location ();
    saved_errno = *D.8735;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8745>; else goto <D.8746>;
    <D.8745>:
    D.8735 = __errno_location ();
    *D.8735 = saved_errno;
    D.8747 = -1;
    return D.8747;
    <D.8746>:
    ret = chmod (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.8744>:
  <D.8741>:
  <D.8734>:
  D.8747 = ret;
  return D.8747;
}


_wapi_utime (const char * filename, const struct utimbuf * buf)
{
  int * D.8751;
  int D.8752;
  int __mono_io_portability_helpers.3;
  int D.8760;
  int ret;

  ret = utime (filename, buf);
  if (ret == -1) goto <D.8749>; else goto <D.8750>;
  <D.8749>:
  D.8751 = __errno_location ();
  D.8752 = *D.8751;
  if (D.8752 == 2) goto <D.8753>; else goto <D.8754>;
  <D.8753>:
  __mono_io_portability_helpers.3 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.3 > 0) goto <D.8756>; else goto <D.8757>;
  <D.8756>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8751 = __errno_location ();
    saved_errno = *D.8751;
    located_filename = mono_portability_find_file (filename, 1);
    if (located_filename == 0B) goto <D.8758>; else goto <D.8759>;
    <D.8758>:
    D.8751 = __errno_location ();
    *D.8751 = saved_errno;
    D.8760 = -1;
    return D.8760;
    <D.8759>:
    ret = utime (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.8757>:
  <D.8754>:
  <D.8750>:
  D.8760 = ret;
  return D.8760;
}


_wapi_unlink (const char * pathname)
{
  int * D.8766;
  int D.8767;
  _Bool D.8768;
  _Bool D.8769;
  _Bool D.8770;
  int D.8772;
  int __mono_io_portability_helpers.4;
  int D.8778;
  int ret;

  ret = unlink (pathname);
  if (ret == -1) goto <D.8764>; else goto <D.8765>;
  <D.8764>:
  D.8766 = __errno_location ();
  D.8767 = *D.8766;
  D.8768 = D.8767 == 2;
  D.8769 = D.8767 == 20;
  D.8770 = D.8768 | D.8769;
  if (D.8770 != 0) goto <D.8762>; else goto <D.8771>;
  <D.8771>:
  D.8766 = __errno_location ();
  D.8772 = *D.8766;
  if (D.8772 == 21) goto <D.8762>; else goto <D.8763>;
  <D.8762>:
  __mono_io_portability_helpers.4 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.4 > 0) goto <D.8774>; else goto <D.8775>;
  <D.8774>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8766 = __errno_location ();
    saved_errno = *D.8766;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8776>; else goto <D.8777>;
    <D.8776>:
    D.8766 = __errno_location ();
    *D.8766 = saved_errno;
    D.8778 = -1;
    return D.8778;
    <D.8777>:
    ret = unlink (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.8775>:
  <D.8763>:
  <D.8765>:
  D.8778 = ret;
  return D.8778;
}


_wapi_rename (const char * oldpath, const char * newpath)
{
  int * D.8787;
  int D.8788;
  _Bool D.8789;
  _Bool D.8790;
  _Bool D.8791;
  int D.8793;
  int __mono_io_portability_helpers.5;
  int D.8801;
  int ret;
  gchar * located_newpath;

  located_newpath = mono_portability_find_file (newpath, 0);
  if (located_newpath == 0B) goto <D.8780>; else goto <D.8781>;
  <D.8780>:
  ret = rename (oldpath, newpath);
  goto <D.8782>;
  <D.8781>:
  ret = rename (oldpath, located_newpath);
  if (ret == -1) goto <D.8785>; else goto <D.8786>;
  <D.8785>:
  D.8787 = __errno_location ();
  D.8788 = *D.8787;
  D.8789 = D.8788 == 21;
  D.8790 = D.8788 == 36;
  D.8791 = D.8789 | D.8790;
  if (D.8791 != 0) goto <D.8783>; else goto <D.8792>;
  <D.8792>:
  D.8787 = __errno_location ();
  D.8793 = *D.8787;
  if (D.8793 == 2) goto <D.8783>; else goto <D.8794>;
  <D.8794>:
  D.8787 = __errno_location ();
  D.8793 = *D.8787;
  if (D.8793 == 20) goto <D.8783>; else goto <D.8795>;
  <D.8795>:
  D.8787 = __errno_location ();
  D.8793 = *D.8787;
  if (D.8793 == 18) goto <D.8783>; else goto <D.8784>;
  <D.8783>:
  __mono_io_portability_helpers.5 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.5 > 0) goto <D.8797>; else goto <D.8798>;
  <D.8797>:
  {
    int saved_errno;
    gchar * located_oldpath;

    D.8787 = __errno_location ();
    saved_errno = *D.8787;
    located_oldpath = mono_portability_find_file (oldpath, 1);
    if (located_oldpath == 0B) goto <D.8799>; else goto <D.8800>;
    <D.8799>:
    monoeg_g_free (located_oldpath);
    monoeg_g_free (located_newpath);
    D.8787 = __errno_location ();
    *D.8787 = saved_errno;
    D.8801 = -1;
    return D.8801;
    <D.8800>:
    ret = rename (located_oldpath, located_newpath);
    monoeg_g_free (located_oldpath);
  }
  <D.8798>:
  <D.8784>:
  <D.8786>:
  monoeg_g_free (located_newpath);
  <D.8782>:
  D.8801 = ret;
  return D.8801;
}


_wapi_stat (const char * path, struct stat * buf)
{
  int * D.8805;
  int D.8806;
  _Bool D.8807;
  _Bool D.8808;
  _Bool D.8809;
  int __mono_io_portability_helpers.6;
  int D.8817;
  int ret;

  ret = stat (path, buf);
  if (ret == -1) goto <D.8803>; else goto <D.8804>;
  <D.8803>:
  D.8805 = __errno_location ();
  D.8806 = *D.8805;
  D.8807 = D.8806 == 2;
  D.8808 = D.8806 == 20;
  D.8809 = D.8807 | D.8808;
  if (D.8809 != 0) goto <D.8810>; else goto <D.8811>;
  <D.8810>:
  __mono_io_portability_helpers.6 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.6 > 0) goto <D.8813>; else goto <D.8814>;
  <D.8813>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8805 = __errno_location ();
    saved_errno = *D.8805;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.8815>; else goto <D.8816>;
    <D.8815>:
    D.8805 = __errno_location ();
    *D.8805 = saved_errno;
    D.8817 = -1;
    return D.8817;
    <D.8816>:
    ret = stat (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.8814>:
  <D.8811>:
  <D.8804>:
  D.8817 = ret;
  return D.8817;
}


stat (const char * __path, struct stat * __statbuf)
{
  int D.8819;

  D.8819 = __xstat (3, __path, __statbuf);
  return D.8819;
}


_wapi_lstat (const char * path, struct stat * buf)
{
  int * D.8823;
  int D.8824;
  _Bool D.8825;
  _Bool D.8826;
  _Bool D.8827;
  int __mono_io_portability_helpers.7;
  int D.8835;
  int ret;

  ret = lstat (path, buf);
  if (ret == -1) goto <D.8821>; else goto <D.8822>;
  <D.8821>:
  D.8823 = __errno_location ();
  D.8824 = *D.8823;
  D.8825 = D.8824 == 2;
  D.8826 = D.8824 == 20;
  D.8827 = D.8825 | D.8826;
  if (D.8827 != 0) goto <D.8828>; else goto <D.8829>;
  <D.8828>:
  __mono_io_portability_helpers.7 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.7 > 0) goto <D.8831>; else goto <D.8832>;
  <D.8831>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8823 = __errno_location ();
    saved_errno = *D.8823;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.8833>; else goto <D.8834>;
    <D.8833>:
    D.8823 = __errno_location ();
    *D.8823 = saved_errno;
    D.8835 = -1;
    return D.8835;
    <D.8834>:
    ret = lstat (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.8832>:
  <D.8829>:
  <D.8822>:
  D.8835 = ret;
  return D.8835;
}


lstat (const char * __path, struct stat * __statbuf)
{
  int D.8837;

  D.8837 = __lxstat (3, __path, __statbuf);
  return D.8837;
}


_wapi_mkdir (const char * pathname, mode_t mode)
{
  int D.8842;
  int ret;
  gchar * located_filename;

  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.8839>; else goto <D.8840>;
  <D.8839>:
  ret = mkdir (pathname, mode);
  goto <D.8841>;
  <D.8840>:
  ret = mkdir (located_filename, mode);
  monoeg_g_free (located_filename);
  <D.8841>:
  D.8842 = ret;
  return D.8842;
}


_wapi_rmdir (const char * pathname)
{
  int * D.8848;
  int D.8849;
  _Bool D.8850;
  _Bool D.8851;
  _Bool D.8852;
  int D.8854;
  int __mono_io_portability_helpers.8;
  int D.8860;
  int ret;

  ret = rmdir (pathname);
  if (ret == -1) goto <D.8846>; else goto <D.8847>;
  <D.8846>:
  D.8848 = __errno_location ();
  D.8849 = *D.8848;
  D.8850 = D.8849 == 2;
  D.8851 = D.8849 == 20;
  D.8852 = D.8850 | D.8851;
  if (D.8852 != 0) goto <D.8844>; else goto <D.8853>;
  <D.8853>:
  D.8848 = __errno_location ();
  D.8854 = *D.8848;
  if (D.8854 == 36) goto <D.8844>; else goto <D.8845>;
  <D.8844>:
  __mono_io_portability_helpers.8 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.8 > 0) goto <D.8856>; else goto <D.8857>;
  <D.8856>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8848 = __errno_location ();
    saved_errno = *D.8848;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8858>; else goto <D.8859>;
    <D.8858>:
    D.8848 = __errno_location ();
    *D.8848 = saved_errno;
    D.8860 = -1;
    return D.8860;
    <D.8859>:
    ret = rmdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.8857>:
  <D.8845>:
  <D.8847>:
  D.8860 = ret;
  return D.8860;
}


_wapi_chdir (const char * path)
{
  int * D.8866;
  int D.8867;
  _Bool D.8868;
  _Bool D.8869;
  _Bool D.8870;
  int D.8872;
  int __mono_io_portability_helpers.9;
  int D.8878;
  int ret;

  ret = chdir (path);
  if (ret == -1) goto <D.8864>; else goto <D.8865>;
  <D.8864>:
  D.8866 = __errno_location ();
  D.8867 = *D.8866;
  D.8868 = D.8867 == 2;
  D.8869 = D.8867 == 20;
  D.8870 = D.8868 | D.8869;
  if (D.8870 != 0) goto <D.8862>; else goto <D.8871>;
  <D.8871>:
  D.8866 = __errno_location ();
  D.8872 = *D.8866;
  if (D.8872 == 36) goto <D.8862>; else goto <D.8863>;
  <D.8862>:
  __mono_io_portability_helpers.9 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.9 > 0) goto <D.8874>; else goto <D.8875>;
  <D.8874>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8866 = __errno_location ();
    saved_errno = *D.8866;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.8876>; else goto <D.8877>;
    <D.8876>:
    D.8866 = __errno_location ();
    *D.8866 = saved_errno;
    D.8878 = -1;
    return D.8878;
    <D.8877>:
    ret = chdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.8875>:
  <D.8863>:
  <D.8865>:
  D.8878 = ret;
  return D.8878;
}


_wapi_basename (const gchar * filename)
{
  int __mono_io_portability_helpers.10;
  int D.8883;
  const short unsigned int * * D.8886;
  const short unsigned int * D.8887;
  char D.8888;
  unsigned int D.8889;
  unsigned int D.8890;
  const short unsigned int * D.8891;
  short unsigned int D.8892;
  int D.8893;
  int D.8894;
  gchar * D.8897;
  char D.8898;
  unsigned int D.8901;
  int D.8902;
  unsigned int D.8903;
  const void * D.8904;
  sizetype len.11;
  sizetype D.8906;
  gchar * D.8907;
  gchar * D.8908;
  gchar * new_filename;
  gchar * ret;

  new_filename = monoeg_strdup (filename);
  __mono_io_portability_helpers.10 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.10 > 0) goto <D.8881>; else goto <D.8882>;
  <D.8881>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.8882>:
  __mono_io_portability_helpers.10 = __mono_io_portability_helpers;
  D.8883 = __mono_io_portability_helpers.10 & 2;
  if (D.8883 != 0) goto <D.8884>; else goto <D.8885>;
  <D.8884>:
  D.8886 = __ctype_b_loc ();
  D.8887 = *D.8886;
  D.8888 = *new_filename;
  D.8889 = (unsigned int) D.8888;
  D.8890 = D.8889 * 2;
  D.8891 = D.8887 + D.8890;
  D.8892 = *D.8891;
  D.8893 = (int) D.8892;
  D.8894 = D.8893 & 1024;
  if (D.8894 != 0) goto <D.8895>; else goto <D.8896>;
  <D.8895>:
  D.8897 = new_filename + 1;
  D.8898 = *D.8897;
  if (D.8898 == 58) goto <D.8899>; else goto <D.8900>;
  <D.8899>:
  {
    int len;

    D.8901 = strlen (new_filename);
    len = (int) D.8901;
    D.8902 = len + -2;
    D.8903 = (unsigned int) D.8902;
    D.8904 = new_filename + 2;
    memmove (new_filename, D.8904, D.8903);
    len.11 = (sizetype) len;
    D.8906 = len.11 + 4294967294;
    D.8907 = new_filename + D.8906;
    *D.8907 = 0;
  }
  <D.8900>:
  <D.8896>:
  <D.8885>:
  ret = monoeg_g_path_get_basename (new_filename);
  monoeg_g_free (new_filename);
  D.8908 = ret;
  return D.8908;
}


monoeg_strdup (const gchar * str)
{
  gchar * D.8912;

  if (str != 0B) goto <D.8910>; else goto <D.8911>;
  <D.8910>:
  D.8912 = __strdup (str);
  return D.8912;
  <D.8911>:
  D.8912 = 0B;
  return D.8912;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.8914;
  unsigned int D.8915;

  D.8915 = __builtin_object_size (__dest, 0);
  D.8914 = __builtin___memmove_chk (__dest, __src, __len, D.8915);
  return D.8914;
}


_wapi_dirname (const gchar * filename)
{
  int __mono_io_portability_helpers.12;
  int D.8920;
  const short unsigned int * * D.8923;
  const short unsigned int * D.8924;
  char D.8925;
  unsigned int D.8926;
  unsigned int D.8927;
  const short unsigned int * D.8928;
  short unsigned int D.8929;
  int D.8930;
  int D.8931;
  gchar * D.8934;
  char D.8935;
  unsigned int D.8938;
  int D.8939;
  unsigned int D.8940;
  const void * D.8941;
  sizetype len.13;
  sizetype D.8943;
  gchar * D.8944;
  gchar * D.8945;
  gchar * new_filename;
  gchar * ret;

  new_filename = monoeg_strdup (filename);
  __mono_io_portability_helpers.12 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.12 > 0) goto <D.8918>; else goto <D.8919>;
  <D.8918>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.8919>:
  __mono_io_portability_helpers.12 = __mono_io_portability_helpers;
  D.8920 = __mono_io_portability_helpers.12 & 2;
  if (D.8920 != 0) goto <D.8921>; else goto <D.8922>;
  <D.8921>:
  D.8923 = __ctype_b_loc ();
  D.8924 = *D.8923;
  D.8925 = *new_filename;
  D.8926 = (unsigned int) D.8925;
  D.8927 = D.8926 * 2;
  D.8928 = D.8924 + D.8927;
  D.8929 = *D.8928;
  D.8930 = (int) D.8929;
  D.8931 = D.8930 & 1024;
  if (D.8931 != 0) goto <D.8932>; else goto <D.8933>;
  <D.8932>:
  D.8934 = new_filename + 1;
  D.8935 = *D.8934;
  if (D.8935 == 58) goto <D.8936>; else goto <D.8937>;
  <D.8936>:
  {
    int len;

    D.8938 = strlen (new_filename);
    len = (int) D.8938;
    D.8939 = len + -2;
    D.8940 = (unsigned int) D.8939;
    D.8941 = new_filename + 2;
    memmove (new_filename, D.8941, D.8940);
    len.13 = (sizetype) len;
    D.8943 = len.13 + 4294967294;
    D.8944 = new_filename + D.8943;
    *D.8944 = 0;
  }
  <D.8937>:
  <D.8933>:
  <D.8922>:
  ret = monoeg_g_path_get_dirname (new_filename);
  monoeg_g_free (new_filename);
  D.8945 = ret;
  return D.8945;
}


_wapi_g_dir_open (const gchar * path, guint flags, struct GError * * error)
{
  struct GError * D.8949;
  int D.8950;
  unsigned int D.8951;
  unsigned int D.8952;
  int __mono_io_portability_helpers.14;
  struct GDir * D.8960;
  struct GError * tmp_error.15;
  struct GDir * ret;

  ret = monoeg_g_dir_open (path, flags, error);
  if (ret == 0B) goto <D.8947>; else goto <D.8948>;
  <D.8947>:
  D.8949 = *error;
  D.8950 = D.8949->code;
  D.8951 = (unsigned int) D.8950;
  D.8952 = D.8951 + 4294967293;
  if (D.8952 <= 2) goto <D.8953>; else goto <D.8954>;
  <D.8953>:
  __mono_io_portability_helpers.14 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.14 > 0) goto <D.8956>; else goto <D.8957>;
  <D.8956>:
  {
    gchar * located_filename;
    struct GError * tmp_error;

    try
      {
        located_filename = mono_portability_find_file (path, 1);
        tmp_error = 0B;
        if (located_filename == 0B) goto <D.8958>; else goto <D.8959>;
        <D.8958>:
        D.8960 = 0B;
        return D.8960;
        <D.8959>:
        ret = monoeg_g_dir_open (located_filename, flags, &tmp_error);
        monoeg_g_free (located_filename);
        tmp_error.15 = tmp_error;
        if (tmp_error.15 == 0B) goto <D.8962>; else goto <D.8963>;
        <D.8962>:
        monoeg_g_clear_error (error);
        <D.8963>:
      }
    finally
      {
        tmp_error = {CLOBBER};
      }
  }
  <D.8957>:
  <D.8954>:
  <D.8948>:
  D.8960 = ret;
  return D.8960;
}


_wapi_io_scandir (const gchar * dirname, const gchar * pattern, gchar * * * namelist)
{
  struct GError * error.16;
  int D.8970;
  int D.8973;
  int D.8976;
  int * D.8979;
  gint D.8980;
  int __mono_io_portability_helpers.17;
  int D.8982;
  int D.8985;
  unsigned int D.8988;
  unsigned int D.8989;
  int D.8990;
  int D.8993;
  char * * D.8998;
  unsigned int i.18;
  unsigned int D.9000;
  char * * D.9001;
  char * D.9002;
  gchar * D.9003;
  unsigned int D.9004;
  int D.9007;
  void * * D.9008;
  struct GError * error;
  struct GDir * dir;
  struct GPtrArray * names;
  gint result;
  struct wapi_glob_t glob_buf;
  int flags;
  int i;

  try
    {
      error = 0B;
      flags = 0;
      dir = _wapi_g_dir_open (dirname, 0, &error);
      if (dir == 0B) goto <D.8967>; else goto <D.8968>;
      <D.8967>:
      {
        gint errnum;

        error.16 = error;
        D.8970 = error.16->code;
        errnum = get_errno_from_g_file_error (D.8970);
        error.16 = error;
        monoeg_g_error_free (error.16);
        if (errnum == 2) goto <D.8971>; else goto <D.8972>;
        <D.8971>:
        D.8973 = _wapi_access (dirname, 0);
        if (D.8973 == 0) goto <D.8974>; else goto <D.8975>;
        <D.8974>:
        D.8976 = _wapi_access (dirname, 5);
        if (D.8976 != 0) goto <D.8977>; else goto <D.8978>;
        <D.8977>:
        errnum = 13;
        <D.8978>:
        <D.8975>:
        <D.8972>:
        D.8979 = __errno_location ();
        *D.8979 = errnum;
        D.8980 = -1;
        return D.8980;
      }
      <D.8968>:
      __mono_io_portability_helpers.17 = __mono_io_portability_helpers;
      D.8982 = __mono_io_portability_helpers.17 & 4;
      if (D.8982 != 0) goto <D.8983>; else goto <D.8984>;
      <D.8983>:
      flags = 16384;
      <D.8984>:
      result = _wapi_glob (dir, pattern, flags, &glob_buf);
      D.8985 = monoeg_g_str_has_suffix (pattern, ".*");
      if (D.8985 != 0) goto <D.8986>; else goto <D.8987>;
      <D.8986>:
      {
        gchar * pattern2;
        gint result2;

        D.8988 = strlen (pattern);
        D.8989 = D.8988 + 4294967294;
        pattern2 = monoeg_g_strndup (pattern, D.8989);
        monoeg_g_dir_rewind (dir);
        D.8990 = flags | 65;
        result2 = _wapi_glob (dir, pattern2, D.8990, &glob_buf);
        monoeg_g_free (pattern2);
        if (result != 0) goto <D.8991>; else goto <D.8992>;
        <D.8991>:
        result = result2;
        <D.8992>:
      }
      <D.8987>:
      monoeg_g_dir_close (dir);
      D.8993 = glob_buf.gl_pathc;
      if (D.8993 == 0) goto <D.8994>; else goto <D.8995>;
      <D.8994>:
      D.8980 = 0;
      return D.8980;
      <D.8995>:
      if (result != 0) goto <D.8996>; else goto <D.8997>;
      <D.8996>:
      D.8980 = -1;
      return D.8980;
      <D.8997>:
      names = monoeg_g_ptr_array_new ();
      i = 0;
      goto <D.8672>;
      <D.8671>:
      D.8998 = glob_buf.gl_pathv;
      i.18 = (unsigned int) i;
      D.9000 = i.18 * 4;
      D.9001 = D.8998 + D.9000;
      D.9002 = *D.9001;
      D.9003 = monoeg_strdup (D.9002);
      monoeg_g_ptr_array_add (names, D.9003);
      i = i + 1;
      <D.8672>:
      D.8993 = glob_buf.gl_pathc;
      if (D.8993 > i) goto <D.8671>; else goto <D.8673>;
      <D.8673>:
      _wapi_globfree (&glob_buf);
      D.9004 = names->len;
      result = (gint) D.9004;
      if (result > 0) goto <D.9005>; else goto <D.9006>;
      <D.9005>:
      monoeg_g_ptr_array_sort (names, file_compare);
      D.9007 = result + 1;
      monoeg_g_ptr_array_set_size (names, D.9007);
      D.9008 = monoeg_g_ptr_array_free (names, 0);
      *namelist = D.9008;
      goto <D.9009>;
      <D.9006>:
      monoeg_g_ptr_array_free (names, 1);
      <D.9009>:
      D.8980 = result;
      return D.8980;
    }
  finally
    {
      error = {CLOBBER};
      glob_buf = {CLOBBER};
    }
}


file_compare (const void * a, const void * b)
{
  gint D.9012;
  int D.8631;
  gchar * astr;
  gchar * bstr;

  astr = MEM[(gchar * *)a];
  bstr = MEM[(gchar * *)b];
  {
    size_t __s1_len;
    size_t __s2_len;

    D.8631 = __builtin_strcmp (astr, bstr);
  }
  D.9012 = D.8631;
  return D.9012;
}


get_errno_from_g_file_error (gint error)
{
  gint D.9015;

  switch (error) <default: <D.9014>, case 3: <D.8635>, case 4: <D.8637>, case 5: <D.8638>, case 6: <D.8639>, case 7: <D.8640>, case 8: <D.8641>, case 9: <D.8642>, case 10: <D.8643>, case 11: <D.8644>, case 12: <D.8645>, case 13: <D.8646>, case 14: <D.8647>, case 15: <D.8648>, case 16: <D.8649>, case 17: <D.8650>, case 18: <D.8651>, case 19: <D.8652>, case 20: <D.8653>, case 22: <D.8654>, case 24: <D.8655>>
  <D.8635>:
  error = 36;
  goto <D.8636>;
  <D.8637>:
  error = 2;
  goto <D.8636>;
  <D.8638>:
  error = 20;
  goto <D.8636>;
  <D.8639>:
  error = 6;
  goto <D.8636>;
  <D.8640>:
  error = 19;
  goto <D.8636>;
  <D.8641>:
  error = 30;
  goto <D.8636>;
  <D.8642>:
  error = 26;
  goto <D.8636>;
  <D.8643>:
  error = 14;
  goto <D.8636>;
  <D.8644>:
  error = 40;
  goto <D.8636>;
  <D.8645>:
  error = 28;
  goto <D.8636>;
  <D.8646>:
  error = 12;
  goto <D.8636>;
  <D.8647>:
  error = 24;
  goto <D.8636>;
  <D.8648>:
  error = 23;
  goto <D.8636>;
  <D.8649>:
  error = 9;
  goto <D.8636>;
  <D.8650>:
  error = 22;
  goto <D.8636>;
  <D.8651>:
  error = 32;
  goto <D.8636>;
  <D.8652>:
  error = 11;
  goto <D.8636>;
  <D.8653>:
  error = 4;
  goto <D.8636>;
  <D.8654>:
  error = 1;
  goto <D.8636>;
  <D.8655>:
  error = 87;
  goto <D.8636>;
  <D.9014>:
  <D.8636>:
  D.9015 = error;
  return D.9015;
}