test_strfreev ()
{
  gchar * D.5850;
  gchar * * D.5851;
  gchar * D.5852;
  gchar * * D.5853;
  gchar * D.5854;
  gchar * * D.5855;
  gchar * D.5856;
  gchar * * array;

  array = monoeg_malloc (32);
  D.5850 = monoeg_strdup ("one");
  *array = D.5850;
  D.5851 = array + 8;
  D.5852 = monoeg_strdup ("two");
  *D.5851 = D.5852;
  D.5853 = array + 16;
  D.5854 = monoeg_strdup ("three");
  *D.5853 = D.5854;
  D.5855 = array + 24;
  *D.5855 = 0B;
  monoeg_g_strfreev (array);
  monoeg_g_strfreev (0B);
  D.5856 = 0B;
  return D.5856;
}


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

  if (str != 0B) goto <D.5858>; else goto <D.5859>;
  <D.5858>:
  D.5860 = __strdup (str);
  return D.5860;
  <D.5859>:
  D.5860 = 0B;
  return D.5860;
}


test_concat ()
{
  int D.4960;
  int iftmp.0;
  int D.4959;
  char[13] * D.5865;
  unsigned char D.5866;
  int D.5867;
  unsigned char D.5868;
  int D.5869;
  _Bool D.5870;
  _Bool D.5871;
  _Bool D.5872;
  const unsigned char * D.5875;
  unsigned char D.5876;
  int D.5877;
  const unsigned char * D.5878;
  unsigned char D.5879;
  int D.5880;
  _Bool D.5881;
  _Bool D.5882;
  const unsigned char * D.5885;
  unsigned char D.5886;
  int D.5887;
  const unsigned char * D.5888;
  unsigned char D.5889;
  int D.5890;
  _Bool D.5891;
  _Bool D.5892;
  const unsigned char * D.5895;
  unsigned char D.5896;
  int D.5897;
  const unsigned char * D.5898;
  unsigned char D.5899;
  int D.5900;
  gchar * D.5904;
  gchar * x;

  x = monoeg_g_strconcat ("Hello", ", ", "world", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = x;
      D.5865 = "Hello, world";
      D.5866 = MEM[(const unsigned char *)D.5865];
      D.5867 = (int) D.5866;
      D.5868 = *__s2;
      D.5869 = (int) D.5868;
      __result = D.5867 - D.5869;
      {
        D.5870 = __s2_len != 0;
        D.5871 = __result == 0;
        D.5872 = D.5870 & D.5871;
        if (D.5872 != 0) goto <D.5873>; else goto <D.5874>;
        <D.5873>:
        D.5875 = &MEM[(void *)"Hello, world" + 1B];
        D.5876 = *D.5875;
        D.5877 = (int) D.5876;
        D.5878 = __s2 + 1;
        D.5879 = *D.5878;
        D.5880 = (int) D.5879;
        __result = D.5877 - D.5880;
        D.5881 = __s2_len > 1;
        D.5871 = __result == 0;
        D.5882 = D.5881 & D.5871;
        if (D.5882 != 0) goto <D.5883>; else goto <D.5884>;
        <D.5883>:
        D.5885 = &MEM[(void *)"Hello, world" + 2B];
        D.5886 = *D.5885;
        D.5887 = (int) D.5886;
        D.5888 = __s2 + 2;
        D.5889 = *D.5888;
        D.5890 = (int) D.5889;
        __result = D.5887 - D.5890;
        D.5891 = __s2_len > 2;
        D.5871 = __result == 0;
        D.5892 = D.5891 & D.5871;
        if (D.5892 != 0) goto <D.5893>; else goto <D.5894>;
        <D.5893>:
        D.5895 = &MEM[(void *)"Hello, world" + 3B];
        D.5896 = *D.5895;
        D.5897 = (int) D.5896;
        D.5898 = __s2 + 3;
        D.5899 = *D.5898;
        D.5900 = (int) D.5899;
        __result = D.5897 - D.5900;
        <D.5894>:
        <D.5884>:
        <D.5874>:
      }
      D.4959 = __result;
    }
    iftmp.0 = -D.4959;
    goto <D.5901>;
    <D.5864>:
    iftmp.0 = __builtin_strcmp (x, "Hello, world");
    <D.5901>:
    D.4960 = iftmp.0;
  }
  if (D.4960 != 0) goto <D.5902>; else goto <D.5903>;
  <D.5902>:
  D.5904 = FAILED ("concat failed, got: %s", x);
  return D.5904;
  <D.5903>:
  monoeg_g_free (x);
  D.5904 = 0B;
  return D.5904;
}


