monoeg_g_slist_alloc ()
{
  struct GSList * D.5651;

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


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


monoeg_g_slist_append (struct GSList * list, void * data)
{
  struct GSList * D.5653;
  struct GSList * D.5654;

  D.5654 = monoeg_g_slist_prepend (0B, data);
  D.5653 = monoeg_g_slist_concat (list, D.5654);
  return D.5653;
}


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

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


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

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


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

  prev = 0B;
  goto <D.5468>;
  <D.5467>:
  if (list == link) goto <D.5466>; else goto <D.5662>;
  <D.5662>:
  prev = list;
  list = list->next;
  <D.5468>:
  if (list != 0B) goto <D.5467>; else goto <D.5466>;
  <D.5466>:
  D.5663 = prev;
  return D.5663;
}


insert_after (struct GSList * list, void * data)
{
  struct GSList * D.5665;
  struct GSList * D.5666;
  struct GSList * D.5667;

  D.5665 = list->next;
  D.5666 = monoeg_g_slist_prepend (D.5665, data);
  list->next = D.5666;
  D.5667 = list->next;
  return D.5667;
}


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

    next = list->next;
    monoeg_g_slist_free_1 (list);
    list = next;
  }
  <D.5480>:
  if (list != 0B) goto <D.5479>; else goto <D.5481>;
  <D.5481>:
}


monoeg_g_slist_copy (struct GSList * list)
{
  struct GSList * D.5671;
  void * D.5672;
  struct GSList * copy;
  struct GSList * tmp;

  if (list == 0B) goto <D.5669>; else goto <D.5670>;
  <D.5669>:
  D.5671 = 0B;
  return D.5671;
  <D.5670>:
  D.5672 = list->data;
  copy = monoeg_g_slist_prepend (0B, D.5672);
  tmp = copy;
  list = list->next;
  goto <D.5488>;
  <D.5487>:
  D.5672 = list->data;
  tmp = insert_after (tmp, D.5672);
  list = list->next;
  <D.5488>:
  if (list != 0B) goto <D.5487>; else goto <D.5489>;
  <D.5489>:
  D.5671 = copy;
  return D.5671;
}


monoeg_g_slist_concat (struct GSList * list1, struct GSList * list2)
{
  struct GSList * D.5676;
  struct GSList * D.5677;

  if (list1 == 0B) goto <D.5674>; else goto <D.5675>;
  <D.5674>:
  D.5676 = list2;
  return D.5676;
  <D.5675>:
  D.5677 = monoeg_g_slist_last (list1);
  D.5677->next = list2;
  D.5676 = list1;
  return D.5676;
}


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

  goto <D.5500>;
  <D.5499>:
  D.5679 = list->data;
  func (D.5679, user_data);
  list = list->next;
  <D.5500>:
  if (list != 0B) goto <D.5499>; else goto <D.5501>;
  <D.5501>:
}


monoeg_g_slist_last (struct GSList * list)
{
  struct GSList * D.5682;
  struct GSList * D.5683;

  if (list == 0B) goto <D.5680>; else goto <D.5681>;
  <D.5680>:
  D.5682 = 0B;
  return D.5682;
  <D.5681>:
  goto <D.5506>;
  <D.5505>:
  list = list->next;
  <D.5506>:
  D.5683 = list->next;
  if (D.5683 != 0B) goto <D.5505>; else goto <D.5507>;
  <D.5507>:
  D.5682 = list;
  return D.5682;
}


monoeg_g_slist_find (struct GSList * list, const void * data)
{
  void * D.5685;
  struct GSList * D.5687;

  goto <D.5514>;
  <D.5513>:
  D.5685 = list->data;
  if (D.5685 == data) goto <D.5512>; else goto <D.5686>;
  <D.5686>:
  list = list->next;
  <D.5514>:
  if (list != 0B) goto <D.5513>; else goto <D.5512>;
  <D.5512>:
  D.5687 = list;
  return D.5687;
}


