monoeg_g_list_alloc ()
{
  struct GList * D.4780;

  D.4780 = monoeg_malloc0 (12);
  return D.4780;
}


monoeg_g_list_prepend (struct GList * list, void * data)
{
  struct GList * D.4782;
  struct GList * iftmp.0;

  if (list != 0B) goto <D.4784>; else goto <D.4785>;
  <D.4784>:
  iftmp.0 = list->prev;
  goto <D.4786>;
  <D.4785>:
  iftmp.0 = 0B;
  <D.4786>:
  D.4782 = new_node (iftmp.0, data, list);
  return D.4782;
}


new_node (struct GList * prev, void * data, struct GList * next)
{
  struct GList * D.4792;
  struct GList * node;

  node = monoeg_g_list_alloc ();
  node->data = data;
  node->prev = prev;
  node->next = next;
  if (prev != 0B) goto <D.4788>; else goto <D.4789>;
  <D.4788>:
  prev->next = node;
  <D.4789>:
  if (next != 0B) goto <D.4790>; else goto <D.4791>;
  <D.4790>:
  next->prev = node;
  <D.4791>:
  D.4792 = node;
  return D.4792;
}


monoeg_g_list_free_1 (struct GList * list)
{
  monoeg_g_free (list);
}


monoeg_g_list_free (struct GList * list)
{
  goto <D.4593>;
  <D.4592>:
  {
    struct GList * next;

    next = list->next;
    monoeg_g_list_free_1 (list);
    list = next;
  }
  <D.4593>:
  if (list != 0B) goto <D.4592>; else goto <D.4594>;
  <D.4594>:
}


monoeg_g_list_append (struct GList * list, void * data)
{
  struct GList * D.4794;
  struct GList * D.4795;
  struct GList * iftmp.1;
  struct GList * node;

  D.4794 = monoeg_g_list_last (list);
  node = new_node (D.4794, data, 0B);
  if (list != 0B) goto <D.4797>; else goto <D.4798>;
  <D.4797>:
  iftmp.1 = list;
  goto <D.4799>;
  <D.4798>:
  iftmp.1 = node;
  <D.4799>:
  D.4795 = iftmp.1;
  return D.4795;
}


monoeg_g_list_concat (struct GList * list1, struct GList * list2)
{
  _Bool D.4801;
  _Bool D.4802;
  _Bool D.4803;
  struct GList * D.4806;
  struct GList * D.4807;
  struct GList * D.4808;
  struct GList * iftmp.2;

  D.4801 = list1 != 0B;
  D.4802 = list2 != 0B;
  D.4803 = D.4801 & D.4802;
  if (D.4803 != 0) goto <D.4804>; else goto <D.4805>;
  <D.4804>:
  D.4806 = monoeg_g_list_last (list1);
  list2->prev = D.4806;
  D.4807 = list2->prev;
  D.4807->next = list2;
  <D.4805>:
  if (list1 != 0B) goto <D.4810>; else goto <D.4811>;
  <D.4810>:
  iftmp.2 = list1;
  goto <D.4812>;
  <D.4811>:
  iftmp.2 = list2;
  <D.4812>:
  D.4808 = iftmp.2;
  return D.4808;
}


monoeg_g_list_length (struct GList * list)
{
  guint D.4814;
  guint length;

  length = 0;
  goto <D.4609>;
  <D.4608>:
  length = length + 1;
  list = list->next;
  <D.4609>:
  if (list != 0B) goto <D.4608>; else goto <D.4610>;
  <D.4610>:
  D.4814 = length;
  return D.4814;
}


monoeg_g_list_remove (struct GList * list, const void * data)
{
  struct GList * D.4818;
  struct GList * D.4821;
  struct GList * current;

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.4816>; else goto <D.4817>;
  <D.4816>:
  D.4818 = list;
  return D.4818;
  <D.4817>:
  if (current == list) goto <D.4819>; else goto <D.4820>;
  <D.4819>:
  list = list->next;
  <D.4820>:
  D.4821 = disconnect_node (current);
  monoeg_g_list_free_1 (D.4821);
  D.4818 = list;
  return D.4818;
}


