test_slist_nth ()
{
  void * D.5110;
  gchar * D.5113;
  char * foo;
  char * bar;
  char * baz;
  struct GSList * nth;
  struct GSList * list;

  foo = "foo";
  bar = "bar";
  baz = "baz";
  list = monoeg_g_slist_prepend (0B, baz);
  list = monoeg_g_slist_prepend (list, bar);
  list = monoeg_g_slist_prepend (list, foo);
  nth = monoeg_g_slist_nth (list, 0);
  D.5110 = nth->data;
  if (D.5110 != foo) goto <D.5111>; else goto <D.5112>;
  <D.5111>:
  D.5113 = FAILED ("nth failed. #0");
  return D.5113;
  <D.5112>:
  nth = monoeg_g_slist_nth (list, 1);
  D.5110 = nth->data;
  if (D.5110 != bar) goto <D.5114>; else goto <D.5115>;
  <D.5114>:
  D.5113 = FAILED ("nth failed. #1");
  return D.5113;
  <D.5115>:
  nth = monoeg_g_slist_nth (list, 2);
  D.5110 = nth->data;
  if (D.5110 != baz) goto <D.5116>; else goto <D.5117>;
  <D.5116>:
  D.5113 = FAILED ("nth failed. #2");
  return D.5113;
  <D.5117>:
  nth = monoeg_g_slist_nth (list, 3);
  if (nth != 0B) goto <D.5118>; else goto <D.5119>;
  <D.5118>:
  D.5110 = nth->data;
  D.5113 = FAILED ("nth failed. #3: %s", D.5110);
  return D.5113;
  <D.5119>:
  monoeg_g_slist_free (list);
  D.5113 = 0B;
  return D.5113;
}


test_slist_index ()
{
  gchar * D.5123;
  int i;
  char * foo;
  char * bar;
  char * baz;
  struct GSList * list;

  foo = "foo";
  bar = "bar";
  baz = "baz";
  list = monoeg_g_slist_prepend (0B, baz);
  list = monoeg_g_slist_prepend (list, bar);
  list = monoeg_g_slist_prepend (list, foo);
  i = monoeg_g_slist_index (list, foo);
  if (i != 0) goto <D.5121>; else goto <D.5122>;
  <D.5121>:
  D.5123 = FAILED ("index failed. #0: %d", i);
  return D.5123;
  <D.5122>:
  i = monoeg_g_slist_index (list, bar);
  if (i != 1) goto <D.5124>; else goto <D.5125>;
  <D.5124>:
  D.5123 = FAILED ("index failed. #1: %d", i);
  return D.5123;
  <D.5125>:
  i = monoeg_g_slist_index (list, baz);
  if (i != 2) goto <D.5126>; else goto <D.5127>;
  <D.5126>:
  D.5123 = FAILED ("index failed. #2: %d", i);
  return D.5123;
  <D.5127>:
  monoeg_g_slist_free (list);
  D.5123 = 0B;
  return D.5123;
}


test_slist_append ()
{
  unsigned int D.5129;
  gchar * D.5132;
  unsigned int D.5135;
  struct GSList * foo;
  struct GSList * list;

  list = monoeg_g_slist_append (0B, "first");
  D.5129 = monoeg_g_slist_length (list);
  if (D.5129 != 1) goto <D.5130>; else goto <D.5131>;
  <D.5130>:
  D.5132 = FAILED ("append(null,...) failed");
  return D.5132;
  <D.5131>:
  foo = monoeg_g_slist_append (list, "second");
  if (foo != list) goto <D.5133>; else goto <D.5134>;
  <D.5133>:
  D.5132 = FAILED ("changed list head on non-empty");
  return D.5132;
  <D.5134>:
  D.5135 = monoeg_g_slist_length (list);
  if (D.5135 != 2) goto <D.5136>; else goto <D.5137>;
  <D.5136>:
  D.5132 = FAILED ("Append failed");
  return D.5132;
  <D.5137>:
  monoeg_g_slist_free (list);
  D.5132 = 0B;
  return D.5132;
}


test_slist_concat ()
{
  unsigned int D.5139;
  gchar * D.5142;
  struct GSList * foo;
  struct GSList * bar;
  struct GSList * list;

  foo = monoeg_g_slist_prepend (0B, "foo");
  bar = monoeg_g_slist_prepend (0B, "bar");
  list = monoeg_g_slist_concat (foo, bar);
  D.5139 = monoeg_g_slist_length (list);
  if (D.5139 != 2) goto <D.5140>; else goto <D.5141>;
  <D.5140>:
  D.5142 = FAILED ("Concat failed.");
  return D.5142;
  <D.5141>:
  monoeg_g_slist_free (list);
  D.5142 = 0B;
  return D.5142;
}


