test_list_length ()
{
  unsigned int D.5176;
  gchar * D.5179;
  unsigned int D.5180;
  unsigned int D.5183;
  struct GList * list;

  list = monoeg_g_list_prepend (0B, "foo");
  D.5176 = monoeg_g_list_length (list);
  if (D.5176 != 1) goto <D.5177>; else goto <D.5178>;
  <D.5177>:
  D.5179 = FAILED ("length failed. #1");
  return D.5179;
  <D.5178>:
  list = monoeg_g_list_prepend (list, "bar");
  D.5180 = monoeg_g_list_length (list);
  if (D.5180 != 2) goto <D.5181>; else goto <D.5182>;
  <D.5181>:
  D.5179 = FAILED ("length failed. #2");
  return D.5179;
  <D.5182>:
  list = monoeg_g_list_append (list, "bar");
  D.5183 = monoeg_g_list_length (list);
  if (D.5183 != 3) goto <D.5184>; else goto <D.5185>;
  <D.5184>:
  D.5179 = FAILED ("length failed. #3");
  return D.5179;
  <D.5185>:
  monoeg_g_list_free (list);
  D.5179 = 0B;
  return D.5179;
}


test_list_nth ()
{
  void * D.5187;
  gchar * D.5190;
  char * foo;
  char * bar;
  char * baz;
  struct GList * nth;
  struct GList * list;

  foo = "foo";
  bar = "bar";
  baz = "baz";
  list = monoeg_g_list_prepend (0B, baz);
  list = monoeg_g_list_prepend (list, bar);
  list = monoeg_g_list_prepend (list, foo);
  nth = monoeg_g_list_nth (list, 0);
  D.5187 = nth->data;
  if (D.5187 != foo) goto <D.5188>; else goto <D.5189>;
  <D.5188>:
  D.5190 = FAILED ("nth failed. #0");
  return D.5190;
  <D.5189>:
  nth = monoeg_g_list_nth (list, 1);
  D.5187 = nth->data;
  if (D.5187 != bar) goto <D.5191>; else goto <D.5192>;
  <D.5191>:
  D.5190 = FAILED ("nth failed. #1");
  return D.5190;
  <D.5192>:
  nth = monoeg_g_list_nth (list, 2);
  D.5187 = nth->data;
  if (D.5187 != baz) goto <D.5193>; else goto <D.5194>;
  <D.5193>:
  D.5190 = FAILED ("nth failed. #2");
  return D.5190;
  <D.5194>:
  nth = monoeg_g_list_nth (list, 3);
  if (nth != 0B) goto <D.5195>; else goto <D.5196>;
  <D.5195>:
  D.5187 = nth->data;
  D.5190 = FAILED ("nth failed. #3: %s", D.5187);
  return D.5190;
  <D.5196>:
  monoeg_g_list_free (list);
  D.5190 = 0B;
  return D.5190;
}


test_list_index ()
{
  gchar * D.5200;
  int i;
  char * foo;
  char * bar;
  char * baz;
  struct GList * list;

  foo = "foo";
  bar = "bar";
  baz = "baz";
  list = monoeg_g_list_prepend (0B, baz);
  list = monoeg_g_list_prepend (list, bar);
  list = monoeg_g_list_prepend (list, foo);
  i = monoeg_g_list_index (list, foo);
  if (i != 0) goto <D.5198>; else goto <D.5199>;
  <D.5198>:
  D.5200 = FAILED ("index failed. #0: %d", i);
  return D.5200;
  <D.5199>:
  i = monoeg_g_list_index (list, bar);
  if (i != 1) goto <D.5201>; else goto <D.5202>;
  <D.5201>:
  D.5200 = FAILED ("index failed. #1: %d", i);
  return D.5200;
  <D.5202>:
  i = monoeg_g_list_index (list, baz);
  if (i != 2) goto <D.5203>; else goto <D.5204>;
  <D.5203>:
  D.5200 = FAILED ("index failed. #2: %d", i);
  return D.5200;
  <D.5204>:
  monoeg_g_list_free (list);
  D.5200 = 0B;
  return D.5200;
}


test_list_append ()
{
  unsigned int D.5206;
  gchar * D.5209;
  unsigned int D.5210;
  struct GList * list;

  list = monoeg_g_list_prepend (0B, "first");
  D.5206 = monoeg_g_list_length (list);
  if (D.5206 != 1) goto <D.5207>; else goto <D.5208>;
  <D.5207>:
  D.5209 = FAILED ("Prepend failed");
  return D.5209;
  <D.5208>:
  list = monoeg_g_list_append (list, "second");
  D.5210 = monoeg_g_list_length (list);
  if (D.5210 != 2) goto <D.5211>; else goto <D.5212>;
  <D.5211>:
  D.5209 = FAILED ("Append failed");
  return D.5209;
  <D.5212>:
  monoeg_g_list_free (list);
  D.5209 = 0B;
  return D.5209;
}


