_wapi_open (const char * pathname, int flags, mode_t mode)
{
  int D.8706;
  int * D.8717;
  int D.8718;
  int __mono_io_portability_helpers.0;
  int D.8725;
  int fd;
  gchar * located_filename;

  D.8706 = flags & 256;
  if (D.8706 != 0) goto <D.8707>; else goto <D.8708>;
  <D.8707>:
  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.8709>; else goto <D.8710>;
  <D.8709>:
  fd = open (pathname, flags, mode);
  goto <D.8711>;
  <D.8710>:
  fd = open (located_filename, flags, mode);
  monoeg_g_free (located_filename);
  <D.8711>:
  goto <D.8712>;
  <D.8708>:
  fd = open (pathname, flags, mode);
  if (fd == -1) goto <D.8715>; else goto <D.8716>;
  <D.8715>:
  D.8717 = __errno_location ();
  D.8718 = *D.8717;
  if (D.8718 == 2) goto <D.8713>; else goto <D.8719>;
  <D.8719>:
  D.8717 = __errno_location ();
  D.8718 = *D.8717;
  if (D.8718 == 20) goto <D.8713>; else goto <D.8714>;
  <D.8713>:
  __mono_io_portability_helpers.0 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.0 > 0) goto <D.8721>; else goto <D.8722>;
  <D.8721>:
  {
    int saved_errno;

    D.8717 = __errno_location ();
    saved_errno = *D.8717;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8723>; else goto <D.8724>;
    <D.8723>:
    D.8717 = __errno_location ();
    *D.8717 = saved_errno;
    D.8725 = -1;
    return D.8725;
    <D.8724>:
    fd = open (located_filename, flags, mode);
    monoeg_g_free (located_filename);
  }
  <D.8722>:
  <D.8714>:
  <D.8716>:
  <D.8712>:
  D.8725 = fd;
  return D.8725;
}


open (const char * __path, int __oflag)
{
  int D.8727;
  int D.8730;
  int D.8735;
  int D.8737;
  int D.8738;
  int D.8741;
  int D.8742;

  D.8727 = __builtin_va_arg_pack_len ();
  if (D.8727 > 1) goto <D.8728>; else goto <D.8729>;
  <D.8728>:
  __open_too_many_args ();
  <D.8729>:
  D.8730 = __builtin_constant_p (__oflag);
  if (D.8730 != 0) goto <D.8731>; else goto <D.8732>;
  <D.8731>:
  D.8735 = __oflag & 256;
  if (D.8735 != 0) goto <D.8733>; else goto <D.8736>;
  <D.8736>:
  D.8737 = __oflag & 4259840;
  if (D.8737 == 4259840) goto <D.8733>; else goto <D.8734>;
  <D.8733>:
  D.8738 = __builtin_va_arg_pack_len ();
  if (D.8738 <= 0) goto <D.8739>; else goto <D.8740>;
  <D.8739>:
  __open_missing_mode ();
  D.8741 = __open_2 (__path, __oflag);
  return D.8741;
  <D.8740>:
  <D.8734>:
  D.8741 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8741;
  <D.8732>:
  D.8742 = __builtin_va_arg_pack_len ();
  if (D.8742 <= 0) goto <D.8743>; else goto <D.8744>;
  <D.8743>:
  D.8741 = __open_2 (__path, __oflag);
  return D.8741;
  <D.8744>:
  D.8741 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.8741;
}


_wapi_access (const char * pathname, int mode)
{
  int * D.8750;
  int D.8751;
  int __mono_io_portability_helpers.1;
  int D.8758;
  int ret;

  ret = access (pathname, mode);
  if (ret == -1) goto <D.8748>; else goto <D.8749>;
  <D.8748>:
  D.8750 = __errno_location ();
  D.8751 = *D.8750;
  if (D.8751 == 2) goto <D.8746>; else goto <D.8752>;
  <D.8752>:
  D.8750 = __errno_location ();
  D.8751 = *D.8750;
  if (D.8751 == 20) goto <D.8746>; else goto <D.8747>;
  <D.8746>:
  __mono_io_portability_helpers.1 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.1 > 0) goto <D.8754>; else goto <D.8755>;
  <D.8754>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8750 = __errno_location ();
    saved_errno = *D.8750;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8756>; else goto <D.8757>;
    <D.8756>:
    D.8750 = __errno_location ();
    *D.8750 = saved_errno;
    D.8758 = -1;
    return D.8758;
    <D.8757>:
    ret = access (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.8755>:
  <D.8747>:
  <D.8749>:
  D.8758 = ret;
  return D.8758;
}


