_wapi_open (const char * pathname, int flags, mode_t mode)
{
  int D.9023;
  int * D.9032;
  int D.9033;
  _Bool D.9034;
  _Bool D.9035;
  _Bool D.9036;
  int __mono_io_portability_helpers.0;
  int D.9044;
  int fd;
  gchar * located_filename;

  D.9023 = flags & 64;
  if (D.9023 != 0) goto <D.9024>; else goto <D.9025>;
  <D.9024>:
  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.9026>; else goto <D.9027>;
  <D.9026>:
  fd = open (pathname, flags, mode);
  goto <D.9028>;
  <D.9027>:
  fd = open (located_filename, flags, mode);
  monoeg_g_free (located_filename);
  <D.9028>:
  goto <D.9029>;
  <D.9025>:
  fd = open (pathname, flags, mode);
  if (fd == -1) goto <D.9030>; else goto <D.9031>;
  <D.9030>:
  D.9032 = __errno_location ();
  D.9033 = *D.9032;
  D.9034 = D.9033 == 2;
  D.9035 = D.9033 == 20;
  D.9036 = D.9034 | D.9035;
  if (D.9036 != 0) goto <D.9037>; else goto <D.9038>;
  <D.9037>:
  __mono_io_portability_helpers.0 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.0 > 0) goto <D.9040>; else goto <D.9041>;
  <D.9040>:
  {
    int saved_errno;

    D.9032 = __errno_location ();
    saved_errno = *D.9032;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9042>; else goto <D.9043>;
    <D.9042>:
    D.9032 = __errno_location ();
    *D.9032 = saved_errno;
    D.9044 = -1;
    return D.9044;
    <D.9043>:
    fd = open (located_filename, flags, mode);
    monoeg_g_free (located_filename);
  }
  <D.9041>:
  <D.9038>:
  <D.9031>:
  <D.9029>:
  D.9044 = fd;
  return D.9044;
}


open (const char * __path, int __oflag)
{
  int D.9046;
  int D.9049;
  int D.9054;
  int D.9056;
  int D.9057;
  int D.9060;
  int D.9061;

  D.9046 = __builtin_va_arg_pack_len ();
  if (D.9046 > 1) goto <D.9047>; else goto <D.9048>;
  <D.9047>:
  __open_too_many_args ();
  <D.9048>:
  D.9049 = __builtin_constant_p (__oflag);
  if (D.9049 != 0) goto <D.9050>; else goto <D.9051>;
  <D.9050>:
  D.9054 = __oflag & 64;
  if (D.9054 != 0) goto <D.9052>; else goto <D.9055>;
  <D.9055>:
  D.9056 = __oflag & 4259840;
  if (D.9056 == 4259840) goto <D.9052>; else goto <D.9053>;
  <D.9052>:
  D.9057 = __builtin_va_arg_pack_len ();
  if (D.9057 <= 0) goto <D.9058>; else goto <D.9059>;
  <D.9058>:
  __open_missing_mode ();
  D.9060 = __open_2 (__path, __oflag);
  return D.9060;
  <D.9059>:
  <D.9053>:
  D.9060 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.9060;
  <D.9051>:
  D.9061 = __builtin_va_arg_pack_len ();
  if (D.9061 <= 0) goto <D.9062>; else goto <D.9063>;
  <D.9062>:
  D.9060 = __open_2 (__path, __oflag);
  return D.9060;
  <D.9063>:
  D.9060 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.9060;
}


_wapi_access (const char * pathname, int mode)
{
  int * D.9067;
  int D.9068;
  _Bool D.9069;
  _Bool D.9070;
  _Bool D.9071;
  int __mono_io_portability_helpers.1;
  int D.9079;
  int ret;

  ret = access (pathname, mode);
  if (ret == -1) goto <D.9065>; else goto <D.9066>;
  <D.9065>:
  D.9067 = __errno_location ();
  D.9068 = *D.9067;
  D.9069 = D.9068 == 2;
  D.9070 = D.9068 == 20;
  D.9071 = D.9069 | D.9070;
  if (D.9071 != 0) goto <D.9072>; else goto <D.9073>;
  <D.9072>:
  __mono_io_portability_helpers.1 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.1 > 0) goto <D.9075>; else goto <D.9076>;
  <D.9075>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9067 = __errno_location ();
    saved_errno = *D.9067;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9077>; else goto <D.9078>;
    <D.9077>:
    D.9067 = __errno_location ();
    *D.9067 = saved_errno;
    D.9079 = -1;
    return D.9079;
    <D.9078>:
    ret = access (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.9076>:
  <D.9073>:
  <D.9066>:
  D.9079 = ret;
  return D.9079;
}


