_wapi_open (const char * pathname, int flags, mode_t mode)
{
  int D.11287;
  int * D.11296;
  int D.11297;
  _Bool D.11298;
  _Bool D.11299;
  _Bool D.11300;
  int __mono_io_portability_helpers.0;
  int D.11308;
  int fd;
  gchar * located_filename;

  D.11287 = flags & 64;
  if (D.11287 != 0) goto <D.11288>; else goto <D.11289>;
  <D.11288>:
  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.11290>; else goto <D.11291>;
  <D.11290>:
  fd = open (pathname, flags, mode);
  goto <D.11292>;
  <D.11291>:
  fd = open (located_filename, flags, mode);
  monoeg_g_free (located_filename);
  <D.11292>:
  goto <D.11293>;
  <D.11289>:
  fd = open (pathname, flags, mode);
  if (fd == -1) goto <D.11294>; else goto <D.11295>;
  <D.11294>:
  D.11296 = __errno_location ();
  D.11297 = *D.11296;
  D.11298 = D.11297 == 2;
  D.11299 = D.11297 == 20;
  D.11300 = D.11298 | D.11299;
  if (D.11300 != 0) goto <D.11301>; else goto <D.11302>;
  <D.11301>:
  __mono_io_portability_helpers.0 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.0 > 0) goto <D.11304>; else goto <D.11305>;
  <D.11304>:
  {
    int saved_errno;

    D.11296 = __errno_location ();
    saved_errno = *D.11296;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.11306>; else goto <D.11307>;
    <D.11306>:
    D.11296 = __errno_location ();
    *D.11296 = saved_errno;
    D.11308 = -1;
    return D.11308;
    <D.11307>:
    fd = open (located_filename, flags, mode);
    monoeg_g_free (located_filename);
  }
  <D.11305>:
  <D.11302>:
  <D.11295>:
  <D.11293>:
  D.11308 = fd;
  return D.11308;
}


open (const char * __path, int __oflag)
{
  int D.11310;
  int D.11313;
  int D.11318;
  int D.11320;
  int D.11321;
  int D.11324;
  int D.11325;

  D.11310 = __builtin_va_arg_pack_len ();
  if (D.11310 > 1) goto <D.11311>; else goto <D.11312>;
  <D.11311>:
  __open_too_many_args ();
  <D.11312>:
  D.11313 = __builtin_constant_p (__oflag);
  if (D.11313 != 0) goto <D.11314>; else goto <D.11315>;
  <D.11314>:
  D.11318 = __oflag & 64;
  if (D.11318 != 0) goto <D.11316>; else goto <D.11319>;
  <D.11319>:
  D.11320 = __oflag & 4210688;
  if (D.11320 == 4210688) goto <D.11316>; else goto <D.11317>;
  <D.11316>:
  D.11321 = __builtin_va_arg_pack_len ();
  if (D.11321 <= 0) goto <D.11322>; else goto <D.11323>;
  <D.11322>:
  __open_missing_mode ();
  D.11324 = __open_2 (__path, __oflag);
  return D.11324;
  <D.11323>:
  <D.11317>:
  D.11324 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.11324;
  <D.11315>:
  D.11325 = __builtin_va_arg_pack_len ();
  if (D.11325 <= 0) goto <D.11326>; else goto <D.11327>;
  <D.11326>:
  D.11324 = __open_2 (__path, __oflag);
  return D.11324;
  <D.11327>:
  D.11324 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.11324;
}