test_list_last ()
{
  gchar * D.5216;
  struct GList * D.5217;
  struct GList * D.5218;
  int D.4979;
  int iftmp.0;
  int D.4975;
  char[5] * D.5222;
  unsigned char D.5223;
  int D.5224;
  unsigned char D.5225;
  int D.5226;
  _Bool D.5227;
  _Bool D.5228;
  _Bool D.5229;
  const unsigned char * D.5232;
  unsigned char D.5233;
  int D.5234;
  const unsigned char * D.5235;
  unsigned char D.5236;
  int D.5237;
  _Bool D.5238;
  _Bool D.5239;
  const unsigned char * D.5242;
  unsigned char D.5243;
  int D.5244;
  const unsigned char * D.5245;
  unsigned char D.5246;
  int D.5247;
  _Bool D.5248;
  _Bool D.5249;
  const unsigned char * D.5252;
  unsigned char D.5253;
  int D.5254;
  const unsigned char * D.5255;
  unsigned char D.5256;
  int D.5257;
  void * D.5259;
  struct GList * foo;
  struct GList * bar;
  struct GList * last;

  foo = monoeg_g_list_prepend (0B, "foo");
  bar = monoeg_g_list_prepend (0B, "bar");
  foo = monoeg_g_list_concat (foo, bar);
  last = monoeg_g_list_last (foo);
  if (last != bar) goto <D.5214>; else goto <D.5215>;
  <D.5214>:
  D.5216 = FAILED ("last failed. #1");
  return D.5216;
  <D.5215>:
  D.5217 = monoeg_g_list_prepend (0B, "baz");
  foo = monoeg_g_list_concat (foo, D.5217);
  D.5218 = monoeg_g_list_prepend (0B, "quux");
  foo = monoeg_g_list_concat (foo, D.5218);
  last = monoeg_g_list_last (foo);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = last->data;
      D.5222 = "quux";
      D.5223 = MEM[(const unsigned char *)D.5222];
      D.5224 = (int) D.5223;
      D.5225 = *__s2;
      D.5226 = (int) D.5225;
      __result = D.5224 - D.5226;
      {
        D.5227 = __s1_len != 0;
        D.5228 = __result == 0;
        D.5229 = D.5227 & D.5228;
        if (D.5229 != 0) goto <D.5230>; else goto <D.5231>;
        <D.5230>:
        D.5232 = &MEM[(void *)"quux" + 1B];
        D.5233 = *D.5232;
        D.5234 = (int) D.5233;
        D.5235 = __s2 + 1;
        D.5236 = *D.5235;
        D.5237 = (int) D.5236;
        __result = D.5234 - D.5237;
        D.5238 = __s1_len > 1;
        D.5228 = __result == 0;
        D.5239 = D.5238 & D.5228;
        if (D.5239 != 0) goto <D.5240>; else goto <D.5241>;
        <D.5240>:
        D.5242 = &MEM[(void *)"quux" + 2B];
        D.5243 = *D.5242;
        D.5244 = (int) D.5243;
        D.5245 = __s2 + 2;
        D.5246 = *D.5245;
        D.5247 = (int) D.5246;
        __result = D.5244 - D.5247;
        D.5248 = __s1_len > 2;
        D.5228 = __result == 0;
        D.5249 = D.5248 & D.5228;
        if (D.5249 != 0) goto <D.5250>; else goto <D.5251>;
        <D.5250>:
        D.5252 = &MEM[(void *)"quux" + 3B];
        D.5253 = *D.5252;
        D.5254 = (int) D.5253;
        D.5255 = __s2 + 3;
        D.5256 = *D.5255;
        D.5257 = (int) D.5256;
        __result = D.5254 - D.5257;
        <D.5251>:
        <D.5241>:
        <D.5231>:
      }
      D.4975 = __result;
    }
    iftmp.0 = D.4975;
    goto <D.5258>;
    <D.5221>:
    D.5259 = last->data;
    iftmp.0 = __builtin_strcmp ("quux", D.5259);
    <D.5258>:
    D.4979 = iftmp.0;
  }
  if (D.4979 != 0) goto <D.5260>; else goto <D.5261>;
  <D.5260>:
  D.5216 = FAILED ("last failed. #2");
  return D.5216;
  <D.5261>:
  monoeg_g_list_free (foo);
  D.5216 = 0B;
  return D.5216;
}