test_slist_find ()
{
  void * D.5144;
  gchar * D.5147;
  struct GSList * list;
  struct GSList * found;
  char * data;

  list = monoeg_g_slist_prepend (0B, "three");
  list = monoeg_g_slist_prepend (list, "two");
  list = monoeg_g_slist_prepend (list, "one");
  data = "four";
  list = monoeg_g_slist_append (list, data);
  found = monoeg_g_slist_find (list, data);
  D.5144 = found->data;
  if (D.5144 != data) goto <D.5145>; else goto <D.5146>;
  <D.5145>:
  D.5147 = FAILED ("Find failed");
  return D.5147;
  <D.5146>:
  monoeg_g_slist_free (list);
  D.5147 = 0B;
  return D.5147;
}


test_slist_find_custom ()
{
  gchar * D.5151;
  struct GSList * list;
  struct GSList * found;
  char * foo;
  char * bar;
  char * baz;

  list = 0B;
  foo = "foo";
  bar = "bar";
  baz = "baz";
  list = monoeg_g_slist_prepend (list, baz);
  list = monoeg_g_slist_prepend (list, bar);
  list = monoeg_g_slist_prepend (list, foo);
  found = monoeg_g_slist_find_custom (list, baz, find_custom);
  if (found == 0B) goto <D.5149>; else goto <D.5150>;
  <D.5149>:
  D.5151 = FAILED ("Find failed");
  return D.5151;
  <D.5150>:
  monoeg_g_slist_free (list);
  D.5151 = 0B;
  return D.5151;
}


find_custom (const void * a, const void * b)
{
  gint D.5153;
  int D.4986;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.4986 = __builtin_strcmp (a, b);
  }
  D.5153 = D.4986;
  return D.5153;
}


test_slist_remove ()
{
  unsigned int D.5155;
  gchar * D.5158;
  int D.5006;
  int iftmp.0;
  int D.5002;
  char[4] * D.5162;
  unsigned char D.5163;
  int D.5164;
  unsigned char D.5165;
  int D.5166;
  _Bool D.5167;
  _Bool D.5168;
  _Bool D.5169;
  const unsigned char * D.5172;
  unsigned char D.5173;
  int D.5174;
  const unsigned char * D.5175;
  unsigned char D.5176;
  int D.5177;
  _Bool D.5178;
  _Bool D.5179;
  const unsigned char * D.5182;
  unsigned char D.5183;
  int D.5184;
  const unsigned char * D.5185;
  unsigned char D.5186;
  int D.5187;
  _Bool D.5188;
  _Bool D.5189;
  const unsigned char * D.5192;
  unsigned char D.5193;
  int D.5194;
  const unsigned char * D.5195;
  unsigned char D.5196;
  int D.5197;
  void * D.5199;
  struct GSList * list;
  char * one;

  list = monoeg_g_slist_prepend (0B, "three");
  one = "one";
  list = monoeg_g_slist_prepend (list, "two");
  list = monoeg_g_slist_prepend (list, one);
  list = monoeg_g_slist_remove (list, one);
  D.5155 = monoeg_g_slist_length (list);
  if (D.5155 != 2) goto <D.5156>; else goto <D.5157>;
  <D.5156>:
  D.5158 = FAILED ("Remove failed");
  return D.5158;
  <D.5157>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = list->data;
      D.5162 = "two";
      D.5163 = MEM[(const unsigned char *)D.5162];
      D.5164 = (int) D.5163;
      D.5165 = *__s2;
      D.5166 = (int) D.5165;
      __result = D.5164 - D.5166;
      {
        D.5167 = __s1_len != 0;
        D.5168 = __result == 0;
        D.5169 = D.5167 & D.5168;
        if (D.5169 != 0) goto <D.5170>; else goto <D.5171>;
        <D.5170>:
        D.5172 = &MEM[(void *)"two" + 1B];
        D.5173 = *D.5172;
        D.5174 = (int) D.5173;
        D.5175 = __s2 + 1;
        D.5176 = *D.5175;
        D.5177 = (int) D.5176;
        __result = D.5174 - D.5177;
        D.5178 = __s1_len > 1;
        D.5168 = __result == 0;
        D.5179 = D.5178 & D.5168;
        if (D.5179 != 0) goto <D.5180>; else goto <D.5181>;
        <D.5180>:
        D.5182 = &MEM[(void *)"two" + 2B];
        D.5183 = *D.5182;
        D.5184 = (int) D.5183;
        D.5185 = __s2 + 2;
        D.5186 = *D.5185;
        D.5187 = (int) D.5186;
        __result = D.5184 - D.5187;
        D.5188 = __s1_len > 2;
        D.5168 = __result == 0;
        D.5189 = D.5188 & D.5168;
        if (D.5189 != 0) goto <D.5190>; else goto <D.5191>;
        <D.5190>:
        D.5192 = &MEM[(void *)"two" + 3B];
        D.5193 = *D.5192;
        D.5194 = (int) D.5193;
        D.5195 = __s2 + 3;
        D.5196 = *D.5195;
        D.5197 = (int) D.5196;
        __result = D.5194 - D.5197;
        <D.5191>:
        <D.5181>:
        <D.5171>:
      }
      D.5002 = __result;
    }
    iftmp.0 = D.5002;
    goto <D.5198>;
    <D.5161>:
    D.5199 = list->data;
    iftmp.0 = __builtin_strcmp ("two", D.5199);
    <D.5198>:
    D.5006 = iftmp.0;
  }
  if (D.5006 != 0) goto <D.5200>; else goto <D.5201>;
  <D.5200>:
  D.5158 = FAILED ("Remove failed");
  return D.5158;
  <D.5201>:
  monoeg_g_slist_free (list);
  D.5158 = 0B;
  return D.5158;
}


