_wapi_open (const char * pathname, int flags, mode_t mode)
{
  int D.9541;
  int * D.9552;
  int D.9553;
  int __mono_io_portability_helpers.0;
  int D.9560;
  int fd;
  gchar * located_filename;

  D.9541 = flags & 64;
  if (D.9541 != 0) goto <D.9542>; else goto <D.9543>;
  <D.9542>:
  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.9544>; else goto <D.9545>;
  <D.9544>:
  fd = open (pathname, flags, mode);
  goto <D.9546>;
  <D.9545>:
  fd = open (located_filename, flags, mode);
  monoeg_g_free (located_filename);
  <D.9546>:
  goto <D.9547>;
  <D.9543>:
  fd = open (pathname, flags, mode);
  if (fd == -1) goto <D.9550>; else goto <D.9551>;
  <D.9550>:
  D.9552 = __errno_location ();
  D.9553 = *D.9552;
  if (D.9553 == 2) goto <D.9548>; else goto <D.9554>;
  <D.9554>:
  D.9552 = __errno_location ();
  D.9553 = *D.9552;
  if (D.9553 == 20) goto <D.9548>; else goto <D.9549>;
  <D.9548>:
  __mono_io_portability_helpers.0 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.0 > 0) goto <D.9556>; else goto <D.9557>;
  <D.9556>:
  {
    int saved_errno;

    D.9552 = __errno_location ();
    saved_errno = *D.9552;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9558>; else goto <D.9559>;
    <D.9558>:
    D.9552 = __errno_location ();
    *D.9552 = saved_errno;
    D.9560 = -1;
    return D.9560;
    <D.9559>:
    fd = open (located_filename, flags, mode);
    monoeg_g_free (located_filename);
  }
  <D.9557>:
  <D.9549>:
  <D.9551>:
  <D.9547>:
  D.9560 = fd;
  return D.9560;
}


open (const char * __path, int __oflag)
{
  int D.9562;
  int D.9565;
  int D.9570;
  int D.9572;
  int D.9573;
  int D.9576;
  int D.9577;

  D.9562 = __builtin_va_arg_pack_len ();
  if (D.9562 > 1) goto <D.9563>; else goto <D.9564>;
  <D.9563>:
  __open_too_many_args ();
  <D.9564>:
  D.9565 = __builtin_constant_p (__oflag);
  if (D.9565 != 0) goto <D.9566>; else goto <D.9567>;
  <D.9566>:
  D.9570 = __oflag & 64;
  if (D.9570 != 0) goto <D.9568>; else goto <D.9571>;
  <D.9571>:
  D.9572 = __oflag & 4259840;
  if (D.9572 == 4259840) goto <D.9568>; else goto <D.9569>;
  <D.9568>:
  D.9573 = __builtin_va_arg_pack_len ();
  if (D.9573 <= 0) goto <D.9574>; else goto <D.9575>;
  <D.9574>:
  __open_missing_mode ();
  D.9576 = __open_2 (__path, __oflag);
  return D.9576;
  <D.9575>:
  <D.9569>:
  D.9576 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.9576;
  <D.9567>:
  D.9577 = __builtin_va_arg_pack_len ();
  if (D.9577 <= 0) goto <D.9578>; else goto <D.9579>;
  <D.9578>:
  D.9576 = __open_2 (__path, __oflag);
  return D.9576;
  <D.9579>:
  D.9576 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.9576;
}


_wapi_access (const char * pathname, int mode)
{
  int * D.9585;
  int D.9586;
  int __mono_io_portability_helpers.1;
  int D.9593;
  int ret;

  ret = access (pathname, mode);
  if (ret == -1) goto <D.9583>; else goto <D.9584>;
  <D.9583>:
  D.9585 = __errno_location ();
  D.9586 = *D.9585;
  if (D.9586 == 2) goto <D.9581>; else goto <D.9587>;
  <D.9587>:
  D.9585 = __errno_location ();
  D.9586 = *D.9585;
  if (D.9586 == 20) goto <D.9581>; else goto <D.9582>;
  <D.9581>:
  __mono_io_portability_helpers.1 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.1 > 0) goto <D.9589>; else goto <D.9590>;
  <D.9589>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9585 = __errno_location ();
    saved_errno = *D.9585;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9591>; else goto <D.9592>;
    <D.9591>:
    D.9585 = __errno_location ();
    *D.9585 = saved_errno;
    D.9593 = -1;
    return D.9593;
    <D.9592>:
    ret = access (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.9590>:
  <D.9582>:
  <D.9584>:
  D.9593 = ret;
  return D.9593;
}


