test_buildpath ()
{
  int D.6488;
  int iftmp.0;
  int D.6487;
  char[11] * D.6738;
  unsigned char D.6739;
  int D.6740;
  unsigned char D.6741;
  int D.6742;
  _Bool D.6743;
  _Bool D.6744;
  _Bool D.6745;
  const unsigned char * D.6748;
  unsigned char D.6749;
  int D.6750;
  const unsigned char * D.6751;
  unsigned char D.6752;
  int D.6753;
  _Bool D.6754;
  _Bool D.6755;
  const unsigned char * D.6758;
  unsigned char D.6759;
  int D.6760;
  const unsigned char * D.6761;
  unsigned char D.6762;
  int D.6763;
  _Bool D.6764;
  _Bool D.6765;
  const unsigned char * D.6768;
  unsigned char D.6769;
  int D.6770;
  const unsigned char * D.6771;
  unsigned char D.6772;
  int D.6773;
  gchar * D.6777;
  int D.6497;
  int iftmp.1;
  int D.6496;
  unsigned char D.6781;
  int D.6782;
  _Bool D.6783;
  _Bool D.6784;
  _Bool D.6785;
  const unsigned char * D.6788;
  unsigned char D.6789;
  int D.6790;
  _Bool D.6791;
  _Bool D.6792;
  const unsigned char * D.6795;
  unsigned char D.6796;
  int D.6797;
  _Bool D.6798;
  _Bool D.6799;
  const unsigned char * D.6802;
  unsigned char D.6803;
  int D.6804;
  int D.6506;
  int iftmp.2;
  int D.6505;
  unsigned char D.6811;
  int D.6812;
  _Bool D.6813;
  _Bool D.6814;
  _Bool D.6815;
  const unsigned char * D.6818;
  unsigned char D.6819;
  int D.6820;
  _Bool D.6821;
  _Bool D.6822;
  const unsigned char * D.6825;
  unsigned char D.6826;
  int D.6827;
  _Bool D.6828;
  _Bool D.6829;
  const unsigned char * D.6832;
  unsigned char D.6833;
  int D.6834;
  int D.6515;
  int iftmp.3;
  int D.6514;
  unsigned char D.6841;
  int D.6842;
  _Bool D.6843;
  _Bool D.6844;
  _Bool D.6845;
  const unsigned char * D.6848;
  unsigned char D.6849;
  int D.6850;
  _Bool D.6851;
  _Bool D.6852;
  const unsigned char * D.6855;
  unsigned char D.6856;
  int D.6857;
  _Bool D.6858;
  _Bool D.6859;
  const unsigned char * D.6862;
  unsigned char D.6863;
  int D.6864;
  int D.6524;
  int iftmp.4;
  int D.6523;
  char[14] * D.6871;
  unsigned char D.6872;
  int D.6873;
  unsigned char D.6874;
  int D.6875;
  _Bool D.6876;
  _Bool D.6877;
  _Bool D.6878;
  const unsigned char * D.6881;
  unsigned char D.6882;
  int D.6883;
  const unsigned char * D.6884;
  unsigned char D.6885;
  int D.6886;
  _Bool D.6887;
  _Bool D.6888;
  const unsigned char * D.6891;
  unsigned char D.6892;
  int D.6893;
  const unsigned char * D.6894;
  unsigned char D.6895;
  int D.6896;
  _Bool D.6897;
  _Bool D.6898;
  const unsigned char * D.6901;
  unsigned char D.6902;
  int D.6903;
  const unsigned char * D.6904;
  unsigned char D.6905;
  int D.6906;
  int D.6533;
  int iftmp.5;
  int D.6532;
  char[13] * D.6913;
  unsigned char D.6914;
  int D.6915;
  unsigned char D.6916;
  int D.6917;
  _Bool D.6918;
  _Bool D.6919;
  _Bool D.6920;
  const unsigned char * D.6923;
  unsigned char D.6924;
  int D.6925;
  const unsigned char * D.6926;
  unsigned char D.6927;
  int D.6928;
  _Bool D.6929;
  _Bool D.6930;
  const unsigned char * D.6933;
  unsigned char D.6934;
  int D.6935;
  const unsigned char * D.6936;
  unsigned char D.6937;
  int D.6938;
  _Bool D.6939;
  _Bool D.6940;
  const unsigned char * D.6943;
  unsigned char D.6944;
  int D.6945;
  const unsigned char * D.6946;
  unsigned char D.6947;
  int D.6948;
  int D.6542;
  int iftmp.6;
  int D.6541;
  unsigned char D.6955;
  int D.6956;
  _Bool D.6957;
  _Bool D.6958;
  _Bool D.6959;
  const unsigned char * D.6962;
  unsigned char D.6963;
  int D.6964;
  _Bool D.6965;
  _Bool D.6966;
  const unsigned char * D.6969;
  unsigned char D.6970;
  int D.6971;
  _Bool D.6972;
  _Bool D.6973;
  const unsigned char * D.6976;
  unsigned char D.6977;
  int D.6978;
  int D.6551;
  int iftmp.7;
  int D.6550;
  unsigned char D.6985;
  int D.6986;
  _Bool D.6987;
  _Bool D.6988;
  _Bool D.6989;
  const unsigned char * D.6992;
  unsigned char D.6993;
  int D.6994;
  _Bool D.6995;
  _Bool D.6996;
  const unsigned char * D.6999;
  unsigned char D.7000;
  int D.7001;
  _Bool D.7002;
  _Bool D.7003;
  const unsigned char * D.7006;
  unsigned char D.7007;
  int D.7008;
  int D.6560;
  int iftmp.8;
  int D.6559;
  unsigned char D.7015;
  int D.7016;
  _Bool D.7017;
  _Bool D.7018;
  _Bool D.7019;
  const unsigned char * D.7022;
  unsigned char D.7023;
  int D.7024;
  _Bool D.7025;
  _Bool D.7026;
  const unsigned char * D.7029;
  unsigned char D.7030;
  int D.7031;
  _Bool D.7032;
  _Bool D.7033;
  const unsigned char * D.7036;
  unsigned char D.7037;
  int D.7038;
  int D.6569;
  int iftmp.9;
  int D.6568;
  char[21] * D.7045;
  unsigned char D.7046;
  int D.7047;
  unsigned char D.7048;
  int D.7049;
  _Bool D.7050;
  _Bool D.7051;
  _Bool D.7052;
  const unsigned char * D.7055;
  unsigned char D.7056;
  int D.7057;
  const unsigned char * D.7058;
  unsigned char D.7059;
  int D.7060;
  _Bool D.7061;
  _Bool D.7062;
  const unsigned char * D.7065;
  unsigned char D.7066;
  int D.7067;
  const unsigned char * D.7068;
  unsigned char D.7069;
  int D.7070;
  _Bool D.7071;
  _Bool D.7072;
  const unsigned char * D.7075;
  unsigned char D.7076;
  int D.7077;
  const unsigned char * D.7078;
  unsigned char D.7079;
  int D.7080;
  int D.6578;
  int iftmp.10;
  int D.6577;
  unsigned char D.7087;
  int D.7088;
  _Bool D.7089;
  _Bool D.7090;
  _Bool D.7091;
  const unsigned char * D.7094;
  unsigned char D.7095;
  int D.7096;
  _Bool D.7097;
  _Bool D.7098;
  const unsigned char * D.7101;
  unsigned char D.7102;
  int D.7103;
  _Bool D.7104;
  _Bool D.7105;
  const unsigned char * D.7108;
  unsigned char D.7109;
  int D.7110;
  int D.6587;
  int iftmp.11;
  int D.6586;
  unsigned char D.7117;
  int D.7118;
  _Bool D.7119;
  _Bool D.7120;
  _Bool D.7121;
  const unsigned char * D.7124;
  unsigned char D.7125;
  int D.7126;
  _Bool D.7127;
  _Bool D.7128;
  const unsigned char * D.7131;
  unsigned char D.7132;
  int D.7133;
  _Bool D.7134;
  _Bool D.7135;
  const unsigned char * D.7138;
  unsigned char D.7139;
  int D.7140;
  int D.6596;
  int iftmp.12;
  int D.6595;
  char[8] * D.7147;
  unsigned char D.7148;
  int D.7149;
  unsigned char D.7150;
  int D.7151;
  _Bool D.7152;
  _Bool D.7153;
  _Bool D.7154;
  const unsigned char * D.7157;
  unsigned char D.7158;
  int D.7159;
  const unsigned char * D.7160;
  unsigned char D.7161;
  int D.7162;
  _Bool D.7163;
  _Bool D.7164;
  const unsigned char * D.7167;
  unsigned char D.7168;
  int D.7169;
  const unsigned char * D.7170;
  unsigned char D.7171;
  int D.7172;
  _Bool D.7173;
  _Bool D.7174;
  const unsigned char * D.7177;
  unsigned char D.7178;
  int D.7179;
  const unsigned char * D.7180;
  unsigned char D.7181;
  int D.7182;
  int D.6605;
  int iftmp.13;
  int D.6604;
  char[6] * D.7189;
  unsigned char D.7190;
  int D.7191;
  unsigned char D.7192;
  int D.7193;
  _Bool D.7194;
  _Bool D.7195;
  _Bool D.7196;
  const unsigned char * D.7199;
  unsigned char D.7200;
  int D.7201;
  const unsigned char * D.7202;
  unsigned char D.7203;
  int D.7204;
  _Bool D.7205;
  _Bool D.7206;
  const unsigned char * D.7209;
  unsigned char D.7210;
  int D.7211;
  const unsigned char * D.7212;
  unsigned char D.7213;
  int D.7214;
  _Bool D.7215;
  _Bool D.7216;
  const unsigned char * D.7219;
  unsigned char D.7220;
  int D.7221;
  const unsigned char * D.7222;
  unsigned char D.7223;
  int D.7224;
  char D.7230;
  char * s;
  char * buffer;
  char * dir;

  buffer = "var/private";
  dir = "/";
  s = monoeg_g_build_path ("/", "hola///", "//mundo", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 10;
    if (__s2_len <= 3) goto <D.6736>; else goto <D.6737>;
    <D.6736>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.6738 = "hola/mundo";
      D.6739 = MEM[(const unsigned char *)D.6738];
      D.6740 = (int) D.6739;
      D.6741 = *__s2;
      D.6742 = (int) D.6741;
      __result = D.6740 - D.6742;
      {
        D.6743 = __s2_len != 0;
        D.6744 = __result == 0;
        D.6745 = D.6743 & D.6744;
        if (D.6745 != 0) goto <D.6746>; else goto <D.6747>;
        <D.6746>:
        D.6748 = &MEM[(void *)"hola/mundo" + 1B];
        D.6749 = *D.6748;
        D.6750 = (int) D.6749;
        D.6751 = __s2 + 1;
        D.6752 = *D.6751;
        D.6753 = (int) D.6752;
        __result = D.6750 - D.6753;
        D.6754 = __s2_len > 1;
        D.6744 = __result == 0;
        D.6755 = D.6754 & D.6744;
        if (D.6755 != 0) goto <D.6756>; else goto <D.6757>;
        <D.6756>:
        D.6758 = &MEM[(void *)"hola/mundo" + 2B];
        D.6759 = *D.6758;
        D.6760 = (int) D.6759;
        D.6761 = __s2 + 2;
        D.6762 = *D.6761;
        D.6763 = (int) D.6762;
        __result = D.6760 - D.6763;
        D.6764 = __s2_len > 2;
        D.6744 = __result == 0;
        D.6765 = D.6764 & D.6744;
        if (D.6765 != 0) goto <D.6766>; else goto <D.6767>;
        <D.6766>:
        D.6768 = &MEM[(void *)"hola/mundo" + 3B];
        D.6769 = *D.6768;
        D.6770 = (int) D.6769;
        D.6771 = __s2 + 3;
        D.6772 = *D.6771;
        D.6773 = (int) D.6772;
        __result = D.6770 - D.6773;
        <D.6767>:
        <D.6757>:
        <D.6747>:
      }
      D.6487 = __result;
    }
    iftmp.0 = -D.6487;
    goto <D.6774>;
    <D.6737>:
    iftmp.0 = __builtin_strcmp (s, "hola/mundo");
    <D.6774>:
    D.6488 = iftmp.0;
  }
  if (D.6488 != 0) goto <D.6775>; else goto <D.6776>;
  <D.6775>:
  D.6777 = FAILED ("1 Got wrong result, got: %s", s);
  return D.6777;
  <D.6776>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("/", "hola/", "/mundo", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 10;
    if (__s2_len <= 3) goto <D.6779>; else goto <D.6780>;
    <D.6779>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.6738 = "hola/mundo";
      D.6739 = MEM[(const unsigned char *)D.6738];
      D.6740 = (int) D.6739;
      D.6781 = *__s2;
      D.6782 = (int) D.6781;
      __result = D.6740 - D.6782;
      {
        D.6783 = __s2_len != 0;
        D.6784 = __result == 0;
        D.6785 = D.6783 & D.6784;
        if (D.6785 != 0) goto <D.6786>; else goto <D.6787>;
        <D.6786>:
        D.6748 = &MEM[(void *)"hola/mundo" + 1B];
        D.6749 = *D.6748;
        D.6750 = (int) D.6749;
        D.6788 = __s2 + 1;
        D.6789 = *D.6788;
        D.6790 = (int) D.6789;
        __result = D.6750 - D.6790;
        D.6791 = __s2_len > 1;
        D.6784 = __result == 0;
        D.6792 = D.6791 & D.6784;
        if (D.6792 != 0) goto <D.6793>; else goto <D.6794>;
        <D.6793>:
        D.6758 = &MEM[(void *)"hola/mundo" + 2B];
        D.6759 = *D.6758;
        D.6760 = (int) D.6759;
        D.6795 = __s2 + 2;
        D.6796 = *D.6795;
        D.6797 = (int) D.6796;
        __result = D.6760 - D.6797;
        D.6798 = __s2_len > 2;
        D.6784 = __result == 0;
        D.6799 = D.6798 & D.6784;
        if (D.6799 != 0) goto <D.6800>; else goto <D.6801>;
        <D.6800>:
        D.6768 = &MEM[(void *)"hola/mundo" + 3B];
        D.6769 = *D.6768;
        D.6770 = (int) D.6769;
        D.6802 = __s2 + 3;
        D.6803 = *D.6802;
        D.6804 = (int) D.6803;
        __result = D.6770 - D.6804;
        <D.6801>:
        <D.6794>:
        <D.6787>:
      }
      D.6496 = __result;
    }
    iftmp.1 = -D.6496;
    goto <D.6805>;
    <D.6780>:
    iftmp.1 = __builtin_strcmp (s, "hola/mundo");
    <D.6805>:
    D.6497 = iftmp.1;
  }
  if (D.6497 != 0) goto <D.6806>; else goto <D.6807>;
  <D.6806>:
  D.6777 = FAILED ("2 Got wrong result, got: %s", s);
  return D.6777;
  <D.6807>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("/", "hola/", "mundo", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 10;
    if (__s2_len <= 3) goto <D.6809>; else goto <D.6810>;
    <D.6809>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.6738 = "hola/mundo";
      D.6739 = MEM[(const unsigned char *)D.6738];
      D.6740 = (int) D.6739;
      D.6811 = *__s2;
      D.6812 = (int) D.6811;
      __result = D.6740 - D.6812;
      {
        D.6813 = __s2_len != 0;
        D.6814 = __result == 0;
        D.6815 = D.6813 & D.6814;
        if (D.6815 != 0) goto <D.6816>; else goto <D.6817>;
        <D.6816>:
        D.6748 = &MEM[(void *)"hola/mundo" + 1B];
        D.6749 = *D.6748;
        D.6750 = (int) D.6749;
        D.6818 = __s2 + 1;
        D.6819 = *D.6818;
        D.6820 = (int) D.6819;
        __result = D.6750 - D.6820;
        D.6821 = __s2_len > 1;
        D.6814 = __result == 0;
        D.6822 = D.6821 & D.6814;
        if (D.6822 != 0) goto <D.6823>; else goto <D.6824>;
        <D.6823>:
        D.6758 = &MEM[(void *)"hola/mundo" + 2B];
        D.6759 = *D.6758;
        D.6760 = (int) D.6759;
        D.6825 = __s2 + 2;
        D.6826 = *D.6825;
        D.6827 = (int) D.6826;
        __result = D.6760 - D.6827;
        D.6828 = __s2_len > 2;
        D.6814 = __result == 0;
        D.6829 = D.6828 & D.6814;
        if (D.6829 != 0) goto <D.6830>; else goto <D.6831>;
        <D.6830>:
        D.6768 = &MEM[(void *)"hola/mundo" + 3B];
        D.6769 = *D.6768;
        D.6770 = (int) D.6769;
        D.6832 = __s2 + 3;
        D.6833 = *D.6832;
        D.6834 = (int) D.6833;
        __result = D.6770 - D.6834;
        <D.6831>:
        <D.6824>:
        <D.6817>:
      }
      D.6505 = __result;
    }
    iftmp.2 = -D.6505;
    goto <D.6835>;
    <D.6810>:
    iftmp.2 = __builtin_strcmp (s, "hola/mundo");
    <D.6835>:
    D.6506 = iftmp.2;
  }
  if (D.6506 != 0) goto <D.6836>; else goto <D.6837>;
  <D.6836>:
  D.6777 = FAILED ("3 Got wrong result, got: %s", s);
  return D.6777;
  <D.6837>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("/", "hola", "/mundo", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 10;
    if (__s2_len <= 3) goto <D.6839>; else goto <D.6840>;
    <D.6839>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.6738 = "hola/mundo";
      D.6739 = MEM[(const unsigned char *)D.6738];
      D.6740 = (int) D.6739;
      D.6841 = *__s2;
      D.6842 = (int) D.6841;
      __result = D.6740 - D.6842;
      {
        D.6843 = __s2_len != 0;
        D.6844 = __result == 0;
        D.6845 = D.6843 & D.6844;
        if (D.6845 != 0) goto <D.6846>; else goto <D.6847>;
        <D.6846>:
        D.6748 = &MEM[(void *)"hola/mundo" + 1B];
        D.6749 = *D.6748;
        D.6750 = (int) D.6749;
        D.6848 = __s2 + 1;
        D.6849 = *D.6848;
        D.6850 = (int) D.6849;
        __result = D.6750 - D.6850;
        D.6851 = __s2_len > 1;
        D.6844 = __result == 0;
        D.6852 = D.6851 & D.6844;
        if (D.6852 != 0) goto <D.6853>; else goto <D.6854>;
        <D.6853>:
        D.6758 = &MEM[(void *)"hola/mundo" + 2B];
        D.6759 = *D.6758;
        D.6760 = (int) D.6759;
        D.6855 = __s2 + 2;
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        __result = D.6760 - D.6857;
        D.6858 = __s2_len > 2;
        D.6844 = __result == 0;
        D.6859 = D.6858 & D.6844;
        if (D.6859 != 0) goto <D.6860>; else goto <D.6861>;
        <D.6860>:
        D.6768 = &MEM[(void *)"hola/mundo" + 3B];
        D.6769 = *D.6768;
        D.6770 = (int) D.6769;
        D.6862 = __s2 + 3;
        D.6863 = *D.6862;
        D.6864 = (int) D.6863;
        __result = D.6770 - D.6864;
        <D.6861>:
        <D.6854>:
        <D.6847>:
      }
      D.6514 = __result;
    }
    iftmp.3 = -D.6514;
    goto <D.6865>;
    <D.6840>:
    iftmp.3 = __builtin_strcmp (s, "hola/mundo");
    <D.6865>:
    D.6515 = iftmp.3;
  }
  if (D.6515 != 0) goto <D.6866>; else goto <D.6867>;
  <D.6866>:
  D.6777 = FAILED ("4 Got wrong result, got: %s", s);
  return D.6777;
  <D.6867>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("/", "/hello", "world/", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 13;
    if (__s2_len <= 3) goto <D.6869>; else goto <D.6870>;
    <D.6869>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.6871 = "/hello/world/";
      D.6872 = MEM[(const unsigned char *)D.6871];
      D.6873 = (int) D.6872;
      D.6874 = *__s2;
      D.6875 = (int) D.6874;
      __result = D.6873 - D.6875;
      {
        D.6876 = __s2_len != 0;
        D.6877 = __result == 0;
        D.6878 = D.6876 & D.6877;
        if (D.6878 != 0) goto <D.6879>; else goto <D.6880>;
        <D.6879>:
        D.6881 = &MEM[(void *)"/hello/world/" + 1B];
        D.6882 = *D.6881;
        D.6883 = (int) D.6882;
        D.6884 = __s2 + 1;
        D.6885 = *D.6884;
        D.6886 = (int) D.6885;
        __result = D.6883 - D.6886;
        D.6887 = __s2_len > 1;
        D.6877 = __result == 0;
        D.6888 = D.6887 & D.6877;
        if (D.6888 != 0) goto <D.6889>; else goto <D.6890>;
        <D.6889>:
        D.6891 = &MEM[(void *)"/hello/world/" + 2B];
        D.6892 = *D.6891;
        D.6893 = (int) D.6892;
        D.6894 = __s2 + 2;
        D.6895 = *D.6894;
        D.6896 = (int) D.6895;
        __result = D.6893 - D.6896;
        D.6897 = __s2_len > 2;
        D.6877 = __result == 0;
        D.6898 = D.6897 & D.6877;
        if (D.6898 != 0) goto <D.6899>; else goto <D.6900>;
        <D.6899>:
        D.6901 = &MEM[(void *)"/hello/world/" + 3B];
        D.6902 = *D.6901;
        D.6903 = (int) D.6902;
        D.6904 = __s2 + 3;
        D.6905 = *D.6904;
        D.6906 = (int) D.6905;
        __result = D.6903 - D.6906;
        <D.6900>:
        <D.6890>:
        <D.6880>:
      }
      D.6523 = __result;
    }
    iftmp.4 = -D.6523;
    goto <D.6907>;
    <D.6870>:
    iftmp.4 = __builtin_strcmp (s, "/hello/world/");
    <D.6907>:
    D.6524 = iftmp.4;
  }
  if (D.6524 != 0) goto <D.6908>; else goto <D.6909>;
  <D.6908>:
  D.6777 = FAILED ("5 Got wrong result, got: %s", s);
  return D.6777;
  <D.6909>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("**", "hello", "world", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 12;
    if (__s2_len <= 3) goto <D.6911>; else goto <D.6912>;
    <D.6911>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.6913 = "hello**world";
      D.6914 = MEM[(const unsigned char *)D.6913];
      D.6915 = (int) D.6914;
      D.6916 = *__s2;
      D.6917 = (int) D.6916;
      __result = D.6915 - D.6917;
      {
        D.6918 = __s2_len != 0;
        D.6919 = __result == 0;
        D.6920 = D.6918 & D.6919;
        if (D.6920 != 0) goto <D.6921>; else goto <D.6922>;
        <D.6921>:
        D.6923 = &MEM[(void *)"hello**world" + 1B];
        D.6924 = *D.6923;
        D.6925 = (int) D.6924;
        D.6926 = __s2 + 1;
        D.6927 = *D.6926;
        D.6928 = (int) D.6927;
        __result = D.6925 - D.6928;
        D.6929 = __s2_len > 1;
        D.6919 = __result == 0;
        D.6930 = D.6929 & D.6919;
        if (D.6930 != 0) goto <D.6931>; else goto <D.6932>;
        <D.6931>:
        D.6933 = &MEM[(void *)"hello**world" + 2B];
        D.6934 = *D.6933;
        D.6935 = (int) D.6934;
        D.6936 = __s2 + 2;
        D.6937 = *D.6936;
        D.6938 = (int) D.6937;
        __result = D.6935 - D.6938;
        D.6939 = __s2_len > 2;
        D.6919 = __result == 0;
        D.6940 = D.6939 & D.6919;
        if (D.6940 != 0) goto <D.6941>; else goto <D.6942>;
        <D.6941>:
        D.6943 = &MEM[(void *)"hello**world" + 3B];
        D.6944 = *D.6943;
        D.6945 = (int) D.6944;
        D.6946 = __s2 + 3;
        D.6947 = *D.6946;
        D.6948 = (int) D.6947;
        __result = D.6945 - D.6948;
        <D.6942>:
        <D.6932>:
        <D.6922>:
      }
      D.6532 = __result;
    }
    iftmp.5 = -D.6532;
    goto <D.6949>;
    <D.6912>:
    iftmp.5 = __builtin_strcmp (s, "hello**world");
    <D.6949>:
    D.6533 = iftmp.5;
  }
  if (D.6533 != 0) goto <D.6950>; else goto <D.6951>;
  <D.6950>:
  D.6777 = FAILED ("6 Got wrong result, got: %s", s);
  return D.6777;
  <D.6951>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("**", "hello**", "world", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 12;
    if (__s2_len <= 3) goto <D.6953>; else goto <D.6954>;
    <D.6953>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.6913 = "hello**world";
      D.6914 = MEM[(const unsigned char *)D.6913];
      D.6915 = (int) D.6914;
      D.6955 = *__s2;
      D.6956 = (int) D.6955;
      __result = D.6915 - D.6956;
      {
        D.6957 = __s2_len != 0;
        D.6958 = __result == 0;
        D.6959 = D.6957 & D.6958;
        if (D.6959 != 0) goto <D.6960>; else goto <D.6961>;
        <D.6960>:
        D.6923 = &MEM[(void *)"hello**world" + 1B];
        D.6924 = *D.6923;
        D.6925 = (int) D.6924;
        D.6962 = __s2 + 1;
        D.6963 = *D.6962;
        D.6964 = (int) D.6963;
        __result = D.6925 - D.6964;
        D.6965 = __s2_len > 1;
        D.6958 = __result == 0;
        D.6966 = D.6965 & D.6958;
        if (D.6966 != 0) goto <D.6967>; else goto <D.6968>;
        <D.6967>:
        D.6933 = &MEM[(void *)"hello**world" + 2B];
        D.6934 = *D.6933;
        D.6935 = (int) D.6934;
        D.6969 = __s2 + 2;
        D.6970 = *D.6969;
        D.6971 = (int) D.6970;
        __result = D.6935 - D.6971;
        D.6972 = __s2_len > 2;
        D.6958 = __result == 0;
        D.6973 = D.6972 & D.6958;
        if (D.6973 != 0) goto <D.6974>; else goto <D.6975>;
        <D.6974>:
        D.6943 = &MEM[(void *)"hello**world" + 3B];
        D.6944 = *D.6943;
        D.6945 = (int) D.6944;
        D.6976 = __s2 + 3;
        D.6977 = *D.6976;
        D.6978 = (int) D.6977;
        __result = D.6945 - D.6978;
        <D.6975>:
        <D.6968>:
        <D.6961>:
      }
      D.6541 = __result;
    }
    iftmp.6 = -D.6541;
    goto <D.6979>;
    <D.6954>:
    iftmp.6 = __builtin_strcmp (s, "hello**world");
    <D.6979>:
    D.6542 = iftmp.6;
  }
  if (D.6542 != 0) goto <D.6980>; else goto <D.6981>;
  <D.6980>:
  D.6777 = FAILED ("7 Got wrong result, got: %s", s);
  return D.6777;
  <D.6981>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("**", "hello**", "**world", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 12;
    if (__s2_len <= 3) goto <D.6983>; else goto <D.6984>;
    <D.6983>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.6913 = "hello**world";
      D.6914 = MEM[(const unsigned char *)D.6913];
      D.6915 = (int) D.6914;
      D.6985 = *__s2;
      D.6986 = (int) D.6985;
      __result = D.6915 - D.6986;
      {
        D.6987 = __s2_len != 0;
        D.6988 = __result == 0;
        D.6989 = D.6987 & D.6988;
        if (D.6989 != 0) goto <D.6990>; else goto <D.6991>;
        <D.6990>:
        D.6923 = &MEM[(void *)"hello**world" + 1B];
        D.6924 = *D.6923;
        D.6925 = (int) D.6924;
        D.6992 = __s2 + 1;
        D.6993 = *D.6992;
        D.6994 = (int) D.6993;
        __result = D.6925 - D.6994;
        D.6995 = __s2_len > 1;
        D.6988 = __result == 0;
        D.6996 = D.6995 & D.6988;
        if (D.6996 != 0) goto <D.6997>; else goto <D.6998>;
        <D.6997>:
        D.6933 = &MEM[(void *)"hello**world" + 2B];
        D.6934 = *D.6933;
        D.6935 = (int) D.6934;
        D.6999 = __s2 + 2;
        D.7000 = *D.6999;
        D.7001 = (int) D.7000;
        __result = D.6935 - D.7001;
        D.7002 = __s2_len > 2;
        D.6988 = __result == 0;
        D.7003 = D.7002 & D.6988;
        if (D.7003 != 0) goto <D.7004>; else goto <D.7005>;
        <D.7004>:
        D.6943 = &MEM[(void *)"hello**world" + 3B];
        D.6944 = *D.6943;
        D.6945 = (int) D.6944;
        D.7006 = __s2 + 3;
        D.7007 = *D.7006;
        D.7008 = (int) D.7007;
        __result = D.6945 - D.7008;
        <D.7005>:
        <D.6998>:
        <D.6991>:
      }
      D.6550 = __result;
    }
    iftmp.7 = -D.6550;
    goto <D.7009>;
    <D.6984>:
    iftmp.7 = __builtin_strcmp (s, "hello**world");
    <D.7009>:
    D.6551 = iftmp.7;
  }
  if (D.6551 != 0) goto <D.7010>; else goto <D.7011>;
  <D.7010>:
  D.6777 = FAILED ("8 Got wrong result, got: %s", s);
  return D.6777;
  <D.7011>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("**", "hello**", "**world", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 12;
    if (__s2_len <= 3) goto <D.7013>; else goto <D.7014>;
    <D.7013>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.6913 = "hello**world";
      D.6914 = MEM[(const unsigned char *)D.6913];
      D.6915 = (int) D.6914;
      D.7015 = *__s2;
      D.7016 = (int) D.7015;
      __result = D.6915 - D.7016;
      {
        D.7017 = __s2_len != 0;
        D.7018 = __result == 0;
        D.7019 = D.7017 & D.7018;
        if (D.7019 != 0) goto <D.7020>; else goto <D.7021>;
        <D.7020>:
        D.6923 = &MEM[(void *)"hello**world" + 1B];
        D.6924 = *D.6923;
        D.6925 = (int) D.6924;
        D.7022 = __s2 + 1;
        D.7023 = *D.7022;
        D.7024 = (int) D.7023;
        __result = D.6925 - D.7024;
        D.7025 = __s2_len > 1;
        D.7018 = __result == 0;
        D.7026 = D.7025 & D.7018;
        if (D.7026 != 0) goto <D.7027>; else goto <D.7028>;
        <D.7027>:
        D.6933 = &MEM[(void *)"hello**world" + 2B];
        D.6934 = *D.6933;
        D.6935 = (int) D.6934;
        D.7029 = __s2 + 2;
        D.7030 = *D.7029;
        D.7031 = (int) D.7030;
        __result = D.6935 - D.7031;
        D.7032 = __s2_len > 2;
        D.7018 = __result == 0;
        D.7033 = D.7032 & D.7018;
        if (D.7033 != 0) goto <D.7034>; else goto <D.7035>;
        <D.7034>:
        D.6943 = &MEM[(void *)"hello**world" + 3B];
        D.6944 = *D.6943;
        D.6945 = (int) D.6944;
        D.7036 = __s2 + 3;
        D.7037 = *D.7036;
        D.7038 = (int) D.7037;
        __result = D.6945 - D.7038;
        <D.7035>:
        <D.7028>:
        <D.7021>:
      }
      D.6559 = __result;
    }
    iftmp.8 = -D.6559;
    goto <D.7039>;
    <D.7014>:
    iftmp.8 = __builtin_strcmp (s, "hello**world");
    <D.7039>:
    D.6560 = iftmp.8;
  }
  if (D.6560 != 0) goto <D.7040>; else goto <D.7041>;
  <D.7040>:
  D.6777 = FAILED ("9 Got wrong result, got: %s", s);
  return D.6777;
  <D.7041>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("1234567890", "hello", "world", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 20;
    if (__s2_len <= 3) goto <D.7043>; else goto <D.7044>;
    <D.7043>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7045 = "hello1234567890world";
      D.7046 = MEM[(const unsigned char *)D.7045];
      D.7047 = (int) D.7046;
      D.7048 = *__s2;
      D.7049 = (int) D.7048;
      __result = D.7047 - D.7049;
      {
        D.7050 = __s2_len != 0;
        D.7051 = __result == 0;
        D.7052 = D.7050 & D.7051;
        if (D.7052 != 0) goto <D.7053>; else goto <D.7054>;
        <D.7053>:
        D.7055 = &MEM[(void *)"hello1234567890world" + 1B];
        D.7056 = *D.7055;
        D.7057 = (int) D.7056;
        D.7058 = __s2 + 1;
        D.7059 = *D.7058;
        D.7060 = (int) D.7059;
        __result = D.7057 - D.7060;
        D.7061 = __s2_len > 1;
        D.7051 = __result == 0;
        D.7062 = D.7061 & D.7051;
        if (D.7062 != 0) goto <D.7063>; else goto <D.7064>;
        <D.7063>:
        D.7065 = &MEM[(void *)"hello1234567890world" + 2B];
        D.7066 = *D.7065;
        D.7067 = (int) D.7066;
        D.7068 = __s2 + 2;
        D.7069 = *D.7068;
        D.7070 = (int) D.7069;
        __result = D.7067 - D.7070;
        D.7071 = __s2_len > 2;
        D.7051 = __result == 0;
        D.7072 = D.7071 & D.7051;
        if (D.7072 != 0) goto <D.7073>; else goto <D.7074>;
        <D.7073>:
        D.7075 = &MEM[(void *)"hello1234567890world" + 3B];
        D.7076 = *D.7075;
        D.7077 = (int) D.7076;
        D.7078 = __s2 + 3;
        D.7079 = *D.7078;
        D.7080 = (int) D.7079;
        __result = D.7077 - D.7080;
        <D.7074>:
        <D.7064>:
        <D.7054>:
      }
      D.6568 = __result;
    }
    iftmp.9 = -D.6568;
    goto <D.7081>;
    <D.7044>:
    iftmp.9 = __builtin_strcmp (s, "hello1234567890world");
    <D.7081>:
    D.6569 = iftmp.9;
  }
  if (D.6569 != 0) goto <D.7082>; else goto <D.7083>;
  <D.7082>:
  D.6777 = FAILED ("10 Got wrong result, got: %s", s);
  return D.6777;
  <D.7083>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("1234567890", "hello1234567890", "1234567890world", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 20;
    if (__s2_len <= 3) goto <D.7085>; else goto <D.7086>;
    <D.7085>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7045 = "hello1234567890world";
      D.7046 = MEM[(const unsigned char *)D.7045];
      D.7047 = (int) D.7046;
      D.7087 = *__s2;
      D.7088 = (int) D.7087;
      __result = D.7047 - D.7088;
      {
        D.7089 = __s2_len != 0;
        D.7090 = __result == 0;
        D.7091 = D.7089 & D.7090;
        if (D.7091 != 0) goto <D.7092>; else goto <D.7093>;
        <D.7092>:
        D.7055 = &MEM[(void *)"hello1234567890world" + 1B];
        D.7056 = *D.7055;
        D.7057 = (int) D.7056;
        D.7094 = __s2 + 1;
        D.7095 = *D.7094;
        D.7096 = (int) D.7095;
        __result = D.7057 - D.7096;
        D.7097 = __s2_len > 1;
        D.7090 = __result == 0;
        D.7098 = D.7097 & D.7090;
        if (D.7098 != 0) goto <D.7099>; else goto <D.7100>;
        <D.7099>:
        D.7065 = &MEM[(void *)"hello1234567890world" + 2B];
        D.7066 = *D.7065;
        D.7067 = (int) D.7066;
        D.7101 = __s2 + 2;
        D.7102 = *D.7101;
        D.7103 = (int) D.7102;
        __result = D.7067 - D.7103;
        D.7104 = __s2_len > 2;
        D.7090 = __result == 0;
        D.7105 = D.7104 & D.7090;
        if (D.7105 != 0) goto <D.7106>; else goto <D.7107>;
        <D.7106>:
        D.7075 = &MEM[(void *)"hello1234567890world" + 3B];
        D.7076 = *D.7075;
        D.7077 = (int) D.7076;
        D.7108 = __s2 + 3;
        D.7109 = *D.7108;
        D.7110 = (int) D.7109;
        __result = D.7077 - D.7110;
        <D.7107>:
        <D.7100>:
        <D.7093>:
      }
      D.6577 = __result;
    }
    iftmp.10 = -D.6577;
    goto <D.7111>;
    <D.7086>:
    iftmp.10 = __builtin_strcmp (s, "hello1234567890world");
    <D.7111>:
    D.6578 = iftmp.10;
  }
  if (D.6578 != 0) goto <D.7112>; else goto <D.7113>;
  <D.7112>:
  D.6777 = FAILED ("11 Got wrong result, got: %s", s);
  return D.6777;
  <D.7113>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("1234567890", "hello12345678901234567890", "1234567890world", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 20;
    if (__s2_len <= 3) goto <D.7115>; else goto <D.7116>;
    <D.7115>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7045 = "hello1234567890world";
      D.7046 = MEM[(const unsigned char *)D.7045];
      D.7047 = (int) D.7046;
      D.7117 = *__s2;
      D.7118 = (int) D.7117;
      __result = D.7047 - D.7118;
      {
        D.7119 = __s2_len != 0;
        D.7120 = __result == 0;
        D.7121 = D.7119 & D.7120;
        if (D.7121 != 0) goto <D.7122>; else goto <D.7123>;
        <D.7122>:
        D.7055 = &MEM[(void *)"hello1234567890world" + 1B];
        D.7056 = *D.7055;
        D.7057 = (int) D.7056;
        D.7124 = __s2 + 1;
        D.7125 = *D.7124;
        D.7126 = (int) D.7125;
        __result = D.7057 - D.7126;
        D.7127 = __s2_len > 1;
        D.7120 = __result == 0;
        D.7128 = D.7127 & D.7120;
        if (D.7128 != 0) goto <D.7129>; else goto <D.7130>;
        <D.7129>:
        D.7065 = &MEM[(void *)"hello1234567890world" + 2B];
        D.7066 = *D.7065;
        D.7067 = (int) D.7066;
        D.7131 = __s2 + 2;
        D.7132 = *D.7131;
        D.7133 = (int) D.7132;
        __result = D.7067 - D.7133;
        D.7134 = __s2_len > 2;
        D.7120 = __result == 0;
        D.7135 = D.7134 & D.7120;
        if (D.7135 != 0) goto <D.7136>; else goto <D.7137>;
        <D.7136>:
        D.7075 = &MEM[(void *)"hello1234567890world" + 3B];
        D.7076 = *D.7075;
        D.7077 = (int) D.7076;
        D.7138 = __s2 + 3;
        D.7139 = *D.7138;
        D.7140 = (int) D.7139;
        __result = D.7077 - D.7140;
        <D.7137>:
        <D.7130>:
        <D.7123>:
      }
      D.6586 = __result;
    }
    iftmp.11 = -D.6586;
    goto <D.7141>;
    <D.7116>:
    iftmp.11 = __builtin_strcmp (s, "hello1234567890world");
    <D.7141>:
    D.6587 = iftmp.11;
  }
  if (D.6587 != 0) goto <D.7142>; else goto <D.7143>;
  <D.7142>:
  D.6777 = FAILED ("12 Got wrong result, got: %s", s);
  return D.6777;
  <D.7143>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("/", "a", "b", "c", "d", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.7145>; else goto <D.7146>;
    <D.7145>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7147 = "a/b/c/d";
      D.7148 = MEM[(const unsigned char *)D.7147];
      D.7149 = (int) D.7148;
      D.7150 = *__s2;
      D.7151 = (int) D.7150;
      __result = D.7149 - D.7151;
      {
        D.7152 = __s2_len != 0;
        D.7153 = __result == 0;
        D.7154 = D.7152 & D.7153;
        if (D.7154 != 0) goto <D.7155>; else goto <D.7156>;
        <D.7155>:
        D.7157 = &MEM[(void *)"a/b/c/d" + 1B];
        D.7158 = *D.7157;
        D.7159 = (int) D.7158;
        D.7160 = __s2 + 1;
        D.7161 = *D.7160;
        D.7162 = (int) D.7161;
        __result = D.7159 - D.7162;
        D.7163 = __s2_len > 1;
        D.7153 = __result == 0;
        D.7164 = D.7163 & D.7153;
        if (D.7164 != 0) goto <D.7165>; else goto <D.7166>;
        <D.7165>:
        D.7167 = &MEM[(void *)"a/b/c/d" + 2B];
        D.7168 = *D.7167;
        D.7169 = (int) D.7168;
        D.7170 = __s2 + 2;
        D.7171 = *D.7170;
        D.7172 = (int) D.7171;
        __result = D.7169 - D.7172;
        D.7173 = __s2_len > 2;
        D.7153 = __result == 0;
        D.7174 = D.7173 & D.7153;
        if (D.7174 != 0) goto <D.7175>; else goto <D.7176>;
        <D.7175>:
        D.7177 = &MEM[(void *)"a/b/c/d" + 3B];
        D.7178 = *D.7177;
        D.7179 = (int) D.7178;
        D.7180 = __s2 + 3;
        D.7181 = *D.7180;
        D.7182 = (int) D.7181;
        __result = D.7179 - D.7182;
        <D.7176>:
        <D.7166>:
        <D.7156>:
      }
      D.6595 = __result;
    }
    iftmp.12 = -D.6595;
    goto <D.7183>;
    <D.7146>:
    iftmp.12 = __builtin_strcmp (s, "a/b/c/d");
    <D.7183>:
    D.6596 = iftmp.12;
  }
  if (D.6596 != 0) goto <D.7184>; else goto <D.7185>;
  <D.7184>:
  D.6777 = FAILED ("13 Got wrong result, got: %s", s);
  return D.6777;
  <D.7185>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("/", "/a", "", "/c/", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.7187>; else goto <D.7188>;
    <D.7187>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7189 = "/a/c/";
      D.7190 = MEM[(const unsigned char *)D.7189];
      D.7191 = (int) D.7190;
      D.7192 = *__s2;
      D.7193 = (int) D.7192;
      __result = D.7191 - D.7193;
      {
        D.7194 = __s2_len != 0;
        D.7195 = __result == 0;
        D.7196 = D.7194 & D.7195;
        if (D.7196 != 0) goto <D.7197>; else goto <D.7198>;
        <D.7197>:
        D.7199 = &MEM[(void *)"/a/c/" + 1B];
        D.7200 = *D.7199;
        D.7201 = (int) D.7200;
        D.7202 = __s2 + 1;
        D.7203 = *D.7202;
        D.7204 = (int) D.7203;
        __result = D.7201 - D.7204;
        D.7205 = __s2_len > 1;
        D.7195 = __result == 0;
        D.7206 = D.7205 & D.7195;
        if (D.7206 != 0) goto <D.7207>; else goto <D.7208>;
        <D.7207>:
        D.7209 = &MEM[(void *)"/a/c/" + 2B];
        D.7210 = *D.7209;
        D.7211 = (int) D.7210;
        D.7212 = __s2 + 2;
        D.7213 = *D.7212;
        D.7214 = (int) D.7213;
        __result = D.7211 - D.7214;
        D.7215 = __s2_len > 2;
        D.7195 = __result == 0;
        D.7216 = D.7215 & D.7195;
        if (D.7216 != 0) goto <D.7217>; else goto <D.7218>;
        <D.7217>:
        D.7219 = &MEM[(void *)"/a/c/" + 3B];
        D.7220 = *D.7219;
        D.7221 = (int) D.7220;
        D.7222 = __s2 + 3;
        D.7223 = *D.7222;
        D.7224 = (int) D.7223;
        __result = D.7221 - D.7224;
        <D.7218>:
        <D.7208>:
        <D.7198>:
      }
      D.6604 = __result;
    }
    iftmp.13 = -D.6604;
    goto <D.7225>;
    <D.7188>:
    iftmp.13 = __builtin_strcmp (s, "/a/c/");
    <D.7225>:
    D.6605 = iftmp.13;
  }
  if (D.6605 != 0) goto <D.7226>; else goto <D.7227>;
  <D.7226>:
  D.6777 = FAILED ("14 Got wrong result, got: %s", s);
  return D.6777;
  <D.7227>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("/", 0B, 0B);
  if (s == 0B) goto <D.7228>; else goto <D.7229>;
  <D.7228>:
  D.6777 = FAILED ("must get a non-NULL return");
  return D.6777;
  <D.7229>:
  D.7230 = *s;
  if (D.7230 != 0) goto <D.7231>; else goto <D.7232>;
  <D.7231>:
  D.6777 = FAILED ("must get an empty string");
  return D.6777;
  <D.7232>:
  dir = "//";
  dir = dir + 1;
  s = monoeg_g_build_path ("/", dir, buffer, 0B);
  D.7230 = *s;
  if (D.7230 != 47) goto <D.7233>; else goto <D.7234>;
  <D.7233>:
  D.6777 = FAILED ("Must have a \'/\' at the start");
  return D.6777;
  <D.7234>:
  monoeg_g_free (s);
  D.6777 = 0B;
  return D.6777;
}