test_list_concat ()
{
  unsigned int D.5263;
  gchar * D.5266;
  int D.4993;
  int iftmp.1;
  int D.4992;
  char[4] * D.5270;
  unsigned char D.5271;
  int D.5272;
  unsigned char D.5273;
  int D.5274;
  _Bool D.5275;
  _Bool D.5276;
  _Bool D.5277;
  const unsigned char * D.5280;
  unsigned char D.5281;
  int D.5282;
  const unsigned char * D.5283;
  unsigned char D.5284;
  int D.5285;
  _Bool D.5286;
  _Bool D.5287;
  const unsigned char * D.5290;
  unsigned char D.5291;
  int D.5292;
  const unsigned char * D.5293;
  unsigned char D.5294;
  int D.5295;
  _Bool D.5296;
  _Bool D.5297;
  const unsigned char * D.5300;
  unsigned char D.5301;
  int D.5302;
  const unsigned char * D.5303;
  unsigned char D.5304;
  int D.5305;
  void * D.5307;
  int D.5002;
  int iftmp.2;
  int D.5001;
  struct GList * D.5313;
  char[4] * D.5314;
  unsigned char D.5315;
  int D.5316;
  unsigned char D.5317;
  int D.5318;
  _Bool D.5319;
  _Bool D.5320;
  _Bool D.5321;
  const unsigned char * D.5324;
  unsigned char D.5325;
  int D.5326;
  const unsigned char * D.5327;
  unsigned char D.5328;
  int D.5329;
  _Bool D.5330;
  _Bool D.5331;
  const unsigned char * D.5334;
  unsigned char D.5335;
  int D.5336;
  const unsigned char * D.5337;
  unsigned char D.5338;
  int D.5339;
  _Bool D.5340;
  _Bool D.5341;
  const unsigned char * D.5344;
  unsigned char D.5345;
  int D.5346;
  const unsigned char * D.5347;
  unsigned char D.5348;
  int D.5349;
  void * D.5351;
  struct GList * D.5354;
  struct GList * D.5357;
  struct GList * foo;
  struct GList * bar;
  struct GList * list;

  foo = monoeg_g_list_prepend (0B, "foo");
  bar = monoeg_g_list_prepend (0B, "bar");
  list = monoeg_g_list_concat (foo, bar);
  D.5263 = monoeg_g_list_length (list);
  if (D.5263 != 2) goto <D.5264>; else goto <D.5265>;
  <D.5264>:
  D.5266 = FAILED ("Concat failed. #1");
  return D.5266;
  <D.5265>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = list->data;
      D.5270 = "foo";
      D.5271 = MEM[(const unsigned char *)D.5270];
      D.5272 = (int) D.5271;
      D.5273 = *__s2;
      D.5274 = (int) D.5273;
      __result = D.5272 - D.5274;
      {
        D.5275 = __s2_len != 0;
        D.5276 = __result == 0;
        D.5277 = D.5275 & D.5276;
        if (D.5277 != 0) goto <D.5278>; else goto <D.5279>;
        <D.5278>:
        D.5280 = &MEM[(void *)"foo" + 1B];
        D.5281 = *D.5280;
        D.5282 = (int) D.5281;
        D.5283 = __s2 + 1;
        D.5284 = *D.5283;
        D.5285 = (int) D.5284;
        __result = D.5282 - D.5285;
        D.5286 = __s2_len > 1;
        D.5276 = __result == 0;
        D.5287 = D.5286 & D.5276;
        if (D.5287 != 0) goto <D.5288>; else goto <D.5289>;
        <D.5288>:
        D.5290 = &MEM[(void *)"foo" + 2B];
        D.5291 = *D.5290;
        D.5292 = (int) D.5291;
        D.5293 = __s2 + 2;
        D.5294 = *D.5293;
        D.5295 = (int) D.5294;
        __result = D.5292 - D.5295;
        D.5296 = __s2_len > 2;
        D.5276 = __result == 0;
        D.5297 = D.5296 & D.5276;
        if (D.5297 != 0) goto <D.5298>; else goto <D.5299>;
        <D.5298>:
        D.5300 = &MEM[(void *)"foo" + 3B];
        D.5301 = *D.5300;
        D.5302 = (int) D.5301;
        D.5303 = __s2 + 3;
        D.5304 = *D.5303;
        D.5305 = (int) D.5304;
        __result = D.5302 - D.5305;
        <D.5299>:
        <D.5289>:
        <D.5279>:
      }
      D.4992 = __result;
    }
    iftmp.1 = -D.4992;
    goto <D.5306>;
    <D.5269>:
    D.5307 = list->data;
    iftmp.1 = __builtin_strcmp (D.5307, "foo");
    <D.5306>:
    D.4993 = iftmp.1;
  }
  if (D.4993 != 0) goto <D.5308>; else goto <D.5309>;
  <D.5308>:
  D.5266 = FAILED ("Concat failed. #2");
  return D.5266;
  <D.5309>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.5313 = list->next;
      __s2 = D.5313->data;
      D.5314 = "bar";
      D.5315 = MEM[(const unsigned char *)D.5314];
      D.5316 = (int) D.5315;
      D.5317 = *__s2;
      D.5318 = (int) D.5317;
      __result = D.5316 - D.5318;
      {
        D.5319 = __s2_len != 0;
        D.5320 = __result == 0;
        D.5321 = D.5319 & D.5320;
        if (D.5321 != 0) goto <D.5322>; else goto <D.5323>;
        <D.5322>:
        D.5324 = &MEM[(void *)"bar" + 1B];
        D.5325 = *D.5324;
        D.5326 = (int) D.5325;
        D.5327 = __s2 + 1;
        D.5328 = *D.5327;
        D.5329 = (int) D.5328;
        __result = D.5326 - D.5329;
        D.5330 = __s2_len > 1;
        D.5320 = __result == 0;
        D.5331 = D.5330 & D.5320;
        if (D.5331 != 0) goto <D.5332>; else goto <D.5333>;
        <D.5332>:
        D.5334 = &MEM[(void *)"bar" + 2B];
        D.5335 = *D.5334;
        D.5336 = (int) D.5335;
        D.5337 = __s2 + 2;
        D.5338 = *D.5337;
        D.5339 = (int) D.5338;
        __result = D.5336 - D.5339;
        D.5340 = __s2_len > 2;
        D.5320 = __result == 0;
        D.5341 = D.5340 & D.5320;
        if (D.5341 != 0) goto <D.5342>; else goto <D.5343>;
        <D.5342>:
        D.5344 = &MEM[(void *)"bar" + 3B];
        D.5345 = *D.5344;
        D.5346 = (int) D.5345;
        D.5347 = __s2 + 3;
        D.5348 = *D.5347;
        D.5349 = (int) D.5348;
        __result = D.5346 - D.5349;
        <D.5343>:
        <D.5333>:
        <D.5323>:
      }
      D.5001 = __result;
    }
    iftmp.2 = -D.5001;
    goto <D.5350>;
    <D.5312>:
    D.5313 = list->next;
    D.5351 = D.5313->data;
    iftmp.2 = __builtin_strcmp (D.5351, "bar");
    <D.5350>:
    D.5002 = iftmp.2;
  }
  if (D.5002 != 0) goto <D.5352>; else goto <D.5353>;
  <D.5352>:
  D.5266 = FAILED ("Concat failed. #3");
  return D.5266;
  <D.5353>:
  D.5354 = monoeg_g_list_first (list);
  if (D.5354 != foo) goto <D.5355>; else goto <D.5356>;
  <D.5355>:
  D.5266 = FAILED ("Concat failed. #4");
  return D.5266;
  <D.5356>:
  D.5357 = monoeg_g_list_last (list);
  if (D.5357 != bar) goto <D.5358>; else goto <D.5359>;
  <D.5358>:
  D.5266 = FAILED ("Concat failed. #5");
  return D.5266;
  <D.5359>:
  monoeg_g_list_free (list);
  D.5266 = 0B;
  return D.5266;
}