_wapi_access (const char * pathname, int mode)
{
  int * D.11331;
  int D.11332;
  _Bool D.11333;
  _Bool D.11334;
  _Bool D.11335;
  int __mono_io_portability_helpers.1;
  int D.11343;
  int ret;

  ret = access (pathname, mode);
  if (ret == -1) goto <D.11329>; else goto <D.11330>;
  <D.11329>:
  D.11331 = __errno_location ();
  D.11332 = *D.11331;
  D.11333 = D.11332 == 2;
  D.11334 = D.11332 == 20;
  D.11335 = D.11333 | D.11334;
  if (D.11335 != 0) goto <D.11336>; else goto <D.11337>;
  <D.11336>:
  __mono_io_portability_helpers.1 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.1 > 0) goto <D.11339>; else goto <D.11340>;
  <D.11339>:
  {
    int saved_errno;
    gchar * located_filename;

    D.11331 = __errno_location ();
    saved_errno = *D.11331;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.11341>; else goto <D.11342>;
    <D.11341>:
    D.11331 = __errno_location ();
    *D.11331 = saved_errno;
    D.11343 = -1;
    return D.11343;
    <D.11342>:
    ret = access (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.11340>:
  <D.11337>:
  <D.11330>:
  D.11343 = ret;
  return D.11343;
}


_wapi_chmod (const char * pathname, mode_t mode)
{
  int * D.11347;
  int D.11348;
  _Bool D.11349;
  _Bool D.11350;
  _Bool D.11351;
  int __mono_io_portability_helpers.2;
  int D.11359;
  int ret;

  ret = chmod (pathname, mode);
  if (ret == -1) goto <D.11345>; else goto <D.11346>;
  <D.11345>:
  D.11347 = __errno_location ();
  D.11348 = *D.11347;
  D.11349 = D.11348 == 2;
  D.11350 = D.11348 == 20;
  D.11351 = D.11349 | D.11350;
  if (D.11351 != 0) goto <D.11352>; else goto <D.11353>;
  <D.11352>:
  __mono_io_portability_helpers.2 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.2 > 0) goto <D.11355>; else goto <D.11356>;
  <D.11355>:
  {
    int saved_errno;
    gchar * located_filename;

    D.11347 = __errno_location ();
    saved_errno = *D.11347;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.11357>; else goto <D.11358>;
    <D.11357>:
    D.11347 = __errno_location ();
    *D.11347 = saved_errno;
    D.11359 = -1;
    return D.11359;
    <D.11358>:
    ret = chmod (located_filename, mode);
    monoeg_g_free (located_filename);
  }
  <D.11356>:
  <D.11353>:
  <D.11346>:
  D.11359 = ret;
  return D.11359;
}