disconnect_node (struct GList * node)
{
  struct GList * D.4823;
  struct GList * D.4826;
  struct GList * D.4829;

  D.4823 = node->next;
  if (D.4823 != 0B) goto <D.4824>; else goto <D.4825>;
  <D.4824>:
  D.4823 = node->next;
  D.4826 = node->prev;
  D.4823->prev = D.4826;
  <D.4825>:
  D.4826 = node->prev;
  if (D.4826 != 0B) goto <D.4827>; else goto <D.4828>;
  <D.4827>:
  D.4826 = node->prev;
  D.4823 = node->next;
  D.4826->next = D.4823;
  <D.4828>:
  D.4829 = node;
  return D.4829;
}


monoeg_g_list_remove_all (struct GList * list, const void * data)
{
  struct GList * D.4833;
  struct GList * D.4836;
  struct GList * current;

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.4831>; else goto <D.4832>;
  <D.4831>:
  D.4833 = list;
  return D.4833;
  <D.4832>:
  goto <D.4622>;
  <D.4621>:
  if (current == list) goto <D.4834>; else goto <D.4835>;
  <D.4834>:
  list = list->next;
  <D.4835>:
  D.4836 = disconnect_node (current);
  monoeg_g_list_free_1 (D.4836);
  current = monoeg_g_list_find (list, data);
  <D.4622>:
  if (current != 0B) goto <D.4621>; else goto <D.4623>;
  <D.4623>:
  D.4833 = list;
  return D.4833;
}


monoeg_g_list_remove_link (struct GList * list, struct GList * link)
{
  struct GList * D.4840;

  if (list == link) goto <D.4838>; else goto <D.4839>;
  <D.4838>:
  list = list->next;
  <D.4839>:
  disconnect_node (link);
  link->next = 0B;
  link->prev = 0B;
  D.4840 = list;
  return D.4840;
}


monoeg_g_list_delete_link (struct GList * list, struct GList * link)
{
  struct GList * D.4842;

  list = monoeg_g_list_remove_link (list, link);
  monoeg_g_list_free_1 (link);
  D.4842 = list;
  return D.4842;
}


monoeg_g_list_find (struct GList * list, const void * data)
{
  void * D.4844;
  struct GList * D.4847;

  goto <D.4637>;
  <D.4636>:
  D.4844 = list->data;
  if (D.4844 == data) goto <D.4845>; else goto <D.4846>;
  <D.4845>:
  D.4847 = list;
  return D.4847;
  <D.4846>:
  list = list->next;
  <D.4637>:
  if (list != 0B) goto <D.4636>; else goto <D.4638>;
  <D.4638>:
  D.4847 = 0B;
  return D.4847;
}


monoeg_g_list_find_custom (struct GList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.4851;
  void * D.4852;
  int D.4853;

  if (func == 0B) goto <D.4849>; else goto <D.4850>;
  <D.4849>:
  D.4851 = 0B;
  return D.4851;
  <D.4850>:
  goto <D.4645>;
  <D.4644>:
  D.4852 = list->data;
  D.4853 = func (D.4852, data);
  if (D.4853 == 0) goto <D.4854>; else goto <D.4855>;
  <D.4854>:
  D.4851 = list;
  return D.4851;
  <D.4855>:
  list = list->next;
  <D.4645>:
  if (list != 0B) goto <D.4644>; else goto <D.4646>;
  <D.4646>:
  D.4851 = 0B;
  return D.4851;
}


