monoeg_g_slist_alloc ()
{
  struct GSList * D.4807;

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


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


monoeg_g_slist_append (struct GSList * list, void * data)
{
  struct GSList * D.4809;
  struct GSList * D.4810;

  D.4810 = monoeg_g_slist_prepend (0B, data);
  D.4809 = monoeg_g_slist_concat (list, D.4810);
  return D.4809;
}


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

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


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

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


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

  prev = 0B;
  goto <D.4624>;
  <D.4623>:
  if (list == link) goto <D.4622>; else goto <D.4818>;
  <D.4818>:
  prev = list;
  list = list->next;
  <D.4624>:
  if (list != 0B) goto <D.4623>; else goto <D.4622>;
  <D.4622>:
  D.4819 = prev;
  return D.4819;
}


insert_after (struct GSList * list, void * data)
{
  struct GSList * D.4821;
  struct GSList * D.4822;
  struct GSList * D.4823;

  D.4821 = list->next;
  D.4822 = monoeg_g_slist_prepend (D.4821, data);
  list->next = D.4822;
  D.4823 = list->next;
  return D.4823;
}


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

    next = list->next;
    monoeg_g_slist_free_1 (list);
    list = next;
  }
  <D.4636>:
  if (list != 0B) goto <D.4635>; else goto <D.4637>;
  <D.4637>:
}


monoeg_g_slist_copy (struct GSList * list)
{
  struct GSList * D.4827;
  void * D.4828;
  struct GSList * copy;
  struct GSList * tmp;

  if (list == 0B) goto <D.4825>; else goto <D.4826>;
  <D.4825>:
  D.4827 = 0B;
  return D.4827;
  <D.4826>:
  D.4828 = list->data;
  copy = monoeg_g_slist_prepend (0B, D.4828);
  tmp = copy;
  list = list->next;
  goto <D.4644>;
  <D.4643>:
  D.4828 = list->data;
  tmp = insert_after (tmp, D.4828);
  list = list->next;
  <D.4644>:
  if (list != 0B) goto <D.4643>; else goto <D.4645>;
  <D.4645>:
  D.4827 = copy;
  return D.4827;
}


monoeg_g_slist_concat (struct GSList * list1, struct GSList * list2)
{
  struct GSList * D.4832;
  struct GSList * D.4833;

  if (list1 == 0B) goto <D.4830>; else goto <D.4831>;
  <D.4830>:
  D.4832 = list2;
  return D.4832;
  <D.4831>:
  D.4833 = monoeg_g_slist_last (list1);
  D.4833->next = list2;
  D.4832 = list1;
  return D.4832;
}


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

  goto <D.4656>;
  <D.4655>:
  D.4835 = list->data;
  func (D.4835, user_data);
  list = list->next;
  <D.4656>:
  if (list != 0B) goto <D.4655>; else goto <D.4657>;
  <D.4657>:
}


monoeg_g_slist_last (struct GSList * list)
{
  struct GSList * D.4838;
  struct GSList * D.4839;

  if (list == 0B) goto <D.4836>; else goto <D.4837>;
  <D.4836>:
  D.4838 = 0B;
  return D.4838;
  <D.4837>:
  goto <D.4662>;
  <D.4661>:
  list = list->next;
  <D.4662>:
  D.4839 = list->next;
  if (D.4839 != 0B) goto <D.4661>; else goto <D.4663>;
  <D.4663>:
  D.4838 = list;
  return D.4838;
}


monoeg_g_slist_find (struct GSList * list, const void * data)
{
  void * D.4841;
  struct GSList * D.4843;

  goto <D.4670>;
  <D.4669>:
  D.4841 = list->data;
  if (D.4841 == data) goto <D.4668>; else goto <D.4842>;
  <D.4842>:
  list = list->next;
  <D.4670>:
  if (list != 0B) goto <D.4669>; else goto <D.4668>;
  <D.4668>:
  D.4843 = list;
  return D.4843;
}