_wapi_utime (const char * filename, const struct utimbuf * buf)
{
  int * D.11363;
  int D.11364;
  int __mono_io_portability_helpers.3;
  int D.11372;
  int ret;

  ret = utime (filename, buf);
  if (ret == -1) goto <D.11361>; else goto <D.11362>;
  <D.11361>:
  D.11363 = __errno_location ();
  D.11364 = *D.11363;
  if (D.11364 == 2) goto <D.11365>; else goto <D.11366>;
  <D.11365>:
  __mono_io_portability_helpers.3 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.3 > 0) goto <D.11368>; else goto <D.11369>;
  <D.11368>:
  {
    int saved_errno;
    gchar * located_filename;

    D.11363 = __errno_location ();
    saved_errno = *D.11363;
    located_filename = mono_portability_find_file (filename, 1);
    if (located_filename == 0B) goto <D.11370>; else goto <D.11371>;
    <D.11370>:
    D.11363 = __errno_location ();
    *D.11363 = saved_errno;
    D.11372 = -1;
    return D.11372;
    <D.11371>:
    ret = utime (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.11369>:
  <D.11366>:
  <D.11362>:
  D.11372 = ret;
  return D.11372;
}


_wapi_unlink (const char * pathname)
{
  int * D.11378;
  int D.11379;
  _Bool D.11380;
  _Bool D.11381;
  _Bool D.11382;
  int D.11384;
  int __mono_io_portability_helpers.4;
  int D.11390;
  int ret;

  ret = unlink (pathname);
  if (ret == -1) goto <D.11376>; else goto <D.11377>;
  <D.11376>:
  D.11378 = __errno_location ();
  D.11379 = *D.11378;
  D.11380 = D.11379 == 2;
  D.11381 = D.11379 == 20;
  D.11382 = D.11380 | D.11381;
  if (D.11382 != 0) goto <D.11374>; else goto <D.11383>;
  <D.11383>:
  D.11378 = __errno_location ();
  D.11384 = *D.11378;
  if (D.11384 == 21) goto <D.11374>; else goto <D.11375>;
  <D.11374>:
  __mono_io_portability_helpers.4 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.4 > 0) goto <D.11386>; else goto <D.11387>;
  <D.11386>:
  {
    int saved_errno;
    gchar * located_filename;

    D.11378 = __errno_location ();
    saved_errno = *D.11378;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.11388>; else goto <D.11389>;
    <D.11388>:
    D.11378 = __errno_location ();
    *D.11378 = saved_errno;
    D.11390 = -1;
    return D.11390;
    <D.11389>:
    ret = unlink (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.11387>:
  <D.11375>:
  <D.11377>:
  D.11390 = ret;
  return D.11390;
}


_wapi_rename (const char * oldpath, const char * newpath)
{
  int * D.11399;
  int D.11400;
  _Bool D.11401;
  _Bool D.11402;
  _Bool D.11403;
  int D.11405;
  int __mono_io_portability_helpers.5;
  int D.11413;
  int ret;
  gchar * located_newpath;

  located_newpath = mono_portability_find_file (newpath, 0);
  if (located_newpath == 0B) goto <D.11392>; else goto <D.11393>;
  <D.11392>:
  ret = rename (oldpath, newpath);
  goto <D.11394>;
  <D.11393>:
  ret = rename (oldpath, located_newpath);
  if (ret == -1) goto <D.11397>; else goto <D.11398>;
  <D.11397>:
  D.11399 = __errno_location ();
  D.11400 = *D.11399;
  D.11401 = D.11400 == 21;
  D.11402 = D.11400 == 36;
  D.11403 = D.11401 | D.11402;
  if (D.11403 != 0) goto <D.11395>; else goto <D.11404>;
  <D.11404>:
  D.11399 = __errno_location ();
  D.11405 = *D.11399;
  if (D.11405 == 2) goto <D.11395>; else goto <D.11406>;
  <D.11406>:
  D.11399 = __errno_location ();
  D.11405 = *D.11399;
  if (D.11405 == 20) goto <D.11395>; else goto <D.11407>;
  <D.11407>:
  D.11399 = __errno_location ();
  D.11405 = *D.11399;
  if (D.11405 == 18) goto <D.11395>; else goto <D.11396>;
  <D.11395>:
  __mono_io_portability_helpers.5 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.5 > 0) goto <D.11409>; else goto <D.11410>;
  <D.11409>:
  {
    int saved_errno;
    gchar * located_oldpath;

    D.11399 = __errno_location ();
    saved_errno = *D.11399;
    located_oldpath = mono_portability_find_file (oldpath, 1);
    if (located_oldpath == 0B) goto <D.11411>; else goto <D.11412>;
    <D.11411>:
    monoeg_g_free (located_oldpath);
    monoeg_g_free (located_newpath);
    D.11399 = __errno_location ();
    *D.11399 = saved_errno;
    D.11413 = -1;
    return D.11413;
    <D.11412>:
    ret = rename (located_oldpath, located_newpath);
    monoeg_g_free (located_oldpath);
  }
  <D.11410>:
  <D.11396>:
  <D.11398>:
  monoeg_g_free (located_newpath);
  <D.11394>:
  D.11413 = ret;
  return D.11413;
}


_wapi_stat (const char * path, struct stat * buf)
{
  int * D.11417;
  int D.11418;
  _Bool D.11419;
  _Bool D.11420;
  _Bool D.11421;
  int __mono_io_portability_helpers.6;
  int D.11429;
  int ret;

  ret = stat (path, buf);
  if (ret == -1) goto <D.11415>; else goto <D.11416>;
  <D.11415>:
  D.11417 = __errno_location ();
  D.11418 = *D.11417;
  D.11419 = D.11418 == 2;
  D.11420 = D.11418 == 20;
  D.11421 = D.11419 | D.11420;
  if (D.11421 != 0) goto <D.11422>; else goto <D.11423>;
  <D.11422>:
  __mono_io_portability_helpers.6 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.6 > 0) goto <D.11425>; else goto <D.11426>;
  <D.11425>:
  {
    int saved_errno;
    gchar * located_filename;

    D.11417 = __errno_location ();
    saved_errno = *D.11417;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.11427>; else goto <D.11428>;
    <D.11427>:
    D.11417 = __errno_location ();
    *D.11417 = saved_errno;
    D.11429 = -1;
    return D.11429;
    <D.11428>:
    ret = stat (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.11426>:
  <D.11423>:
  <D.11416>:
  D.11429 = ret;
  return D.11429;
}


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

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


_wapi_lstat (const char * path, struct stat * buf)
{
  int * D.11435;
  int D.11436;
  _Bool D.11437;
  _Bool D.11438;
  _Bool D.11439;
  int __mono_io_portability_helpers.7;
  int D.11447;
  int ret;

  ret = lstat (path, buf);
  if (ret == -1) goto <D.11433>; else goto <D.11434>;
  <D.11433>:
  D.11435 = __errno_location ();
  D.11436 = *D.11435;
  D.11437 = D.11436 == 2;
  D.11438 = D.11436 == 20;
  D.11439 = D.11437 | D.11438;
  if (D.11439 != 0) goto <D.11440>; else goto <D.11441>;
  <D.11440>:
  __mono_io_portability_helpers.7 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.7 > 0) goto <D.11443>; else goto <D.11444>;
  <D.11443>:
  {
    int saved_errno;
    gchar * located_filename;

    D.11435 = __errno_location ();
    saved_errno = *D.11435;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.11445>; else goto <D.11446>;
    <D.11445>:
    D.11435 = __errno_location ();
    *D.11435 = saved_errno;
    D.11447 = -1;
    return D.11447;
    <D.11446>:
    ret = lstat (located_filename, buf);
    monoeg_g_free (located_filename);
  }
  <D.11444>:
  <D.11441>:
  <D.11434>:
  D.11447 = ret;
  return D.11447;
}


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

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


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

  located_filename = mono_portability_find_file (pathname, 0);
  if (located_filename == 0B) goto <D.11451>; else goto <D.11452>;
  <D.11451>:
  ret = mkdir (pathname, mode);
  goto <D.11453>;
  <D.11452>:
  ret = mkdir (located_filename, mode);
  monoeg_g_free (located_filename);
  <D.11453>:
  D.11454 = ret;
  return D.11454;
}