test_buildfname ()
{
  int D.6617;
  int iftmp.14;
  int D.6616;
  char[8] * D.7239;
  unsigned char D.7240;
  int D.7241;
  unsigned char D.7242;
  int D.7243;
  _Bool D.7244;
  _Bool D.7245;
  _Bool D.7246;
  const unsigned char * D.7249;
  unsigned char D.7250;
  int D.7251;
  const unsigned char * D.7252;
  unsigned char D.7253;
  int D.7254;
  _Bool D.7255;
  _Bool D.7256;
  const unsigned char * D.7259;
  unsigned char D.7260;
  int D.7261;
  const unsigned char * D.7262;
  unsigned char D.7263;
  int D.7264;
  _Bool D.7265;
  _Bool D.7266;
  const unsigned char * D.7269;
  unsigned char D.7270;
  int D.7271;
  const unsigned char * D.7272;
  unsigned char D.7273;
  int D.7274;
  gchar * D.7278;
  int D.6626;
  int iftmp.15;
  int D.6625;
  char[3] * D.7282;
  unsigned char D.7283;
  int D.7284;
  unsigned char D.7285;
  int D.7286;
  _Bool D.7287;
  _Bool D.7288;
  _Bool D.7289;
  const unsigned char * D.7292;
  unsigned char D.7293;
  int D.7294;
  const unsigned char * D.7295;
  unsigned char D.7296;
  int D.7297;
  _Bool D.7298;
  _Bool D.7299;
  const unsigned char * D.7302;
  unsigned char D.7303;
  int D.7304;
  const unsigned char * D.7305;
  unsigned char D.7306;
  int D.7307;
  _Bool D.7308;
  _Bool D.7309;
  const unsigned char * D.7312;
  unsigned char D.7313;
  int D.7314;
  const unsigned char * D.7315;
  unsigned char D.7316;
  int D.7317;
  int D.6635;
  int iftmp.16;
  int D.6634;
  char[19] * D.7324;
  unsigned char D.7325;
  int D.7326;
  unsigned char D.7327;
  int D.7328;
  _Bool D.7329;
  _Bool D.7330;
  _Bool D.7331;
  const unsigned char * D.7334;
  unsigned char D.7335;
  int D.7336;
  const unsigned char * D.7337;
  unsigned char D.7338;
  int D.7339;
  _Bool D.7340;
  _Bool D.7341;
  const unsigned char * D.7344;
  unsigned char D.7345;
  int D.7346;
  const unsigned char * D.7347;
  unsigned char D.7348;
  int D.7349;
  _Bool D.7350;
  _Bool D.7351;
  const unsigned char * D.7354;
  unsigned char D.7355;
  int D.7356;
  const unsigned char * D.7357;
  unsigned char D.7358;
  int D.7359;
  char * s;

  s = monoeg_g_build_path ("/", "a", "b", "c", "d", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.7237>; else goto <D.7238>;
    <D.7237>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7239 = "a/b/c/d";
      D.7240 = MEM[(const unsigned char *)D.7239];
      D.7241 = (int) D.7240;
      D.7242 = *__s2;
      D.7243 = (int) D.7242;
      __result = D.7241 - D.7243;
      {
        D.7244 = __s2_len != 0;
        D.7245 = __result == 0;
        D.7246 = D.7244 & D.7245;
        if (D.7246 != 0) goto <D.7247>; else goto <D.7248>;
        <D.7247>:
        D.7249 = &MEM[(void *)"a/b/c/d" + 1B];
        D.7250 = *D.7249;
        D.7251 = (int) D.7250;
        D.7252 = __s2 + 1;
        D.7253 = *D.7252;
        D.7254 = (int) D.7253;
        __result = D.7251 - D.7254;
        D.7255 = __s2_len > 1;
        D.7245 = __result == 0;
        D.7256 = D.7255 & D.7245;
        if (D.7256 != 0) goto <D.7257>; else goto <D.7258>;
        <D.7257>:
        D.7259 = &MEM[(void *)"a/b/c/d" + 2B];
        D.7260 = *D.7259;
        D.7261 = (int) D.7260;
        D.7262 = __s2 + 2;
        D.7263 = *D.7262;
        D.7264 = (int) D.7263;
        __result = D.7261 - D.7264;
        D.7265 = __s2_len > 2;
        D.7245 = __result == 0;
        D.7266 = D.7265 & D.7245;
        if (D.7266 != 0) goto <D.7267>; else goto <D.7268>;
        <D.7267>:
        D.7269 = &MEM[(void *)"a/b/c/d" + 3B];
        D.7270 = *D.7269;
        D.7271 = (int) D.7270;
        D.7272 = __s2 + 3;
        D.7273 = *D.7272;
        D.7274 = (int) D.7273;
        __result = D.7271 - D.7274;
        <D.7268>:
        <D.7258>:
        <D.7248>:
      }
      D.6616 = __result;
    }
    iftmp.14 = -D.6616;
    goto <D.7275>;
    <D.7238>:
    iftmp.14 = __builtin_strcmp (s, "a/b/c/d");
    <D.7275>:
    D.6617 = iftmp.14;
  }
  if (D.6617 != 0) goto <D.7276>; else goto <D.7277>;
  <D.7276>:
  D.7278 = FAILED ("1 Got wrong result, got: %s", s);
  return D.7278;
  <D.7277>:
  monoeg_g_free (s);
  s = monoeg_g_build_path ("/", "/", "a", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 2;
    if (__s2_len <= 3) goto <D.7280>; else goto <D.7281>;
    <D.7280>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7282 = "/a";
      D.7283 = MEM[(const unsigned char *)D.7282];
      D.7284 = (int) D.7283;
      D.7285 = *__s2;
      D.7286 = (int) D.7285;
      __result = D.7284 - D.7286;
      {
        D.7287 = __s2_len != 0;
        D.7288 = __result == 0;
        D.7289 = D.7287 & D.7288;
        if (D.7289 != 0) goto <D.7290>; else goto <D.7291>;
        <D.7290>:
        D.7292 = &MEM[(void *)"/a" + 1B];
        D.7293 = *D.7292;
        D.7294 = (int) D.7293;
        D.7295 = __s2 + 1;
        D.7296 = *D.7295;
        D.7297 = (int) D.7296;
        __result = D.7294 - D.7297;
        D.7298 = __s2_len > 1;
        D.7288 = __result == 0;
        D.7299 = D.7298 & D.7288;
        if (D.7299 != 0) goto <D.7300>; else goto <D.7301>;
        <D.7300>:
        D.7302 = &MEM[(void *)"/a" + 2B];
        D.7303 = *D.7302;
        D.7304 = (int) D.7303;
        D.7305 = __s2 + 2;
        D.7306 = *D.7305;
        D.7307 = (int) D.7306;
        __result = D.7304 - D.7307;
        D.7308 = __s2_len > 2;
        D.7288 = __result == 0;
        D.7309 = D.7308 & D.7288;
        if (D.7309 != 0) goto <D.7310>; else goto <D.7311>;
        <D.7310>:
        D.7312 = &MEM[(void *)"/a" + 3B];
        D.7313 = *D.7312;
        D.7314 = (int) D.7313;
        D.7315 = __s2 + 3;
        D.7316 = *D.7315;
        D.7317 = (int) D.7316;
        __result = D.7314 - D.7317;
        <D.7311>:
        <D.7301>:
        <D.7291>:
      }
      D.6625 = __result;
    }
    iftmp.15 = -D.6625;
    goto <D.7318>;
    <D.7281>:
    iftmp.15 = __builtin_strcmp (s, "/a");
    <D.7318>:
    D.6626 = iftmp.15;
  }
  if (D.6626 != 0) goto <D.7319>; else goto <D.7320>;
  <D.7319>:
  D.7278 = FAILED ("1 Got wrong result, got: %s", s);
  return D.7278;
  <D.7320>:
  s = monoeg_g_build_path ("/", "/", "foo", "/bar", "tolo/", "/meo/", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 18;
    if (__s2_len <= 3) goto <D.7322>; else goto <D.7323>;
    <D.7322>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7324 = "/foo/bar/tolo/meo/";
      D.7325 = MEM[(const unsigned char *)D.7324];
      D.7326 = (int) D.7325;
      D.7327 = *__s2;
      D.7328 = (int) D.7327;
      __result = D.7326 - D.7328;
      {
        D.7329 = __s2_len != 0;
        D.7330 = __result == 0;
        D.7331 = D.7329 & D.7330;
        if (D.7331 != 0) goto <D.7332>; else goto <D.7333>;
        <D.7332>:
        D.7334 = &MEM[(void *)"/foo/bar/tolo/meo/" + 1B];
        D.7335 = *D.7334;
        D.7336 = (int) D.7335;
        D.7337 = __s2 + 1;
        D.7338 = *D.7337;
        D.7339 = (int) D.7338;
        __result = D.7336 - D.7339;
        D.7340 = __s2_len > 1;
        D.7330 = __result == 0;
        D.7341 = D.7340 & D.7330;
        if (D.7341 != 0) goto <D.7342>; else goto <D.7343>;
        <D.7342>:
        D.7344 = &MEM[(void *)"/foo/bar/tolo/meo/" + 2B];
        D.7345 = *D.7344;
        D.7346 = (int) D.7345;
        D.7347 = __s2 + 2;
        D.7348 = *D.7347;
        D.7349 = (int) D.7348;
        __result = D.7346 - D.7349;
        D.7350 = __s2_len > 2;
        D.7330 = __result == 0;
        D.7351 = D.7350 & D.7330;
        if (D.7351 != 0) goto <D.7352>; else goto <D.7353>;
        <D.7352>:
        D.7354 = &MEM[(void *)"/foo/bar/tolo/meo/" + 3B];
        D.7355 = *D.7354;
        D.7356 = (int) D.7355;
        D.7357 = __s2 + 3;
        D.7358 = *D.7357;
        D.7359 = (int) D.7358;
        __result = D.7356 - D.7359;
        <D.7353>:
        <D.7343>:
        <D.7333>:
      }
      D.6634 = __result;
    }
    iftmp.16 = -D.6634;
    goto <D.7360>;
    <D.7323>:
    iftmp.16 = __builtin_strcmp (s, "/foo/bar/tolo/meo/");
    <D.7360>:
    D.6635 = iftmp.16;
  }
  if (D.6635 != 0) goto <D.7361>; else goto <D.7362>;
  <D.7361>:
  D.7278 = FAILED ("1 Got wrong result, got: %s", s);
  return D.7278;
  <D.7362>:
  D.7278 = 0B;
  return D.7278;
}


