monoeg_g_slist_alloc ()
{
  struct GSList * D.5240;

  D.5240 = monoeg_malloc0 (16);
  return D.5240;
}


monoeg_g_slist_free_1 (struct GSList * list)
{
  monoeg_g_free (list);
}


monoeg_g_slist_append (struct GSList * list, void * data)
{
  struct GSList * D.5242;
  struct GSList * D.5243;

  D.5243 = monoeg_g_slist_prepend (0B, data);
  D.5242 = monoeg_g_slist_concat (list, D.5243);
  return D.5242;
}


monoeg_g_slist_prepend (struct GSList * list, void * data)
{
  struct GSList * D.5245;
  struct GSList * head;

  head = monoeg_g_slist_alloc ();
  head->data = data;
  head->next = list;
  D.5245 = head;
  return D.5245;
}


monoeg_g_slist_insert_before (struct GSList * list, struct GSList * sibling, void * data)
{
  struct GSList * D.5249;
  struct GSList * prev;

  prev = find_prev_link (list, sibling);
  if (prev == 0B) goto <D.5247>; else goto <D.5248>;
  <D.5247>:
  D.5249 = monoeg_g_slist_prepend (list, data);
  return D.5249;
  <D.5248>:
  insert_after (prev, data);
  D.5249 = list;
  return D.5249;
}


find_prev_link (struct GSList * list, struct GSList * link)
{
  struct GSList * D.5252;
  struct GSList * prev;

  prev = 0B;
  goto <D.5057>;
  <D.5056>:
  if (list == link) goto <D.5055>; else goto <D.5251>;
  <D.5251>:
  prev = list;
  list = list->next;
  <D.5057>:
  if (list != 0B) goto <D.5056>; else goto <D.5055>;
  <D.5055>:
  D.5252 = prev;
  return D.5252;
}


insert_after (struct GSList * list, void * data)
{
  struct GSList * D.5254;
  struct GSList * D.5255;
  struct GSList * D.5256;

  D.5254 = list->next;
  D.5255 = monoeg_g_slist_prepend (D.5254, data);
  list->next = D.5255;
  D.5256 = list->next;
  return D.5256;
}


monoeg_g_slist_free (struct GSList * list)
{
  goto <D.5069>;
  <D.5068>:
  {
    struct GSList * next;

    next = list->next;
    monoeg_g_slist_free_1 (list);
    list = next;
  }
  <D.5069>:
  if (list != 0B) goto <D.5068>; else goto <D.5070>;
  <D.5070>:
}


monoeg_g_slist_copy (struct GSList * list)
{
  struct GSList * D.5260;
  void * D.5261;
  struct GSList * copy;
  struct GSList * tmp;

  if (list == 0B) goto <D.5258>; else goto <D.5259>;
  <D.5258>:
  D.5260 = 0B;
  return D.5260;
  <D.5259>:
  D.5261 = list->data;
  copy = monoeg_g_slist_prepend (0B, D.5261);
  tmp = copy;
  list = list->next;
  goto <D.5077>;
  <D.5076>:
  D.5261 = list->data;
  tmp = insert_after (tmp, D.5261);
  list = list->next;
  <D.5077>:
  if (list != 0B) goto <D.5076>; else goto <D.5078>;
  <D.5078>:
  D.5260 = copy;
  return D.5260;
}


monoeg_g_slist_concat (struct GSList * list1, struct GSList * list2)
{
  struct GSList * D.5265;
  struct GSList * D.5266;

  if (list1 == 0B) goto <D.5263>; else goto <D.5264>;
  <D.5263>:
  D.5265 = list2;
  return D.5265;
  <D.5264>:
  D.5266 = monoeg_g_slist_last (list1);
  D.5266->next = list2;
  D.5265 = list1;
  return D.5265;
}


monoeg_g_slist_foreach (struct GSList * list, void (*GFunc) (void *, void *) func, void * user_data)
{
  void * D.5268;

  goto <D.5089>;
  <D.5088>:
  D.5268 = list->data;
  func (D.5268, user_data);
  list = list->next;
  <D.5089>:
  if (list != 0B) goto <D.5088>; else goto <D.5090>;
  <D.5090>:
}