_wapi_chmod (const char * pathname, mode_t mode)
{
  int * D.9599;
  int D.9600;
  int __mono_io_portability_helpers.2;
  int D.9607;
  int ret;

  ret = chmod (pathname, mode);
  if (ret == -1) goto <D.9597>; else goto <D.9598>;
  <D.9597>:
  D.9599 = __errno_location ();
  D.9600 = *D.9599;
  if (D.9600 == 2) goto <D.9595>; else goto <D.9601>;
  <D.9601>:
  D.9599 = __errno_location ();
  D.9600 = *D.9599;
  if (D.9600 == 20) goto <D.9595>; else goto <D.9596>;
  <D.9595>:
  __mono_io_portability_helpers.2 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.2 > 0) goto <D.9603>; else goto <D.9604>;
  <D.9603>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9599 = __errno_location ();
    saved_errno = *D.9599;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9605>; else goto <D.9606>;
    <D.9605>:
    D.9599 = __errno_location ();
    *D.9599 = saved_errno;
    D.9607 = -1;
    return D.9607;
    <D.9606>:
    ret = chmod (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.9604>:
  <D.9596>:
  <D.9598>:
  D.9607 = ret;
  return D.9607;
}


_wapi_utime (const char * filename, const struct utimbuf * buf)
{
  int * D.9611;
  int D.9612;
  int __mono_io_portability_helpers.3;
  int D.9620;
  int ret;

  ret = utime (filename, buf);
  if (ret == -1) goto <D.9609>; else goto <D.9610>;
  <D.9609>:
  D.9611 = __errno_location ();
  D.9612 = *D.9611;
  if (D.9612 == 2) goto <D.9613>; else goto <D.9614>;
  <D.9613>:
  __mono_io_portability_helpers.3 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.3 > 0) goto <D.9616>; else goto <D.9617>;
  <D.9616>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9611 = __errno_location ();
    saved_errno = *D.9611;
    located_filename = mono_portability_find_file (filename, 1);
    if (located_filename == 0B) goto <D.9618>; else goto <D.9619>;
    <D.9618>:
    D.9611 = __errno_location ();
    *D.9611 = saved_errno;
    D.9620 = -1;
    return D.9620;
    <D.9619>:
    ret = utime (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.9617>:
  <D.9614>:
  <D.9610>:
  D.9620 = ret;
  return D.9620;
}


_wapi_unlink (const char * pathname)
{
  int * D.9626;
  int D.9627;
  int __mono_io_portability_helpers.4;
  int D.9635;
  int ret;

  ret = unlink (pathname);
  if (ret == -1) goto <D.9624>; else goto <D.9625>;
  <D.9624>:
  D.9626 = __errno_location ();
  D.9627 = *D.9626;
  if (D.9627 == 2) goto <D.9622>; else goto <D.9628>;
  <D.9628>:
  D.9626 = __errno_location ();
  D.9627 = *D.9626;
  if (D.9627 == 20) goto <D.9622>; else goto <D.9629>;
  <D.9629>:
  D.9626 = __errno_location ();
  D.9627 = *D.9626;
  if (D.9627 == 21) goto <D.9622>; else goto <D.9623>;
  <D.9622>:
  __mono_io_portability_helpers.4 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.4 > 0) goto <D.9631>; else goto <D.9632>;
  <D.9631>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9626 = __errno_location ();
    saved_errno = *D.9626;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9633>; else goto <D.9634>;
    <D.9633>:
    D.9626 = __errno_location ();
    *D.9626 = saved_errno;
    D.9635 = -1;
    return D.9635;
    <D.9634>:
    ret = unlink (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.9632>:
  <D.9623>:
  <D.9625>:
  D.9635 = ret;
  return D.9635;
}


