monoeg_g_slist_alloc ()
{
  struct GSList * D.5137;

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


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


monoeg_g_slist_append (struct GSList * list, void * data)
{
  struct GSList * D.5139;
  struct GSList * D.5140;

  D.5140 = monoeg_g_slist_prepend (0B, data);
  D.5139 = monoeg_g_slist_concat (list, D.5140);
  return D.5139;
}


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

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


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

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


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

  prev = 0B;
  goto <D.4954>;
  <D.4953>:
  if (list == link) goto <D.4952>; else goto <D.5148>;
  <D.5148>:
  prev = list;
  list = list->next;
  <D.4954>:
  if (list != 0B) goto <D.4953>; else goto <D.4952>;
  <D.4952>:
  D.5149 = prev;
  return D.5149;
}


insert_after (struct GSList * list, void * data)
{
  struct GSList * D.5151;
  struct GSList * D.5152;
  struct GSList * D.5153;

  D.5151 = list->next;
  D.5152 = monoeg_g_slist_prepend (D.5151, data);
  list->next = D.5152;
  D.5153 = list->next;
  return D.5153;
}


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

    next = list->next;
    monoeg_g_slist_free_1 (list);
    list = next;
  }
  <D.4966>:
  if (list != 0B) goto <D.4965>; else goto <D.4967>;
  <D.4967>:
}


monoeg_g_slist_copy (struct GSList * list)
{
  struct GSList * D.5157;
  void * D.5158;
  struct GSList * copy;
  struct GSList * tmp;

  if (list == 0B) goto <D.5155>; else goto <D.5156>;
  <D.5155>:
  D.5157 = 0B;
  return D.5157;
  <D.5156>:
  D.5158 = list->data;
  copy = monoeg_g_slist_prepend (0B, D.5158);
  tmp = copy;
  list = list->next;
  goto <D.4974>;
  <D.4973>:
  D.5158 = list->data;
  tmp = insert_after (tmp, D.5158);
  list = list->next;
  <D.4974>:
  if (list != 0B) goto <D.4973>; else goto <D.4975>;
  <D.4975>:
  D.5157 = copy;
  return D.5157;
}


monoeg_g_slist_concat (struct GSList * list1, struct GSList * list2)
{
  struct GSList * D.5162;
  struct GSList * D.5163;

  if (list1 == 0B) goto <D.5160>; else goto <D.5161>;
  <D.5160>:
  D.5162 = list2;
  return D.5162;
  <D.5161>:
  D.5163 = monoeg_g_slist_last (list1);
  D.5163->next = list2;
  D.5162 = list1;
  return D.5162;
}


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

  goto <D.4986>;
  <D.4985>:
  D.5165 = list->data;
  func (D.5165, user_data);
  list = list->next;
  <D.4986>:
  if (list != 0B) goto <D.4985>; else goto <D.4987>;
  <D.4987>:
}


monoeg_g_slist_last (struct GSList * list)
{
  struct GSList * D.5168;
  struct GSList * D.5169;

  if (list == 0B) goto <D.5166>; else goto <D.5167>;
  <D.5166>:
  D.5168 = 0B;
  return D.5168;
  <D.5167>:
  goto <D.4992>;
  <D.4991>:
  list = list->next;
  <D.4992>:
  D.5169 = list->next;
  if (D.5169 != 0B) goto <D.4991>; else goto <D.4993>;
  <D.4993>:
  D.5168 = list;
  return D.5168;
}


monoeg_g_slist_find (struct GSList * list, const void * data)
{
  void * D.5171;
  struct GSList * D.5173;

  goto <D.5000>;
  <D.4999>:
  D.5171 = list->data;
  if (D.5171 == data) goto <D.4998>; else goto <D.5172>;
  <D.5172>:
  list = list->next;
  <D.5000>:
  if (list != 0B) goto <D.4999>; else goto <D.4998>;
  <D.4998>:
  D.5173 = list;
  return D.5173;
}