monoeg_g_slist_last (struct GSList * list)
{
  struct GSList * D.5271;
  struct GSList * D.5272;

  if (list == 0B) goto <D.5269>; else goto <D.5270>;
  <D.5269>:
  D.5271 = 0B;
  return D.5271;
  <D.5270>:
  goto <D.5095>;
  <D.5094>:
  list = list->next;
  <D.5095>:
  D.5272 = list->next;
  if (D.5272 != 0B) goto <D.5094>; else goto <D.5096>;
  <D.5096>:
  D.5271 = list;
  return D.5271;
}


monoeg_g_slist_find (struct GSList * list, const void * data)
{
  void * D.5274;
  struct GSList * D.5276;

  goto <D.5103>;
  <D.5102>:
  D.5274 = list->data;
  if (D.5274 == data) goto <D.5101>; else goto <D.5275>;
  <D.5275>:
  list = list->next;
  <D.5103>:
  if (list != 0B) goto <D.5102>; else goto <D.5101>;
  <D.5101>:
  D.5276 = list;
  return D.5276;
}


monoeg_g_slist_find_custom (struct GSList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.5280;
  void * D.5281;
  int D.5282;

  if (func == 0B) goto <D.5278>; else goto <D.5279>;
  <D.5278>:
  D.5280 = 0B;
  return D.5280;
  <D.5279>:
  goto <D.5110>;
  <D.5109>:
  D.5281 = list->data;
  D.5282 = func (D.5281, data);
  if (D.5282 == 0) goto <D.5283>; else goto <D.5284>;
  <D.5283>:
  D.5280 = list;
  return D.5280;
  <D.5284>:
  list = list->next;
  <D.5110>:
  if (list != 0B) goto <D.5109>; else goto <D.5111>;
  <D.5111>:
  D.5280 = 0B;
  return D.5280;
}


monoeg_g_slist_length (struct GSList * list)
{
  guint D.5286;
  guint length;

  length = 0;
  goto <D.5117>;
  <D.5116>:
  length = length + 1;
  list = list->next;
  <D.5117>:
  if (list != 0B) goto <D.5116>; else goto <D.5118>;
  <D.5118>:
  D.5286 = length;
  return D.5286;
}


monoeg_g_slist_remove (struct GSList * list, const void * data)
{
  struct GSList * iftmp.0;
  struct GSList * D.5296;
  struct GSList * D.5298;
  struct GSList * prev;
  struct GSList * current;

  prev = find_prev (list, data);
  if (prev != 0B) goto <D.5289>; else goto <D.5290>;
  <D.5289>:
  iftmp.0 = prev->next;
  goto <D.5291>;
  <D.5290>:
  iftmp.0 = list;
  <D.5291>:
  current = iftmp.0;
  if (current != 0B) goto <D.5292>; else goto <D.5293>;
  <D.5292>:
  if (prev != 0B) goto <D.5294>; else goto <D.5295>;
  <D.5294>:
  D.5296 = current->next;
  prev->next = D.5296;
  goto <D.5297>;
  <D.5295>:
  list = current->next;
  <D.5297>:
  monoeg_g_slist_free_1 (current);
  <D.5293>:
  D.5298 = list;
  return D.5298;
}


find_prev (struct GSList * list, const void * data)
{
  void * D.5300;
  struct GSList * D.5302;
  struct GSList * prev;

  prev = 0B;
  goto <D.5049>;
  <D.5048>:
  D.5300 = list->data;
  if (D.5300 == data) goto <D.5047>; else goto <D.5301>;
  <D.5301>:
  prev = list;
  list = list->next;
  <D.5049>:
  if (list != 0B) goto <D.5048>; else goto <D.5047>;
  <D.5047>:
  D.5302 = prev;
  return D.5302;
}