_wapi_rename (const char * oldpath, const char * newpath)
{
  int * D.9644;
  int D.9645;
  int __mono_io_portability_helpers.5;
  int D.9655;
  int ret;
  gchar * located_newpath;

  located_newpath = mono_portability_find_file (newpath, 0);
  if (located_newpath == 0B) goto <D.9637>; else goto <D.9638>;
  <D.9637>:
  ret = rename (oldpath, newpath);
  goto <D.9639>;
  <D.9638>:
  ret = rename (oldpath, located_newpath);
  if (ret == -1) goto <D.9642>; else goto <D.9643>;
  <D.9642>:
  D.9644 = __errno_location ();
  D.9645 = *D.9644;
  if (D.9645 == 21) goto <D.9640>; else goto <D.9646>;
  <D.9646>:
  D.9644 = __errno_location ();
  D.9645 = *D.9644;
  if (D.9645 == 36) goto <D.9640>; else goto <D.9647>;
  <D.9647>:
  D.9644 = __errno_location ();
  D.9645 = *D.9644;
  if (D.9645 == 2) goto <D.9640>; else goto <D.9648>;
  <D.9648>:
  D.9644 = __errno_location ();
  D.9645 = *D.9644;
  if (D.9645 == 20) goto <D.9640>; else goto <D.9649>;
  <D.9649>:
  D.9644 = __errno_location ();
  D.9645 = *D.9644;
  if (D.9645 == 18) goto <D.9640>; else goto <D.9641>;
  <D.9640>:
  __mono_io_portability_helpers.5 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.5 > 0) goto <D.9651>; else goto <D.9652>;
  <D.9651>:
  {
    int saved_errno;
    gchar * located_oldpath;

    D.9644 = __errno_location ();
    saved_errno = *D.9644;
    located_oldpath = mono_portability_find_file (oldpath, 1);
    if (located_oldpath == 0B) goto <D.9653>; else goto <D.9654>;
    <D.9653>:
    monoeg_g_free (located_oldpath);
    monoeg_g_free (located_newpath);
    D.9644 = __errno_location ();
    *D.9644 = saved_errno;
    D.9655 = -1;
    return D.9655;
    <D.9654>:
    ret = rename (located_oldpath, located_newpath);
    monoeg_g_free (located_oldpath);
  }
  <D.9652>:
  <D.9641>:
  <D.9643>:
  monoeg_g_free (located_newpath);
  <D.9639>:
  D.9655 = ret;
  return D.9655;
}


_wapi_stat (const char * path, struct stat * buf)
{
  int * D.9661;
  int D.9662;
  int __mono_io_portability_helpers.6;
  int D.9669;
  int ret;

  ret = stat (path, buf);
  if (ret == -1) goto <D.9659>; else goto <D.9660>;
  <D.9659>:
  D.9661 = __errno_location ();
  D.9662 = *D.9661;
  if (D.9662 == 2) goto <D.9657>; else goto <D.9663>;
  <D.9663>:
  D.9661 = __errno_location ();
  D.9662 = *D.9661;
  if (D.9662 == 20) goto <D.9657>; else goto <D.9658>;
  <D.9657>:
  __mono_io_portability_helpers.6 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.6 > 0) goto <D.9665>; else goto <D.9666>;
  <D.9665>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9661 = __errno_location ();
    saved_errno = *D.9661;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.9667>; else goto <D.9668>;
    <D.9667>:
    D.9661 = __errno_location ();
    *D.9661 = saved_errno;
    D.9669 = -1;
    return D.9669;
    <D.9668>:
    ret = stat (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.9666>:
  <D.9658>:
  <D.9660>:
  D.9669 = ret;
  return D.9669;
}


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

  D.9671 = __xstat (1, __path, __statbuf);
  return D.9671;
}


_wapi_lstat (const char * path, struct stat * buf)
{
  int * D.9677;
  int D.9678;
  int __mono_io_portability_helpers.7;
  int D.9685;
  int ret;

  ret = lstat (path, buf);
  if (ret == -1) goto <D.9675>; else goto <D.9676>;
  <D.9675>:
  D.9677 = __errno_location ();
  D.9678 = *D.9677;
  if (D.9678 == 2) goto <D.9673>; else goto <D.9679>;
  <D.9679>:
  D.9677 = __errno_location ();
  D.9678 = *D.9677;
  if (D.9678 == 20) goto <D.9673>; else goto <D.9674>;
  <D.9673>:
  __mono_io_portability_helpers.7 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.7 > 0) goto <D.9681>; else goto <D.9682>;
  <D.9681>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9677 = __errno_location ();
    saved_errno = *D.9677;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.9683>; else goto <D.9684>;
    <D.9683>:
    D.9677 = __errno_location ();
    *D.9677 = saved_errno;
    D.9685 = -1;
    return D.9685;
    <D.9684>:
    ret = lstat (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.9682>:
  <D.9674>:
  <D.9676>:
  D.9685 = ret;
  return D.9685;
}


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

  D.9687 = __lxstat (1, __path, __statbuf);
  return D.9687;
}


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

  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.9689>; else goto <D.9690>;
  <D.9689>:
  ret = mkdir (pathname, mode);
  goto <D.9691>;
  <D.9690>:
  ret = mkdir (located_filename, mode);
  monoeg_g_free (located_filename);
  <D.9691>:
  D.9692 = ret;
  return D.9692;
}