monoeg_g_slist_find_custom (struct GSList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.5177;
  void * D.5178;
  int D.5179;

  if (func == 0B) goto <D.5175>; else goto <D.5176>;
  <D.5175>:
  D.5177 = 0B;
  return D.5177;
  <D.5176>:
  goto <D.5007>;
  <D.5006>:
  D.5178 = list->data;
  D.5179 = func (D.5178, data);
  if (D.5179 == 0) goto <D.5180>; else goto <D.5181>;
  <D.5180>:
  D.5177 = list;
  return D.5177;
  <D.5181>:
  list = list->next;
  <D.5007>:
  if (list != 0B) goto <D.5006>; else goto <D.5008>;
  <D.5008>:
  D.5177 = 0B;
  return D.5177;
}


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

  length = 0;
  goto <D.5014>;
  <D.5013>:
  length = length + 1;
  list = list->next;
  <D.5014>:
  if (list != 0B) goto <D.5013>; else goto <D.5015>;
  <D.5015>:
  D.5183 = length;
  return D.5183;
}


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

  prev = find_prev (list, data);
  if (prev != 0B) goto <D.5186>; else goto <D.5187>;
  <D.5186>:
  iftmp.0 = prev->next;
  goto <D.5188>;
  <D.5187>:
  iftmp.0 = list;
  <D.5188>:
  current = iftmp.0;
  if (current != 0B) goto <D.5189>; else goto <D.5190>;
  <D.5189>:
  if (prev != 0B) goto <D.5191>; else goto <D.5192>;
  <D.5191>:
  D.5193 = current->next;
  prev->next = D.5193;
  goto <D.5194>;
  <D.5192>:
  list = current->next;
  <D.5194>:
  monoeg_g_slist_free_1 (current);
  <D.5190>:
  D.5195 = list;
  return D.5195;
}


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

  prev = 0B;
  goto <D.4946>;
  <D.4945>:
  D.5197 = list->data;
  if (D.5197 == data) goto <D.4944>; else goto <D.5198>;
  <D.5198>:
  prev = list;
  list = list->next;
  <D.4946>:
  if (list != 0B) goto <D.4945>; else goto <D.4944>;
  <D.4944>:
  D.5199 = prev;
  return D.5199;
}


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

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

    tmp_prev = find_prev (next, data);
    if (tmp_prev != 0B) goto <D.5201>; else goto <D.5202>;
    <D.5201>:
    prev = tmp_prev;
    <D.5202>:
    if (prev != 0B) goto <D.5204>; else goto <D.5205>;
    <D.5204>:
    iftmp.1 = prev->next;
    goto <D.5206>;
    <D.5205>:
    iftmp.1 = list;
    <D.5206>:
    current = iftmp.1;
    if (current == 0B) goto <D.5030>; else goto <D.5207>;
    <D.5207>:
    next = current->next;
    if (prev != 0B) goto <D.5208>; else goto <D.5209>;
    <D.5208>:
    prev->next = next;
    goto <D.5210>;
    <D.5209>:
    list = next;
    <D.5210>:
    monoeg_g_slist_free_1 (current);
  }
  <D.5032>:
  if (next != 0B) goto <D.5031>; else goto <D.5030>;
  <D.5030>:
  D.5211 = list;
  return D.5211;
}


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

  prev = find_prev_link (list, link);
  if (prev != 0B) goto <D.5214>; else goto <D.5215>;
  <D.5214>:
  iftmp.2 = prev->next;
  goto <D.5216>;
  <D.5215>:
  iftmp.2 = list;
  <D.5216>:
  current = iftmp.2;
  if (current != 0B) goto <D.5217>; else goto <D.5218>;
  <D.5217>:
  if (prev != 0B) goto <D.5219>; else goto <D.5220>;
  <D.5219>:
  D.5221 = current->next;
  prev->next = D.5221;
  goto <D.5222>;
  <D.5220>:
  list = current->next;
  <D.5222>:
  current->next = 0B;
  <D.5218>:
  D.5223 = list;
  return D.5223;
}


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

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


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

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

    next = list->next;
    list->next = prev;
    prev = list;
    list = next;
  }
  <D.5049>:
  if (list != 0B) goto <D.5048>; else goto <D.5050>;
  <D.5050>:
  D.5227 = prev;
  return D.5227;
}