_wapi_chmod (const char * pathname, mode_t mode)
{
  int * D.8764;
  int D.8765;
  int __mono_io_portability_helpers.2;
  int D.8772;
  int ret;

  ret = chmod (pathname, mode);
  if (ret == -1) goto <D.8762>; else goto <D.8763>;
  <D.8762>:
  D.8764 = __errno_location ();
  D.8765 = *D.8764;
  if (D.8765 == 2) goto <D.8760>; else goto <D.8766>;
  <D.8766>:
  D.8764 = __errno_location ();
  D.8765 = *D.8764;
  if (D.8765 == 20) goto <D.8760>; else goto <D.8761>;
  <D.8760>:
  __mono_io_portability_helpers.2 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.2 > 0) goto <D.8768>; else goto <D.8769>;
  <D.8768>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8764 = __errno_location ();
    saved_errno = *D.8764;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8770>; else goto <D.8771>;
    <D.8770>:
    D.8764 = __errno_location ();
    *D.8764 = saved_errno;
    D.8772 = -1;
    return D.8772;
    <D.8771>:
    ret = chmod (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.8769>:
  <D.8761>:
  <D.8763>:
  D.8772 = ret;
  return D.8772;
}


_wapi_utime (const char * filename, const struct utimbuf * buf)
{
  int * D.8776;
  int D.8777;
  int __mono_io_portability_helpers.3;
  int D.8785;
  int ret;

  ret = utime (filename, buf);
  if (ret == -1) goto <D.8774>; else goto <D.8775>;
  <D.8774>:
  D.8776 = __errno_location ();
  D.8777 = *D.8776;
  if (D.8777 == 2) goto <D.8778>; else goto <D.8779>;
  <D.8778>:
  __mono_io_portability_helpers.3 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.3 > 0) goto <D.8781>; else goto <D.8782>;
  <D.8781>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8776 = __errno_location ();
    saved_errno = *D.8776;
    located_filename = mono_portability_find_file (filename, 1);
    if (located_filename == 0B) goto <D.8783>; else goto <D.8784>;
    <D.8783>:
    D.8776 = __errno_location ();
    *D.8776 = saved_errno;
    D.8785 = -1;
    return D.8785;
    <D.8784>:
    ret = utime (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.8782>:
  <D.8779>:
  <D.8775>:
  D.8785 = ret;
  return D.8785;
}


_wapi_unlink (const char * pathname)
{
  int * D.8791;
  int D.8792;
  int __mono_io_portability_helpers.4;
  int D.8800;
  int ret;

  ret = unlink (pathname);
  if (ret == -1) goto <D.8789>; else goto <D.8790>;
  <D.8789>:
  D.8791 = __errno_location ();
  D.8792 = *D.8791;
  if (D.8792 == 2) goto <D.8787>; else goto <D.8793>;
  <D.8793>:
  D.8791 = __errno_location ();
  D.8792 = *D.8791;
  if (D.8792 == 20) goto <D.8787>; else goto <D.8794>;
  <D.8794>:
  D.8791 = __errno_location ();
  D.8792 = *D.8791;
  if (D.8792 == 21) goto <D.8787>; else goto <D.8788>;
  <D.8787>:
  __mono_io_portability_helpers.4 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.4 > 0) goto <D.8796>; else goto <D.8797>;
  <D.8796>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8791 = __errno_location ();
    saved_errno = *D.8791;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8798>; else goto <D.8799>;
    <D.8798>:
    D.8791 = __errno_location ();
    *D.8791 = saved_errno;
    D.8800 = -1;
    return D.8800;
    <D.8799>:
    ret = unlink (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.8797>:
  <D.8788>:
  <D.8790>:
  D.8800 = ret;
  return D.8800;
}