monoeg_g_slist_remove_all (struct GSList * list, const void * data)
{
  struct GSList * iftmp.1;
  struct GSList * D.5314;
  struct GSList * next;
  struct GSList * prev;
  struct GSList * current;

  next = list;
  prev = 0B;
  goto <D.5135>;
  <D.5134>:
  {
    struct GSList * tmp_prev;

    tmp_prev = find_prev (next, data);
    if (tmp_prev != 0B) goto <D.5304>; else goto <D.5305>;
    <D.5304>:
    prev = tmp_prev;
    <D.5305>:
    if (prev != 0B) goto <D.5307>; else goto <D.5308>;
    <D.5307>:
    iftmp.1 = prev->next;
    goto <D.5309>;
    <D.5308>:
    iftmp.1 = list;
    <D.5309>:
    current = iftmp.1;
    if (current == 0B) goto <D.5133>; else goto <D.5310>;
    <D.5310>:
    next = current->next;
    if (prev != 0B) goto <D.5311>; else goto <D.5312>;
    <D.5311>:
    prev->next = next;
    goto <D.5313>;
    <D.5312>:
    list = next;
    <D.5313>:
    monoeg_g_slist_free_1 (current);
  }
  <D.5135>:
  if (next != 0B) goto <D.5134>; else goto <D.5133>;
  <D.5133>:
  D.5314 = list;
  return D.5314;
}


monoeg_g_slist_remove_link (struct GSList * list, struct GSList * link)
{
  struct GSList * iftmp.2;
  struct GSList * D.5324;
  struct GSList * D.5326;
  struct GSList * prev;
  struct GSList * current;

  prev = find_prev_link (list, link);
  if (prev != 0B) goto <D.5317>; else goto <D.5318>;
  <D.5317>:
  iftmp.2 = prev->next;
  goto <D.5319>;
  <D.5318>:
  iftmp.2 = list;
  <D.5319>:
  current = iftmp.2;
  if (current != 0B) goto <D.5320>; else goto <D.5321>;
  <D.5320>:
  if (prev != 0B) goto <D.5322>; else goto <D.5323>;
  <D.5322>:
  D.5324 = current->next;
  prev->next = D.5324;
  goto <D.5325>;
  <D.5323>:
  list = current->next;
  <D.5325>:
  current->next = 0B;
  <D.5321>:
  D.5326 = list;
  return D.5326;
}


monoeg_g_slist_delete_link (struct GSList * list, struct GSList * link)
{
  struct GSList * D.5328;

  list = monoeg_g_slist_remove_link (list, link);
  monoeg_g_slist_free_1 (link);
  D.5328 = list;
  return D.5328;
}


monoeg_g_slist_reverse (struct GSList * list)
{
  struct GSList * D.5330;
  struct GSList * prev;

  prev = 0B;
  goto <D.5152>;
  <D.5151>:
  {
    struct GSList * next;

    next = list->next;
    list->next = prev;
    prev = list;
    list = next;
  }
  <D.5152>:
  if (list != 0B) goto <D.5151>; else goto <D.5153>;
  <D.5153>:
  D.5330 = prev;
  return D.5330;
}


monoeg_g_slist_insert_sorted (struct GSList * list, void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.5334;
  void * D.5338;
  int D.5339;
  struct GSList * D.5340;
  void * D.5341;
  int D.5342;
  struct GSList * prev;

  prev = 0B;
  if (func == 0B) goto <D.5332>; else goto <D.5333>;
  <D.5332>:
  D.5334 = list;
  return D.5334;
  <D.5333>:
  if (list == 0B) goto <D.5335>; else goto <D.5337>;
  <D.5337>:
  D.5338 = list->data;
  D.5339 = func (D.5338, data);
  if (D.5339 > 0) goto <D.5335>; else goto <D.5336>;
  <D.5335>:
  D.5334 = monoeg_g_slist_prepend (list, data);
  return D.5334;
  <D.5336>:
  prev = list;
  goto <D.5162>;
  <D.5161>:
  D.5340 = prev->next;
  D.5341 = D.5340->data;
  D.5342 = func (D.5341, data);
  if (D.5342 > 0) goto <D.5160>; else goto <D.5343>;
  <D.5343>:
  prev = prev->next;
  <D.5162>:
  D.5340 = prev->next;
  if (D.5340 != 0B) goto <D.5161>; else goto <D.5160>;
  <D.5160>:
  insert_after (prev, data);
  D.5334 = list;
  return D.5334;
}