_wapi_chmod (const char * pathname, mode_t mode)
{
  int * D.9083;
  int D.9084;
  _Bool D.9085;
  _Bool D.9086;
  _Bool D.9087;
  int __mono_io_portability_helpers.2;
  int D.9095;
  int ret;

  ret = chmod (pathname, mode);
  if (ret == -1) goto <D.9081>; else goto <D.9082>;
  <D.9081>:
  D.9083 = __errno_location ();
  D.9084 = *D.9083;
  D.9085 = D.9084 == 2;
  D.9086 = D.9084 == 20;
  D.9087 = D.9085 | D.9086;
  if (D.9087 != 0) goto <D.9088>; else goto <D.9089>;
  <D.9088>:
  __mono_io_portability_helpers.2 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.2 > 0) goto <D.9091>; else goto <D.9092>;
  <D.9091>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9083 = __errno_location ();
    saved_errno = *D.9083;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9093>; else goto <D.9094>;
    <D.9093>:
    D.9083 = __errno_location ();
    *D.9083 = saved_errno;
    D.9095 = -1;
    return D.9095;
    <D.9094>:
    ret = chmod (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.9092>:
  <D.9089>:
  <D.9082>:
  D.9095 = ret;
  return D.9095;
}


_wapi_utime (const char * filename, const struct utimbuf * buf)
{
  int * D.9099;
  int D.9100;
  int __mono_io_portability_helpers.3;
  int D.9108;
  int ret;

  ret = utime (filename, buf);
  if (ret == -1) goto <D.9097>; else goto <D.9098>;
  <D.9097>:
  D.9099 = __errno_location ();
  D.9100 = *D.9099;
  if (D.9100 == 2) goto <D.9101>; else goto <D.9102>;
  <D.9101>:
  __mono_io_portability_helpers.3 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.3 > 0) goto <D.9104>; else goto <D.9105>;
  <D.9104>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9099 = __errno_location ();
    saved_errno = *D.9099;
    located_filename = mono_portability_find_file (filename, 1);
    if (located_filename == 0B) goto <D.9106>; else goto <D.9107>;
    <D.9106>:
    D.9099 = __errno_location ();
    *D.9099 = saved_errno;
    D.9108 = -1;
    return D.9108;
    <D.9107>:
    ret = utime (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.9105>:
  <D.9102>:
  <D.9098>:
  D.9108 = ret;
  return D.9108;
}


_wapi_unlink (const char * pathname)
{
  int * D.9114;
  int D.9115;
  _Bool D.9116;
  _Bool D.9117;
  _Bool D.9118;
  int D.9120;
  int __mono_io_portability_helpers.4;
  int D.9126;
  int ret;

  ret = unlink (pathname);
  if (ret == -1) goto <D.9112>; else goto <D.9113>;
  <D.9112>:
  D.9114 = __errno_location ();
  D.9115 = *D.9114;
  D.9116 = D.9115 == 2;
  D.9117 = D.9115 == 20;
  D.9118 = D.9116 | D.9117;
  if (D.9118 != 0) goto <D.9110>; else goto <D.9119>;
  <D.9119>:
  D.9114 = __errno_location ();
  D.9120 = *D.9114;
  if (D.9120 == 21) goto <D.9110>; else goto <D.9111>;
  <D.9110>:
  __mono_io_portability_helpers.4 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.4 > 0) goto <D.9122>; else goto <D.9123>;
  <D.9122>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9114 = __errno_location ();
    saved_errno = *D.9114;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9124>; else goto <D.9125>;
    <D.9124>:
    D.9114 = __errno_location ();
    *D.9114 = saved_errno;
    D.9126 = -1;
    return D.9126;
    <D.9125>:
    ret = unlink (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.9123>:
  <D.9111>:
  <D.9113>:
  D.9126 = ret;
  return D.9126;
}