test_dirname ()
{
  int D.6647;
  int iftmp.17;
  int D.6646;
  char[6] * D.7367;
  unsigned char D.7368;
  int D.7369;
  unsigned char D.7370;
  int D.7371;
  _Bool D.7372;
  _Bool D.7373;
  _Bool D.7374;
  const unsigned char * D.7377;
  unsigned char D.7378;
  int D.7379;
  const unsigned char * D.7380;
  unsigned char D.7381;
  int D.7382;
  _Bool D.7383;
  _Bool D.7384;
  const unsigned char * D.7387;
  unsigned char D.7388;
  int D.7389;
  const unsigned char * D.7390;
  unsigned char D.7391;
  int D.7392;
  _Bool D.7393;
  _Bool D.7394;
  const unsigned char * D.7397;
  unsigned char D.7398;
  int D.7399;
  const unsigned char * D.7400;
  unsigned char D.7401;
  int D.7402;
  char * D.7406;
  int D.6656;
  int iftmp.18;
  int D.6655;
  char[13] * D.7410;
  unsigned char D.7411;
  int D.7412;
  unsigned char D.7413;
  int D.7414;
  _Bool D.7415;
  _Bool D.7416;
  _Bool D.7417;
  const unsigned char * D.7420;
  unsigned char D.7421;
  int D.7422;
  const unsigned char * D.7423;
  unsigned char D.7424;
  int D.7425;
  _Bool D.7426;
  _Bool D.7427;
  const unsigned char * D.7430;
  unsigned char D.7431;
  int D.7432;
  const unsigned char * D.7433;
  unsigned char D.7434;
  int D.7435;
  _Bool D.7436;
  _Bool D.7437;
  const unsigned char * D.7440;
  unsigned char D.7441;
  int D.7442;
  const unsigned char * D.7443;
  unsigned char D.7444;
  int D.7445;
  int D.6665;
  int iftmp.19;
  int D.6664;
  char[2] * D.7452;
  unsigned char D.7453;
  int D.7454;
  unsigned char D.7455;
  int D.7456;
  _Bool D.7457;
  _Bool D.7458;
  _Bool D.7459;
  const unsigned char * D.7462;
  unsigned char D.7463;
  int D.7464;
  const unsigned char * D.7465;
  unsigned char D.7466;
  int D.7467;
  _Bool D.7468;
  _Bool D.7469;
  const unsigned char * D.7472;
  unsigned char D.7473;
  int D.7474;
  const unsigned char * D.7475;
  unsigned char D.7476;
  int D.7477;
  _Bool D.7478;
  _Bool D.7479;
  const unsigned char * D.7482;
  unsigned char D.7483;
  int D.7484;
  const unsigned char * D.7485;
  unsigned char D.7486;
  int D.7487;
  int D.6674;
  int iftmp.20;
  int D.6673;
  char[2] * D.7494;
  unsigned char D.7495;
  int D.7496;
  unsigned char D.7497;
  int D.7498;
  _Bool D.7499;
  _Bool D.7500;
  _Bool D.7501;
  const unsigned char * D.7504;
  unsigned char D.7505;
  int D.7506;
  const unsigned char * D.7507;
  unsigned char D.7508;
  int D.7509;
  _Bool D.7510;
  _Bool D.7511;
  const unsigned char * D.7514;
  unsigned char D.7515;
  int D.7516;
  const unsigned char * D.7517;
  unsigned char D.7518;
  int D.7519;
  _Bool D.7520;
  _Bool D.7521;
  const unsigned char * D.7524;
  unsigned char D.7525;
  int D.7526;
  const unsigned char * D.7527;
  unsigned char D.7528;
  int D.7529;
  char * s;

  s = monoeg_g_path_get_dirname ("/home/miguel");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.7365>; else goto <D.7366>;
    <D.7365>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7367 = "/home";
      D.7368 = MEM[(const unsigned char *)D.7367];
      D.7369 = (int) D.7368;
      D.7370 = *__s2;
      D.7371 = (int) D.7370;
      __result = D.7369 - D.7371;
      {
        D.7372 = __s2_len != 0;
        D.7373 = __result == 0;
        D.7374 = D.7372 & D.7373;
        if (D.7374 != 0) goto <D.7375>; else goto <D.7376>;
        <D.7375>:
        D.7377 = &MEM[(void *)"/home" + 1B];
        D.7378 = *D.7377;
        D.7379 = (int) D.7378;
        D.7380 = __s2 + 1;
        D.7381 = *D.7380;
        D.7382 = (int) D.7381;
        __result = D.7379 - D.7382;
        D.7383 = __s2_len > 1;
        D.7373 = __result == 0;
        D.7384 = D.7383 & D.7373;
        if (D.7384 != 0) goto <D.7385>; else goto <D.7386>;
        <D.7385>:
        D.7387 = &MEM[(void *)"/home" + 2B];
        D.7388 = *D.7387;
        D.7389 = (int) D.7388;
        D.7390 = __s2 + 2;
        D.7391 = *D.7390;
        D.7392 = (int) D.7391;
        __result = D.7389 - D.7392;
        D.7393 = __s2_len > 2;
        D.7373 = __result == 0;
        D.7394 = D.7393 & D.7373;
        if (D.7394 != 0) goto <D.7395>; else goto <D.7396>;
        <D.7395>:
        D.7397 = &MEM[(void *)"/home" + 3B];
        D.7398 = *D.7397;
        D.7399 = (int) D.7398;
        D.7400 = __s2 + 3;
        D.7401 = *D.7400;
        D.7402 = (int) D.7401;
        __result = D.7399 - D.7402;
        <D.7396>:
        <D.7386>:
        <D.7376>:
      }
      D.6646 = __result;
    }
    iftmp.17 = -D.6646;
    goto <D.7403>;
    <D.7366>:
    iftmp.17 = __builtin_strcmp (s, "/home");
    <D.7403>:
    D.6647 = iftmp.17;
  }
  if (D.6647 != 0) goto <D.7404>; else goto <D.7405>;
  <D.7404>:
  D.7406 = FAILED ("Expected /home, got %s", s);
  return D.7406;
  <D.7405>:
  monoeg_g_free (s);
  s = monoeg_g_path_get_dirname ("/home/dingus/");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 12;
    if (__s2_len <= 3) goto <D.7408>; else goto <D.7409>;
    <D.7408>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7410 = "/home/dingus";
      D.7411 = MEM[(const unsigned char *)D.7410];
      D.7412 = (int) D.7411;
      D.7413 = *__s2;
      D.7414 = (int) D.7413;
      __result = D.7412 - D.7414;
      {
        D.7415 = __s2_len != 0;
        D.7416 = __result == 0;
        D.7417 = D.7415 & D.7416;
        if (D.7417 != 0) goto <D.7418>; else goto <D.7419>;
        <D.7418>:
        D.7420 = &MEM[(void *)"/home/dingus" + 1B];
        D.7421 = *D.7420;
        D.7422 = (int) D.7421;
        D.7423 = __s2 + 1;
        D.7424 = *D.7423;
        D.7425 = (int) D.7424;
        __result = D.7422 - D.7425;
        D.7426 = __s2_len > 1;
        D.7416 = __result == 0;
        D.7427 = D.7426 & D.7416;
        if (D.7427 != 0) goto <D.7428>; else goto <D.7429>;
        <D.7428>:
        D.7430 = &MEM[(void *)"/home/dingus" + 2B];
        D.7431 = *D.7430;
        D.7432 = (int) D.7431;
        D.7433 = __s2 + 2;
        D.7434 = *D.7433;
        D.7435 = (int) D.7434;
        __result = D.7432 - D.7435;
        D.7436 = __s2_len > 2;
        D.7416 = __result == 0;
        D.7437 = D.7436 & D.7416;
        if (D.7437 != 0) goto <D.7438>; else goto <D.7439>;
        <D.7438>:
        D.7440 = &MEM[(void *)"/home/dingus" + 3B];
        D.7441 = *D.7440;
        D.7442 = (int) D.7441;
        D.7443 = __s2 + 3;
        D.7444 = *D.7443;
        D.7445 = (int) D.7444;
        __result = D.7442 - D.7445;
        <D.7439>:
        <D.7429>:
        <D.7419>:
      }
      D.6655 = __result;
    }
    iftmp.18 = -D.6655;
    goto <D.7446>;
    <D.7409>:
    iftmp.18 = __builtin_strcmp (s, "/home/dingus");
    <D.7446>:
    D.6656 = iftmp.18;
  }
  if (D.6656 != 0) goto <D.7447>; else goto <D.7448>;
  <D.7447>:
  D.7406 = FAILED ("Expected /home/dingus, got %s", s);
  return D.7406;
  <D.7448>:
  monoeg_g_free (s);
  s = monoeg_g_path_get_dirname ("dir.c");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.7450>; else goto <D.7451>;
    <D.7450>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7452 = ".";
      D.7453 = MEM[(const unsigned char *)D.7452];
      D.7454 = (int) D.7453;
      D.7455 = *__s2;
      D.7456 = (int) D.7455;
      __result = D.7454 - D.7456;
      {
        D.7457 = __s2_len != 0;
        D.7458 = __result == 0;
        D.7459 = D.7457 & D.7458;
        if (D.7459 != 0) goto <D.7460>; else goto <D.7461>;
        <D.7460>:
        D.7462 = &MEM[(void *)"." + 1B];
        D.7463 = *D.7462;
        D.7464 = (int) D.7463;
        D.7465 = __s2 + 1;
        D.7466 = *D.7465;
        D.7467 = (int) D.7466;
        __result = D.7464 - D.7467;
        D.7468 = __s2_len > 1;
        D.7458 = __result == 0;
        D.7469 = D.7468 & D.7458;
        if (D.7469 != 0) goto <D.7470>; else goto <D.7471>;
        <D.7470>:
        D.7472 = &MEM[(void *)"." + 2B];
        D.7473 = *D.7472;
        D.7474 = (int) D.7473;
        D.7475 = __s2 + 2;
        D.7476 = *D.7475;
        D.7477 = (int) D.7476;
        __result = D.7474 - D.7477;
        D.7478 = __s2_len > 2;
        D.7458 = __result == 0;
        D.7479 = D.7478 & D.7458;
        if (D.7479 != 0) goto <D.7480>; else goto <D.7481>;
        <D.7480>:
        D.7482 = &MEM[(void *)"." + 3B];
        D.7483 = *D.7482;
        D.7484 = (int) D.7483;
        D.7485 = __s2 + 3;
        D.7486 = *D.7485;
        D.7487 = (int) D.7486;
        __result = D.7484 - D.7487;
        <D.7481>:
        <D.7471>:
        <D.7461>:
      }
      D.6664 = __result;
    }
    iftmp.19 = -D.6664;
    goto <D.7488>;
    <D.7451>:
    iftmp.19 = __builtin_strcmp (s, ".");
    <D.7488>:
    D.6665 = iftmp.19;
  }
  if (D.6665 != 0) goto <D.7489>; else goto <D.7490>;
  <D.7489>:
  D.7406 = FAILED ("Expected `.\', got %s", s);
  return D.7406;
  <D.7490>:
  monoeg_g_free (s);
  s = monoeg_g_path_get_dirname ("/index.html");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.7492>; else goto <D.7493>;
    <D.7492>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7494 = "/";
      D.7495 = MEM[(const unsigned char *)D.7494];
      D.7496 = (int) D.7495;
      D.7497 = *__s2;
      D.7498 = (int) D.7497;
      __result = D.7496 - D.7498;
      {
        D.7499 = __s2_len != 0;
        D.7500 = __result == 0;
        D.7501 = D.7499 & D.7500;
        if (D.7501 != 0) goto <D.7502>; else goto <D.7503>;
        <D.7502>:
        D.7504 = &MEM[(void *)"/" + 1B];
        D.7505 = *D.7504;
        D.7506 = (int) D.7505;
        D.7507 = __s2 + 1;
        D.7508 = *D.7507;
        D.7509 = (int) D.7508;
        __result = D.7506 - D.7509;
        D.7510 = __s2_len > 1;
        D.7500 = __result == 0;
        D.7511 = D.7510 & D.7500;
        if (D.7511 != 0) goto <D.7512>; else goto <D.7513>;
        <D.7512>:
        D.7514 = &MEM[(void *)"/" + 2B];
        D.7515 = *D.7514;
        D.7516 = (int) D.7515;
        D.7517 = __s2 + 2;
        D.7518 = *D.7517;
        D.7519 = (int) D.7518;
        __result = D.7516 - D.7519;
        D.7520 = __s2_len > 2;
        D.7500 = __result == 0;
        D.7521 = D.7520 & D.7500;
        if (D.7521 != 0) goto <D.7522>; else goto <D.7523>;
        <D.7522>:
        D.7524 = &MEM[(void *)"/" + 3B];
        D.7525 = *D.7524;
        D.7526 = (int) D.7525;
        D.7527 = __s2 + 3;
        D.7528 = *D.7527;
        D.7529 = (int) D.7528;
        __result = D.7526 - D.7529;
        <D.7523>:
        <D.7513>:
        <D.7503>:
      }
      D.6673 = __result;
    }
    iftmp.20 = -D.6673;
    goto <D.7530>;
    <D.7493>:
    iftmp.20 = __builtin_strcmp (s, "/");
    <D.7530>:
    D.6674 = iftmp.20;
  }
  if (D.6674 != 0) goto <D.7531>; else goto <D.7532>;
  <D.7531>:
  D.7406 = FAILED ("Expected [/], got [%s]", s);
  return D.7406;
  <D.7532>:
  D.7406 = 0B;
  return D.7406;
}