test_split ()
{
  gchar * D.5908;
  long unsigned int D.5909;
  long unsigned int D.5910;
  gchar * * D.5911;
  gchar * D.5912;
  int D.4980;
  gchar * D.5919;
  char D.5924;
  int D.4989;
  int iftmp.1;
  int D.4988;
  char[11] * D.5930;
  unsigned char D.5931;
  int D.5932;
  unsigned char D.5933;
  int D.5934;
  _Bool D.5935;
  _Bool D.5936;
  _Bool D.5937;
  const unsigned char * D.5940;
  unsigned char D.5941;
  int D.5942;
  const unsigned char * D.5943;
  unsigned char D.5944;
  int D.5945;
  _Bool D.5946;
  _Bool D.5947;
  const unsigned char * D.5950;
  unsigned char D.5951;
  int D.5952;
  const unsigned char * D.5953;
  unsigned char D.5954;
  int D.5955;
  _Bool D.5956;
  _Bool D.5957;
  const unsigned char * D.5960;
  unsigned char D.5961;
  int D.5962;
  const unsigned char * D.5963;
  unsigned char D.5964;
  int D.5965;
  int D.4998;
  int iftmp.2;
  int D.4997;
  char[17] * D.5972;
  unsigned char D.5973;
  int D.5974;
  unsigned char D.5975;
  int D.5976;
  _Bool D.5977;
  _Bool D.5978;
  _Bool D.5979;
  const unsigned char * D.5982;
  unsigned char D.5983;
  int D.5984;
  const unsigned char * D.5985;
  unsigned char D.5986;
  int D.5987;
  _Bool D.5988;
  _Bool D.5989;
  const unsigned char * D.5992;
  unsigned char D.5993;
  int D.5994;
  const unsigned char * D.5995;
  unsigned char D.5996;
  int D.5997;
  _Bool D.5998;
  _Bool D.5999;
  const unsigned char * D.6002;
  unsigned char D.6003;
  int D.6004;
  const unsigned char * D.6005;
  unsigned char D.6006;
  int D.6007;
  gchar * * D.6009;
  gchar * D.6010;
  int D.5007;
  int iftmp.3;
  int D.5006;
  char[17] * D.6016;
  unsigned char D.6017;
  int D.6018;
  unsigned char D.6019;
  int D.6020;
  _Bool D.6021;
  _Bool D.6022;
  _Bool D.6023;
  const unsigned char * D.6026;
  unsigned char D.6027;
  int D.6028;
  const unsigned char * D.6029;
  unsigned char D.6030;
  int D.6031;
  _Bool D.6032;
  _Bool D.6033;
  const unsigned char * D.6036;
  unsigned char D.6037;
  int D.6038;
  const unsigned char * D.6039;
  unsigned char D.6040;
  int D.6041;
  _Bool D.6042;
  _Bool D.6043;
  const unsigned char * D.6046;
  unsigned char D.6047;
  int D.6048;
  const unsigned char * D.6049;
  unsigned char D.6050;
  int D.6051;
  gchar * * D.6053;
  gchar * D.6054;
  gchar * * D.6057;
  gchar * D.6058;
  int D.5016;
  int iftmp.4;
  int D.5015;
  char[4] * D.6064;
  unsigned char D.6065;
  int D.6066;
  unsigned char D.6067;
  int D.6068;
  _Bool D.6069;
  _Bool D.6070;
  _Bool D.6071;
  const unsigned char * D.6074;
  unsigned char D.6075;
  int D.6076;
  const unsigned char * D.6077;
  unsigned char D.6078;
  int D.6079;
  _Bool D.6080;
  _Bool D.6081;
  const unsigned char * D.6084;
  unsigned char D.6085;
  int D.6086;
  const unsigned char * D.6087;
  unsigned char D.6088;
  int D.6089;
  _Bool D.6090;
  _Bool D.6091;
  const unsigned char * D.6094;
  unsigned char D.6095;
  int D.6096;
  const unsigned char * D.6097;
  unsigned char D.6098;
  int D.6099;
  int D.5025;
  int iftmp.5;
  int D.5024;
  char[8] * D.6106;
  unsigned char D.6107;
  int D.6108;
  unsigned char D.6109;
  int D.6110;
  _Bool D.6111;
  _Bool D.6112;
  _Bool D.6113;
  const unsigned char * D.6116;
  unsigned char D.6117;
  int D.6118;
  const unsigned char * D.6119;
  unsigned char D.6120;
  int D.6121;
  _Bool D.6122;
  _Bool D.6123;
  const unsigned char * D.6126;
  unsigned char D.6127;
  int D.6128;
  const unsigned char * D.6129;
  unsigned char D.6130;
  int D.6131;
  _Bool D.6132;
  _Bool D.6133;
  const unsigned char * D.6136;
  unsigned char D.6137;
  int D.6138;
  const unsigned char * D.6139;
  unsigned char D.6140;
  int D.6141;
  int D.5034;
  int iftmp.6;
  int D.5033;
  char[8] * D.6148;
  unsigned char D.6149;
  int D.6150;
  unsigned char D.6151;
  int D.6152;
  _Bool D.6153;
  _Bool D.6154;
  _Bool D.6155;
  const unsigned char * D.6158;
  unsigned char D.6159;
  int D.6160;
  const unsigned char * D.6161;
  unsigned char D.6162;
  int D.6163;
  _Bool D.6164;
  _Bool D.6165;
  const unsigned char * D.6168;
  unsigned char D.6169;
  int D.6170;
  const unsigned char * D.6171;
  unsigned char D.6172;
  int D.6173;
  _Bool D.6174;
  _Bool D.6175;
  const unsigned char * D.6178;
  unsigned char D.6179;
  int D.6180;
  const unsigned char * D.6181;
  unsigned char D.6182;
  int D.6183;
  int D.5043;
  int iftmp.7;
  int D.5042;
  unsigned char D.6192;
  int D.6193;
  _Bool D.6194;
  _Bool D.6195;
  _Bool D.6196;
  const unsigned char * D.6199;
  unsigned char D.6200;
  int D.6201;
  _Bool D.6202;
  _Bool D.6203;
  const unsigned char * D.6206;
  unsigned char D.6207;
  int D.6208;
  _Bool D.6209;
  _Bool D.6210;
  const unsigned char * D.6213;
  unsigned char D.6214;
  int D.6215;
  int D.5052;
  int iftmp.8;
  int D.5051;
  char[17] * D.6222;
  unsigned char D.6223;
  int D.6224;
  unsigned char D.6225;
  int D.6226;
  _Bool D.6227;
  _Bool D.6228;
  _Bool D.6229;
  const unsigned char * D.6232;
  unsigned char D.6233;
  int D.6234;
  const unsigned char * D.6235;
  unsigned char D.6236;
  int D.6237;
  _Bool D.6238;
  _Bool D.6239;
  const unsigned char * D.6242;
  unsigned char D.6243;
  int D.6244;
  const unsigned char * D.6245;
  unsigned char D.6246;
  int D.6247;
  _Bool D.6248;
  _Bool D.6249;
  const unsigned char * D.6252;
  unsigned char D.6253;
  int D.6254;
  const unsigned char * D.6255;
  unsigned char D.6256;
  int D.6257;
  int D.5061;
  int iftmp.9;
  int D.5060;
  unsigned char D.6266;
  int D.6267;
  _Bool D.6268;
  _Bool D.6269;
  _Bool D.6270;
  const unsigned char * D.6273;
  unsigned char D.6274;
  int D.6275;
  _Bool D.6276;
  _Bool D.6277;
  const unsigned char * D.6280;
  unsigned char D.6281;
  int D.6282;
  _Bool D.6283;
  _Bool D.6284;
  const unsigned char * D.6287;
  unsigned char D.6288;
  int D.6289;
  int D.5070;
  int iftmp.10;
  int D.5069;
  unsigned char D.6296;
  int D.6297;
  _Bool D.6298;
  _Bool D.6299;
  _Bool D.6300;
  const unsigned char * D.6303;
  unsigned char D.6304;
  int D.6305;
  _Bool D.6306;
  _Bool D.6307;
  const unsigned char * D.6310;
  unsigned char D.6311;
  int D.6312;
  _Bool D.6313;
  _Bool D.6314;
  const unsigned char * D.6317;
  unsigned char D.6318;
  int D.6319;
  int D.5079;
  int iftmp.11;
  int D.5078;
  char[10] * D.6326;
  unsigned char D.6327;
  int D.6328;
  unsigned char D.6329;
  int D.6330;
  _Bool D.6331;
  _Bool D.6332;
  _Bool D.6333;
  const unsigned char * D.6336;
  unsigned char D.6337;
  int D.6338;
  const unsigned char * D.6339;
  unsigned char D.6340;
  int D.6341;
  _Bool D.6342;
  _Bool D.6343;
  const unsigned char * D.6346;
  unsigned char D.6347;
  int D.6348;
  const unsigned char * D.6349;
  unsigned char D.6350;
  int D.6351;
  _Bool D.6352;
  _Bool D.6353;
  const unsigned char * D.6356;
  unsigned char D.6357;
  int D.6358;
  const unsigned char * D.6359;
  unsigned char D.6360;
  int D.6361;
  int D.5088;
  int iftmp.12;
  int D.5087;
  unsigned char D.6370;
  int D.6371;
  _Bool D.6372;
  _Bool D.6373;
  _Bool D.6374;
  const unsigned char * D.6377;
  unsigned char D.6378;
  int D.6379;
  _Bool D.6380;
  _Bool D.6381;
  const unsigned char * D.6384;
  unsigned char D.6385;
  int D.6386;
  _Bool D.6387;
  _Bool D.6388;
  const unsigned char * D.6391;
  unsigned char D.6392;
  int D.6393;
  int D.5097;
  int iftmp.13;
  int D.5096;
  char[1] * D.6400;
  unsigned char D.6401;
  int D.6402;
  unsigned char D.6403;
  int D.6404;
  _Bool D.6405;
  _Bool D.6406;
  _Bool D.6407;
  const unsigned char * D.6410;
  unsigned char D.6411;
  int D.6412;
  const unsigned char * D.6413;
  unsigned char D.6414;
  int D.6415;
  _Bool D.6416;
  _Bool D.6417;
  const unsigned char * D.6420;
  unsigned char D.6421;
  int D.6422;
  const unsigned char * D.6423;
  unsigned char D.6424;
  int D.6425;
  _Bool D.6426;
  _Bool D.6427;
  const unsigned char * D.6430;
  unsigned char D.6431;
  int D.6432;
  const unsigned char * D.6433;
  unsigned char D.6434;
  int D.6435;
  unsigned char D.6437;
  int D.5106;
  int iftmp.14;
  int D.5105;
  unsigned char D.6443;
  int D.6444;
  _Bool D.6445;
  _Bool D.6446;
  _Bool D.6447;
  const unsigned char * D.6450;
  unsigned char D.6451;
  int D.6452;
  _Bool D.6453;
  _Bool D.6454;
  const unsigned char * D.6457;
  unsigned char D.6458;
  int D.6459;
  _Bool D.6460;
  _Bool D.6461;
  const unsigned char * D.6464;
  unsigned char D.6465;
  int D.6466;
  unsigned char D.6468;
  int D.5115;
  int iftmp.15;
  int D.5114;
  char[4] * D.6474;
  unsigned char D.6475;
  int D.6476;
  unsigned char D.6477;
  int D.6478;
  _Bool D.6479;
  _Bool D.6480;
  _Bool D.6481;
  const unsigned char * D.6484;
  unsigned char D.6485;
  int D.6486;
  const unsigned char * D.6487;
  unsigned char D.6488;
  int D.6489;
  _Bool D.6490;
  _Bool D.6491;
  const unsigned char * D.6494;
  unsigned char D.6495;
  int D.6496;
  const unsigned char * D.6497;
  unsigned char D.6498;
  int D.6499;
  _Bool D.6500;
  _Bool D.6501;
  const unsigned char * D.6504;
  unsigned char D.6505;
  int D.6506;
  const unsigned char * D.6507;
  unsigned char D.6508;
  int D.6509;
  int D.5124;
  int iftmp.16;
  int D.5123;
  unsigned char D.6516;
  int D.6517;
  _Bool D.6518;
  _Bool D.6519;
  _Bool D.6520;
  const unsigned char * D.6523;
  unsigned char D.6524;
  int D.6525;
  _Bool D.6526;
  _Bool D.6527;
  const unsigned char * D.6530;
  unsigned char D.6531;
  int D.6532;
  _Bool D.6533;
  _Bool D.6534;
  const unsigned char * D.6537;
  unsigned char D.6538;
  int D.6539;
  gchar * * D.6541;
  gchar * D.6542;
  unsigned char D.6543;
  gchar * * D.6546;
  gchar * D.6547;
  int D.5133;
  int iftmp.17;
  int D.5132;
  unsigned char D.6553;
  int D.6554;
  _Bool D.6555;
  _Bool D.6556;
  _Bool D.6557;
  const unsigned char * D.6560;
  unsigned char D.6561;
  int D.6562;
  _Bool D.6563;
  _Bool D.6564;
  const unsigned char * D.6567;
  unsigned char D.6568;
  int D.6569;
  _Bool D.6570;
  _Bool D.6571;
  const unsigned char * D.6574;
  unsigned char D.6575;
  int D.6576;
  unsigned char D.6578;
  int D.5142;
  int iftmp.18;
  int D.5141;
  unsigned char D.6584;
  int D.6585;
  _Bool D.6586;
  _Bool D.6587;
  _Bool D.6588;
  const unsigned char * D.6591;
  unsigned char D.6592;
  int D.6593;
  _Bool D.6594;
  _Bool D.6595;
  const unsigned char * D.6598;
  unsigned char D.6599;
  int D.6600;
  _Bool D.6601;
  _Bool D.6602;
  const unsigned char * D.6605;
  unsigned char D.6606;
  int D.6607;
  int D.5151;
  int iftmp.19;
  int D.5150;
  unsigned char D.6614;
  int D.6615;
  _Bool D.6616;
  _Bool D.6617;
  _Bool D.6618;
  const unsigned char * D.6621;
  unsigned char D.6622;
  int D.6623;
  _Bool D.6624;
  _Bool D.6625;
  const unsigned char * D.6628;
  unsigned char D.6629;
  int D.6630;
  _Bool D.6631;
  _Bool D.6632;
  const unsigned char * D.6635;
  unsigned char D.6636;
  int D.6637;
  int D.5160;
  int iftmp.20;
  int D.5159;
  unsigned char D.6644;
  int D.6645;
  _Bool D.6646;
  _Bool D.6647;
  _Bool D.6648;
  const unsigned char * D.6651;
  unsigned char D.6652;
  int D.6653;
  _Bool D.6654;
  _Bool D.6655;
  const unsigned char * D.6658;
  unsigned char D.6659;
  int D.6660;
  _Bool D.6661;
  _Bool D.6662;
  const unsigned char * D.6665;
  unsigned char D.6666;
  int D.6667;
  int D.5169;
  int iftmp.21;
  int D.5168;
  unsigned char D.6674;
  int D.6675;
  _Bool D.6676;
  _Bool D.6677;
  _Bool D.6678;
  const unsigned char * D.6681;
  unsigned char D.6682;
  int D.6683;
  _Bool D.6684;
  _Bool D.6685;
  const unsigned char * D.6688;
  unsigned char D.6689;
  int D.6690;
  _Bool D.6691;
  _Bool D.6692;
  const unsigned char * D.6695;
  unsigned char D.6696;
  int D.6697;
  int D.5178;
  int iftmp.22;
  int D.5177;
  char[6] * D.6706;
  unsigned char D.6707;
  int D.6708;
  unsigned char D.6709;
  int D.6710;
  _Bool D.6711;
  _Bool D.6712;
  _Bool D.6713;
  const unsigned char * D.6716;
  unsigned char D.6717;
  int D.6718;
  const unsigned char * D.6719;
  unsigned char D.6720;
  int D.6721;
  _Bool D.6722;
  _Bool D.6723;
  const unsigned char * D.6726;
  unsigned char D.6727;
  int D.6728;
  const unsigned char * D.6729;
  unsigned char D.6730;
  int D.6731;
  _Bool D.6732;
  _Bool D.6733;
  const unsigned char * D.6736;
  unsigned char D.6737;
  int D.6738;
  const unsigned char * D.6739;
  unsigned char D.6740;
  int D.6741;
  int D.5187;
  int iftmp.23;
  int D.5186;
  unsigned char D.6748;
  int D.6749;
  _Bool D.6750;
  _Bool D.6751;
  _Bool D.6752;
  const unsigned char * D.6755;
  unsigned char D.6756;
  int D.6757;
  _Bool D.6758;
  _Bool D.6759;
  const unsigned char * D.6762;
  unsigned char D.6763;
  int D.6764;
  _Bool D.6765;
  _Bool D.6766;
  const unsigned char * D.6769;
  unsigned char D.6770;
  int D.6771;
  const gchar * to_split;
  gint i;
  gchar * * v;

  to_split = "Hello world, how are we doing today?";
  v = monoeg_g_strsplit (to_split, " ", 0);
  if (v == 0B) goto <D.5906>; else goto <D.5907>;
  <D.5906>:
  D.5908 = FAILED ("split failed, got NULL vector (1)");
  return D.5908;
  <D.5907>:
  i = 0;
  goto <D.4967>;
  <D.4966>:
  i = i + 1;
  <D.4967>:
  D.5909 = (long unsigned int) i;
  D.5910 = D.5909 * 8;
  D.5911 = v + D.5910;
  D.5912 = *D.5911;
  if (D.5912 != 0B) goto <D.4966>; else goto <D.4968>;
  <D.4968>:
  if (i != 7) goto <D.5913>; else goto <D.5914>;
  <D.5913>:
  D.5908 = FAILED ("split failed, expected 7 tokens, got %d", i);
  return D.5908;
  <D.5914>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit (to_split, ":", -1);
  if (v == 0B) goto <D.5915>; else goto <D.5916>;
  <D.5915>:
  D.5908 = FAILED ("split failed, got NULL vector (2)");
  return D.5908;
  <D.5916>:
  i = 0;
  goto <D.4970>;
  <D.4969>:
  i = i + 1;
  <D.4970>:
  D.5909 = (long unsigned int) i;
  D.5910 = D.5909 * 8;
  D.5911 = v + D.5910;
  D.5912 = *D.5911;
  if (D.5912 != 0B) goto <D.4969>; else goto <D.4971>;
  <D.4971>:
  if (i != 1) goto <D.5917>; else goto <D.5918>;
  <D.5917>:
  D.5908 = FAILED ("split failed, expected 1 token, got %d", i);
  return D.5908;
  <D.5918>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.5919 = *v;
    D.4980 = __builtin_strcmp (D.5919, to_split);
  }
  if (D.4980 != 0) goto <D.5920>; else goto <D.5921>;
  <D.5920>:
  D.5919 = *v;
  D.5908 = FAILED ("expected vector[0] to be \'%s\' but it was \'%s\'", to_split, D.5919);
  return D.5908;
  <D.5921>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit ("", ":", 0);
  if (v == 0B) goto <D.5922>; else goto <D.5923>;
  <D.5922>:
  D.5908 = FAILED ("g_strsplit returned NULL");
  return D.5908;
  <D.5923>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit ("/home/miguel/dingus", "/", 0);
  D.5919 = *v;
  D.5924 = *D.5919;
  if (D.5924 != 0) goto <D.5925>; else goto <D.5926>;
  <D.5925>:
  D.5908 = FAILED ("Got a non-empty first element");
  return D.5908;
  <D.5926>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit ("appdomain1, Version=0.0.0.0, Culture=neutral", ",", 4);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.5930 = "appdomain1";
      D.5931 = MEM[(const unsigned char *)D.5930];
      D.5932 = (int) D.5931;
      D.5933 = *__s2;
      D.5934 = (int) D.5933;
      __result = D.5932 - D.5934;
      {
        D.5935 = __s2_len != 0;
        D.5936 = __result == 0;
        D.5937 = D.5935 & D.5936;
        if (D.5937 != 0) goto <D.5938>; else goto <D.5939>;
        <D.5938>:
        D.5940 = &MEM[(void *)"appdomain1" + 1B];
        D.5941 = *D.5940;
        D.5942 = (int) D.5941;
        D.5943 = __s2 + 1;
        D.5944 = *D.5943;
        D.5945 = (int) D.5944;
        __result = D.5942 - D.5945;
        D.5946 = __s2_len > 1;
        D.5936 = __result == 0;
        D.5947 = D.5946 & D.5936;
        if (D.5947 != 0) goto <D.5948>; else goto <D.5949>;
        <D.5948>:
        D.5950 = &MEM[(void *)"appdomain1" + 2B];
        D.5951 = *D.5950;
        D.5952 = (int) D.5951;
        D.5953 = __s2 + 2;
        D.5954 = *D.5953;
        D.5955 = (int) D.5954;
        __result = D.5952 - D.5955;
        D.5956 = __s2_len > 2;
        D.5936 = __result == 0;
        D.5957 = D.5956 & D.5936;
        if (D.5957 != 0) goto <D.5958>; else goto <D.5959>;
        <D.5958>:
        D.5960 = &MEM[(void *)"appdomain1" + 3B];
        D.5961 = *D.5960;
        D.5962 = (int) D.5961;
        D.5963 = __s2 + 3;
        D.5964 = *D.5963;
        D.5965 = (int) D.5964;
        __result = D.5962 - D.5965;
        <D.5959>:
        <D.5949>:
        <D.5939>:
      }
      D.4988 = __result;
    }
    iftmp.1 = -D.4988;
    goto <D.5966>;
    <D.5929>:
    D.5919 = *v;
    iftmp.1 = __builtin_strcmp (D.5919, "appdomain1");
    <D.5966>:
    D.4989 = iftmp.1;
  }
  if (D.4989 != 0) goto <D.5967>; else goto <D.5968>;
  <D.5967>:
  D.5908 = FAILED ("Invalid value");
  return D.5908;
  <D.5968>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 16;
    if (__s2_len <= 3) goto <D.5970>; else goto <D.5971>;
    <D.5970>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 8B];
      D.5972 = " Version=0.0.0.0";
      D.5973 = MEM[(const unsigned char *)D.5972];
      D.5974 = (int) D.5973;
      D.5975 = *__s2;
      D.5976 = (int) D.5975;
      __result = D.5974 - D.5976;
      {
        D.5977 = __s2_len != 0;
        D.5978 = __result == 0;
        D.5979 = D.5977 & D.5978;
        if (D.5979 != 0) goto <D.5980>; else goto <D.5981>;
        <D.5980>:
        D.5982 = &MEM[(void *)" Version=0.0.0.0" + 1B];
        D.5983 = *D.5982;
        D.5984 = (int) D.5983;
        D.5985 = __s2 + 1;
        D.5986 = *D.5985;
        D.5987 = (int) D.5986;
        __result = D.5984 - D.5987;
        D.5988 = __s2_len > 1;
        D.5978 = __result == 0;
        D.5989 = D.5988 & D.5978;
        if (D.5989 != 0) goto <D.5990>; else goto <D.5991>;
        <D.5990>:
        D.5992 = &MEM[(void *)" Version=0.0.0.0" + 2B];
        D.5993 = *D.5992;
        D.5994 = (int) D.5993;
        D.5995 = __s2 + 2;
        D.5996 = *D.5995;
        D.5997 = (int) D.5996;
        __result = D.5994 - D.5997;
        D.5998 = __s2_len > 2;
        D.5978 = __result == 0;
        D.5999 = D.5998 & D.5978;
        if (D.5999 != 0) goto <D.6000>; else goto <D.6001>;
        <D.6000>:
        D.6002 = &MEM[(void *)" Version=0.0.0.0" + 3B];
        D.6003 = *D.6002;
        D.6004 = (int) D.6003;
        D.6005 = __s2 + 3;
        D.6006 = *D.6005;
        D.6007 = (int) D.6006;
        __result = D.6004 - D.6007;
        <D.6001>:
        <D.5991>:
        <D.5981>:
      }
      D.4997 = __result;
    }
    iftmp.2 = -D.4997;
    goto <D.6008>;
    <D.5971>:
    D.6009 = v + 8;
    D.6010 = *D.6009;
    iftmp.2 = __builtin_strcmp (D.6010, " Version=0.0.0.0");
    <D.6008>:
    D.4998 = iftmp.2;
  }
  if (D.4998 != 0) goto <D.6011>; else goto <D.6012>;
  <D.6011>:
  D.5908 = FAILED ("Invalid value");
  return D.5908;
  <D.6012>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 16;
    if (__s2_len <= 3) goto <D.6014>; else goto <D.6015>;
    <D.6014>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 16B];
      D.6016 = " Culture=neutral";
      D.6017 = MEM[(const unsigned char *)D.6016];
      D.6018 = (int) D.6017;
      D.6019 = *__s2;
      D.6020 = (int) D.6019;
      __result = D.6018 - D.6020;
      {
        D.6021 = __s2_len != 0;
        D.6022 = __result == 0;
        D.6023 = D.6021 & D.6022;
        if (D.6023 != 0) goto <D.6024>; else goto <D.6025>;
        <D.6024>:
        D.6026 = &MEM[(void *)" Culture=neutral" + 1B];
        D.6027 = *D.6026;
        D.6028 = (int) D.6027;
        D.6029 = __s2 + 1;
        D.6030 = *D.6029;
        D.6031 = (int) D.6030;
        __result = D.6028 - D.6031;
        D.6032 = __s2_len > 1;
        D.6022 = __result == 0;
        D.6033 = D.6032 & D.6022;
        if (D.6033 != 0) goto <D.6034>; else goto <D.6035>;
        <D.6034>:
        D.6036 = &MEM[(void *)" Culture=neutral" + 2B];
        D.6037 = *D.6036;
        D.6038 = (int) D.6037;
        D.6039 = __s2 + 2;
        D.6040 = *D.6039;
        D.6041 = (int) D.6040;
        __result = D.6038 - D.6041;
        D.6042 = __s2_len > 2;
        D.6022 = __result == 0;
        D.6043 = D.6042 & D.6022;
        if (D.6043 != 0) goto <D.6044>; else goto <D.6045>;
        <D.6044>:
        D.6046 = &MEM[(void *)" Culture=neutral" + 3B];
        D.6047 = *D.6046;
        D.6048 = (int) D.6047;
        D.6049 = __s2 + 3;
        D.6050 = *D.6049;
        D.6051 = (int) D.6050;
        __result = D.6048 - D.6051;
        <D.6045>:
        <D.6035>:
        <D.6025>:
      }
      D.5006 = __result;
    }
    iftmp.3 = -D.5006;
    goto <D.6052>;
    <D.6015>:
    D.6053 = v + 16;
    D.6054 = *D.6053;
    iftmp.3 = __builtin_strcmp (D.6054, " Culture=neutral");
    <D.6052>:
    D.5007 = iftmp.3;
  }
  if (D.5007 != 0) goto <D.6055>; else goto <D.6056>;
  <D.6055>:
  D.5908 = FAILED ("Invalid value");
  return D.5908;
  <D.6056>:
  D.6057 = v + 24;
  D.6058 = *D.6057;
  if (D.6058 != 0B) goto <D.6059>; else goto <D.6060>;
  <D.6059>:
  D.5908 = FAILED ("Expected only 3 elements");
  return D.5908;
  <D.6060>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit ("abcXYdefXghiXYjklYmno", "XY", 4);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.6064 = "abc";
      D.6065 = MEM[(const unsigned char *)D.6064];
      D.6066 = (int) D.6065;
      D.6067 = *__s2;
      D.6068 = (int) D.6067;
      __result = D.6066 - D.6068;
      {
        D.6069 = __s2_len != 0;
        D.6070 = __result == 0;
        D.6071 = D.6069 & D.6070;
        if (D.6071 != 0) goto <D.6072>; else goto <D.6073>;
        <D.6072>:
        D.6074 = &MEM[(void *)"abc" + 1B];
        D.6075 = *D.6074;
        D.6076 = (int) D.6075;
        D.6077 = __s2 + 1;
        D.6078 = *D.6077;
        D.6079 = (int) D.6078;
        __result = D.6076 - D.6079;
        D.6080 = __s2_len > 1;
        D.6070 = __result == 0;
        D.6081 = D.6080 & D.6070;
        if (D.6081 != 0) goto <D.6082>; else goto <D.6083>;
        <D.6082>:
        D.6084 = &MEM[(void *)"abc" + 2B];
        D.6085 = *D.6084;
        D.6086 = (int) D.6085;
        D.6087 = __s2 + 2;
        D.6088 = *D.6087;
        D.6089 = (int) D.6088;
        __result = D.6086 - D.6089;
        D.6090 = __s2_len > 2;
        D.6070 = __result == 0;
        D.6091 = D.6090 & D.6070;
        if (D.6091 != 0) goto <D.6092>; else goto <D.6093>;
        <D.6092>:
        D.6094 = &MEM[(void *)"abc" + 3B];
        D.6095 = *D.6094;
        D.6096 = (int) D.6095;
        D.6097 = __s2 + 3;
        D.6098 = *D.6097;
        D.6099 = (int) D.6098;
        __result = D.6096 - D.6099;
        <D.6093>:
        <D.6083>:
        <D.6073>:
      }
      D.5015 = __result;
    }
    iftmp.4 = -D.5015;
    goto <D.6100>;
    <D.6063>:
    D.5919 = *v;
    iftmp.4 = __builtin_strcmp (D.5919, "abc");
    <D.6100>:
    D.5016 = iftmp.4;
  }
  if (D.5016 != 0) goto <D.6101>; else goto <D.6102>;
  <D.6101>:
  D.5908 = FAILED ("Invalid value 0");
  return D.5908;
  <D.6102>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 8B];
      D.6106 = "defXghi";
      D.6107 = MEM[(const unsigned char *)D.6106];
      D.6108 = (int) D.6107;
      D.6109 = *__s2;
      D.6110 = (int) D.6109;
      __result = D.6108 - D.6110;
      {
        D.6111 = __s2_len != 0;
        D.6112 = __result == 0;
        D.6113 = D.6111 & D.6112;
        if (D.6113 != 0) goto <D.6114>; else goto <D.6115>;
        <D.6114>:
        D.6116 = &MEM[(void *)"defXghi" + 1B];
        D.6117 = *D.6116;
        D.6118 = (int) D.6117;
        D.6119 = __s2 + 1;
        D.6120 = *D.6119;
        D.6121 = (int) D.6120;
        __result = D.6118 - D.6121;
        D.6122 = __s2_len > 1;
        D.6112 = __result == 0;
        D.6123 = D.6122 & D.6112;
        if (D.6123 != 0) goto <D.6124>; else goto <D.6125>;
        <D.6124>:
        D.6126 = &MEM[(void *)"defXghi" + 2B];
        D.6127 = *D.6126;
        D.6128 = (int) D.6127;
        D.6129 = __s2 + 2;
        D.6130 = *D.6129;
        D.6131 = (int) D.6130;
        __result = D.6128 - D.6131;
        D.6132 = __s2_len > 2;
        D.6112 = __result == 0;
        D.6133 = D.6132 & D.6112;
        if (D.6133 != 0) goto <D.6134>; else goto <D.6135>;
        <D.6134>:
        D.6136 = &MEM[(void *)"defXghi" + 3B];
        D.6137 = *D.6136;
        D.6138 = (int) D.6137;
        D.6139 = __s2 + 3;
        D.6140 = *D.6139;
        D.6141 = (int) D.6140;
        __result = D.6138 - D.6141;
        <D.6135>:
        <D.6125>:
        <D.6115>:
      }
      D.5024 = __result;
    }
    iftmp.5 = -D.5024;
    goto <D.6142>;
    <D.6105>:
    D.6009 = v + 8;
    D.6010 = *D.6009;
    iftmp.5 = __builtin_strcmp (D.6010, "defXghi");
    <D.6142>:
    D.5025 = iftmp.5;
  }
  if (D.5025 != 0) goto <D.6143>; else goto <D.6144>;
  <D.6143>:
  D.5908 = FAILED ("Invalid value 1");
  return D.5908;
  <D.6144>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 16B];
      D.6148 = "jklYmno";
      D.6149 = MEM[(const unsigned char *)D.6148];
      D.6150 = (int) D.6149;
      D.6151 = *__s2;
      D.6152 = (int) D.6151;
      __result = D.6150 - D.6152;
      {
        D.6153 = __s2_len != 0;
        D.6154 = __result == 0;
        D.6155 = D.6153 & D.6154;
        if (D.6155 != 0) goto <D.6156>; else goto <D.6157>;
        <D.6156>:
        D.6158 = &MEM[(void *)"jklYmno" + 1B];
        D.6159 = *D.6158;
        D.6160 = (int) D.6159;
        D.6161 = __s2 + 1;
        D.6162 = *D.6161;
        D.6163 = (int) D.6162;
        __result = D.6160 - D.6163;
        D.6164 = __s2_len > 1;
        D.6154 = __result == 0;
        D.6165 = D.6164 & D.6154;
        if (D.6165 != 0) goto <D.6166>; else goto <D.6167>;
        <D.6166>:
        D.6168 = &MEM[(void *)"jklYmno" + 2B];
        D.6169 = *D.6168;
        D.6170 = (int) D.6169;
        D.6171 = __s2 + 2;
        D.6172 = *D.6171;
        D.6173 = (int) D.6172;
        __result = D.6170 - D.6173;
        D.6174 = __s2_len > 2;
        D.6154 = __result == 0;
        D.6175 = D.6174 & D.6154;
        if (D.6175 != 0) goto <D.6176>; else goto <D.6177>;
        <D.6176>:
        D.6178 = &MEM[(void *)"jklYmno" + 3B];
        D.6179 = *D.6178;
        D.6180 = (int) D.6179;
        D.6181 = __s2 + 3;
        D.6182 = *D.6181;
        D.6183 = (int) D.6182;
        __result = D.6180 - D.6183;
        <D.6177>:
        <D.6167>:
        <D.6157>:
      }
      D.5033 = __result;
    }
    iftmp.6 = -D.5033;
    goto <D.6184>;
    <D.6147>:
    D.6053 = v + 16;
    D.6054 = *D.6053;
    iftmp.6 = __builtin_strcmp (D.6054, "jklYmno");
    <D.6184>:
    D.5034 = iftmp.6;
  }
  if (D.5034 != 0) goto <D.6185>; else goto <D.6186>;
  <D.6185>:
  D.5908 = FAILED ("Invalid value 2");
  return D.5908;
  <D.6186>:
  D.6057 = v + 24;
  D.6058 = *D.6057;
  if (D.6058 != 0B) goto <D.6187>; else goto <D.6188>;
  <D.6187>:
  D.5908 = FAILED ("Expected only 3 elements (1)");
  return D.5908;
  <D.6188>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit ("abcXYdefXghiXYjklYmno", "XY", 2);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.6064 = "abc";
      D.6065 = MEM[(const unsigned char *)D.6064];
      D.6066 = (int) D.6065;
      D.6192 = *__s2;
      D.6193 = (int) D.6192;
      __result = D.6066 - D.6193;
      {
        D.6194 = __s2_len != 0;
        D.6195 = __result == 0;
        D.6196 = D.6194 & D.6195;
        if (D.6196 != 0) goto <D.6197>; else goto <D.6198>;
        <D.6197>:
        D.6074 = &MEM[(void *)"abc" + 1B];
        D.6075 = *D.6074;
        D.6076 = (int) D.6075;
        D.6199 = __s2 + 1;
        D.6200 = *D.6199;
        D.6201 = (int) D.6200;
        __result = D.6076 - D.6201;
        D.6202 = __s2_len > 1;
        D.6195 = __result == 0;
        D.6203 = D.6202 & D.6195;
        if (D.6203 != 0) goto <D.6204>; else goto <D.6205>;
        <D.6204>:
        D.6084 = &MEM[(void *)"abc" + 2B];
        D.6085 = *D.6084;
        D.6086 = (int) D.6085;
        D.6206 = __s2 + 2;
        D.6207 = *D.6206;
        D.6208 = (int) D.6207;
        __result = D.6086 - D.6208;
        D.6209 = __s2_len > 2;
        D.6195 = __result == 0;
        D.6210 = D.6209 & D.6195;
        if (D.6210 != 0) goto <D.6211>; else goto <D.6212>;
        <D.6211>:
        D.6094 = &MEM[(void *)"abc" + 3B];
        D.6095 = *D.6094;
        D.6096 = (int) D.6095;
        D.6213 = __s2 + 3;
        D.6214 = *D.6213;
        D.6215 = (int) D.6214;
        __result = D.6096 - D.6215;
        <D.6212>:
        <D.6205>:
        <D.6198>:
      }
      D.5042 = __result;
    }
    iftmp.7 = -D.5042;
    goto <D.6216>;
    <D.6191>:
    D.5919 = *v;
    iftmp.7 = __builtin_strcmp (D.5919, "abc");
    <D.6216>:
    D.5043 = iftmp.7;
  }
  if (D.5043 != 0) goto <D.6217>; else goto <D.6218>;
  <D.6217>:
  D.5908 = FAILED ("Invalid value 3");
  return D.5908;
  <D.6218>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 16;
    if (__s2_len <= 3) goto <D.6220>; else goto <D.6221>;
    <D.6220>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 8B];
      D.6222 = "defXghiXYjklYmno";
      D.6223 = MEM[(const unsigned char *)D.6222];
      D.6224 = (int) D.6223;
      D.6225 = *__s2;
      D.6226 = (int) D.6225;
      __result = D.6224 - D.6226;
      {
        D.6227 = __s2_len != 0;
        D.6228 = __result == 0;
        D.6229 = D.6227 & D.6228;
        if (D.6229 != 0) goto <D.6230>; else goto <D.6231>;
        <D.6230>:
        D.6232 = &MEM[(void *)"defXghiXYjklYmno" + 1B];
        D.6233 = *D.6232;
        D.6234 = (int) D.6233;
        D.6235 = __s2 + 1;
        D.6236 = *D.6235;
        D.6237 = (int) D.6236;
        __result = D.6234 - D.6237;
        D.6238 = __s2_len > 1;
        D.6228 = __result == 0;
        D.6239 = D.6238 & D.6228;
        if (D.6239 != 0) goto <D.6240>; else goto <D.6241>;
        <D.6240>:
        D.6242 = &MEM[(void *)"defXghiXYjklYmno" + 2B];
        D.6243 = *D.6242;
        D.6244 = (int) D.6243;
        D.6245 = __s2 + 2;
        D.6246 = *D.6245;
        D.6247 = (int) D.6246;
        __result = D.6244 - D.6247;
        D.6248 = __s2_len > 2;
        D.6228 = __result == 0;
        D.6249 = D.6248 & D.6228;
        if (D.6249 != 0) goto <D.6250>; else goto <D.6251>;
        <D.6250>:
        D.6252 = &MEM[(void *)"defXghiXYjklYmno" + 3B];
        D.6253 = *D.6252;
        D.6254 = (int) D.6253;
        D.6255 = __s2 + 3;
        D.6256 = *D.6255;
        D.6257 = (int) D.6256;
        __result = D.6254 - D.6257;
        <D.6251>:
        <D.6241>:
        <D.6231>:
      }
      D.5051 = __result;
    }
    iftmp.8 = -D.5051;
    goto <D.6258>;
    <D.6221>:
    D.6009 = v + 8;
    D.6010 = *D.6009;
    iftmp.8 = __builtin_strcmp (D.6010, "defXghiXYjklYmno");
    <D.6258>:
    D.5052 = iftmp.8;
  }
  if (D.5052 != 0) goto <D.6259>; else goto <D.6260>;
  <D.6259>:
  D.5908 = FAILED ("Invalid value 4");
  return D.5908;
  <D.6260>:
  D.6053 = v + 16;
  D.6054 = *D.6053;
  if (D.6054 != 0B) goto <D.6261>; else goto <D.6262>;
  <D.6261>:
  D.5908 = FAILED ("Expected only 2 elements (2)");
  return D.5908;
  <D.6262>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit ("abcXYdefXghiXYjklYmnoXY", "XY", 3);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.6064 = "abc";
      D.6065 = MEM[(const unsigned char *)D.6064];
      D.6066 = (int) D.6065;
      D.6266 = *__s2;
      D.6267 = (int) D.6266;
      __result = D.6066 - D.6267;
      {
        D.6268 = __s2_len != 0;
        D.6269 = __result == 0;
        D.6270 = D.6268 & D.6269;
        if (D.6270 != 0) goto <D.6271>; else goto <D.6272>;
        <D.6271>:
        D.6074 = &MEM[(void *)"abc" + 1B];
        D.6075 = *D.6074;
        D.6076 = (int) D.6075;
        D.6273 = __s2 + 1;
        D.6274 = *D.6273;
        D.6275 = (int) D.6274;
        __result = D.6076 - D.6275;
        D.6276 = __s2_len > 1;
        D.6269 = __result == 0;
        D.6277 = D.6276 & D.6269;
        if (D.6277 != 0) goto <D.6278>; else goto <D.6279>;
        <D.6278>:
        D.6084 = &MEM[(void *)"abc" + 2B];
        D.6085 = *D.6084;
        D.6086 = (int) D.6085;
        D.6280 = __s2 + 2;
        D.6281 = *D.6280;
        D.6282 = (int) D.6281;
        __result = D.6086 - D.6282;
        D.6283 = __s2_len > 2;
        D.6269 = __result == 0;
        D.6284 = D.6283 & D.6269;
        if (D.6284 != 0) goto <D.6285>; else goto <D.6286>;
        <D.6285>:
        D.6094 = &MEM[(void *)"abc" + 3B];
        D.6095 = *D.6094;
        D.6096 = (int) D.6095;
        D.6287 = __s2 + 3;
        D.6288 = *D.6287;
        D.6289 = (int) D.6288;
        __result = D.6096 - D.6289;
        <D.6286>:
        <D.6279>:
        <D.6272>:
      }
      D.5060 = __result;
    }
    iftmp.9 = -D.5060;
    goto <D.6290>;
    <D.6265>:
    D.5919 = *v;
    iftmp.9 = __builtin_strcmp (D.5919, "abc");
    <D.6290>:
    D.5061 = iftmp.9;
  }
  if (D.5061 != 0) goto <D.6291>; else goto <D.6292>;
  <D.6291>:
  D.5908 = FAILED ("Invalid value 5");
  return D.5908;
  <D.6292>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 8B];
      D.6106 = "defXghi";
      D.6107 = MEM[(const unsigned char *)D.6106];
      D.6108 = (int) D.6107;
      D.6296 = *__s2;
      D.6297 = (int) D.6296;
      __result = D.6108 - D.6297;
      {
        D.6298 = __s2_len != 0;
        D.6299 = __result == 0;
        D.6300 = D.6298 & D.6299;
        if (D.6300 != 0) goto <D.6301>; else goto <D.6302>;
        <D.6301>:
        D.6116 = &MEM[(void *)"defXghi" + 1B];
        D.6117 = *D.6116;
        D.6118 = (int) D.6117;
        D.6303 = __s2 + 1;
        D.6304 = *D.6303;
        D.6305 = (int) D.6304;
        __result = D.6118 - D.6305;
        D.6306 = __s2_len > 1;
        D.6299 = __result == 0;
        D.6307 = D.6306 & D.6299;
        if (D.6307 != 0) goto <D.6308>; else goto <D.6309>;
        <D.6308>:
        D.6126 = &MEM[(void *)"defXghi" + 2B];
        D.6127 = *D.6126;
        D.6128 = (int) D.6127;
        D.6310 = __s2 + 2;
        D.6311 = *D.6310;
        D.6312 = (int) D.6311;
        __result = D.6128 - D.6312;
        D.6313 = __s2_len > 2;
        D.6299 = __result == 0;
        D.6314 = D.6313 & D.6299;
        if (D.6314 != 0) goto <D.6315>; else goto <D.6316>;
        <D.6315>:
        D.6136 = &MEM[(void *)"defXghi" + 3B];
        D.6137 = *D.6136;
        D.6138 = (int) D.6137;
        D.6317 = __s2 + 3;
        D.6318 = *D.6317;
        D.6319 = (int) D.6318;
        __result = D.6138 - D.6319;
        <D.6316>:
        <D.6309>:
        <D.6302>:
      }
      D.5069 = __result;
    }
    iftmp.10 = -D.5069;
    goto <D.6320>;
    <D.6295>:
    D.6009 = v + 8;
    D.6010 = *D.6009;
    iftmp.10 = __builtin_strcmp (D.6010, "defXghi");
    <D.6320>:
    D.5070 = iftmp.10;
  }
  if (D.5070 != 0) goto <D.6321>; else goto <D.6322>;
  <D.6321>:
  D.5908 = FAILED ("Invalid value 6");
  return D.5908;
  <D.6322>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.6324>; else goto <D.6325>;
    <D.6324>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 16B];
      D.6326 = "jklYmnoXY";
      D.6327 = MEM[(const unsigned char *)D.6326];
      D.6328 = (int) D.6327;
      D.6329 = *__s2;
      D.6330 = (int) D.6329;
      __result = D.6328 - D.6330;
      {
        D.6331 = __s2_len != 0;
        D.6332 = __result == 0;
        D.6333 = D.6331 & D.6332;
        if (D.6333 != 0) goto <D.6334>; else goto <D.6335>;
        <D.6334>:
        D.6336 = &MEM[(void *)"jklYmnoXY" + 1B];
        D.6337 = *D.6336;
        D.6338 = (int) D.6337;
        D.6339 = __s2 + 1;
        D.6340 = *D.6339;
        D.6341 = (int) D.6340;
        __result = D.6338 - D.6341;
        D.6342 = __s2_len > 1;
        D.6332 = __result == 0;
        D.6343 = D.6342 & D.6332;
        if (D.6343 != 0) goto <D.6344>; else goto <D.6345>;
        <D.6344>:
        D.6346 = &MEM[(void *)"jklYmnoXY" + 2B];
        D.6347 = *D.6346;
        D.6348 = (int) D.6347;
        D.6349 = __s2 + 2;
        D.6350 = *D.6349;
        D.6351 = (int) D.6350;
        __result = D.6348 - D.6351;
        D.6352 = __s2_len > 2;
        D.6332 = __result == 0;
        D.6353 = D.6352 & D.6332;
        if (D.6353 != 0) goto <D.6354>; else goto <D.6355>;
        <D.6354>:
        D.6356 = &MEM[(void *)"jklYmnoXY" + 3B];
        D.6357 = *D.6356;
        D.6358 = (int) D.6357;
        D.6359 = __s2 + 3;
        D.6360 = *D.6359;
        D.6361 = (int) D.6360;
        __result = D.6358 - D.6361;
        <D.6355>:
        <D.6345>:
        <D.6335>:
      }
      D.5078 = __result;
    }
    iftmp.11 = -D.5078;
    goto <D.6362>;
    <D.6325>:
    D.6053 = v + 16;
    D.6054 = *D.6053;
    iftmp.11 = __builtin_strcmp (D.6054, "jklYmnoXY");
    <D.6362>:
    D.5079 = iftmp.11;
  }
  if (D.5079 != 0) goto <D.6363>; else goto <D.6364>;
  <D.6363>:
  D.5908 = FAILED ("Invalid value 7");
  return D.5908;
  <D.6364>:
  D.6057 = v + 24;
  D.6058 = *D.6057;
  if (D.6058 != 0B) goto <D.6365>; else goto <D.6366>;
  <D.6365>:
  D.5908 = FAILED ("Expected only 3 elements (3)");
  return D.5908;
  <D.6366>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit ("abcXYXYXYdefXY", "XY", -1);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.6064 = "abc";
      D.6065 = MEM[(const unsigned char *)D.6064];
      D.6066 = (int) D.6065;
      D.6370 = *__s2;
      D.6371 = (int) D.6370;
      __result = D.6066 - D.6371;
      {
        D.6372 = __s2_len != 0;
        D.6373 = __result == 0;
        D.6374 = D.6372 & D.6373;
        if (D.6374 != 0) goto <D.6375>; else goto <D.6376>;
        <D.6375>:
        D.6074 = &MEM[(void *)"abc" + 1B];
        D.6075 = *D.6074;
        D.6076 = (int) D.6075;
        D.6377 = __s2 + 1;
        D.6378 = *D.6377;
        D.6379 = (int) D.6378;
        __result = D.6076 - D.6379;
        D.6380 = __s2_len > 1;
        D.6373 = __result == 0;
        D.6381 = D.6380 & D.6373;
        if (D.6381 != 0) goto <D.6382>; else goto <D.6383>;
        <D.6382>:
        D.6084 = &MEM[(void *)"abc" + 2B];
        D.6085 = *D.6084;
        D.6086 = (int) D.6085;
        D.6384 = __s2 + 2;
        D.6385 = *D.6384;
        D.6386 = (int) D.6385;
        __result = D.6086 - D.6386;
        D.6387 = __s2_len > 2;
        D.6373 = __result == 0;
        D.6388 = D.6387 & D.6373;
        if (D.6388 != 0) goto <D.6389>; else goto <D.6390>;
        <D.6389>:
        D.6094 = &MEM[(void *)"abc" + 3B];
        D.6095 = *D.6094;
        D.6096 = (int) D.6095;
        D.6391 = __s2 + 3;
        D.6392 = *D.6391;
        D.6393 = (int) D.6392;
        __result = D.6096 - D.6393;
        <D.6390>:
        <D.6383>:
        <D.6376>:
      }
      D.5087 = __result;
    }
    iftmp.12 = -D.5087;
    goto <D.6394>;
    <D.6369>:
    D.5919 = *v;
    iftmp.12 = __builtin_strcmp (D.5919, "abc");
    <D.6394>:
    D.5088 = iftmp.12;
  }
  if (D.5088 != 0) goto <D.6395>; else goto <D.6396>;
  <D.6395>:
  D.5908 = FAILED ("Invalid value 8");
  return D.5908;
  <D.6396>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.6398>; else goto <D.6399>;
    <D.6398>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 8B];
      D.6400 = "";
      D.6401 = MEM[(const unsigned char *)D.6400];
      D.6402 = (int) D.6401;
      D.6403 = *__s2;
      D.6404 = (int) D.6403;
      __result = D.6402 - D.6404;
      {
        D.6405 = __s2_len != 0;
        D.6406 = __result == 0;
        D.6407 = D.6405 & D.6406;
        if (D.6407 != 0) goto <D.6408>; else goto <D.6409>;
        <D.6408>:
        D.6410 = &MEM[(void *)"" + 1B];
        D.6411 = *D.6410;
        D.6412 = (int) D.6411;
        D.6413 = __s2 + 1;
        D.6414 = *D.6413;
        D.6415 = (int) D.6414;
        __result = D.6412 - D.6415;
        D.6416 = __s2_len > 1;
        D.6406 = __result == 0;
        D.6417 = D.6416 & D.6406;
        if (D.6417 != 0) goto <D.6418>; else goto <D.6419>;
        <D.6418>:
        D.6420 = &MEM[(void *)"" + 2B];
        D.6421 = *D.6420;
        D.6422 = (int) D.6421;
        D.6423 = __s2 + 2;
        D.6424 = *D.6423;
        D.6425 = (int) D.6424;
        __result = D.6422 - D.6425;
        D.6426 = __s2_len > 2;
        D.6406 = __result == 0;
        D.6427 = D.6426 & D.6406;
        if (D.6427 != 0) goto <D.6428>; else goto <D.6429>;
        <D.6428>:
        D.6430 = &MEM[(void *)"" + 3B];
        D.6431 = *D.6430;
        D.6432 = (int) D.6431;
        D.6433 = __s2 + 3;
        D.6434 = *D.6433;
        D.6435 = (int) D.6434;
        __result = D.6432 - D.6435;
        <D.6429>:
        <D.6419>:
        <D.6409>:
      }
      D.5096 = __result;
    }
    iftmp.13 = -D.5096;
    goto <D.6436>;
    <D.6399>:
    D.6009 = v + 8;
    D.6010 = *D.6009;
    D.6437 = MEM[(const unsigned char * {ref-all})D.6010];
    iftmp.13 = (int) D.6437;
    <D.6436>:
    D.5097 = iftmp.13;
  }
  if (D.5097 != 0) goto <D.6438>; else goto <D.6439>;
  <D.6438>:
  D.5908 = FAILED ("Invalid value 9");
  return D.5908;
  <D.6439>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.6441>; else goto <D.6442>;
    <D.6441>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 16B];
      D.6400 = "";
      D.6401 = MEM[(const unsigned char *)D.6400];
      D.6402 = (int) D.6401;
      D.6443 = *__s2;
      D.6444 = (int) D.6443;
      __result = D.6402 - D.6444;
      {
        D.6445 = __s2_len != 0;
        D.6446 = __result == 0;
        D.6447 = D.6445 & D.6446;
        if (D.6447 != 0) goto <D.6448>; else goto <D.6449>;
        <D.6448>:
        D.6410 = &MEM[(void *)"" + 1B];
        D.6411 = *D.6410;
        D.6412 = (int) D.6411;
        D.6450 = __s2 + 1;
        D.6451 = *D.6450;
        D.6452 = (int) D.6451;
        __result = D.6412 - D.6452;
        D.6453 = __s2_len > 1;
        D.6446 = __result == 0;
        D.6454 = D.6453 & D.6446;
        if (D.6454 != 0) goto <D.6455>; else goto <D.6456>;
        <D.6455>:
        D.6420 = &MEM[(void *)"" + 2B];
        D.6421 = *D.6420;
        D.6422 = (int) D.6421;
        D.6457 = __s2 + 2;
        D.6458 = *D.6457;
        D.6459 = (int) D.6458;
        __result = D.6422 - D.6459;
        D.6460 = __s2_len > 2;
        D.6446 = __result == 0;
        D.6461 = D.6460 & D.6446;
        if (D.6461 != 0) goto <D.6462>; else goto <D.6463>;
        <D.6462>:
        D.6430 = &MEM[(void *)"" + 3B];
        D.6431 = *D.6430;
        D.6432 = (int) D.6431;
        D.6464 = __s2 + 3;
        D.6465 = *D.6464;
        D.6466 = (int) D.6465;
        __result = D.6432 - D.6466;
        <D.6463>:
        <D.6456>:
        <D.6449>:
      }
      D.5105 = __result;
    }
    iftmp.14 = -D.5105;
    goto <D.6467>;
    <D.6442>:
    D.6053 = v + 16;
    D.6054 = *D.6053;
    D.6468 = MEM[(const unsigned char * {ref-all})D.6054];
    iftmp.14 = (int) D.6468;
    <D.6467>:
    D.5106 = iftmp.14;
  }
  if (D.5106 != 0) goto <D.6469>; else goto <D.6470>;
  <D.6469>:
  D.5908 = FAILED ("Invalid value 10");
  return D.5908;
  <D.6470>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 24B];
      D.6474 = "def";
      D.6475 = MEM[(const unsigned char *)D.6474];
      D.6476 = (int) D.6475;
      D.6477 = *__s2;
      D.6478 = (int) D.6477;
      __result = D.6476 - D.6478;
      {
        D.6479 = __s2_len != 0;
        D.6480 = __result == 0;
        D.6481 = D.6479 & D.6480;
        if (D.6481 != 0) goto <D.6482>; else goto <D.6483>;
        <D.6482>:
        D.6484 = &MEM[(void *)"def" + 1B];
        D.6485 = *D.6484;
        D.6486 = (int) D.6485;
        D.6487 = __s2 + 1;
        D.6488 = *D.6487;
        D.6489 = (int) D.6488;
        __result = D.6486 - D.6489;
        D.6490 = __s2_len > 1;
        D.6480 = __result == 0;
        D.6491 = D.6490 & D.6480;
        if (D.6491 != 0) goto <D.6492>; else goto <D.6493>;
        <D.6492>:
        D.6494 = &MEM[(void *)"def" + 2B];
        D.6495 = *D.6494;
        D.6496 = (int) D.6495;
        D.6497 = __s2 + 2;
        D.6498 = *D.6497;
        D.6499 = (int) D.6498;
        __result = D.6496 - D.6499;
        D.6500 = __s2_len > 2;
        D.6480 = __result == 0;
        D.6501 = D.6500 & D.6480;
        if (D.6501 != 0) goto <D.6502>; else goto <D.6503>;
        <D.6502>:
        D.6504 = &MEM[(void *)"def" + 3B];
        D.6505 = *D.6504;
        D.6506 = (int) D.6505;
        D.6507 = __s2 + 3;
        D.6508 = *D.6507;
        D.6509 = (int) D.6508;
        __result = D.6506 - D.6509;
        <D.6503>:
        <D.6493>:
        <D.6483>:
      }
      D.5114 = __result;
    }
    iftmp.15 = -D.5114;
    goto <D.6510>;
    <D.6473>:
    D.6057 = v + 24;
    D.6058 = *D.6057;
    iftmp.15 = __builtin_strcmp (D.6058, "def");
    <D.6510>:
    D.5115 = iftmp.15;
  }
  if (D.5115 != 0) goto <D.6511>; else goto <D.6512>;
  <D.6511>:
  D.5908 = FAILED ("Invalid value 11");
  return D.5908;
  <D.6512>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.6514>; else goto <D.6515>;
    <D.6514>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 32B];
      D.6400 = "";
      D.6401 = MEM[(const unsigned char *)D.6400];
      D.6402 = (int) D.6401;
      D.6516 = *__s2;
      D.6517 = (int) D.6516;
      __result = D.6402 - D.6517;
      {
        D.6518 = __s2_len != 0;
        D.6519 = __result == 0;
        D.6520 = D.6518 & D.6519;
        if (D.6520 != 0) goto <D.6521>; else goto <D.6522>;
        <D.6521>:
        D.6410 = &MEM[(void *)"" + 1B];
        D.6411 = *D.6410;
        D.6412 = (int) D.6411;
        D.6523 = __s2 + 1;
        D.6524 = *D.6523;
        D.6525 = (int) D.6524;
        __result = D.6412 - D.6525;
        D.6526 = __s2_len > 1;
        D.6519 = __result == 0;
        D.6527 = D.6526 & D.6519;
        if (D.6527 != 0) goto <D.6528>; else goto <D.6529>;
        <D.6528>:
        D.6420 = &MEM[(void *)"" + 2B];
        D.6421 = *D.6420;
        D.6422 = (int) D.6421;
        D.6530 = __s2 + 2;
        D.6531 = *D.6530;
        D.6532 = (int) D.6531;
        __result = D.6422 - D.6532;
        D.6533 = __s2_len > 2;
        D.6519 = __result == 0;
        D.6534 = D.6533 & D.6519;
        if (D.6534 != 0) goto <D.6535>; else goto <D.6536>;
        <D.6535>:
        D.6430 = &MEM[(void *)"" + 3B];
        D.6431 = *D.6430;
        D.6432 = (int) D.6431;
        D.6537 = __s2 + 3;
        D.6538 = *D.6537;
        D.6539 = (int) D.6538;
        __result = D.6432 - D.6539;
        <D.6536>:
        <D.6529>:
        <D.6522>:
      }
      D.5123 = __result;
    }
    iftmp.16 = -D.5123;
    goto <D.6540>;
    <D.6515>:
    D.6541 = v + 32;
    D.6542 = *D.6541;
    D.6543 = MEM[(const unsigned char * {ref-all})D.6542];
    iftmp.16 = (int) D.6543;
    <D.6540>:
    D.5124 = iftmp.16;
  }
  if (D.5124 != 0) goto <D.6544>; else goto <D.6545>;
  <D.6544>:
  D.5908 = FAILED ("Invalid value 12");
  return D.5908;
  <D.6545>:
  D.6546 = v + 40;
  D.6547 = *D.6546;
  if (D.6547 != 0B) goto <D.6548>; else goto <D.6549>;
  <D.6548>:
  D.5908 = FAILED ("Expected only 5 elements (4)");
  return D.5908;
  <D.6549>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit ("XYXYXYabcXYdef", "XY", -1);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.6551>; else goto <D.6552>;
    <D.6551>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = *v;
      D.6400 = "";
      D.6401 = MEM[(const unsigned char *)D.6400];
      D.6402 = (int) D.6401;
      D.6553 = *__s2;
      D.6554 = (int) D.6553;
      __result = D.6402 - D.6554;
      {
        D.6555 = __s2_len != 0;
        D.6556 = __result == 0;
        D.6557 = D.6555 & D.6556;
        if (D.6557 != 0) goto <D.6558>; else goto <D.6559>;
        <D.6558>:
        D.6410 = &MEM[(void *)"" + 1B];
        D.6411 = *D.6410;
        D.6412 = (int) D.6411;
        D.6560 = __s2 + 1;
        D.6561 = *D.6560;
        D.6562 = (int) D.6561;
        __result = D.6412 - D.6562;
        D.6563 = __s2_len > 1;
        D.6556 = __result == 0;
        D.6564 = D.6563 & D.6556;
        if (D.6564 != 0) goto <D.6565>; else goto <D.6566>;
        <D.6565>:
        D.6420 = &MEM[(void *)"" + 2B];
        D.6421 = *D.6420;
        D.6422 = (int) D.6421;
        D.6567 = __s2 + 2;
        D.6568 = *D.6567;
        D.6569 = (int) D.6568;
        __result = D.6422 - D.6569;
        D.6570 = __s2_len > 2;
        D.6556 = __result == 0;
        D.6571 = D.6570 & D.6556;
        if (D.6571 != 0) goto <D.6572>; else goto <D.6573>;
        <D.6572>:
        D.6430 = &MEM[(void *)"" + 3B];
        D.6431 = *D.6430;
        D.6432 = (int) D.6431;
        D.6574 = __s2 + 3;
        D.6575 = *D.6574;
        D.6576 = (int) D.6575;
        __result = D.6432 - D.6576;
        <D.6573>:
        <D.6566>:
        <D.6559>:
      }
      D.5132 = __result;
    }
    iftmp.17 = -D.5132;
    goto <D.6577>;
    <D.6552>:
    D.5919 = *v;
    D.6578 = MEM[(const unsigned char * {ref-all})D.5919];
    iftmp.17 = (int) D.6578;
    <D.6577>:
    D.5133 = iftmp.17;
  }
  if (D.5133 != 0) goto <D.6579>; else goto <D.6580>;
  <D.6579>:
  D.5908 = FAILED ("Invalid value 13");
  return D.5908;
  <D.6580>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.6582>; else goto <D.6583>;
    <D.6582>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 8B];
      D.6400 = "";
      D.6401 = MEM[(const unsigned char *)D.6400];
      D.6402 = (int) D.6401;
      D.6584 = *__s2;
      D.6585 = (int) D.6584;
      __result = D.6402 - D.6585;
      {
        D.6586 = __s2_len != 0;
        D.6587 = __result == 0;
        D.6588 = D.6586 & D.6587;
        if (D.6588 != 0) goto <D.6589>; else goto <D.6590>;
        <D.6589>:
        D.6410 = &MEM[(void *)"" + 1B];
        D.6411 = *D.6410;
        D.6412 = (int) D.6411;
        D.6591 = __s2 + 1;
        D.6592 = *D.6591;
        D.6593 = (int) D.6592;
        __result = D.6412 - D.6593;
        D.6594 = __s2_len > 1;
        D.6587 = __result == 0;
        D.6595 = D.6594 & D.6587;
        if (D.6595 != 0) goto <D.6596>; else goto <D.6597>;
        <D.6596>:
        D.6420 = &MEM[(void *)"" + 2B];
        D.6421 = *D.6420;
        D.6422 = (int) D.6421;
        D.6598 = __s2 + 2;
        D.6599 = *D.6598;
        D.6600 = (int) D.6599;
        __result = D.6422 - D.6600;
        D.6601 = __s2_len > 2;
        D.6587 = __result == 0;
        D.6602 = D.6601 & D.6587;
        if (D.6602 != 0) goto <D.6603>; else goto <D.6604>;
        <D.6603>:
        D.6430 = &MEM[(void *)"" + 3B];
        D.6431 = *D.6430;
        D.6432 = (int) D.6431;
        D.6605 = __s2 + 3;
        D.6606 = *D.6605;
        D.6607 = (int) D.6606;
        __result = D.6432 - D.6607;
        <D.6604>:
        <D.6597>:
        <D.6590>:
      }
      D.5141 = __result;
    }
    iftmp.18 = -D.5141;
    goto <D.6608>;
    <D.6583>:
    D.6009 = v + 8;
    D.6010 = *D.6009;
    D.6437 = MEM[(const unsigned char * {ref-all})D.6010];
    iftmp.18 = (int) D.6437;
    <D.6608>:
    D.5142 = iftmp.18;
  }
  if (D.5142 != 0) goto <D.6609>; else goto <D.6610>;
  <D.6609>:
  D.5908 = FAILED ("Invalid value 14");
  return D.5908;
  <D.6610>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.6612>; else goto <D.6613>;
    <D.6612>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 16B];
      D.6400 = "";
      D.6401 = MEM[(const unsigned char *)D.6400];
      D.6402 = (int) D.6401;
      D.6614 = *__s2;
      D.6615 = (int) D.6614;
      __result = D.6402 - D.6615;
      {
        D.6616 = __s2_len != 0;
        D.6617 = __result == 0;
        D.6618 = D.6616 & D.6617;
        if (D.6618 != 0) goto <D.6619>; else goto <D.6620>;
        <D.6619>:
        D.6410 = &MEM[(void *)"" + 1B];
        D.6411 = *D.6410;
        D.6412 = (int) D.6411;
        D.6621 = __s2 + 1;
        D.6622 = *D.6621;
        D.6623 = (int) D.6622;
        __result = D.6412 - D.6623;
        D.6624 = __s2_len > 1;
        D.6617 = __result == 0;
        D.6625 = D.6624 & D.6617;
        if (D.6625 != 0) goto <D.6626>; else goto <D.6627>;
        <D.6626>:
        D.6420 = &MEM[(void *)"" + 2B];
        D.6421 = *D.6420;
        D.6422 = (int) D.6421;
        D.6628 = __s2 + 2;
        D.6629 = *D.6628;
        D.6630 = (int) D.6629;
        __result = D.6422 - D.6630;
        D.6631 = __s2_len > 2;
        D.6617 = __result == 0;
        D.6632 = D.6631 & D.6617;
        if (D.6632 != 0) goto <D.6633>; else goto <D.6634>;
        <D.6633>:
        D.6430 = &MEM[(void *)"" + 3B];
        D.6431 = *D.6430;
        D.6432 = (int) D.6431;
        D.6635 = __s2 + 3;
        D.6636 = *D.6635;
        D.6637 = (int) D.6636;
        __result = D.6432 - D.6637;
        <D.6634>:
        <D.6627>:
        <D.6620>:
      }
      D.5150 = __result;
    }
    iftmp.19 = -D.5150;
    goto <D.6638>;
    <D.6613>:
    D.6053 = v + 16;
    D.6054 = *D.6053;
    D.6468 = MEM[(const unsigned char * {ref-all})D.6054];
    iftmp.19 = (int) D.6468;
    <D.6638>:
    D.5151 = iftmp.19;
  }
  if (D.5151 != 0) goto <D.6639>; else goto <D.6640>;
  <D.6639>:
  D.5908 = FAILED ("Invalid value 15");
  return D.5908;
  <D.6640>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 24B];
      D.6064 = "abc";
      D.6065 = MEM[(const unsigned char *)D.6064];
      D.6066 = (int) D.6065;
      D.6644 = *__s2;
      D.6645 = (int) D.6644;
      __result = D.6066 - D.6645;
      {
        D.6646 = __s2_len != 0;
        D.6647 = __result == 0;
        D.6648 = D.6646 & D.6647;
        if (D.6648 != 0) goto <D.6649>; else goto <D.6650>;
        <D.6649>:
        D.6074 = &MEM[(void *)"abc" + 1B];
        D.6075 = *D.6074;
        D.6076 = (int) D.6075;
        D.6651 = __s2 + 1;
        D.6652 = *D.6651;
        D.6653 = (int) D.6652;
        __result = D.6076 - D.6653;
        D.6654 = __s2_len > 1;
        D.6647 = __result == 0;
        D.6655 = D.6654 & D.6647;
        if (D.6655 != 0) goto <D.6656>; else goto <D.6657>;
        <D.6656>:
        D.6084 = &MEM[(void *)"abc" + 2B];
        D.6085 = *D.6084;
        D.6086 = (int) D.6085;
        D.6658 = __s2 + 2;
        D.6659 = *D.6658;
        D.6660 = (int) D.6659;
        __result = D.6086 - D.6660;
        D.6661 = __s2_len > 2;
        D.6647 = __result == 0;
        D.6662 = D.6661 & D.6647;
        if (D.6662 != 0) goto <D.6663>; else goto <D.6664>;
        <D.6663>:
        D.6094 = &MEM[(void *)"abc" + 3B];
        D.6095 = *D.6094;
        D.6096 = (int) D.6095;
        D.6665 = __s2 + 3;
        D.6666 = *D.6665;
        D.6667 = (int) D.6666;
        __result = D.6096 - D.6667;
        <D.6664>:
        <D.6657>:
        <D.6650>:
      }
      D.5159 = __result;
    }
    iftmp.20 = -D.5159;
    goto <D.6668>;
    <D.6643>:
    D.6057 = v + 24;
    D.6058 = *D.6057;
    iftmp.20 = __builtin_strcmp (D.6058, "abc");
    <D.6668>:
    D.5160 = iftmp.20;
  }
  if (D.5160 != 0) goto <D.6669>; else goto <D.6670>;
  <D.6669>:
  D.5908 = FAILED ("Invalid value 16");
  return D.5908;
  <D.6670>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 32B];
      D.6474 = "def";
      D.6475 = MEM[(const unsigned char *)D.6474];
      D.6476 = (int) D.6475;
      D.6674 = *__s2;
      D.6675 = (int) D.6674;
      __result = D.6476 - D.6675;
      {
        D.6676 = __s2_len != 0;
        D.6677 = __result == 0;
        D.6678 = D.6676 & D.6677;
        if (D.6678 != 0) goto <D.6679>; else goto <D.6680>;
        <D.6679>:
        D.6484 = &MEM[(void *)"def" + 1B];
        D.6485 = *D.6484;
        D.6486 = (int) D.6485;
        D.6681 = __s2 + 1;
        D.6682 = *D.6681;
        D.6683 = (int) D.6682;
        __result = D.6486 - D.6683;
        D.6684 = __s2_len > 1;
        D.6677 = __result == 0;
        D.6685 = D.6684 & D.6677;
        if (D.6685 != 0) goto <D.6686>; else goto <D.6687>;
        <D.6686>:
        D.6494 = &MEM[(void *)"def" + 2B];
        D.6495 = *D.6494;
        D.6496 = (int) D.6495;
        D.6688 = __s2 + 2;
        D.6689 = *D.6688;
        D.6690 = (int) D.6689;
        __result = D.6496 - D.6690;
        D.6691 = __s2_len > 2;
        D.6677 = __result == 0;
        D.6692 = D.6691 & D.6677;
        if (D.6692 != 0) goto <D.6693>; else goto <D.6694>;
        <D.6693>:
        D.6504 = &MEM[(void *)"def" + 3B];
        D.6505 = *D.6504;
        D.6506 = (int) D.6505;
        D.6695 = __s2 + 3;
        D.6696 = *D.6695;
        D.6697 = (int) D.6696;
        __result = D.6506 - D.6697;
        <D.6694>:
        <D.6687>:
        <D.6680>:
      }
      D.5168 = __result;
    }
    iftmp.21 = -D.5168;
    goto <D.6698>;
    <D.6673>:
    D.6541 = v + 32;
    D.6542 = *D.6541;
    iftmp.21 = __builtin_strcmp (D.6542, "def");
    <D.6698>:
    D.5169 = iftmp.21;
  }
  if (D.5169 != 0) goto <D.6699>; else goto <D.6700>;
  <D.6699>:
  D.5908 = FAILED ("Invalid value 17");
  return D.5908;
  <D.6700>:
  D.6546 = v + 40;
  D.6547 = *D.6546;
  if (D.6547 != 0B) goto <D.6701>; else goto <D.6702>;
  <D.6701>:
  D.5908 = FAILED ("Expected only 5 elements (5)");
  return D.5908;
  <D.6702>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit ("value=", "=", 2);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.6706 = "value";
      D.6707 = MEM[(const unsigned char *)D.6706];
      D.6708 = (int) D.6707;
      D.6709 = *__s2;
      D.6710 = (int) D.6709;
      __result = D.6708 - D.6710;
      {
        D.6711 = __s2_len != 0;
        D.6712 = __result == 0;
        D.6713 = D.6711 & D.6712;
        if (D.6713 != 0) goto <D.6714>; else goto <D.6715>;
        <D.6714>:
        D.6716 = &MEM[(void *)"value" + 1B];
        D.6717 = *D.6716;
        D.6718 = (int) D.6717;
        D.6719 = __s2 + 1;
        D.6720 = *D.6719;
        D.6721 = (int) D.6720;
        __result = D.6718 - D.6721;
        D.6722 = __s2_len > 1;
        D.6712 = __result == 0;
        D.6723 = D.6722 & D.6712;
        if (D.6723 != 0) goto <D.6724>; else goto <D.6725>;
        <D.6724>:
        D.6726 = &MEM[(void *)"value" + 2B];
        D.6727 = *D.6726;
        D.6728 = (int) D.6727;
        D.6729 = __s2 + 2;
        D.6730 = *D.6729;
        D.6731 = (int) D.6730;
        __result = D.6728 - D.6731;
        D.6732 = __s2_len > 2;
        D.6712 = __result == 0;
        D.6733 = D.6732 & D.6712;
        if (D.6733 != 0) goto <D.6734>; else goto <D.6735>;
        <D.6734>:
        D.6736 = &MEM[(void *)"value" + 3B];
        D.6737 = *D.6736;
        D.6738 = (int) D.6737;
        D.6739 = __s2 + 3;
        D.6740 = *D.6739;
        D.6741 = (int) D.6740;
        __result = D.6738 - D.6741;
        <D.6735>:
        <D.6725>:
        <D.6715>:
      }
      D.5177 = __result;
    }
    iftmp.22 = -D.5177;
    goto <D.6742>;
    <D.6705>:
    D.5919 = *v;
    iftmp.22 = __builtin_strcmp (D.5919, "value");
    <D.6742>:
    D.5178 = iftmp.22;
  }
  if (D.5178 != 0) goto <D.6743>; else goto <D.6744>;
  <D.6743>:
  D.5919 = *v;
  D.5908 = FAILED ("Invalid value 18; expected \'value\', got \'%s\'", D.5919);
  return D.5908;
  <D.6744>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.6746>; else goto <D.6747>;
    <D.6746>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 8B];
      D.6400 = "";
      D.6401 = MEM[(const unsigned char *)D.6400];
      D.6402 = (int) D.6401;
      D.6748 = *__s2;
      D.6749 = (int) D.6748;
      __result = D.6402 - D.6749;
      {
        D.6750 = __s2_len != 0;
        D.6751 = __result == 0;
        D.6752 = D.6750 & D.6751;
        if (D.6752 != 0) goto <D.6753>; else goto <D.6754>;
        <D.6753>:
        D.6410 = &MEM[(void *)"" + 1B];
        D.6411 = *D.6410;
        D.6412 = (int) D.6411;
        D.6755 = __s2 + 1;
        D.6756 = *D.6755;
        D.6757 = (int) D.6756;
        __result = D.6412 - D.6757;
        D.6758 = __s2_len > 1;
        D.6751 = __result == 0;
        D.6759 = D.6758 & D.6751;
        if (D.6759 != 0) goto <D.6760>; else goto <D.6761>;
        <D.6760>:
        D.6420 = &MEM[(void *)"" + 2B];
        D.6421 = *D.6420;
        D.6422 = (int) D.6421;
        D.6762 = __s2 + 2;
        D.6763 = *D.6762;
        D.6764 = (int) D.6763;
        __result = D.6422 - D.6764;
        D.6765 = __s2_len > 2;
        D.6751 = __result == 0;
        D.6766 = D.6765 & D.6751;
        if (D.6766 != 0) goto <D.6767>; else goto <D.6768>;
        <D.6767>:
        D.6430 = &MEM[(void *)"" + 3B];
        D.6431 = *D.6430;
        D.6432 = (int) D.6431;
        D.6769 = __s2 + 3;
        D.6770 = *D.6769;
        D.6771 = (int) D.6770;
        __result = D.6432 - D.6771;
        <D.6768>:
        <D.6761>:
        <D.6754>:
      }
      D.5186 = __result;
    }
    iftmp.23 = -D.5186;
    goto <D.6772>;
    <D.6747>:
    D.6009 = v + 8;
    D.6010 = *D.6009;
    D.6437 = MEM[(const unsigned char * {ref-all})D.6010];
    iftmp.23 = (int) D.6437;
    <D.6772>:
    D.5187 = iftmp.23;
  }
  if (D.5187 != 0) goto <D.6773>; else goto <D.6774>;
  <D.6773>:
  D.6009 = v + 8;
  D.6010 = *D.6009;
  D.5908 = FAILED ("Invalid value 19; expected \'\', got \'%s\'", D.6010);
  return D.5908;
  <D.6774>:
  D.6053 = v + 16;
  D.6054 = *D.6053;
  if (D.6054 != 0B) goto <D.6775>; else goto <D.6776>;
  <D.6775>:
  D.5908 = FAILED ("Expected only 2 elements (6)");
  return D.5908;
  <D.6776>:
  monoeg_g_strfreev (v);
  D.5908 = 0B;
  return D.5908;
}