test_slist_remove_link ()
{
  unsigned int D.5203;
  gchar * D.5206;
  struct GSList * D.5207;
  struct GSList * foo;
  struct GSList * bar;
  struct GSList * baz;
  struct GSList * list;

  foo = monoeg_g_slist_prepend (0B, "a");
  bar = monoeg_g_slist_prepend (0B, "b");
  baz = monoeg_g_slist_prepend (0B, "c");
  list = foo;
  foo = monoeg_g_slist_concat (foo, bar);
  foo = monoeg_g_slist_concat (foo, baz);
  list = monoeg_g_slist_remove_link (list, bar);
  D.5203 = monoeg_g_slist_length (list);
  if (D.5203 != 2) goto <D.5204>; else goto <D.5205>;
  <D.5204>:
  D.5206 = FAILED ("remove_link failed #1");
  return D.5206;
  <D.5205>:
  D.5207 = bar->next;
  if (D.5207 != 0B) goto <D.5208>; else goto <D.5209>;
  <D.5208>:
  D.5206 = FAILED ("remove_link failed #2");
  return D.5206;
  <D.5209>:
  monoeg_g_slist_free (list);
  monoeg_g_slist_free (bar);
  D.5206 = 0B;
  return D.5206;
}


test_slist_insert_sorted ()
{
  int D.5030;
  int iftmp.1;
  int D.5026;
  struct GSList * D.5214;
  char[3] * D.5215;
  unsigned char D.5216;
  int D.5217;
  unsigned char D.5218;
  int D.5219;
  _Bool D.5220;
  _Bool D.5221;
  _Bool D.5222;
  const unsigned char * D.5225;
  unsigned char D.5226;
  int D.5227;
  const unsigned char * D.5228;
  unsigned char D.5229;
  int D.5230;
  _Bool D.5231;
  _Bool D.5232;
  const unsigned char * D.5235;
  unsigned char D.5236;
  int D.5237;
  const unsigned char * D.5238;
  unsigned char D.5239;
  int D.5240;
  _Bool D.5241;
  _Bool D.5242;
  const unsigned char * D.5245;
  unsigned char D.5246;
  int D.5247;
  const unsigned char * D.5248;
  unsigned char D.5249;
  int D.5250;
  void * D.5252;
  gchar * D.5255;
  int D.5039;
  int iftmp.2;
  int D.5035;
  char[1] * D.5259;
  unsigned char D.5260;
  int D.5261;
  unsigned char D.5262;
  int D.5263;
  _Bool D.5264;
  _Bool D.5265;
  _Bool D.5266;
  const unsigned char * D.5269;
  unsigned char D.5270;
  int D.5271;
  const unsigned char * D.5272;
  unsigned char D.5273;
  int D.5274;
  _Bool D.5275;
  _Bool D.5276;
  const unsigned char * D.5279;
  unsigned char D.5280;
  int D.5281;
  const unsigned char * D.5282;
  unsigned char D.5283;
  int D.5284;
  _Bool D.5285;
  _Bool D.5286;
  const unsigned char * D.5289;
  unsigned char D.5290;
  int D.5291;
  const unsigned char * D.5292;
  unsigned char D.5293;
  int D.5294;
  void * D.5296;
  unsigned char D.5297;
  int D.5298;
  int D.5048;
  int iftmp.3;
  int D.5044;
  struct GSList * D.5304;
  char[5] * D.5305;
  unsigned char D.5306;
  int D.5307;
  unsigned char D.5308;
  int D.5309;
  _Bool D.5310;
  _Bool D.5311;
  _Bool D.5312;
  const unsigned char * D.5315;
  unsigned char D.5316;
  int D.5317;
  const unsigned char * D.5318;
  unsigned char D.5319;
  int D.5320;
  _Bool D.5321;
  _Bool D.5322;
  const unsigned char * D.5325;
  unsigned char D.5326;
  int D.5327;
  const unsigned char * D.5328;
  unsigned char D.5329;
  int D.5330;
  _Bool D.5331;
  _Bool D.5332;
  const unsigned char * D.5335;
  unsigned char D.5336;
  int D.5337;
  const unsigned char * D.5338;
  unsigned char D.5339;
  int D.5340;
  struct GSList * D.5342;
  void * D.5343;
  struct GSList * list;

  list = monoeg_g_slist_prepend (0B, "a");
  list = monoeg_g_slist_append (list, "aaa");
  list = monoeg_g_slist_insert_sorted (list, "aa", compare);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.5214 = list->next;
      __s2 = D.5214->data;
      D.5215 = "aa";
      D.5216 = MEM[(const unsigned char *)D.5215];
      D.5217 = (int) D.5216;
      D.5218 = *__s2;
      D.5219 = (int) D.5218;
      __result = D.5217 - D.5219;
      {
        D.5220 = __s1_len != 0;
        D.5221 = __result == 0;
        D.5222 = D.5220 & D.5221;
        if (D.5222 != 0) goto <D.5223>; else goto <D.5224>;
        <D.5223>:
        D.5225 = &MEM[(void *)"aa" + 1B];
        D.5226 = *D.5225;
        D.5227 = (int) D.5226;
        D.5228 = __s2 + 1;
        D.5229 = *D.5228;
        D.5230 = (int) D.5229;
        __result = D.5227 - D.5230;
        D.5231 = __s1_len > 1;
        D.5221 = __result == 0;
        D.5232 = D.5231 & D.5221;
        if (D.5232 != 0) goto <D.5233>; else goto <D.5234>;
        <D.5233>:
        D.5235 = &MEM[(void *)"aa" + 2B];
        D.5236 = *D.5235;
        D.5237 = (int) D.5236;
        D.5238 = __s2 + 2;
        D.5239 = *D.5238;
        D.5240 = (int) D.5239;
        __result = D.5237 - D.5240;
        D.5241 = __s1_len > 2;
        D.5221 = __result == 0;
        D.5242 = D.5241 & D.5221;
        if (D.5242 != 0) goto <D.5243>; else goto <D.5244>;
        <D.5243>:
        D.5245 = &MEM[(void *)"aa" + 3B];
        D.5246 = *D.5245;
        D.5247 = (int) D.5246;
        D.5248 = __s2 + 3;
        D.5249 = *D.5248;
        D.5250 = (int) D.5249;
        __result = D.5247 - D.5250;
        <D.5244>:
        <D.5234>:
        <D.5224>:
      }
      D.5026 = __result;
    }
    iftmp.1 = D.5026;
    goto <D.5251>;
    <D.5213>:
    D.5214 = list->next;
    D.5252 = D.5214->data;
    iftmp.1 = __builtin_strcmp ("aa", D.5252);
    <D.5251>:
    D.5030 = iftmp.1;
  }
  if (D.5030 != 0) goto <D.5253>; else goto <D.5254>;
  <D.5253>:
  D.5255 = FAILED ("insert_sorted failed #1");
  return D.5255;
  <D.5254>:
  list = monoeg_g_slist_insert_sorted (list, "", compare);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = list->data;
      D.5259 = "";
      D.5260 = MEM[(const unsigned char *)D.5259];
      D.5261 = (int) D.5260;
      D.5262 = *__s2;
      D.5263 = (int) D.5262;
      __result = D.5261 - D.5263;
      {
        D.5264 = __s1_len != 0;
        D.5265 = __result == 0;
        D.5266 = D.5264 & D.5265;
        if (D.5266 != 0) goto <D.5267>; else goto <D.5268>;
        <D.5267>:
        D.5269 = &MEM[(void *)"" + 1B];
        D.5270 = *D.5269;
        D.5271 = (int) D.5270;
        D.5272 = __s2 + 1;
        D.5273 = *D.5272;
        D.5274 = (int) D.5273;
        __result = D.5271 - D.5274;
        D.5275 = __s1_len > 1;
        D.5265 = __result == 0;
        D.5276 = D.5275 & D.5265;
        if (D.5276 != 0) goto <D.5277>; else goto <D.5278>;
        <D.5277>:
        D.5279 = &MEM[(void *)"" + 2B];
        D.5280 = *D.5279;
        D.5281 = (int) D.5280;
        D.5282 = __s2 + 2;
        D.5283 = *D.5282;
        D.5284 = (int) D.5283;
        __result = D.5281 - D.5284;
        D.5285 = __s1_len > 2;
        D.5265 = __result == 0;
        D.5286 = D.5285 & D.5265;
        if (D.5286 != 0) goto <D.5287>; else goto <D.5288>;
        <D.5287>:
        D.5289 = &MEM[(void *)"" + 3B];
        D.5290 = *D.5289;
        D.5291 = (int) D.5290;
        D.5292 = __s2 + 3;
        D.5293 = *D.5292;
        D.5294 = (int) D.5293;
        __result = D.5291 - D.5294;
        <D.5288>:
        <D.5278>:
        <D.5268>:
      }
      D.5035 = __result;
    }
    iftmp.2 = D.5035;
    goto <D.5295>;
    <D.5258>:
    D.5296 = list->data;
    D.5297 = MEM[(const unsigned char * {ref-all})D.5296];
    D.5298 = (int) D.5297;
    iftmp.2 = -D.5298;
    <D.5295>:
    D.5039 = iftmp.2;
  }
  if (D.5039 != 0) goto <D.5299>; else goto <D.5300>;
  <D.5299>:
  D.5255 = FAILED ("insert_sorted failed #2");
  return D.5255;
  <D.5300>:
  list = monoeg_g_slist_insert_sorted (list, "aaaa", compare);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.5304 = monoeg_g_slist_last (list);
      __s2 = D.5304->data;
      D.5305 = "aaaa";
      D.5306 = MEM[(const unsigned char *)D.5305];
      D.5307 = (int) D.5306;
      D.5308 = *__s2;
      D.5309 = (int) D.5308;
      __result = D.5307 - D.5309;
      {
        D.5310 = __s1_len != 0;
        D.5311 = __result == 0;
        D.5312 = D.5310 & D.5311;
        if (D.5312 != 0) goto <D.5313>; else goto <D.5314>;
        <D.5313>:
        D.5315 = &MEM[(void *)"aaaa" + 1B];
        D.5316 = *D.5315;
        D.5317 = (int) D.5316;
        D.5318 = __s2 + 1;
        D.5319 = *D.5318;
        D.5320 = (int) D.5319;
        __result = D.5317 - D.5320;
        D.5321 = __s1_len > 1;
        D.5311 = __result == 0;
        D.5322 = D.5321 & D.5311;
        if (D.5322 != 0) goto <D.5323>; else goto <D.5324>;
        <D.5323>:
        D.5325 = &MEM[(void *)"aaaa" + 2B];
        D.5326 = *D.5325;
        D.5327 = (int) D.5326;
        D.5328 = __s2 + 2;
        D.5329 = *D.5328;
        D.5330 = (int) D.5329;
        __result = D.5327 - D.5330;
        D.5331 = __s1_len > 2;
        D.5311 = __result == 0;
        D.5332 = D.5331 & D.5311;
        if (D.5332 != 0) goto <D.5333>; else goto <D.5334>;
        <D.5333>:
        D.5335 = &MEM[(void *)"aaaa" + 3B];
        D.5336 = *D.5335;
        D.5337 = (int) D.5336;
        D.5338 = __s2 + 3;
        D.5339 = *D.5338;
        D.5340 = (int) D.5339;
        __result = D.5337 - D.5340;
        <D.5334>:
        <D.5324>:
        <D.5314>:
      }
      D.5044 = __result;
    }
    iftmp.3 = D.5044;
    goto <D.5341>;
    <D.5303>:
    D.5342 = monoeg_g_slist_last (list);
    D.5343 = D.5342->data;
    iftmp.3 = __builtin_strcmp ("aaaa", D.5343);
    <D.5341>:
    D.5048 = iftmp.3;
  }
  if (D.5048 != 0) goto <D.5344>; else goto <D.5345>;
  <D.5344>:
  D.5255 = FAILED ("insert_sorted failed #3");
  return D.5255;
  <D.5345>:
  monoeg_g_slist_free (list);
  D.5255 = 0B;
  return D.5255;
}