_wapi_rename (const char * oldpath, const char * newpath)
{
  int * D.9135;
  int D.9136;
  _Bool D.9137;
  _Bool D.9138;
  _Bool D.9139;
  int D.9141;
  int __mono_io_portability_helpers.5;
  int D.9149;
  int ret;
  gchar * located_newpath;

  located_newpath = mono_portability_find_file (newpath, 0);
  if (located_newpath == 0B) goto <D.9128>; else goto <D.9129>;
  <D.9128>:
  ret = rename (oldpath, newpath);
  goto <D.9130>;
  <D.9129>:
  ret = rename (oldpath, located_newpath);
  if (ret == -1) goto <D.9133>; else goto <D.9134>;
  <D.9133>:
  D.9135 = __errno_location ();
  D.9136 = *D.9135;
  D.9137 = D.9136 == 21;
  D.9138 = D.9136 == 36;
  D.9139 = D.9137 | D.9138;
  if (D.9139 != 0) goto <D.9131>; else goto <D.9140>;
  <D.9140>:
  D.9135 = __errno_location ();
  D.9141 = *D.9135;
  if (D.9141 == 2) goto <D.9131>; else goto <D.9142>;
  <D.9142>:
  D.9135 = __errno_location ();
  D.9141 = *D.9135;
  if (D.9141 == 20) goto <D.9131>; else goto <D.9143>;
  <D.9143>:
  D.9135 = __errno_location ();
  D.9141 = *D.9135;
  if (D.9141 == 18) goto <D.9131>; else goto <D.9132>;
  <D.9131>:
  __mono_io_portability_helpers.5 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.5 > 0) goto <D.9145>; else goto <D.9146>;
  <D.9145>:
  {
    int saved_errno;
    gchar * located_oldpath;

    D.9135 = __errno_location ();
    saved_errno = *D.9135;
    located_oldpath = mono_portability_find_file (oldpath, 1);
    if (located_oldpath == 0B) goto <D.9147>; else goto <D.9148>;
    <D.9147>:
    monoeg_g_free (located_oldpath);
    monoeg_g_free (located_newpath);
    D.9135 = __errno_location ();
    *D.9135 = saved_errno;
    D.9149 = -1;
    return D.9149;
    <D.9148>:
    ret = rename (located_oldpath, located_newpath);
    monoeg_g_free (located_oldpath);
  }
  <D.9146>:
  <D.9132>:
  <D.9134>:
  monoeg_g_free (located_newpath);
  <D.9130>:
  D.9149 = ret;
  return D.9149;
}


_wapi_stat (const char * path, struct stat * buf)
{
  int * D.9153;
  int D.9154;
  _Bool D.9155;
  _Bool D.9156;
  _Bool D.9157;
  int __mono_io_portability_helpers.6;
  int D.9165;
  int ret;

  ret = stat (path, buf);
  if (ret == -1) goto <D.9151>; else goto <D.9152>;
  <D.9151>:
  D.9153 = __errno_location ();
  D.9154 = *D.9153;
  D.9155 = D.9154 == 2;
  D.9156 = D.9154 == 20;
  D.9157 = D.9155 | D.9156;
  if (D.9157 != 0) goto <D.9158>; else goto <D.9159>;
  <D.9158>:
  __mono_io_portability_helpers.6 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.6 > 0) goto <D.9161>; else goto <D.9162>;
  <D.9161>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9153 = __errno_location ();
    saved_errno = *D.9153;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.9163>; else goto <D.9164>;
    <D.9163>:
    D.9153 = __errno_location ();
    *D.9153 = saved_errno;
    D.9165 = -1;
    return D.9165;
    <D.9164>:
    ret = stat (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.9162>:
  <D.9159>:
  <D.9152>:
  D.9165 = ret;
  return D.9165;
}


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

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