monoeg_g_slist_index (struct GSList * list, const void * data)
{
  void * D.5345;
  gint D.5348;
  gint index;

  index = 0;
  goto <D.5169>;
  <D.5168>:
  D.5345 = list->data;
  if (D.5345 == data) goto <D.5346>; else goto <D.5347>;
  <D.5346>:
  D.5348 = index;
  return D.5348;
  <D.5347>:
  index = index + 1;
  list = list->next;
  <D.5169>:
  if (list != 0B) goto <D.5168>; else goto <D.5170>;
  <D.5170>:
  D.5348 = -1;
  return D.5348;
}


monoeg_g_slist_nth (struct GSList * list, guint n)
{
  struct GSList * D.5351;

  goto <D.5177>;
  <D.5176>:
  if (n == 0) goto <D.5175>; else goto <D.5350>;
  <D.5350>:
  n = n + 4294967295;
  list = list->next;
  <D.5177>:
  if (list != 0B) goto <D.5176>; else goto <D.5175>;
  <D.5175>:
  D.5351 = list;
  return D.5351;
}


monoeg_g_slist_nth_data (struct GSList * list, guint n)
{
  void * D.5353;
  void * iftmp.3;
  struct GSList * node;

  node = monoeg_g_slist_nth (list, n);
  if (node != 0B) goto <D.5355>; else goto <D.5356>;
  <D.5355>:
  iftmp.3 = node->data;
  goto <D.5357>;
  <D.5356>:
  iftmp.3 = 0B;
  <D.5357>:
  D.5353 = iftmp.3;
  return D.5353;
}