_wapi_rename (const char * oldpath, const char * newpath)
{
  int * D.8809;
  int D.8810;
  int __mono_io_portability_helpers.5;
  int D.8820;
  int ret;
  gchar * located_newpath;

  located_newpath = mono_portability_find_file (newpath, 0);
  if (located_newpath == 0B) goto <D.8802>; else goto <D.8803>;
  <D.8802>:
  ret = rename (oldpath, newpath);
  goto <D.8804>;
  <D.8803>:
  ret = rename (oldpath, located_newpath);
  if (ret == -1) goto <D.8807>; else goto <D.8808>;
  <D.8807>:
  D.8809 = __errno_location ();
  D.8810 = *D.8809;
  if (D.8810 == 21) goto <D.8805>; else goto <D.8811>;
  <D.8811>:
  D.8809 = __errno_location ();
  D.8810 = *D.8809;
  if (D.8810 == 78) goto <D.8805>; else goto <D.8812>;
  <D.8812>:
  D.8809 = __errno_location ();
  D.8810 = *D.8809;
  if (D.8810 == 2) goto <D.8805>; else goto <D.8813>;
  <D.8813>:
  D.8809 = __errno_location ();
  D.8810 = *D.8809;
  if (D.8810 == 20) goto <D.8805>; else goto <D.8814>;
  <D.8814>:
  D.8809 = __errno_location ();
  D.8810 = *D.8809;
  if (D.8810 == 18) goto <D.8805>; else goto <D.8806>;
  <D.8805>:
  __mono_io_portability_helpers.5 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.5 > 0) goto <D.8816>; else goto <D.8817>;
  <D.8816>:
  {
    int saved_errno;
    gchar * located_oldpath;

    D.8809 = __errno_location ();
    saved_errno = *D.8809;
    located_oldpath = mono_portability_find_file (oldpath, 1);
    if (located_oldpath == 0B) goto <D.8818>; else goto <D.8819>;
    <D.8818>:
    monoeg_g_free (located_oldpath);
    monoeg_g_free (located_newpath);
    D.8809 = __errno_location ();
    *D.8809 = saved_errno;
    D.8820 = -1;
    return D.8820;
    <D.8819>:
    ret = rename (located_oldpath, located_newpath);
    monoeg_g_free (located_oldpath);
  }
  <D.8817>:
  <D.8806>:
  <D.8808>:
  monoeg_g_free (located_newpath);
  <D.8804>:
  D.8820 = ret;
  return D.8820;
}


_wapi_stat (const char * path, struct stat * buf)
{
  int * D.8826;
  int D.8827;
  int __mono_io_portability_helpers.6;
  int D.8834;
  int ret;

  ret = stat (path, buf);
  if (ret == -1) goto <D.8824>; else goto <D.8825>;
  <D.8824>:
  D.8826 = __errno_location ();
  D.8827 = *D.8826;
  if (D.8827 == 2) goto <D.8822>; else goto <D.8828>;
  <D.8828>:
  D.8826 = __errno_location ();
  D.8827 = *D.8826;
  if (D.8827 == 20) goto <D.8822>; else goto <D.8823>;
  <D.8822>:
  __mono_io_portability_helpers.6 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.6 > 0) goto <D.8830>; else goto <D.8831>;
  <D.8830>:
  {
    int saved_errno;
    gchar * located_filename;

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


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

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


_wapi_lstat (const char * path, struct stat * buf)
{
  int * D.8842;
  int D.8843;
  int __mono_io_portability_helpers.7;
  int D.8850;
  int ret;

  ret = lstat (path, buf);
  if (ret == -1) goto <D.8840>; else goto <D.8841>;
  <D.8840>:
  D.8842 = __errno_location ();
  D.8843 = *D.8842;
  if (D.8843 == 2) goto <D.8838>; else goto <D.8844>;
  <D.8844>:
  D.8842 = __errno_location ();
  D.8843 = *D.8842;
  if (D.8843 == 20) goto <D.8838>; else goto <D.8839>;
  <D.8838>:
  __mono_io_portability_helpers.7 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.7 > 0) goto <D.8846>; else goto <D.8847>;
  <D.8846>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8842 = __errno_location ();
    saved_errno = *D.8842;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.8848>; else goto <D.8849>;
    <D.8848>:
    D.8842 = __errno_location ();
    *D.8842 = saved_errno;
    D.8850 = -1;
    return D.8850;
    <D.8849>:
    ret = lstat (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.8847>:
  <D.8839>:
  <D.8841>:
  D.8850 = ret;
  return D.8850;
}


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

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


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

  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.8854>; else goto <D.8855>;
  <D.8854>:
  ret = mkdir (pathname, mode);
  goto <D.8856>;
  <D.8855>:
  ret = mkdir (located_filename, mode);
  monoeg_g_free (located_filename);
  <D.8856>:
  D.8857 = ret;
  return D.8857;
}


