monoeg_g_slist_alloc ()
{
  struct GSList * D.4787;

  D.4787 = monoeg_malloc0 (8);
  return D.4787;
}


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


monoeg_g_slist_append (struct GSList * list, void * data)
{
  struct GSList * D.4789;
  struct GSList * D.4790;

  D.4790 = monoeg_g_slist_prepend (0B, data);
  D.4789 = monoeg_g_slist_concat (list, D.4790);
  return D.4789;
}


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

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


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

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


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

  prev = 0B;
  goto <D.4604>;
  <D.4603>:
  if (list == link) goto <D.4602>; else goto <D.4798>;
  <D.4798>:
  prev = list;
  list = list->next;
  <D.4604>:
  if (list != 0B) goto <D.4603>; else goto <D.4602>;
  <D.4602>:
  D.4799 = prev;
  return D.4799;
}


insert_after (struct GSList * list, void * data)
{
  struct GSList * D.4801;
  struct GSList * D.4802;
  struct GSList * D.4803;

  D.4801 = list->next;
  D.4802 = monoeg_g_slist_prepend (D.4801, data);
  list->next = D.4802;
  D.4803 = list->next;
  return D.4803;
}


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

    next = list->next;
    monoeg_g_slist_free_1 (list);
    list = next;
  }
  <D.4616>:
  if (list != 0B) goto <D.4615>; else goto <D.4617>;
  <D.4617>:
}


monoeg_g_slist_copy (struct GSList * list)
{
  struct GSList * D.4807;
  void * D.4808;
  struct GSList * copy;
  struct GSList * tmp;

  if (list == 0B) goto <D.4805>; else goto <D.4806>;
  <D.4805>:
  D.4807 = 0B;
  return D.4807;
  <D.4806>:
  D.4808 = list->data;
  copy = monoeg_g_slist_prepend (0B, D.4808);
  tmp = copy;
  list = list->next;
  goto <D.4624>;
  <D.4623>:
  D.4808 = list->data;
  tmp = insert_after (tmp, D.4808);
  list = list->next;
  <D.4624>:
  if (list != 0B) goto <D.4623>; else goto <D.4625>;
  <D.4625>:
  D.4807 = copy;
  return D.4807;
}


monoeg_g_slist_concat (struct GSList * list1, struct GSList * list2)
{
  struct GSList * D.4812;
  struct GSList * D.4813;

  if (list1 == 0B) goto <D.4810>; else goto <D.4811>;
  <D.4810>:
  D.4812 = list2;
  return D.4812;
  <D.4811>:
  D.4813 = monoeg_g_slist_last (list1);
  D.4813->next = list2;
  D.4812 = list1;
  return D.4812;
}


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

  goto <D.4636>;
  <D.4635>:
  D.4815 = list->data;
  func (D.4815, user_data);
  list = list->next;
  <D.4636>:
  if (list != 0B) goto <D.4635>; else goto <D.4637>;
  <D.4637>:
}


monoeg_g_slist_last (struct GSList * list)
{
  struct GSList * D.4818;
  struct GSList * D.4819;

  if (list == 0B) goto <D.4816>; else goto <D.4817>;
  <D.4816>:
  D.4818 = 0B;
  return D.4818;
  <D.4817>:
  goto <D.4642>;
  <D.4641>:
  list = list->next;
  <D.4642>:
  D.4819 = list->next;
  if (D.4819 != 0B) goto <D.4641>; else goto <D.4643>;
  <D.4643>:
  D.4818 = list;
  return D.4818;
}


monoeg_g_slist_find (struct GSList * list, const void * data)
{
  void * D.4821;
  struct GSList * D.4823;

  goto <D.4650>;
  <D.4649>:
  D.4821 = list->data;
  if (D.4821 == data) goto <D.4648>; else goto <D.4822>;
  <D.4822>:
  list = list->next;
  <D.4650>:
  if (list != 0B) goto <D.4649>; else goto <D.4648>;
  <D.4648>:
  D.4823 = list;
  return D.4823;
}