compare (const void * a, const void * b)
{
  long unsigned int D.5347;
  long unsigned int D.5348;
  gint D.5351;
  char * foo;
  char * bar;

  foo = a;
  bar = b;
  D.5347 = strlen (foo);
  D.5348 = strlen (bar);
  if (D.5347 < D.5348) goto <D.5349>; else goto <D.5350>;
  <D.5349>:
  D.5351 = -1;
  return D.5351;
  <D.5350>:
  D.5351 = 1;
  return D.5351;
}


test_slist_insert_before ()
{
  int D.5062;
  int iftmp.4;
  int D.5061;
  char[4] * D.5356;
  unsigned char D.5357;
  int D.5358;
  unsigned char D.5359;
  int D.5360;
  _Bool D.5361;
  _Bool D.5362;
  _Bool D.5363;
  const unsigned char * D.5366;
  unsigned char D.5367;
  int D.5368;
  const unsigned char * D.5369;
  unsigned char D.5370;
  int D.5371;
  _Bool D.5372;
  _Bool D.5373;
  const unsigned char * D.5376;
  unsigned char D.5377;
  int D.5378;
  const unsigned char * D.5379;
  unsigned char D.5380;
  int D.5381;
  _Bool D.5382;
  _Bool D.5383;
  const unsigned char * D.5386;
  unsigned char D.5387;
  int D.5388;
  const unsigned char * D.5389;
  unsigned char D.5390;
  int D.5391;
  void * D.5393;
  gchar * D.5396;
  int D.5071;
  int iftmp.5;
  int D.5070;
  struct GSList * D.5402;
  char[4] * D.5403;
  unsigned char D.5404;
  int D.5405;
  unsigned char D.5406;
  int D.5407;
  _Bool D.5408;
  _Bool D.5409;
  _Bool D.5410;
  const unsigned char * D.5413;
  unsigned char D.5414;
  int D.5415;
  const unsigned char * D.5416;
  unsigned char D.5417;
  int D.5418;
  _Bool D.5419;
  _Bool D.5420;
  const unsigned char * D.5423;
  unsigned char D.5424;
  int D.5425;
  const unsigned char * D.5426;
  unsigned char D.5427;
  int D.5428;
  _Bool D.5429;
  _Bool D.5430;
  const unsigned char * D.5433;
  unsigned char D.5434;
  int D.5435;
  const unsigned char * D.5436;
  unsigned char D.5437;
  int D.5438;
  void * D.5440;
  struct GSList * foo;
  struct GSList * bar;
  struct GSList * baz;

  foo = monoeg_g_slist_prepend (0B, "foo");
  foo = monoeg_g_slist_insert_before (foo, 0B, "bar");
  bar = monoeg_g_slist_last (foo);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = bar->data;
      D.5356 = "bar";
      D.5357 = MEM[(const unsigned char *)D.5356];
      D.5358 = (int) D.5357;
      D.5359 = *__s2;
      D.5360 = (int) D.5359;
      __result = D.5358 - D.5360;
      {
        D.5361 = __s2_len != 0;
        D.5362 = __result == 0;
        D.5363 = D.5361 & D.5362;
        if (D.5363 != 0) goto <D.5364>; else goto <D.5365>;
        <D.5364>:
        D.5366 = &MEM[(void *)"bar" + 1B];
        D.5367 = *D.5366;
        D.5368 = (int) D.5367;
        D.5369 = __s2 + 1;
        D.5370 = *D.5369;
        D.5371 = (int) D.5370;
        __result = D.5368 - D.5371;
        D.5372 = __s2_len > 1;
        D.5362 = __result == 0;
        D.5373 = D.5372 & D.5362;
        if (D.5373 != 0) goto <D.5374>; else goto <D.5375>;
        <D.5374>:
        D.5376 = &MEM[(void *)"bar" + 2B];
        D.5377 = *D.5376;
        D.5378 = (int) D.5377;
        D.5379 = __s2 + 2;
        D.5380 = *D.5379;
        D.5381 = (int) D.5380;
        __result = D.5378 - D.5381;
        D.5382 = __s2_len > 2;
        D.5362 = __result == 0;
        D.5383 = D.5382 & D.5362;
        if (D.5383 != 0) goto <D.5384>; else goto <D.5385>;
        <D.5384>:
        D.5386 = &MEM[(void *)"bar" + 3B];
        D.5387 = *D.5386;
        D.5388 = (int) D.5387;
        D.5389 = __s2 + 3;
        D.5390 = *D.5389;
        D.5391 = (int) D.5390;
        __result = D.5388 - D.5391;
        <D.5385>:
        <D.5375>:
        <D.5365>:
      }
      D.5061 = __result;
    }
    iftmp.4 = -D.5061;
    goto <D.5392>;
    <D.5355>:
    D.5393 = bar->data;
    iftmp.4 = __builtin_strcmp (D.5393, "bar");
    <D.5392>:
    D.5062 = iftmp.4;
  }
  if (D.5062 != 0) goto <D.5394>; else goto <D.5395>;
  <D.5394>:
  D.5396 = FAILED ("1");
  return D.5396;
  <D.5395>:
  baz = monoeg_g_slist_insert_before (foo, bar, "baz");
  if (foo != baz) goto <D.5397>; else goto <D.5398>;
  <D.5397>:
  D.5396 = FAILED ("2");
  return D.5396;
  <D.5398>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.5402 = foo->next;
      __s2 = D.5402->data;
      D.5403 = "baz";
      D.5404 = MEM[(const unsigned char *)D.5403];
      D.5405 = (int) D.5404;
      D.5406 = *__s2;
      D.5407 = (int) D.5406;
      __result = D.5405 - D.5407;
      {
        D.5408 = __s2_len != 0;
        D.5409 = __result == 0;
        D.5410 = D.5408 & D.5409;
        if (D.5410 != 0) goto <D.5411>; else goto <D.5412>;
        <D.5411>:
        D.5413 = &MEM[(void *)"baz" + 1B];
        D.5414 = *D.5413;
        D.5415 = (int) D.5414;
        D.5416 = __s2 + 1;
        D.5417 = *D.5416;
        D.5418 = (int) D.5417;
        __result = D.5415 - D.5418;
        D.5419 = __s2_len > 1;
        D.5409 = __result == 0;
        D.5420 = D.5419 & D.5409;
        if (D.5420 != 0) goto <D.5421>; else goto <D.5422>;
        <D.5421>:
        D.5423 = &MEM[(void *)"baz" + 2B];
        D.5424 = *D.5423;
        D.5425 = (int) D.5424;
        D.5426 = __s2 + 2;
        D.5427 = *D.5426;
        D.5428 = (int) D.5427;
        __result = D.5425 - D.5428;
        D.5429 = __s2_len > 2;
        D.5409 = __result == 0;
        D.5430 = D.5429 & D.5409;
        if (D.5430 != 0) goto <D.5431>; else goto <D.5432>;
        <D.5431>:
        D.5433 = &MEM[(void *)"baz" + 3B];
        D.5434 = *D.5433;
        D.5435 = (int) D.5434;
        D.5436 = __s2 + 3;
        D.5437 = *D.5436;
        D.5438 = (int) D.5437;
        __result = D.5435 - D.5438;
        <D.5432>:
        <D.5422>:
        <D.5412>:
      }
      D.5070 = __result;
    }
    iftmp.5 = -D.5070;
    goto <D.5439>;
    <D.5401>:
    D.5402 = foo->next;
    D.5440 = D.5402->data;
    iftmp.5 = __builtin_strcmp (D.5440, "baz");
    <D.5439>:
    D.5071 = iftmp.5;
  }
  if (D.5071 != 0) goto <D.5441>; else goto <D.5442>;
  <D.5441>:
  D.5402 = foo->next;
  D.5440 = D.5402->data;
  D.5396 = FAILED ("3: %s", D.5440);
  return D.5396;
  <D.5442>:
  monoeg_g_slist_free (foo);
  D.5396 = 0B;
  return D.5396;
}