monoeg_g_slist_find_custom (struct GSList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.4847;
  void * D.4848;
  int D.4849;

  if (func == 0B) goto <D.4845>; else goto <D.4846>;
  <D.4845>:
  D.4847 = 0B;
  return D.4847;
  <D.4846>:
  goto <D.4677>;
  <D.4676>:
  D.4848 = list->data;
  D.4849 = func (D.4848, data);
  if (D.4849 == 0) goto <D.4850>; else goto <D.4851>;
  <D.4850>:
  D.4847 = list;
  return D.4847;
  <D.4851>:
  list = list->next;
  <D.4677>:
  if (list != 0B) goto <D.4676>; else goto <D.4678>;
  <D.4678>:
  D.4847 = 0B;
  return D.4847;
}


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

  length = 0;
  goto <D.4684>;
  <D.4683>:
  length = length + 1;
  list = list->next;
  <D.4684>:
  if (list != 0B) goto <D.4683>; else goto <D.4685>;
  <D.4685>:
  D.4853 = length;
  return D.4853;
}


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

  prev = find_prev (list, data);
  if (prev != 0B) goto <D.4856>; else goto <D.4857>;
  <D.4856>:
  iftmp.0 = prev->next;
  goto <D.4858>;
  <D.4857>:
  iftmp.0 = list;
  <D.4858>:
  current = iftmp.0;
  if (current != 0B) goto <D.4859>; else goto <D.4860>;
  <D.4859>:
  if (prev != 0B) goto <D.4861>; else goto <D.4862>;
  <D.4861>:
  D.4863 = current->next;
  prev->next = D.4863;
  goto <D.4864>;
  <D.4862>:
  list = current->next;
  <D.4864>:
  monoeg_g_slist_free_1 (current);
  <D.4860>:
  D.4865 = list;
  return D.4865;
}


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

  prev = 0B;
  goto <D.4616>;
  <D.4615>:
  D.4867 = list->data;
  if (D.4867 == data) goto <D.4614>; else goto <D.4868>;
  <D.4868>:
  prev = list;
  list = list->next;
  <D.4616>:
  if (list != 0B) goto <D.4615>; else goto <D.4614>;
  <D.4614>:
  D.4869 = prev;
  return D.4869;
}


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

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

    tmp_prev = find_prev (next, data);
    if (tmp_prev != 0B) goto <D.4871>; else goto <D.4872>;
    <D.4871>:
    prev = tmp_prev;
    <D.4872>:
    if (prev != 0B) goto <D.4874>; else goto <D.4875>;
    <D.4874>:
    iftmp.1 = prev->next;
    goto <D.4876>;
    <D.4875>:
    iftmp.1 = list;
    <D.4876>:
    current = iftmp.1;
    if (current == 0B) goto <D.4700>; else goto <D.4877>;
    <D.4877>:
    next = current->next;
    if (prev != 0B) goto <D.4878>; else goto <D.4879>;
    <D.4878>:
    prev->next = next;
    goto <D.4880>;
    <D.4879>:
    list = next;
    <D.4880>:
    monoeg_g_slist_free_1 (current);
  }
  <D.4702>:
  if (next != 0B) goto <D.4701>; else goto <D.4700>;
  <D.4700>:
  D.4881 = list;
  return D.4881;
}


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

  prev = find_prev_link (list, link);
  if (prev != 0B) goto <D.4884>; else goto <D.4885>;
  <D.4884>:
  iftmp.2 = prev->next;
  goto <D.4886>;
  <D.4885>:
  iftmp.2 = list;
  <D.4886>:
  current = iftmp.2;
  if (current != 0B) goto <D.4887>; else goto <D.4888>;
  <D.4887>:
  if (prev != 0B) goto <D.4889>; else goto <D.4890>;
  <D.4889>:
  D.4891 = current->next;
  prev->next = D.4891;
  goto <D.4892>;
  <D.4890>:
  list = current->next;
  <D.4892>:
  current->next = 0B;
  <D.4888>:
  D.4893 = list;
  return D.4893;
}


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

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


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

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

    next = list->next;
    list->next = prev;
    prev = list;
    list = next;
  }
  <D.4719>:
  if (list != 0B) goto <D.4718>; else goto <D.4720>;
  <D.4720>:
  D.4897 = prev;
  return D.4897;
}