_wapi_lstat (const char * path, struct stat * buf)
{
  int * D.9171;
  int D.9172;
  _Bool D.9173;
  _Bool D.9174;
  _Bool D.9175;
  int __mono_io_portability_helpers.7;
  int D.9183;
  int ret;

  ret = lstat (path, buf);
  if (ret == -1) goto <D.9169>; else goto <D.9170>;
  <D.9169>:
  D.9171 = __errno_location ();
  D.9172 = *D.9171;
  D.9173 = D.9172 == 2;
  D.9174 = D.9172 == 20;
  D.9175 = D.9173 | D.9174;
  if (D.9175 != 0) goto <D.9176>; else goto <D.9177>;
  <D.9176>:
  __mono_io_portability_helpers.7 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.7 > 0) goto <D.9179>; else goto <D.9180>;
  <D.9179>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9171 = __errno_location ();
    saved_errno = *D.9171;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.9181>; else goto <D.9182>;
    <D.9181>:
    D.9171 = __errno_location ();
    *D.9171 = saved_errno;
    D.9183 = -1;
    return D.9183;
    <D.9182>:
    ret = lstat (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.9180>:
  <D.9177>:
  <D.9170>:
  D.9183 = ret;
  return D.9183;
}


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

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


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

  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.9187>; else goto <D.9188>;
  <D.9187>:
  ret = mkdir (pathname, mode);
  goto <D.9189>;
  <D.9188>:
  ret = mkdir (located_filename, mode);
  monoeg_g_free (located_filename);
  <D.9189>:
  D.9190 = ret;
  return D.9190;
}


_wapi_rmdir (const char * pathname)
{
  int * D.9196;
  int D.9197;
  _Bool D.9198;
  _Bool D.9199;
  _Bool D.9200;
  int D.9202;
  int __mono_io_portability_helpers.8;
  int D.9208;
  int ret;

  ret = rmdir (pathname);
  if (ret == -1) goto <D.9194>; else goto <D.9195>;
  <D.9194>:
  D.9196 = __errno_location ();
  D.9197 = *D.9196;
  D.9198 = D.9197 == 2;
  D.9199 = D.9197 == 20;
  D.9200 = D.9198 | D.9199;
  if (D.9200 != 0) goto <D.9192>; else goto <D.9201>;
  <D.9201>:
  D.9196 = __errno_location ();
  D.9202 = *D.9196;
  if (D.9202 == 36) goto <D.9192>; else goto <D.9193>;
  <D.9192>:
  __mono_io_portability_helpers.8 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.8 > 0) goto <D.9204>; else goto <D.9205>;
  <D.9204>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9196 = __errno_location ();
    saved_errno = *D.9196;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.9206>; else goto <D.9207>;
    <D.9206>:
    D.9196 = __errno_location ();
    *D.9196 = saved_errno;
    D.9208 = -1;
    return D.9208;
    <D.9207>:
    ret = rmdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.9205>:
  <D.9193>:
  <D.9195>:
  D.9208 = ret;
  return D.9208;
}


_wapi_chdir (const char * path)
{
  int * D.9214;
  int D.9215;
  _Bool D.9216;
  _Bool D.9217;
  _Bool D.9218;
  int D.9220;
  int __mono_io_portability_helpers.9;
  int D.9226;
  int ret;

  ret = chdir (path);
  if (ret == -1) goto <D.9212>; else goto <D.9213>;
  <D.9212>:
  D.9214 = __errno_location ();
  D.9215 = *D.9214;
  D.9216 = D.9215 == 2;
  D.9217 = D.9215 == 20;
  D.9218 = D.9216 | D.9217;
  if (D.9218 != 0) goto <D.9210>; else goto <D.9219>;
  <D.9219>:
  D.9214 = __errno_location ();
  D.9220 = *D.9214;
  if (D.9220 == 36) goto <D.9210>; else goto <D.9211>;
  <D.9210>:
  __mono_io_portability_helpers.9 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.9 > 0) goto <D.9222>; else goto <D.9223>;
  <D.9222>:
  {
    int saved_errno;
    gchar * located_filename;

    D.9214 = __errno_location ();
    saved_errno = *D.9214;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.9224>; else goto <D.9225>;
    <D.9224>:
    D.9214 = __errno_location ();
    *D.9214 = saved_errno;
    D.9226 = -1;
    return D.9226;
    <D.9225>:
    ret = chdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.9223>:
  <D.9211>:
  <D.9213>:
  D.9226 = ret;
  return D.9226;
}