test_split_set ()
{
  int D.5199;
  int iftmp.24;
  int D.5198;
  char[4] * D.6781;
  unsigned char D.6782;
  int D.6783;
  unsigned char D.6784;
  int D.6785;
  _Bool D.6786;
  _Bool D.6787;
  _Bool D.6788;
  const unsigned char * D.6791;
  unsigned char D.6792;
  int D.6793;
  const unsigned char * D.6794;
  unsigned char D.6795;
  int D.6796;
  _Bool D.6797;
  _Bool D.6798;
  const unsigned char * D.6801;
  unsigned char D.6802;
  int D.6803;
  const unsigned char * D.6804;
  unsigned char D.6805;
  int D.6806;
  _Bool D.6807;
  _Bool D.6808;
  const unsigned char * D.6811;
  unsigned char D.6812;
  int D.6813;
  const unsigned char * D.6814;
  unsigned char D.6815;
  int D.6816;
  gchar * D.6818;
  gchar * D.6821;
  int D.5208;
  int iftmp.25;
  int D.5207;
  char[1] * D.6825;
  unsigned char D.6826;
  int D.6827;
  unsigned char D.6828;
  int D.6829;
  _Bool D.6830;
  _Bool D.6831;
  _Bool D.6832;
  const unsigned char * D.6835;
  unsigned char D.6836;
  int D.6837;
  const unsigned char * D.6838;
  unsigned char D.6839;
  int D.6840;
  _Bool D.6841;
  _Bool D.6842;
  const unsigned char * D.6845;
  unsigned char D.6846;
  int D.6847;
  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;
  const unsigned char * D.6858;
  unsigned char D.6859;
  int D.6860;
  gchar * * D.6862;
  gchar * D.6863;
  unsigned char D.6864;
  int D.5217;
  int iftmp.26;
  int D.5216;
  char[4] * D.6870;
  unsigned char D.6871;
  int D.6872;
  unsigned char D.6873;
  int D.6874;
  _Bool D.6875;
  _Bool D.6876;
  _Bool D.6877;
  const unsigned char * D.6880;
  unsigned char D.6881;
  int D.6882;
  const unsigned char * D.6883;
  unsigned char D.6884;
  int D.6885;
  _Bool D.6886;
  _Bool D.6887;
  const unsigned char * D.6890;
  unsigned char D.6891;
  int D.6892;
  const unsigned char * D.6893;
  unsigned char D.6894;
  int D.6895;
  _Bool D.6896;
  _Bool D.6897;
  const unsigned char * D.6900;
  unsigned char D.6901;
  int D.6902;
  const unsigned char * D.6903;
  unsigned char D.6904;
  int D.6905;
  gchar * * D.6907;
  gchar * D.6908;
  int D.5226;
  int iftmp.27;
  int D.5225;
  char[4] * D.6914;
  unsigned char D.6915;
  int D.6916;
  unsigned char D.6917;
  int D.6918;
  _Bool D.6919;
  _Bool D.6920;
  _Bool D.6921;
  const unsigned char * D.6924;
  unsigned char D.6925;
  int D.6926;
  const unsigned char * D.6927;
  unsigned char D.6928;
  int D.6929;
  _Bool D.6930;
  _Bool D.6931;
  const unsigned char * D.6934;
  unsigned char D.6935;
  int D.6936;
  const unsigned char * D.6937;
  unsigned char D.6938;
  int D.6939;
  _Bool D.6940;
  _Bool D.6941;
  const unsigned char * D.6944;
  unsigned char D.6945;
  int D.6946;
  const unsigned char * D.6947;
  unsigned char D.6948;
  int D.6949;
  gchar * * D.6951;
  gchar * D.6952;
  int D.5235;
  int iftmp.28;
  int D.5234;
  unsigned char D.6958;
  int D.6959;
  _Bool D.6960;
  _Bool D.6961;
  _Bool D.6962;
  const unsigned char * D.6965;
  unsigned char D.6966;
  int D.6967;
  _Bool D.6968;
  _Bool D.6969;
  const unsigned char * D.6972;
  unsigned char D.6973;
  int D.6974;
  _Bool D.6975;
  _Bool D.6976;
  const unsigned char * D.6979;
  unsigned char D.6980;
  int D.6981;
  gchar * * D.6983;
  gchar * D.6984;
  unsigned char D.6985;
  int D.5244;
  int iftmp.29;
  int D.5243;
  char[8] * D.6991;
  unsigned char D.6992;
  int D.6993;
  unsigned char D.6994;
  int D.6995;
  _Bool D.6996;
  _Bool D.6997;
  _Bool D.6998;
  const unsigned char * D.7001;
  unsigned char D.7002;
  int D.7003;
  const unsigned char * D.7004;
  unsigned char D.7005;
  int D.7006;
  _Bool D.7007;
  _Bool D.7008;
  const unsigned char * D.7011;
  unsigned char D.7012;
  int D.7013;
  const unsigned char * D.7014;
  unsigned char D.7015;
  int D.7016;
  _Bool D.7017;
  _Bool D.7018;
  const unsigned char * D.7021;
  unsigned char D.7022;
  int D.7023;
  const unsigned char * D.7024;
  unsigned char D.7025;
  int D.7026;
  gchar * * D.7028;
  gchar * D.7029;
  gchar * * D.7032;
  gchar * D.7033;
  int D.5253;
  int iftmp.30;
  int D.5252;
  unsigned char D.7039;
  int D.7040;
  _Bool D.7041;
  _Bool D.7042;
  _Bool D.7043;
  const unsigned char * D.7046;
  unsigned char D.7047;
  int D.7048;
  _Bool D.7049;
  _Bool D.7050;
  const unsigned char * D.7053;
  unsigned char D.7054;
  int D.7055;
  _Bool D.7056;
  _Bool D.7057;
  const unsigned char * D.7060;
  unsigned char D.7061;
  int D.7062;
  int D.5262;
  int iftmp.31;
  int D.5261;
  unsigned char D.7069;
  int D.7070;
  _Bool D.7071;
  _Bool D.7072;
  _Bool D.7073;
  const unsigned char * D.7076;
  unsigned char D.7077;
  int D.7078;
  _Bool D.7079;
  _Bool D.7080;
  const unsigned char * D.7083;
  unsigned char D.7084;
  int D.7085;
  _Bool D.7086;
  _Bool D.7087;
  const unsigned char * D.7090;
  unsigned char D.7091;
  int D.7092;
  int D.5271;
  int iftmp.32;
  int D.5270;
  char[17] * D.7099;
  unsigned char D.7100;
  int D.7101;
  unsigned char D.7102;
  int D.7103;
  _Bool D.7104;
  _Bool D.7105;
  _Bool D.7106;
  const unsigned char * D.7109;
  unsigned char D.7110;
  int D.7111;
  const unsigned char * D.7112;
  unsigned char D.7113;
  int D.7114;
  _Bool D.7115;
  _Bool D.7116;
  const unsigned char * D.7119;
  unsigned char D.7120;
  int D.7121;
  const unsigned char * D.7122;
  unsigned char D.7123;
  int D.7124;
  _Bool D.7125;
  _Bool D.7126;
  const unsigned char * D.7129;
  unsigned char D.7130;
  int D.7131;
  const unsigned char * D.7132;
  unsigned char D.7133;
  int D.7134;
  int D.5280;
  int iftmp.33;
  int D.5279;
  unsigned char D.7143;
  int D.7144;
  _Bool D.7145;
  _Bool D.7146;
  _Bool D.7147;
  const unsigned char * D.7150;
  unsigned char D.7151;
  int D.7152;
  _Bool D.7153;
  _Bool D.7154;
  const unsigned char * D.7157;
  unsigned char D.7158;
  int D.7159;
  _Bool D.7160;
  _Bool D.7161;
  const unsigned char * D.7164;
  unsigned char D.7165;
  int D.7166;
  int D.5289;
  int iftmp.34;
  int D.5288;
  unsigned char D.7173;
  int D.7174;
  _Bool D.7175;
  _Bool D.7176;
  _Bool D.7177;
  const unsigned char * D.7180;
  unsigned char D.7181;
  int D.7182;
  _Bool D.7183;
  _Bool D.7184;
  const unsigned char * D.7187;
  unsigned char D.7188;
  int D.7189;
  _Bool D.7190;
  _Bool D.7191;
  const unsigned char * D.7194;
  unsigned char D.7195;
  int D.7196;
  int D.5298;
  int iftmp.35;
  int D.5297;
  unsigned char D.7203;
  int D.7204;
  _Bool D.7205;
  _Bool D.7206;
  _Bool D.7207;
  const unsigned char * D.7210;
  unsigned char D.7211;
  int D.7212;
  _Bool D.7213;
  _Bool D.7214;
  const unsigned char * D.7217;
  unsigned char D.7218;
  int D.7219;
  _Bool D.7220;
  _Bool D.7221;
  const unsigned char * D.7224;
  unsigned char D.7225;
  int D.7226;
  int D.5307;
  int iftmp.36;
  int D.5306;
  char[4] * D.7233;
  unsigned char D.7234;
  int D.7235;
  unsigned char D.7236;
  int D.7237;
  _Bool D.7238;
  _Bool D.7239;
  _Bool D.7240;
  const unsigned char * D.7243;
  unsigned char D.7244;
  int D.7245;
  const unsigned char * D.7246;
  unsigned char D.7247;
  int D.7248;
  _Bool D.7249;
  _Bool D.7250;
  const unsigned char * D.7253;
  unsigned char D.7254;
  int D.7255;
  const unsigned char * D.7256;
  unsigned char D.7257;
  int D.7258;
  _Bool D.7259;
  _Bool D.7260;
  const unsigned char * D.7263;
  unsigned char D.7264;
  int D.7265;
  const unsigned char * D.7266;
  unsigned char D.7267;
  int D.7268;
  int D.5316;
  int iftmp.37;
  int D.5315;
  char[5] * D.7275;
  unsigned char D.7276;
  int D.7277;
  unsigned char D.7278;
  int D.7279;
  _Bool D.7280;
  _Bool D.7281;
  _Bool D.7282;
  const unsigned char * D.7285;
  unsigned char D.7286;
  int D.7287;
  const unsigned char * D.7288;
  unsigned char D.7289;
  int D.7290;
  _Bool D.7291;
  _Bool D.7292;
  const unsigned char * D.7295;
  unsigned char D.7296;
  int D.7297;
  const unsigned char * D.7298;
  unsigned char D.7299;
  int D.7300;
  _Bool D.7301;
  _Bool D.7302;
  const unsigned char * D.7305;
  unsigned char D.7306;
  int D.7307;
  const unsigned char * D.7308;
  unsigned char D.7309;
  int D.7310;
  int D.5325;
  int iftmp.38;
  int D.5324;
  unsigned char D.7319;
  int D.7320;
  _Bool D.7321;
  _Bool D.7322;
  _Bool D.7323;
  const unsigned char * D.7326;
  unsigned char D.7327;
  int D.7328;
  _Bool D.7329;
  _Bool D.7330;
  const unsigned char * D.7333;
  unsigned char D.7334;
  int D.7335;
  _Bool D.7336;
  _Bool D.7337;
  const unsigned char * D.7340;
  unsigned char D.7341;
  int D.7342;
  int D.5334;
  int iftmp.39;
  int D.5333;
  unsigned char D.7349;
  int D.7350;
  _Bool D.7351;
  _Bool D.7352;
  _Bool D.7353;
  const unsigned char * D.7356;
  unsigned char D.7357;
  int D.7358;
  _Bool D.7359;
  _Bool D.7360;
  const unsigned char * D.7363;
  unsigned char D.7364;
  int D.7365;
  _Bool D.7366;
  _Bool D.7367;
  const unsigned char * D.7370;
  unsigned char D.7371;
  int D.7372;
  int D.5343;
  int iftmp.40;
  int D.5342;
  unsigned char D.7379;
  int D.7380;
  _Bool D.7381;
  _Bool D.7382;
  _Bool D.7383;
  const unsigned char * D.7386;
  unsigned char D.7387;
  int D.7388;
  _Bool D.7389;
  _Bool D.7390;
  const unsigned char * D.7393;
  unsigned char D.7394;
  int D.7395;
  _Bool D.7396;
  _Bool D.7397;
  const unsigned char * D.7400;
  unsigned char D.7401;
  int D.7402;
  unsigned char D.7404;
  int D.5352;
  int iftmp.41;
  int D.5351;
  unsigned char D.7410;
  int D.7411;
  _Bool D.7412;
  _Bool D.7413;
  _Bool D.7414;
  const unsigned char * D.7417;
  unsigned char D.7418;
  int D.7419;
  _Bool D.7420;
  _Bool D.7421;
  const unsigned char * D.7424;
  unsigned char D.7425;
  int D.7426;
  _Bool D.7427;
  _Bool D.7428;
  const unsigned char * D.7431;
  unsigned char D.7432;
  int D.7433;
  int D.5361;
  int iftmp.42;
  int D.5360;
  unsigned char D.7440;
  int D.7441;
  _Bool D.7442;
  _Bool D.7443;
  _Bool D.7444;
  const unsigned char * D.7447;
  unsigned char D.7448;
  int D.7449;
  _Bool D.7450;
  _Bool D.7451;
  const unsigned char * D.7454;
  unsigned char D.7455;
  int D.7456;
  _Bool D.7457;
  _Bool D.7458;
  const unsigned char * D.7461;
  unsigned char D.7462;
  int D.7463;
  int D.5370;
  int iftmp.43;
  int D.5369;
  unsigned char D.7470;
  int D.7471;
  _Bool D.7472;
  _Bool D.7473;
  _Bool D.7474;
  const unsigned char * D.7477;
  unsigned char D.7478;
  int D.7479;
  _Bool D.7480;
  _Bool D.7481;
  const unsigned char * D.7484;
  unsigned char D.7485;
  int D.7486;
  _Bool D.7487;
  _Bool D.7488;
  const unsigned char * D.7491;
  unsigned char D.7492;
  int D.7493;
  unsigned char D.7495;
  int D.5379;
  int iftmp.44;
  int D.5378;
  unsigned char D.7503;
  int D.7504;
  _Bool D.7505;
  _Bool D.7506;
  _Bool D.7507;
  const unsigned char * D.7510;
  unsigned char D.7511;
  int D.7512;
  _Bool D.7513;
  _Bool D.7514;
  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;
  unsigned char D.7528;
  int D.5388;
  int iftmp.45;
  int D.5387;
  unsigned char D.7534;
  int D.7535;
  _Bool D.7536;
  _Bool D.7537;
  _Bool D.7538;
  const unsigned char * D.7541;
  unsigned char D.7542;
  int D.7543;
  _Bool D.7544;
  _Bool D.7545;
  const unsigned char * D.7548;
  unsigned char D.7549;
  int D.7550;
  _Bool D.7551;
  _Bool D.7552;
  const unsigned char * D.7555;
  unsigned char D.7556;
  int D.7557;
  int D.5397;
  int iftmp.46;
  int D.5396;
  unsigned char D.7564;
  int D.7565;
  _Bool D.7566;
  _Bool D.7567;
  _Bool D.7568;
  const unsigned char * D.7571;
  unsigned char D.7572;
  int D.7573;
  _Bool D.7574;
  _Bool D.7575;
  const unsigned char * D.7578;
  unsigned char D.7579;
  int D.7580;
  _Bool D.7581;
  _Bool D.7582;
  const unsigned char * D.7585;
  unsigned char D.7586;
  int D.7587;
  int D.5406;
  int iftmp.47;
  int D.5405;
  unsigned char D.7594;
  int D.7595;
  _Bool D.7596;
  _Bool D.7597;
  _Bool D.7598;
  const unsigned char * D.7601;
  unsigned char D.7602;
  int D.7603;
  _Bool D.7604;
  _Bool D.7605;
  const unsigned char * D.7608;
  unsigned char D.7609;
  int D.7610;
  _Bool D.7611;
  _Bool D.7612;
  const unsigned char * D.7615;
  unsigned char D.7616;
  int D.7617;
  int D.5415;
  int iftmp.48;
  int D.5414;
  unsigned char D.7624;
  int D.7625;
  _Bool D.7626;
  _Bool D.7627;
  _Bool D.7628;
  const unsigned char * D.7631;
  unsigned char D.7632;
  int D.7633;
  _Bool D.7634;
  _Bool D.7635;
  const unsigned char * D.7638;
  unsigned char D.7639;
  int D.7640;
  _Bool D.7641;
  _Bool D.7642;
  const unsigned char * D.7645;
  unsigned char D.7646;
  int D.7647;
  int D.5424;
  int iftmp.49;
  int D.5423;
  unsigned char D.7654;
  int D.7655;
  _Bool D.7656;
  _Bool D.7657;
  _Bool D.7658;
  const unsigned char * D.7661;
  unsigned char D.7662;
  int D.7663;
  _Bool D.7664;
  _Bool D.7665;
  const unsigned char * D.7668;
  unsigned char D.7669;
  int D.7670;
  _Bool D.7671;
  _Bool D.7672;
  const unsigned char * D.7675;
  unsigned char D.7676;
  int D.7677;
  gchar * * v;

  v = monoeg_g_strsplit_set ("abcXYdefXghiXYjklYmno", "XY", 6);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.6781 = "abc";
      D.6782 = MEM[(const unsigned char *)D.6781];
      D.6783 = (int) D.6782;
      D.6784 = *__s2;
      D.6785 = (int) D.6784;
      __result = D.6783 - D.6785;
      {
        D.6786 = __s2_len != 0;
        D.6787 = __result == 0;
        D.6788 = D.6786 & D.6787;
        if (D.6788 != 0) goto <D.6789>; else goto <D.6790>;
        <D.6789>:
        D.6791 = &MEM[(void *)"abc" + 1B];
        D.6792 = *D.6791;
        D.6793 = (int) D.6792;
        D.6794 = __s2 + 1;
        D.6795 = *D.6794;
        D.6796 = (int) D.6795;
        __result = D.6793 - D.6796;
        D.6797 = __s2_len > 1;
        D.6787 = __result == 0;
        D.6798 = D.6797 & D.6787;
        if (D.6798 != 0) goto <D.6799>; else goto <D.6800>;
        <D.6799>:
        D.6801 = &MEM[(void *)"abc" + 2B];
        D.6802 = *D.6801;
        D.6803 = (int) D.6802;
        D.6804 = __s2 + 2;
        D.6805 = *D.6804;
        D.6806 = (int) D.6805;
        __result = D.6803 - D.6806;
        D.6807 = __s2_len > 2;
        D.6787 = __result == 0;
        D.6808 = D.6807 & D.6787;
        if (D.6808 != 0) goto <D.6809>; else goto <D.6810>;
        <D.6809>:
        D.6811 = &MEM[(void *)"abc" + 3B];
        D.6812 = *D.6811;
        D.6813 = (int) D.6812;
        D.6814 = __s2 + 3;
        D.6815 = *D.6814;
        D.6816 = (int) D.6815;
        __result = D.6813 - D.6816;
        <D.6810>:
        <D.6800>:
        <D.6790>:
      }
      D.5198 = __result;
    }
    iftmp.24 = -D.5198;
    goto <D.6817>;
    <D.6780>:
    D.6818 = *v;
    iftmp.24 = __builtin_strcmp (D.6818, "abc");
    <D.6817>:
    D.5199 = iftmp.24;
  }
  if (D.5199 != 0) goto <D.6819>; else goto <D.6820>;
  <D.6819>:
  D.6821 = FAILED ("Invalid value 0");
  return D.6821;
  <D.6820>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.6823>; else goto <D.6824>;
    <D.6823>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 8B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.6828 = *__s2;
      D.6829 = (int) D.6828;
      __result = D.6827 - D.6829;
      {
        D.6830 = __s2_len != 0;
        D.6831 = __result == 0;
        D.6832 = D.6830 & D.6831;
        if (D.6832 != 0) goto <D.6833>; else goto <D.6834>;
        <D.6833>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.6838 = __s2 + 1;
        D.6839 = *D.6838;
        D.6840 = (int) D.6839;
        __result = D.6837 - D.6840;
        D.6841 = __s2_len > 1;
        D.6831 = __result == 0;
        D.6842 = D.6841 & D.6831;
        if (D.6842 != 0) goto <D.6843>; else goto <D.6844>;
        <D.6843>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.6848 = __s2 + 2;
        D.6849 = *D.6848;
        D.6850 = (int) D.6849;
        __result = D.6847 - D.6850;
        D.6851 = __s2_len > 2;
        D.6831 = __result == 0;
        D.6852 = D.6851 & D.6831;
        if (D.6852 != 0) goto <D.6853>; else goto <D.6854>;
        <D.6853>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.6858 = __s2 + 3;
        D.6859 = *D.6858;
        D.6860 = (int) D.6859;
        __result = D.6857 - D.6860;
        <D.6854>:
        <D.6844>:
        <D.6834>:
      }
      D.5207 = __result;
    }
    iftmp.25 = -D.5207;
    goto <D.6861>;
    <D.6824>:
    D.6862 = v + 8;
    D.6863 = *D.6862;
    D.6864 = MEM[(const unsigned char * {ref-all})D.6863];
    iftmp.25 = (int) D.6864;
    <D.6861>:
    D.5208 = iftmp.25;
  }
  if (D.5208 != 0) goto <D.6865>; else goto <D.6866>;
  <D.6865>:
  D.6821 = FAILED ("Invalid value 1");
  return D.6821;
  <D.6866>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 16B];
      D.6870 = "def";
      D.6871 = MEM[(const unsigned char *)D.6870];
      D.6872 = (int) D.6871;
      D.6873 = *__s2;
      D.6874 = (int) D.6873;
      __result = D.6872 - D.6874;
      {
        D.6875 = __s2_len != 0;
        D.6876 = __result == 0;
        D.6877 = D.6875 & D.6876;
        if (D.6877 != 0) goto <D.6878>; else goto <D.6879>;
        <D.6878>:
        D.6880 = &MEM[(void *)"def" + 1B];
        D.6881 = *D.6880;
        D.6882 = (int) D.6881;
        D.6883 = __s2 + 1;
        D.6884 = *D.6883;
        D.6885 = (int) D.6884;
        __result = D.6882 - D.6885;
        D.6886 = __s2_len > 1;
        D.6876 = __result == 0;
        D.6887 = D.6886 & D.6876;
        if (D.6887 != 0) goto <D.6888>; else goto <D.6889>;
        <D.6888>:
        D.6890 = &MEM[(void *)"def" + 2B];
        D.6891 = *D.6890;
        D.6892 = (int) D.6891;
        D.6893 = __s2 + 2;
        D.6894 = *D.6893;
        D.6895 = (int) D.6894;
        __result = D.6892 - D.6895;
        D.6896 = __s2_len > 2;
        D.6876 = __result == 0;
        D.6897 = D.6896 & D.6876;
        if (D.6897 != 0) goto <D.6898>; else goto <D.6899>;
        <D.6898>:
        D.6900 = &MEM[(void *)"def" + 3B];
        D.6901 = *D.6900;
        D.6902 = (int) D.6901;
        D.6903 = __s2 + 3;
        D.6904 = *D.6903;
        D.6905 = (int) D.6904;
        __result = D.6902 - D.6905;
        <D.6899>:
        <D.6889>:
        <D.6879>:
      }
      D.5216 = __result;
    }
    iftmp.26 = -D.5216;
    goto <D.6906>;
    <D.6869>:
    D.6907 = v + 16;
    D.6908 = *D.6907;
    iftmp.26 = __builtin_strcmp (D.6908, "def");
    <D.6906>:
    D.5217 = iftmp.26;
  }
  if (D.5217 != 0) goto <D.6909>; else goto <D.6910>;
  <D.6909>:
  D.6821 = FAILED ("Invalid value 2");
  return D.6821;
  <D.6910>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 24B];
      D.6914 = "ghi";
      D.6915 = MEM[(const unsigned char *)D.6914];
      D.6916 = (int) D.6915;
      D.6917 = *__s2;
      D.6918 = (int) D.6917;
      __result = D.6916 - D.6918;
      {
        D.6919 = __s2_len != 0;
        D.6920 = __result == 0;
        D.6921 = D.6919 & D.6920;
        if (D.6921 != 0) goto <D.6922>; else goto <D.6923>;
        <D.6922>:
        D.6924 = &MEM[(void *)"ghi" + 1B];
        D.6925 = *D.6924;
        D.6926 = (int) D.6925;
        D.6927 = __s2 + 1;
        D.6928 = *D.6927;
        D.6929 = (int) D.6928;
        __result = D.6926 - D.6929;
        D.6930 = __s2_len > 1;
        D.6920 = __result == 0;
        D.6931 = D.6930 & D.6920;
        if (D.6931 != 0) goto <D.6932>; else goto <D.6933>;
        <D.6932>:
        D.6934 = &MEM[(void *)"ghi" + 2B];
        D.6935 = *D.6934;
        D.6936 = (int) D.6935;
        D.6937 = __s2 + 2;
        D.6938 = *D.6937;
        D.6939 = (int) D.6938;
        __result = D.6936 - D.6939;
        D.6940 = __s2_len > 2;
        D.6920 = __result == 0;
        D.6941 = D.6940 & D.6920;
        if (D.6941 != 0) goto <D.6942>; else goto <D.6943>;
        <D.6942>:
        D.6944 = &MEM[(void *)"ghi" + 3B];
        D.6945 = *D.6944;
        D.6946 = (int) D.6945;
        D.6947 = __s2 + 3;
        D.6948 = *D.6947;
        D.6949 = (int) D.6948;
        __result = D.6946 - D.6949;
        <D.6943>:
        <D.6933>:
        <D.6923>:
      }
      D.5225 = __result;
    }
    iftmp.27 = -D.5225;
    goto <D.6950>;
    <D.6913>:
    D.6951 = v + 24;
    D.6952 = *D.6951;
    iftmp.27 = __builtin_strcmp (D.6952, "ghi");
    <D.6950>:
    D.5226 = iftmp.27;
  }
  if (D.5226 != 0) goto <D.6953>; else goto <D.6954>;
  <D.6953>:
  D.6821 = FAILED ("Invalid value 3");
  return D.6821;
  <D.6954>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.6956>; else goto <D.6957>;
    <D.6956>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 32B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.6958 = *__s2;
      D.6959 = (int) D.6958;
      __result = D.6827 - D.6959;
      {
        D.6960 = __s2_len != 0;
        D.6961 = __result == 0;
        D.6962 = D.6960 & D.6961;
        if (D.6962 != 0) goto <D.6963>; else goto <D.6964>;
        <D.6963>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.6965 = __s2 + 1;
        D.6966 = *D.6965;
        D.6967 = (int) D.6966;
        __result = D.6837 - D.6967;
        D.6968 = __s2_len > 1;
        D.6961 = __result == 0;
        D.6969 = D.6968 & D.6961;
        if (D.6969 != 0) goto <D.6970>; else goto <D.6971>;
        <D.6970>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.6972 = __s2 + 2;
        D.6973 = *D.6972;
        D.6974 = (int) D.6973;
        __result = D.6847 - D.6974;
        D.6975 = __s2_len > 2;
        D.6961 = __result == 0;
        D.6976 = D.6975 & D.6961;
        if (D.6976 != 0) goto <D.6977>; else goto <D.6978>;
        <D.6977>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.6979 = __s2 + 3;
        D.6980 = *D.6979;
        D.6981 = (int) D.6980;
        __result = D.6857 - D.6981;
        <D.6978>:
        <D.6971>:
        <D.6964>:
      }
      D.5234 = __result;
    }
    iftmp.28 = -D.5234;
    goto <D.6982>;
    <D.6957>:
    D.6983 = v + 32;
    D.6984 = *D.6983;
    D.6985 = MEM[(const unsigned char * {ref-all})D.6984];
    iftmp.28 = (int) D.6985;
    <D.6982>:
    D.5235 = iftmp.28;
  }
  if (D.5235 != 0) goto <D.6986>; else goto <D.6987>;
  <D.6986>:
  D.6821 = FAILED ("Invalid value 4");
  return D.6821;
  <D.6987>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 40B];
      D.6991 = "jklYmno";
      D.6992 = MEM[(const unsigned char *)D.6991];
      D.6993 = (int) D.6992;
      D.6994 = *__s2;
      D.6995 = (int) D.6994;
      __result = D.6993 - D.6995;
      {
        D.6996 = __s2_len != 0;
        D.6997 = __result == 0;
        D.6998 = D.6996 & D.6997;
        if (D.6998 != 0) goto <D.6999>; else goto <D.7000>;
        <D.6999>:
        D.7001 = &MEM[(void *)"jklYmno" + 1B];
        D.7002 = *D.7001;
        D.7003 = (int) D.7002;
        D.7004 = __s2 + 1;
        D.7005 = *D.7004;
        D.7006 = (int) D.7005;
        __result = D.7003 - D.7006;
        D.7007 = __s2_len > 1;
        D.6997 = __result == 0;
        D.7008 = D.7007 & D.6997;
        if (D.7008 != 0) goto <D.7009>; else goto <D.7010>;
        <D.7009>:
        D.7011 = &MEM[(void *)"jklYmno" + 2B];
        D.7012 = *D.7011;
        D.7013 = (int) D.7012;
        D.7014 = __s2 + 2;
        D.7015 = *D.7014;
        D.7016 = (int) D.7015;
        __result = D.7013 - D.7016;
        D.7017 = __s2_len > 2;
        D.6997 = __result == 0;
        D.7018 = D.7017 & D.6997;
        if (D.7018 != 0) goto <D.7019>; else goto <D.7020>;
        <D.7019>:
        D.7021 = &MEM[(void *)"jklYmno" + 3B];
        D.7022 = *D.7021;
        D.7023 = (int) D.7022;
        D.7024 = __s2 + 3;
        D.7025 = *D.7024;
        D.7026 = (int) D.7025;
        __result = D.7023 - D.7026;
        <D.7020>:
        <D.7010>:
        <D.7000>:
      }
      D.5243 = __result;
    }
    iftmp.29 = -D.5243;
    goto <D.7027>;
    <D.6990>:
    D.7028 = v + 40;
    D.7029 = *D.7028;
    iftmp.29 = __builtin_strcmp (D.7029, "jklYmno");
    <D.7027>:
    D.5244 = iftmp.29;
  }
  if (D.5244 != 0) goto <D.7030>; else goto <D.7031>;
  <D.7030>:
  D.6821 = FAILED ("Invalid value 5");
  return D.6821;
  <D.7031>:
  D.7032 = v + 48;
  D.7033 = *D.7032;
  if (D.7033 != 0B) goto <D.7034>; else goto <D.7035>;
  <D.7034>:
  D.6821 = FAILED ("Expected only 6 elements (1)");
  return D.6821;
  <D.7035>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit_set ("abcXYdefXghiXYjklYmno", "XY", 3);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.6781 = "abc";
      D.6782 = MEM[(const unsigned char *)D.6781];
      D.6783 = (int) D.6782;
      D.7039 = *__s2;
      D.7040 = (int) D.7039;
      __result = D.6783 - D.7040;
      {
        D.7041 = __s2_len != 0;
        D.7042 = __result == 0;
        D.7043 = D.7041 & D.7042;
        if (D.7043 != 0) goto <D.7044>; else goto <D.7045>;
        <D.7044>:
        D.6791 = &MEM[(void *)"abc" + 1B];
        D.6792 = *D.6791;
        D.6793 = (int) D.6792;
        D.7046 = __s2 + 1;
        D.7047 = *D.7046;
        D.7048 = (int) D.7047;
        __result = D.6793 - D.7048;
        D.7049 = __s2_len > 1;
        D.7042 = __result == 0;
        D.7050 = D.7049 & D.7042;
        if (D.7050 != 0) goto <D.7051>; else goto <D.7052>;
        <D.7051>:
        D.6801 = &MEM[(void *)"abc" + 2B];
        D.6802 = *D.6801;
        D.6803 = (int) D.6802;
        D.7053 = __s2 + 2;
        D.7054 = *D.7053;
        D.7055 = (int) D.7054;
        __result = D.6803 - D.7055;
        D.7056 = __s2_len > 2;
        D.7042 = __result == 0;
        D.7057 = D.7056 & D.7042;
        if (D.7057 != 0) goto <D.7058>; else goto <D.7059>;
        <D.7058>:
        D.6811 = &MEM[(void *)"abc" + 3B];
        D.6812 = *D.6811;
        D.6813 = (int) D.6812;
        D.7060 = __s2 + 3;
        D.7061 = *D.7060;
        D.7062 = (int) D.7061;
        __result = D.6813 - D.7062;
        <D.7059>:
        <D.7052>:
        <D.7045>:
      }
      D.5252 = __result;
    }
    iftmp.30 = -D.5252;
    goto <D.7063>;
    <D.7038>:
    D.6818 = *v;
    iftmp.30 = __builtin_strcmp (D.6818, "abc");
    <D.7063>:
    D.5253 = iftmp.30;
  }
  if (D.5253 != 0) goto <D.7064>; else goto <D.7065>;
  <D.7064>:
  D.6821 = FAILED ("Invalid value 6");
  return D.6821;
  <D.7065>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7067>; else goto <D.7068>;
    <D.7067>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 8B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.7069 = *__s2;
      D.7070 = (int) D.7069;
      __result = D.6827 - D.7070;
      {
        D.7071 = __s2_len != 0;
        D.7072 = __result == 0;
        D.7073 = D.7071 & D.7072;
        if (D.7073 != 0) goto <D.7074>; else goto <D.7075>;
        <D.7074>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.7076 = __s2 + 1;
        D.7077 = *D.7076;
        D.7078 = (int) D.7077;
        __result = D.6837 - D.7078;
        D.7079 = __s2_len > 1;
        D.7072 = __result == 0;
        D.7080 = D.7079 & D.7072;
        if (D.7080 != 0) goto <D.7081>; else goto <D.7082>;
        <D.7081>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.7083 = __s2 + 2;
        D.7084 = *D.7083;
        D.7085 = (int) D.7084;
        __result = D.6847 - D.7085;
        D.7086 = __s2_len > 2;
        D.7072 = __result == 0;
        D.7087 = D.7086 & D.7072;
        if (D.7087 != 0) goto <D.7088>; else goto <D.7089>;
        <D.7088>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.7090 = __s2 + 3;
        D.7091 = *D.7090;
        D.7092 = (int) D.7091;
        __result = D.6857 - D.7092;
        <D.7089>:
        <D.7082>:
        <D.7075>:
      }
      D.5261 = __result;
    }
    iftmp.31 = -D.5261;
    goto <D.7093>;
    <D.7068>:
    D.6862 = v + 8;
    D.6863 = *D.6862;
    D.6864 = MEM[(const unsigned char * {ref-all})D.6863];
    iftmp.31 = (int) D.6864;
    <D.7093>:
    D.5262 = iftmp.31;
  }
  if (D.5262 != 0) goto <D.7094>; else goto <D.7095>;
  <D.7094>:
  D.6821 = FAILED ("Invalid value 7");
  return D.6821;
  <D.7095>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 16;
    if (__s2_len <= 3) goto <D.7097>; else goto <D.7098>;
    <D.7097>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 16B];
      D.7099 = "defXghiXYjklYmno";
      D.7100 = MEM[(const unsigned char *)D.7099];
      D.7101 = (int) D.7100;
      D.7102 = *__s2;
      D.7103 = (int) D.7102;
      __result = D.7101 - D.7103;
      {
        D.7104 = __s2_len != 0;
        D.7105 = __result == 0;
        D.7106 = D.7104 & D.7105;
        if (D.7106 != 0) goto <D.7107>; else goto <D.7108>;
        <D.7107>:
        D.7109 = &MEM[(void *)"defXghiXYjklYmno" + 1B];
        D.7110 = *D.7109;
        D.7111 = (int) D.7110;
        D.7112 = __s2 + 1;
        D.7113 = *D.7112;
        D.7114 = (int) D.7113;
        __result = D.7111 - D.7114;
        D.7115 = __s2_len > 1;
        D.7105 = __result == 0;
        D.7116 = D.7115 & D.7105;
        if (D.7116 != 0) goto <D.7117>; else goto <D.7118>;
        <D.7117>:
        D.7119 = &MEM[(void *)"defXghiXYjklYmno" + 2B];
        D.7120 = *D.7119;
        D.7121 = (int) D.7120;
        D.7122 = __s2 + 2;
        D.7123 = *D.7122;
        D.7124 = (int) D.7123;
        __result = D.7121 - D.7124;
        D.7125 = __s2_len > 2;
        D.7105 = __result == 0;
        D.7126 = D.7125 & D.7105;
        if (D.7126 != 0) goto <D.7127>; else goto <D.7128>;
        <D.7127>:
        D.7129 = &MEM[(void *)"defXghiXYjklYmno" + 3B];
        D.7130 = *D.7129;
        D.7131 = (int) D.7130;
        D.7132 = __s2 + 3;
        D.7133 = *D.7132;
        D.7134 = (int) D.7133;
        __result = D.7131 - D.7134;
        <D.7128>:
        <D.7118>:
        <D.7108>:
      }
      D.5270 = __result;
    }
    iftmp.32 = -D.5270;
    goto <D.7135>;
    <D.7098>:
    D.6907 = v + 16;
    D.6908 = *D.6907;
    iftmp.32 = __builtin_strcmp (D.6908, "defXghiXYjklYmno");
    <D.7135>:
    D.5271 = iftmp.32;
  }
  if (D.5271 != 0) goto <D.7136>; else goto <D.7137>;
  <D.7136>:
  D.6821 = FAILED ("Invalid value 8");
  return D.6821;
  <D.7137>:
  D.6951 = v + 24;
  D.6952 = *D.6951;
  if (D.6952 != 0B) goto <D.7138>; else goto <D.7139>;
  <D.7138>:
  D.6821 = FAILED ("Expected only 3 elements (2)");
  return D.6821;
  <D.7139>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit_set ("abcXdefYghiXjklYmnoX", "XY", 5);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.6781 = "abc";
      D.6782 = MEM[(const unsigned char *)D.6781];
      D.6783 = (int) D.6782;
      D.7143 = *__s2;
      D.7144 = (int) D.7143;
      __result = D.6783 - D.7144;
      {
        D.7145 = __s2_len != 0;
        D.7146 = __result == 0;
        D.7147 = D.7145 & D.7146;
        if (D.7147 != 0) goto <D.7148>; else goto <D.7149>;
        <D.7148>:
        D.6791 = &MEM[(void *)"abc" + 1B];
        D.6792 = *D.6791;
        D.6793 = (int) D.6792;
        D.7150 = __s2 + 1;
        D.7151 = *D.7150;
        D.7152 = (int) D.7151;
        __result = D.6793 - D.7152;
        D.7153 = __s2_len > 1;
        D.7146 = __result == 0;
        D.7154 = D.7153 & D.7146;
        if (D.7154 != 0) goto <D.7155>; else goto <D.7156>;
        <D.7155>:
        D.6801 = &MEM[(void *)"abc" + 2B];
        D.6802 = *D.6801;
        D.6803 = (int) D.6802;
        D.7157 = __s2 + 2;
        D.7158 = *D.7157;
        D.7159 = (int) D.7158;
        __result = D.6803 - D.7159;
        D.7160 = __s2_len > 2;
        D.7146 = __result == 0;
        D.7161 = D.7160 & D.7146;
        if (D.7161 != 0) goto <D.7162>; else goto <D.7163>;
        <D.7162>:
        D.6811 = &MEM[(void *)"abc" + 3B];
        D.6812 = *D.6811;
        D.6813 = (int) D.6812;
        D.7164 = __s2 + 3;
        D.7165 = *D.7164;
        D.7166 = (int) D.7165;
        __result = D.6813 - D.7166;
        <D.7163>:
        <D.7156>:
        <D.7149>:
      }
      D.5279 = __result;
    }
    iftmp.33 = -D.5279;
    goto <D.7167>;
    <D.7142>:
    D.6818 = *v;
    iftmp.33 = __builtin_strcmp (D.6818, "abc");
    <D.7167>:
    D.5280 = iftmp.33;
  }
  if (D.5280 != 0) goto <D.7168>; else goto <D.7169>;
  <D.7168>:
  D.6821 = FAILED ("Invalid value 9");
  return D.6821;
  <D.7169>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 8B];
      D.6870 = "def";
      D.6871 = MEM[(const unsigned char *)D.6870];
      D.6872 = (int) D.6871;
      D.7173 = *__s2;
      D.7174 = (int) D.7173;
      __result = D.6872 - D.7174;
      {
        D.7175 = __s2_len != 0;
        D.7176 = __result == 0;
        D.7177 = D.7175 & D.7176;
        if (D.7177 != 0) goto <D.7178>; else goto <D.7179>;
        <D.7178>:
        D.6880 = &MEM[(void *)"def" + 1B];
        D.6881 = *D.6880;
        D.6882 = (int) D.6881;
        D.7180 = __s2 + 1;
        D.7181 = *D.7180;
        D.7182 = (int) D.7181;
        __result = D.6882 - D.7182;
        D.7183 = __s2_len > 1;
        D.7176 = __result == 0;
        D.7184 = D.7183 & D.7176;
        if (D.7184 != 0) goto <D.7185>; else goto <D.7186>;
        <D.7185>:
        D.6890 = &MEM[(void *)"def" + 2B];
        D.6891 = *D.6890;
        D.6892 = (int) D.6891;
        D.7187 = __s2 + 2;
        D.7188 = *D.7187;
        D.7189 = (int) D.7188;
        __result = D.6892 - D.7189;
        D.7190 = __s2_len > 2;
        D.7176 = __result == 0;
        D.7191 = D.7190 & D.7176;
        if (D.7191 != 0) goto <D.7192>; else goto <D.7193>;
        <D.7192>:
        D.6900 = &MEM[(void *)"def" + 3B];
        D.6901 = *D.6900;
        D.6902 = (int) D.6901;
        D.7194 = __s2 + 3;
        D.7195 = *D.7194;
        D.7196 = (int) D.7195;
        __result = D.6902 - D.7196;
        <D.7193>:
        <D.7186>:
        <D.7179>:
      }
      D.5288 = __result;
    }
    iftmp.34 = -D.5288;
    goto <D.7197>;
    <D.7172>:
    D.6862 = v + 8;
    D.6863 = *D.6862;
    iftmp.34 = __builtin_strcmp (D.6863, "def");
    <D.7197>:
    D.5289 = iftmp.34;
  }
  if (D.5289 != 0) goto <D.7198>; else goto <D.7199>;
  <D.7198>:
  D.6821 = FAILED ("Invalid value 10");
  return D.6821;
  <D.7199>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 16B];
      D.6914 = "ghi";
      D.6915 = MEM[(const unsigned char *)D.6914];
      D.6916 = (int) D.6915;
      D.7203 = *__s2;
      D.7204 = (int) D.7203;
      __result = D.6916 - D.7204;
      {
        D.7205 = __s2_len != 0;
        D.7206 = __result == 0;
        D.7207 = D.7205 & D.7206;
        if (D.7207 != 0) goto <D.7208>; else goto <D.7209>;
        <D.7208>:
        D.6924 = &MEM[(void *)"ghi" + 1B];
        D.6925 = *D.6924;
        D.6926 = (int) D.6925;
        D.7210 = __s2 + 1;
        D.7211 = *D.7210;
        D.7212 = (int) D.7211;
        __result = D.6926 - D.7212;
        D.7213 = __s2_len > 1;
        D.7206 = __result == 0;
        D.7214 = D.7213 & D.7206;
        if (D.7214 != 0) goto <D.7215>; else goto <D.7216>;
        <D.7215>:
        D.6934 = &MEM[(void *)"ghi" + 2B];
        D.6935 = *D.6934;
        D.6936 = (int) D.6935;
        D.7217 = __s2 + 2;
        D.7218 = *D.7217;
        D.7219 = (int) D.7218;
        __result = D.6936 - D.7219;
        D.7220 = __s2_len > 2;
        D.7206 = __result == 0;
        D.7221 = D.7220 & D.7206;
        if (D.7221 != 0) goto <D.7222>; else goto <D.7223>;
        <D.7222>:
        D.6944 = &MEM[(void *)"ghi" + 3B];
        D.6945 = *D.6944;
        D.6946 = (int) D.6945;
        D.7224 = __s2 + 3;
        D.7225 = *D.7224;
        D.7226 = (int) D.7225;
        __result = D.6946 - D.7226;
        <D.7223>:
        <D.7216>:
        <D.7209>:
      }
      D.5297 = __result;
    }
    iftmp.35 = -D.5297;
    goto <D.7227>;
    <D.7202>:
    D.6907 = v + 16;
    D.6908 = *D.6907;
    iftmp.35 = __builtin_strcmp (D.6908, "ghi");
    <D.7227>:
    D.5298 = iftmp.35;
  }
  if (D.5298 != 0) goto <D.7228>; else goto <D.7229>;
  <D.7228>:
  D.6821 = FAILED ("Invalid value 11");
  return D.6821;
  <D.7229>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 24B];
      D.7233 = "jkl";
      D.7234 = MEM[(const unsigned char *)D.7233];
      D.7235 = (int) D.7234;
      D.7236 = *__s2;
      D.7237 = (int) D.7236;
      __result = D.7235 - D.7237;
      {
        D.7238 = __s2_len != 0;
        D.7239 = __result == 0;
        D.7240 = D.7238 & D.7239;
        if (D.7240 != 0) goto <D.7241>; else goto <D.7242>;
        <D.7241>:
        D.7243 = &MEM[(void *)"jkl" + 1B];
        D.7244 = *D.7243;
        D.7245 = (int) D.7244;
        D.7246 = __s2 + 1;
        D.7247 = *D.7246;
        D.7248 = (int) D.7247;
        __result = D.7245 - D.7248;
        D.7249 = __s2_len > 1;
        D.7239 = __result == 0;
        D.7250 = D.7249 & D.7239;
        if (D.7250 != 0) goto <D.7251>; else goto <D.7252>;
        <D.7251>:
        D.7253 = &MEM[(void *)"jkl" + 2B];
        D.7254 = *D.7253;
        D.7255 = (int) D.7254;
        D.7256 = __s2 + 2;
        D.7257 = *D.7256;
        D.7258 = (int) D.7257;
        __result = D.7255 - D.7258;
        D.7259 = __s2_len > 2;
        D.7239 = __result == 0;
        D.7260 = D.7259 & D.7239;
        if (D.7260 != 0) goto <D.7261>; else goto <D.7262>;
        <D.7261>:
        D.7263 = &MEM[(void *)"jkl" + 3B];
        D.7264 = *D.7263;
        D.7265 = (int) D.7264;
        D.7266 = __s2 + 3;
        D.7267 = *D.7266;
        D.7268 = (int) D.7267;
        __result = D.7265 - D.7268;
        <D.7262>:
        <D.7252>:
        <D.7242>:
      }
      D.5306 = __result;
    }
    iftmp.36 = -D.5306;
    goto <D.7269>;
    <D.7232>:
    D.6951 = v + 24;
    D.6952 = *D.6951;
    iftmp.36 = __builtin_strcmp (D.6952, "jkl");
    <D.7269>:
    D.5307 = iftmp.36;
  }
  if (D.5307 != 0) goto <D.7270>; else goto <D.7271>;
  <D.7270>:
  D.6821 = FAILED ("Invalid value 12");
  return D.6821;
  <D.7271>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.7273>; else goto <D.7274>;
    <D.7273>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 32B];
      D.7275 = "mnoX";
      D.7276 = MEM[(const unsigned char *)D.7275];
      D.7277 = (int) D.7276;
      D.7278 = *__s2;
      D.7279 = (int) D.7278;
      __result = D.7277 - D.7279;
      {
        D.7280 = __s2_len != 0;
        D.7281 = __result == 0;
        D.7282 = D.7280 & D.7281;
        if (D.7282 != 0) goto <D.7283>; else goto <D.7284>;
        <D.7283>:
        D.7285 = &MEM[(void *)"mnoX" + 1B];
        D.7286 = *D.7285;
        D.7287 = (int) D.7286;
        D.7288 = __s2 + 1;
        D.7289 = *D.7288;
        D.7290 = (int) D.7289;
        __result = D.7287 - D.7290;
        D.7291 = __s2_len > 1;
        D.7281 = __result == 0;
        D.7292 = D.7291 & D.7281;
        if (D.7292 != 0) goto <D.7293>; else goto <D.7294>;
        <D.7293>:
        D.7295 = &MEM[(void *)"mnoX" + 2B];
        D.7296 = *D.7295;
        D.7297 = (int) D.7296;
        D.7298 = __s2 + 2;
        D.7299 = *D.7298;
        D.7300 = (int) D.7299;
        __result = D.7297 - D.7300;
        D.7301 = __s2_len > 2;
        D.7281 = __result == 0;
        D.7302 = D.7301 & D.7281;
        if (D.7302 != 0) goto <D.7303>; else goto <D.7304>;
        <D.7303>:
        D.7305 = &MEM[(void *)"mnoX" + 3B];
        D.7306 = *D.7305;
        D.7307 = (int) D.7306;
        D.7308 = __s2 + 3;
        D.7309 = *D.7308;
        D.7310 = (int) D.7309;
        __result = D.7307 - D.7310;
        <D.7304>:
        <D.7294>:
        <D.7284>:
      }
      D.5315 = __result;
    }
    iftmp.37 = -D.5315;
    goto <D.7311>;
    <D.7274>:
    D.6983 = v + 32;
    D.6984 = *D.6983;
    iftmp.37 = __builtin_strcmp (D.6984, "mnoX");
    <D.7311>:
    D.5316 = iftmp.37;
  }
  if (D.5316 != 0) goto <D.7312>; else goto <D.7313>;
  <D.7312>:
  D.6821 = FAILED ("Invalid value 13");
  return D.6821;
  <D.7313>:
  D.7028 = v + 40;
  D.7029 = *D.7028;
  if (D.7029 != 0B) goto <D.7314>; else goto <D.7315>;
  <D.7314>:
  D.6821 = FAILED ("Expected only 5 elements (5)");
  return D.6821;
  <D.7315>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit_set ("abcXYXdefXY", "XY", -1);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = *v;
      D.6781 = "abc";
      D.6782 = MEM[(const unsigned char *)D.6781];
      D.6783 = (int) D.6782;
      D.7319 = *__s2;
      D.7320 = (int) D.7319;
      __result = D.6783 - D.7320;
      {
        D.7321 = __s2_len != 0;
        D.7322 = __result == 0;
        D.7323 = D.7321 & D.7322;
        if (D.7323 != 0) goto <D.7324>; else goto <D.7325>;
        <D.7324>:
        D.6791 = &MEM[(void *)"abc" + 1B];
        D.6792 = *D.6791;
        D.6793 = (int) D.6792;
        D.7326 = __s2 + 1;
        D.7327 = *D.7326;
        D.7328 = (int) D.7327;
        __result = D.6793 - D.7328;
        D.7329 = __s2_len > 1;
        D.7322 = __result == 0;
        D.7330 = D.7329 & D.7322;
        if (D.7330 != 0) goto <D.7331>; else goto <D.7332>;
        <D.7331>:
        D.6801 = &MEM[(void *)"abc" + 2B];
        D.6802 = *D.6801;
        D.6803 = (int) D.6802;
        D.7333 = __s2 + 2;
        D.7334 = *D.7333;
        D.7335 = (int) D.7334;
        __result = D.6803 - D.7335;
        D.7336 = __s2_len > 2;
        D.7322 = __result == 0;
        D.7337 = D.7336 & D.7322;
        if (D.7337 != 0) goto <D.7338>; else goto <D.7339>;
        <D.7338>:
        D.6811 = &MEM[(void *)"abc" + 3B];
        D.6812 = *D.6811;
        D.6813 = (int) D.6812;
        D.7340 = __s2 + 3;
        D.7341 = *D.7340;
        D.7342 = (int) D.7341;
        __result = D.6813 - D.7342;
        <D.7339>:
        <D.7332>:
        <D.7325>:
      }
      D.5324 = __result;
    }
    iftmp.38 = -D.5324;
    goto <D.7343>;
    <D.7318>:
    D.6818 = *v;
    iftmp.38 = __builtin_strcmp (D.6818, "abc");
    <D.7343>:
    D.5325 = iftmp.38;
  }
  if (D.5325 != 0) goto <D.7344>; else goto <D.7345>;
  <D.7344>:
  D.6821 = FAILED ("Invalid value 14");
  return D.6821;
  <D.7345>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7347>; else goto <D.7348>;
    <D.7347>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 8B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.7349 = *__s2;
      D.7350 = (int) D.7349;
      __result = D.6827 - D.7350;
      {
        D.7351 = __s2_len != 0;
        D.7352 = __result == 0;
        D.7353 = D.7351 & D.7352;
        if (D.7353 != 0) goto <D.7354>; else goto <D.7355>;
        <D.7354>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.7356 = __s2 + 1;
        D.7357 = *D.7356;
        D.7358 = (int) D.7357;
        __result = D.6837 - D.7358;
        D.7359 = __s2_len > 1;
        D.7352 = __result == 0;
        D.7360 = D.7359 & D.7352;
        if (D.7360 != 0) goto <D.7361>; else goto <D.7362>;
        <D.7361>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.7363 = __s2 + 2;
        D.7364 = *D.7363;
        D.7365 = (int) D.7364;
        __result = D.6847 - D.7365;
        D.7366 = __s2_len > 2;
        D.7352 = __result == 0;
        D.7367 = D.7366 & D.7352;
        if (D.7367 != 0) goto <D.7368>; else goto <D.7369>;
        <D.7368>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.7370 = __s2 + 3;
        D.7371 = *D.7370;
        D.7372 = (int) D.7371;
        __result = D.6857 - D.7372;
        <D.7369>:
        <D.7362>:
        <D.7355>:
      }
      D.5333 = __result;
    }
    iftmp.39 = -D.5333;
    goto <D.7373>;
    <D.7348>:
    D.6862 = v + 8;
    D.6863 = *D.6862;
    D.6864 = MEM[(const unsigned char * {ref-all})D.6863];
    iftmp.39 = (int) D.6864;
    <D.7373>:
    D.5334 = iftmp.39;
  }
  if (D.5334 != 0) goto <D.7374>; else goto <D.7375>;
  <D.7374>:
  D.6821 = FAILED ("Invalid value 15");
  return D.6821;
  <D.7375>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7377>; else goto <D.7378>;
    <D.7377>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 16B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.7379 = *__s2;
      D.7380 = (int) D.7379;
      __result = D.6827 - D.7380;
      {
        D.7381 = __s2_len != 0;
        D.7382 = __result == 0;
        D.7383 = D.7381 & D.7382;
        if (D.7383 != 0) goto <D.7384>; else goto <D.7385>;
        <D.7384>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.7386 = __s2 + 1;
        D.7387 = *D.7386;
        D.7388 = (int) D.7387;
        __result = D.6837 - D.7388;
        D.7389 = __s2_len > 1;
        D.7382 = __result == 0;
        D.7390 = D.7389 & D.7382;
        if (D.7390 != 0) goto <D.7391>; else goto <D.7392>;
        <D.7391>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.7393 = __s2 + 2;
        D.7394 = *D.7393;
        D.7395 = (int) D.7394;
        __result = D.6847 - D.7395;
        D.7396 = __s2_len > 2;
        D.7382 = __result == 0;
        D.7397 = D.7396 & D.7382;
        if (D.7397 != 0) goto <D.7398>; else goto <D.7399>;
        <D.7398>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.7400 = __s2 + 3;
        D.7401 = *D.7400;
        D.7402 = (int) D.7401;
        __result = D.6857 - D.7402;
        <D.7399>:
        <D.7392>:
        <D.7385>:
      }
      D.5342 = __result;
    }
    iftmp.40 = -D.5342;
    goto <D.7403>;
    <D.7378>:
    D.6907 = v + 16;
    D.6908 = *D.6907;
    D.7404 = MEM[(const unsigned char * {ref-all})D.6908];
    iftmp.40 = (int) D.7404;
    <D.7403>:
    D.5343 = iftmp.40;
  }
  if (D.5343 != 0) goto <D.7405>; else goto <D.7406>;
  <D.7405>:
  D.6821 = FAILED ("Invalid value 16");
  return D.6821;
  <D.7406>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 24B];
      D.6870 = "def";
      D.6871 = MEM[(const unsigned char *)D.6870];
      D.6872 = (int) D.6871;
      D.7410 = *__s2;
      D.7411 = (int) D.7410;
      __result = D.6872 - D.7411;
      {
        D.7412 = __s2_len != 0;
        D.7413 = __result == 0;
        D.7414 = D.7412 & D.7413;
        if (D.7414 != 0) goto <D.7415>; else goto <D.7416>;
        <D.7415>:
        D.6880 = &MEM[(void *)"def" + 1B];
        D.6881 = *D.6880;
        D.6882 = (int) D.6881;
        D.7417 = __s2 + 1;
        D.7418 = *D.7417;
        D.7419 = (int) D.7418;
        __result = D.6882 - D.7419;
        D.7420 = __s2_len > 1;
        D.7413 = __result == 0;
        D.7421 = D.7420 & D.7413;
        if (D.7421 != 0) goto <D.7422>; else goto <D.7423>;
        <D.7422>:
        D.6890 = &MEM[(void *)"def" + 2B];
        D.6891 = *D.6890;
        D.6892 = (int) D.6891;
        D.7424 = __s2 + 2;
        D.7425 = *D.7424;
        D.7426 = (int) D.7425;
        __result = D.6892 - D.7426;
        D.7427 = __s2_len > 2;
        D.7413 = __result == 0;
        D.7428 = D.7427 & D.7413;
        if (D.7428 != 0) goto <D.7429>; else goto <D.7430>;
        <D.7429>:
        D.6900 = &MEM[(void *)"def" + 3B];
        D.6901 = *D.6900;
        D.6902 = (int) D.6901;
        D.7431 = __s2 + 3;
        D.7432 = *D.7431;
        D.7433 = (int) D.7432;
        __result = D.6902 - D.7433;
        <D.7430>:
        <D.7423>:
        <D.7416>:
      }
      D.5351 = __result;
    }
    iftmp.41 = -D.5351;
    goto <D.7434>;
    <D.7409>:
    D.6951 = v + 24;
    D.6952 = *D.6951;
    iftmp.41 = __builtin_strcmp (D.6952, "def");
    <D.7434>:
    D.5352 = iftmp.41;
  }
  if (D.5352 != 0) goto <D.7435>; else goto <D.7436>;
  <D.7435>:
  D.6821 = FAILED ("Invalid value 17");
  return D.6821;
  <D.7436>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7438>; else goto <D.7439>;
    <D.7438>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 32B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.7440 = *__s2;
      D.7441 = (int) D.7440;
      __result = D.6827 - D.7441;
      {
        D.7442 = __s2_len != 0;
        D.7443 = __result == 0;
        D.7444 = D.7442 & D.7443;
        if (D.7444 != 0) goto <D.7445>; else goto <D.7446>;
        <D.7445>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.7447 = __s2 + 1;
        D.7448 = *D.7447;
        D.7449 = (int) D.7448;
        __result = D.6837 - D.7449;
        D.7450 = __s2_len > 1;
        D.7443 = __result == 0;
        D.7451 = D.7450 & D.7443;
        if (D.7451 != 0) goto <D.7452>; else goto <D.7453>;
        <D.7452>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.7454 = __s2 + 2;
        D.7455 = *D.7454;
        D.7456 = (int) D.7455;
        __result = D.6847 - D.7456;
        D.7457 = __s2_len > 2;
        D.7443 = __result == 0;
        D.7458 = D.7457 & D.7443;
        if (D.7458 != 0) goto <D.7459>; else goto <D.7460>;
        <D.7459>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.7461 = __s2 + 3;
        D.7462 = *D.7461;
        D.7463 = (int) D.7462;
        __result = D.6857 - D.7463;
        <D.7460>:
        <D.7453>:
        <D.7446>:
      }
      D.5360 = __result;
    }
    iftmp.42 = -D.5360;
    goto <D.7464>;
    <D.7439>:
    D.6983 = v + 32;
    D.6984 = *D.6983;
    D.6985 = MEM[(const unsigned char * {ref-all})D.6984];
    iftmp.42 = (int) D.6985;
    <D.7464>:
    D.5361 = iftmp.42;
  }
  if (D.5361 != 0) goto <D.7465>; else goto <D.7466>;
  <D.7465>:
  D.6821 = FAILED ("Invalid value 18");
  return D.6821;
  <D.7466>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7468>; else goto <D.7469>;
    <D.7468>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 40B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.7470 = *__s2;
      D.7471 = (int) D.7470;
      __result = D.6827 - D.7471;
      {
        D.7472 = __s2_len != 0;
        D.7473 = __result == 0;
        D.7474 = D.7472 & D.7473;
        if (D.7474 != 0) goto <D.7475>; else goto <D.7476>;
        <D.7475>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.7477 = __s2 + 1;
        D.7478 = *D.7477;
        D.7479 = (int) D.7478;
        __result = D.6837 - D.7479;
        D.7480 = __s2_len > 1;
        D.7473 = __result == 0;
        D.7481 = D.7480 & D.7473;
        if (D.7481 != 0) goto <D.7482>; else goto <D.7483>;
        <D.7482>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.7484 = __s2 + 2;
        D.7485 = *D.7484;
        D.7486 = (int) D.7485;
        __result = D.6847 - D.7486;
        D.7487 = __s2_len > 2;
        D.7473 = __result == 0;
        D.7488 = D.7487 & D.7473;
        if (D.7488 != 0) goto <D.7489>; else goto <D.7490>;
        <D.7489>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.7491 = __s2 + 3;
        D.7492 = *D.7491;
        D.7493 = (int) D.7492;
        __result = D.6857 - D.7493;
        <D.7490>:
        <D.7483>:
        <D.7476>:
      }
      D.5369 = __result;
    }
    iftmp.43 = -D.5369;
    goto <D.7494>;
    <D.7469>:
    D.7028 = v + 40;
    D.7029 = *D.7028;
    D.7495 = MEM[(const unsigned char * {ref-all})D.7029];
    iftmp.43 = (int) D.7495;
    <D.7494>:
    D.5370 = iftmp.43;
  }
  if (D.5370 != 0) goto <D.7496>; else goto <D.7497>;
  <D.7496>:
  D.6821 = FAILED ("Invalid value 19");
  return D.6821;
  <D.7497>:
  D.7032 = v + 48;
  D.7033 = *D.7032;
  if (D.7033 != 0B) goto <D.7498>; else goto <D.7499>;
  <D.7498>:
  D.6821 = FAILED ("Expected only 6 elements (4)");
  return D.6821;
  <D.7499>:
  monoeg_g_strfreev (v);
  v = monoeg_g_strsplit_set ("XYXabcXYdef", "XY", -1);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7501>; else goto <D.7502>;
    <D.7501>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = *v;
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.7503 = *__s2;
      D.7504 = (int) D.7503;
      __result = D.6827 - D.7504;
      {
        D.7505 = __s2_len != 0;
        D.7506 = __result == 0;
        D.7507 = D.7505 & D.7506;
        if (D.7507 != 0) goto <D.7508>; else goto <D.7509>;
        <D.7508>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.7510 = __s2 + 1;
        D.7511 = *D.7510;
        D.7512 = (int) D.7511;
        __result = D.6837 - D.7512;
        D.7513 = __s2_len > 1;
        D.7506 = __result == 0;
        D.7514 = D.7513 & D.7506;
        if (D.7514 != 0) goto <D.7515>; else goto <D.7516>;
        <D.7515>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.7517 = __s2 + 2;
        D.7518 = *D.7517;
        D.7519 = (int) D.7518;
        __result = D.6847 - D.7519;
        D.7520 = __s2_len > 2;
        D.7506 = __result == 0;
        D.7521 = D.7520 & D.7506;
        if (D.7521 != 0) goto <D.7522>; else goto <D.7523>;
        <D.7522>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.7524 = __s2 + 3;
        D.7525 = *D.7524;
        D.7526 = (int) D.7525;
        __result = D.6857 - D.7526;
        <D.7523>:
        <D.7516>:
        <D.7509>:
      }
      D.5378 = __result;
    }
    iftmp.44 = -D.5378;
    goto <D.7527>;
    <D.7502>:
    D.6818 = *v;
    D.7528 = MEM[(const unsigned char * {ref-all})D.6818];
    iftmp.44 = (int) D.7528;
    <D.7527>:
    D.5379 = iftmp.44;
  }
  if (D.5379 != 0) goto <D.7529>; else goto <D.7530>;
  <D.7529>:
  D.6821 = FAILED ("Invalid value 20");
  return D.6821;
  <D.7530>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7532>; else goto <D.7533>;
    <D.7532>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 8B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.7534 = *__s2;
      D.7535 = (int) D.7534;
      __result = D.6827 - D.7535;
      {
        D.7536 = __s2_len != 0;
        D.7537 = __result == 0;
        D.7538 = D.7536 & D.7537;
        if (D.7538 != 0) goto <D.7539>; else goto <D.7540>;
        <D.7539>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.7541 = __s2 + 1;
        D.7542 = *D.7541;
        D.7543 = (int) D.7542;
        __result = D.6837 - D.7543;
        D.7544 = __s2_len > 1;
        D.7537 = __result == 0;
        D.7545 = D.7544 & D.7537;
        if (D.7545 != 0) goto <D.7546>; else goto <D.7547>;
        <D.7546>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.7548 = __s2 + 2;
        D.7549 = *D.7548;
        D.7550 = (int) D.7549;
        __result = D.6847 - D.7550;
        D.7551 = __s2_len > 2;
        D.7537 = __result == 0;
        D.7552 = D.7551 & D.7537;
        if (D.7552 != 0) goto <D.7553>; else goto <D.7554>;
        <D.7553>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.7555 = __s2 + 3;
        D.7556 = *D.7555;
        D.7557 = (int) D.7556;
        __result = D.6857 - D.7557;
        <D.7554>:
        <D.7547>:
        <D.7540>:
      }
      D.5387 = __result;
    }
    iftmp.45 = -D.5387;
    goto <D.7558>;
    <D.7533>:
    D.6862 = v + 8;
    D.6863 = *D.6862;
    D.6864 = MEM[(const unsigned char * {ref-all})D.6863];
    iftmp.45 = (int) D.6864;
    <D.7558>:
    D.5388 = iftmp.45;
  }
  if (D.5388 != 0) goto <D.7559>; else goto <D.7560>;
  <D.7559>:
  D.6821 = FAILED ("Invalid value 21");
  return D.6821;
  <D.7560>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7562>; else goto <D.7563>;
    <D.7562>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 16B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.7564 = *__s2;
      D.7565 = (int) D.7564;
      __result = D.6827 - D.7565;
      {
        D.7566 = __s2_len != 0;
        D.7567 = __result == 0;
        D.7568 = D.7566 & D.7567;
        if (D.7568 != 0) goto <D.7569>; else goto <D.7570>;
        <D.7569>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.7571 = __s2 + 1;
        D.7572 = *D.7571;
        D.7573 = (int) D.7572;
        __result = D.6837 - D.7573;
        D.7574 = __s2_len > 1;
        D.7567 = __result == 0;
        D.7575 = D.7574 & D.7567;
        if (D.7575 != 0) goto <D.7576>; else goto <D.7577>;
        <D.7576>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.7578 = __s2 + 2;
        D.7579 = *D.7578;
        D.7580 = (int) D.7579;
        __result = D.6847 - D.7580;
        D.7581 = __s2_len > 2;
        D.7567 = __result == 0;
        D.7582 = D.7581 & D.7567;
        if (D.7582 != 0) goto <D.7583>; else goto <D.7584>;
        <D.7583>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.7585 = __s2 + 3;
        D.7586 = *D.7585;
        D.7587 = (int) D.7586;
        __result = D.6857 - D.7587;
        <D.7584>:
        <D.7577>:
        <D.7570>:
      }
      D.5396 = __result;
    }
    iftmp.46 = -D.5396;
    goto <D.7588>;
    <D.7563>:
    D.6907 = v + 16;
    D.6908 = *D.6907;
    D.7404 = MEM[(const unsigned char * {ref-all})D.6908];
    iftmp.46 = (int) D.7404;
    <D.7588>:
    D.5397 = iftmp.46;
  }
  if (D.5397 != 0) goto <D.7589>; else goto <D.7590>;
  <D.7589>:
  D.6821 = FAILED ("Invalid value 22");
  return D.6821;
  <D.7590>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 24B];
      D.6781 = "abc";
      D.6782 = MEM[(const unsigned char *)D.6781];
      D.6783 = (int) D.6782;
      D.7594 = *__s2;
      D.7595 = (int) D.7594;
      __result = D.6783 - D.7595;
      {
        D.7596 = __s2_len != 0;
        D.7597 = __result == 0;
        D.7598 = D.7596 & D.7597;
        if (D.7598 != 0) goto <D.7599>; else goto <D.7600>;
        <D.7599>:
        D.6791 = &MEM[(void *)"abc" + 1B];
        D.6792 = *D.6791;
        D.6793 = (int) D.6792;
        D.7601 = __s2 + 1;
        D.7602 = *D.7601;
        D.7603 = (int) D.7602;
        __result = D.6793 - D.7603;
        D.7604 = __s2_len > 1;
        D.7597 = __result == 0;
        D.7605 = D.7604 & D.7597;
        if (D.7605 != 0) goto <D.7606>; else goto <D.7607>;
        <D.7606>:
        D.6801 = &MEM[(void *)"abc" + 2B];
        D.6802 = *D.6801;
        D.6803 = (int) D.6802;
        D.7608 = __s2 + 2;
        D.7609 = *D.7608;
        D.7610 = (int) D.7609;
        __result = D.6803 - D.7610;
        D.7611 = __s2_len > 2;
        D.7597 = __result == 0;
        D.7612 = D.7611 & D.7597;
        if (D.7612 != 0) goto <D.7613>; else goto <D.7614>;
        <D.7613>:
        D.6811 = &MEM[(void *)"abc" + 3B];
        D.6812 = *D.6811;
        D.6813 = (int) D.6812;
        D.7615 = __s2 + 3;
        D.7616 = *D.7615;
        D.7617 = (int) D.7616;
        __result = D.6813 - D.7617;
        <D.7614>:
        <D.7607>:
        <D.7600>:
      }
      D.5405 = __result;
    }
    iftmp.47 = -D.5405;
    goto <D.7618>;
    <D.7593>:
    D.6951 = v + 24;
    D.6952 = *D.6951;
    iftmp.47 = __builtin_strcmp (D.6952, "abc");
    <D.7618>:
    D.5406 = iftmp.47;
  }
  if (D.5406 != 0) goto <D.7619>; else goto <D.7620>;
  <D.7619>:
  D.6821 = FAILED ("Invalid value 23");
  return D.6821;
  <D.7620>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7622>; else goto <D.7623>;
    <D.7622>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = MEM[(gchar * *)v + 32B];
      D.6825 = "";
      D.6826 = MEM[(const unsigned char *)D.6825];
      D.6827 = (int) D.6826;
      D.7624 = *__s2;
      D.7625 = (int) D.7624;
      __result = D.6827 - D.7625;
      {
        D.7626 = __s2_len != 0;
        D.7627 = __result == 0;
        D.7628 = D.7626 & D.7627;
        if (D.7628 != 0) goto <D.7629>; else goto <D.7630>;
        <D.7629>:
        D.6835 = &MEM[(void *)"" + 1B];
        D.6836 = *D.6835;
        D.6837 = (int) D.6836;
        D.7631 = __s2 + 1;
        D.7632 = *D.7631;
        D.7633 = (int) D.7632;
        __result = D.6837 - D.7633;
        D.7634 = __s2_len > 1;
        D.7627 = __result == 0;
        D.7635 = D.7634 & D.7627;
        if (D.7635 != 0) goto <D.7636>; else goto <D.7637>;
        <D.7636>:
        D.6845 = &MEM[(void *)"" + 2B];
        D.6846 = *D.6845;
        D.6847 = (int) D.6846;
        D.7638 = __s2 + 2;
        D.7639 = *D.7638;
        D.7640 = (int) D.7639;
        __result = D.6847 - D.7640;
        D.7641 = __s2_len > 2;
        D.7627 = __result == 0;
        D.7642 = D.7641 & D.7627;
        if (D.7642 != 0) goto <D.7643>; else goto <D.7644>;
        <D.7643>:
        D.6855 = &MEM[(void *)"" + 3B];
        D.6856 = *D.6855;
        D.6857 = (int) D.6856;
        D.7645 = __s2 + 3;
        D.7646 = *D.7645;
        D.7647 = (int) D.7646;
        __result = D.6857 - D.7647;
        <D.7644>:
        <D.7637>:
        <D.7630>:
      }
      D.5414 = __result;
    }
    iftmp.48 = -D.5414;
    goto <D.7648>;
    <D.7623>:
    D.6983 = v + 32;
    D.6984 = *D.6983;
    D.6985 = MEM[(const unsigned char * {ref-all})D.6984];
    iftmp.48 = (int) D.6985;
    <D.7648>:
    D.5415 = iftmp.48;
  }
  if (D.5415 != 0) goto <D.7649>; else goto <D.7650>;
  <D.7649>:
  D.6821 = FAILED ("Invalid value 24");
  return D.6821;
  <D.7650>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = MEM[(gchar * *)v + 40B];
      D.6870 = "def";
      D.6871 = MEM[(const unsigned char *)D.6870];
      D.6872 = (int) D.6871;
      D.7654 = *__s2;
      D.7655 = (int) D.7654;
      __result = D.6872 - D.7655;
      {
        D.7656 = __s2_len != 0;
        D.7657 = __result == 0;
        D.7658 = D.7656 & D.7657;
        if (D.7658 != 0) goto <D.7659>; else goto <D.7660>;
        <D.7659>:
        D.6880 = &MEM[(void *)"def" + 1B];
        D.6881 = *D.6880;
        D.6882 = (int) D.6881;
        D.7661 = __s2 + 1;
        D.7662 = *D.7661;
        D.7663 = (int) D.7662;
        __result = D.6882 - D.7663;
        D.7664 = __s2_len > 1;
        D.7657 = __result == 0;
        D.7665 = D.7664 & D.7657;
        if (D.7665 != 0) goto <D.7666>; else goto <D.7667>;
        <D.7666>:
        D.6890 = &MEM[(void *)"def" + 2B];
        D.6891 = *D.6890;
        D.6892 = (int) D.6891;
        D.7668 = __s2 + 2;
        D.7669 = *D.7668;
        D.7670 = (int) D.7669;
        __result = D.6892 - D.7670;
        D.7671 = __s2_len > 2;
        D.7657 = __result == 0;
        D.7672 = D.7671 & D.7657;
        if (D.7672 != 0) goto <D.7673>; else goto <D.7674>;
        <D.7673>:
        D.6900 = &MEM[(void *)"def" + 3B];
        D.6901 = *D.6900;
        D.6902 = (int) D.6901;
        D.7675 = __s2 + 3;
        D.7676 = *D.7675;
        D.7677 = (int) D.7676;
        __result = D.6902 - D.7677;
        <D.7674>:
        <D.7667>:
        <D.7660>:
      }
      D.5423 = __result;
    }
    iftmp.49 = -D.5423;
    goto <D.7678>;
    <D.7653>:
    D.7028 = v + 40;
    D.7029 = *D.7028;
    iftmp.49 = __builtin_strcmp (D.7029, "def");
    <D.7678>:
    D.5424 = iftmp.49;
  }
  if (D.5424 != 0) goto <D.7679>; else goto <D.7680>;
  <D.7679>:
  D.6821 = FAILED ("Invalid value 25");
  return D.6821;
  <D.7680>:
  D.7032 = v + 48;
  D.7033 = *D.7032;
  if (D.7033 != 0B) goto <D.7681>; else goto <D.7682>;
  <D.7681>:
  D.6821 = FAILED ("Expected only 6 elements (5)");
  return D.6821;
  <D.7682>:
  monoeg_g_strfreev (v);
  D.6821 = 0B;
  return D.6821;
}


