monoeg_g_list_alloc ()
{
  struct GList * D.4800;

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


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

  if (list != 0B) goto <D.4804>; else goto <D.4805>;
  <D.4804>:
  iftmp.0 = list->prev;
  goto <D.4806>;
  <D.4805>:
  iftmp.0 = 0B;
  <D.4806>:
  D.4802 = new_node (iftmp.0, data, list);
  return D.4802;
}


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

  node = monoeg_g_list_alloc ();
  node->data = data;
  node->prev = prev;
  node->next = next;
  if (prev != 0B) goto <D.4808>; else goto <D.4809>;
  <D.4808>:
  prev->next = node;
  <D.4809>:
  if (next != 0B) goto <D.4810>; else goto <D.4811>;
  <D.4810>:
  next->prev = node;
  <D.4811>:
  D.4812 = node;
  return D.4812;
}


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


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

    next = list->next;
    monoeg_g_list_free_1 (list);
    list = next;
  }
  <D.4613>:
  if (list != 0B) goto <D.4612>; else goto <D.4614>;
  <D.4614>:
}


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

  D.4814 = monoeg_g_list_last (list);
  node = new_node (D.4814, data, 0B);
  if (list != 0B) goto <D.4817>; else goto <D.4818>;
  <D.4817>:
  iftmp.1 = list;
  goto <D.4819>;
  <D.4818>:
  iftmp.1 = node;
  <D.4819>:
  D.4815 = iftmp.1;
  return D.4815;
}


monoeg_g_list_concat (struct GList * list1, struct GList * list2)
{
  struct GList * D.4825;
  struct GList * D.4826;
  struct GList * D.4827;
  struct GList * iftmp.2;

  if (list1 != 0B) goto <D.4821>; else goto <D.4822>;
  <D.4821>:
  if (list2 != 0B) goto <D.4823>; else goto <D.4824>;
  <D.4823>:
  D.4825 = monoeg_g_list_last (list1);
  list2->prev = D.4825;
  D.4826 = list2->prev;
  D.4826->next = list2;
  <D.4824>:
  <D.4822>:
  if (list1 != 0B) goto <D.4829>; else goto <D.4830>;
  <D.4829>:
  iftmp.2 = list1;
  goto <D.4831>;
  <D.4830>:
  iftmp.2 = list2;
  <D.4831>:
  D.4827 = iftmp.2;
  return D.4827;
}


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

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


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

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.4835>; else goto <D.4836>;
  <D.4835>:
  D.4837 = list;
  return D.4837;
  <D.4836>:
  if (current == list) goto <D.4838>; else goto <D.4839>;
  <D.4838>:
  list = list->next;
  <D.4839>:
  D.4840 = disconnect_node (current);
  monoeg_g_list_free_1 (D.4840);
  D.4837 = list;
  return D.4837;
}


disconnect_node (struct GList * node)
{
  struct GList * D.4842;
  struct GList * D.4845;
  struct GList * D.4848;

  D.4842 = node->next;
  if (D.4842 != 0B) goto <D.4843>; else goto <D.4844>;
  <D.4843>:
  D.4842 = node->next;
  D.4845 = node->prev;
  D.4842->prev = D.4845;
  <D.4844>:
  D.4845 = node->prev;
  if (D.4845 != 0B) goto <D.4846>; else goto <D.4847>;
  <D.4846>:
  D.4845 = node->prev;
  D.4842 = node->next;
  D.4845->next = D.4842;
  <D.4847>:
  D.4848 = node;
  return D.4848;
}


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

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.4850>; else goto <D.4851>;
  <D.4850>:
  D.4852 = list;
  return D.4852;
  <D.4851>:
  goto <D.4642>;
  <D.4641>:
  if (current == list) goto <D.4853>; else goto <D.4854>;
  <D.4853>:
  list = list->next;
  <D.4854>:
  D.4855 = disconnect_node (current);
  monoeg_g_list_free_1 (D.4855);
  current = monoeg_g_list_find (list, data);
  <D.4642>:
  if (current != 0B) goto <D.4641>; else goto <D.4643>;
  <D.4643>:
  D.4852 = list;
  return D.4852;
}


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

  if (list == link) goto <D.4857>; else goto <D.4858>;
  <D.4857>:
  list = list->next;
  <D.4858>:
  disconnect_node (link);
  link->next = 0B;
  link->prev = 0B;
  D.4859 = list;
  return D.4859;
}


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

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