test_list_insert_sorted ()
{
  int D.5020;
  int iftmp.3;
  int D.5016;
  struct GList * D.5364;
  char[3] * D.5365;
  unsigned char D.5366;
  int D.5367;
  unsigned char D.5368;
  int D.5369;
  _Bool D.5370;
  _Bool D.5371;
  _Bool D.5372;
  const unsigned char * D.5375;
  unsigned char D.5376;
  int D.5377;
  const unsigned char * D.5378;
  unsigned char D.5379;
  int D.5380;
  _Bool D.5381;
  _Bool D.5382;
  const unsigned char * D.5385;
  unsigned char D.5386;
  int D.5387;
  const unsigned char * D.5388;
  unsigned char D.5389;
  int D.5390;
  _Bool D.5391;
  _Bool D.5392;
  const unsigned char * D.5395;
  unsigned char D.5396;
  int D.5397;
  const unsigned char * D.5398;
  unsigned char D.5399;
  int D.5400;
  void * D.5402;
  gchar * D.5405;
  int D.5029;
  int iftmp.4;
  int D.5025;
  char[1] * D.5409;
  unsigned char D.5410;
  int D.5411;
  unsigned char D.5412;
  int D.5413;
  _Bool D.5414;
  _Bool D.5415;
  _Bool D.5416;
  const unsigned char * D.5419;
  unsigned char D.5420;
  int D.5421;
  const unsigned char * D.5422;
  unsigned char D.5423;
  int D.5424;
  _Bool D.5425;
  _Bool D.5426;
  const unsigned char * D.5429;
  unsigned char D.5430;
  int D.5431;
  const unsigned char * D.5432;
  unsigned char D.5433;
  int D.5434;
  _Bool D.5435;
  _Bool D.5436;
  const unsigned char * D.5439;
  unsigned char D.5440;
  int D.5441;
  const unsigned char * D.5442;
  unsigned char D.5443;
  int D.5444;
  void * D.5446;
  unsigned char D.5447;
  int D.5448;
  int D.5038;
  int iftmp.5;
  int D.5034;
  struct GList * D.5454;
  char[5] * D.5455;
  unsigned char D.5456;
  int D.5457;
  unsigned char D.5458;
  int D.5459;
  _Bool D.5460;
  _Bool D.5461;
  _Bool D.5462;
  const unsigned char * D.5465;
  unsigned char D.5466;
  int D.5467;
  const unsigned char * D.5468;
  unsigned char D.5469;
  int D.5470;
  _Bool D.5471;
  _Bool D.5472;
  const unsigned char * D.5475;
  unsigned char D.5476;
  int D.5477;
  const unsigned char * D.5478;
  unsigned char D.5479;
  int D.5480;
  _Bool D.5481;
  _Bool D.5482;
  const unsigned char * D.5485;
  unsigned char D.5486;
  int D.5487;
  const unsigned char * D.5488;
  unsigned char D.5489;
  int D.5490;
  struct GList * D.5492;
  void * D.5493;
  struct GList * list;

  list = monoeg_g_list_prepend (0B, "a");
  list = monoeg_g_list_append (list, "aaa");
  list = monoeg_g_list_insert_sorted (list, "aa", compare);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.5364 = list->next;
      __s2 = D.5364->data;
      D.5365 = "aa";
      D.5366 = MEM[(const unsigned char *)D.5365];
      D.5367 = (int) D.5366;
      D.5368 = *__s2;
      D.5369 = (int) D.5368;
      __result = D.5367 - D.5369;
      {
        D.5370 = __s1_len != 0;
        D.5371 = __result == 0;
        D.5372 = D.5370 & D.5371;
        if (D.5372 != 0) goto <D.5373>; else goto <D.5374>;
        <D.5373>:
        D.5375 = &MEM[(void *)"aa" + 1B];
        D.5376 = *D.5375;
        D.5377 = (int) D.5376;
        D.5378 = __s2 + 1;
        D.5379 = *D.5378;
        D.5380 = (int) D.5379;
        __result = D.5377 - D.5380;
        D.5381 = __s1_len > 1;
        D.5371 = __result == 0;
        D.5382 = D.5381 & D.5371;
        if (D.5382 != 0) goto <D.5383>; else goto <D.5384>;
        <D.5383>:
        D.5385 = &MEM[(void *)"aa" + 2B];
        D.5386 = *D.5385;
        D.5387 = (int) D.5386;
        D.5388 = __s2 + 2;
        D.5389 = *D.5388;
        D.5390 = (int) D.5389;
        __result = D.5387 - D.5390;
        D.5391 = __s1_len > 2;
        D.5371 = __result == 0;
        D.5392 = D.5391 & D.5371;
        if (D.5392 != 0) goto <D.5393>; else goto <D.5394>;
        <D.5393>:
        D.5395 = &MEM[(void *)"aa" + 3B];
        D.5396 = *D.5395;
        D.5397 = (int) D.5396;
        D.5398 = __s2 + 3;
        D.5399 = *D.5398;
        D.5400 = (int) D.5399;
        __result = D.5397 - D.5400;
        <D.5394>:
        <D.5384>:
        <D.5374>:
      }
      D.5016 = __result;
    }
    iftmp.3 = D.5016;
    goto <D.5401>;
    <D.5363>:
    D.5364 = list->next;
    D.5402 = D.5364->data;
    iftmp.3 = __builtin_strcmp ("aa", D.5402);
    <D.5401>:
    D.5020 = iftmp.3;
  }
  if (D.5020 != 0) goto <D.5403>; else goto <D.5404>;
  <D.5403>:
  D.5405 = FAILED ("insert_sorted failed. #1");
  return D.5405;
  <D.5404>:
  list = monoeg_g_list_insert_sorted (list, "", compare);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = list->data;
      D.5409 = "";
      D.5410 = MEM[(const unsigned char *)D.5409];
      D.5411 = (int) D.5410;
      D.5412 = *__s2;
      D.5413 = (int) D.5412;
      __result = D.5411 - D.5413;
      {
        D.5414 = __s1_len != 0;
        D.5415 = __result == 0;
        D.5416 = D.5414 & D.5415;
        if (D.5416 != 0) goto <D.5417>; else goto <D.5418>;
        <D.5417>:
        D.5419 = &MEM[(void *)"" + 1B];
        D.5420 = *D.5419;
        D.5421 = (int) D.5420;
        D.5422 = __s2 + 1;
        D.5423 = *D.5422;
        D.5424 = (int) D.5423;
        __result = D.5421 - D.5424;
        D.5425 = __s1_len > 1;
        D.5415 = __result == 0;
        D.5426 = D.5425 & D.5415;
        if (D.5426 != 0) goto <D.5427>; else goto <D.5428>;
        <D.5427>:
        D.5429 = &MEM[(void *)"" + 2B];
        D.5430 = *D.5429;
        D.5431 = (int) D.5430;
        D.5432 = __s2 + 2;
        D.5433 = *D.5432;
        D.5434 = (int) D.5433;
        __result = D.5431 - D.5434;
        D.5435 = __s1_len > 2;
        D.5415 = __result == 0;
        D.5436 = D.5435 & D.5415;
        if (D.5436 != 0) goto <D.5437>; else goto <D.5438>;
        <D.5437>:
        D.5439 = &MEM[(void *)"" + 3B];
        D.5440 = *D.5439;
        D.5441 = (int) D.5440;
        D.5442 = __s2 + 3;
        D.5443 = *D.5442;
        D.5444 = (int) D.5443;
        __result = D.5441 - D.5444;
        <D.5438>:
        <D.5428>:
        <D.5418>:
      }
      D.5025 = __result;
    }
    iftmp.4 = D.5025;
    goto <D.5445>;
    <D.5408>:
    D.5446 = list->data;
    D.5447 = MEM[(const unsigned char * {ref-all})D.5446];
    D.5448 = (int) D.5447;
    iftmp.4 = -D.5448;
    <D.5445>:
    D.5029 = iftmp.4;
  }
  if (D.5029 != 0) goto <D.5449>; else goto <D.5450>;
  <D.5449>:
  D.5405 = FAILED ("insert_sorted failed. #2");
  return D.5405;
  <D.5450>:
  list = monoeg_g_list_insert_sorted (list, "aaaa", compare);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.5454 = monoeg_g_list_last (list);
      __s2 = D.5454->data;
      D.5455 = "aaaa";
      D.5456 = MEM[(const unsigned char *)D.5455];
      D.5457 = (int) D.5456;
      D.5458 = *__s2;
      D.5459 = (int) D.5458;
      __result = D.5457 - D.5459;
      {
        D.5460 = __s1_len != 0;
        D.5461 = __result == 0;
        D.5462 = D.5460 & D.5461;
        if (D.5462 != 0) goto <D.5463>; else goto <D.5464>;
        <D.5463>:
        D.5465 = &MEM[(void *)"aaaa" + 1B];
        D.5466 = *D.5465;
        D.5467 = (int) D.5466;
        D.5468 = __s2 + 1;
        D.5469 = *D.5468;
        D.5470 = (int) D.5469;
        __result = D.5467 - D.5470;
        D.5471 = __s1_len > 1;
        D.5461 = __result == 0;
        D.5472 = D.5471 & D.5461;
        if (D.5472 != 0) goto <D.5473>; else goto <D.5474>;
        <D.5473>:
        D.5475 = &MEM[(void *)"aaaa" + 2B];
        D.5476 = *D.5475;
        D.5477 = (int) D.5476;
        D.5478 = __s2 + 2;
        D.5479 = *D.5478;
        D.5480 = (int) D.5479;
        __result = D.5477 - D.5480;
        D.5481 = __s1_len > 2;
        D.5461 = __result == 0;
        D.5482 = D.5481 & D.5461;
        if (D.5482 != 0) goto <D.5483>; else goto <D.5484>;
        <D.5483>:
        D.5485 = &MEM[(void *)"aaaa" + 3B];
        D.5486 = *D.5485;
        D.5487 = (int) D.5486;
        D.5488 = __s2 + 3;
        D.5489 = *D.5488;
        D.5490 = (int) D.5489;
        __result = D.5487 - D.5490;
        <D.5484>:
        <D.5474>:
        <D.5464>:
      }
      D.5034 = __result;
    }
    iftmp.5 = D.5034;
    goto <D.5491>;
    <D.5453>:
    D.5492 = monoeg_g_list_last (list);
    D.5493 = D.5492->data;
    iftmp.5 = __builtin_strcmp ("aaaa", D.5493);
    <D.5491>:
    D.5038 = iftmp.5;
  }
  if (D.5038 != 0) goto <D.5494>; else goto <D.5495>;
  <D.5494>:
  D.5405 = FAILED ("insert_sorted failed. #3");
  return D.5405;
  <D.5495>:
  monoeg_g_list_free (list);
  D.5405 = 0B;
  return D.5405;
}


