monoeg_g_build_path (const gchar * separator, const gchar * first_element)
{
  gchar * D.6416;
  long unsigned int D.6417;
  sizetype D.6418;
  const char * D.6419;
  int D.6420;
  const char * D.6422;
  long int endptr.0;
  long int elem.1;
  long int D.6427;
  char * args.2;
  char * args.3;
  int D.6431;
  char D.6432;
  long int slen.4;
  const char * elem;
  const char * next;
  const char * endptr;
  gboolean trimmed;
  struct GString * path;
  char * args;
  size_t slen;

  try
    {
      if (separator == 0B) goto <D.6414>; else goto <D.6415>;
      <D.6414>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gpath.c", 50, "separator != NULL");
      D.6416 = 0B;
      return D.6416;
      <D.6415>:
      path = monoeg_g_string_sized_new (48);
      slen = strlen (separator);
      __builtin_va_start (&args, 0);
      elem = first_element;
      goto <D.6377>;
      <D.6376>:
      D.6417 = strlen (elem);
      endptr = elem + D.6417;
      trimmed = 0;
      goto <D.6361>;
      <D.6360>:
      D.6418 = -slen;
      D.6419 = endptr + D.6418;
      D.6420 = strncmp (D.6419, separator, slen);
      if (D.6420 != 0) goto <D.6359>; else goto <D.6421>;
      <D.6421>:
      D.6418 = -slen;
      endptr = endptr + D.6418;
      trimmed = 1;
      <D.6361>:
      D.6422 = elem + slen;
      if (D.6422 <= endptr) goto <D.6360>; else goto <D.6359>;
      <D.6359>:
      if (endptr > elem) goto <D.6423>; else goto <D.6424>;
      <D.6423>:
      endptr.0 = (long int) endptr;
      elem.1 = (long int) elem;
      D.6427 = endptr.0 - elem.1;
      monoeg_g_string_append_len (path, elem, D.6427);
      <D.6424>:
      <D.6375>:
      args.2 = args;
      args.3 = args.2 + 8;
      args = args.3;
      next = MEM[(char * *)args.2];
      if (next == 0B) goto <D.6362>; else goto <D.6430>;
      <D.6430>:
      goto <D.6373>;
      <D.6372>:
      next = next + slen;
      <D.6373>:
      D.6431 = strncmp (next, separator, slen);
      if (D.6431 == 0) goto <D.6372>; else goto <D.6374>;
      <D.6374>:
      D.6432 = *next;
      if (D.6432 == 0) goto <D.6375>; else goto <D.6362>;
      <D.6362>:
      if (next != 0B) goto <D.6433>; else goto <D.6435>;
      <D.6435>:
      if (trimmed != 0) goto <D.6433>; else goto <D.6434>;
      <D.6433>:
      slen.4 = (long int) slen;
      monoeg_g_string_append_len (path, separator, slen.4);
      <D.6434>:
      elem = next;
      <D.6377>:
      if (elem != 0B) goto <D.6376>; else goto <D.6378>;
      <D.6378>:
      __builtin_va_end (&args);
      D.6416 = monoeg_g_string_free (path, 0);
      return D.6416;
    }
  finally
    {
      args = {CLOBBER};
    }
}


monoeg_g_path_get_dirname (const gchar * filename)
{
  gchar * D.6441;
  long int p.5;
  long int filename.6;
  long int D.6448;
  long unsigned int D.6449;
  char * D.6450;
  char * p;
  char * r;
  size_t count;

  if (filename == 0B) goto <D.6439>; else goto <D.6440>;
  <D.6439>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gpath.c", 114, "filename != NULL");
  D.6441 = 0B;
  return D.6441;
  <D.6440>:
  p = strrchr_seperator (filename);
  if (p == 0B) goto <D.6442>; else goto <D.6443>;
  <D.6442>:
  D.6441 = monoeg_strdup (".");
  return D.6441;
  <D.6443>:
  if (p == filename) goto <D.6444>; else goto <D.6445>;
  <D.6444>:
  D.6441 = monoeg_strdup ("/");
  return D.6441;
  <D.6445>:
  p.5 = (long int) p;
  filename.6 = (long int) filename;
  D.6448 = p.5 - filename.6;
  count = (size_t) D.6448;
  D.6449 = count + 1;
  r = monoeg_malloc (D.6449);
  strncpy (r, filename, count);
  D.6450 = r + count;
  *D.6450 = 0;
  D.6441 = r;
  return D.6441;
}


strrchr_seperator (const gchar * filename)
{
  gchar * D.6452;
  char * p;

  p = strrchr (filename, 47);
  D.6452 = p;
  return D.6452;
}


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

  if (str != 0B) goto <D.6454>; else goto <D.6455>;
  <D.6454>:
  D.6456 = __strdup (str);
  return D.6456;
  <D.6455>:
  D.6456 = 0B;
  return D.6456;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.6458;
  long unsigned int D.6459;

  D.6459 = __builtin_object_size (__dest, 1);
  D.6458 = __builtin___strncpy_chk (__dest, __src, __len, D.6459);
  return D.6458;
}