_wapi_rmdir (const char * pathname)
{
  int * D.8863;
  int D.8864;
  int __mono_io_portability_helpers.8;
  int D.8872;
  int ret;

  ret = rmdir (pathname);
  if (ret == -1) goto <D.8861>; else goto <D.8862>;
  <D.8861>:
  D.8863 = __errno_location ();
  D.8864 = *D.8863;
  if (D.8864 == 2) goto <D.8859>; else goto <D.8865>;
  <D.8865>:
  D.8863 = __errno_location ();
  D.8864 = *D.8863;
  if (D.8864 == 20) goto <D.8859>; else goto <D.8866>;
  <D.8866>:
  D.8863 = __errno_location ();
  D.8864 = *D.8863;
  if (D.8864 == 78) goto <D.8859>; else goto <D.8860>;
  <D.8859>:
  __mono_io_portability_helpers.8 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.8 > 0) goto <D.8868>; else goto <D.8869>;
  <D.8868>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8863 = __errno_location ();
    saved_errno = *D.8863;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.8870>; else goto <D.8871>;
    <D.8870>:
    D.8863 = __errno_location ();
    *D.8863 = saved_errno;
    D.8872 = -1;
    return D.8872;
    <D.8871>:
    ret = rmdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.8869>:
  <D.8860>:
  <D.8862>:
  D.8872 = ret;
  return D.8872;
}


_wapi_chdir (const char * path)
{
  int * D.8878;
  int D.8879;
  int __mono_io_portability_helpers.9;
  int D.8887;
  int ret;

  ret = chdir (path);
  if (ret == -1) goto <D.8876>; else goto <D.8877>;
  <D.8876>:
  D.8878 = __errno_location ();
  D.8879 = *D.8878;
  if (D.8879 == 2) goto <D.8874>; else goto <D.8880>;
  <D.8880>:
  D.8878 = __errno_location ();
  D.8879 = *D.8878;
  if (D.8879 == 20) goto <D.8874>; else goto <D.8881>;
  <D.8881>:
  D.8878 = __errno_location ();
  D.8879 = *D.8878;
  if (D.8879 == 78) goto <D.8874>; else goto <D.8875>;
  <D.8874>:
  __mono_io_portability_helpers.9 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.9 > 0) goto <D.8883>; else goto <D.8884>;
  <D.8883>:
  {
    int saved_errno;
    gchar * located_filename;

    D.8878 = __errno_location ();
    saved_errno = *D.8878;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.8885>; else goto <D.8886>;
    <D.8885>:
    D.8878 = __errno_location ();
    *D.8878 = saved_errno;
    D.8887 = -1;
    return D.8887;
    <D.8886>:
    ret = chdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.8884>:
  <D.8875>:
  <D.8877>:
  D.8887 = ret;
  return D.8887;
}