monoeg_g_list_find (struct GList * list, const void * data)
{
  void * D.4863;
  struct GList * D.4866;

  goto <D.4657>;
  <D.4656>:
  D.4863 = list->data;
  if (D.4863 == data) goto <D.4864>; else goto <D.4865>;
  <D.4864>:
  D.4866 = list;
  return D.4866;
  <D.4865>:
  list = list->next;
  <D.4657>:
  if (list != 0B) goto <D.4656>; else goto <D.4658>;
  <D.4658>:
  D.4866 = 0B;
  return D.4866;
}


monoeg_g_list_find_custom (struct GList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.4870;
  void * D.4871;
  int D.4872;

  if (func == 0B) goto <D.4868>; else goto <D.4869>;
  <D.4868>:
  D.4870 = 0B;
  return D.4870;
  <D.4869>:
  goto <D.4665>;
  <D.4664>:
  D.4871 = list->data;
  D.4872 = func (D.4871, data);
  if (D.4872 == 0) goto <D.4873>; else goto <D.4874>;
  <D.4873>:
  D.4870 = list;
  return D.4870;
  <D.4874>:
  list = list->next;
  <D.4665>:
  if (list != 0B) goto <D.4664>; else goto <D.4666>;
  <D.4666>:
  D.4870 = 0B;
  return D.4870;
}


monoeg_g_list_reverse (struct GList * list)
{
  struct GList * D.4876;
  struct GList * D.4877;
  struct GList * reverse;

  reverse = 0B;
  goto <D.4672>;
  <D.4671>:
  reverse = list;
  list = reverse->next;
  D.4876 = reverse->prev;
  reverse->next = D.4876;
  reverse->prev = list;
  <D.4672>:
  if (list != 0B) goto <D.4671>; else goto <D.4673>;
  <D.4673>:
  D.4877 = reverse;
  return D.4877;
}


monoeg_g_list_first (struct GList * list)
{
  struct GList * D.4881;
  struct GList * D.4882;

  if (list == 0B) goto <D.4879>; else goto <D.4880>;
  <D.4879>:
  D.4881 = 0B;
  return D.4881;
  <D.4880>:
  goto <D.4678>;
  <D.4677>:
  list = list->prev;
  <D.4678>:
  D.4882 = list->prev;
  if (D.4882 != 0B) goto <D.4677>; else goto <D.4679>;
  <D.4679>:
  D.4881 = list;
  return D.4881;
}