test_slist_sort ()
{
  long int D.5444;
  void * D.5445;
  int D.5446;
  gchar * D.5449;
  int D.5450;
  long int D.5451;
  void * D.5452;
  int D.5453;
  int D.5456;
  int D.5459;
  long int D.5460;
  void * D.5461;
  int D.5462;
  int i;
  int j;
  int mul;
  struct GSList * list;

  list = 0B;
  i = 0;
  goto <D.5092>;
  <D.5091>:
  D.5444 = (long int) i;
  D.5445 = (void *) D.5444;
  list = monoeg_g_slist_prepend (list, D.5445);
  i = i + 1;
  <D.5092>:
  if (i <= 99) goto <D.5091>; else goto <D.5093>;
  <D.5093>:
  list = monoeg_g_slist_sort (list, intcompare);
  D.5446 = verify_sort (list, 100);
  if (D.5446 == 0) goto <D.5447>; else goto <D.5448>;
  <D.5447>:
  D.5449 = FAILED ("decreasing list");
  return D.5449;
  <D.5448>:
  monoeg_g_slist_free (list);
  list = 0B;
  i = 0;
  goto <D.5095>;
  <D.5094>:
  D.5450 = -i;
  D.5451 = (long int) D.5450;
  D.5452 = (void *) D.5451;
  list = monoeg_g_slist_prepend (list, D.5452);
  i = i + 1;
  <D.5095>:
  if (i <= 99) goto <D.5094>; else goto <D.5096>;
  <D.5096>:
  list = monoeg_g_slist_sort (list, intcompare);
  D.5453 = verify_sort (list, 100);
  if (D.5453 == 0) goto <D.5454>; else goto <D.5455>;
  <D.5454>:
  D.5449 = FAILED ("increasing list");
  return D.5449;
  <D.5455>:
  monoeg_g_slist_free (list);
  list = monoeg_g_slist_prepend (0B, 0B);
  i = 1;
  goto <D.5098>;
  <D.5097>:
  D.5450 = -i;
  D.5451 = (long int) D.5450;
  D.5452 = (void *) D.5451;
  list = monoeg_g_slist_prepend (list, D.5452);
  D.5444 = (long int) i;
  D.5445 = (void *) D.5444;
  list = monoeg_g_slist_prepend (list, D.5445);
  i = i + 1;
  <D.5098>:
  if (i <= 99) goto <D.5097>; else goto <D.5099>;
  <D.5099>:
  list = monoeg_g_slist_sort (list, intcompare);
  D.5456 = verify_sort (list, 199);
  if (D.5456 == 0) goto <D.5457>; else goto <D.5458>;
  <D.5457>:
  D.5449 = FAILED ("alternating list");
  return D.5449;
  <D.5458>:
  monoeg_g_slist_free (list);
  list = 0B;
  mul = 1;
  i = 1;
  goto <D.5104>;
  <D.5103>:
  mul = -mul;
  j = 0;
  goto <D.5101>;
  <D.5100>:
  D.5459 = mul * j;
  D.5460 = (long int) D.5459;
  D.5461 = (void *) D.5460;
  list = monoeg_g_slist_prepend (list, D.5461);
  j = j + 1;
  <D.5101>:
  if (j < i) goto <D.5100>; else goto <D.5102>;
  <D.5102>:
  i = i + 1;
  <D.5104>:
  if (i <= 99) goto <D.5103>; else goto <D.5105>;
  <D.5105>:
  list = monoeg_g_slist_sort (list, intcompare);
  D.5462 = verify_sort (list, 4950);
  if (D.5462 == 0) goto <D.5463>; else goto <D.5464>;
  <D.5463>:
  D.5449 = FAILED ("wavering list");
  return D.5449;
  <D.5464>:
  monoeg_g_slist_free (list);
  D.5449 = 0B;
  return D.5449;
}