compare (const void * a, const void * b)
{
  long unsigned int D.5497;
  long unsigned int D.5498;
  gint D.5501;
  char * foo;
  char * bar;

  foo = a;
  bar = b;
  D.5497 = strlen (foo);
  D.5498 = strlen (bar);
  if (D.5497 < D.5498) goto <D.5499>; else goto <D.5500>;
  <D.5499>:
  D.5501 = -1;
  return D.5501;
  <D.5500>:
  D.5501 = 1;
  return D.5501;
}


test_list_copy ()
{
  unsigned int D.5503;
  int D.5053;
  unsigned int i.6;
  struct GList * D.5505;
  void * D.5506;
  struct GList * D.5507;
  void * D.5508;
  gchar * D.5511;
  int i;
  int length;
  struct GList * list;
  struct GList * copy;

  list = monoeg_g_list_prepend (0B, "a");
  list = monoeg_g_list_append (list, "aa");
  list = monoeg_g_list_append (list, "aaa");
  list = monoeg_g_list_append (list, "aaaa");
  D.5503 = monoeg_g_list_length (list);
  length = (int) D.5503;
  copy = monoeg_g_list_copy (list);
  i = 0;
  goto <D.5055>;
  <D.5054>:
  {
    size_t __s1_len;
    size_t __s2_len;

    i.6 = (unsigned int) i;
    D.5505 = monoeg_g_list_nth (copy, i.6);
    D.5506 = D.5505->data;
    i.6 = (unsigned int) i;
    D.5507 = monoeg_g_list_nth (list, i.6);
    D.5508 = D.5507->data;
    D.5053 = __builtin_strcmp (D.5508, D.5506);
  }
  if (D.5053 != 0) goto <D.5509>; else goto <D.5510>;
  <D.5509>:
  D.5511 = FAILED ("copy failed.");
  return D.5511;
  <D.5510>:
  i = i + 1;
  <D.5055>:
  if (i < length) goto <D.5054>; else goto <D.5056>;
  <D.5056>:
  monoeg_g_list_free (list);
  monoeg_g_list_free (copy);
  D.5511 = 0B;
  return D.5511;
}


test_list_reverse ()
{
  struct GList * D.5513;
  unsigned int D.5514;
  gchar * D.5517;
  unsigned int D.5518;
  int D.5072;
  struct GList * D.5519;
  void * D.5520;
  struct GList * D.5521;
  void * D.5522;
  guint i;
  guint length;
  struct GList * list;
  struct GList * reverse;

  list = monoeg_g_list_prepend (0B, "a");
  list = monoeg_g_list_append (list, "aa");
  list = monoeg_g_list_append (list, "aaa");
  list = monoeg_g_list_append (list, "aaaa");
  length = monoeg_g_list_length (list);
  D.5513 = monoeg_g_list_copy (list);
  reverse = monoeg_g_list_reverse (D.5513);
  D.5514 = monoeg_g_list_length (reverse);
  if (D.5514 != length) goto <D.5515>; else goto <D.5516>;
  <D.5515>:
  D.5517 = FAILED ("reverse failed #1");
  return D.5517;
  <D.5516>:
  i = 0;
  goto <D.5074>;
  <D.5073>:
  {
    guint j;

    D.5518 = length - i;
    j = D.5518 + 4294967295;
    {
      size_t __s1_len;
      size_t __s2_len;

      D.5519 = monoeg_g_list_nth (reverse, j);
      D.5520 = D.5519->data;
      D.5521 = monoeg_g_list_nth (list, i);
      D.5522 = D.5521->data;
      D.5072 = __builtin_strcmp (D.5522, D.5520);
    }
    if (D.5072 != 0) goto <D.5523>; else goto <D.5524>;
    <D.5523>:
    D.5517 = FAILED ("reverse failed. #2");
    return D.5517;
    <D.5524>:
  }
  i = i + 1;
  <D.5074>:
  if (i < length) goto <D.5073>; else goto <D.5075>;
  <D.5075>:
  monoeg_g_list_free (list);
  monoeg_g_list_free (reverse);
  D.5517 = 0B;
  return D.5517;
}