test_strreverse ()
{
  int D.5442;
  int D.5452;
  int D.5461;
  gchar * D.7690;
  gchar * res;
  gchar * a;
  gchar * a_target;
  gchar * b;
  gchar * b_target;
  gchar * c;
  gchar * c_target;
  void cleanup = <<< error >>>;

  res = 0B;
  a = monoeg_strdup ("onetwothree");
  a_target = "eerhtowteno";
  b = monoeg_strdup ("onetwothre");
  b_target = "erhtowteno";
  c = monoeg_strdup ("");
  c_target = "";
  monoeg_g_strreverse (a);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.5442 = __builtin_strcmp (a, a_target);
  }
  if (D.5442 != 0) goto <D.7684>; else goto <D.7685>;
  <D.7684>:
  res = FAILED ("strreverse failed. Expecting: \'%s\' and got \'%s\'\n", a, a_target);
  goto cleanup;
  <D.7685>:
  monoeg_g_strreverse (b);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.5452 = __builtin_strcmp (b, b_target);
  }
  if (D.5452 != 0) goto <D.7686>; else goto <D.7687>;
  <D.7686>:
  res = FAILED ("strreverse failed. Expecting: \'%s\' and got \'%s\'\n", b, b_target);
  goto cleanup;
  <D.7687>:
  monoeg_g_strreverse (c);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.5461 = __builtin_strcmp (c, c_target);
  }
  if (D.5461 != 0) goto <D.7688>; else goto <D.7689>;
  <D.7688>:
  res = FAILED ("strreverse failed. Expecting: \'%s\' and got \'%s\'\n", b, b_target);
  goto cleanup;
  <D.7689>:
  cleanup:
  monoeg_g_free (c);
  monoeg_g_free (b);
  monoeg_g_free (a);
  D.7690 = res;
  return D.7690;
}