monoeg_g_path_get_basename (const char * filename)
{
  gchar * D.6463;
  char D.6464;
  char * D.6469;
  char D.6470;
  long int r.7;
  long int filename.8;
  long int D.6475;
  sizetype D.6476;
  char * D.6477;
  const gchar * D.6480;
  char * r;

  if (filename == 0B) goto <D.6461>; else goto <D.6462>;
  <D.6461>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gpath.c", 133, "filename != NULL");
  D.6463 = 0B;
  return D.6463;
  <D.6462>:
  D.6464 = *filename;
  if (D.6464 == 0) goto <D.6465>; else goto <D.6466>;
  <D.6465>:
  D.6463 = monoeg_strdup (".");
  return D.6463;
  <D.6466>:
  r = strrchr_seperator (filename);
  if (r == 0B) goto <D.6467>; else goto <D.6468>;
  <D.6467>:
  D.6463 = monoeg_strdup (filename);
  return D.6463;
  <D.6468>:
  D.6469 = r + 1;
  D.6470 = *D.6469;
  if (D.6470 == 0) goto <D.6471>; else goto <D.6472>;
  <D.6471>:
  {
    char * copy;

    copy = monoeg_strdup (filename);
    r.7 = (long int) r;
    filename.8 = (long int) filename;
    D.6475 = r.7 - filename.8;
    D.6476 = (sizetype) D.6475;
    D.6477 = copy + D.6476;
    *D.6477 = 0;
    r = strrchr_seperator (copy);
    if (r == 0B) goto <D.6478>; else goto <D.6479>;
    <D.6478>:
    monoeg_g_free (copy);
    D.6463 = monoeg_strdup ("/");
    return D.6463;
    <D.6479>:
    D.6480 = r + 1;
    r = monoeg_strdup (D.6480);
    monoeg_g_free (copy);
    D.6463 = r;
    return D.6463;
  }
  <D.6472>:
  D.6480 = r + 1;
  D.6463 = monoeg_strdup (D.6480);
  return D.6463;
}


monoeg_g_find_program_in_path (const gchar * program)
{
  const gchar * D.6482;
  gchar * D.6485;
  char D.6489;
  int D.6490;
  char * iftmp.9;
  char[2] * D.6496;
  char D.6497;
  const char * D.6499;
  char D.6500;
  char * p;
  char * x;
  char * l;
  gchar * curdir;
  char * save;

  try
    {
      D.6482 = monoeg_g_getenv ("PATH");
      p = monoeg_strdup (D.6482);
      x = p;
      curdir = 0B;
      save = 0B;
      if (program == 0B) goto <D.6483>; else goto <D.6484>;
      <D.6483>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gpath.c", 230, "program != NULL");
      D.6485 = 0B;
      return D.6485;
      <D.6484>:
      if (x == 0B) goto <D.6486>; else goto <D.6488>;
      <D.6488>:
      D.6489 = *x;
      if (D.6489 == 0) goto <D.6486>; else goto <D.6487>;
      <D.6486>:
      curdir = monoeg_g_get_current_dir ();
      x = curdir;
      <D.6487>:
      goto <D.6404>;
      <D.6403>:
      {
        char * probe_path;

        x = 0B;
        probe_path = monoeg_g_build_path ("/", l, program, 0B);
        D.6490 = access (probe_path, 1);
        if (D.6490 == 0) goto <D.6491>; else goto <D.6492>;
        <D.6491>:
        monoeg_g_free (curdir);
        monoeg_g_free (p);
        D.6485 = probe_path;
        return D.6485;
        <D.6492>:
        monoeg_g_free (probe_path);
      }
      <D.6404>:
      D.6496 = ":";
      D.6497 = MEM[(const char *)D.6496];
      if (D.6497 != 0) goto <D.6498>; else goto <D.6494>;
      <D.6498>:
      D.6499 = &MEM[(void *)":" + 1B];
      D.6500 = *D.6499;
      if (D.6500 == 0) goto <D.6501>; else goto <D.6494>;
      <D.6501>:
      D.6496 = ":";
      D.6497 = MEM[(const char *)D.6496];
      iftmp.9 = __strtok_r_1c (x, D.6497, &save);
      goto <D.6495>;
      <D.6494>:
      iftmp.9 = __strtok_r (x, ":", &save);
      <D.6495>:
      l = iftmp.9;
      if (l != 0B) goto <D.6403>; else goto <D.6405>;
      <D.6405>:
      monoeg_g_free (curdir);
      monoeg_g_free (p);
      D.6485 = 0B;
      return D.6485;
    }
  finally
    {
      save = {CLOBBER};
    }
}


__strtok_r_1c (char * __s, char __sep, char * * __nextp)
{
  char D.6506;
  char * __s.10;
  char * __s.11;
  char D.6511;
  char * D.6514;
  char * D.6515;
  char * __result;

  if (__s == 0B) goto <D.6504>; else goto <D.6505>;
  <D.6504>:
  __s = *__nextp;
  <D.6505>:
  goto <D.4089>;
  <D.4088>:
  __s = __s + 1;
  <D.4089>:
  D.6506 = *__s;
  if (D.6506 == __sep) goto <D.4088>; else goto <D.4090>;
  <D.4090>:
  __result = 0B;
  D.6506 = *__s;
  if (D.6506 != 0) goto <D.6507>; else goto <D.6508>;
  <D.6507>:
  __s.10 = __s;
  __s = __s.10 + 1;
  __result = __s.10;
  goto <D.4093>;
  <D.4092>:
  __s.11 = __s;
  __s = __s.11 + 1;
  D.6511 = *__s.11;
  if (D.6511 == __sep) goto <D.6512>; else goto <D.6513>;
  <D.6512>:
  D.6514 = __s + 18446744073709551615;
  *D.6514 = 0;
  goto <D.4091>;
  <D.6513>:
  <D.4093>:
  D.6506 = *__s;
  if (D.6506 != 0) goto <D.4092>; else goto <D.4091>;
  <D.4091>:
  <D.6508>:
  *__nextp = __s;
  D.6515 = __result;
  return D.6515;
}


monoeg_g_set_prgname (const gchar * prgname)
{
  gchar * name.12;

  name.12 = monoeg_strdup (prgname);
  name = name.12;
}


monoeg_g_get_prgname ()
{
  gchar * D.6518;

  D.6518 = name;
  return D.6518;
}