monoeg_g_slist_insert_sorted (struct GSList * list, void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.5231;
  void * D.5235;
  int D.5236;
  struct GSList * D.5237;
  void * D.5238;
  int D.5239;
  struct GSList * prev;

  prev = 0B;
  if (func == 0B) goto <D.5229>; else goto <D.5230>;
  <D.5229>:
  D.5231 = list;
  return D.5231;
  <D.5230>:
  if (list == 0B) goto <D.5232>; else goto <D.5234>;
  <D.5234>:
  D.5235 = list->data;
  D.5236 = func (D.5235, data);
  if (D.5236 > 0) goto <D.5232>; else goto <D.5233>;
  <D.5232>:
  D.5231 = monoeg_g_slist_prepend (list, data);
  return D.5231;
  <D.5233>:
  prev = list;
  goto <D.5059>;
  <D.5058>:
  D.5237 = prev->next;
  D.5238 = D.5237->data;
  D.5239 = func (D.5238, data);
  if (D.5239 > 0) goto <D.5057>; else goto <D.5240>;
  <D.5240>:
  prev = prev->next;
  <D.5059>:
  D.5237 = prev->next;
  if (D.5237 != 0B) goto <D.5058>; else goto <D.5057>;
  <D.5057>:
  insert_after (prev, data);
  D.5231 = list;
  return D.5231;
}


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

  index = 0;
  goto <D.5066>;
  <D.5065>:
  D.5242 = list->data;
  if (D.5242 == data) goto <D.5243>; else goto <D.5244>;
  <D.5243>:
  D.5245 = index;
  return D.5245;
  <D.5244>:
  index = index + 1;
  list = list->next;
  <D.5066>:
  if (list != 0B) goto <D.5065>; else goto <D.5067>;
  <D.5067>:
  D.5245 = -1;
  return D.5245;
}


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

  goto <D.5074>;
  <D.5073>:
  if (n == 0) goto <D.5072>; else goto <D.5247>;
  <D.5247>:
  n = n + 4294967295;
  list = list->next;
  <D.5074>:
  if (list != 0B) goto <D.5073>; else goto <D.5072>;
  <D.5072>:
  D.5248 = list;
  return D.5248;
}


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

  node = monoeg_g_slist_nth (list, n);
  if (node != 0B) goto <D.5252>; else goto <D.5253>;
  <D.5252>:
  iftmp.3 = node->data;
  goto <D.5254>;
  <D.5253>:
  iftmp.3 = 0B;
  <D.5254>:
  D.5250 = iftmp.3;
  return D.5250;
}


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

  if (list == 0B) goto <D.5256>; else goto <D.5258>;
  <D.5258>:
  D.5259 = list->next;
  if (D.5259 == 0B) goto <D.5256>; else goto <D.5257>;
  <D.5256>:
  D.5260 = list;
  return D.5260;
  <D.5257>:
  D.5260 = do_sort (list, func);
  return D.5260;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.5262;
  void * D.5263;
  int D.5264;
  struct GSList * D.5268;
  struct list_node * D.5269;
  int D.5270;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.5262 = next->data;
        D.5263 = list->data;
        D.5264 = func (D.5263, D.5262);
        if (D.5264 > 0) goto <D.5265>; else goto <D.5266>;
        <D.5265>:
        next->next = list;
        next = list;
        list = list->next;
        <D.5266>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.5130>:
      if (list != 0B) goto <D.5267>; else goto <D.5131>;
      <D.5267>:
      D.5268 = list->next;
      if (D.5268 != 0B) goto <D.5129>; else goto <D.5131>;
      <D.5131>:
      D.5270 = si.n_ranks;
      D.5269 = sweep_up (&si, list, D.5270);
      return D.5269;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.5274;
  unsigned int rank.4;
  gint (*<Tc58>) (const void *, const void *) D.5280;
  struct list_node * D.5281;
  struct list_node * D.5285;
  struct list_node * D.5286;
  int D.5292;
  int i;

  D.5274 = si->n_ranks;
  if (D.5274 < rank) goto <D.5275>; else goto <D.5276>;
  <D.5275>:
  rank.4 = (unsigned int) rank;
  if (rank.4 > 59) goto <D.5278>; else goto <D.5279>;
  <D.5278>:
  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.5279>:
  D.5280 = si->func;
  D.5274 = si->n_ranks;
  D.5281 = sweep_up (si, 0B, D.5274);
  list = merge_lists (D.5281, list, D.5280);
  i = si->n_ranks;
  goto <D.5117>;
  <D.5116>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5117>:
  if (i < rank) goto <D.5116>; else goto <D.5118>;
  <D.5118>:
  goto <D.5282>;
  <D.5276>:
  if (rank != 0) goto <D.5283>; else goto <D.5284>;
  <D.5283>:
  D.5280 = si->func;
  D.5285 = sweep_up (si, 0B, rank);
  list = merge_lists (D.5285, list, D.5280);
  <D.5284>:
  i = rank;
  goto <D.5120>;
  <D.5119>:
  D.5280 = si->func;
  D.5286 = si->ranks[i];
  list = merge_lists (D.5286, list, D.5280);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5120>:
  D.5274 = si->n_ranks;
  if (D.5274 > i) goto <D.5287>; else goto <D.5121>;
  <D.5287>:
  D.5286 = si->ranks[i];
  if (D.5286 != 0B) goto <D.5119>; else goto <D.5121>;
  <D.5121>:
  <D.5282>:
  if (i == 59) goto <D.5288>; else goto <D.5289>;
  <D.5288>:
  i = i + -1;
  <D.5289>:
  D.5274 = si->n_ranks;
  if (D.5274 <= i) goto <D.5290>; else goto <D.5291>;
  <D.5290>:
  D.5292 = i + 1;
  si->n_ranks = D.5292;
  <D.5291>:
  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.5293;
  void * D.5294;
  int D.5295;
  struct list_node * D.5299;
  _Bool D.5300;
  _Bool D.5301;
  _Bool D.5302;
  struct list_node * iftmp.5;
  struct list_node * D.5307;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.5099>;
      <D.5098>:
      D.5293 = second->data;
      D.5294 = first->data;
      D.5295 = func (D.5294, D.5293);
      if (D.5295 > 0) goto <D.5296>; else goto <D.5297>;
      <D.5296>:
      *pos = second;
      second = second->next;
      goto <D.5298>;
      <D.5297>:
      *pos = first;
      first = first->next;
      <D.5298>:
      D.5299 = *pos;
      pos = &D.5299->next;
      <D.5099>:
      D.5300 = first != 0B;
      D.5301 = second != 0B;
      D.5302 = D.5300 & D.5301;
      if (D.5302 != 0) goto <D.5098>; else goto <D.5100>;
      <D.5100>:
      if (first != 0B) goto <D.5304>; else goto <D.5305>;
      <D.5304>:
      iftmp.5 = first;
      goto <D.5306>;
      <D.5305>:
      iftmp.5 = second;
      <D.5306>:
      *pos = iftmp.5;
      D.5307 = list;
      return D.5307;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  gint (*<Tc58>) (const void *, const void *) D.5310;
  struct list_node * D.5311;
  struct list_node * D.5312;
  int i;

  i = si->min_rank;
  goto <D.5108>;
  <D.5107>:
  D.5310 = si->func;
  D.5311 = si->ranks[i];
  list = merge_lists (D.5311, list, D.5310);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5108>:
  if (i < upto) goto <D.5107>; else goto <D.5109>;
  <D.5109>:
  D.5312 = list;
  return D.5312;
}