test_strjoin ()
{
  int D.5473;
  int iftmp.50;
  int D.5472;
  char[3] * D.7695;
  unsigned char D.7696;
  int D.7697;
  unsigned char D.7698;
  int D.7699;
  _Bool D.7700;
  _Bool D.7701;
  _Bool D.7702;
  const unsigned char * D.7705;
  unsigned char D.7706;
  int D.7707;
  const unsigned char * D.7708;
  unsigned char D.7709;
  int D.7710;
  _Bool D.7711;
  _Bool D.7712;
  const unsigned char * D.7715;
  unsigned char D.7716;
  int D.7717;
  const unsigned char * D.7718;
  unsigned char D.7719;
  int D.7720;
  _Bool D.7721;
  _Bool D.7722;
  const unsigned char * D.7725;
  unsigned char D.7726;
  int D.7727;
  const unsigned char * D.7728;
  unsigned char D.7729;
  int D.7730;
  gchar * D.7734;
  int D.5482;
  int iftmp.51;
  int D.5481;
  unsigned char D.7738;
  int D.7739;
  _Bool D.7740;
  _Bool D.7741;
  _Bool D.7742;
  const unsigned char * D.7745;
  unsigned char D.7746;
  int D.7747;
  _Bool D.7748;
  _Bool D.7749;
  const unsigned char * D.7752;
  unsigned char D.7753;
  int D.7754;
  _Bool D.7755;
  _Bool D.7756;
  const unsigned char * D.7759;
  unsigned char D.7760;
  int D.7761;
  int D.5491;
  int iftmp.52;
  int D.5490;
  char[4] * D.7768;
  unsigned char D.7769;
  int D.7770;
  unsigned char D.7771;
  int D.7772;
  _Bool D.7773;
  _Bool D.7774;
  _Bool D.7775;
  const unsigned char * D.7778;
  unsigned char D.7779;
  int D.7780;
  const unsigned char * D.7781;
  unsigned char D.7782;
  int D.7783;
  _Bool D.7784;
  _Bool D.7785;
  const unsigned char * D.7788;
  unsigned char D.7789;
  int D.7790;
  const unsigned char * D.7791;
  unsigned char D.7792;
  int D.7793;
  _Bool D.7794;
  _Bool D.7795;
  const unsigned char * D.7798;
  unsigned char D.7799;
  int D.7800;
  const unsigned char * D.7801;
  unsigned char D.7802;
  int D.7803;
  int D.5500;
  int iftmp.53;
  int D.5499;
  char[20] * D.7810;
  unsigned char D.7811;
  int D.7812;
  unsigned char D.7813;
  int D.7814;
  _Bool D.7815;
  _Bool D.7816;
  _Bool D.7817;
  const unsigned char * D.7820;
  unsigned char D.7821;
  int D.7822;
  const unsigned char * D.7823;
  unsigned char D.7824;
  int D.7825;
  _Bool D.7826;
  _Bool D.7827;
  const unsigned char * D.7830;
  unsigned char D.7831;
  int D.7832;
  const unsigned char * D.7833;
  unsigned char D.7834;
  int D.7835;
  _Bool D.7836;
  _Bool D.7837;
  const unsigned char * D.7840;
  unsigned char D.7841;
  int D.7842;
  const unsigned char * D.7843;
  unsigned char D.7844;
  int D.7845;
  int D.5509;
  int iftmp.54;
  int D.5508;
  char[1] * D.7855;
  unsigned char D.7856;
  int D.7857;
  unsigned char D.7858;
  int D.7859;
  _Bool D.7860;
  _Bool D.7861;
  _Bool D.7862;
  const unsigned char * D.7865;
  unsigned char D.7866;
  int D.7867;
  const unsigned char * D.7868;
  unsigned char D.7869;
  int D.7870;
  _Bool D.7871;
  _Bool D.7872;
  const unsigned char * D.7875;
  unsigned char D.7876;
  int D.7877;
  const unsigned char * D.7878;
  unsigned char D.7879;
  int D.7880;
  _Bool D.7881;
  _Bool D.7882;
  const unsigned char * D.7885;
  unsigned char D.7886;
  int D.7887;
  const unsigned char * D.7888;
  unsigned char D.7889;
  int D.7890;
  unsigned char D.7892;
  char * s;

  s = monoeg_g_strjoin (0B, "a", "b", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.7695 = "ab";
      D.7696 = MEM[(const unsigned char *)D.7695];
      D.7697 = (int) D.7696;
      D.7698 = *__s2;
      D.7699 = (int) D.7698;
      __result = D.7697 - D.7699;
      {
        D.7700 = __s2_len != 0;
        D.7701 = __result == 0;
        D.7702 = D.7700 & D.7701;
        if (D.7702 != 0) goto <D.7703>; else goto <D.7704>;
        <D.7703>:
        D.7705 = &MEM[(void *)"ab" + 1B];
        D.7706 = *D.7705;
        D.7707 = (int) D.7706;
        D.7708 = __s2 + 1;
        D.7709 = *D.7708;
        D.7710 = (int) D.7709;
        __result = D.7707 - D.7710;
        D.7711 = __s2_len > 1;
        D.7701 = __result == 0;
        D.7712 = D.7711 & D.7701;
        if (D.7712 != 0) goto <D.7713>; else goto <D.7714>;
        <D.7713>:
        D.7715 = &MEM[(void *)"ab" + 2B];
        D.7716 = *D.7715;
        D.7717 = (int) D.7716;
        D.7718 = __s2 + 2;
        D.7719 = *D.7718;
        D.7720 = (int) D.7719;
        __result = D.7717 - D.7720;
        D.7721 = __s2_len > 2;
        D.7701 = __result == 0;
        D.7722 = D.7721 & D.7701;
        if (D.7722 != 0) goto <D.7723>; else goto <D.7724>;
        <D.7723>:
        D.7725 = &MEM[(void *)"ab" + 3B];
        D.7726 = *D.7725;
        D.7727 = (int) D.7726;
        D.7728 = __s2 + 3;
        D.7729 = *D.7728;
        D.7730 = (int) D.7729;
        __result = D.7727 - D.7730;
        <D.7724>:
        <D.7714>:
        <D.7704>:
      }
      D.5472 = __result;
    }
    iftmp.50 = -D.5472;
    goto <D.7731>;
    <D.7694>:
    iftmp.50 = __builtin_strcmp (s, "ab");
    <D.7731>:
    D.5473 = iftmp.50;
  }
  if (D.5473 != 0) goto <D.7732>; else goto <D.7733>;
  <D.7732>:
  D.7734 = FAILED ("Join of two strings with no separator fails");
  return D.7734;
  <D.7733>:
  monoeg_g_free (s);
  s = monoeg_g_strjoin ("", "a", "b", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.7695 = "ab";
      D.7696 = MEM[(const unsigned char *)D.7695];
      D.7697 = (int) D.7696;
      D.7738 = *__s2;
      D.7739 = (int) D.7738;
      __result = D.7697 - D.7739;
      {
        D.7740 = __s2_len != 0;
        D.7741 = __result == 0;
        D.7742 = D.7740 & D.7741;
        if (D.7742 != 0) goto <D.7743>; else goto <D.7744>;
        <D.7743>:
        D.7705 = &MEM[(void *)"ab" + 1B];
        D.7706 = *D.7705;
        D.7707 = (int) D.7706;
        D.7745 = __s2 + 1;
        D.7746 = *D.7745;
        D.7747 = (int) D.7746;
        __result = D.7707 - D.7747;
        D.7748 = __s2_len > 1;
        D.7741 = __result == 0;
        D.7749 = D.7748 & D.7741;
        if (D.7749 != 0) goto <D.7750>; else goto <D.7751>;
        <D.7750>:
        D.7715 = &MEM[(void *)"ab" + 2B];
        D.7716 = *D.7715;
        D.7717 = (int) D.7716;
        D.7752 = __s2 + 2;
        D.7753 = *D.7752;
        D.7754 = (int) D.7753;
        __result = D.7717 - D.7754;
        D.7755 = __s2_len > 2;
        D.7741 = __result == 0;
        D.7756 = D.7755 & D.7741;
        if (D.7756 != 0) goto <D.7757>; else goto <D.7758>;
        <D.7757>:
        D.7725 = &MEM[(void *)"ab" + 3B];
        D.7726 = *D.7725;
        D.7727 = (int) D.7726;
        D.7759 = __s2 + 3;
        D.7760 = *D.7759;
        D.7761 = (int) D.7760;
        __result = D.7727 - D.7761;
        <D.7758>:
        <D.7751>:
        <D.7744>:
      }
      D.5481 = __result;
    }
    iftmp.51 = -D.5481;
    goto <D.7762>;
    <D.7737>:
    iftmp.51 = __builtin_strcmp (s, "ab");
    <D.7762>:
    D.5482 = iftmp.51;
  }
  if (D.5482 != 0) goto <D.7763>; else goto <D.7764>;
  <D.7763>:
  D.7734 = FAILED ("Join of two strings with empty separator fails");
  return D.7734;
  <D.7764>:
  monoeg_g_free (s);
  s = monoeg_g_strjoin ("-", "a", "b", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.7768 = "a-b";
      D.7769 = MEM[(const unsigned char *)D.7768];
      D.7770 = (int) D.7769;
      D.7771 = *__s2;
      D.7772 = (int) D.7771;
      __result = D.7770 - D.7772;
      {
        D.7773 = __s2_len != 0;
        D.7774 = __result == 0;
        D.7775 = D.7773 & D.7774;
        if (D.7775 != 0) goto <D.7776>; else goto <D.7777>;
        <D.7776>:
        D.7778 = &MEM[(void *)"a-b" + 1B];
        D.7779 = *D.7778;
        D.7780 = (int) D.7779;
        D.7781 = __s2 + 1;
        D.7782 = *D.7781;
        D.7783 = (int) D.7782;
        __result = D.7780 - D.7783;
        D.7784 = __s2_len > 1;
        D.7774 = __result == 0;
        D.7785 = D.7784 & D.7774;
        if (D.7785 != 0) goto <D.7786>; else goto <D.7787>;
        <D.7786>:
        D.7788 = &MEM[(void *)"a-b" + 2B];
        D.7789 = *D.7788;
        D.7790 = (int) D.7789;
        D.7791 = __s2 + 2;
        D.7792 = *D.7791;
        D.7793 = (int) D.7792;
        __result = D.7790 - D.7793;
        D.7794 = __s2_len > 2;
        D.7774 = __result == 0;
        D.7795 = D.7794 & D.7774;
        if (D.7795 != 0) goto <D.7796>; else goto <D.7797>;
        <D.7796>:
        D.7798 = &MEM[(void *)"a-b" + 3B];
        D.7799 = *D.7798;
        D.7800 = (int) D.7799;
        D.7801 = __s2 + 3;
        D.7802 = *D.7801;
        D.7803 = (int) D.7802;
        __result = D.7800 - D.7803;
        <D.7797>:
        <D.7787>:
        <D.7777>:
      }
      D.5490 = __result;
    }
    iftmp.52 = -D.5490;
    goto <D.7804>;
    <D.7767>:
    iftmp.52 = __builtin_strcmp (s, "a-b");
    <D.7804>:
    D.5491 = iftmp.52;
  }
  if (D.5491 != 0) goto <D.7805>; else goto <D.7806>;
  <D.7805>:
  D.7734 = FAILED ("Join of two strings with separator fails");
  return D.7734;
  <D.7806>:
  monoeg_g_free (s);
  s = monoeg_g_strjoin ("-", "aaaa", "bbbb", "cccc", "dddd", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 19;
    if (__s2_len <= 3) goto <D.7808>; else goto <D.7809>;
    <D.7808>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7810 = "aaaa-bbbb-cccc-dddd";
      D.7811 = MEM[(const unsigned char *)D.7810];
      D.7812 = (int) D.7811;
      D.7813 = *__s2;
      D.7814 = (int) D.7813;
      __result = D.7812 - D.7814;
      {
        D.7815 = __s2_len != 0;
        D.7816 = __result == 0;
        D.7817 = D.7815 & D.7816;
        if (D.7817 != 0) goto <D.7818>; else goto <D.7819>;
        <D.7818>:
        D.7820 = &MEM[(void *)"aaaa-bbbb-cccc-dddd" + 1B];
        D.7821 = *D.7820;
        D.7822 = (int) D.7821;
        D.7823 = __s2 + 1;
        D.7824 = *D.7823;
        D.7825 = (int) D.7824;
        __result = D.7822 - D.7825;
        D.7826 = __s2_len > 1;
        D.7816 = __result == 0;
        D.7827 = D.7826 & D.7816;
        if (D.7827 != 0) goto <D.7828>; else goto <D.7829>;
        <D.7828>:
        D.7830 = &MEM[(void *)"aaaa-bbbb-cccc-dddd" + 2B];
        D.7831 = *D.7830;
        D.7832 = (int) D.7831;
        D.7833 = __s2 + 2;
        D.7834 = *D.7833;
        D.7835 = (int) D.7834;
        __result = D.7832 - D.7835;
        D.7836 = __s2_len > 2;
        D.7816 = __result == 0;
        D.7837 = D.7836 & D.7816;
        if (D.7837 != 0) goto <D.7838>; else goto <D.7839>;
        <D.7838>:
        D.7840 = &MEM[(void *)"aaaa-bbbb-cccc-dddd" + 3B];
        D.7841 = *D.7840;
        D.7842 = (int) D.7841;
        D.7843 = __s2 + 3;
        D.7844 = *D.7843;
        D.7845 = (int) D.7844;
        __result = D.7842 - D.7845;
        <D.7839>:
        <D.7829>:
        <D.7819>:
      }
      D.5499 = __result;
    }
    iftmp.53 = -D.5499;
    goto <D.7846>;
    <D.7809>:
    iftmp.53 = __builtin_strcmp (s, "aaaa-bbbb-cccc-dddd");
    <D.7846>:
    D.5500 = iftmp.53;
  }
  if (D.5500 != 0) goto <D.7847>; else goto <D.7848>;
  <D.7847>:
  D.7734 = FAILED ("Join of multiple strings fails");
  return D.7734;
  <D.7848>:
  monoeg_g_free (s);
  s = monoeg_g_strjoin ("-", 0B);
  if (s == 0B) goto <D.7849>; else goto <D.7851>;
  <D.7851>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.7853>; else goto <D.7854>;
    <D.7853>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.7855 = "";
      D.7856 = MEM[(const unsigned char *)D.7855];
      D.7857 = (int) D.7856;
      D.7858 = *__s2;
      D.7859 = (int) D.7858;
      __result = D.7857 - D.7859;
      {
        D.7860 = __s2_len != 0;
        D.7861 = __result == 0;
        D.7862 = D.7860 & D.7861;
        if (D.7862 != 0) goto <D.7863>; else goto <D.7864>;
        <D.7863>:
        D.7865 = &MEM[(void *)"" + 1B];
        D.7866 = *D.7865;
        D.7867 = (int) D.7866;
        D.7868 = __s2 + 1;
        D.7869 = *D.7868;
        D.7870 = (int) D.7869;
        __result = D.7867 - D.7870;
        D.7871 = __s2_len > 1;
        D.7861 = __result == 0;
        D.7872 = D.7871 & D.7861;
        if (D.7872 != 0) goto <D.7873>; else goto <D.7874>;
        <D.7873>:
        D.7875 = &MEM[(void *)"" + 2B];
        D.7876 = *D.7875;
        D.7877 = (int) D.7876;
        D.7878 = __s2 + 2;
        D.7879 = *D.7878;
        D.7880 = (int) D.7879;
        __result = D.7877 - D.7880;
        D.7881 = __s2_len > 2;
        D.7861 = __result == 0;
        D.7882 = D.7881 & D.7861;
        if (D.7882 != 0) goto <D.7883>; else goto <D.7884>;
        <D.7883>:
        D.7885 = &MEM[(void *)"" + 3B];
        D.7886 = *D.7885;
        D.7887 = (int) D.7886;
        D.7888 = __s2 + 3;
        D.7889 = *D.7888;
        D.7890 = (int) D.7889;
        __result = D.7887 - D.7890;
        <D.7884>:
        <D.7874>:
        <D.7864>:
      }
      D.5508 = __result;
    }
    iftmp.54 = -D.5508;
    goto <D.7891>;
    <D.7854>:
    D.7892 = MEM[(const unsigned char * {ref-all})s];
    iftmp.54 = (int) D.7892;
    <D.7891>:
    D.5509 = iftmp.54;
  }
  if (D.5509 != 0) goto <D.7849>; else goto <D.7850>;
  <D.7849>:
  D.7734 = FAILED ("Failed to join empty arguments");
  return D.7734;
  <D.7850>:
  monoeg_g_free (s);
  D.7734 = 0B;
  return D.7734;
}


test_strchug ()
{
  int D.5521;
  int iftmp.55;
  int D.5517;
  char[5] * D.7897;
  unsigned char D.7898;
  int D.7899;
  unsigned char D.7900;
  int D.7901;
  _Bool D.7902;
  _Bool D.7903;
  _Bool D.7904;
  const unsigned char * D.7907;
  unsigned char D.7908;
  int D.7909;
  const unsigned char * D.7910;
  unsigned char D.7911;
  int D.7912;
  _Bool D.7913;
  _Bool D.7914;
  const unsigned char * D.7917;
  unsigned char D.7918;
  int D.7919;
  const unsigned char * D.7920;
  unsigned char D.7921;
  int D.7922;
  _Bool D.7923;
  _Bool D.7924;
  const unsigned char * D.7927;
  unsigned char D.7928;
  int D.7929;
  const unsigned char * D.7930;
  unsigned char D.7931;
  int D.7932;
  struct _IO_FILE * stderr.56;
  gchar * D.7937;
  char * str;

  str = monoeg_strdup (" \t\n hola");
  monoeg_g_strchug (str);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 4;
    if (__s1_len <= 3) goto <D.7895>; else goto <D.7896>;
    <D.7895>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.7897 = "hola";
      D.7898 = MEM[(const unsigned char *)D.7897];
      D.7899 = (int) D.7898;
      D.7900 = *__s2;
      D.7901 = (int) D.7900;
      __result = D.7899 - D.7901;
      {
        D.7902 = __s1_len != 0;
        D.7903 = __result == 0;
        D.7904 = D.7902 & D.7903;
        if (D.7904 != 0) goto <D.7905>; else goto <D.7906>;
        <D.7905>:
        D.7907 = &MEM[(void *)"hola" + 1B];
        D.7908 = *D.7907;
        D.7909 = (int) D.7908;
        D.7910 = __s2 + 1;
        D.7911 = *D.7910;
        D.7912 = (int) D.7911;
        __result = D.7909 - D.7912;
        D.7913 = __s1_len > 1;
        D.7903 = __result == 0;
        D.7914 = D.7913 & D.7903;
        if (D.7914 != 0) goto <D.7915>; else goto <D.7916>;
        <D.7915>:
        D.7917 = &MEM[(void *)"hola" + 2B];
        D.7918 = *D.7917;
        D.7919 = (int) D.7918;
        D.7920 = __s2 + 2;
        D.7921 = *D.7920;
        D.7922 = (int) D.7921;
        __result = D.7919 - D.7922;
        D.7923 = __s1_len > 2;
        D.7903 = __result == 0;
        D.7924 = D.7923 & D.7903;
        if (D.7924 != 0) goto <D.7925>; else goto <D.7926>;
        <D.7925>:
        D.7927 = &MEM[(void *)"hola" + 3B];
        D.7928 = *D.7927;
        D.7929 = (int) D.7928;
        D.7930 = __s2 + 3;
        D.7931 = *D.7930;
        D.7932 = (int) D.7931;
        __result = D.7929 - D.7932;
        <D.7926>:
        <D.7916>:
        <D.7906>:
      }
      D.5517 = __result;
    }
    iftmp.55 = D.5517;
    goto <D.7933>;
    <D.7896>:
    iftmp.55 = __builtin_strcmp ("hola", str);
    <D.7933>:
    D.5521 = iftmp.55;
  }
  if (D.5521 != 0) goto <D.7934>; else goto <D.7935>;
  <D.7934>:
  stderr.56 = stderr;
  fprintf (stderr.56, "%s\n", str);
  monoeg_g_free (str);
  D.7937 = FAILED ("Failed.");
  return D.7937;
  <D.7935>:
  monoeg_g_free (str);
  D.7937 = 0B;
  return D.7937;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.7939;

  D.7939 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.7939;
}