test_basename ()
{
  int D.6686;
  int iftmp.21;
  int D.6685;
  char[2] * D.7537;
  unsigned char D.7538;
  int D.7539;
  unsigned char D.7540;
  int D.7541;
  _Bool D.7542;
  _Bool D.7543;
  _Bool D.7544;
  const unsigned char * D.7547;
  unsigned char D.7548;
  int D.7549;
  const unsigned char * D.7550;
  unsigned char D.7551;
  int D.7552;
  _Bool D.7553;
  _Bool D.7554;
  const unsigned char * D.7557;
  unsigned char D.7558;
  int D.7559;
  const unsigned char * D.7560;
  unsigned char D.7561;
  int D.7562;
  _Bool D.7563;
  _Bool D.7564;
  const unsigned char * D.7567;
  unsigned char D.7568;
  int D.7569;
  const unsigned char * D.7570;
  unsigned char D.7571;
  int D.7572;
  char * D.7576;
  int D.6695;
  int iftmp.22;
  int D.6694;
  char[7] * D.7580;
  unsigned char D.7581;
  int D.7582;
  unsigned char D.7583;
  int D.7584;
  _Bool D.7585;
  _Bool D.7586;
  _Bool D.7587;
  const unsigned char * D.7590;
  unsigned char D.7591;
  int D.7592;
  const unsigned char * D.7593;
  unsigned char D.7594;
  int D.7595;
  _Bool D.7596;
  _Bool D.7597;
  const unsigned char * D.7600;
  unsigned char D.7601;
  int D.7602;
  const unsigned char * D.7603;
  unsigned char D.7604;
  int D.7605;
  _Bool D.7606;
  _Bool D.7607;
  const unsigned char * D.7610;
  unsigned char D.7611;
  int D.7612;
  const unsigned char * D.7613;
  unsigned char D.7614;
  int D.7615;
  int D.6704;
  int iftmp.23;
  int D.6703;
  unsigned char D.7622;
  int D.7623;
  _Bool D.7624;
  _Bool D.7625;
  _Bool D.7626;
  const unsigned char * D.7629;
  unsigned char D.7630;
  int D.7631;
  _Bool D.7632;
  _Bool D.7633;
  const unsigned char * D.7636;
  unsigned char D.7637;
  int D.7638;
  _Bool D.7639;
  _Bool D.7640;
  const unsigned char * D.7643;
  unsigned char D.7644;
  int D.7645;
  char * s;

  s = monoeg_g_path_get_basename ("");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.7535>; else goto <D.7536>;
    <D.7535>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7537 = ".";
      D.7538 = MEM[(const unsigned char *)D.7537];
      D.7539 = (int) D.7538;
      D.7540 = *__s2;
      D.7541 = (int) D.7540;
      __result = D.7539 - D.7541;
      {
        D.7542 = __s2_len != 0;
        D.7543 = __result == 0;
        D.7544 = D.7542 & D.7543;
        if (D.7544 != 0) goto <D.7545>; else goto <D.7546>;
        <D.7545>:
        D.7547 = &MEM[(void *)"." + 1B];
        D.7548 = *D.7547;
        D.7549 = (int) D.7548;
        D.7550 = __s2 + 1;
        D.7551 = *D.7550;
        D.7552 = (int) D.7551;
        __result = D.7549 - D.7552;
        D.7553 = __s2_len > 1;
        D.7543 = __result == 0;
        D.7554 = D.7553 & D.7543;
        if (D.7554 != 0) goto <D.7555>; else goto <D.7556>;
        <D.7555>:
        D.7557 = &MEM[(void *)"." + 2B];
        D.7558 = *D.7557;
        D.7559 = (int) D.7558;
        D.7560 = __s2 + 2;
        D.7561 = *D.7560;
        D.7562 = (int) D.7561;
        __result = D.7559 - D.7562;
        D.7563 = __s2_len > 2;
        D.7543 = __result == 0;
        D.7564 = D.7563 & D.7543;
        if (D.7564 != 0) goto <D.7565>; else goto <D.7566>;
        <D.7565>:
        D.7567 = &MEM[(void *)"." + 3B];
        D.7568 = *D.7567;
        D.7569 = (int) D.7568;
        D.7570 = __s2 + 3;
        D.7571 = *D.7570;
        D.7572 = (int) D.7571;
        __result = D.7569 - D.7572;
        <D.7566>:
        <D.7556>:
        <D.7546>:
      }
      D.6685 = __result;
    }
    iftmp.21 = -D.6685;
    goto <D.7573>;
    <D.7536>:
    iftmp.21 = __builtin_strcmp (s, ".");
    <D.7573>:
    D.6686 = iftmp.21;
  }
  if (D.6686 != 0) goto <D.7574>; else goto <D.7575>;
  <D.7574>:
  D.7576 = FAILED ("Expected `.\', got %s", s);
  return D.7576;
  <D.7575>:
  monoeg_g_free (s);
  s = monoeg_g_path_get_basename ("/home/dingus/");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.7578>; else goto <D.7579>;
    <D.7578>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7580 = "dingus";
      D.7581 = MEM[(const unsigned char *)D.7580];
      D.7582 = (int) D.7581;
      D.7583 = *__s2;
      D.7584 = (int) D.7583;
      __result = D.7582 - D.7584;
      {
        D.7585 = __s2_len != 0;
        D.7586 = __result == 0;
        D.7587 = D.7585 & D.7586;
        if (D.7587 != 0) goto <D.7588>; else goto <D.7589>;
        <D.7588>:
        D.7590 = &MEM[(void *)"dingus" + 1B];
        D.7591 = *D.7590;
        D.7592 = (int) D.7591;
        D.7593 = __s2 + 1;
        D.7594 = *D.7593;
        D.7595 = (int) D.7594;
        __result = D.7592 - D.7595;
        D.7596 = __s2_len > 1;
        D.7586 = __result == 0;
        D.7597 = D.7596 & D.7586;
        if (D.7597 != 0) goto <D.7598>; else goto <D.7599>;
        <D.7598>:
        D.7600 = &MEM[(void *)"dingus" + 2B];
        D.7601 = *D.7600;
        D.7602 = (int) D.7601;
        D.7603 = __s2 + 2;
        D.7604 = *D.7603;
        D.7605 = (int) D.7604;
        __result = D.7602 - D.7605;
        D.7606 = __s2_len > 2;
        D.7586 = __result == 0;
        D.7607 = D.7606 & D.7586;
        if (D.7607 != 0) goto <D.7608>; else goto <D.7609>;
        <D.7608>:
        D.7610 = &MEM[(void *)"dingus" + 3B];
        D.7611 = *D.7610;
        D.7612 = (int) D.7611;
        D.7613 = __s2 + 3;
        D.7614 = *D.7613;
        D.7615 = (int) D.7614;
        __result = D.7612 - D.7615;
        <D.7609>:
        <D.7599>:
        <D.7589>:
      }
      D.6694 = __result;
    }
    iftmp.22 = -D.6694;
    goto <D.7616>;
    <D.7579>:
    iftmp.22 = __builtin_strcmp (s, "dingus");
    <D.7616>:
    D.6695 = iftmp.22;
  }
  if (D.6695 != 0) goto <D.7617>; else goto <D.7618>;
  <D.7617>:
  D.7576 = FAILED ("1 Expected dingus, got %s", s);
  return D.7576;
  <D.7618>:
  monoeg_g_free (s);
  s = monoeg_g_path_get_basename ("/home/dingus");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.7620>; else goto <D.7621>;
    <D.7620>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7580 = "dingus";
      D.7581 = MEM[(const unsigned char *)D.7580];
      D.7582 = (int) D.7581;
      D.7622 = *__s2;
      D.7623 = (int) D.7622;
      __result = D.7582 - D.7623;
      {
        D.7624 = __s2_len != 0;
        D.7625 = __result == 0;
        D.7626 = D.7624 & D.7625;
        if (D.7626 != 0) goto <D.7627>; else goto <D.7628>;
        <D.7627>:
        D.7590 = &MEM[(void *)"dingus" + 1B];
        D.7591 = *D.7590;
        D.7592 = (int) D.7591;
        D.7629 = __s2 + 1;
        D.7630 = *D.7629;
        D.7631 = (int) D.7630;
        __result = D.7592 - D.7631;
        D.7632 = __s2_len > 1;
        D.7625 = __result == 0;
        D.7633 = D.7632 & D.7625;
        if (D.7633 != 0) goto <D.7634>; else goto <D.7635>;
        <D.7634>:
        D.7600 = &MEM[(void *)"dingus" + 2B];
        D.7601 = *D.7600;
        D.7602 = (int) D.7601;
        D.7636 = __s2 + 2;
        D.7637 = *D.7636;
        D.7638 = (int) D.7637;
        __result = D.7602 - D.7638;
        D.7639 = __s2_len > 2;
        D.7625 = __result == 0;
        D.7640 = D.7639 & D.7625;
        if (D.7640 != 0) goto <D.7641>; else goto <D.7642>;
        <D.7641>:
        D.7610 = &MEM[(void *)"dingus" + 3B];
        D.7611 = *D.7610;
        D.7612 = (int) D.7611;
        D.7643 = __s2 + 3;
        D.7644 = *D.7643;
        D.7645 = (int) D.7644;
        __result = D.7612 - D.7645;
        <D.7642>:
        <D.7635>:
        <D.7628>:
      }
      D.6703 = __result;
    }
    iftmp.23 = -D.6703;
    goto <D.7646>;
    <D.7621>:
    iftmp.23 = __builtin_strcmp (s, "dingus");
    <D.7646>:
    D.6704 = iftmp.23;
  }
  if (D.6704 != 0) goto <D.7647>; else goto <D.7648>;
  <D.7647>:
  D.7576 = FAILED ("2 Expected dingus, got %s", s);
  return D.7576;
  <D.7648>:
  monoeg_g_free (s);
  D.7576 = 0B;
  return D.7576;
}