intcompare (const void * p1, const void * p2)
{
  int D.5466;
  long int p1.6;
  int D.5468;
  long int p2.7;
  int D.5470;

  p1.6 = (long int) p1;
  D.5468 = (int) p1.6;
  p2.7 = (long int) p2;
  D.5470 = (int) p2.7;
  D.5466 = D.5468 - D.5470;
  return D.5466;
}


verify_sort (struct GSList * list, int len)
{
  void * D.5472;
  long int D.5473;
  gboolean D.5476;
  _Bool D.5479;
  int prev;

  D.5472 = list->data;
  D.5473 = (long int) D.5472;
  prev = (int) D.5473;
  len = len + -1;
  list = list->next;
  goto <D.5083>;
  <D.5082>:
  {
    int curr;

    D.5472 = list->data;
    D.5473 = (long int) D.5472;
    curr = (int) D.5473;
    if (prev > curr) goto <D.5474>; else goto <D.5475>;
    <D.5474>:
    D.5476 = 0;
    return D.5476;
    <D.5475>:
    prev = curr;
    if (len == 0) goto <D.5477>; else goto <D.5478>;
    <D.5477>:
    D.5476 = 0;
    return D.5476;
    <D.5478>:
    len = len + -1;
  }
  list = list->next;
  <D.5083>:
  if (list != 0B) goto <D.5082>; else goto <D.5084>;
  <D.5084>:
  D.5479 = len == 0;
  D.5476 = (gboolean) D.5479;
  return D.5476;
}


slist_tests_init ()
{
  struct Test * D.5481;

  D.5481 = &slist_tests;
  return D.5481;
}