monoeg_g_list_reverse (struct GList * list)
{
  struct GList * D.4857;
  struct GList * D.4858;
  struct GList * reverse;

  reverse = 0B;
  goto <D.4652>;
  <D.4651>:
  reverse = list;
  list = reverse->next;
  D.4857 = reverse->prev;
  reverse->next = D.4857;
  reverse->prev = list;
  <D.4652>:
  if (list != 0B) goto <D.4651>; else goto <D.4653>;
  <D.4653>:
  D.4858 = reverse;
  return D.4858;
}


monoeg_g_list_first (struct GList * list)
{
  struct GList * D.4862;
  struct GList * D.4863;

  if (list == 0B) goto <D.4860>; else goto <D.4861>;
  <D.4860>:
  D.4862 = 0B;
  return D.4862;
  <D.4861>:
  goto <D.4658>;
  <D.4657>:
  list = list->prev;
  <D.4658>:
  D.4863 = list->prev;
  if (D.4863 != 0B) goto <D.4657>; else goto <D.4659>;
  <D.4659>:
  D.4862 = list;
  return D.4862;
}


monoeg_g_list_last (struct GList * list)
{
  struct GList * D.4867;
  struct GList * D.4868;

  if (list == 0B) goto <D.4865>; else goto <D.4866>;
  <D.4865>:
  D.4867 = 0B;
  return D.4867;
  <D.4866>:
  goto <D.4664>;
  <D.4663>:
  list = list->next;
  <D.4664>:
  D.4868 = list->next;
  if (D.4868 != 0B) goto <D.4663>; else goto <D.4665>;
  <D.4665>:
  D.4867 = list;
  return D.4867;
}


monoeg_g_list_insert_sorted (struct GList * list, void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.4872;
  void * D.4873;
  int D.4874;
  struct GList * iftmp.3;
  struct GList * prev;
  struct GList * current;
  struct GList * node;

  prev = 0B;
  if (func == 0B) goto <D.4870>; else goto <D.4871>;
  <D.4870>:
  D.4872 = list;
  return D.4872;
  <D.4871>:
  current = list;
  goto <D.4676>;
  <D.4675>:
  D.4873 = current->data;
  D.4874 = func (D.4873, data);
  if (D.4874 > 0) goto <D.4674>; else goto <D.4875>;
  <D.4875>:
  prev = current;
  current = current->next;
  <D.4676>:
  if (current != 0B) goto <D.4675>; else goto <D.4674>;
  <D.4674>:
  node = new_node (prev, data, current);
  if (list == current) goto <D.4877>; else goto <D.4878>;
  <D.4877>:
  iftmp.3 = node;
  goto <D.4879>;
  <D.4878>:
  iftmp.3 = list;
  <D.4879>:
  D.4872 = iftmp.3;
  return D.4872;
}


monoeg_g_list_insert_before (struct GList * list, struct GList * sibling, void * data)
{
  struct GList * D.4883;
  struct GList * D.4884;
  struct GList * iftmp.4;

  if (sibling != 0B) goto <D.4881>; else goto <D.4882>;
  <D.4881>:
  {
    struct GList * node;

    D.4883 = sibling->prev;
    node = new_node (D.4883, data, sibling);
    if (list == sibling) goto <D.4886>; else goto <D.4887>;
    <D.4886>:
    iftmp.4 = node;
    goto <D.4888>;
    <D.4887>:
    iftmp.4 = list;
    <D.4888>:
    D.4884 = iftmp.4;
    return D.4884;
  }
  <D.4882>:
  D.4884 = monoeg_g_list_append (list, data);
  return D.4884;
}


monoeg_g_list_foreach (struct GList * list, void (*GFunc) (void *, void *) func, void * user_data)
{
  void * D.4890;

  goto <D.4689>;
  <D.4688>:
  D.4890 = list->data;
  func (D.4890, user_data);
  list = list->next;
  <D.4689>:
  if (list != 0B) goto <D.4688>; else goto <D.4690>;
  <D.4690>:
}