_wapi_rmdir (const char * pathname)
{
  int * D.11460;
  int D.11461;
  _Bool D.11462;
  _Bool D.11463;
  _Bool D.11464;
  int D.11466;
  int __mono_io_portability_helpers.8;
  int D.11472;
  int ret;

  ret = rmdir (pathname);
  if (ret == -1) goto <D.11458>; else goto <D.11459>;
  <D.11458>:
  D.11460 = __errno_location ();
  D.11461 = *D.11460;
  D.11462 = D.11461 == 2;
  D.11463 = D.11461 == 20;
  D.11464 = D.11462 | D.11463;
  if (D.11464 != 0) goto <D.11456>; else goto <D.11465>;
  <D.11465>:
  D.11460 = __errno_location ();
  D.11466 = *D.11460;
  if (D.11466 == 36) goto <D.11456>; else goto <D.11457>;
  <D.11456>:
  __mono_io_portability_helpers.8 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.8 > 0) goto <D.11468>; else goto <D.11469>;
  <D.11468>:
  {
    int saved_errno;
    gchar * located_filename;

    D.11460 = __errno_location ();
    saved_errno = *D.11460;
    located_filename = mono_portability_find_file (pathname, 1);
    if (located_filename == 0B) goto <D.11470>; else goto <D.11471>;
    <D.11470>:
    D.11460 = __errno_location ();
    *D.11460 = saved_errno;
    D.11472 = -1;
    return D.11472;
    <D.11471>:
    ret = rmdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.11469>:
  <D.11457>:
  <D.11459>:
  D.11472 = ret;
  return D.11472;
}