monoeg_g_slist_find_custom (struct GSList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.4827;
  void * D.4828;
  int D.4829;

  if (func == 0B) goto <D.4825>; else goto <D.4826>;
  <D.4825>:
  D.4827 = 0B;
  return D.4827;
  <D.4826>:
  goto <D.4657>;
  <D.4656>:
  D.4828 = list->data;
  D.4829 = func (D.4828, data);
  if (D.4829 == 0) goto <D.4830>; else goto <D.4831>;
  <D.4830>:
  D.4827 = list;
  return D.4827;
  <D.4831>:
  list = list->next;
  <D.4657>:
  if (list != 0B) goto <D.4656>; else goto <D.4658>;
  <D.4658>:
  D.4827 = 0B;
  return D.4827;
}


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

  length = 0;
  goto <D.4664>;
  <D.4663>:
  length = length + 1;
  list = list->next;
  <D.4664>:
  if (list != 0B) goto <D.4663>; else goto <D.4665>;
  <D.4665>:
  D.4833 = length;
  return D.4833;
}


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

  prev = find_prev (list, data);
  if (prev != 0B) goto <D.4836>; else goto <D.4837>;
  <D.4836>:
  iftmp.0 = prev->next;
  goto <D.4838>;
  <D.4837>:
  iftmp.0 = list;
  <D.4838>:
  current = iftmp.0;
  if (current != 0B) goto <D.4839>; else goto <D.4840>;
  <D.4839>:
  if (prev != 0B) goto <D.4841>; else goto <D.4842>;
  <D.4841>:
  D.4843 = current->next;
  prev->next = D.4843;
  goto <D.4844>;
  <D.4842>:
  list = current->next;
  <D.4844>:
  monoeg_g_slist_free_1 (current);
  <D.4840>:
  D.4845 = list;
  return D.4845;
}


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

  prev = 0B;
  goto <D.4596>;
  <D.4595>:
  D.4847 = list->data;
  if (D.4847 == data) goto <D.4594>; else goto <D.4848>;
  <D.4848>:
  prev = list;
  list = list->next;
  <D.4596>:
  if (list != 0B) goto <D.4595>; else goto <D.4594>;
  <D.4594>:
  D.4849 = prev;
  return D.4849;
}


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

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

    tmp_prev = find_prev (next, data);
    if (tmp_prev != 0B) goto <D.4851>; else goto <D.4852>;
    <D.4851>:
    prev = tmp_prev;
    <D.4852>:
    if (prev != 0B) goto <D.4854>; else goto <D.4855>;
    <D.4854>:
    iftmp.1 = prev->next;
    goto <D.4856>;
    <D.4855>:
    iftmp.1 = list;
    <D.4856>:
    current = iftmp.1;
    if (current == 0B) goto <D.4680>; else goto <D.4857>;
    <D.4857>:
    next = current->next;
    if (prev != 0B) goto <D.4858>; else goto <D.4859>;
    <D.4858>:
    prev->next = next;
    goto <D.4860>;
    <D.4859>:
    list = next;
    <D.4860>:
    monoeg_g_slist_free_1 (current);
  }
  <D.4682>:
  if (next != 0B) goto <D.4681>; else goto <D.4680>;
  <D.4680>:
  D.4861 = list;
  return D.4861;
}


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

  prev = find_prev_link (list, link);
  if (prev != 0B) goto <D.4864>; else goto <D.4865>;
  <D.4864>:
  iftmp.2 = prev->next;
  goto <D.4866>;
  <D.4865>:
  iftmp.2 = list;
  <D.4866>:
  current = iftmp.2;
  if (current != 0B) goto <D.4867>; else goto <D.4868>;
  <D.4867>:
  if (prev != 0B) goto <D.4869>; else goto <D.4870>;
  <D.4869>:
  D.4871 = current->next;
  prev->next = D.4871;
  goto <D.4872>;
  <D.4870>:
  list = current->next;
  <D.4872>:
  current->next = 0B;
  <D.4868>:
  D.4873 = list;
  return D.4873;
}


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

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


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

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

    next = list->next;
    list->next = prev;
    prev = list;
    list = next;
  }
  <D.4699>:
  if (list != 0B) goto <D.4698>; else goto <D.4700>;
  <D.4700>:
  D.4877 = prev;
  return D.4877;
}