test_list_remove ()
{
  unsigned int D.5526;
  gchar * D.5529;
  int D.5088;
  int iftmp.7;
  int D.5084;
  char[4] * D.5533;
  unsigned char D.5534;
  int D.5535;
  unsigned char D.5536;
  int D.5537;
  _Bool D.5538;
  _Bool D.5539;
  _Bool D.5540;
  const unsigned char * D.5543;
  unsigned char D.5544;
  int D.5545;
  const unsigned char * D.5546;
  unsigned char D.5547;
  int D.5548;
  _Bool D.5549;
  _Bool D.5550;
  const unsigned char * D.5553;
  unsigned char D.5554;
  int D.5555;
  const unsigned char * D.5556;
  unsigned char D.5557;
  int D.5558;
  _Bool D.5559;
  _Bool D.5560;
  const unsigned char * D.5563;
  unsigned char D.5564;
  int D.5565;
  const unsigned char * D.5566;
  unsigned char D.5567;
  int D.5568;
  void * D.5570;
  struct GList * list;
  char * one;

  list = monoeg_g_list_prepend (0B, "three");
  one = "one";
  list = monoeg_g_list_prepend (list, "two");
  list = monoeg_g_list_prepend (list, one);
  list = monoeg_g_list_remove (list, one);
  D.5526 = monoeg_g_list_length (list);
  if (D.5526 != 2) goto <D.5527>; else goto <D.5528>;
  <D.5527>:
  D.5529 = FAILED ("Remove failed");
  return D.5529;
  <D.5528>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = list->data;
      D.5533 = "two";
      D.5534 = MEM[(const unsigned char *)D.5533];
      D.5535 = (int) D.5534;
      D.5536 = *__s2;
      D.5537 = (int) D.5536;
      __result = D.5535 - D.5537;
      {
        D.5538 = __s1_len != 0;
        D.5539 = __result == 0;
        D.5540 = D.5538 & D.5539;
        if (D.5540 != 0) goto <D.5541>; else goto <D.5542>;
        <D.5541>:
        D.5543 = &MEM[(void *)"two" + 1B];
        D.5544 = *D.5543;
        D.5545 = (int) D.5544;
        D.5546 = __s2 + 1;
        D.5547 = *D.5546;
        D.5548 = (int) D.5547;
        __result = D.5545 - D.5548;
        D.5549 = __s1_len > 1;
        D.5539 = __result == 0;
        D.5550 = D.5549 & D.5539;
        if (D.5550 != 0) goto <D.5551>; else goto <D.5552>;
        <D.5551>:
        D.5553 = &MEM[(void *)"two" + 2B];
        D.5554 = *D.5553;
        D.5555 = (int) D.5554;
        D.5556 = __s2 + 2;
        D.5557 = *D.5556;
        D.5558 = (int) D.5557;
        __result = D.5555 - D.5558;
        D.5559 = __s1_len > 2;
        D.5539 = __result == 0;
        D.5560 = D.5559 & D.5539;
        if (D.5560 != 0) goto <D.5561>; else goto <D.5562>;
        <D.5561>:
        D.5563 = &MEM[(void *)"two" + 3B];
        D.5564 = *D.5563;
        D.5565 = (int) D.5564;
        D.5566 = __s2 + 3;
        D.5567 = *D.5566;
        D.5568 = (int) D.5567;
        __result = D.5565 - D.5568;
        <D.5562>:
        <D.5552>:
        <D.5542>:
      }
      D.5084 = __result;
    }
    iftmp.7 = D.5084;
    goto <D.5569>;
    <D.5532>:
    D.5570 = list->data;
    iftmp.7 = __builtin_strcmp ("two", D.5570);
    <D.5569>:
    D.5088 = iftmp.7;
  }
  if (D.5088 != 0) goto <D.5571>; else goto <D.5572>;
  <D.5571>:
  D.5529 = FAILED ("Remove failed");
  return D.5529;
  <D.5572>:
  monoeg_g_list_free (list);
  D.5529 = 0B;
  return D.5529;
}


test_list_remove_link ()
{
  unsigned int D.5574;
  gchar * D.5577;
  struct GList * D.5578;
  struct GList * foo;
  struct GList * bar;
  struct GList * baz;
  struct GList * list;

  foo = monoeg_g_list_prepend (0B, "a");
  bar = monoeg_g_list_prepend (0B, "b");
  baz = monoeg_g_list_prepend (0B, "c");
  list = foo;
  foo = monoeg_g_list_concat (foo, bar);
  foo = monoeg_g_list_concat (foo, baz);
  list = monoeg_g_list_remove_link (list, bar);
  D.5574 = monoeg_g_list_length (list);
  if (D.5574 != 2) goto <D.5575>; else goto <D.5576>;
  <D.5575>:
  D.5577 = FAILED ("remove_link failed #1");
  return D.5577;
  <D.5576>:
  D.5578 = bar->next;
  if (D.5578 != 0B) goto <D.5579>; else goto <D.5580>;
  <D.5579>:
  D.5577 = FAILED ("remove_link failed #2");
  return D.5577;
  <D.5580>:
  monoeg_g_list_free (list);
  monoeg_g_list_free (bar);
  D.5577 = 0B;
  return D.5577;
}