_wapi_chdir (const char * path)
{
  int * D.11478;
  int D.11479;
  _Bool D.11480;
  _Bool D.11481;
  _Bool D.11482;
  int D.11484;
  int __mono_io_portability_helpers.9;
  int D.11490;
  int ret;

  ret = chdir (path);
  if (ret == -1) goto <D.11476>; else goto <D.11477>;
  <D.11476>:
  D.11478 = __errno_location ();
  D.11479 = *D.11478;
  D.11480 = D.11479 == 2;
  D.11481 = D.11479 == 20;
  D.11482 = D.11480 | D.11481;
  if (D.11482 != 0) goto <D.11474>; else goto <D.11483>;
  <D.11483>:
  D.11478 = __errno_location ();
  D.11484 = *D.11478;
  if (D.11484 == 36) goto <D.11474>; else goto <D.11475>;
  <D.11474>:
  __mono_io_portability_helpers.9 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.9 > 0) goto <D.11486>; else goto <D.11487>;
  <D.11486>:
  {
    int saved_errno;
    gchar * located_filename;

    D.11478 = __errno_location ();
    saved_errno = *D.11478;
    located_filename = mono_portability_find_file (path, 1);
    if (located_filename == 0B) goto <D.11488>; else goto <D.11489>;
    <D.11488>:
    D.11478 = __errno_location ();
    *D.11478 = saved_errno;
    D.11490 = -1;
    return D.11490;
    <D.11489>:
    ret = chdir (located_filename);
    monoeg_g_free (located_filename);
  }
  <D.11487>:
  <D.11475>:
  <D.11477>:
  D.11490 = ret;
  return D.11490;
}


_wapi_basename (const gchar * filename)
{
  int __mono_io_portability_helpers.10;
  int D.11495;
  const short unsigned int * * D.11498;
  const short unsigned int * D.11499;
  char D.11500;
  unsigned int D.11501;
  unsigned int D.11502;
  const short unsigned int * D.11503;
  short unsigned int D.11504;
  int D.11505;
  int D.11506;
  gchar * D.11509;
  char D.11510;
  unsigned int D.11513;
  const void * D.11514;
  int D.11515;
  unsigned int D.11516;
  sizetype len.11;
  sizetype D.11518;
  gchar * D.11519;
  gchar * D.11520;
  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.11493>; else goto <D.11494>;
  <D.11493>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.11494>:
  __mono_io_portability_helpers.10 = __mono_io_portability_helpers;
  D.11495 = __mono_io_portability_helpers.10 & 2;
  if (D.11495 != 0) goto <D.11496>; else goto <D.11497>;
  <D.11496>:
  D.11498 = __ctype_b_loc ();
  D.11499 = *D.11498;
  D.11500 = *new_filename;
  D.11501 = (unsigned int) D.11500;
  D.11502 = D.11501 * 2;
  D.11503 = D.11499 + D.11502;
  D.11504 = *D.11503;
  D.11505 = (int) D.11504;
  D.11506 = D.11505 & 1024;
  if (D.11506 != 0) goto <D.11507>; else goto <D.11508>;
  <D.11507>:
  D.11509 = new_filename + 1;
  D.11510 = *D.11509;
  if (D.11510 == 58) goto <D.11511>; else goto <D.11512>;
  <D.11511>:
  {
    int len;

    D.11513 = strlen (new_filename);
    len = (int) D.11513;
    D.11514 = new_filename + 2;
    D.11515 = len + -2;
    D.11516 = (unsigned int) D.11515;
    memmove (new_filename, D.11514, D.11516);
    len.11 = (sizetype) len;
    D.11518 = len.11 + 4294967294;
    D.11519 = new_filename + D.11518;
    *D.11519 = 0;
  }
  <D.11512>:
  <D.11508>:
  <D.11497>:
  ret = monoeg_g_path_get_basename (new_filename);
  monoeg_g_free (new_filename);
  D.11520 = ret;
  return D.11520;
}


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

  if (str != 0B) goto <D.11522>; else goto <D.11523>;
  <D.11522>:
  D.11524 = __strdup (str);
  return D.11524;
  <D.11523>:
  D.11524 = 0B;
  return D.11524;
}


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

  D.11527 = __builtin_object_size (__dest, 0);
  D.11526 = __builtin___memmove_chk (__dest, __src, __len, D.11527);
  return D.11526;
}