monoeg_g_list_index (struct GList * list, const void * data)
{
  void * D.4891;
  gint D.4894;
  gint index;

  index = 0;
  goto <D.4697>;
  <D.4696>:
  D.4891 = list->data;
  if (D.4891 == data) goto <D.4892>; else goto <D.4893>;
  <D.4892>:
  D.4894 = index;
  return D.4894;
  <D.4893>:
  index = index + 1;
  list = list->next;
  <D.4697>:
  if (list != 0B) goto <D.4696>; else goto <D.4698>;
  <D.4698>:
  D.4894 = -1;
  return D.4894;
}


monoeg_g_list_nth (struct GList * list, guint n)
{
  struct GList * D.4897;

  goto <D.4705>;
  <D.4704>:
  if (n == 0) goto <D.4703>; else goto <D.4896>;
  <D.4896>:
  n = n + 4294967295;
  list = list->next;
  <D.4705>:
  if (list != 0B) goto <D.4704>; else goto <D.4703>;
  <D.4703>:
  D.4897 = list;
  return D.4897;
}


monoeg_g_list_nth_data (struct GList * list, guint n)
{
  void * D.4899;
  void * iftmp.5;
  struct GList * node;

  node = monoeg_g_list_nth (list, n);
  if (node != 0B) goto <D.4901>; else goto <D.4902>;
  <D.4901>:
  iftmp.5 = node->data;
  goto <D.4903>;
  <D.4902>:
  iftmp.5 = 0B;
  <D.4903>:
  D.4899 = iftmp.5;
  return D.4899;
}


monoeg_g_list_copy (struct GList * list)
{
  void * D.4907;
  struct GList * D.4908;
  struct GList * copy;

  copy = 0B;
  if (list != 0B) goto <D.4905>; else goto <D.4906>;
  <D.4905>:
  {
    struct GList * tmp;

    D.4907 = list->data;
    tmp = new_node (0B, D.4907, 0B);
    copy = tmp;
    list = list->next;
    goto <D.4717>;
    <D.4716>:
    D.4907 = list->data;
    tmp = new_node (tmp, D.4907, 0B);
    list = list->next;
    <D.4717>:
    if (list != 0B) goto <D.4716>; else goto <D.4718>;
    <D.4718>:
  }
  <D.4906>:
  D.4908 = copy;
  return D.4908;
}