monoeg_g_slist_insert_sorted (struct GSList * list, void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.4901;
  void * D.4905;
  int D.4906;
  struct GSList * D.4907;
  void * D.4908;
  int D.4909;
  struct GSList * prev;

  prev = 0B;
  if (func == 0B) goto <D.4899>; else goto <D.4900>;
  <D.4899>:
  D.4901 = list;
  return D.4901;
  <D.4900>:
  if (list == 0B) goto <D.4902>; else goto <D.4904>;
  <D.4904>:
  D.4905 = list->data;
  D.4906 = func (D.4905, data);
  if (D.4906 > 0) goto <D.4902>; else goto <D.4903>;
  <D.4902>:
  D.4901 = monoeg_g_slist_prepend (list, data);
  return D.4901;
  <D.4903>:
  prev = list;
  goto <D.4729>;
  <D.4728>:
  D.4907 = prev->next;
  D.4908 = D.4907->data;
  D.4909 = func (D.4908, data);
  if (D.4909 > 0) goto <D.4727>; else goto <D.4910>;
  <D.4910>:
  prev = prev->next;
  <D.4729>:
  D.4907 = prev->next;
  if (D.4907 != 0B) goto <D.4728>; else goto <D.4727>;
  <D.4727>:
  insert_after (prev, data);
  D.4901 = list;
  return D.4901;
}


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

  index = 0;
  goto <D.4736>;
  <D.4735>:
  D.4912 = list->data;
  if (D.4912 == data) goto <D.4913>; else goto <D.4914>;
  <D.4913>:
  D.4915 = index;
  return D.4915;
  <D.4914>:
  index = index + 1;
  list = list->next;
  <D.4736>:
  if (list != 0B) goto <D.4735>; else goto <D.4737>;
  <D.4737>:
  D.4915 = -1;
  return D.4915;
}


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

  goto <D.4744>;
  <D.4743>:
  if (n == 0) goto <D.4742>; else goto <D.4917>;
  <D.4917>:
  n = n + 4294967295;
  list = list->next;
  <D.4744>:
  if (list != 0B) goto <D.4743>; else goto <D.4742>;
  <D.4742>:
  D.4918 = list;
  return D.4918;
}


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

  node = monoeg_g_slist_nth (list, n);
  if (node != 0B) goto <D.4922>; else goto <D.4923>;
  <D.4922>:
  iftmp.3 = node->data;
  goto <D.4924>;
  <D.4923>:
  iftmp.3 = 0B;
  <D.4924>:
  D.4920 = iftmp.3;
  return D.4920;
}


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

  if (list == 0B) goto <D.4926>; else goto <D.4928>;
  <D.4928>:
  D.4929 = list->next;
  if (D.4929 == 0B) goto <D.4926>; else goto <D.4927>;
  <D.4926>:
  D.4930 = list;
  return D.4930;
  <D.4927>:
  D.4930 = do_sort (list, func);
  return D.4930;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.4932;
  void * D.4933;
  int D.4934;
  struct GSList * D.4938;
  struct list_node * D.4939;
  int D.4940;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.4932 = list->data;
        D.4933 = next->data;
        D.4934 = func (D.4932, D.4933);
        if (D.4934 > 0) goto <D.4935>; else goto <D.4936>;
        <D.4935>:
        next->next = list;
        next = list;
        list = list->next;
        <D.4936>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.4800>:
      if (list != 0B) goto <D.4937>; else goto <D.4801>;
      <D.4937>:
      D.4938 = list->next;
      if (D.4938 != 0B) goto <D.4799>; else goto <D.4801>;
      <D.4801>:
      D.4940 = si.n_ranks;
      D.4939 = sweep_up (&si, list, D.4940);
      return D.4939;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.4944;
  unsigned int rank.4;
  struct list_node * D.4950;
  gint (*<Tba2>) (const void *, const void *) D.4951;
  struct list_node * D.4955;
  struct list_node * D.4956;
  int D.4962;
  int i;

  D.4944 = si->n_ranks;
  if (D.4944 < rank) goto <D.4945>; else goto <D.4946>;
  <D.4945>:
  rank.4 = (unsigned int) rank;
  if (rank.4 > 28) goto <D.4948>; else goto <D.4949>;
  <D.4948>:
  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.4949>:
  D.4944 = si->n_ranks;
  D.4950 = sweep_up (si, 0B, D.4944);
  D.4951 = si->func;
  list = merge_lists (D.4950, list, D.4951);
  i = si->n_ranks;
  goto <D.4787>;
  <D.4786>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4787>:
  if (i < rank) goto <D.4786>; else goto <D.4788>;
  <D.4788>:
  goto <D.4952>;
  <D.4946>:
  if (rank != 0) goto <D.4953>; else goto <D.4954>;
  <D.4953>:
  D.4955 = sweep_up (si, 0B, rank);
  D.4951 = si->func;
  list = merge_lists (D.4955, list, D.4951);
  <D.4954>:
  i = rank;
  goto <D.4790>;
  <D.4789>:
  D.4956 = si->ranks[i];
  D.4951 = si->func;
  list = merge_lists (D.4956, list, D.4951);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4790>:
  D.4944 = si->n_ranks;
  if (D.4944 > i) goto <D.4957>; else goto <D.4791>;
  <D.4957>:
  D.4956 = si->ranks[i];
  if (D.4956 != 0B) goto <D.4789>; else goto <D.4791>;
  <D.4791>:
  <D.4952>:
  if (i == 28) goto <D.4958>; else goto <D.4959>;
  <D.4958>:
  i = i + -1;
  <D.4959>:
  D.4944 = si->n_ranks;
  if (D.4944 <= i) goto <D.4960>; else goto <D.4961>;
  <D.4960>:
  D.4962 = i + 1;
  si->n_ranks = D.4962;
  <D.4961>:
  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.4963;
  void * D.4964;
  int D.4965;
  struct list_node * D.4969;
  struct list_node * iftmp.5;
  struct list_node * D.4975;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.4769>;
      <D.4768>:
      D.4963 = first->data;
      D.4964 = second->data;
      D.4965 = func (D.4963, D.4964);
      if (D.4965 > 0) goto <D.4966>; else goto <D.4967>;
      <D.4966>:
      *pos = second;
      second = second->next;
      goto <D.4968>;
      <D.4967>:
      *pos = first;
      first = first->next;
      <D.4968>:
      D.4969 = *pos;
      pos = &D.4969->next;
      <D.4769>:
      if (first != 0B) goto <D.4970>; else goto <D.4770>;
      <D.4970>:
      if (second != 0B) goto <D.4768>; else goto <D.4770>;
      <D.4770>:
      if (first != 0B) goto <D.4972>; else goto <D.4973>;
      <D.4972>:
      iftmp.5 = first;
      goto <D.4974>;
      <D.4973>:
      iftmp.5 = second;
      <D.4974>:
      *pos = iftmp.5;
      D.4975 = list;
      return D.4975;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  struct list_node * D.4978;
  gint (*<Tba2>) (const void *, const void *) D.4979;
  struct list_node * D.4980;
  int i;

  i = si->min_rank;
  goto <D.4778>;
  <D.4777>:
  D.4978 = si->ranks[i];
  D.4979 = si->func;
  list = merge_lists (D.4978, list, D.4979);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4778>:
  if (i < upto) goto <D.4777>; else goto <D.4779>;
  <D.4779>:
  D.4980 = list;
  return D.4980;
}