monoeg_g_slist_find_custom (struct GSList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.5691;
  void * D.5692;
  int D.5693;

  if (func == 0B) goto <D.5689>; else goto <D.5690>;
  <D.5689>:
  D.5691 = 0B;
  return D.5691;
  <D.5690>:
  goto <D.5521>;
  <D.5520>:
  D.5692 = list->data;
  D.5693 = func (D.5692, data);
  if (D.5693 == 0) goto <D.5694>; else goto <D.5695>;
  <D.5694>:
  D.5691 = list;
  return D.5691;
  <D.5695>:
  list = list->next;
  <D.5521>:
  if (list != 0B) goto <D.5520>; else goto <D.5522>;
  <D.5522>:
  D.5691 = 0B;
  return D.5691;
}


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

  length = 0;
  goto <D.5528>;
  <D.5527>:
  length = length + 1;
  list = list->next;
  <D.5528>:
  if (list != 0B) goto <D.5527>; else goto <D.5529>;
  <D.5529>:
  D.5697 = length;
  return D.5697;
}


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

  prev = find_prev (list, data);
  if (prev != 0B) goto <D.5700>; else goto <D.5701>;
  <D.5700>:
  iftmp.0 = prev->next;
  goto <D.5702>;
  <D.5701>:
  iftmp.0 = list;
  <D.5702>:
  current = iftmp.0;
  if (current != 0B) goto <D.5703>; else goto <D.5704>;
  <D.5703>:
  if (prev != 0B) goto <D.5705>; else goto <D.5706>;
  <D.5705>:
  D.5707 = current->next;
  prev->next = D.5707;
  goto <D.5708>;
  <D.5706>:
  list = current->next;
  <D.5708>:
  monoeg_g_slist_free_1 (current);
  <D.5704>:
  D.5709 = list;
  return D.5709;
}


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

  prev = 0B;
  goto <D.5460>;
  <D.5459>:
  D.5711 = list->data;
  if (D.5711 == data) goto <D.5458>; else goto <D.5712>;
  <D.5712>:
  prev = list;
  list = list->next;
  <D.5460>:
  if (list != 0B) goto <D.5459>; else goto <D.5458>;
  <D.5458>:
  D.5713 = prev;
  return D.5713;
}


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

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

    tmp_prev = find_prev (next, data);
    if (tmp_prev != 0B) goto <D.5715>; else goto <D.5716>;
    <D.5715>:
    prev = tmp_prev;
    <D.5716>:
    if (prev != 0B) goto <D.5718>; else goto <D.5719>;
    <D.5718>:
    iftmp.1 = prev->next;
    goto <D.5720>;
    <D.5719>:
    iftmp.1 = list;
    <D.5720>:
    current = iftmp.1;
    if (current == 0B) goto <D.5544>; else goto <D.5721>;
    <D.5721>:
    next = current->next;
    if (prev != 0B) goto <D.5722>; else goto <D.5723>;
    <D.5722>:
    prev->next = next;
    goto <D.5724>;
    <D.5723>:
    list = next;
    <D.5724>:
    monoeg_g_slist_free_1 (current);
  }
  <D.5546>:
  if (next != 0B) goto <D.5545>; else goto <D.5544>;
  <D.5544>:
  D.5725 = list;
  return D.5725;
}


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

  prev = find_prev_link (list, link);
  if (prev != 0B) goto <D.5728>; else goto <D.5729>;
  <D.5728>:
  iftmp.2 = prev->next;
  goto <D.5730>;
  <D.5729>:
  iftmp.2 = list;
  <D.5730>:
  current = iftmp.2;
  if (current != 0B) goto <D.5731>; else goto <D.5732>;
  <D.5731>:
  if (prev != 0B) goto <D.5733>; else goto <D.5734>;
  <D.5733>:
  D.5735 = current->next;
  prev->next = D.5735;
  goto <D.5736>;
  <D.5734>:
  list = current->next;
  <D.5736>:
  current->next = 0B;
  <D.5732>:
  D.5737 = list;
  return D.5737;
}


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

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


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

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

    next = list->next;
    list->next = prev;
    prev = list;
    list = next;
  }
  <D.5563>:
  if (list != 0B) goto <D.5562>; else goto <D.5564>;
  <D.5564>:
  D.5741 = prev;
  return D.5741;
}