monoeg_g_list_last (struct GList * list)
{
  struct GList * D.4886;
  struct GList * D.4887;

  if (list == 0B) goto <D.4884>; else goto <D.4885>;
  <D.4884>:
  D.4886 = 0B;
  return D.4886;
  <D.4885>:
  goto <D.4684>;
  <D.4683>:
  list = list->next;
  <D.4684>:
  D.4887 = list->next;
  if (D.4887 != 0B) goto <D.4683>; else goto <D.4685>;
  <D.4685>:
  D.4886 = list;
  return D.4886;
}


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

  prev = 0B;
  if (func == 0B) goto <D.4889>; else goto <D.4890>;
  <D.4889>:
  D.4891 = list;
  return D.4891;
  <D.4890>:
  current = list;
  goto <D.4696>;
  <D.4695>:
  D.4892 = current->data;
  D.4893 = func (D.4892, data);
  if (D.4893 > 0) goto <D.4694>; else goto <D.4894>;
  <D.4894>:
  prev = current;
  current = current->next;
  <D.4696>:
  if (current != 0B) goto <D.4695>; else goto <D.4694>;
  <D.4694>:
  node = new_node (prev, data, current);
  if (list == current) goto <D.4896>; else goto <D.4897>;
  <D.4896>:
  iftmp.3 = node;
  goto <D.4898>;
  <D.4897>:
  iftmp.3 = list;
  <D.4898>:
  D.4891 = iftmp.3;
  return D.4891;
}


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

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

    D.4902 = sibling->prev;
    node = new_node (D.4902, data, sibling);
    if (list == sibling) goto <D.4905>; else goto <D.4906>;
    <D.4905>:
    iftmp.4 = node;
    goto <D.4907>;
    <D.4906>:
    iftmp.4 = list;
    <D.4907>:
    D.4903 = iftmp.4;
    return D.4903;
  }
  <D.4901>:
  D.4903 = monoeg_g_list_append (list, data);
  return D.4903;
}


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

  goto <D.4709>;
  <D.4708>:
  D.4909 = list->data;
  func (D.4909, user_data);
  list = list->next;
  <D.4709>:
  if (list != 0B) goto <D.4708>; else goto <D.4710>;
  <D.4710>:
}


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

  index = 0;
  goto <D.4717>;
  <D.4716>:
  D.4910 = list->data;
  if (D.4910 == data) goto <D.4911>; else goto <D.4912>;
  <D.4911>:
  D.4913 = index;
  return D.4913;
  <D.4912>:
  index = index + 1;
  list = list->next;
  <D.4717>:
  if (list != 0B) goto <D.4716>; else goto <D.4718>;
  <D.4718>:
  D.4913 = -1;
  return D.4913;
}


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

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


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

  node = monoeg_g_list_nth (list, n);
  if (node != 0B) goto <D.4920>; else goto <D.4921>;
  <D.4920>:
  iftmp.5 = node->data;
  goto <D.4922>;
  <D.4921>:
  iftmp.5 = 0B;
  <D.4922>:
  D.4918 = iftmp.5;
  return D.4918;
}


monoeg_g_list_copy (struct GList * list)
{
  void * D.4926;
  struct GList * D.4927;
  struct GList * copy;

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

    D.4926 = list->data;
    tmp = new_node (0B, D.4926, 0B);
    copy = tmp;
    list = list->next;
    goto <D.4737>;
    <D.4736>:
    D.4926 = list->data;
    tmp = new_node (tmp, D.4926, 0B);
    list = list->next;
    <D.4737>:
    if (list != 0B) goto <D.4736>; else goto <D.4738>;
    <D.4738>:
  }
  <D.4925>:
  D.4927 = copy;
  return D.4927;
}