test_ppath ()
{
  gchar * D.7652;
  char * s;
  const gchar * searchfor;

  searchfor = "ls";
  s = monoeg_g_find_program_in_path (searchfor);
  if (s == 0B) goto <D.7650>; else goto <D.7651>;
  <D.7650>:
  D.7652 = FAILED ("No %s on this system?", searchfor);
  return D.7652;
  <D.7651>:
  monoeg_g_free (s);
  D.7652 = 0B;
  return D.7652;
}


test_ppath2 ()
{
  gchar * D.7656;
  char * s;
  const char * path;
  const gchar * searchfor;

  path = monoeg_g_getenv ("PATH");
  searchfor = "test-glib";
  monoeg_g_setenv ("PATH", "", 1);
  s = monoeg_g_find_program_in_path ("ls");
  if (s != 0B) goto <D.7654>; else goto <D.7655>;
  <D.7654>:
  monoeg_g_setenv ("PATH", path, 1);
  D.7656 = FAILED ("Found something interesting here: %s", s);
  return D.7656;
  <D.7655>:
  monoeg_g_free (s);
  s = monoeg_g_find_program_in_path (searchfor);
  if (s == 0B) goto <D.7657>; else goto <D.7658>;
  <D.7657>:
  monoeg_g_setenv ("PATH", path, 1);
  D.7656 = FAILED ("It should find \'%s\' in the current directory.", searchfor);
  return D.7656;
  <D.7658>:
  monoeg_g_free (s);
  monoeg_g_setenv ("PATH", path, 1);
  D.7656 = 0B;
  return D.7656;
}