test_list_insert_before ()
{
  int D.5108;
  int iftmp.8;
  int D.5107;
  char[4] * D.5585;
  unsigned char D.5586;
  int D.5587;
  unsigned char D.5588;
  int D.5589;
  _Bool D.5590;
  _Bool D.5591;
  _Bool D.5592;
  const unsigned char * D.5595;
  unsigned char D.5596;
  int D.5597;
  const unsigned char * D.5598;
  unsigned char D.5599;
  int D.5600;
  _Bool D.5601;
  _Bool D.5602;
  const unsigned char * D.5605;
  unsigned char D.5606;
  int D.5607;
  const unsigned char * D.5608;
  unsigned char D.5609;
  int D.5610;
  _Bool D.5611;
  _Bool D.5612;
  const unsigned char * D.5615;
  unsigned char D.5616;
  int D.5617;
  const unsigned char * D.5618;
  unsigned char D.5619;
  int D.5620;
  void * D.5622;
  gchar * D.5625;
  int D.5117;
  int iftmp.9;
  int D.5116;
  char[4] * D.5631;
  unsigned char D.5632;
  int D.5633;
  unsigned char D.5634;
  int D.5635;
  _Bool D.5636;
  _Bool D.5637;
  _Bool D.5638;
  const unsigned char * D.5641;
  unsigned char D.5642;
  int D.5643;
  const unsigned char * D.5644;
  unsigned char D.5645;
  int D.5646;
  _Bool D.5647;
  _Bool D.5648;
  const unsigned char * D.5651;
  unsigned char D.5652;
  int D.5653;
  const unsigned char * D.5654;
  unsigned char D.5655;
  int D.5656;
  _Bool D.5657;
  _Bool D.5658;
  const unsigned char * D.5661;
  unsigned char D.5662;
  int D.5663;
  const unsigned char * D.5664;
  unsigned char D.5665;
  int D.5666;
  void * D.5668;
  void * D.5671;
  struct GList * foo;
  struct GList * bar;
  struct GList * baz;

  foo = monoeg_g_list_prepend (0B, "foo");
  foo = monoeg_g_list_insert_before (foo, 0B, "bar");
  bar = monoeg_g_list_last (foo);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = bar->data;
      D.5585 = "bar";
      D.5586 = MEM[(const unsigned char *)D.5585];
      D.5587 = (int) D.5586;
      D.5588 = *__s2;
      D.5589 = (int) D.5588;
      __result = D.5587 - D.5589;
      {
        D.5590 = __s2_len != 0;
        D.5591 = __result == 0;
        D.5592 = D.5590 & D.5591;
        if (D.5592 != 0) goto <D.5593>; else goto <D.5594>;
        <D.5593>:
        D.5595 = &MEM[(void *)"bar" + 1B];
        D.5596 = *D.5595;
        D.5597 = (int) D.5596;
        D.5598 = __s2 + 1;
        D.5599 = *D.5598;
        D.5600 = (int) D.5599;
        __result = D.5597 - D.5600;
        D.5601 = __s2_len > 1;
        D.5591 = __result == 0;
        D.5602 = D.5601 & D.5591;
        if (D.5602 != 0) goto <D.5603>; else goto <D.5604>;
        <D.5603>:
        D.5605 = &MEM[(void *)"bar" + 2B];
        D.5606 = *D.5605;
        D.5607 = (int) D.5606;
        D.5608 = __s2 + 2;
        D.5609 = *D.5608;
        D.5610 = (int) D.5609;
        __result = D.5607 - D.5610;
        D.5611 = __s2_len > 2;
        D.5591 = __result == 0;
        D.5612 = D.5611 & D.5591;
        if (D.5612 != 0) goto <D.5613>; else goto <D.5614>;
        <D.5613>:
        D.5615 = &MEM[(void *)"bar" + 3B];
        D.5616 = *D.5615;
        D.5617 = (int) D.5616;
        D.5618 = __s2 + 3;
        D.5619 = *D.5618;
        D.5620 = (int) D.5619;
        __result = D.5617 - D.5620;
        <D.5614>:
        <D.5604>:
        <D.5594>:
      }
      D.5107 = __result;
    }
    iftmp.8 = -D.5107;
    goto <D.5621>;
    <D.5584>:
    D.5622 = bar->data;
    iftmp.8 = __builtin_strcmp (D.5622, "bar");
    <D.5621>:
    D.5108 = iftmp.8;
  }
  if (D.5108 != 0) goto <D.5623>; else goto <D.5624>;
  <D.5623>:
  D.5625 = FAILED ("1");
  return D.5625;
  <D.5624>:
  baz = monoeg_g_list_insert_before (foo, bar, "baz");
  if (foo != baz) goto <D.5626>; else goto <D.5627>;
  <D.5626>:
  D.5625 = FAILED ("2");
  return D.5625;
  <D.5627>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = monoeg_g_list_nth_data (foo, 1);
      D.5631 = "baz";
      D.5632 = MEM[(const unsigned char *)D.5631];
      D.5633 = (int) D.5632;
      D.5634 = *__s2;
      D.5635 = (int) D.5634;
      __result = D.5633 - D.5635;
      {
        D.5636 = __s2_len != 0;
        D.5637 = __result == 0;
        D.5638 = D.5636 & D.5637;
        if (D.5638 != 0) goto <D.5639>; else goto <D.5640>;
        <D.5639>:
        D.5641 = &MEM[(void *)"baz" + 1B];
        D.5642 = *D.5641;
        D.5643 = (int) D.5642;
        D.5644 = __s2 + 1;
        D.5645 = *D.5644;
        D.5646 = (int) D.5645;
        __result = D.5643 - D.5646;
        D.5647 = __s2_len > 1;
        D.5637 = __result == 0;
        D.5648 = D.5647 & D.5637;
        if (D.5648 != 0) goto <D.5649>; else goto <D.5650>;
        <D.5649>:
        D.5651 = &MEM[(void *)"baz" + 2B];
        D.5652 = *D.5651;
        D.5653 = (int) D.5652;
        D.5654 = __s2 + 2;
        D.5655 = *D.5654;
        D.5656 = (int) D.5655;
        __result = D.5653 - D.5656;
        D.5657 = __s2_len > 2;
        D.5637 = __result == 0;
        D.5658 = D.5657 & D.5637;
        if (D.5658 != 0) goto <D.5659>; else goto <D.5660>;
        <D.5659>:
        D.5661 = &MEM[(void *)"baz" + 3B];
        D.5662 = *D.5661;
        D.5663 = (int) D.5662;
        D.5664 = __s2 + 3;
        D.5665 = *D.5664;
        D.5666 = (int) D.5665;
        __result = D.5663 - D.5666;
        <D.5660>:
        <D.5650>:
        <D.5640>:
      }
      D.5116 = __result;
    }
    iftmp.9 = -D.5116;
    goto <D.5667>;
    <D.5630>:
    D.5668 = monoeg_g_list_nth_data (foo, 1);
    iftmp.9 = __builtin_strcmp (D.5668, "baz");
    <D.5667>:
    D.5117 = iftmp.9;
  }
  if (D.5117 != 0) goto <D.5669>; else goto <D.5670>;
  <D.5669>:
  D.5671 = monoeg_g_list_nth_data (foo, 1);
  D.5625 = FAILED ("3: %s", D.5671);
  return D.5625;
  <D.5670>:
  monoeg_g_list_free (foo);
  D.5625 = 0B;
  return D.5625;
}