monoeg_g_slist_insert_sorted (struct GSList * list, void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.5745;
  void * D.5749;
  int D.5750;
  struct GSList * D.5751;
  void * D.5752;
  int D.5753;
  struct GSList * prev;

  prev = 0B;
  if (func == 0B) goto <D.5743>; else goto <D.5744>;
  <D.5743>:
  D.5745 = list;
  return D.5745;
  <D.5744>:
  if (list == 0B) goto <D.5746>; else goto <D.5748>;
  <D.5748>:
  D.5749 = list->data;
  D.5750 = func (D.5749, data);
  if (D.5750 > 0) goto <D.5746>; else goto <D.5747>;
  <D.5746>:
  D.5745 = monoeg_g_slist_prepend (list, data);
  return D.5745;
  <D.5747>:
  prev = list;
  goto <D.5573>;
  <D.5572>:
  D.5751 = prev->next;
  D.5752 = D.5751->data;
  D.5753 = func (D.5752, data);
  if (D.5753 > 0) goto <D.5571>; else goto <D.5754>;
  <D.5754>:
  prev = prev->next;
  <D.5573>:
  D.5751 = prev->next;
  if (D.5751 != 0B) goto <D.5572>; else goto <D.5571>;
  <D.5571>:
  insert_after (prev, data);
  D.5745 = list;
  return D.5745;
}


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

  index = 0;
  goto <D.5580>;
  <D.5579>:
  D.5756 = list->data;
  if (D.5756 == data) goto <D.5757>; else goto <D.5758>;
  <D.5757>:
  D.5759 = index;
  return D.5759;
  <D.5758>:
  index = index + 1;
  list = list->next;
  <D.5580>:
  if (list != 0B) goto <D.5579>; else goto <D.5581>;
  <D.5581>:
  D.5759 = -1;
  return D.5759;
}


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

  goto <D.5588>;
  <D.5587>:
  if (n == 0) goto <D.5586>; else goto <D.5761>;
  <D.5761>:
  n = n + 4294967295;
  list = list->next;
  <D.5588>:
  if (list != 0B) goto <D.5587>; else goto <D.5586>;
  <D.5586>:
  D.5762 = list;
  return D.5762;
}


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

  node = monoeg_g_slist_nth (list, n);
  if (node != 0B) goto <D.5766>; else goto <D.5767>;
  <D.5766>:
  iftmp.3 = node->data;
  goto <D.5768>;
  <D.5767>:
  iftmp.3 = 0B;
  <D.5768>:
  D.5764 = iftmp.3;
  return D.5764;
}


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

  if (list == 0B) goto <D.5770>; else goto <D.5772>;
  <D.5772>:
  D.5773 = list->next;
  if (D.5773 == 0B) goto <D.5770>; else goto <D.5771>;
  <D.5770>:
  D.5774 = list;
  return D.5774;
  <D.5771>:
  D.5774 = do_sort (list, func);
  return D.5774;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.5776;
  void * D.5777;
  int D.5778;
  struct GSList * D.5782;
  struct list_node * D.5783;
  int D.5784;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.5776 = list->data;
        D.5777 = next->data;
        D.5778 = func (D.5776, D.5777);
        if (D.5778 > 0) goto <D.5779>; else goto <D.5780>;
        <D.5779>:
        next->next = list;
        next = list;
        list = list->next;
        <D.5780>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.5644>:
      if (list != 0B) goto <D.5781>; else goto <D.5645>;
      <D.5781>:
      D.5782 = list->next;
      if (D.5782 != 0B) goto <D.5643>; else goto <D.5645>;
      <D.5645>:
      D.5784 = si.n_ranks;
      D.5783 = sweep_up (&si, list, D.5784);
      return D.5783;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.5788;
  unsigned int rank.4;
  struct list_node * D.5794;
  gint (*<Tc8d>) (const void *, const void *) D.5795;
  struct list_node * D.5799;
  struct list_node * D.5800;
  int D.5806;
  int i;

  D.5788 = si->n_ranks;
  if (D.5788 < rank) goto <D.5789>; else goto <D.5790>;
  <D.5789>:
  rank.4 = (unsigned int) rank;
  if (rank.4 > 59) goto <D.5792>; else goto <D.5793>;
  <D.5792>:
  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.5793>:
  D.5788 = si->n_ranks;
  D.5794 = sweep_up (si, 0B, D.5788);
  D.5795 = si->func;
  list = merge_lists (D.5794, list, D.5795);
  i = si->n_ranks;
  goto <D.5631>;
  <D.5630>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5631>:
  if (i < rank) goto <D.5630>; else goto <D.5632>;
  <D.5632>:
  goto <D.5796>;
  <D.5790>:
  if (rank != 0) goto <D.5797>; else goto <D.5798>;
  <D.5797>:
  D.5799 = sweep_up (si, 0B, rank);
  D.5795 = si->func;
  list = merge_lists (D.5799, list, D.5795);
  <D.5798>:
  i = rank;
  goto <D.5634>;
  <D.5633>:
  D.5800 = si->ranks[i];
  D.5795 = si->func;
  list = merge_lists (D.5800, list, D.5795);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5634>:
  D.5788 = si->n_ranks;
  if (D.5788 > i) goto <D.5801>; else goto <D.5635>;
  <D.5801>:
  D.5800 = si->ranks[i];
  if (D.5800 != 0B) goto <D.5633>; else goto <D.5635>;
  <D.5635>:
  <D.5796>:
  if (i == 59) goto <D.5802>; else goto <D.5803>;
  <D.5802>:
  i = i + -1;
  <D.5803>:
  D.5788 = si->n_ranks;
  if (D.5788 <= i) goto <D.5804>; else goto <D.5805>;
  <D.5804>:
  D.5806 = i + 1;
  si->n_ranks = D.5806;
  <D.5805>:
  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.5807;
  void * D.5808;
  int D.5809;
  struct list_node * D.5813;
  struct list_node * iftmp.5;
  struct list_node * D.5819;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.5613>;
      <D.5612>:
      D.5807 = first->data;
      D.5808 = second->data;
      D.5809 = func (D.5807, D.5808);
      if (D.5809 > 0) goto <D.5810>; else goto <D.5811>;
      <D.5810>:
      *pos = second;
      second = second->next;
      goto <D.5812>;
      <D.5811>:
      *pos = first;
      first = first->next;
      <D.5812>:
      D.5813 = *pos;
      pos = &D.5813->next;
      <D.5613>:
      if (first != 0B) goto <D.5814>; else goto <D.5614>;
      <D.5814>:
      if (second != 0B) goto <D.5612>; else goto <D.5614>;
      <D.5614>:
      if (first != 0B) goto <D.5816>; else goto <D.5817>;
      <D.5816>:
      iftmp.5 = first;
      goto <D.5818>;
      <D.5817>:
      iftmp.5 = second;
      <D.5818>:
      *pos = iftmp.5;
      D.5819 = list;
      return D.5819;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  struct list_node * D.5822;
  gint (*<Tc8d>) (const void *, const void *) D.5823;
  struct list_node * D.5824;
  int i;

  i = si->min_rank;
  goto <D.5622>;
  <D.5621>:
  D.5822 = si->ranks[i];
  D.5823 = si->func;
  list = merge_lists (D.5822, list, D.5823);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5622>:
  if (i < upto) goto <D.5621>; else goto <D.5623>;
  <D.5623>:
  D.5824 = list;
  return D.5824;
}