_wapi_rmdir (const char * pathname)
{
  int * D.9698;
  int D.9699;
  int __mono_io_portability_helpers.8;
  int D.9707;
  int ret;

  ret = rmdir (pathname);
  if (ret == -1) goto <D.9696>; else goto <D.9697>;
  <D.9696>:
  D.9698 = __errno_location ();
  D.9699 = *D.9698;
  if (D.9699 == 2) goto <D.9694>; else goto <D.9700>;
  <D.9700>:
  D.9698 = __errno_location ();
  D.9699 = *D.9698;
  if (D.9699 == 20) goto <D.9694>; else goto <D.9701>;
  <D.9701>:
  D.9698 = __errno_location ();
  D.9699 = *D.9698;
  if (D.9699 == 36) goto <D.9694>; else goto <D.9695>;
  <D.9694>:
  __mono_io_portability_helpers.8 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.8 > 0) goto <D.9703>; else goto <D.9704>;
  <D.9703>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9698 = __errno_location ();
    saved_errno = *D.9698;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9705>; else goto <D.9706>;
    <D.9705>:
    D.9698 = __errno_location ();
    *D.9698 = saved_errno;
    D.9707 = -1;
    return D.9707;
    <D.9706>:
    ret = rmdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.9704>:
  <D.9695>:
  <D.9697>:
  D.9707 = ret;
  return D.9707;
}


_wapi_chdir (const char * path)
{
  int * D.9713;
  int D.9714;
  int __mono_io_portability_helpers.9;
  int D.9722;
  int ret;

  ret = chdir (path);
  if (ret == -1) goto <D.9711>; else goto <D.9712>;
  <D.9711>:
  D.9713 = __errno_location ();
  D.9714 = *D.9713;
  if (D.9714 == 2) goto <D.9709>; else goto <D.9715>;
  <D.9715>:
  D.9713 = __errno_location ();
  D.9714 = *D.9713;
  if (D.9714 == 20) goto <D.9709>; else goto <D.9716>;
  <D.9716>:
  D.9713 = __errno_location ();
  D.9714 = *D.9713;
  if (D.9714 == 36) goto <D.9709>; else goto <D.9710>;
  <D.9709>:
  __mono_io_portability_helpers.9 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.9 > 0) goto <D.9718>; else goto <D.9719>;
  <D.9718>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9713 = __errno_location ();
    saved_errno = *D.9713;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.9720>; else goto <D.9721>;
    <D.9720>:
    D.9713 = __errno_location ();
    *D.9713 = saved_errno;
    D.9722 = -1;
    return D.9722;
    <D.9721>:
    ret = chdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.9719>:
  <D.9710>:
  <D.9712>:
  D.9722 = ret;
  return D.9722;
}