_wapi_dirname (const gchar * filename)
{
  int __mono_io_portability_helpers.12;
  int D.11532;
  const short unsigned int * * D.11535;
  const short unsigned int * D.11536;
  char D.11537;
  unsigned int D.11538;
  unsigned int D.11539;
  const short unsigned int * D.11540;
  short unsigned int D.11541;
  int D.11542;
  int D.11543;
  gchar * D.11546;
  char D.11547;
  unsigned int D.11550;
  const void * D.11551;
  int D.11552;
  unsigned int D.11553;
  sizetype len.13;
  sizetype D.11555;
  gchar * D.11556;
  gchar * D.11557;
  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.11530>; else goto <D.11531>;
  <D.11530>:
  monoeg_g_strdelimit (new_filename, "\\", 47);
  <D.11531>:
  __mono_io_portability_helpers.12 = __mono_io_portability_helpers;
  D.11532 = __mono_io_portability_helpers.12 & 2;
  if (D.11532 != 0) goto <D.11533>; else goto <D.11534>;
  <D.11533>:
  D.11535 = __ctype_b_loc ();
  D.11536 = *D.11535;
  D.11537 = *new_filename;
  D.11538 = (unsigned int) D.11537;
  D.11539 = D.11538 * 2;
  D.11540 = D.11536 + D.11539;
  D.11541 = *D.11540;
  D.11542 = (int) D.11541;
  D.11543 = D.11542 & 1024;
  if (D.11543 != 0) goto <D.11544>; else goto <D.11545>;
  <D.11544>:
  D.11546 = new_filename + 1;
  D.11547 = *D.11546;
  if (D.11547 == 58) goto <D.11548>; else goto <D.11549>;
  <D.11548>:
  {
    int len;

    D.11550 = strlen (new_filename);
    len = (int) D.11550;
    D.11551 = new_filename + 2;
    D.11552 = len + -2;
    D.11553 = (unsigned int) D.11552;
    memmove (new_filename, D.11551, D.11553);
    len.13 = (sizetype) len;
    D.11555 = len.13 + 4294967294;
    D.11556 = new_filename + D.11555;
    *D.11556 = 0;
  }
  <D.11549>:
  <D.11545>:
  <D.11534>:
  ret = monoeg_g_path_get_dirname (new_filename);
  monoeg_g_free (new_filename);
  D.11557 = ret;
  return D.11557;
}