monoeg_g_slist_insert_sorted (struct GSList * list, void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.4881;
  void * D.4885;
  int D.4886;
  struct GSList * D.4887;
  void * D.4888;
  int D.4889;
  struct GSList * prev;

  prev = 0B;
  if (func == 0B) goto <D.4879>; else goto <D.4880>;
  <D.4879>:
  D.4881 = list;
  return D.4881;
  <D.4880>:
  if (list == 0B) goto <D.4882>; else goto <D.4884>;
  <D.4884>:
  D.4885 = list->data;
  D.4886 = func (D.4885, data);
  if (D.4886 > 0) goto <D.4882>; else goto <D.4883>;
  <D.4882>:
  D.4881 = monoeg_g_slist_prepend (list, data);
  return D.4881;
  <D.4883>:
  prev = list;
  goto <D.4709>;
  <D.4708>:
  D.4887 = prev->next;
  D.4888 = D.4887->data;
  D.4889 = func (D.4888, data);
  if (D.4889 > 0) goto <D.4707>; else goto <D.4890>;
  <D.4890>:
  prev = prev->next;
  <D.4709>:
  D.4887 = prev->next;
  if (D.4887 != 0B) goto <D.4708>; else goto <D.4707>;
  <D.4707>:
  insert_after (prev, data);
  D.4881 = list;
  return D.4881;
}


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

  index = 0;
  goto <D.4716>;
  <D.4715>:
  D.4892 = list->data;
  if (D.4892 == data) goto <D.4893>; else goto <D.4894>;
  <D.4893>:
  D.4895 = index;
  return D.4895;
  <D.4894>:
  index = index + 1;
  list = list->next;
  <D.4716>:
  if (list != 0B) goto <D.4715>; else goto <D.4717>;
  <D.4717>:
  D.4895 = -1;
  return D.4895;
}


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

  goto <D.4724>;
  <D.4723>:
  if (n == 0) goto <D.4722>; else goto <D.4897>;
  <D.4897>:
  n = n + 4294967295;
  list = list->next;
  <D.4724>:
  if (list != 0B) goto <D.4723>; else goto <D.4722>;
  <D.4722>:
  D.4898 = list;
  return D.4898;
}


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

  node = monoeg_g_slist_nth (list, n);
  if (node != 0B) goto <D.4902>; else goto <D.4903>;
  <D.4902>:
  iftmp.3 = node->data;
  goto <D.4904>;
  <D.4903>:
  iftmp.3 = 0B;
  <D.4904>:
  D.4900 = iftmp.3;
  return D.4900;
}


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

  if (list == 0B) goto <D.4906>; else goto <D.4908>;
  <D.4908>:
  D.4909 = list->next;
  if (D.4909 == 0B) goto <D.4906>; else goto <D.4907>;
  <D.4906>:
  D.4910 = list;
  return D.4910;
  <D.4907>:
  D.4910 = do_sort (list, func);
  return D.4910;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.4912;
  void * D.4913;
  int D.4914;
  struct GSList * D.4918;
  struct list_node * D.4919;
  int D.4920;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.4912 = next->data;
        D.4913 = list->data;
        D.4914 = func (D.4913, D.4912);
        if (D.4914 > 0) goto <D.4915>; else goto <D.4916>;
        <D.4915>:
        next->next = list;
        next = list;
        list = list->next;
        <D.4916>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.4780>:
      if (list != 0B) goto <D.4917>; else goto <D.4781>;
      <D.4917>:
      D.4918 = list->next;
      if (D.4918 != 0B) goto <D.4779>; else goto <D.4781>;
      <D.4781>:
      D.4920 = si.n_ranks;
      D.4919 = sweep_up (&si, list, D.4920);
      return D.4919;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.4924;
  unsigned int rank.4;
  gint (*<Tb99>) (const void *, const void *) D.4930;
  struct list_node * D.4931;
  struct list_node * D.4935;
  struct list_node * D.4936;
  int D.4942;
  int i;

  D.4924 = si->n_ranks;
  if (D.4924 < rank) goto <D.4925>; else goto <D.4926>;
  <D.4925>:
  rank.4 = (unsigned int) rank;
  if (rank.4 > 28) goto <D.4928>; else goto <D.4929>;
  <D.4928>:
  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 = 28;
  <D.4929>:
  D.4930 = si->func;
  D.4924 = si->n_ranks;
  D.4931 = sweep_up (si, 0B, D.4924);
  list = merge_lists (D.4931, list, D.4930);
  i = si->n_ranks;
  goto <D.4767>;
  <D.4766>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4767>:
  if (i < rank) goto <D.4766>; else goto <D.4768>;
  <D.4768>:
  goto <D.4932>;
  <D.4926>:
  if (rank != 0) goto <D.4933>; else goto <D.4934>;
  <D.4933>:
  D.4930 = si->func;
  D.4935 = sweep_up (si, 0B, rank);
  list = merge_lists (D.4935, list, D.4930);
  <D.4934>:
  i = rank;
  goto <D.4770>;
  <D.4769>:
  D.4930 = si->func;
  D.4936 = si->ranks[i];
  list = merge_lists (D.4936, list, D.4930);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4770>:
  D.4924 = si->n_ranks;
  if (D.4924 > i) goto <D.4937>; else goto <D.4771>;
  <D.4937>:
  D.4936 = si->ranks[i];
  if (D.4936 != 0B) goto <D.4769>; else goto <D.4771>;
  <D.4771>:
  <D.4932>:
  if (i == 28) goto <D.4938>; else goto <D.4939>;
  <D.4938>:
  i = i + -1;
  <D.4939>:
  D.4924 = si->n_ranks;
  if (D.4924 <= i) goto <D.4940>; else goto <D.4941>;
  <D.4940>:
  D.4942 = i + 1;
  si->n_ranks = D.4942;
  <D.4941>:
  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.4943;
  void * D.4944;
  int D.4945;
  struct list_node * D.4949;
  _Bool D.4950;
  _Bool D.4951;
  _Bool D.4952;
  struct list_node * iftmp.5;
  struct list_node * D.4957;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.4749>;
      <D.4748>:
      D.4943 = second->data;
      D.4944 = first->data;
      D.4945 = func (D.4944, D.4943);
      if (D.4945 > 0) goto <D.4946>; else goto <D.4947>;
      <D.4946>:
      *pos = second;
      second = second->next;
      goto <D.4948>;
      <D.4947>:
      *pos = first;
      first = first->next;
      <D.4948>:
      D.4949 = *pos;
      pos = &D.4949->next;
      <D.4749>:
      D.4950 = first != 0B;
      D.4951 = second != 0B;
      D.4952 = D.4950 & D.4951;
      if (D.4952 != 0) goto <D.4748>; else goto <D.4750>;
      <D.4750>:
      if (first != 0B) goto <D.4954>; else goto <D.4955>;
      <D.4954>:
      iftmp.5 = first;
      goto <D.4956>;
      <D.4955>:
      iftmp.5 = second;
      <D.4956>:
      *pos = iftmp.5;
      D.4957 = list;
      return D.4957;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  gint (*<Tb99>) (const void *, const void *) D.4960;
  struct list_node * D.4961;
  struct list_node * D.4962;
  int i;

  i = si->min_rank;
  goto <D.4758>;
  <D.4757>:
  D.4960 = si->func;
  D.4961 = si->ranks[i];
  list = merge_lists (D.4961, list, D.4960);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4758>:
  if (i < upto) goto <D.4757>; else goto <D.4759>;
  <D.4759>:
  D.4962 = list;
  return D.4962;
}