_wapi_basename (const gchar * filename)
{
  int __mono_io_portability_helpers.10;
  int D.8892;
  const short unsigned int * * D.8895;
  const short unsigned int * D.8896;
  char D.8897;
  unsigned int D.8898;
  unsigned int D.8899;
  const short unsigned int * D.8900;
  short unsigned int D.8901;
  int D.8902;
  int D.8903;
  gchar * D.8906;
  char D.8907;
  unsigned int D.8910;
  const void * D.8911;
  int D.8912;
  unsigned int D.8913;
  sizetype len.11;
  sizetype D.8915;
  gchar * D.8916;
  gchar * D.8917;
  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.8890>; else goto <D.8891>;
  <D.8890>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.8891>:
  __mono_io_portability_helpers.10 = __mono_io_portability_helpers;
  D.8892 = __mono_io_portability_helpers.10 & 2;
  if (D.8892 != 0) goto <D.8893>; else goto <D.8894>;
  <D.8893>:
  D.8895 = __ctype_b_loc ();
  D.8896 = *D.8895;
  D.8897 = *new_filename;
  D.8898 = (unsigned int) D.8897;
  D.8899 = D.8898 * 2;
  D.8900 = D.8896 + D.8899;
  D.8901 = *D.8900;
  D.8902 = (int) D.8901;
  D.8903 = D.8902 & 1024;
  if (D.8903 != 0) goto <D.8904>; else goto <D.8905>;
  <D.8904>:
  D.8906 = new_filename + 1;
  D.8907 = *D.8906;
  if (D.8907 == 58) goto <D.8908>; else goto <D.8909>;
  <D.8908>:
  {
    int len;

    D.8910 = strlen (new_filename);
    len = (int) D.8910;
    D.8911 = new_filename + 2;
    D.8912 = len + -2;
    D.8913 = (unsigned int) D.8912;
    memmove (new_filename, D.8911, D.8913);
    len.11 = (sizetype) len;
    D.8915 = len.11 + 4294967294;
    D.8916 = new_filename + D.8915;
    *D.8916 = 0;
  }
  <D.8909>:
  <D.8905>:
  <D.8894>:
  ret = monoeg_g_path_get_basename (new_filename);
  monoeg_g_free (new_filename);
  D.8917 = ret;
  return D.8917;
}


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

  if (str != 0B) goto <D.8919>; else goto <D.8920>;
  <D.8919>:
  D.8921 = __strdup (str);
  return D.8921;
  <D.8920>:
  D.8921 = 0B;
  return D.8921;
}


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

  D.8924 = __builtin_object_size (__dest, 0);
  D.8923 = __builtin___memmove_chk (__dest, __src, __len, D.8924);
  return D.8923;
}


_wapi_dirname (const gchar * filename)
{
  int __mono_io_portability_helpers.12;
  int D.8929;
  const short unsigned int * * D.8932;
  const short unsigned int * D.8933;
  char D.8934;
  unsigned int D.8935;
  unsigned int D.8936;
  const short unsigned int * D.8937;
  short unsigned int D.8938;
  int D.8939;
  int D.8940;
  gchar * D.8943;
  char D.8944;
  unsigned int D.8947;
  const void * D.8948;
  int D.8949;
  unsigned int D.8950;
  sizetype len.13;
  sizetype D.8952;
  gchar * D.8953;
  gchar * D.8954;
  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.8927>; else goto <D.8928>;
  <D.8927>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.8928>:
  __mono_io_portability_helpers.12 = __mono_io_portability_helpers;
  D.8929 = __mono_io_portability_helpers.12 & 2;
  if (D.8929 != 0) goto <D.8930>; else goto <D.8931>;
  <D.8930>:
  D.8932 = __ctype_b_loc ();
  D.8933 = *D.8932;
  D.8934 = *new_filename;
  D.8935 = (unsigned int) D.8934;
  D.8936 = D.8935 * 2;
  D.8937 = D.8933 + D.8936;
  D.8938 = *D.8937;
  D.8939 = (int) D.8938;
  D.8940 = D.8939 & 1024;
  if (D.8940 != 0) goto <D.8941>; else goto <D.8942>;
  <D.8941>:
  D.8943 = new_filename + 1;
  D.8944 = *D.8943;
  if (D.8944 == 58) goto <D.8945>; else goto <D.8946>;
  <D.8945>:
  {
    int len;

    D.8947 = strlen (new_filename);
    len = (int) D.8947;
    D.8948 = new_filename + 2;
    D.8949 = len + -2;
    D.8950 = (unsigned int) D.8949;
    memmove (new_filename, D.8948, D.8950);
    len.13 = (sizetype) len;
    D.8952 = len.13 + 4294967294;
    D.8953 = new_filename + D.8952;
    *D.8953 = 0;
  }
  <D.8946>:
  <D.8942>:
  <D.8931>:
  ret = monoeg_g_path_get_dirname (new_filename);
  monoeg_g_free (new_filename);
  D.8954 = ret;
  return D.8954;
}