test_strchomp ()
{
  int D.5533;
  int iftmp.57;
  int D.5529;
  char[5] * D.7944;
  unsigned char D.7945;
  int D.7946;
  unsigned char D.7947;
  int D.7948;
  _Bool D.7949;
  _Bool D.7950;
  _Bool D.7951;
  const unsigned char * D.7954;
  unsigned char D.7955;
  int D.7956;
  const unsigned char * D.7957;
  unsigned char D.7958;
  int D.7959;
  _Bool D.7960;
  _Bool D.7961;
  const unsigned char * D.7964;
  unsigned char D.7965;
  int D.7966;
  const unsigned char * D.7967;
  unsigned char D.7968;
  int D.7969;
  _Bool D.7970;
  _Bool D.7971;
  const unsigned char * D.7974;
  unsigned char D.7975;
  int D.7976;
  const unsigned char * D.7977;
  unsigned char D.7978;
  int D.7979;
  struct _IO_FILE * stderr.58;
  gchar * D.7984;
  char * str;

  str = monoeg_strdup ("hola  \t");
  monoeg_g_strchomp (str);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 4;
    if (__s1_len <= 3) goto <D.7942>; else goto <D.7943>;
    <D.7942>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.7944 = "hola";
      D.7945 = MEM[(const unsigned char *)D.7944];
      D.7946 = (int) D.7945;
      D.7947 = *__s2;
      D.7948 = (int) D.7947;
      __result = D.7946 - D.7948;
      {
        D.7949 = __s1_len != 0;
        D.7950 = __result == 0;
        D.7951 = D.7949 & D.7950;
        if (D.7951 != 0) goto <D.7952>; else goto <D.7953>;
        <D.7952>:
        D.7954 = &MEM[(void *)"hola" + 1B];
        D.7955 = *D.7954;
        D.7956 = (int) D.7955;
        D.7957 = __s2 + 1;
        D.7958 = *D.7957;
        D.7959 = (int) D.7958;
        __result = D.7956 - D.7959;
        D.7960 = __s1_len > 1;
        D.7950 = __result == 0;
        D.7961 = D.7960 & D.7950;
        if (D.7961 != 0) goto <D.7962>; else goto <D.7963>;
        <D.7962>:
        D.7964 = &MEM[(void *)"hola" + 2B];
        D.7965 = *D.7964;
        D.7966 = (int) D.7965;
        D.7967 = __s2 + 2;
        D.7968 = *D.7967;
        D.7969 = (int) D.7968;
        __result = D.7966 - D.7969;
        D.7970 = __s1_len > 2;
        D.7950 = __result == 0;
        D.7971 = D.7970 & D.7950;
        if (D.7971 != 0) goto <D.7972>; else goto <D.7973>;
        <D.7972>:
        D.7974 = &MEM[(void *)"hola" + 3B];
        D.7975 = *D.7974;
        D.7976 = (int) D.7975;
        D.7977 = __s2 + 3;
        D.7978 = *D.7977;
        D.7979 = (int) D.7978;
        __result = D.7976 - D.7979;
        <D.7973>:
        <D.7963>:
        <D.7953>:
      }
      D.5529 = __result;
    }
    iftmp.57 = D.5529;
    goto <D.7980>;
    <D.7943>:
    iftmp.57 = __builtin_strcmp ("hola", str);
    <D.7980>:
    D.5533 = iftmp.57;
  }
  if (D.5533 != 0) goto <D.7981>; else goto <D.7982>;
  <D.7981>:
  stderr.58 = stderr;
  fprintf (stderr.58, "%s\n", str);
  monoeg_g_free (str);
  D.7984 = FAILED ("Failed.");
  return D.7984;
  <D.7982>:
  monoeg_g_free (str);
  D.7984 = 0B;
  return D.7984;
}


test_strstrip ()
{
  gchar * D.7986;
  int D.5545;
  int iftmp.59;
  int D.5541;
  char[5] * D.7990;
  unsigned char D.7991;
  int D.7992;
  unsigned char D.7993;
  int D.7994;
  _Bool D.7995;
  _Bool D.7996;
  _Bool D.7997;
  const unsigned char * D.8000;
  unsigned char D.8001;
  int D.8002;
  const unsigned char * D.8003;
  unsigned char D.8004;
  int D.8005;
  _Bool D.8006;
  _Bool D.8007;
  const unsigned char * D.8010;
  unsigned char D.8011;
  int D.8012;
  const unsigned char * D.8013;
  unsigned char D.8014;
  int D.8015;
  _Bool D.8016;
  _Bool D.8017;
  const unsigned char * D.8020;
  unsigned char D.8021;
  int D.8022;
  const unsigned char * D.8023;
  unsigned char D.8024;
  int D.8025;
  struct _IO_FILE * stderr.60;
  gchar * D.8030;
  char * str;

  str = monoeg_strdup (" \t hola   ");
  D.7986 = monoeg_g_strchomp (str);
  monoeg_g_strchug (D.7986);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 4;
    if (__s1_len <= 3) goto <D.7988>; else goto <D.7989>;
    <D.7988>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.7990 = "hola";
      D.7991 = MEM[(const unsigned char *)D.7990];
      D.7992 = (int) D.7991;
      D.7993 = *__s2;
      D.7994 = (int) D.7993;
      __result = D.7992 - D.7994;
      {
        D.7995 = __s1_len != 0;
        D.7996 = __result == 0;
        D.7997 = D.7995 & D.7996;
        if (D.7997 != 0) goto <D.7998>; else goto <D.7999>;
        <D.7998>:
        D.8000 = &MEM[(void *)"hola" + 1B];
        D.8001 = *D.8000;
        D.8002 = (int) D.8001;
        D.8003 = __s2 + 1;
        D.8004 = *D.8003;
        D.8005 = (int) D.8004;
        __result = D.8002 - D.8005;
        D.8006 = __s1_len > 1;
        D.7996 = __result == 0;
        D.8007 = D.8006 & D.7996;
        if (D.8007 != 0) goto <D.8008>; else goto <D.8009>;
        <D.8008>:
        D.8010 = &MEM[(void *)"hola" + 2B];
        D.8011 = *D.8010;
        D.8012 = (int) D.8011;
        D.8013 = __s2 + 2;
        D.8014 = *D.8013;
        D.8015 = (int) D.8014;
        __result = D.8012 - D.8015;
        D.8016 = __s1_len > 2;
        D.7996 = __result == 0;
        D.8017 = D.8016 & D.7996;
        if (D.8017 != 0) goto <D.8018>; else goto <D.8019>;
        <D.8018>:
        D.8020 = &MEM[(void *)"hola" + 3B];
        D.8021 = *D.8020;
        D.8022 = (int) D.8021;
        D.8023 = __s2 + 3;
        D.8024 = *D.8023;
        D.8025 = (int) D.8024;
        __result = D.8022 - D.8025;
        <D.8019>:
        <D.8009>:
        <D.7999>:
      }
      D.5541 = __result;
    }
    iftmp.59 = D.5541;
    goto <D.8026>;
    <D.7989>:
    iftmp.59 = __builtin_strcmp ("hola", str);
    <D.8026>:
    D.5545 = iftmp.59;
  }
  if (D.5545 != 0) goto <D.8027>; else goto <D.8028>;
  <D.8027>:
  stderr.60 = stderr;
  fprintf (stderr.60, "%s\n", str);
  monoeg_g_free (str);
  D.8030 = FAILED ("Failed.");
  return D.8030;
  <D.8028>:
  monoeg_g_free (str);
  D.8030 = 0B;
  return D.8030;
}