_wapi_basename (const gchar * filename)
{
  int __mono_io_portability_helpers.10;
  int D.9231;
  const short unsigned int * * D.9234;
  const short unsigned int * D.9235;
  char D.9236;
  long unsigned int D.9237;
  long unsigned int D.9238;
  const short unsigned int * D.9239;
  short unsigned int D.9240;
  int D.9241;
  int D.9242;
  gchar * D.9245;
  char D.9246;
  long unsigned int D.9249;
  int D.9250;
  long unsigned int D.9251;
  const void * D.9252;
  sizetype D.9253;
  sizetype D.9254;
  gchar * D.9255;
  gchar * D.9256;
  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.9229>; else goto <D.9230>;
  <D.9229>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.9230>:
  __mono_io_portability_helpers.10 = __mono_io_portability_helpers;
  D.9231 = __mono_io_portability_helpers.10 & 2;
  if (D.9231 != 0) goto <D.9232>; else goto <D.9233>;
  <D.9232>:
  D.9234 = __ctype_b_loc ();
  D.9235 = *D.9234;
  D.9236 = *new_filename;
  D.9237 = (long unsigned int) D.9236;
  D.9238 = D.9237 * 2;
  D.9239 = D.9235 + D.9238;
  D.9240 = *D.9239;
  D.9241 = (int) D.9240;
  D.9242 = D.9241 & 1024;
  if (D.9242 != 0) goto <D.9243>; else goto <D.9244>;
  <D.9243>:
  D.9245 = new_filename + 1;
  D.9246 = *D.9245;
  if (D.9246 == 58) goto <D.9247>; else goto <D.9248>;
  <D.9247>:
  {
    int len;

    D.9249 = strlen (new_filename);
    len = (int) D.9249;
    D.9250 = len + -2;
    D.9251 = (long unsigned int) D.9250;
    D.9252 = new_filename + 2;
    memmove (new_filename, D.9252, D.9251);
    D.9253 = (sizetype) len;
    D.9254 = D.9253 + 18446744073709551614;
    D.9255 = new_filename + D.9254;
    *D.9255 = 0;
  }
  <D.9248>:
  <D.9244>:
  <D.9233>:
  ret = monoeg_g_path_get_basename (new_filename);
  monoeg_g_free (new_filename);
  D.9256 = ret;
  return D.9256;
}


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

  if (str != 0B) goto <D.9258>; else goto <D.9259>;
  <D.9258>:
  D.9260 = __strdup (str);
  return D.9260;
  <D.9259>:
  D.9260 = 0B;
  return D.9260;
}


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

  D.9263 = __builtin_object_size (__dest, 0);
  D.9262 = __builtin___memmove_chk (__dest, __src, __len, D.9263);
  return D.9262;
}


_wapi_dirname (const gchar * filename)
{
  int __mono_io_portability_helpers.11;
  int D.9268;
  const short unsigned int * * D.9271;
  const short unsigned int * D.9272;
  char D.9273;
  long unsigned int D.9274;
  long unsigned int D.9275;
  const short unsigned int * D.9276;
  short unsigned int D.9277;
  int D.9278;
  int D.9279;
  gchar * D.9282;
  char D.9283;
  long unsigned int D.9286;
  int D.9287;
  long unsigned int D.9288;
  const void * D.9289;
  sizetype D.9290;
  sizetype D.9291;
  gchar * D.9292;
  gchar * D.9293;
  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.9266>; else goto <D.9267>;
  <D.9266>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.9267>:
  __mono_io_portability_helpers.11 = __mono_io_portability_helpers;
  D.9268 = __mono_io_portability_helpers.11 & 2;
  if (D.9268 != 0) goto <D.9269>; else goto <D.9270>;
  <D.9269>:
  D.9271 = __ctype_b_loc ();
  D.9272 = *D.9271;
  D.9273 = *new_filename;
  D.9274 = (long unsigned int) D.9273;
  D.9275 = D.9274 * 2;
  D.9276 = D.9272 + D.9275;
  D.9277 = *D.9276;
  D.9278 = (int) D.9277;
  D.9279 = D.9278 & 1024;
  if (D.9279 != 0) goto <D.9280>; else goto <D.9281>;
  <D.9280>:
  D.9282 = new_filename + 1;
  D.9283 = *D.9282;
  if (D.9283 == 58) goto <D.9284>; else goto <D.9285>;
  <D.9284>:
  {
    int len;

    D.9286 = strlen (new_filename);
    len = (int) D.9286;
    D.9287 = len + -2;
    D.9288 = (long unsigned int) D.9287;
    D.9289 = new_filename + 2;
    memmove (new_filename, D.9289, D.9288);
    D.9290 = (sizetype) len;
    D.9291 = D.9290 + 18446744073709551614;
    D.9292 = new_filename + D.9291;
    *D.9292 = 0;
  }
  <D.9285>:
  <D.9281>:
  <D.9270>:
  ret = monoeg_g_path_get_dirname (new_filename);
  monoeg_g_free (new_filename);
  D.9293 = ret;
  return D.9293;
}