_wapi_basename (const gchar * filename)
{
  int __mono_io_portability_helpers.10;
  int D.9727;
  const short unsigned int * * D.9730;
  const short unsigned int * D.9731;
  char D.9732;
  long unsigned int D.9733;
  long unsigned int D.9734;
  const short unsigned int * D.9735;
  short unsigned int D.9736;
  int D.9737;
  int D.9738;
  gchar * D.9741;
  char D.9742;
  long unsigned int D.9745;
  const void * D.9746;
  int D.9747;
  long unsigned int D.9748;
  sizetype D.9749;
  sizetype D.9750;
  gchar * D.9751;
  gchar * D.9752;
  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.9725>; else goto <D.9726>;
  <D.9725>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.9726>:
  __mono_io_portability_helpers.10 = __mono_io_portability_helpers;
  D.9727 = __mono_io_portability_helpers.10 & 2;
  if (D.9727 != 0) goto <D.9728>; else goto <D.9729>;
  <D.9728>:
  D.9730 = __ctype_b_loc ();
  D.9731 = *D.9730;
  D.9732 = *new_filename;
  D.9733 = (long unsigned int) D.9732;
  D.9734 = D.9733 * 2;
  D.9735 = D.9731 + D.9734;
  D.9736 = *D.9735;
  D.9737 = (int) D.9736;
  D.9738 = D.9737 & 1024;
  if (D.9738 != 0) goto <D.9739>; else goto <D.9740>;
  <D.9739>:
  D.9741 = new_filename + 1;
  D.9742 = *D.9741;
  if (D.9742 == 58) goto <D.9743>; else goto <D.9744>;
  <D.9743>:
  {
    int len;

    D.9745 = strlen (new_filename);
    len = (int) D.9745;
    D.9746 = new_filename + 2;
    D.9747 = len + -2;
    D.9748 = (long unsigned int) D.9747;
    memmove (new_filename, D.9746, D.9748);
    D.9749 = (sizetype) len;
    D.9750 = D.9749 + 18446744073709551614;
    D.9751 = new_filename + D.9750;
    *D.9751 = 0;
  }
  <D.9744>:
  <D.9740>:
  <D.9729>:
  ret = monoeg_g_path_get_basename (new_filename);
  monoeg_g_free (new_filename);
  D.9752 = ret;
  return D.9752;
}


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

  if (str != 0B) goto <D.9754>; else goto <D.9755>;
  <D.9754>:
  D.9756 = __strdup (str);
  return D.9756;
  <D.9755>:
  D.9756 = 0B;
  return D.9756;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.9758;
  long unsigned int D.9759;

  D.9759 = __builtin_object_size (__dest, 0);
  D.9758 = __builtin___memmove_chk (__dest, __src, __len, D.9759);
  return D.9758;
}


_wapi_dirname (const gchar * filename)
{
  int __mono_io_portability_helpers.11;
  int D.9764;
  const short unsigned int * * D.9767;
  const short unsigned int * D.9768;
  char D.9769;
  long unsigned int D.9770;
  long unsigned int D.9771;
  const short unsigned int * D.9772;
  short unsigned int D.9773;
  int D.9774;
  int D.9775;
  gchar * D.9778;
  char D.9779;
  long unsigned int D.9782;
  const void * D.9783;
  int D.9784;
  long unsigned int D.9785;
  sizetype D.9786;
  sizetype D.9787;
  gchar * D.9788;
  gchar * D.9789;
  gchar * new_filename;
  gchar * ret;

  new_filename = monoeg_strdup (filename);
  __mono_io_portability_helpers.11 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.11 > 0) goto <D.9762>; else goto <D.9763>;
  <D.9762>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.9763>:
  __mono_io_portability_helpers.11 = __mono_io_portability_helpers;
  D.9764 = __mono_io_portability_helpers.11 & 2;
  if (D.9764 != 0) goto <D.9765>; else goto <D.9766>;
  <D.9765>:
  D.9767 = __ctype_b_loc ();
  D.9768 = *D.9767;
  D.9769 = *new_filename;
  D.9770 = (long unsigned int) D.9769;
  D.9771 = D.9770 * 2;
  D.9772 = D.9768 + D.9771;
  D.9773 = *D.9772;
  D.9774 = (int) D.9773;
  D.9775 = D.9774 & 1024;
  if (D.9775 != 0) goto <D.9776>; else goto <D.9777>;
  <D.9776>:
  D.9778 = new_filename + 1;
  D.9779 = *D.9778;
  if (D.9779 == 58) goto <D.9780>; else goto <D.9781>;
  <D.9780>:
  {
    int len;

    D.9782 = strlen (new_filename);
    len = (int) D.9782;
    D.9783 = new_filename + 2;
    D.9784 = len + -2;
    D.9785 = (long unsigned int) D.9784;
    memmove (new_filename, D.9783, D.9785);
    D.9786 = (sizetype) len;
    D.9787 = D.9786 + 18446744073709551614;
    D.9788 = new_filename + D.9787;
    *D.9788 = 0;
  }
  <D.9781>:
  <D.9777>:
  <D.9766>:
  ret = monoeg_g_path_get_dirname (new_filename);
  monoeg_g_free (new_filename);
  D.9789 = ret;
  return D.9789;
}