test_filename_to_uri ()
{
  int D.5557;
  int iftmp.61;
  int D.5556;
  char[10] * D.8035;
  unsigned char D.8036;
  int D.8037;
  unsigned char D.8038;
  int D.8039;
  _Bool D.8040;
  _Bool D.8041;
  _Bool D.8042;
  const unsigned char * D.8045;
  unsigned char D.8046;
  int D.8047;
  const unsigned char * D.8048;
  unsigned char D.8049;
  int D.8050;
  _Bool D.8051;
  _Bool D.8052;
  const unsigned char * D.8055;
  unsigned char D.8056;
  int D.8057;
  const unsigned char * D.8058;
  unsigned char D.8059;
  int D.8060;
  _Bool D.8061;
  _Bool D.8062;
  const unsigned char * D.8065;
  unsigned char D.8066;
  int D.8067;
  const unsigned char * D.8068;
  unsigned char D.8069;
  int D.8070;
  gchar * D.8074;
  int D.5566;
  int iftmp.62;
  int D.5565;
  char[20] * D.8078;
  unsigned char D.8079;
  int D.8080;
  unsigned char D.8081;
  int D.8082;
  _Bool D.8083;
  _Bool D.8084;
  _Bool D.8085;
  const unsigned char * D.8088;
  unsigned char D.8089;
  int D.8090;
  const unsigned char * D.8091;
  unsigned char D.8092;
  int D.8093;
  _Bool D.8094;
  _Bool D.8095;
  const unsigned char * D.8098;
  unsigned char D.8099;
  int D.8100;
  const unsigned char * D.8101;
  unsigned char D.8102;
  int D.8103;
  _Bool D.8104;
  _Bool D.8105;
  const unsigned char * D.8108;
  unsigned char D.8109;
  int D.8110;
  const unsigned char * D.8111;
  unsigned char D.8112;
  int D.8113;
  int D.5575;
  int iftmp.63;
  int D.5574;
  char[23] * D.8120;
  unsigned char D.8121;
  int D.8122;
  unsigned char D.8123;
  int D.8124;
  _Bool D.8125;
  _Bool D.8126;
  _Bool D.8127;
  const unsigned char * D.8130;
  unsigned char D.8131;
  int D.8132;
  const unsigned char * D.8133;
  unsigned char D.8134;
  int D.8135;
  _Bool D.8136;
  _Bool D.8137;
  const unsigned char * D.8140;
  unsigned char D.8141;
  int D.8142;
  const unsigned char * D.8143;
  unsigned char D.8144;
  int D.8145;
  _Bool D.8146;
  _Bool D.8147;
  const unsigned char * D.8150;
  unsigned char D.8151;
  int D.8152;
  const unsigned char * D.8153;
  unsigned char D.8154;
  int D.8155;
  int D.5584;
  int iftmp.64;
  int D.5583;
  char[15] * D.8162;
  unsigned char D.8163;
  int D.8164;
  unsigned char D.8165;
  int D.8166;
  _Bool D.8167;
  _Bool D.8168;
  _Bool D.8169;
  const unsigned char * D.8172;
  unsigned char D.8173;
  int D.8174;
  const unsigned char * D.8175;
  unsigned char D.8176;
  int D.8177;
  _Bool D.8178;
  _Bool D.8179;
  const unsigned char * D.8182;
  unsigned char D.8183;
  int D.8184;
  const unsigned char * D.8185;
  unsigned char D.8186;
  int D.8187;
  _Bool D.8188;
  _Bool D.8189;
  const unsigned char * D.8192;
  unsigned char D.8193;
  int D.8194;
  const unsigned char * D.8195;
  unsigned char D.8196;
  int D.8197;
  int D.5593;
  int iftmp.65;
  int D.5592;
  char[21] * D.8204;
  unsigned char D.8205;
  int D.8206;
  unsigned char D.8207;
  int D.8208;
  _Bool D.8209;
  _Bool D.8210;
  _Bool D.8211;
  const unsigned char * D.8214;
  unsigned char D.8215;
  int D.8216;
  const unsigned char * D.8217;
  unsigned char D.8218;
  int D.8219;
  _Bool D.8220;
  _Bool D.8221;
  const unsigned char * D.8224;
  unsigned char D.8225;
  int D.8226;
  const unsigned char * D.8227;
  unsigned char D.8228;
  int D.8229;
  _Bool D.8230;
  _Bool D.8231;
  const unsigned char * D.8234;
  unsigned char D.8235;
  int D.8236;
  const unsigned char * D.8237;
  unsigned char D.8238;
  int D.8239;
  int D.5602;
  int iftmp.66;
  int D.5601;
  char[12] * D.8246;
  unsigned char D.8247;
  int D.8248;
  unsigned char D.8249;
  int D.8250;
  _Bool D.8251;
  _Bool D.8252;
  _Bool D.8253;
  const unsigned char * D.8256;
  unsigned char D.8257;
  int D.8258;
  const unsigned char * D.8259;
  unsigned char D.8260;
  int D.8261;
  _Bool D.8262;
  _Bool D.8263;
  const unsigned char * D.8266;
  unsigned char D.8267;
  int D.8268;
  const unsigned char * D.8269;
  unsigned char D.8270;
  int D.8271;
  _Bool D.8272;
  _Bool D.8273;
  const unsigned char * D.8276;
  unsigned char D.8277;
  int D.8278;
  const unsigned char * D.8279;
  unsigned char D.8280;
  int D.8281;
  int D.5611;
  int iftmp.67;
  int D.5610;
  char[105] * D.8288;
  unsigned char D.8289;
  int D.8290;
  unsigned char D.8291;
  int D.8292;
  _Bool D.8293;
  _Bool D.8294;
  _Bool D.8295;
  const unsigned char * D.8298;
  unsigned char D.8299;
  int D.8300;
  const unsigned char * D.8301;
  unsigned char D.8302;
  int D.8303;
  _Bool D.8304;
  _Bool D.8305;
  const unsigned char * D.8308;
  unsigned char D.8309;
  int D.8310;
  const unsigned char * D.8311;
  unsigned char D.8312;
  int D.8313;
  _Bool D.8314;
  _Bool D.8315;
  const unsigned char * D.8318;
  unsigned char D.8319;
  int D.8320;
  const unsigned char * D.8321;
  unsigned char D.8322;
  int D.8323;
  int D.5620;
  int iftmp.68;
  int D.5619;
  char[21] * D.8330;
  unsigned char D.8331;
  int D.8332;
  unsigned char D.8333;
  int D.8334;
  _Bool D.8335;
  _Bool D.8336;
  _Bool D.8337;
  const unsigned char * D.8340;
  unsigned char D.8341;
  int D.8342;
  const unsigned char * D.8343;
  unsigned char D.8344;
  int D.8345;
  _Bool D.8346;
  _Bool D.8347;
  const unsigned char * D.8350;
  unsigned char D.8351;
  int D.8352;
  const unsigned char * D.8353;
  unsigned char D.8354;
  int D.8355;
  _Bool D.8356;
  _Bool D.8357;
  const unsigned char * D.8360;
  unsigned char D.8361;
  int D.8362;
  const unsigned char * D.8363;
  unsigned char D.8364;
  int D.8365;
  int D.5629;
  int iftmp.69;
  int D.5628;
  char[18] * D.8372;
  unsigned char D.8373;
  int D.8374;
  unsigned char D.8375;
  int D.8376;
  _Bool D.8377;
  _Bool D.8378;
  _Bool D.8379;
  const unsigned char * D.8382;
  unsigned char D.8383;
  int D.8384;
  const unsigned char * D.8385;
  unsigned char D.8386;
  int D.8387;
  _Bool D.8388;
  _Bool D.8389;
  const unsigned char * D.8392;
  unsigned char D.8393;
  int D.8394;
  const unsigned char * D.8395;
  unsigned char D.8396;
  int D.8397;
  _Bool D.8398;
  _Bool D.8399;
  const unsigned char * D.8402;
  unsigned char D.8403;
  int D.8404;
  const unsigned char * D.8405;
  unsigned char D.8406;
  int D.8407;
  int D.5638;
  int iftmp.70;
  int D.5637;
  char[21] * D.8414;
  unsigned char D.8415;
  int D.8416;
  unsigned char D.8417;
  int D.8418;
  _Bool D.8419;
  _Bool D.8420;
  _Bool D.8421;
  const unsigned char * D.8424;
  unsigned char D.8425;
  int D.8426;
  const unsigned char * D.8427;
  unsigned char D.8428;
  int D.8429;
  _Bool D.8430;
  _Bool D.8431;
  const unsigned char * D.8434;
  unsigned char D.8435;
  int D.8436;
  const unsigned char * D.8437;
  unsigned char D.8438;
  int D.8439;
  _Bool D.8440;
  _Bool D.8441;
  const unsigned char * D.8444;
  unsigned char D.8445;
  int D.8446;
  const unsigned char * D.8447;
  unsigned char D.8448;
  int D.8449;
  int D.5647;
  int iftmp.71;
  int D.5646;
  char[21] * D.8456;
  unsigned char D.8457;
  int D.8458;
  unsigned char D.8459;
  int D.8460;
  _Bool D.8461;
  _Bool D.8462;
  _Bool D.8463;
  const unsigned char * D.8466;
  unsigned char D.8467;
  int D.8468;
  const unsigned char * D.8469;
  unsigned char D.8470;
  int D.8471;
  _Bool D.8472;
  _Bool D.8473;
  const unsigned char * D.8476;
  unsigned char D.8477;
  int D.8478;
  const unsigned char * D.8479;
  unsigned char D.8480;
  int D.8481;
  _Bool D.8482;
  _Bool D.8483;
  const unsigned char * D.8486;
  unsigned char D.8487;
  int D.8488;
  const unsigned char * D.8489;
  unsigned char D.8490;
  int D.8491;
  int D.5656;
  int iftmp.72;
  int D.5655;
  char[34] * D.8498;
  unsigned char D.8499;
  int D.8500;
  unsigned char D.8501;
  int D.8502;
  _Bool D.8503;
  _Bool D.8504;
  _Bool D.8505;
  const unsigned char * D.8508;
  unsigned char D.8509;
  int D.8510;
  const unsigned char * D.8511;
  unsigned char D.8512;
  int D.8513;
  _Bool D.8514;
  _Bool D.8515;
  const unsigned char * D.8518;
  unsigned char D.8519;
  int D.8520;
  const unsigned char * D.8521;
  unsigned char D.8522;
  int D.8523;
  _Bool D.8524;
  _Bool D.8525;
  const unsigned char * D.8528;
  unsigned char D.8529;
  int D.8530;
  const unsigned char * D.8531;
  unsigned char D.8532;
  int D.8533;
  int D.5665;
  int iftmp.73;
  int D.5664;
  char[25] * D.8540;
  unsigned char D.8541;
  int D.8542;
  unsigned char D.8543;
  int D.8544;
  _Bool D.8545;
  _Bool D.8546;
  _Bool D.8547;
  const unsigned char * D.8550;
  unsigned char D.8551;
  int D.8552;
  const unsigned char * D.8553;
  unsigned char D.8554;
  int D.8555;
  _Bool D.8556;
  _Bool D.8557;
  const unsigned char * D.8560;
  unsigned char D.8561;
  int D.8562;
  const unsigned char * D.8563;
  unsigned char D.8564;
  int D.8565;
  _Bool D.8566;
  _Bool D.8567;
  const unsigned char * D.8570;
  unsigned char D.8571;
  int D.8572;
  const unsigned char * D.8573;
  unsigned char D.8574;
  int D.8575;
  int D.5674;
  int iftmp.74;
  int D.5673;
  char[62] * D.8582;
  unsigned char D.8583;
  int D.8584;
  unsigned char D.8585;
  int D.8586;
  _Bool D.8587;
  _Bool D.8588;
  _Bool D.8589;
  const unsigned char * D.8592;
  unsigned char D.8593;
  int D.8594;
  const unsigned char * D.8595;
  unsigned char D.8596;
  int D.8597;
  _Bool D.8598;
  _Bool D.8599;
  const unsigned char * D.8602;
  unsigned char D.8603;
  int D.8604;
  const unsigned char * D.8605;
  unsigned char D.8606;
  int D.8607;
  _Bool D.8608;
  _Bool D.8609;
  const unsigned char * D.8612;
  unsigned char D.8613;
  int D.8614;
  const unsigned char * D.8615;
  unsigned char D.8616;
  int D.8617;
  char * s;

  s = monoeg_g_filename_to_uri ("/a", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 9;
    if (__s2_len <= 3) goto <D.8033>; else goto <D.8034>;
    <D.8033>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8035 = "file:///a";
      D.8036 = MEM[(const unsigned char *)D.8035];
      D.8037 = (int) D.8036;
      D.8038 = *__s2;
      D.8039 = (int) D.8038;
      __result = D.8037 - D.8039;
      {
        D.8040 = __s2_len != 0;
        D.8041 = __result == 0;
        D.8042 = D.8040 & D.8041;
        if (D.8042 != 0) goto <D.8043>; else goto <D.8044>;
        <D.8043>:
        D.8045 = &MEM[(void *)"file:///a" + 1B];
        D.8046 = *D.8045;
        D.8047 = (int) D.8046;
        D.8048 = __s2 + 1;
        D.8049 = *D.8048;
        D.8050 = (int) D.8049;
        __result = D.8047 - D.8050;
        D.8051 = __s2_len > 1;
        D.8041 = __result == 0;
        D.8052 = D.8051 & D.8041;
        if (D.8052 != 0) goto <D.8053>; else goto <D.8054>;
        <D.8053>:
        D.8055 = &MEM[(void *)"file:///a" + 2B];
        D.8056 = *D.8055;
        D.8057 = (int) D.8056;
        D.8058 = __s2 + 2;
        D.8059 = *D.8058;
        D.8060 = (int) D.8059;
        __result = D.8057 - D.8060;
        D.8061 = __s2_len > 2;
        D.8041 = __result == 0;
        D.8062 = D.8061 & D.8041;
        if (D.8062 != 0) goto <D.8063>; else goto <D.8064>;
        <D.8063>:
        D.8065 = &MEM[(void *)"file:///a" + 3B];
        D.8066 = *D.8065;
        D.8067 = (int) D.8066;
        D.8068 = __s2 + 3;
        D.8069 = *D.8068;
        D.8070 = (int) D.8069;
        __result = D.8067 - D.8070;
        <D.8064>:
        <D.8054>:
        <D.8044>:
      }
      D.5556 = __result;
    }
    iftmp.61 = -D.5556;
    goto <D.8071>;
    <D.8034>:
    iftmp.61 = __builtin_strcmp (s, "file:///a");
    <D.8071>:
    D.5557 = iftmp.61;
  }
  if (D.5557 != 0) goto <D.8072>; else goto <D.8073>;
  <D.8072>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///a");
  return D.8074;
  <D.8073>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/home/miguel", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 19;
    if (__s2_len <= 3) goto <D.8076>; else goto <D.8077>;
    <D.8076>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8078 = "file:///home/miguel";
      D.8079 = MEM[(const unsigned char *)D.8078];
      D.8080 = (int) D.8079;
      D.8081 = *__s2;
      D.8082 = (int) D.8081;
      __result = D.8080 - D.8082;
      {
        D.8083 = __s2_len != 0;
        D.8084 = __result == 0;
        D.8085 = D.8083 & D.8084;
        if (D.8085 != 0) goto <D.8086>; else goto <D.8087>;
        <D.8086>:
        D.8088 = &MEM[(void *)"file:///home/miguel" + 1B];
        D.8089 = *D.8088;
        D.8090 = (int) D.8089;
        D.8091 = __s2 + 1;
        D.8092 = *D.8091;
        D.8093 = (int) D.8092;
        __result = D.8090 - D.8093;
        D.8094 = __s2_len > 1;
        D.8084 = __result == 0;
        D.8095 = D.8094 & D.8084;
        if (D.8095 != 0) goto <D.8096>; else goto <D.8097>;
        <D.8096>:
        D.8098 = &MEM[(void *)"file:///home/miguel" + 2B];
        D.8099 = *D.8098;
        D.8100 = (int) D.8099;
        D.8101 = __s2 + 2;
        D.8102 = *D.8101;
        D.8103 = (int) D.8102;
        __result = D.8100 - D.8103;
        D.8104 = __s2_len > 2;
        D.8084 = __result == 0;
        D.8105 = D.8104 & D.8084;
        if (D.8105 != 0) goto <D.8106>; else goto <D.8107>;
        <D.8106>:
        D.8108 = &MEM[(void *)"file:///home/miguel" + 3B];
        D.8109 = *D.8108;
        D.8110 = (int) D.8109;
        D.8111 = __s2 + 3;
        D.8112 = *D.8111;
        D.8113 = (int) D.8112;
        __result = D.8110 - D.8113;
        <D.8107>:
        <D.8097>:
        <D.8087>:
      }
      D.5565 = __result;
    }
    iftmp.62 = -D.5565;
    goto <D.8114>;
    <D.8077>:
    iftmp.62 = __builtin_strcmp (s, "file:///home/miguel");
    <D.8114>:
    D.5566 = iftmp.62;
  }
  if (D.5566 != 0) goto <D.8115>; else goto <D.8116>;
  <D.8115>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///home/miguel");
  return D.8074;
  <D.8116>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/home/mig uel", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 22;
    if (__s2_len <= 3) goto <D.8118>; else goto <D.8119>;
    <D.8118>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8120 = "file:///home/mig%20uel";
      D.8121 = MEM[(const unsigned char *)D.8120];
      D.8122 = (int) D.8121;
      D.8123 = *__s2;
      D.8124 = (int) D.8123;
      __result = D.8122 - D.8124;
      {
        D.8125 = __s2_len != 0;
        D.8126 = __result == 0;
        D.8127 = D.8125 & D.8126;
        if (D.8127 != 0) goto <D.8128>; else goto <D.8129>;
        <D.8128>:
        D.8130 = &MEM[(void *)"file:///home/mig%20uel" + 1B];
        D.8131 = *D.8130;
        D.8132 = (int) D.8131;
        D.8133 = __s2 + 1;
        D.8134 = *D.8133;
        D.8135 = (int) D.8134;
        __result = D.8132 - D.8135;
        D.8136 = __s2_len > 1;
        D.8126 = __result == 0;
        D.8137 = D.8136 & D.8126;
        if (D.8137 != 0) goto <D.8138>; else goto <D.8139>;
        <D.8138>:
        D.8140 = &MEM[(void *)"file:///home/mig%20uel" + 2B];
        D.8141 = *D.8140;
        D.8142 = (int) D.8141;
        D.8143 = __s2 + 2;
        D.8144 = *D.8143;
        D.8145 = (int) D.8144;
        __result = D.8142 - D.8145;
        D.8146 = __s2_len > 2;
        D.8126 = __result == 0;
        D.8147 = D.8146 & D.8126;
        if (D.8147 != 0) goto <D.8148>; else goto <D.8149>;
        <D.8148>:
        D.8150 = &MEM[(void *)"file:///home/mig%20uel" + 3B];
        D.8151 = *D.8150;
        D.8152 = (int) D.8151;
        D.8153 = __s2 + 3;
        D.8154 = *D.8153;
        D.8155 = (int) D.8154;
        __result = D.8152 - D.8155;
        <D.8149>:
        <D.8139>:
        <D.8129>:
      }
      D.5574 = __result;
    }
    iftmp.63 = -D.5574;
    goto <D.8156>;
    <D.8119>:
    iftmp.63 = __builtin_strcmp (s, "file:///home/mig%20uel");
    <D.8156>:
    D.5575 = iftmp.63;
  }
  if (D.5575 != 0) goto <D.8157>; else goto <D.8158>;
  <D.8157>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///home/mig%20uel");
  return D.8074;
  <D.8158>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/Ã¡", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 14;
    if (__s2_len <= 3) goto <D.8160>; else goto <D.8161>;
    <D.8160>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8162 = "file:///%C3%A1";
      D.8163 = MEM[(const unsigned char *)D.8162];
      D.8164 = (int) D.8163;
      D.8165 = *__s2;
      D.8166 = (int) D.8165;
      __result = D.8164 - D.8166;
      {
        D.8167 = __s2_len != 0;
        D.8168 = __result == 0;
        D.8169 = D.8167 & D.8168;
        if (D.8169 != 0) goto <D.8170>; else goto <D.8171>;
        <D.8170>:
        D.8172 = &MEM[(void *)"file:///%C3%A1" + 1B];
        D.8173 = *D.8172;
        D.8174 = (int) D.8173;
        D.8175 = __s2 + 1;
        D.8176 = *D.8175;
        D.8177 = (int) D.8176;
        __result = D.8174 - D.8177;
        D.8178 = __s2_len > 1;
        D.8168 = __result == 0;
        D.8179 = D.8178 & D.8168;
        if (D.8179 != 0) goto <D.8180>; else goto <D.8181>;
        <D.8180>:
        D.8182 = &MEM[(void *)"file:///%C3%A1" + 2B];
        D.8183 = *D.8182;
        D.8184 = (int) D.8183;
        D.8185 = __s2 + 2;
        D.8186 = *D.8185;
        D.8187 = (int) D.8186;
        __result = D.8184 - D.8187;
        D.8188 = __s2_len > 2;
        D.8168 = __result == 0;
        D.8189 = D.8188 & D.8168;
        if (D.8189 != 0) goto <D.8190>; else goto <D.8191>;
        <D.8190>:
        D.8192 = &MEM[(void *)"file:///%C3%A1" + 3B];
        D.8193 = *D.8192;
        D.8194 = (int) D.8193;
        D.8195 = __s2 + 3;
        D.8196 = *D.8195;
        D.8197 = (int) D.8196;
        __result = D.8194 - D.8197;
        <D.8191>:
        <D.8181>:
        <D.8171>:
      }
      D.5583 = __result;
    }
    iftmp.64 = -D.5583;
    goto <D.8198>;
    <D.8161>:
    iftmp.64 = __builtin_strcmp (s, "file:///%C3%A1");
    <D.8198>:
    D.5584 = iftmp.64;
  }
  if (D.5584 != 0) goto <D.8199>; else goto <D.8200>;
  <D.8199>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///%C3%A1");
  return D.8074;
  <D.8200>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/Ã¡/octal", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.8204 = "file:///%C3%A1/octal";
      D.8205 = MEM[(const unsigned char *)D.8204];
      D.8206 = (int) D.8205;
      D.8207 = *__s2;
      D.8208 = (int) D.8207;
      __result = D.8206 - D.8208;
      {
        D.8209 = __s2_len != 0;
        D.8210 = __result == 0;
        D.8211 = D.8209 & D.8210;
        if (D.8211 != 0) goto <D.8212>; else goto <D.8213>;
        <D.8212>:
        D.8214 = &MEM[(void *)"file:///%C3%A1/octal" + 1B];
        D.8215 = *D.8214;
        D.8216 = (int) D.8215;
        D.8217 = __s2 + 1;
        D.8218 = *D.8217;
        D.8219 = (int) D.8218;
        __result = D.8216 - D.8219;
        D.8220 = __s2_len > 1;
        D.8210 = __result == 0;
        D.8221 = D.8220 & D.8210;
        if (D.8221 != 0) goto <D.8222>; else goto <D.8223>;
        <D.8222>:
        D.8224 = &MEM[(void *)"file:///%C3%A1/octal" + 2B];
        D.8225 = *D.8224;
        D.8226 = (int) D.8225;
        D.8227 = __s2 + 2;
        D.8228 = *D.8227;
        D.8229 = (int) D.8228;
        __result = D.8226 - D.8229;
        D.8230 = __s2_len > 2;
        D.8210 = __result == 0;
        D.8231 = D.8230 & D.8210;
        if (D.8231 != 0) goto <D.8232>; else goto <D.8233>;
        <D.8232>:
        D.8234 = &MEM[(void *)"file:///%C3%A1/octal" + 3B];
        D.8235 = *D.8234;
        D.8236 = (int) D.8235;
        D.8237 = __s2 + 3;
        D.8238 = *D.8237;
        D.8239 = (int) D.8238;
        __result = D.8236 - D.8239;
        <D.8233>:
        <D.8223>:
        <D.8213>:
      }
      D.5592 = __result;
    }
    iftmp.65 = -D.5592;
    goto <D.8240>;
    <D.8203>:
    iftmp.65 = __builtin_strcmp (s, "file:///%C3%A1/octal");
    <D.8240>:
    D.5593 = iftmp.65;
  }
  if (D.5593 != 0) goto <D.8241>; else goto <D.8242>;
  <D.8241>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///%C3%A1/octal");
  return D.8074;
  <D.8242>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/%", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.8244>; else goto <D.8245>;
    <D.8244>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8246 = "file:///%25";
      D.8247 = MEM[(const unsigned char *)D.8246];
      D.8248 = (int) D.8247;
      D.8249 = *__s2;
      D.8250 = (int) D.8249;
      __result = D.8248 - D.8250;
      {
        D.8251 = __s2_len != 0;
        D.8252 = __result == 0;
        D.8253 = D.8251 & D.8252;
        if (D.8253 != 0) goto <D.8254>; else goto <D.8255>;
        <D.8254>:
        D.8256 = &MEM[(void *)"file:///%25" + 1B];
        D.8257 = *D.8256;
        D.8258 = (int) D.8257;
        D.8259 = __s2 + 1;
        D.8260 = *D.8259;
        D.8261 = (int) D.8260;
        __result = D.8258 - D.8261;
        D.8262 = __s2_len > 1;
        D.8252 = __result == 0;
        D.8263 = D.8262 & D.8252;
        if (D.8263 != 0) goto <D.8264>; else goto <D.8265>;
        <D.8264>:
        D.8266 = &MEM[(void *)"file:///%25" + 2B];
        D.8267 = *D.8266;
        D.8268 = (int) D.8267;
        D.8269 = __s2 + 2;
        D.8270 = *D.8269;
        D.8271 = (int) D.8270;
        __result = D.8268 - D.8271;
        D.8272 = __s2_len > 2;
        D.8252 = __result == 0;
        D.8273 = D.8272 & D.8252;
        if (D.8273 != 0) goto <D.8274>; else goto <D.8275>;
        <D.8274>:
        D.8276 = &MEM[(void *)"file:///%25" + 3B];
        D.8277 = *D.8276;
        D.8278 = (int) D.8277;
        D.8279 = __s2 + 3;
        D.8280 = *D.8279;
        D.8281 = (int) D.8280;
        __result = D.8278 - D.8281;
        <D.8275>:
        <D.8265>:
        <D.8255>:
      }
      D.5601 = __result;
    }
    iftmp.66 = -D.5601;
    goto <D.8282>;
    <D.8245>:
    iftmp.66 = __builtin_strcmp (s, "file:///%25");
    <D.8282>:
    D.5602 = iftmp.66;
  }
  if (D.5602 != 0) goto <D.8283>; else goto <D.8284>;
  <D.8283>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///%25");
  return D.8074;
  <D.8284>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/\1\2\3\4\5\6\7\b\t\n\v\f\r ", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 104;
    if (__s2_len <= 3) goto <D.8286>; else goto <D.8287>;
    <D.8286>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8288 = "file:///%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20";
      D.8289 = MEM[(const unsigned char *)D.8288];
      D.8290 = (int) D.8289;
      D.8291 = *__s2;
      D.8292 = (int) D.8291;
      __result = D.8290 - D.8292;
      {
        D.8293 = __s2_len != 0;
        D.8294 = __result == 0;
        D.8295 = D.8293 & D.8294;
        if (D.8295 != 0) goto <D.8296>; else goto <D.8297>;
        <D.8296>:
        D.8298 = &MEM[(void *)"file:///%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20" + 1B];
        D.8299 = *D.8298;
        D.8300 = (int) D.8299;
        D.8301 = __s2 + 1;
        D.8302 = *D.8301;
        D.8303 = (int) D.8302;
        __result = D.8300 - D.8303;
        D.8304 = __s2_len > 1;
        D.8294 = __result == 0;
        D.8305 = D.8304 & D.8294;
        if (D.8305 != 0) goto <D.8306>; else goto <D.8307>;
        <D.8306>:
        D.8308 = &MEM[(void *)"file:///%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20" + 2B];
        D.8309 = *D.8308;
        D.8310 = (int) D.8309;
        D.8311 = __s2 + 2;
        D.8312 = *D.8311;
        D.8313 = (int) D.8312;
        __result = D.8310 - D.8313;
        D.8314 = __s2_len > 2;
        D.8294 = __result == 0;
        D.8315 = D.8314 & D.8294;
        if (D.8315 != 0) goto <D.8316>; else goto <D.8317>;
        <D.8316>:
        D.8318 = &MEM[(void *)"file:///%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20" + 3B];
        D.8319 = *D.8318;
        D.8320 = (int) D.8319;
        D.8321 = __s2 + 3;
        D.8322 = *D.8321;
        D.8323 = (int) D.8322;
        __result = D.8320 - D.8323;
        <D.8317>:
        <D.8307>:
        <D.8297>:
      }
      D.5610 = __result;
    }
    iftmp.67 = -D.5610;
    goto <D.8324>;
    <D.8287>:
    iftmp.67 = __builtin_strcmp (s, "file:///%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20");
    <D.8324>:
    D.5611 = iftmp.67;
  }
  if (D.5611 != 0) goto <D.8325>; else goto <D.8326>;
  <D.8325>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20");
  return D.8074;
  <D.8326>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/!$&\'()*+,-./", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.8330 = "file:///!$&\'()*+,-./";
      D.8331 = MEM[(const unsigned char *)D.8330];
      D.8332 = (int) D.8331;
      D.8333 = *__s2;
      D.8334 = (int) D.8333;
      __result = D.8332 - D.8334;
      {
        D.8335 = __s2_len != 0;
        D.8336 = __result == 0;
        D.8337 = D.8335 & D.8336;
        if (D.8337 != 0) goto <D.8338>; else goto <D.8339>;
        <D.8338>:
        D.8340 = &MEM[(void *)"file:///!$&\'()*+,-./" + 1B];
        D.8341 = *D.8340;
        D.8342 = (int) D.8341;
        D.8343 = __s2 + 1;
        D.8344 = *D.8343;
        D.8345 = (int) D.8344;
        __result = D.8342 - D.8345;
        D.8346 = __s2_len > 1;
        D.8336 = __result == 0;
        D.8347 = D.8346 & D.8336;
        if (D.8347 != 0) goto <D.8348>; else goto <D.8349>;
        <D.8348>:
        D.8350 = &MEM[(void *)"file:///!$&\'()*+,-./" + 2B];
        D.8351 = *D.8350;
        D.8352 = (int) D.8351;
        D.8353 = __s2 + 2;
        D.8354 = *D.8353;
        D.8355 = (int) D.8354;
        __result = D.8352 - D.8355;
        D.8356 = __s2_len > 2;
        D.8336 = __result == 0;
        D.8357 = D.8356 & D.8336;
        if (D.8357 != 0) goto <D.8358>; else goto <D.8359>;
        <D.8358>:
        D.8360 = &MEM[(void *)"file:///!$&\'()*+,-./" + 3B];
        D.8361 = *D.8360;
        D.8362 = (int) D.8361;
        D.8363 = __s2 + 3;
        D.8364 = *D.8363;
        D.8365 = (int) D.8364;
        __result = D.8362 - D.8365;
        <D.8359>:
        <D.8349>:
        <D.8339>:
      }
      D.5619 = __result;
    }
    iftmp.68 = -D.5619;
    goto <D.8366>;
    <D.8329>:
    iftmp.68 = __builtin_strcmp (s, "file:///!$&\'()*+,-./");
    <D.8366>:
    D.5620 = iftmp.68;
  }
  if (D.5620 != 0) goto <D.8367>; else goto <D.8368>;
  <D.8367>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///!$&\'()*+,-./");
  return D.8074;
  <D.8368>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/\"#%", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 17;
    if (__s2_len <= 3) goto <D.8370>; else goto <D.8371>;
    <D.8370>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8372 = "file:///%22%23%25";
      D.8373 = MEM[(const unsigned char *)D.8372];
      D.8374 = (int) D.8373;
      D.8375 = *__s2;
      D.8376 = (int) D.8375;
      __result = D.8374 - D.8376;
      {
        D.8377 = __s2_len != 0;
        D.8378 = __result == 0;
        D.8379 = D.8377 & D.8378;
        if (D.8379 != 0) goto <D.8380>; else goto <D.8381>;
        <D.8380>:
        D.8382 = &MEM[(void *)"file:///%22%23%25" + 1B];
        D.8383 = *D.8382;
        D.8384 = (int) D.8383;
        D.8385 = __s2 + 1;
        D.8386 = *D.8385;
        D.8387 = (int) D.8386;
        __result = D.8384 - D.8387;
        D.8388 = __s2_len > 1;
        D.8378 = __result == 0;
        D.8389 = D.8388 & D.8378;
        if (D.8389 != 0) goto <D.8390>; else goto <D.8391>;
        <D.8390>:
        D.8392 = &MEM[(void *)"file:///%22%23%25" + 2B];
        D.8393 = *D.8392;
        D.8394 = (int) D.8393;
        D.8395 = __s2 + 2;
        D.8396 = *D.8395;
        D.8397 = (int) D.8396;
        __result = D.8394 - D.8397;
        D.8398 = __s2_len > 2;
        D.8378 = __result == 0;
        D.8399 = D.8398 & D.8378;
        if (D.8399 != 0) goto <D.8400>; else goto <D.8401>;
        <D.8400>:
        D.8402 = &MEM[(void *)"file:///%22%23%25" + 3B];
        D.8403 = *D.8402;
        D.8404 = (int) D.8403;
        D.8405 = __s2 + 3;
        D.8406 = *D.8405;
        D.8407 = (int) D.8406;
        __result = D.8404 - D.8407;
        <D.8401>:
        <D.8391>:
        <D.8381>:
      }
      D.5628 = __result;
    }
    iftmp.69 = -D.5628;
    goto <D.8408>;
    <D.8371>:
    iftmp.69 = __builtin_strcmp (s, "file:///%22%23%25");
    <D.8408>:
    D.5629 = iftmp.69;
  }
  if (D.5629 != 0) goto <D.8409>; else goto <D.8410>;
  <D.8409>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///%22%23%25");
  return D.8074;
  <D.8410>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/0123456789:=", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.8414 = "file:///0123456789:=";
      D.8415 = MEM[(const unsigned char *)D.8414];
      D.8416 = (int) D.8415;
      D.8417 = *__s2;
      D.8418 = (int) D.8417;
      __result = D.8416 - D.8418;
      {
        D.8419 = __s2_len != 0;
        D.8420 = __result == 0;
        D.8421 = D.8419 & D.8420;
        if (D.8421 != 0) goto <D.8422>; else goto <D.8423>;
        <D.8422>:
        D.8424 = &MEM[(void *)"file:///0123456789:=" + 1B];
        D.8425 = *D.8424;
        D.8426 = (int) D.8425;
        D.8427 = __s2 + 1;
        D.8428 = *D.8427;
        D.8429 = (int) D.8428;
        __result = D.8426 - D.8429;
        D.8430 = __s2_len > 1;
        D.8420 = __result == 0;
        D.8431 = D.8430 & D.8420;
        if (D.8431 != 0) goto <D.8432>; else goto <D.8433>;
        <D.8432>:
        D.8434 = &MEM[(void *)"file:///0123456789:=" + 2B];
        D.8435 = *D.8434;
        D.8436 = (int) D.8435;
        D.8437 = __s2 + 2;
        D.8438 = *D.8437;
        D.8439 = (int) D.8438;
        __result = D.8436 - D.8439;
        D.8440 = __s2_len > 2;
        D.8420 = __result == 0;
        D.8441 = D.8440 & D.8420;
        if (D.8441 != 0) goto <D.8442>; else goto <D.8443>;
        <D.8442>:
        D.8444 = &MEM[(void *)"file:///0123456789:=" + 3B];
        D.8445 = *D.8444;
        D.8446 = (int) D.8445;
        D.8447 = __s2 + 3;
        D.8448 = *D.8447;
        D.8449 = (int) D.8448;
        __result = D.8446 - D.8449;
        <D.8443>:
        <D.8433>:
        <D.8423>:
      }
      D.5637 = __result;
    }
    iftmp.70 = -D.5637;
    goto <D.8450>;
    <D.8413>:
    iftmp.70 = __builtin_strcmp (s, "file:///0123456789:=");
    <D.8450>:
    D.5638 = iftmp.70;
  }
  if (D.5638 != 0) goto <D.8451>; else goto <D.8452>;
  <D.8451>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///0123456789:=");
  return D.8074;
  <D.8452>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/;<>?", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.8456 = "file:///%3B%3C%3E%3F";
      D.8457 = MEM[(const unsigned char *)D.8456];
      D.8458 = (int) D.8457;
      D.8459 = *__s2;
      D.8460 = (int) D.8459;
      __result = D.8458 - D.8460;
      {
        D.8461 = __s2_len != 0;
        D.8462 = __result == 0;
        D.8463 = D.8461 & D.8462;
        if (D.8463 != 0) goto <D.8464>; else goto <D.8465>;
        <D.8464>:
        D.8466 = &MEM[(void *)"file:///%3B%3C%3E%3F" + 1B];
        D.8467 = *D.8466;
        D.8468 = (int) D.8467;
        D.8469 = __s2 + 1;
        D.8470 = *D.8469;
        D.8471 = (int) D.8470;
        __result = D.8468 - D.8471;
        D.8472 = __s2_len > 1;
        D.8462 = __result == 0;
        D.8473 = D.8472 & D.8462;
        if (D.8473 != 0) goto <D.8474>; else goto <D.8475>;
        <D.8474>:
        D.8476 = &MEM[(void *)"file:///%3B%3C%3E%3F" + 2B];
        D.8477 = *D.8476;
        D.8478 = (int) D.8477;
        D.8479 = __s2 + 2;
        D.8480 = *D.8479;
        D.8481 = (int) D.8480;
        __result = D.8478 - D.8481;
        D.8482 = __s2_len > 2;
        D.8462 = __result == 0;
        D.8483 = D.8482 & D.8462;
        if (D.8483 != 0) goto <D.8484>; else goto <D.8485>;
        <D.8484>:
        D.8486 = &MEM[(void *)"file:///%3B%3C%3E%3F" + 3B];
        D.8487 = *D.8486;
        D.8488 = (int) D.8487;
        D.8489 = __s2 + 3;
        D.8490 = *D.8489;
        D.8491 = (int) D.8490;
        __result = D.8488 - D.8491;
        <D.8485>:
        <D.8475>:
        <D.8465>:
      }
      D.5646 = __result;
    }
    iftmp.71 = -D.5646;
    goto <D.8492>;
    <D.8455>:
    iftmp.71 = __builtin_strcmp (s, "file:///%3B%3C%3E%3F");
    <D.8492>:
    D.5647 = iftmp.71;
  }
  if (D.5647 != 0) goto <D.8493>; else goto <D.8494>;
  <D.8493>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///%3B%3C%3E%3F");
  return D.8074;
  <D.8494>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/[\\]^_`{|}", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 33;
    if (__s2_len <= 3) goto <D.8496>; else goto <D.8497>;
    <D.8496>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8498 = "file:///%5B%5C%5D%5E_%60%7B%7C%7D";
      D.8499 = MEM[(const unsigned char *)D.8498];
      D.8500 = (int) D.8499;
      D.8501 = *__s2;
      D.8502 = (int) D.8501;
      __result = D.8500 - D.8502;
      {
        D.8503 = __s2_len != 0;
        D.8504 = __result == 0;
        D.8505 = D.8503 & D.8504;
        if (D.8505 != 0) goto <D.8506>; else goto <D.8507>;
        <D.8506>:
        D.8508 = &MEM[(void *)"file:///%5B%5C%5D%5E_%60%7B%7C%7D" + 1B];
        D.8509 = *D.8508;
        D.8510 = (int) D.8509;
        D.8511 = __s2 + 1;
        D.8512 = *D.8511;
        D.8513 = (int) D.8512;
        __result = D.8510 - D.8513;
        D.8514 = __s2_len > 1;
        D.8504 = __result == 0;
        D.8515 = D.8514 & D.8504;
        if (D.8515 != 0) goto <D.8516>; else goto <D.8517>;
        <D.8516>:
        D.8518 = &MEM[(void *)"file:///%5B%5C%5D%5E_%60%7B%7C%7D" + 2B];
        D.8519 = *D.8518;
        D.8520 = (int) D.8519;
        D.8521 = __s2 + 2;
        D.8522 = *D.8521;
        D.8523 = (int) D.8522;
        __result = D.8520 - D.8523;
        D.8524 = __s2_len > 2;
        D.8504 = __result == 0;
        D.8525 = D.8524 & D.8504;
        if (D.8525 != 0) goto <D.8526>; else goto <D.8527>;
        <D.8526>:
        D.8528 = &MEM[(void *)"file:///%5B%5C%5D%5E_%60%7B%7C%7D" + 3B];
        D.8529 = *D.8528;
        D.8530 = (int) D.8529;
        D.8531 = __s2 + 3;
        D.8532 = *D.8531;
        D.8533 = (int) D.8532;
        __result = D.8530 - D.8533;
        <D.8527>:
        <D.8517>:
        <D.8507>:
      }
      D.5655 = __result;
    }
    iftmp.72 = -D.5655;
    goto <D.8534>;
    <D.8497>:
    iftmp.72 = __builtin_strcmp (s, "file:///%5B%5C%5D%5E_%60%7B%7C%7D");
    <D.8534>:
    D.5656 = iftmp.72;
  }
  if (D.5656 != 0) goto <D.8535>; else goto <D.8536>;
  <D.8535>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///%5B%5C%5D%5E_%60%7B%7C%7D");
  return D.8074;
  <D.8536>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/{|}~€", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 24;
    if (__s2_len <= 3) goto <D.8538>; else goto <D.8539>;
    <D.8538>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8540 = "file:///%7B%7C%7D~%7F%80";
      D.8541 = MEM[(const unsigned char *)D.8540];
      D.8542 = (int) D.8541;
      D.8543 = *__s2;
      D.8544 = (int) D.8543;
      __result = D.8542 - D.8544;
      {
        D.8545 = __s2_len != 0;
        D.8546 = __result == 0;
        D.8547 = D.8545 & D.8546;
        if (D.8547 != 0) goto <D.8548>; else goto <D.8549>;
        <D.8548>:
        D.8550 = &MEM[(void *)"file:///%7B%7C%7D~%7F%80" + 1B];
        D.8551 = *D.8550;
        D.8552 = (int) D.8551;
        D.8553 = __s2 + 1;
        D.8554 = *D.8553;
        D.8555 = (int) D.8554;
        __result = D.8552 - D.8555;
        D.8556 = __s2_len > 1;
        D.8546 = __result == 0;
        D.8557 = D.8556 & D.8546;
        if (D.8557 != 0) goto <D.8558>; else goto <D.8559>;
        <D.8558>:
        D.8560 = &MEM[(void *)"file:///%7B%7C%7D~%7F%80" + 2B];
        D.8561 = *D.8560;
        D.8562 = (int) D.8561;
        D.8563 = __s2 + 2;
        D.8564 = *D.8563;
        D.8565 = (int) D.8564;
        __result = D.8562 - D.8565;
        D.8566 = __s2_len > 2;
        D.8546 = __result == 0;
        D.8567 = D.8566 & D.8546;
        if (D.8567 != 0) goto <D.8568>; else goto <D.8569>;
        <D.8568>:
        D.8570 = &MEM[(void *)"file:///%7B%7C%7D~%7F%80" + 3B];
        D.8571 = *D.8570;
        D.8572 = (int) D.8571;
        D.8573 = __s2 + 3;
        D.8574 = *D.8573;
        D.8575 = (int) D.8574;
        __result = D.8572 - D.8575;
        <D.8569>:
        <D.8559>:
        <D.8549>:
      }
      D.5664 = __result;
    }
    iftmp.73 = -D.5664;
    goto <D.8576>;
    <D.8539>:
    iftmp.73 = __builtin_strcmp (s, "file:///%7B%7C%7D~%7F%80");
    <D.8576>:
    D.5665 = iftmp.73;
  }
  if (D.5665 != 0) goto <D.8577>; else goto <D.8578>;
  <D.8577>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///%7B%7C%7D~%7F%80");
  return D.8074;
  <D.8578>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("/@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 61;
    if (__s2_len <= 3) goto <D.8580>; else goto <D.8581>;
    <D.8580>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = s;
      D.8582 = "file:///@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
      D.8583 = MEM[(const unsigned char *)D.8582];
      D.8584 = (int) D.8583;
      D.8585 = *__s2;
      D.8586 = (int) D.8585;
      __result = D.8584 - D.8586;
      {
        D.8587 = __s2_len != 0;
        D.8588 = __result == 0;
        D.8589 = D.8587 & D.8588;
        if (D.8589 != 0) goto <D.8590>; else goto <D.8591>;
        <D.8590>:
        D.8592 = &MEM[(void *)"file:///@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + 1B];
        D.8593 = *D.8592;
        D.8594 = (int) D.8593;
        D.8595 = __s2 + 1;
        D.8596 = *D.8595;
        D.8597 = (int) D.8596;
        __result = D.8594 - D.8597;
        D.8598 = __s2_len > 1;
        D.8588 = __result == 0;
        D.8599 = D.8598 & D.8588;
        if (D.8599 != 0) goto <D.8600>; else goto <D.8601>;
        <D.8600>:
        D.8602 = &MEM[(void *)"file:///@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + 2B];
        D.8603 = *D.8602;
        D.8604 = (int) D.8603;
        D.8605 = __s2 + 2;
        D.8606 = *D.8605;
        D.8607 = (int) D.8606;
        __result = D.8604 - D.8607;
        D.8608 = __s2_len > 2;
        D.8588 = __result == 0;
        D.8609 = D.8608 & D.8588;
        if (D.8609 != 0) goto <D.8610>; else goto <D.8611>;
        <D.8610>:
        D.8612 = &MEM[(void *)"file:///@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + 3B];
        D.8613 = *D.8612;
        D.8614 = (int) D.8613;
        D.8615 = __s2 + 3;
        D.8616 = *D.8615;
        D.8617 = (int) D.8616;
        __result = D.8614 - D.8617;
        <D.8611>:
        <D.8601>:
        <D.8591>:
      }
      D.5673 = __result;
    }
    iftmp.74 = -D.5673;
    goto <D.8618>;
    <D.8581>:
    iftmp.74 = __builtin_strcmp (s, "file:///@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
    <D.8618>:
    D.5674 = iftmp.74;
  }
  if (D.5674 != 0) goto <D.8619>; else goto <D.8620>;
  <D.8619>:
  D.8074 = FAILED ("Got %s expected %s", s, "file:///@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
  return D.8074;
  <D.8620>:
  monoeg_g_free (s);
  s = monoeg_g_filename_to_uri ("a", 0B, 0B);
  if (s != 0B) goto <D.8621>; else goto <D.8622>;
  <D.8621>:
  D.8074 = FAILED ("got %s, expected NULL", s);
  return D.8074;
  <D.8622>:
  s = monoeg_g_filename_to_uri ("./hola", 0B, 0B);
  if (s != 0B) goto <D.8623>; else goto <D.8624>;
  <D.8623>:
  D.8074 = FAILED ("got %s, expected NULL", s);
  return D.8074;
  <D.8624>:
  D.8074 = 0B;
  return D.8074;
}


test_filename_from_uri ()
{
  int D.5686;
  int iftmp.75;
  int D.5685;
  char[3] * D.8629;
  unsigned char D.8630;
  int D.8631;
  unsigned char D.8632;
  int D.8633;
  _Bool D.8634;
  _Bool D.8635;
  _Bool D.8636;
  const unsigned char * D.8639;
  unsigned char D.8640;
  int D.8641;
  const unsigned char * D.8642;
  unsigned char D.8643;
  int D.8644;
  _Bool D.8645;
  _Bool D.8646;
  const unsigned char * D.8649;
  unsigned char D.8650;
  int D.8651;
  const unsigned char * D.8652;
  unsigned char D.8653;
  int D.8654;
  _Bool D.8655;
  _Bool D.8656;
  const unsigned char * D.8659;
  unsigned char D.8660;
  int D.8661;
  const unsigned char * D.8662;
  unsigned char D.8663;
  int D.8664;
  gchar * D.8668;
  int D.5695;
  int iftmp.76;
  int D.5694;
  char[3] * D.8672;
  unsigned char D.8673;
  int D.8674;
  unsigned char D.8675;
  int D.8676;
  _Bool D.8677;
  _Bool D.8678;
  _Bool D.8679;
  const unsigned char * D.8682;
  unsigned char D.8683;
  int D.8684;
  const unsigned char * D.8685;
  unsigned char D.8686;
  int D.8687;
  _Bool D.8688;
  _Bool D.8689;
  const unsigned char * D.8692;
  unsigned char D.8693;
  int D.8694;
  const unsigned char * D.8695;
  unsigned char D.8696;
  int D.8697;
  _Bool D.8698;
  _Bool D.8699;
  const unsigned char * D.8702;
  unsigned char D.8703;
  int D.8704;
  const unsigned char * D.8705;
  unsigned char D.8706;
  int D.8707;
  int D.5704;
  int iftmp.77;
  int D.5703;
  char[13] * D.8714;
  unsigned char D.8715;
  int D.8716;
  unsigned char D.8717;
  int D.8718;
  _Bool D.8719;
  _Bool D.8720;
  _Bool D.8721;
  const unsigned char * D.8724;
  unsigned char D.8725;
  int D.8726;
  const unsigned char * D.8727;
  unsigned char D.8728;
  int D.8729;
  _Bool D.8730;
  _Bool D.8731;
  const unsigned char * D.8734;
  unsigned char D.8735;
  int D.8736;
  const unsigned char * D.8737;
  unsigned char D.8738;
  int D.8739;
  _Bool D.8740;
  _Bool D.8741;
  const unsigned char * D.8744;
  unsigned char D.8745;
  int D.8746;
  const unsigned char * D.8747;
  unsigned char D.8748;
  int D.8749;
  int D.5713;
  int iftmp.78;
  int D.5712;
  char[14] * D.8756;
  unsigned char D.8757;
  int D.8758;
  unsigned char D.8759;
  int D.8760;
  _Bool D.8761;
  _Bool D.8762;
  _Bool D.8763;
  const unsigned char * D.8766;
  unsigned char D.8767;
  int D.8768;
  const unsigned char * D.8769;
  unsigned char D.8770;
  int D.8771;
  _Bool D.8772;
  _Bool D.8773;
  const unsigned char * D.8776;
  unsigned char D.8777;
  int D.8778;
  const unsigned char * D.8779;
  unsigned char D.8780;
  int D.8781;
  _Bool D.8782;
  _Bool D.8783;
  const unsigned char * D.8786;
  unsigned char D.8787;
  int D.8788;
  const unsigned char * D.8789;
  unsigned char D.8790;
  int D.8791;
  char * s;

  s = monoeg_g_filename_from_uri ("file:///a", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.8629 = "/a";
      D.8630 = MEM[(const unsigned char *)D.8629];
      D.8631 = (int) D.8630;
      D.8632 = *__s2;
      D.8633 = (int) D.8632;
      __result = D.8631 - D.8633;
      {
        D.8634 = __s2_len != 0;
        D.8635 = __result == 0;
        D.8636 = D.8634 & D.8635;
        if (D.8636 != 0) goto <D.8637>; else goto <D.8638>;
        <D.8637>:
        D.8639 = &MEM[(void *)"/a" + 1B];
        D.8640 = *D.8639;
        D.8641 = (int) D.8640;
        D.8642 = __s2 + 1;
        D.8643 = *D.8642;
        D.8644 = (int) D.8643;
        __result = D.8641 - D.8644;
        D.8645 = __s2_len > 1;
        D.8635 = __result == 0;
        D.8646 = D.8645 & D.8635;
        if (D.8646 != 0) goto <D.8647>; else goto <D.8648>;
        <D.8647>:
        D.8649 = &MEM[(void *)"/a" + 2B];
        D.8650 = *D.8649;
        D.8651 = (int) D.8650;
        D.8652 = __s2 + 2;
        D.8653 = *D.8652;
        D.8654 = (int) D.8653;
        __result = D.8651 - D.8654;
        D.8655 = __s2_len > 2;
        D.8635 = __result == 0;
        D.8656 = D.8655 & D.8635;
        if (D.8656 != 0) goto <D.8657>; else goto <D.8658>;
        <D.8657>:
        D.8659 = &MEM[(void *)"/a" + 3B];
        D.8660 = *D.8659;
        D.8661 = (int) D.8660;
        D.8662 = __s2 + 3;
        D.8663 = *D.8662;
        D.8664 = (int) D.8663;
        __result = D.8661 - D.8664;
        <D.8658>:
        <D.8648>:
        <D.8638>:
      }
      D.5685 = __result;
    }
    iftmp.75 = -D.5685;
    goto <D.8665>;
    <D.8628>:
    iftmp.75 = __builtin_strcmp (s, "/a");
    <D.8665>:
    D.5686 = iftmp.75;
  }
  if (D.5686 != 0) goto <D.8666>; else goto <D.8667>;
  <D.8666>:
  D.8668 = FAILED ("Got %s expected %s", s, "/a");
  return D.8668;
  <D.8667>:
  monoeg_g_free (s);
  s = monoeg_g_filename_from_uri ("file:///%41", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.8672 = "/A";
      D.8673 = MEM[(const unsigned char *)D.8672];
      D.8674 = (int) D.8673;
      D.8675 = *__s2;
      D.8676 = (int) D.8675;
      __result = D.8674 - D.8676;
      {
        D.8677 = __s2_len != 0;
        D.8678 = __result == 0;
        D.8679 = D.8677 & D.8678;
        if (D.8679 != 0) goto <D.8680>; else goto <D.8681>;
        <D.8680>:
        D.8682 = &MEM[(void *)"/A" + 1B];
        D.8683 = *D.8682;
        D.8684 = (int) D.8683;
        D.8685 = __s2 + 1;
        D.8686 = *D.8685;
        D.8687 = (int) D.8686;
        __result = D.8684 - D.8687;
        D.8688 = __s2_len > 1;
        D.8678 = __result == 0;
        D.8689 = D.8688 & D.8678;
        if (D.8689 != 0) goto <D.8690>; else goto <D.8691>;
        <D.8690>:
        D.8692 = &MEM[(void *)"/A" + 2B];
        D.8693 = *D.8692;
        D.8694 = (int) D.8693;
        D.8695 = __s2 + 2;
        D.8696 = *D.8695;
        D.8697 = (int) D.8696;
        __result = D.8694 - D.8697;
        D.8698 = __s2_len > 2;
        D.8678 = __result == 0;
        D.8699 = D.8698 & D.8678;
        if (D.8699 != 0) goto <D.8700>; else goto <D.8701>;
        <D.8700>:
        D.8702 = &MEM[(void *)"/A" + 3B];
        D.8703 = *D.8702;
        D.8704 = (int) D.8703;
        D.8705 = __s2 + 3;
        D.8706 = *D.8705;
        D.8707 = (int) D.8706;
        __result = D.8704 - D.8707;
        <D.8701>:
        <D.8691>:
        <D.8681>:
      }
      D.5694 = __result;
    }
    iftmp.76 = -D.5694;
    goto <D.8708>;
    <D.8671>:
    iftmp.76 = __builtin_strcmp (s, "/A");
    <D.8708>:
    D.5695 = iftmp.76;
  }
  if (D.5695 != 0) goto <D.8709>; else goto <D.8710>;
  <D.8709>:
  D.8668 = FAILED ("Got %s expected %s", s, "/A");
  return D.8668;
  <D.8710>:
  monoeg_g_free (s);
  s = monoeg_g_filename_from_uri ("file:///home/miguel", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.8714 = "/home/miguel";
      D.8715 = MEM[(const unsigned char *)D.8714];
      D.8716 = (int) D.8715;
      D.8717 = *__s2;
      D.8718 = (int) D.8717;
      __result = D.8716 - D.8718;
      {
        D.8719 = __s2_len != 0;
        D.8720 = __result == 0;
        D.8721 = D.8719 & D.8720;
        if (D.8721 != 0) goto <D.8722>; else goto <D.8723>;
        <D.8722>:
        D.8724 = &MEM[(void *)"/home/miguel" + 1B];
        D.8725 = *D.8724;
        D.8726 = (int) D.8725;
        D.8727 = __s2 + 1;
        D.8728 = *D.8727;
        D.8729 = (int) D.8728;
        __result = D.8726 - D.8729;
        D.8730 = __s2_len > 1;
        D.8720 = __result == 0;
        D.8731 = D.8730 & D.8720;
        if (D.8731 != 0) goto <D.8732>; else goto <D.8733>;
        <D.8732>:
        D.8734 = &MEM[(void *)"/home/miguel" + 2B];
        D.8735 = *D.8734;
        D.8736 = (int) D.8735;
        D.8737 = __s2 + 2;
        D.8738 = *D.8737;
        D.8739 = (int) D.8738;
        __result = D.8736 - D.8739;
        D.8740 = __s2_len > 2;
        D.8720 = __result == 0;
        D.8741 = D.8740 & D.8720;
        if (D.8741 != 0) goto <D.8742>; else goto <D.8743>;
        <D.8742>:
        D.8744 = &MEM[(void *)"/home/miguel" + 3B];
        D.8745 = *D.8744;
        D.8746 = (int) D.8745;
        D.8747 = __s2 + 3;
        D.8748 = *D.8747;
        D.8749 = (int) D.8748;
        __result = D.8746 - D.8749;
        <D.8743>:
        <D.8733>:
        <D.8723>:
      }
      D.5703 = __result;
    }
    iftmp.77 = -D.5703;
    goto <D.8750>;
    <D.8713>:
    iftmp.77 = __builtin_strcmp (s, "/home/miguel");
    <D.8750>:
    D.5704 = iftmp.77;
  }
  if (D.5704 != 0) goto <D.8751>; else goto <D.8752>;
  <D.8751>:
  D.8668 = FAILED ("Got %s expected %s", s, "/home/miguel");
  return D.8668;
  <D.8752>:
  monoeg_g_free (s);
  s = monoeg_g_filename_from_uri ("file:///home/mig%20uel", 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = s;
      D.8756 = "/home/mig uel";
      D.8757 = MEM[(const unsigned char *)D.8756];
      D.8758 = (int) D.8757;
      D.8759 = *__s2;
      D.8760 = (int) D.8759;
      __result = D.8758 - D.8760;
      {
        D.8761 = __s2_len != 0;
        D.8762 = __result == 0;
        D.8763 = D.8761 & D.8762;
        if (D.8763 != 0) goto <D.8764>; else goto <D.8765>;
        <D.8764>:
        D.8766 = &MEM[(void *)"/home/mig uel" + 1B];
        D.8767 = *D.8766;
        D.8768 = (int) D.8767;
        D.8769 = __s2 + 1;
        D.8770 = *D.8769;
        D.8771 = (int) D.8770;
        __result = D.8768 - D.8771;
        D.8772 = __s2_len > 1;
        D.8762 = __result == 0;
        D.8773 = D.8772 & D.8762;
        if (D.8773 != 0) goto <D.8774>; else goto <D.8775>;
        <D.8774>:
        D.8776 = &MEM[(void *)"/home/mig uel" + 2B];
        D.8777 = *D.8776;
        D.8778 = (int) D.8777;
        D.8779 = __s2 + 2;
        D.8780 = *D.8779;
        D.8781 = (int) D.8780;
        __result = D.8778 - D.8781;
        D.8782 = __s2_len > 2;
        D.8762 = __result == 0;
        D.8783 = D.8782 & D.8762;
        if (D.8783 != 0) goto <D.8784>; else goto <D.8785>;
        <D.8784>:
        D.8786 = &MEM[(void *)"/home/mig uel" + 3B];
        D.8787 = *D.8786;
        D.8788 = (int) D.8787;
        D.8789 = __s2 + 3;
        D.8790 = *D.8789;
        D.8791 = (int) D.8790;
        __result = D.8788 - D.8791;
        <D.8785>:
        <D.8775>:
        <D.8765>:
      }
      D.5712 = __result;
    }
    iftmp.78 = -D.5712;
    goto <D.8792>;
    <D.8755>:
    iftmp.78 = __builtin_strcmp (s, "/home/mig uel");
    <D.8792>:
    D.5713 = iftmp.78;
  }
  if (D.5713 != 0) goto <D.8793>; else goto <D.8794>;
  <D.8793>:
  D.8668 = FAILED ("Got %s expected %s", s, "/home/mig uel");
  return D.8668;
  <D.8794>:
  monoeg_g_free (s);
  s = monoeg_g_filename_from_uri ("/a", 0B, 0B);
  if (s != 0B) goto <D.8795>; else goto <D.8796>;
  <D.8795>:
  D.8668 = FAILED ("got %s, expected NULL", s);
  return D.8668;
  <D.8796>:
  s = monoeg_g_filename_from_uri ("a", 0B, 0B);
  if (s != 0B) goto <D.8797>; else goto <D.8798>;
  <D.8797>:
  D.8668 = FAILED ("got %s, expected NULL", s);
  return D.8668;
  <D.8798>:
  s = monoeg_g_filename_from_uri ("file://a", 0B, 0B);
  if (s != 0B) goto <D.8799>; else goto <D.8800>;
  <D.8799>:
  D.8668 = FAILED ("got %s, expected NULL", s);
  return D.8668;
  <D.8800>:
  s = monoeg_g_filename_from_uri ("file:a", 0B, 0B);
  if (s != 0B) goto <D.8801>; else goto <D.8802>;
  <D.8801>:
  D.8668 = FAILED ("got %s, expected NULL", s);
  return D.8668;
  <D.8802>:
  s = monoeg_g_filename_from_uri ("file:///%", 0B, 0B);
  if (s != 0B) goto <D.8803>; else goto <D.8804>;
  <D.8803>:
  D.8668 = FAILED ("got %s, expected NULL", s);
  return D.8668;
  <D.8804>:
  s = monoeg_g_filename_from_uri ("file:///%0", 0B, 0B);
  if (s != 0B) goto <D.8805>; else goto <D.8806>;
  <D.8805>:
  D.8668 = FAILED ("got %s, expected NULL", s);
  return D.8668;
  <D.8806>:
  s = monoeg_g_filename_from_uri ("file:///%jj", 0B, 0B);
  if (s != 0B) goto <D.8807>; else goto <D.8808>;
  <D.8807>:
  D.8668 = FAILED ("got %s, expected NULL", s);
  return D.8668;
  <D.8808>:
  D.8668 = 0B;
  return D.8668;
}


test_ascii_xdigit_value ()
{
  gchar * D.8812;
  int D.8823;
  int D.8824;
  char j.79;
  unsigned char j.80;
  unsigned char D.8829;
  int D.8830;
  char j.81;
  unsigned char j.82;
  unsigned char D.8835;
  int D.8836;
  char j.83;
  unsigned char j.84;
  unsigned char D.8841;
  int i;
  gchar j;

  i = monoeg_g_ascii_xdigit_value (58);
  if (i != -1) goto <D.8810>; else goto <D.8811>;
  <D.8810>:
  D.8812 = FAILED ("\'9\' + 1");
  return D.8812;
  <D.8811>:
  i = monoeg_g_ascii_xdigit_value (47);
  if (i != -1) goto <D.8813>; else goto <D.8814>;
  <D.8813>:
  D.8812 = FAILED ("\'0\' - 1");
  return D.8812;
  <D.8814>:
  i = monoeg_g_ascii_xdigit_value (96);
  if (i != -1) goto <D.8815>; else goto <D.8816>;
  <D.8815>:
  D.8812 = FAILED ("\'a\' - 1");
  return D.8812;
  <D.8816>:
  i = monoeg_g_ascii_xdigit_value (103);
  if (i != -1) goto <D.8817>; else goto <D.8818>;
  <D.8817>:
  D.8812 = FAILED ("\'f\' + 1");
  return D.8812;
  <D.8818>:
  i = monoeg_g_ascii_xdigit_value (64);
  if (i != -1) goto <D.8819>; else goto <D.8820>;
  <D.8819>:
  D.8812 = FAILED ("\'A\' - 1");
  return D.8812;
  <D.8820>:
  i = monoeg_g_ascii_xdigit_value (71);
  if (i != -1) goto <D.8821>; else goto <D.8822>;
  <D.8821>:
  D.8812 = FAILED ("\'F\' + 1");
  return D.8812;
  <D.8822>:
  j = 48;
  goto <D.5720>;
  <D.5719>:
  {
    int c;

    D.8823 = (int) j;
    c = monoeg_g_ascii_xdigit_value (D.8823);
    D.8823 = (int) j;
    D.8824 = D.8823 + -48;
    if (D.8824 != c) goto <D.8825>; else goto <D.8826>;
    <D.8825>:
    D.8823 = (int) j;
    D.8812 = FAILED ("Digits %c -> %d", D.8823, c);
    return D.8812;
    <D.8826>:
  }
  j.79 = j;
  j.80 = (unsigned char) j.79;
  D.8829 = j.80 + 1;
  j = (gchar) D.8829;
  <D.5720>:
  if (j <= 56) goto <D.5719>; else goto <D.5721>;
  <D.5721>:
  j = 97;
  goto <D.5724>;
  <D.5723>:
  {
    int c;

    D.8823 = (int) j;
    c = monoeg_g_ascii_xdigit_value (D.8823);
    D.8823 = (int) j;
    D.8830 = D.8823 + -87;
    if (D.8830 != c) goto <D.8831>; else goto <D.8832>;
    <D.8831>:
    D.8823 = (int) j;
    D.8812 = FAILED ("Lower %c -> %d", D.8823, c);
    return D.8812;
    <D.8832>:
  }
  j.81 = j;
  j.82 = (unsigned char) j.81;
  D.8835 = j.82 + 1;
  j = (gchar) D.8835;
  <D.5724>:
  if (j <= 101) goto <D.5723>; else goto <D.5725>;
  <D.5725>:
  j = 65;
  goto <D.5728>;
  <D.5727>:
  {
    int c;

    D.8823 = (int) j;
    c = monoeg_g_ascii_xdigit_value (D.8823);
    D.8823 = (int) j;
    D.8836 = D.8823 + -55;
    if (D.8836 != c) goto <D.8837>; else goto <D.8838>;
    <D.8837>:
    D.8823 = (int) j;
    D.8812 = FAILED ("Upper %c -> %d", D.8823, c);
    return D.8812;
    <D.8838>:
  }
  j.83 = j;
  j.84 = (unsigned char) j.83;
  D.8841 = j.84 + 1;
  j = (gchar) D.8841;
  <D.5728>:
  if (j <= 69) goto <D.5727>; else goto <D.5729>;
  <D.5729>:
  D.8812 = 0B;
  return D.8812;
}


test_strdelimit ()
{
  int D.5741;
  int iftmp.85;
  int D.5737;
  char[8] * D.8846;
  unsigned char D.8847;
  int D.8848;
  unsigned char D.8849;
  int D.8850;
  _Bool D.8851;
  _Bool D.8852;
  _Bool D.8853;
  const unsigned char * D.8856;
  unsigned char D.8857;
  int D.8858;
  const unsigned char * D.8859;
  unsigned char D.8860;
  int D.8861;
  _Bool D.8862;
  _Bool D.8863;
  const unsigned char * D.8866;
  unsigned char D.8867;
  int D.8868;
  const unsigned char * D.8869;
  unsigned char D.8870;
  int D.8871;
  _Bool D.8872;
  _Bool D.8873;
  const unsigned char * D.8876;
  unsigned char D.8877;
  int D.8878;
  const unsigned char * D.8879;
  unsigned char D.8880;
  int D.8881;
  gchar * D.8885;
  int D.5750;
  int iftmp.86;
  int D.5746;
  char[5] * D.8889;
  unsigned char D.8890;
  int D.8891;
  unsigned char D.8892;
  int D.8893;
  _Bool D.8894;
  _Bool D.8895;
  _Bool D.8896;
  const unsigned char * D.8899;
  unsigned char D.8900;
  int D.8901;
  const unsigned char * D.8902;
  unsigned char D.8903;
  int D.8904;
  _Bool D.8905;
  _Bool D.8906;
  const unsigned char * D.8909;
  unsigned char D.8910;
  int D.8911;
  const unsigned char * D.8912;
  unsigned char D.8913;
  int D.8914;
  _Bool D.8915;
  _Bool D.8916;
  const unsigned char * D.8919;
  unsigned char D.8920;
  int D.8921;
  const unsigned char * D.8922;
  unsigned char D.8923;
  int D.8924;
  gchar * str;

  str = monoeg_strdup ("_-|> <.");
  str = monoeg_g_strdelimit (str, 0B, 97);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 7;
    if (__s1_len <= 3) goto <D.8844>; else goto <D.8845>;
    <D.8844>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.8846 = "aaaaaaa";
      D.8847 = MEM[(const unsigned char *)D.8846];
      D.8848 = (int) D.8847;
      D.8849 = *__s2;
      D.8850 = (int) D.8849;
      __result = D.8848 - D.8850;
      {
        D.8851 = __s1_len != 0;
        D.8852 = __result == 0;
        D.8853 = D.8851 & D.8852;
        if (D.8853 != 0) goto <D.8854>; else goto <D.8855>;
        <D.8854>:
        D.8856 = &MEM[(void *)"aaaaaaa" + 1B];
        D.8857 = *D.8856;
        D.8858 = (int) D.8857;
        D.8859 = __s2 + 1;
        D.8860 = *D.8859;
        D.8861 = (int) D.8860;
        __result = D.8858 - D.8861;
        D.8862 = __s1_len > 1;
        D.8852 = __result == 0;
        D.8863 = D.8862 & D.8852;
        if (D.8863 != 0) goto <D.8864>; else goto <D.8865>;
        <D.8864>:
        D.8866 = &MEM[(void *)"aaaaaaa" + 2B];
        D.8867 = *D.8866;
        D.8868 = (int) D.8867;
        D.8869 = __s2 + 2;
        D.8870 = *D.8869;
        D.8871 = (int) D.8870;
        __result = D.8868 - D.8871;
        D.8872 = __s1_len > 2;
        D.8852 = __result == 0;
        D.8873 = D.8872 & D.8852;
        if (D.8873 != 0) goto <D.8874>; else goto <D.8875>;
        <D.8874>:
        D.8876 = &MEM[(void *)"aaaaaaa" + 3B];
        D.8877 = *D.8876;
        D.8878 = (int) D.8877;
        D.8879 = __s2 + 3;
        D.8880 = *D.8879;
        D.8881 = (int) D.8880;
        __result = D.8878 - D.8881;
        <D.8875>:
        <D.8865>:
        <D.8855>:
      }
      D.5737 = __result;
    }
    iftmp.85 = D.5737;
    goto <D.8882>;
    <D.8845>:
    iftmp.85 = __builtin_strcmp ("aaaaaaa", str);
    <D.8882>:
    D.5741 = iftmp.85;
  }
  if (D.5741 != 0) goto <D.8883>; else goto <D.8884>;
  <D.8883>:
  D.8885 = FAILED ("All delimiters: \'%s\'", str);
  return D.8885;
  <D.8884>:
  monoeg_g_free (str);
  str = monoeg_strdup ("hola");
  str = monoeg_g_strdelimit (str, "ha", 43);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 4;
    if (__s1_len <= 3) goto <D.8887>; else goto <D.8888>;
    <D.8887>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.8889 = "+ol+";
      D.8890 = MEM[(const unsigned char *)D.8889];
      D.8891 = (int) D.8890;
      D.8892 = *__s2;
      D.8893 = (int) D.8892;
      __result = D.8891 - D.8893;
      {
        D.8894 = __s1_len != 0;
        D.8895 = __result == 0;
        D.8896 = D.8894 & D.8895;
        if (D.8896 != 0) goto <D.8897>; else goto <D.8898>;
        <D.8897>:
        D.8899 = &MEM[(void *)"+ol+" + 1B];
        D.8900 = *D.8899;
        D.8901 = (int) D.8900;
        D.8902 = __s2 + 1;
        D.8903 = *D.8902;
        D.8904 = (int) D.8903;
        __result = D.8901 - D.8904;
        D.8905 = __s1_len > 1;
        D.8895 = __result == 0;
        D.8906 = D.8905 & D.8895;
        if (D.8906 != 0) goto <D.8907>; else goto <D.8908>;
        <D.8907>:
        D.8909 = &MEM[(void *)"+ol+" + 2B];
        D.8910 = *D.8909;
        D.8911 = (int) D.8910;
        D.8912 = __s2 + 2;
        D.8913 = *D.8912;
        D.8914 = (int) D.8913;
        __result = D.8911 - D.8914;
        D.8915 = __s1_len > 2;
        D.8895 = __result == 0;
        D.8916 = D.8915 & D.8895;
        if (D.8916 != 0) goto <D.8917>; else goto <D.8918>;
        <D.8917>:
        D.8919 = &MEM[(void *)"+ol+" + 3B];
        D.8920 = *D.8919;
        D.8921 = (int) D.8920;
        D.8922 = __s2 + 3;
        D.8923 = *D.8922;
        D.8924 = (int) D.8923;
        __result = D.8921 - D.8924;
        <D.8918>:
        <D.8908>:
        <D.8898>:
      }
      D.5746 = __result;
    }
    iftmp.86 = D.5746;
    goto <D.8925>;
    <D.8888>:
    iftmp.86 = __builtin_strcmp ("+ol+", str);
    <D.8925>:
    D.5750 = iftmp.86;
  }
  if (D.5750 != 0) goto <D.8926>; else goto <D.8927>;
  <D.8926>:
  D.8885 = FAILED ("2 delimiters: \'%s\'", str);
  return D.8885;
  <D.8927>:
  monoeg_g_free (str);
  D.8885 = 0B;
  return D.8885;
}


test_strlcpy ()
{
  long unsigned int D.8929;
  long unsigned int D.8930;
  long unsigned int D.8931;
  long unsigned int D.8932;
  long unsigned int D.8933;
  gchar * D.8936;
  int D.5764;
  long unsigned int D.8939;
  int D.5773;
  int iftmp.87;
  int D.5772;
  char[3] * D.8945;
  unsigned char D.8946;
  int D.8947;
  unsigned char D.8948;
  int D.8949;
  _Bool D.8950;
  _Bool D.8951;
  _Bool D.8952;
  const unsigned char * D.8955;
  unsigned char D.8956;
  int D.8957;
  const unsigned char * D.8958;
  unsigned char D.8959;
  int D.8960;
  _Bool D.8961;
  _Bool D.8962;
  const unsigned char * D.8965;
  unsigned char D.8966;
  int D.8967;
  const unsigned char * D.8968;
  unsigned char D.8969;
  int D.8970;
  _Bool D.8971;
  _Bool D.8972;
  const unsigned char * D.8975;
  unsigned char D.8976;
  int D.8977;
  const unsigned char * D.8978;
  unsigned char D.8979;
  int D.8980;
  long unsigned int D.8984;
  char D.8987;
  long unsigned int D.8990;
  int D.5782;
  int D.5791;
  int iftmp.88;
  int D.5790;
  char[11] * D.8998;
  unsigned char D.8999;
  int D.9000;
  unsigned char D.9001;
  int D.9002;
  _Bool D.9003;
  _Bool D.9004;
  _Bool D.9005;
  const unsigned char * D.9008;
  unsigned char D.9009;
  int D.9010;
  const unsigned char * D.9011;
  unsigned char D.9012;
  int D.9013;
  _Bool D.9014;
  _Bool D.9015;
  const unsigned char * D.9018;
  unsigned char D.9019;
  int D.9020;
  const unsigned char * D.9021;
  unsigned char D.9022;
  int D.9023;
  _Bool D.9024;
  _Bool D.9025;
  const unsigned char * D.9028;
  unsigned char D.9029;
  int D.9030;
  const unsigned char * D.9031;
  unsigned char D.9032;
  int D.9033;
  const gchar * src;
  gchar * dest;
  gsize i;

  src = "onetwothree";
  D.8929 = strlen (src);
  D.8930 = D.8929 + 1;
  dest = monoeg_malloc (D.8930);
  D.8931 = strlen (src);
  D.8932 = D.8931 + 1;
  memset (dest, 0, D.8932);
  i = monoeg_g_strlcpy (dest, src, 18446744073709551615);
  D.8933 = strlen (src);
  if (D.8933 != i) goto <D.8934>; else goto <D.8935>;
  <D.8934>:
  D.8936 = FAILED ("Test1 got %d", i);
  return D.8936;
  <D.8935>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.5764 = __builtin_strcmp (dest, src);
  }
  if (D.5764 != 0) goto <D.8937>; else goto <D.8938>;
  <D.8937>:
  D.8936 = FAILED ("Src and dest not equal");
  return D.8936;
  <D.8938>:
  i = monoeg_g_strlcpy (dest, src, 3);
  D.8939 = strlen (src);
  if (D.8939 != i) goto <D.8940>; else goto <D.8941>;
  <D.8940>:
  D.8936 = FAILED ("Test1 got %d", i);
  return D.8936;
  <D.8941>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = dest;
      D.8945 = "on";
      D.8946 = MEM[(const unsigned char *)D.8945];
      D.8947 = (int) D.8946;
      D.8948 = *__s2;
      D.8949 = (int) D.8948;
      __result = D.8947 - D.8949;
      {
        D.8950 = __s2_len != 0;
        D.8951 = __result == 0;
        D.8952 = D.8950 & D.8951;
        if (D.8952 != 0) goto <D.8953>; else goto <D.8954>;
        <D.8953>:
        D.8955 = &MEM[(void *)"on" + 1B];
        D.8956 = *D.8955;
        D.8957 = (int) D.8956;
        D.8958 = __s2 + 1;
        D.8959 = *D.8958;
        D.8960 = (int) D.8959;
        __result = D.8957 - D.8960;
        D.8961 = __s2_len > 1;
        D.8951 = __result == 0;
        D.8962 = D.8961 & D.8951;
        if (D.8962 != 0) goto <D.8963>; else goto <D.8964>;
        <D.8963>:
        D.8965 = &MEM[(void *)"on" + 2B];
        D.8966 = *D.8965;
        D.8967 = (int) D.8966;
        D.8968 = __s2 + 2;
        D.8969 = *D.8968;
        D.8970 = (int) D.8969;
        __result = D.8967 - D.8970;
        D.8971 = __s2_len > 2;
        D.8951 = __result == 0;
        D.8972 = D.8971 & D.8951;
        if (D.8972 != 0) goto <D.8973>; else goto <D.8974>;
        <D.8973>:
        D.8975 = &MEM[(void *)"on" + 3B];
        D.8976 = *D.8975;
        D.8977 = (int) D.8976;
        D.8978 = __s2 + 3;
        D.8979 = *D.8978;
        D.8980 = (int) D.8979;
        __result = D.8977 - D.8980;
        <D.8974>:
        <D.8964>:
        <D.8954>:
      }
      D.5772 = __result;
    }
    iftmp.87 = -D.5772;
    goto <D.8981>;
    <D.8944>:
    iftmp.87 = __builtin_strcmp (dest, "on");
    <D.8981>:
    D.5773 = iftmp.87;
  }
  if (D.5773 != 0) goto <D.8982>; else goto <D.8983>;
  <D.8982>:
  D.8936 = FAILED ("Test2");
  return D.8936;
  <D.8983>:
  i = monoeg_g_strlcpy (dest, src, 1);
  D.8984 = strlen (src);
  if (D.8984 != i) goto <D.8985>; else goto <D.8986>;
  <D.8985>:
  D.8936 = FAILED ("Test3 got %d", i);
  return D.8936;
  <D.8986>:
  D.8987 = *dest;
  if (D.8987 != 0) goto <D.8988>; else goto <D.8989>;
  <D.8988>:
  D.8936 = FAILED ("Test4");
  return D.8936;
  <D.8989>:
  i = monoeg_g_strlcpy (dest, src, 12345);
  D.8990 = strlen (src);
  if (D.8990 != i) goto <D.8991>; else goto <D.8992>;
  <D.8991>:
  D.8936 = FAILED ("Test4 got %d", i);
  return D.8936;
  <D.8992>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.5782 = __builtin_strcmp (dest, src);
  }
  if (D.5782 != 0) goto <D.8993>; else goto <D.8994>;
  <D.8993>:
  D.8936 = FAILED ("Src and dest not equal 2");
  return D.8936;
  <D.8994>:
  monoeg_g_free (dest);
  dest = monoeg_g_filename_from_utf8 ("0123456789", 10, 0B, 0B, 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = dest;
      D.8998 = "0123456789";
      D.8999 = MEM[(const unsigned char *)D.8998];
      D.9000 = (int) D.8999;
      D.9001 = *__s2;
      D.9002 = (int) D.9001;
      __result = D.9000 - D.9002;
      {
        D.9003 = __s2_len != 0;
        D.9004 = __result == 0;
        D.9005 = D.9003 & D.9004;
        if (D.9005 != 0) goto <D.9006>; else goto <D.9007>;
        <D.9006>:
        D.9008 = &MEM[(void *)"0123456789" + 1B];
        D.9009 = *D.9008;
        D.9010 = (int) D.9009;
        D.9011 = __s2 + 1;
        D.9012 = *D.9011;
        D.9013 = (int) D.9012;
        __result = D.9010 - D.9013;
        D.9014 = __s2_len > 1;
        D.9004 = __result == 0;
        D.9015 = D.9014 & D.9004;
        if (D.9015 != 0) goto <D.9016>; else goto <D.9017>;
        <D.9016>:
        D.9018 = &MEM[(void *)"0123456789" + 2B];
        D.9019 = *D.9018;
        D.9020 = (int) D.9019;
        D.9021 = __s2 + 2;
        D.9022 = *D.9021;
        D.9023 = (int) D.9022;
        __result = D.9020 - D.9023;
        D.9024 = __s2_len > 2;
        D.9004 = __result == 0;
        D.9025 = D.9024 & D.9004;
        if (D.9025 != 0) goto <D.9026>; else goto <D.9027>;
        <D.9026>:
        D.9028 = &MEM[(void *)"0123456789" + 3B];
        D.9029 = *D.9028;
        D.9030 = (int) D.9029;
        D.9031 = __s2 + 3;
        D.9032 = *D.9031;
        D.9033 = (int) D.9032;
        __result = D.9030 - D.9033;
        <D.9027>:
        <D.9017>:
        <D.9007>:
      }
      D.5790 = __result;
    }
    iftmp.88 = -D.5790;
    goto <D.9034>;
    <D.8997>:
    iftmp.88 = __builtin_strcmp (dest, "0123456789");
    <D.9034>:
    D.5791 = iftmp.88;
  }
  if (D.5791 != 0) goto <D.9035>; else goto <D.9036>;
  <D.9035>:
  D.8936 = FAILED ("problem [%s] and [%s]", dest, "0123456789");
  return D.8936;
  <D.9036>:
  monoeg_g_free (dest);
  D.8936 = 0B;
  return D.8936;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.9040;
  int D.9045;
  void * D.9047;
  long unsigned int D.9048;

  D.9040 = __builtin_constant_p (__len);
  if (D.9040 != 0) goto <D.9041>; else goto <D.9042>;
  <D.9041>:
  if (__len == 0) goto <D.9043>; else goto <D.9044>;
  <D.9043>:
  D.9045 = __builtin_constant_p (__ch);
  if (D.9045 == 0) goto <D.9038>; else goto <D.9046>;
  <D.9046>:
  if (__ch != 0) goto <D.9038>; else goto <D.9039>;
  <D.9038>:
  __warn_memset_zero_len ();
  D.9047 = __dest;
  return D.9047;
  <D.9039>:
  <D.9044>:
  <D.9042>:
  D.9048 = __builtin_object_size (__dest, 0);
  D.9047 = __builtin___memset_chk (__dest, __ch, __len, D.9048);
  return D.9047;
}


test_strescape ()
{
  int D.5803;
  int iftmp.89;
  int D.5799;
  char[4] * D.9053;
  unsigned char D.9054;
  int D.9055;
  unsigned char D.9056;
  int D.9057;
  _Bool D.9058;
  _Bool D.9059;
  _Bool D.9060;
  const unsigned char * D.9063;
  unsigned char D.9064;
  int D.9065;
  const unsigned char * D.9066;
  unsigned char D.9067;
  int D.9068;
  _Bool D.9069;
  _Bool D.9070;
  const unsigned char * D.9073;
  unsigned char D.9074;
  int D.9075;
  const unsigned char * D.9076;
  unsigned char D.9077;
  int D.9078;
  _Bool D.9079;
  _Bool D.9080;
  const unsigned char * D.9083;
  unsigned char D.9084;
  int D.9085;
  const unsigned char * D.9086;
  unsigned char D.9087;
  int D.9088;
  gchar * D.9092;
  int D.5812;
  int iftmp.90;
  int D.5808;
  char[18] * D.9096;
  unsigned char D.9097;
  int D.9098;
  unsigned char D.9099;
  int D.9100;
  _Bool D.9101;
  _Bool D.9102;
  _Bool D.9103;
  const unsigned char * D.9106;
  unsigned char D.9107;
  int D.9108;
  const unsigned char * D.9109;
  unsigned char D.9110;
  int D.9111;
  _Bool D.9112;
  _Bool D.9113;
  const unsigned char * D.9116;
  unsigned char D.9117;
  int D.9118;
  const unsigned char * D.9119;
  unsigned char D.9120;
  int D.9121;
  _Bool D.9122;
  _Bool D.9123;
  const unsigned char * D.9126;
  unsigned char D.9127;
  int D.9128;
  const unsigned char * D.9129;
  unsigned char D.9130;
  int D.9131;
  int D.5821;
  int iftmp.91;
  int D.5817;
  char[8] * D.9138;
  unsigned char D.9139;
  int D.9140;
  unsigned char D.9141;
  int D.9142;
  _Bool D.9143;
  _Bool D.9144;
  _Bool D.9145;
  const unsigned char * D.9148;
  unsigned char D.9149;
  int D.9150;
  const unsigned char * D.9151;
  unsigned char D.9152;
  int D.9153;
  _Bool D.9154;
  _Bool D.9155;
  const unsigned char * D.9158;
  unsigned char D.9159;
  int D.9160;
  const unsigned char * D.9161;
  unsigned char D.9162;
  int D.9163;
  _Bool D.9164;
  _Bool D.9165;
  const unsigned char * D.9168;
  unsigned char D.9169;
  int D.9170;
  const unsigned char * D.9171;
  unsigned char D.9172;
  int D.9173;
  int D.5830;
  int iftmp.92;
  int D.5826;
  char[5] * D.9180;
  unsigned char D.9181;
  int D.9182;
  unsigned char D.9183;
  int D.9184;
  _Bool D.9185;
  _Bool D.9186;
  _Bool D.9187;
  const unsigned char * D.9190;
  unsigned char D.9191;
  int D.9192;
  const unsigned char * D.9193;
  unsigned char D.9194;
  int D.9195;
  _Bool D.9196;
  _Bool D.9197;
  const unsigned char * D.9200;
  unsigned char D.9201;
  int D.9202;
  const unsigned char * D.9203;
  unsigned char D.9204;
  int D.9205;
  _Bool D.9206;
  _Bool D.9207;
  const unsigned char * D.9210;
  unsigned char D.9211;
  int D.9212;
  const unsigned char * D.9213;
  unsigned char D.9214;
  int D.9215;
  gchar * str;

  str = monoeg_g_strescape ("abc", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.9051>; else goto <D.9052>;
    <D.9051>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.9053 = "abc";
      D.9054 = MEM[(const unsigned char *)D.9053];
      D.9055 = (int) D.9054;
      D.9056 = *__s2;
      D.9057 = (int) D.9056;
      __result = D.9055 - D.9057;
      {
        D.9058 = __s1_len != 0;
        D.9059 = __result == 0;
        D.9060 = D.9058 & D.9059;
        if (D.9060 != 0) goto <D.9061>; else goto <D.9062>;
        <D.9061>:
        D.9063 = &MEM[(void *)"abc" + 1B];
        D.9064 = *D.9063;
        D.9065 = (int) D.9064;
        D.9066 = __s2 + 1;
        D.9067 = *D.9066;
        D.9068 = (int) D.9067;
        __result = D.9065 - D.9068;
        D.9069 = __s1_len > 1;
        D.9059 = __result == 0;
        D.9070 = D.9069 & D.9059;
        if (D.9070 != 0) goto <D.9071>; else goto <D.9072>;
        <D.9071>:
        D.9073 = &MEM[(void *)"abc" + 2B];
        D.9074 = *D.9073;
        D.9075 = (int) D.9074;
        D.9076 = __s2 + 2;
        D.9077 = *D.9076;
        D.9078 = (int) D.9077;
        __result = D.9075 - D.9078;
        D.9079 = __s1_len > 2;
        D.9059 = __result == 0;
        D.9080 = D.9079 & D.9059;
        if (D.9080 != 0) goto <D.9081>; else goto <D.9082>;
        <D.9081>:
        D.9083 = &MEM[(void *)"abc" + 3B];
        D.9084 = *D.9083;
        D.9085 = (int) D.9084;
        D.9086 = __s2 + 3;
        D.9087 = *D.9086;
        D.9088 = (int) D.9087;
        __result = D.9085 - D.9088;
        <D.9082>:
        <D.9072>:
        <D.9062>:
      }
      D.5799 = __result;
    }
    iftmp.89 = D.5799;
    goto <D.9089>;
    <D.9052>:
    iftmp.89 = __builtin_strcmp ("abc", str);
    <D.9089>:
    D.5803 = iftmp.89;
  }
  if (D.5803 != 0) goto <D.9090>; else goto <D.9091>;
  <D.9090>:
  D.9092 = FAILED ("#1");
  return D.9092;
  <D.9091>:
  str = monoeg_g_strescape ("\t\b\f\n\r\\\"abc", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 17;
    if (__s1_len <= 3) goto <D.9094>; else goto <D.9095>;
    <D.9094>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.9096 = "\\t\\b\\f\\n\\r\\\\\\\"abc";
      D.9097 = MEM[(const unsigned char *)D.9096];
      D.9098 = (int) D.9097;
      D.9099 = *__s2;
      D.9100 = (int) D.9099;
      __result = D.9098 - D.9100;
      {
        D.9101 = __s1_len != 0;
        D.9102 = __result == 0;
        D.9103 = D.9101 & D.9102;
        if (D.9103 != 0) goto <D.9104>; else goto <D.9105>;
        <D.9104>:
        D.9106 = &MEM[(void *)"\\t\\b\\f\\n\\r\\\\\\\"abc" + 1B];
        D.9107 = *D.9106;
        D.9108 = (int) D.9107;
        D.9109 = __s2 + 1;
        D.9110 = *D.9109;
        D.9111 = (int) D.9110;
        __result = D.9108 - D.9111;
        D.9112 = __s1_len > 1;
        D.9102 = __result == 0;
        D.9113 = D.9112 & D.9102;
        if (D.9113 != 0) goto <D.9114>; else goto <D.9115>;
        <D.9114>:
        D.9116 = &MEM[(void *)"\\t\\b\\f\\n\\r\\\\\\\"abc" + 2B];
        D.9117 = *D.9116;
        D.9118 = (int) D.9117;
        D.9119 = __s2 + 2;
        D.9120 = *D.9119;
        D.9121 = (int) D.9120;
        __result = D.9118 - D.9121;
        D.9122 = __s1_len > 2;
        D.9102 = __result == 0;
        D.9123 = D.9122 & D.9102;
        if (D.9123 != 0) goto <D.9124>; else goto <D.9125>;
        <D.9124>:
        D.9126 = &MEM[(void *)"\\t\\b\\f\\n\\r\\\\\\\"abc" + 3B];
        D.9127 = *D.9126;
        D.9128 = (int) D.9127;
        D.9129 = __s2 + 3;
        D.9130 = *D.9129;
        D.9131 = (int) D.9130;
        __result = D.9128 - D.9131;
        <D.9125>:
        <D.9115>:
        <D.9105>:
      }
      D.5808 = __result;
    }
    iftmp.90 = D.5808;
    goto <D.9132>;
    <D.9095>:
    iftmp.90 = __builtin_strcmp ("\\t\\b\\f\\n\\r\\\\\\\"abc", str);
    <D.9132>:
    D.5812 = iftmp.90;
  }
  if (D.5812 != 0) goto <D.9133>; else goto <D.9134>;
  <D.9133>:
  D.9092 = FAILED ("#2 %s", str);
  return D.9092;
  <D.9134>:
  str = monoeg_g_strescape ("\1abc", 0B);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 7;
    if (__s1_len <= 3) goto <D.9136>; else goto <D.9137>;
    <D.9136>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.9138 = "\\001abc";
      D.9139 = MEM[(const unsigned char *)D.9138];
      D.9140 = (int) D.9139;
      D.9141 = *__s2;
      D.9142 = (int) D.9141;
      __result = D.9140 - D.9142;
      {
        D.9143 = __s1_len != 0;
        D.9144 = __result == 0;
        D.9145 = D.9143 & D.9144;
        if (D.9145 != 0) goto <D.9146>; else goto <D.9147>;
        <D.9146>:
        D.9148 = &MEM[(void *)"\\001abc" + 1B];
        D.9149 = *D.9148;
        D.9150 = (int) D.9149;
        D.9151 = __s2 + 1;
        D.9152 = *D.9151;
        D.9153 = (int) D.9152;
        __result = D.9150 - D.9153;
        D.9154 = __s1_len > 1;
        D.9144 = __result == 0;
        D.9155 = D.9154 & D.9144;
        if (D.9155 != 0) goto <D.9156>; else goto <D.9157>;
        <D.9156>:
        D.9158 = &MEM[(void *)"\\001abc" + 2B];
        D.9159 = *D.9158;
        D.9160 = (int) D.9159;
        D.9161 = __s2 + 2;
        D.9162 = *D.9161;
        D.9163 = (int) D.9162;
        __result = D.9160 - D.9163;
        D.9164 = __s1_len > 2;
        D.9144 = __result == 0;
        D.9165 = D.9164 & D.9144;
        if (D.9165 != 0) goto <D.9166>; else goto <D.9167>;
        <D.9166>:
        D.9168 = &MEM[(void *)"\\001abc" + 3B];
        D.9169 = *D.9168;
        D.9170 = (int) D.9169;
        D.9171 = __s2 + 3;
        D.9172 = *D.9171;
        D.9173 = (int) D.9172;
        __result = D.9170 - D.9173;
        <D.9167>:
        <D.9157>:
        <D.9147>:
      }
      D.5817 = __result;
    }
    iftmp.91 = D.5817;
    goto <D.9174>;
    <D.9137>:
    iftmp.91 = __builtin_strcmp ("\\001abc", str);
    <D.9174>:
    D.5821 = iftmp.91;
  }
  if (D.5821 != 0) goto <D.9175>; else goto <D.9176>;
  <D.9175>:
  D.9092 = FAILED ("#3 %s", str);
  return D.9092;
  <D.9176>:
  str = monoeg_g_strescape ("\1abc", "\1");
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 4;
    if (__s1_len <= 3) goto <D.9178>; else goto <D.9179>;
    <D.9178>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.9180 = "\1abc";
      D.9181 = MEM[(const unsigned char *)D.9180];
      D.9182 = (int) D.9181;
      D.9183 = *__s2;
      D.9184 = (int) D.9183;
      __result = D.9182 - D.9184;
      {
        D.9185 = __s1_len != 0;
        D.9186 = __result == 0;
        D.9187 = D.9185 & D.9186;
        if (D.9187 != 0) goto <D.9188>; else goto <D.9189>;
        <D.9188>:
        D.9190 = &MEM[(void *)"\1abc" + 1B];
        D.9191 = *D.9190;
        D.9192 = (int) D.9191;
        D.9193 = __s2 + 1;
        D.9194 = *D.9193;
        D.9195 = (int) D.9194;
        __result = D.9192 - D.9195;
        D.9196 = __s1_len > 1;
        D.9186 = __result == 0;
        D.9197 = D.9196 & D.9186;
        if (D.9197 != 0) goto <D.9198>; else goto <D.9199>;
        <D.9198>:
        D.9200 = &MEM[(void *)"\1abc" + 2B];
        D.9201 = *D.9200;
        D.9202 = (int) D.9201;
        D.9203 = __s2 + 2;
        D.9204 = *D.9203;
        D.9205 = (int) D.9204;
        __result = D.9202 - D.9205;
        D.9206 = __s1_len > 2;
        D.9186 = __result == 0;
        D.9207 = D.9206 & D.9186;
        if (D.9207 != 0) goto <D.9208>; else goto <D.9209>;
        <D.9208>:
        D.9210 = &MEM[(void *)"\1abc" + 3B];
        D.9211 = *D.9210;
        D.9212 = (int) D.9211;
        D.9213 = __s2 + 3;
        D.9214 = *D.9213;
        D.9215 = (int) D.9214;
        __result = D.9212 - D.9215;
        <D.9209>:
        <D.9199>:
        <D.9189>:
      }
      D.5826 = __result;
    }
    iftmp.92 = D.5826;
    goto <D.9216>;
    <D.9179>:
    iftmp.92 = __builtin_strcmp ("\1abc", str);
    <D.9216>:
    D.5830 = iftmp.92;
  }
  if (D.5830 != 0) goto <D.9217>; else goto <D.9218>;
  <D.9217>:
  D.9092 = FAILED ("#3 %s", str);
  return D.9092;
  <D.9218>:
  D.9092 = 0B;
  return D.9092;
}


test_ascii_strncasecmp ()
{
  gchar * D.9222;
  int n;

  n = monoeg_g_ascii_strncasecmp ("123", "123", 1);
  if (n != 0) goto <D.9220>; else goto <D.9221>;
  <D.9220>:
  D.9222 = FAILED ("Should have been 0");
  return D.9222;
  <D.9221>:
  n = monoeg_g_ascii_strncasecmp ("423", "123", 1);
  if (n != 3) goto <D.9223>; else goto <D.9224>;
  <D.9223>:
  D.9222 = FAILED ("Should have been 3, got %d", n);
  return D.9222;
  <D.9224>:
  n = monoeg_g_ascii_strncasecmp ("123", "423", 1);
  if (n != -3) goto <D.9225>; else goto <D.9226>;
  <D.9225>:
  D.9222 = FAILED ("Should have been -3, got %d", n);
  return D.9222;
  <D.9226>:
  n = monoeg_g_ascii_strncasecmp ("1", "1", 10);
  if (n != 0) goto <D.9227>; else goto <D.9228>;
  <D.9227>:
  D.9222 = FAILED ("Should have been 0, got %d", n);
  return D.9222;
  <D.9228>:
  D.9222 = 0B;
  return D.9222;
}


test_ascii_strdown ()
{
  long unsigned int D.9230;
  long int D.9231;
  long unsigned int D.9232;
  gchar * D.9235;
  const gchar * a;
  const gchar * b;
  gchar * c;
  gint n;
  gint l;

  a = "~09+AaBcDeFzZ$0909EmPAbCdEEEEEZZZZAAA";
  b = "~09+aabcdefzz$0909empabcdeeeeezzzzaaa";
  D.9230 = strlen (b);
  l = (gint) D.9230;
  D.9231 = (long int) l;
  c = monoeg_g_ascii_strdown (a, D.9231);
  D.9232 = (long unsigned int) l;
  n = monoeg_g_ascii_strncasecmp (b, c, D.9232);
  if (n != 0) goto <D.9233>; else goto <D.9234>;
  <D.9233>:
  monoeg_g_free (c);
  D.9235 = FAILED ("Should have been 0, got %d", n);
  return D.9235;
  <D.9234>:
  monoeg_g_free (c);
  D.9235 = 0B;
  return D.9235;
}


test_strdupv ()
{
  gchar * D.9239;
  unsigned int D.9242;
  gchar * * one;
  gchar * * two;
  gint len;

  one = monoeg_g_strdupv (0B);
  if (one != 0B) goto <D.9237>; else goto <D.9238>;
  <D.9237>:
  D.9239 = FAILED ("Should have been NULL");
  return D.9239;
  <D.9238>:
  one = monoeg_malloc (8);
  *one = 0B;
  two = monoeg_g_strdupv (one);
  if (two == 0B) goto <D.9240>; else goto <D.9241>;
  <D.9240>:
  FAILED ("Should have been not NULL");
  <D.9241>:
  D.9242 = monoeg_g_strv_length (two);
  len = (gint) D.9242;
  if (len != 0) goto <D.9243>; else goto <D.9244>;
  <D.9243>:
  FAILED ("Should have been 0");
  <D.9244>:
  monoeg_g_strfreev (two);
  monoeg_g_strfreev (one);
  D.9239 = 0B;
  return D.9239;
}


strutil_tests_init ()
{
  struct Test * D.9246;

  D.9246 = &strutil_tests;
  return D.9246;
}