_wapi_g_dir_open (const gchar * path, guint flags, struct GError * * error)
{
  struct GError * D.9297;
  int D.9298;
  unsigned int D.9299;
  unsigned int D.9300;
  int __mono_io_portability_helpers.12;
  struct GDir * D.9308;
  struct GError * tmp_error.13;
  struct GDir * ret;

  ret = monoeg_g_dir_open (path, flags, error);
  if (ret == 0B) goto <D.9295>; else goto <D.9296>;
  <D.9295>:
  D.9297 = *error;
  D.9298 = D.9297->code;
  D.9299 = (unsigned int) D.9298;
  D.9300 = D.9299 + 4294967293;
  if (D.9300 <= 2) goto <D.9301>; else goto <D.9302>;
  <D.9301>:
  __mono_io_portability_helpers.12 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.12 > 0) goto <D.9304>; else goto <D.9305>;
  <D.9304>:
  {
    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.9306>; else goto <D.9307>;
        <D.9306>:
        D.9308 = 0B;
        return D.9308;
        <D.9307>:
        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.9310>; else goto <D.9311>;
        <D.9310>:
        monoeg_g_clear_error (error);
        <D.9311>:
      }
    finally
      {
        tmp_error = {CLOBBER};
      }
  }
  <D.9305>:
  <D.9302>:
  <D.9296>:
  D.9308 = ret;
  return D.9308;
}


_wapi_io_scandir (const gchar * dirname, const gchar * pattern, gchar * * * namelist)
{
  struct GError * error.14;
  int D.9318;
  int D.9321;
  int D.9324;
  int * D.9327;
  gint D.9328;
  int __mono_io_portability_helpers.15;
  int D.9330;
  int D.9333;
  long unsigned int D.9336;
  long unsigned int D.9337;
  int D.9338;
  int D.9341;
  char * * D.9346;
  long unsigned int D.9347;
  long unsigned int D.9348;
  char * * D.9349;
  char * D.9350;
  gchar * D.9351;
  unsigned int D.9352;
  int D.9355;
  void * * D.9356;
  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.9315>; else goto <D.9316>;
      <D.9315>:
      {
        gint errnum;

        error.14 = error;
        D.9318 = error.14->code;
        errnum = get_errno_from_g_file_error (D.9318);
        error.14 = error;
        monoeg_g_error_free (error.14);
        if (errnum == 2) goto <D.9319>; else goto <D.9320>;
        <D.9319>:
        D.9321 = _wapi_access (dirname, 0);
        if (D.9321 == 0) goto <D.9322>; else goto <D.9323>;
        <D.9322>:
        D.9324 = _wapi_access (dirname, 5);
        if (D.9324 != 0) goto <D.9325>; else goto <D.9326>;
        <D.9325>:
        errnum = 13;
        <D.9326>:
        <D.9323>:
        <D.9320>:
        D.9327 = __errno_location ();
        *D.9327 = errnum;
        D.9328 = -1;
        return D.9328;
      }
      <D.9316>:
      __mono_io_portability_helpers.15 = __mono_io_portability_helpers;
      D.9330 = __mono_io_portability_helpers.15 & 4;
      if (D.9330 != 0) goto <D.9331>; else goto <D.9332>;
      <D.9331>:
      flags = 16384;
      <D.9332>:
      result = _wapi_glob (dir, pattern, flags, &glob_buf);
      D.9333 = monoeg_g_str_has_suffix (pattern, ".*");
      if (D.9333 != 0) goto <D.9334>; else goto <D.9335>;
      <D.9334>:
      {
        gchar * pattern2;
        gint result2;

        D.9336 = strlen (pattern);
        D.9337 = D.9336 + 18446744073709551614;
        pattern2 = monoeg_g_strndup (pattern, D.9337);
        monoeg_g_dir_rewind (dir);
        D.9338 = flags | 65;
        result2 = _wapi_glob (dir, pattern2, D.9338, &glob_buf);
        monoeg_g_free (pattern2);
        if (result != 0) goto <D.9339>; else goto <D.9340>;
        <D.9339>:
        result = result2;
        <D.9340>:
      }
      <D.9335>:
      monoeg_g_dir_close (dir);
      D.9341 = glob_buf.gl_pathc;
      if (D.9341 == 0) goto <D.9342>; else goto <D.9343>;
      <D.9342>:
      D.9328 = 0;
      return D.9328;
      <D.9343>:
      if (result != 0) goto <D.9344>; else goto <D.9345>;
      <D.9344>:
      D.9328 = -1;
      return D.9328;
      <D.9345>:
      names = monoeg_g_ptr_array_new ();
      i = 0;
      goto <D.9020>;
      <D.9019>:
      D.9346 = glob_buf.gl_pathv;
      D.9347 = (long unsigned int) i;
      D.9348 = D.9347 * 8;
      D.9349 = D.9346 + D.9348;
      D.9350 = *D.9349;
      D.9351 = monoeg_strdup (D.9350);
      monoeg_g_ptr_array_add (names, D.9351);
      i = i + 1;
      <D.9020>:
      D.9341 = glob_buf.gl_pathc;
      if (D.9341 > i) goto <D.9019>; else goto <D.9021>;
      <D.9021>:
      _wapi_globfree (&glob_buf);
      D.9352 = names->len;
      result = (gint) D.9352;
      if (result > 0) goto <D.9353>; else goto <D.9354>;
      <D.9353>:
      monoeg_g_ptr_array_sort (names, file_compare);
      D.9355 = result + 1;
      monoeg_g_ptr_array_set_size (names, D.9355);
      D.9356 = monoeg_g_ptr_array_free (names, 0);
      *namelist = D.9356;
      goto <D.9357>;
      <D.9354>:
      monoeg_g_ptr_array_free (names, 1);
      <D.9357>:
      D.9328 = result;
      return D.9328;
    }
  finally
    {
      error = {CLOBBER};
      glob_buf = {CLOBBER};
    }
}


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

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

    D.8979 = __builtin_strcmp (astr, bstr);
  }
  D.9360 = D.8979;
  return D.9360;
}