monoeg_g_list_sort (struct GList * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.4913;
  struct GList * D.4914;
  struct GList * D.4915;
  struct GList * current;

  if (list == 0B) goto <D.4910>; else goto <D.4912>;
  <D.4912>:
  D.4913 = list->next;
  if (D.4913 == 0B) goto <D.4910>; else goto <D.4911>;
  <D.4910>:
  D.4914 = list;
  return D.4914;
  <D.4911>:
  list = do_sort (list, func);
  list->prev = 0B;
  current = list;
  goto <D.4777>;
  <D.4776>:
  D.4915 = current->next;
  D.4915->prev = current;
  current = current->next;
  <D.4777>:
  D.4915 = current->next;
  if (D.4915 != 0B) goto <D.4776>; else goto <D.4778>;
  <D.4778>:
  D.4914 = list;
  return D.4914;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.4917;
  void * D.4918;
  int D.4919;
  struct GList * D.4923;
  struct list_node * D.4924;
  int D.4925;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.4917 = next->data;
        D.4918 = list->data;
        D.4919 = func (D.4918, D.4917);
        if (D.4919 > 0) goto <D.4920>; else goto <D.4921>;
        <D.4920>:
        next->next = list;
        next = list;
        list = list->next;
        <D.4921>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.4769>:
      if (list != 0B) goto <D.4922>; else goto <D.4770>;
      <D.4922>:
      D.4923 = list->next;
      if (D.4923 != 0B) goto <D.4768>; else goto <D.4770>;
      <D.4770>:
      D.4925 = si.n_ranks;
      D.4924 = sweep_up (&si, list, D.4925);
      return D.4924;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.4929;
  unsigned int rank.6;
  gint (*<Tb99>) (const void *, const void *) D.4935;
  struct list_node * D.4936;
  struct list_node * D.4940;
  struct list_node * D.4941;
  int D.4947;
  int i;

  D.4929 = si->n_ranks;
  if (D.4929 < rank) goto <D.4930>; else goto <D.4931>;
  <D.4930>:
  rank.6 = (unsigned int) rank;
  if (rank.6 > 28) goto <D.4933>; else goto <D.4934>;
  <D.4933>:
  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.4934>:
  D.4935 = si->func;
  D.4929 = si->n_ranks;
  D.4936 = sweep_up (si, 0B, D.4929);
  list = merge_lists (D.4936, list, D.4935);
  i = si->n_ranks;
  goto <D.4756>;
  <D.4755>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4756>:
  if (i < rank) goto <D.4755>; else goto <D.4757>;
  <D.4757>:
  goto <D.4937>;
  <D.4931>:
  if (rank != 0) goto <D.4938>; else goto <D.4939>;
  <D.4938>:
  D.4935 = si->func;
  D.4940 = sweep_up (si, 0B, rank);
  list = merge_lists (D.4940, list, D.4935);
  <D.4939>:
  i = rank;
  goto <D.4759>;
  <D.4758>:
  D.4935 = si->func;
  D.4941 = si->ranks[i];
  list = merge_lists (D.4941, list, D.4935);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4759>:
  D.4929 = si->n_ranks;
  if (D.4929 > i) goto <D.4942>; else goto <D.4760>;
  <D.4942>:
  D.4941 = si->ranks[i];
  if (D.4941 != 0B) goto <D.4758>; else goto <D.4760>;
  <D.4760>:
  <D.4937>:
  if (i == 28) goto <D.4943>; else goto <D.4944>;
  <D.4943>:
  i = i + -1;
  <D.4944>:
  D.4929 = si->n_ranks;
  if (D.4929 <= i) goto <D.4945>; else goto <D.4946>;
  <D.4945>:
  D.4947 = i + 1;
  si->n_ranks = D.4947;
  <D.4946>:
  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.4948;
  void * D.4949;
  int D.4950;
  struct list_node * D.4954;
  _Bool D.4955;
  _Bool D.4956;
  _Bool D.4957;
  struct list_node * iftmp.7;
  struct list_node * D.4962;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.4738>;
      <D.4737>:
      D.4948 = second->data;
      D.4949 = first->data;
      D.4950 = func (D.4949, D.4948);
      if (D.4950 > 0) goto <D.4951>; else goto <D.4952>;
      <D.4951>:
      *pos = second;
      second = second->next;
      goto <D.4953>;
      <D.4952>:
      *pos = first;
      first = first->next;
      <D.4953>:
      D.4954 = *pos;
      pos = &D.4954->next;
      <D.4738>:
      D.4955 = first != 0B;
      D.4956 = second != 0B;
      D.4957 = D.4955 & D.4956;
      if (D.4957 != 0) goto <D.4737>; else goto <D.4739>;
      <D.4739>:
      if (first != 0B) goto <D.4959>; else goto <D.4960>;
      <D.4959>:
      iftmp.7 = first;
      goto <D.4961>;
      <D.4960>:
      iftmp.7 = second;
      <D.4961>:
      *pos = iftmp.7;
      D.4962 = list;
      return D.4962;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  gint (*<Tb99>) (const void *, const void *) D.4965;
  struct list_node * D.4966;
  struct list_node * D.4967;
  int i;

  i = si->min_rank;
  goto <D.4747>;
  <D.4746>:
  D.4965 = si->func;
  D.4966 = si->ranks[i];
  list = merge_lists (D.4966, list, D.4965);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4747>:
  if (i < upto) goto <D.4746>; else goto <D.4748>;
  <D.4748>:
  D.4967 = list;
  return D.4967;
}