_wapi_g_dir_open (const gchar * path, guint flags, struct GError * * error)
{
  struct GError * D.9793;
  int D.9794;
  unsigned int D.9795;
  unsigned int D.9796;
  int __mono_io_portability_helpers.12;
  struct GDir * D.9804;
  struct GError * tmp_error.13;
  struct GDir * ret;

  ret = monoeg_g_dir_open (path, flags, error);
  if (ret == 0B) goto <D.9791>; else goto <D.9792>;
  <D.9791>:
  D.9793 = *error;
  D.9794 = D.9793->code;
  D.9795 = (unsigned int) D.9794;
  D.9796 = D.9795 + 4294967293;
  if (D.9796 <= 2) goto <D.9797>; else goto <D.9798>;
  <D.9797>:
  __mono_io_portability_helpers.12 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.12 > 0) goto <D.9800>; else goto <D.9801>;
  <D.9800>:
  {
    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.9802>; else goto <D.9803>;
        <D.9802>:
        D.9804 = 0B;
        return D.9804;
        <D.9803>:
        ret = monoeg_g_dir_open (located_filename, flags, &tmp_error);
        monoeg_g_free (located_filename);
        tmp_error.13 = tmp_error;
        if (tmp_error.13 == 0B) goto <D.9806>; else goto <D.9807>;
        <D.9806>:
        monoeg_g_clear_error (error);
        <D.9807>:
      }
    finally
      {
        tmp_error = {CLOBBER};
      }
  }
  <D.9801>:
  <D.9798>:
  <D.9792>:
  D.9804 = ret;
  return D.9804;
}


_wapi_io_scandir (const gchar * dirname, const gchar * pattern, gchar * * * namelist)
{
  struct GError * error.14;
  int D.9814;
  int D.9817;
  int D.9820;
  int * D.9823;
  gint D.9824;
  int __mono_io_portability_helpers.15;
  int D.9826;
  int D.9829;
  long unsigned int D.9832;
  long unsigned int D.9833;
  int D.9834;
  int D.9837;
  char * * D.9842;
  long unsigned int D.9843;
  long unsigned int D.9844;
  char * * D.9845;
  char * D.9846;
  gchar * D.9847;
  unsigned int D.9848;
  int D.9851;
  void * * D.9852;
  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.9811>; else goto <D.9812>;
      <D.9811>:
      {
        gint errnum;

        error.14 = error;
        D.9814 = error.14->code;
        errnum = get_errno_from_g_file_error (D.9814);
        error.14 = error;
        monoeg_g_error_free (error.14);
        if (errnum == 2) goto <D.9815>; else goto <D.9816>;
        <D.9815>:
        D.9817 = _wapi_access (dirname, 0);
        if (D.9817 == 0) goto <D.9818>; else goto <D.9819>;
        <D.9818>:
        D.9820 = _wapi_access (dirname, 5);
        if (D.9820 != 0) goto <D.9821>; else goto <D.9822>;
        <D.9821>:
        errnum = 13;
        <D.9822>:
        <D.9819>:
        <D.9816>:
        D.9823 = __errno_location ();
        *D.9823 = errnum;
        D.9824 = -1;
        return D.9824;
      }
      <D.9812>:
      __mono_io_portability_helpers.15 = __mono_io_portability_helpers;
      D.9826 = __mono_io_portability_helpers.15 & 4;
      if (D.9826 != 0) goto <D.9827>; else goto <D.9828>;
      <D.9827>:
      flags = 16384;
      <D.9828>:
      result = _wapi_glob (dir, pattern, flags, &glob_buf);
      D.9829 = monoeg_g_str_has_suffix (pattern, ".*");
      if (D.9829 != 0) goto <D.9830>; else goto <D.9831>;
      <D.9830>:
      {
        gchar * pattern2;
        gint result2;

        D.9832 = strlen (pattern);
        D.9833 = D.9832 + 18446744073709551614;
        pattern2 = monoeg_g_strndup (pattern, D.9833);
        monoeg_g_dir_rewind (dir);
        D.9834 = flags | 65;
        result2 = _wapi_glob (dir, pattern2, D.9834, &glob_buf);
        monoeg_g_free (pattern2);
        if (result != 0) goto <D.9835>; else goto <D.9836>;
        <D.9835>:
        result = result2;
        <D.9836>:
      }
      <D.9831>:
      monoeg_g_dir_close (dir);
      D.9837 = glob_buf.gl_pathc;
      if (D.9837 == 0) goto <D.9838>; else goto <D.9839>;
      <D.9838>:
      D.9824 = 0;
      return D.9824;
      <D.9839>:
      if (result != 0) goto <D.9840>; else goto <D.9841>;
      <D.9840>:
      D.9824 = -1;
      return D.9824;
      <D.9841>:
      names = monoeg_g_ptr_array_new ();
      i = 0;
      goto <D.9538>;
      <D.9537>:
      D.9842 = glob_buf.gl_pathv;
      D.9843 = (long unsigned int) i;
      D.9844 = D.9843 * 8;
      D.9845 = D.9842 + D.9844;
      D.9846 = *D.9845;
      D.9847 = monoeg_strdup (D.9846);
      monoeg_g_ptr_array_add (names, D.9847);
      i = i + 1;
      <D.9538>:
      D.9837 = glob_buf.gl_pathc;
      if (D.9837 > i) goto <D.9537>; else goto <D.9539>;
      <D.9539>:
      _wapi_globfree (&glob_buf);
      D.9848 = names->len;
      result = (gint) D.9848;
      if (result > 0) goto <D.9849>; else goto <D.9850>;
      <D.9849>:
      monoeg_g_ptr_array_sort (names, file_compare);
      D.9851 = result + 1;
      monoeg_g_ptr_array_set_size (names, D.9851);
      D.9852 = monoeg_g_ptr_array_free (names, 0);
      *namelist = D.9852;
      goto <D.9853>;
      <D.9850>:
      monoeg_g_ptr_array_free (names, 1);
      <D.9853>:
      D.9824 = result;
      return D.9824;
    }
  finally
    {
      error = {CLOBBER};
      glob_buf = {CLOBBER};
    }
}


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

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

    D.9497 = __builtin_strcmp (astr, bstr);
  }
  D.9856 = D.9497;
  return D.9856;
}