_wapi_g_dir_open (const gchar * path, guint flags, struct GError * * error)
{
  struct GError * D.8958;
  int D.8959;
  unsigned int D.8960;
  unsigned int D.8961;
  int __mono_io_portability_helpers.14;
  struct GDir * D.8969;
  struct GError * tmp_error.15;
  struct GDir * ret;

  ret = monoeg_g_dir_open (path, flags, error);
  if (ret == 0B) goto <D.8956>; else goto <D.8957>;
  <D.8956>:
  D.8958 = *error;
  D.8959 = D.8958->code;
  D.8960 = (unsigned int) D.8959;
  D.8961 = D.8960 + 4294967293;
  if (D.8961 <= 2) goto <D.8962>; else goto <D.8963>;
  <D.8962>:
  __mono_io_portability_helpers.14 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.14 > 0) goto <D.8965>; else goto <D.8966>;
  <D.8965>:
  {
    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.8967>; else goto <D.8968>;
        <D.8967>:
        D.8969 = 0B;
        return D.8969;
        <D.8968>:
        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.8971>; else goto <D.8972>;
        <D.8971>:
        monoeg_g_clear_error (error);
        <D.8972>:
      }
    finally
      {
        tmp_error = {CLOBBER};
      }
  }
  <D.8966>:
  <D.8963>:
  <D.8957>:
  D.8969 = ret;
  return D.8969;
}


_wapi_io_scandir (const gchar * dirname, const gchar * pattern, gchar * * * namelist)
{
  struct GError * error.16;
  int D.8979;
  int D.8982;
  int D.8985;
  int * D.8988;
  gint D.8989;
  int __mono_io_portability_helpers.17;
  int D.8991;
  int D.8994;
  unsigned int D.8997;
  unsigned int D.8998;
  int D.8999;
  int D.9002;
  char * * D.9007;
  unsigned int i.18;
  unsigned int D.9009;
  char * * D.9010;
  char * D.9011;
  gchar * D.9012;
  unsigned int D.9013;
  int D.9016;
  void * * D.9017;
  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.8976>; else goto <D.8977>;
      <D.8976>:
      {
        gint errnum;

        error.16 = error;
        D.8979 = error.16->code;
        errnum = get_errno_from_g_file_error (D.8979);
        error.16 = error;
        monoeg_g_error_free (error.16);
        if (errnum == 2) goto <D.8980>; else goto <D.8981>;
        <D.8980>:
        D.8982 = _wapi_access (dirname, 0);
        if (D.8982 == 0) goto <D.8983>; else goto <D.8984>;
        <D.8983>:
        D.8985 = _wapi_access (dirname, 5);
        if (D.8985 != 0) goto <D.8986>; else goto <D.8987>;
        <D.8986>:
        errnum = 13;
        <D.8987>:
        <D.8984>:
        <D.8981>:
        D.8988 = __errno_location ();
        *D.8988 = errnum;
        D.8989 = -1;
        return D.8989;
      }
      <D.8977>:
      __mono_io_portability_helpers.17 = __mono_io_portability_helpers;
      D.8991 = __mono_io_portability_helpers.17 & 4;
      if (D.8991 != 0) goto <D.8992>; else goto <D.8993>;
      <D.8992>:
      flags = 16384;
      <D.8993>:
      result = _wapi_glob (dir, pattern, flags, &glob_buf);
      D.8994 = monoeg_g_str_has_suffix (pattern, ".*");
      if (D.8994 != 0) goto <D.8995>; else goto <D.8996>;
      <D.8995>:
      {
        gchar * pattern2;
        gint result2;

        D.8997 = strlen (pattern);
        D.8998 = D.8997 + 4294967294;
        pattern2 = monoeg_g_strndup (pattern, D.8998);
        monoeg_g_dir_rewind (dir);
        D.8999 = flags | 65;
        result2 = _wapi_glob (dir, pattern2, D.8999, &glob_buf);
        monoeg_g_free (pattern2);
        if (result != 0) goto <D.9000>; else goto <D.9001>;
        <D.9000>:
        result = result2;
        <D.9001>:
      }
      <D.8996>:
      monoeg_g_dir_close (dir);
      D.9002 = glob_buf.gl_pathc;
      if (D.9002 == 0) goto <D.9003>; else goto <D.9004>;
      <D.9003>:
      D.8989 = 0;
      return D.8989;
      <D.9004>:
      if (result != 0) goto <D.9005>; else goto <D.9006>;
      <D.9005>:
      D.8989 = -1;
      return D.8989;
      <D.9006>:
      names = monoeg_g_ptr_array_new ();
      i = 0;
      goto <D.8703>;
      <D.8702>:
      D.9007 = glob_buf.gl_pathv;
      i.18 = (unsigned int) i;
      D.9009 = i.18 * 4;
      D.9010 = D.9007 + D.9009;
      D.9011 = *D.9010;
      D.9012 = monoeg_strdup (D.9011);
      monoeg_g_ptr_array_add (names, D.9012);
      i = i + 1;
      <D.8703>:
      D.9002 = glob_buf.gl_pathc;
      if (D.9002 > i) goto <D.8702>; else goto <D.8704>;
      <D.8704>:
      _wapi_globfree (&glob_buf);
      D.9013 = names->len;
      result = (gint) D.9013;
      if (result > 0) goto <D.9014>; else goto <D.9015>;
      <D.9014>:
      monoeg_g_ptr_array_sort (names, file_compare);
      D.9016 = result + 1;
      monoeg_g_ptr_array_set_size (names, D.9016);
      D.9017 = monoeg_g_ptr_array_free (names, 0);
      *namelist = D.9017;
      goto <D.9018>;
      <D.9015>:
      monoeg_g_ptr_array_free (names, 1);
      <D.9018>:
      D.8989 = result;
      return D.8989;
    }
  finally
    {
      error = {CLOBBER};
      glob_buf = {CLOBBER};
    }
}


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

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

    D.8662 = __builtin_strcmp (astr, bstr);
  }
  D.9021 = D.8662;
  return D.9021;
}