test_cwd ()
{
  gchar * D.7662;
  int D.7663;
  int D.6726;
  char * dir;
  const gchar * newdir;

  dir = monoeg_g_get_current_dir ();
  newdir = "/bin";
  if (dir == 0B) goto <D.7660>; else goto <D.7661>;
  <D.7660>:
  D.7662 = FAILED ("No current directory?");
  return D.7662;
  <D.7661>:
  monoeg_g_free (dir);
  D.7663 = chdir (newdir);
  if (D.7663 == -1) goto <D.7664>; else goto <D.7665>;
  <D.7664>:
  D.7662 = FAILED ("No %s?", newdir);
  return D.7662;
  <D.7665>:
  dir = monoeg_g_get_current_dir ();
  {
    size_t __s1_len;
    size_t __s2_len;

    D.6726 = __builtin_strcmp (dir, newdir);
  }
  if (D.6726 != 0) goto <D.7666>; else goto <D.7667>;
  <D.7666>:
  D.7662 = FAILED ("Did not go to %s?", newdir);
  return D.7662;
  <D.7667>:
  monoeg_g_free (dir);
  D.7662 = 0B;
  return D.7662;
}


test_misc ()
{
  gchar * D.7671;
  const char * home;
  const char * tmp;

  home = monoeg_g_get_home_dir ();
  tmp = monoeg_g_get_tmp_dir ();
  if (home == 0B) goto <D.7669>; else goto <D.7670>;
  <D.7669>:
  D.7671 = FAILED ("Where did my home go?");
  return D.7671;
  <D.7670>:
  if (tmp == 0B) goto <D.7672>; else goto <D.7673>;
  <D.7672>:
  D.7671 = FAILED ("Where did my /tmp go?");
  return D.7671;
  <D.7673>:
  D.7671 = 0B;
  return D.7671;
}


path_tests_init ()
{
  struct Test * D.7675;

  D.7675 = &path_tests;
  return D.7675;
}