test_list_sort ()
{
  long int D.5673;
  void * D.5674;
  int D.5675;
  gchar * D.5678;
  int D.5679;
  long int D.5680;
  void * D.5681;
  int D.5682;
  int D.5685;
  int D.5688;
  long int D.5689;
  void * D.5690;
  int D.5691;
  int i;
  int j;
  int mul;
  struct GList * list;

  list = 0B;
  i = 0;
  goto <D.5138>;
  <D.5137>:
  D.5673 = (long int) i;
  D.5674 = (void *) D.5673;
  list = monoeg_g_list_prepend (list, D.5674);
  i = i + 1;
  <D.5138>:
  if (i <= 100) goto <D.5137>; else goto <D.5139>;
  <D.5139>:
  list = monoeg_g_list_sort (list, intcompare);
  D.5675 = verify_sort (list, 101);
  if (D.5675 == 0) goto <D.5676>; else goto <D.5677>;
  <D.5676>:
  D.5678 = FAILED ("decreasing list");
  return D.5678;
  <D.5677>:
  monoeg_g_list_free (list);
  list = 0B;
  i = 0;
  goto <D.5141>;
  <D.5140>:
  D.5679 = -i;
  D.5680 = (long int) D.5679;
  D.5681 = (void *) D.5680;
  list = monoeg_g_list_prepend (list, D.5681);
  i = i + 1;
  <D.5141>:
  if (i <= 100) goto <D.5140>; else goto <D.5142>;
  <D.5142>:
  list = monoeg_g_list_sort (list, intcompare);
  D.5682 = verify_sort (list, 101);
  if (D.5682 == 0) goto <D.5683>; else goto <D.5684>;
  <D.5683>:
  D.5678 = FAILED ("increasing list");
  return D.5678;
  <D.5684>:
  monoeg_g_list_free (list);
  list = monoeg_g_list_prepend (0B, 0B);
  i = 1;
  goto <D.5144>;
  <D.5143>:
  D.5673 = (long int) i;
  D.5674 = (void *) D.5673;
  list = monoeg_g_list_prepend (list, D.5674);
  D.5679 = -i;
  D.5680 = (long int) D.5679;
  D.5681 = (void *) D.5680;
  list = monoeg_g_list_prepend (list, D.5681);
  i = i + 1;
  <D.5144>:
  if (i <= 100) goto <D.5143>; else goto <D.5145>;
  <D.5145>:
  list = monoeg_g_list_sort (list, intcompare);
  D.5685 = verify_sort (list, 201);
  if (D.5685 == 0) goto <D.5686>; else goto <D.5687>;
  <D.5686>:
  D.5678 = FAILED ("alternating list");
  return D.5678;
  <D.5687>:
  monoeg_g_list_free (list);
  list = 0B;
  mul = 1;
  i = 1;
  goto <D.5150>;
  <D.5149>:
  mul = -mul;
  j = 0;
  goto <D.5147>;
  <D.5146>:
  D.5688 = mul * j;
  D.5689 = (long int) D.5688;
  D.5690 = (void *) D.5689;
  list = monoeg_g_list_prepend (list, D.5690);
  j = j + 1;
  <D.5147>:
  if (j < i) goto <D.5146>; else goto <D.5148>;
  <D.5148>:
  i = i + 1;
  <D.5150>:
  if (i <= 100) goto <D.5149>; else goto <D.5151>;
  <D.5151>:
  list = monoeg_g_list_sort (list, intcompare);
  D.5691 = verify_sort (list, 5050);
  if (D.5691 == 0) goto <D.5692>; else goto <D.5693>;
  <D.5692>:
  D.5678 = FAILED ("wavering list");
  return D.5678;
  <D.5693>:
  monoeg_g_list_free (list);
  D.5678 = 0B;
  return D.5678;
}


intcompare (const void * p1, const void * p2)
{
  int D.5695;
  long int p1.10;
  int D.5697;
  long int p2.11;
  int D.5699;

  p1.10 = (long int) p1;
  D.5697 = (int) p1.10;
  p2.11 = (long int) p2;
  D.5699 = (int) p2.11;
  D.5695 = D.5697 - D.5699;
  return D.5695;
}


verify_sort (struct GList * list, int len)
{
  struct GList * D.5701;
  gboolean D.5704;
  void * D.5705;
  long int D.5706;
  struct GList * D.5712;
  _Bool D.5715;
  int prev;

  D.5701 = list->prev;
  if (D.5701 != 0B) goto <D.5702>; else goto <D.5703>;
  <D.5702>:
  D.5704 = 0;
  return D.5704;
  <D.5703>:
  D.5705 = list->data;
  D.5706 = (long int) D.5705;
  prev = (int) D.5706;
  len = len + -1;
  list = list->next;
  goto <D.5129>;
  <D.5128>:
  {
    int curr;

    D.5705 = list->data;
    D.5706 = (long int) D.5705;
    curr = (int) D.5706;
    if (prev > curr) goto <D.5707>; else goto <D.5708>;
    <D.5707>:
    D.5704 = 0;
    return D.5704;
    <D.5708>:
    prev = curr;
    D.5701 = list->prev;
    if (D.5701 == 0B) goto <D.5709>; else goto <D.5711>;
    <D.5711>:
    D.5701 = list->prev;
    D.5712 = D.5701->next;
    if (D.5712 != list) goto <D.5709>; else goto <D.5710>;
    <D.5709>:
    D.5704 = 0;
    return D.5704;
    <D.5710>:
    if (len == 0) goto <D.5713>; else goto <D.5714>;
    <D.5713>:
    D.5704 = 0;
    return D.5704;
    <D.5714>:
    len = len + -1;
  }
  list = list->next;
  <D.5129>:
  if (list != 0B) goto <D.5128>; else goto <D.5130>;
  <D.5130>:
  D.5715 = len == 0;
  D.5704 = (gboolean) D.5715;
  return D.5704;
}


test_list_find_custom ()
{
  gchar * D.5719;
  struct GList * list;
  struct GList * found;
  char * foo;
  char * bar;
  char * baz;

  list = 0B;
  foo = "foo";
  bar = "bar";
  baz = "baz";
  list = monoeg_g_list_prepend (list, baz);
  list = monoeg_g_list_prepend (list, bar);
  list = monoeg_g_list_prepend (list, foo);
  found = monoeg_g_list_find_custom (list, baz, find_custom);
  if (found == 0B) goto <D.5717>; else goto <D.5718>;
  <D.5717>:
  D.5719 = FAILED ("Find failed");
  return D.5719;
  <D.5718>:
  monoeg_g_list_free (list);
  D.5719 = 0B;
  return D.5719;
}


find_custom (const void * a, const void * b)
{
  gint D.5721;
  int D.5164;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.5164 = __builtin_strcmp (a, b);
  }
  D.5721 = D.5164;
  return D.5721;
}


list_tests_init ()
{
  struct Test * D.5723;

  D.5723 = &list_tests;
  return D.5723;
}