get_errno_from_g_file_error (gint error)
{
  gint D.9024;

  switch (error) <default: <D.9023>, case 3: <D.8666>, case 4: <D.8668>, case 5: <D.8669>, case 6: <D.8670>, case 7: <D.8671>, case 8: <D.8672>, case 9: <D.8673>, case 10: <D.8674>, case 11: <D.8675>, case 12: <D.8676>, case 13: <D.8677>, case 14: <D.8678>, case 15: <D.8679>, case 16: <D.8680>, case 17: <D.8681>, case 18: <D.8682>, case 19: <D.8683>, case 20: <D.8684>, case 22: <D.8685>, case 24: <D.8686>>
  <D.8666>:
  error = 78;
  goto <D.8667>;
  <D.8668>:
  error = 2;
  goto <D.8667>;
  <D.8669>:
  error = 20;
  goto <D.8667>;
  <D.8670>:
  error = 6;
  goto <D.8667>;
  <D.8671>:
  error = 19;
  goto <D.8667>;
  <D.8672>:
  error = 30;
  goto <D.8667>;
  <D.8673>:
  error = 26;
  goto <D.8667>;
  <D.8674>:
  error = 14;
  goto <D.8667>;
  <D.8675>:
  error = 90;
  goto <D.8667>;
  <D.8676>:
  error = 28;
  goto <D.8667>;
  <D.8677>:
  error = 12;
  goto <D.8667>;
  <D.8678>:
  error = 24;
  goto <D.8667>;
  <D.8679>:
  error = 23;
  goto <D.8667>;
  <D.8680>:
  error = 9;
  goto <D.8667>;
  <D.8681>:
  error = 22;
  goto <D.8667>;
  <D.8682>:
  error = 32;
  goto <D.8667>;
  <D.8683>:
  error = 11;
  goto <D.8667>;
  <D.8684>:
  error = 4;
  goto <D.8667>;
  <D.8685>:
  error = 1;
  goto <D.8667>;
  <D.8686>:
  error = 87;
  goto <D.8667>;
  <D.9023>:
  <D.8667>:
  D.9024 = error;
  return D.9024;
}