_wapi_g_dir_open (const gchar * path, guint flags, struct GError * * error)
{
  struct GError * D.11561;
  int D.11562;
  unsigned int D.11563;
  unsigned int D.11564;
  int __mono_io_portability_helpers.14;
  struct GDir * D.11572;
  struct GError * tmp_error.15;
  struct GDir * ret;

  ret = monoeg_g_dir_open (path, flags, error);
  if (ret == 0B) goto <D.11559>; else goto <D.11560>;
  <D.11559>:
  D.11561 = *error;
  D.11562 = D.11561->code;
  D.11563 = (unsigned int) D.11562;
  D.11564 = D.11563 + 4294967293;
  if (D.11564 <= 2) goto <D.11565>; else goto <D.11566>;
  <D.11565>:
  __mono_io_portability_helpers.14 = __mono_io_portability_helpers;
  if (__mono_io_portability_helpers.14 > 0) goto <D.11568>; else goto <D.11569>;
  <D.11568>:
  {
    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.11570>; else goto <D.11571>;
        <D.11570>:
        D.11572 = 0B;
        return D.11572;
        <D.11571>:
        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.11574>; else goto <D.11575>;
        <D.11574>:
        monoeg_g_clear_error (error);
        <D.11575>:
      }
    finally
      {
        tmp_error = {CLOBBER};
      }
  }
  <D.11569>:
  <D.11566>:
  <D.11560>:
  D.11572 = ret;
  return D.11572;
}


_wapi_io_scandir (const gchar * dirname, const gchar * pattern, gchar * * * namelist)
{
  struct GError * error.16;
  int D.11582;
  int D.11585;
  int D.11588;
  int * D.11591;
  gint D.11592;
  int __mono_io_portability_helpers.17;
  int D.11594;
  int D.11597;
  unsigned int D.11600;
  unsigned int D.11601;
  int D.11602;
  int D.11605;
  char * * D.11610;
  unsigned int i.18;
  unsigned int D.11612;
  char * * D.11613;
  char * D.11614;
  gchar * D.11615;
  unsigned int D.11616;
  int D.11619;
  void * * D.11620;
  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.11579>; else goto <D.11580>;
      <D.11579>:
      {
        gint errnum;

        error.16 = error;
        D.11582 = error.16->code;
        errnum = get_errno_from_g_file_error (D.11582);
        error.16 = error;
        monoeg_g_error_free (error.16);
        if (errnum == 2) goto <D.11583>; else goto <D.11584>;
        <D.11583>:
        D.11585 = _wapi_access (dirname, 0);
        if (D.11585 == 0) goto <D.11586>; else goto <D.11587>;
        <D.11586>:
        D.11588 = _wapi_access (dirname, 5);
        if (D.11588 != 0) goto <D.11589>; else goto <D.11590>;
        <D.11589>:
        errnum = 13;
        <D.11590>:
        <D.11587>:
        <D.11584>:
        D.11591 = __errno_location ();
        *D.11591 = errnum;
        D.11592 = -1;
        return D.11592;
      }
      <D.11580>:
      __mono_io_portability_helpers.17 = __mono_io_portability_helpers;
      D.11594 = __mono_io_portability_helpers.17 & 4;
      if (D.11594 != 0) goto <D.11595>; else goto <D.11596>;
      <D.11595>:
      flags = 16384;
      <D.11596>:
      result = _wapi_glob (dir, pattern, flags, &glob_buf);
      D.11597 = monoeg_g_str_has_suffix (pattern, ".*");
      if (D.11597 != 0) goto <D.11598>; else goto <D.11599>;
      <D.11598>:
      {
        gchar * pattern2;
        gint result2;

        D.11600 = strlen (pattern);
        D.11601 = D.11600 + 4294967294;
        pattern2 = monoeg_g_strndup (pattern, D.11601);
        monoeg_g_dir_rewind (dir);
        D.11602 = flags | 65;
        result2 = _wapi_glob (dir, pattern2, D.11602, &glob_buf);
        monoeg_g_free (pattern2);
        if (result != 0) goto <D.11603>; else goto <D.11604>;
        <D.11603>:
        result = result2;
        <D.11604>:
      }
      <D.11599>:
      monoeg_g_dir_close (dir);
      D.11605 = glob_buf.gl_pathc;
      if (D.11605 == 0) goto <D.11606>; else goto <D.11607>;
      <D.11606>:
      D.11592 = 0;
      return D.11592;
      <D.11607>:
      if (result != 0) goto <D.11608>; else goto <D.11609>;
      <D.11608>:
      D.11592 = -1;
      return D.11592;
      <D.11609>:
      names = monoeg_g_ptr_array_new ();
      i = 0;
      goto <D.11282>;
      <D.11281>:
      D.11610 = glob_buf.gl_pathv;
      i.18 = (unsigned int) i;
      D.11612 = i.18 * 4;
      D.11613 = D.11610 + D.11612;
      D.11614 = *D.11613;
      D.11615 = monoeg_strdup (D.11614);
      monoeg_g_ptr_array_add (names, D.11615);
      i = i + 1;
      <D.11282>:
      D.11605 = glob_buf.gl_pathc;
      if (D.11605 > i) goto <D.11281>; else goto <D.11283>;
      <D.11283>:
      _wapi_globfree (&glob_buf);
      D.11616 = names->len;
      result = (gint) D.11616;
      if (result > 0) goto <D.11617>; else goto <D.11618>;
      <D.11617>:
      monoeg_g_ptr_array_sort (names, file_compare);
      D.11619 = result + 1;
      monoeg_g_ptr_array_set_size (names, D.11619);
      D.11620 = monoeg_g_ptr_array_free (names, 0);
      *namelist = D.11620;
      goto <D.11621>;
      <D.11618>:
      monoeg_g_ptr_array_free (names, 1);
      <D.11621>:
      D.11592 = result;
      return D.11592;
    }
  finally
    {
      error = {CLOBBER};
      glob_buf = {CLOBBER};
    }
}


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

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

    D.11241 = __builtin_strcmp (astr, bstr);
  }
  D.11624 = D.11241;
  return D.11624;
}