monoeg_g_list_sort (struct GList * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.4932;
  struct GList * D.4933;
  struct GList * D.4934;
  struct GList * current;

  if (list == 0B) goto <D.4929>; else goto <D.4931>;
  <D.4931>:
  D.4932 = list->next;
  if (D.4932 == 0B) goto <D.4929>; else goto <D.4930>;
  <D.4929>:
  D.4933 = list;
  return D.4933;
  <D.4930>:
  list = do_sort (list, func);
  list->prev = 0B;
  current = list;
  goto <D.4797>;
  <D.4796>:
  D.4934 = current->next;
  D.4934->prev = current;
  current = current->next;
  <D.4797>:
  D.4934 = current->next;
  if (D.4934 != 0B) goto <D.4796>; else goto <D.4798>;
  <D.4798>:
  D.4933 = list;
  return D.4933;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.4936;
  void * D.4937;
  int D.4938;
  struct GList * D.4942;
  struct list_node * D.4943;
  int D.4944;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.4936 = list->data;
        D.4937 = next->data;
        D.4938 = func (D.4936, D.4937);
        if (D.4938 > 0) goto <D.4939>; else goto <D.4940>;
        <D.4939>:
        next->next = list;
        next = list;
        list = list->next;
        <D.4940>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.4789>:
      if (list != 0B) goto <D.4941>; else goto <D.4790>;
      <D.4941>:
      D.4942 = list->next;
      if (D.4942 != 0B) goto <D.4788>; else goto <D.4790>;
      <D.4790>:
      D.4944 = si.n_ranks;
      D.4943 = sweep_up (&si, list, D.4944);
      return D.4943;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.4948;
  unsigned int rank.6;
  struct list_node * D.4954;
  gint (*<Tba2>) (const void *, const void *) D.4955;
  struct list_node * D.4959;
  struct list_node * D.4960;
  int D.4966;
  int i;

  D.4948 = si->n_ranks;
  if (D.4948 < rank) goto <D.4949>; else goto <D.4950>;
  <D.4949>:
  rank.6 = (unsigned int) rank;
  if (rank.6 > 28) goto <D.4952>; else goto <D.4953>;
  <D.4952>:
  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.4953>:
  D.4948 = si->n_ranks;
  D.4954 = sweep_up (si, 0B, D.4948);
  D.4955 = si->func;
  list = merge_lists (D.4954, list, D.4955);
  i = si->n_ranks;
  goto <D.4776>;
  <D.4775>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4776>:
  if (i < rank) goto <D.4775>; else goto <D.4777>;
  <D.4777>:
  goto <D.4956>;
  <D.4950>:
  if (rank != 0) goto <D.4957>; else goto <D.4958>;
  <D.4957>:
  D.4959 = sweep_up (si, 0B, rank);
  D.4955 = si->func;
  list = merge_lists (D.4959, list, D.4955);
  <D.4958>:
  i = rank;
  goto <D.4779>;
  <D.4778>:
  D.4960 = si->ranks[i];
  D.4955 = si->func;
  list = merge_lists (D.4960, list, D.4955);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4779>:
  D.4948 = si->n_ranks;
  if (D.4948 > i) goto <D.4961>; else goto <D.4780>;
  <D.4961>:
  D.4960 = si->ranks[i];
  if (D.4960 != 0B) goto <D.4778>; else goto <D.4780>;
  <D.4780>:
  <D.4956>:
  if (i == 28) goto <D.4962>; else goto <D.4963>;
  <D.4962>:
  i = i + -1;
  <D.4963>:
  D.4948 = si->n_ranks;
  if (D.4948 <= i) goto <D.4964>; else goto <D.4965>;
  <D.4964>:
  D.4966 = i + 1;
  si->n_ranks = D.4966;
  <D.4965>:
  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.4967;
  void * D.4968;
  int D.4969;
  struct list_node * D.4973;
  struct list_node * iftmp.7;
  struct list_node * D.4979;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.4758>;
      <D.4757>:
      D.4967 = first->data;
      D.4968 = second->data;
      D.4969 = func (D.4967, D.4968);
      if (D.4969 > 0) goto <D.4970>; else goto <D.4971>;
      <D.4970>:
      *pos = second;
      second = second->next;
      goto <D.4972>;
      <D.4971>:
      *pos = first;
      first = first->next;
      <D.4972>:
      D.4973 = *pos;
      pos = &D.4973->next;
      <D.4758>:
      if (first != 0B) goto <D.4974>; else goto <D.4759>;
      <D.4974>:
      if (second != 0B) goto <D.4757>; else goto <D.4759>;
      <D.4759>:
      if (first != 0B) goto <D.4976>; else goto <D.4977>;
      <D.4976>:
      iftmp.7 = first;
      goto <D.4978>;
      <D.4977>:
      iftmp.7 = second;
      <D.4978>:
      *pos = iftmp.7;
      D.4979 = list;
      return D.4979;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  struct list_node * D.4982;
  gint (*<Tba2>) (const void *, const void *) D.4983;
  struct list_node * D.4984;
  int i;

  i = si->min_rank;
  goto <D.4767>;
  <D.4766>:
  D.4982 = si->ranks[i];
  D.4983 = si->func;
  list = merge_lists (D.4982, list, D.4983);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.4767>:
  if (i < upto) goto <D.4766>; else goto <D.4768>;
  <D.4768>:
  D.4984 = list;
  return D.4984;
}