get_errno_from_g_file_error (gint error)
{
  gint D.9363;

  switch (error) <default: <D.9362>, case 3: <D.8983>, case 4: <D.8985>, case 5: <D.8986>, case 6: <D.8987>, case 7: <D.8988>, case 8: <D.8989>, case 9: <D.8990>, case 10: <D.8991>, case 11: <D.8992>, case 12: <D.8993>, case 13: <D.8994>, case 14: <D.8995>, case 15: <D.8996>, case 16: <D.8997>, case 17: <D.8998>, case 18: <D.8999>, case 19: <D.9000>, case 20: <D.9001>, case 22: <D.9002>, case 24: <D.9003>>
  <D.8983>:
  error = 36;
  goto <D.8984>;
  <D.8985>:
  error = 2;
  goto <D.8984>;
  <D.8986>:
  error = 20;
  goto <D.8984>;
  <D.8987>:
  error = 6;
  goto <D.8984>;
  <D.8988>:
  error = 19;
  goto <D.8984>;
  <D.8989>:
  error = 30;
  goto <D.8984>;
  <D.8990>:
  error = 26;
  goto <D.8984>;
  <D.8991>:
  error = 14;
  goto <D.8984>;
  <D.8992>:
  error = 40;
  goto <D.8984>;
  <D.8993>:
  error = 28;
  goto <D.8984>;
  <D.8994>:
  error = 12;
  goto <D.8984>;
  <D.8995>:
  error = 24;
  goto <D.8984>;
  <D.8996>:
  error = 23;
  goto <D.8984>;
  <D.8997>:
  error = 9;
  goto <D.8984>;
  <D.8998>:
  error = 22;
  goto <D.8984>;
  <D.8999>:
  error = 32;
  goto <D.8984>;
  <D.9000>:
  error = 11;
  goto <D.8984>;
  <D.9001>:
  error = 4;
  goto <D.8984>;
  <D.9002>:
  error = 1;
  goto <D.8984>;
  <D.9003>:
  error = 87;
  goto <D.8984>;
  <D.9362>:
  <D.8984>:
  D.9363 = error;
  return D.9363;
}