get_errno_from_g_file_error (gint error)
{
  gint D.11627;

  switch (error) <default: <D.11626>, case 3: <D.11245>, case 4: <D.11247>, case 5: <D.11248>, case 6: <D.11249>, case 7: <D.11250>, case 8: <D.11251>, case 9: <D.11252>, case 10: <D.11253>, case 11: <D.11254>, case 12: <D.11255>, case 13: <D.11256>, case 14: <D.11257>, case 15: <D.11258>, case 16: <D.11259>, case 17: <D.11260>, case 18: <D.11261>, case 19: <D.11262>, case 20: <D.11263>, case 22: <D.11264>, case 24: <D.11265>>
  <D.11245>:
  error = 36;
  goto <D.11246>;
  <D.11247>:
  error = 2;
  goto <D.11246>;
  <D.11248>:
  error = 20;
  goto <D.11246>;
  <D.11249>:
  error = 6;
  goto <D.11246>;
  <D.11250>:
  error = 19;
  goto <D.11246>;
  <D.11251>:
  error = 30;
  goto <D.11246>;
  <D.11252>:
  error = 26;
  goto <D.11246>;
  <D.11253>:
  error = 14;
  goto <D.11246>;
  <D.11254>:
  error = 40;
  goto <D.11246>;
  <D.11255>:
  error = 28;
  goto <D.11246>;
  <D.11256>:
  error = 12;
  goto <D.11246>;
  <D.11257>:
  error = 24;
  goto <D.11246>;
  <D.11258>:
  error = 23;
  goto <D.11246>;
  <D.11259>:
  error = 9;
  goto <D.11246>;
  <D.11260>:
  error = 22;
  goto <D.11246>;
  <D.11261>:
  error = 32;
  goto <D.11246>;
  <D.11262>:
  error = 11;
  goto <D.11246>;
  <D.11263>:
  error = 4;
  goto <D.11246>;
  <D.11264>:
  error = 1;
  goto <D.11246>;
  <D.11265>:
  error = 87;
  goto <D.11246>;
  <D.11626>:
  <D.11246>:
  D.11627 = error;
  return D.11627;
}