monoeg_g_slist_sort (struct GSList * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.5362;
  struct GSList * D.5363;

  if (list == 0B) goto <D.5359>; else goto <D.5361>;
  <D.5361>:
  D.5362 = list->next;
  if (D.5362 == 0B) goto <D.5359>; else goto <D.5360>;
  <D.5359>:
  D.5363 = list;
  return D.5363;
  <D.5360>:
  D.5363 = do_sort (list, func);
  return D.5363;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.5365;
  void * D.5366;
  int D.5367;
  struct GSList * D.5371;
  struct list_node * D.5372;
  int D.5373;
  struct sort_info si;

  try
    {
      init_sort_info (&si, func);
      goto <D.5233>;
      <D.5232>:
      {
        struct list_node * next;
        struct list_node * tail;

        next = list->next;
        tail = next->next;
        D.5365 = list->data;
        D.5366 = next->data;
        D.5367 = func (D.5365, D.5366);
        if (D.5367 > 0) goto <D.5368>; else goto <D.5369>;
        <D.5368>:
        next->next = list;
        next = list;
        list = list->next;
        <D.5369>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.5233>:
      if (list != 0B) goto <D.5370>; else goto <D.5234>;
      <D.5370>:
      D.5371 = list->next;
      if (D.5371 != 0B) goto <D.5232>; else goto <D.5234>;
      <D.5234>:
      D.5373 = si.n_ranks;
      D.5372 = sweep_up (&si, list, D.5373);
      return D.5372;
    }
  finally
    {
      si = {CLOBBER};
    }
}


init_sort_info (struct sort_info * si, gint (*GCompareFunc) (const void *, const void *) func)
{
  int D.5376;

  si->n_ranks = 0;
  D.5376 = si->n_ranks;
  si->min_rank = D.5376;
  si->func = func;
}


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.5377;
  unsigned int rank.4;
  struct list_node * D.5383;
  gint (*<Tcc5>) (const void *, const void *) D.5384;
  struct list_node * D.5388;
  struct list_node * D.5389;
  int D.5395;
  int i;

  D.5377 = si->n_ranks;
  if (D.5377 < rank) goto <D.5378>; else goto <D.5379>;
  <D.5378>:
  rank.4 = (unsigned int) rank;
  if (rank.4 > 59) goto <D.5381>; else goto <D.5382>;
  <D.5381>:
  monoeg_g_log (0B, 16, "Rank \'%d\' should not exceed ((sizeof (size_t) * 8) - (((sizeof (list_node))>=2) + ((sizeof (list_node))>=4) + ((sizeof (list_node))>=8) + ((sizeof (list_node))>=16) + ((sizeof (list_node))>=32) + ((sizeof (list_node))>=64) + ((sizeof (list_node))>=128)) - 1)", rank);
  rank = 59;
  <D.5382>:
  D.5377 = si->n_ranks;
  D.5383 = sweep_up (si, 0B, D.5377);
  D.5384 = si->func;
  list = merge_lists (D.5383, list, D.5384);
  i = si->n_ranks;
  goto <D.5220>;
  <D.5219>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5220>:
  if (i < rank) goto <D.5219>; else goto <D.5221>;
  <D.5221>:
  goto <D.5385>;
  <D.5379>:
  if (rank != 0) goto <D.5386>; else goto <D.5387>;
  <D.5386>:
  D.5388 = sweep_up (si, 0B, rank);
  D.5384 = si->func;
  list = merge_lists (D.5388, list, D.5384);
  <D.5387>:
  i = rank;
  goto <D.5223>;
  <D.5222>:
  D.5389 = si->ranks[i];
  D.5384 = si->func;
  list = merge_lists (D.5389, list, D.5384);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5223>:
  D.5377 = si->n_ranks;
  if (D.5377 > i) goto <D.5390>; else goto <D.5224>;
  <D.5390>:
  D.5389 = si->ranks[i];
  if (D.5389 != 0B) goto <D.5222>; else goto <D.5224>;
  <D.5224>:
  <D.5385>:
  if (i == 59) goto <D.5391>; else goto <D.5392>;
  <D.5391>:
  i = i + -1;
  <D.5392>:
  D.5377 = si->n_ranks;
  if (D.5377 <= i) goto <D.5393>; else goto <D.5394>;
  <D.5393>:
  D.5395 = i + 1;
  si->n_ranks = D.5395;
  <D.5394>:
  si->min_rank = i;
  si->ranks[i] = list;
}


merge_lists (struct list_node * first, struct list_node * second, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.5396;
  void * D.5397;
  int D.5398;
  struct list_node * D.5402;
  struct list_node * iftmp.5;
  struct list_node * D.5408;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.5202>;
      <D.5201>:
      D.5396 = first->data;
      D.5397 = second->data;
      D.5398 = func (D.5396, D.5397);
      if (D.5398 > 0) goto <D.5399>; else goto <D.5400>;
      <D.5399>:
      *pos = second;
      second = second->next;
      goto <D.5401>;
      <D.5400>:
      *pos = first;
      first = first->next;
      <D.5401>:
      D.5402 = *pos;
      pos = &D.5402->next;
      <D.5202>:
      if (first != 0B) goto <D.5403>; else goto <D.5203>;
      <D.5403>:
      if (second != 0B) goto <D.5201>; else goto <D.5203>;
      <D.5203>:
      if (first != 0B) goto <D.5405>; else goto <D.5406>;
      <D.5405>:
      iftmp.5 = first;
      goto <D.5407>;
      <D.5406>:
      iftmp.5 = second;
      <D.5407>:
      *pos = iftmp.5;
      D.5408 = list;
      return D.5408;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  struct list_node * D.5411;
  gint (*<Tcc5>) (const void *, const void *) D.5412;
  struct list_node * D.5413;
  int i;

  i = si->min_rank;
  goto <D.5211>;
  <D.5210>:
  D.5411 = si->ranks[i];
  D.5412 = si->func;
  list = merge_lists (D.5411, list, D.5412);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5211>:
  if (i < upto) goto <D.5210>; else goto <D.5212>;
  <D.5212>:
  D.5413 = list;
  return D.5413;
}