get_errno_from_g_file_error (gint error)
{
  gint D.9859;

  switch (error) <default: <D.9858>, case 3: <D.9501>, case 4: <D.9503>, case 5: <D.9504>, case 6: <D.9505>, case 7: <D.9506>, case 8: <D.9507>, case 9: <D.9508>, case 10: <D.9509>, case 11: <D.9510>, case 12: <D.9511>, case 13: <D.9512>, case 14: <D.9513>, case 15: <D.9514>, case 16: <D.9515>, case 17: <D.9516>, case 18: <D.9517>, case 19: <D.9518>, case 20: <D.9519>, case 22: <D.9520>, case 24: <D.9521>>
  <D.9501>:
  error = 36;
  goto <D.9502>;
  <D.9503>:
  error = 2;
  goto <D.9502>;
  <D.9504>:
  error = 20;
  goto <D.9502>;
  <D.9505>:
  error = 6;
  goto <D.9502>;
  <D.9506>:
  error = 19;
  goto <D.9502>;
  <D.9507>:
  error = 30;
  goto <D.9502>;
  <D.9508>:
  error = 26;
  goto <D.9502>;
  <D.9509>:
  error = 14;
  goto <D.9502>;
  <D.9510>:
  error = 40;
  goto <D.9502>;
  <D.9511>:
  error = 28;
  goto <D.9502>;
  <D.9512>:
  error = 12;
  goto <D.9502>;
  <D.9513>:
  error = 24;
  goto <D.9502>;
  <D.9514>:
  error = 23;
  goto <D.9502>;
  <D.9515>:
  error = 9;
  goto <D.9502>;
  <D.9516>:
  error = 22;
  goto <D.9502>;
  <D.9517>:
  error = 32;
  goto <D.9502>;
  <D.9518>:
  error = 11;
  goto <D.9502>;
  <D.9519>:
  error = 4;
  goto <D.9502>;
  <D.9520>:
  error = 1;
  goto <D.9502>;
  <D.9521>:
  error = 87;
  goto <D.9502>;
  <D.9858>:
  <D.9502>:
  D.9859 = error;
  return D.9859;
}