monoeg_g_slist_alloc ()
{
  struct GSList * D.7396;

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


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


monoeg_g_slist_append (struct GSList * list, void * data)
{
  struct GSList * D.7398;
  struct GSList * D.7399;

  D.7399 = monoeg_g_slist_prepend (0B, data);
  D.7398 = monoeg_g_slist_concat (list, D.7399);
  return D.7398;
}


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

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


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

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


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

  prev = 0B;
  goto <D.7211>;
  <D.7210>:
  if (list == link) goto <D.7209>; else goto <D.7407>;
  <D.7407>:
  prev = list;
  list = list->next;
  <D.7211>:
  if (list != 0B) goto <D.7210>; else goto <D.7209>;
  <D.7209>:
  D.7408 = prev;
  return D.7408;
}


insert_after (struct GSList * list, void * data)
{
  struct GSList * D.7410;
  struct GSList * D.7411;
  struct GSList * D.7412;

  D.7410 = list->next;
  D.7411 = monoeg_g_slist_prepend (D.7410, data);
  list->next = D.7411;
  D.7412 = list->next;
  return D.7412;
}


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

    next = list->next;
    monoeg_g_slist_free_1 (list);
    list = next;
  }
  <D.7223>:
  if (list != 0B) goto <D.7222>; else goto <D.7224>;
  <D.7224>:
}


monoeg_g_slist_copy (struct GSList * list)
{
  struct GSList * D.7416;
  void * D.7417;
  struct GSList * copy;
  struct GSList * tmp;

  if (list == 0B) goto <D.7414>; else goto <D.7415>;
  <D.7414>:
  D.7416 = 0B;
  return D.7416;
  <D.7415>:
  D.7417 = list->data;
  copy = monoeg_g_slist_prepend (0B, D.7417);
  tmp = copy;
  list = list->next;
  goto <D.7231>;
  <D.7230>:
  D.7417 = list->data;
  tmp = insert_after (tmp, D.7417);
  list = list->next;
  <D.7231>:
  if (list != 0B) goto <D.7230>; else goto <D.7232>;
  <D.7232>:
  D.7416 = copy;
  return D.7416;
}


monoeg_g_slist_concat (struct GSList * list1, struct GSList * list2)
{
  struct GSList * D.7421;
  struct GSList * D.7422;

  if (list1 == 0B) goto <D.7419>; else goto <D.7420>;
  <D.7419>:
  D.7421 = list2;
  return D.7421;
  <D.7420>:
  D.7422 = monoeg_g_slist_last (list1);
  D.7422->next = list2;
  D.7421 = list1;
  return D.7421;
}


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

  goto <D.7243>;
  <D.7242>:
  D.7424 = list->data;
  func (D.7424, user_data);
  list = list->next;
  <D.7243>:
  if (list != 0B) goto <D.7242>; else goto <D.7244>;
  <D.7244>:
}


monoeg_g_slist_last (struct GSList * list)
{
  struct GSList * D.7427;
  struct GSList * D.7428;

  if (list == 0B) goto <D.7425>; else goto <D.7426>;
  <D.7425>:
  D.7427 = 0B;
  return D.7427;
  <D.7426>:
  goto <D.7249>;
  <D.7248>:
  list = list->next;
  <D.7249>:
  D.7428 = list->next;
  if (D.7428 != 0B) goto <D.7248>; else goto <D.7250>;
  <D.7250>:
  D.7427 = list;
  return D.7427;
}


monoeg_g_slist_find (struct GSList * list, const void * data)
{
  void * D.7430;
  struct GSList * D.7432;

  goto <D.7257>;
  <D.7256>:
  D.7430 = list->data;
  if (D.7430 == data) goto <D.7255>; else goto <D.7431>;
  <D.7431>:
  list = list->next;
  <D.7257>:
  if (list != 0B) goto <D.7256>; else goto <D.7255>;
  <D.7255>:
  D.7432 = list;
  return D.7432;
}


monoeg_g_slist_find_custom (struct GSList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.7436;
  void * D.7437;
  int D.7438;

  if (func == 0B) goto <D.7434>; else goto <D.7435>;
  <D.7434>:
  D.7436 = 0B;
  return D.7436;
  <D.7435>:
  goto <D.7264>;
  <D.7263>:
  D.7437 = list->data;
  D.7438 = func (D.7437, data);
  if (D.7438 == 0) goto <D.7439>; else goto <D.7440>;
  <D.7439>:
  D.7436 = list;
  return D.7436;
  <D.7440>:
  list = list->next;
  <D.7264>:
  if (list != 0B) goto <D.7263>; else goto <D.7265>;
  <D.7265>:
  D.7436 = 0B;
  return D.7436;
}


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

  length = 0;
  goto <D.7271>;
  <D.7270>:
  length = length + 1;
  list = list->next;
  <D.7271>:
  if (list != 0B) goto <D.7270>; else goto <D.7272>;
  <D.7272>:
  D.7442 = length;
  return D.7442;
}


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

  prev = find_prev (list, data);
  if (prev != 0B) goto <D.7445>; else goto <D.7446>;
  <D.7445>:
  iftmp.0 = prev->next;
  goto <D.7447>;
  <D.7446>:
  iftmp.0 = list;
  <D.7447>:
  current = iftmp.0;
  if (current != 0B) goto <D.7448>; else goto <D.7449>;
  <D.7448>:
  if (prev != 0B) goto <D.7450>; else goto <D.7451>;
  <D.7450>:
  D.7452 = current->next;
  prev->next = D.7452;
  goto <D.7453>;
  <D.7451>:
  list = current->next;
  <D.7453>:
  monoeg_g_slist_free_1 (current);
  <D.7449>:
  D.7454 = list;
  return D.7454;
}


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

  prev = 0B;
  goto <D.7203>;
  <D.7202>:
  D.7456 = list->data;
  if (D.7456 == data) goto <D.7201>; else goto <D.7457>;
  <D.7457>:
  prev = list;
  list = list->next;
  <D.7203>:
  if (list != 0B) goto <D.7202>; else goto <D.7201>;
  <D.7201>:
  D.7458 = prev;
  return D.7458;
}


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

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

    tmp_prev = find_prev (next, data);
    if (tmp_prev != 0B) goto <D.7460>; else goto <D.7461>;
    <D.7460>:
    prev = tmp_prev;
    <D.7461>:
    if (prev != 0B) goto <D.7463>; else goto <D.7464>;
    <D.7463>:
    iftmp.1 = prev->next;
    goto <D.7465>;
    <D.7464>:
    iftmp.1 = list;
    <D.7465>:
    current = iftmp.1;
    if (current == 0B) goto <D.7287>; else goto <D.7466>;
    <D.7466>:
    next = current->next;
    if (prev != 0B) goto <D.7467>; else goto <D.7468>;
    <D.7467>:
    prev->next = next;
    goto <D.7469>;
    <D.7468>:
    list = next;
    <D.7469>:
    monoeg_g_slist_free_1 (current);
  }
  <D.7289>:
  if (next != 0B) goto <D.7288>; else goto <D.7287>;
  <D.7287>:
  D.7470 = list;
  return D.7470;
}


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

  prev = find_prev_link (list, link);
  if (prev != 0B) goto <D.7473>; else goto <D.7474>;
  <D.7473>:
  iftmp.2 = prev->next;
  goto <D.7475>;
  <D.7474>:
  iftmp.2 = list;
  <D.7475>:
  current = iftmp.2;
  if (current != 0B) goto <D.7476>; else goto <D.7477>;
  <D.7476>:
  if (prev != 0B) goto <D.7478>; else goto <D.7479>;
  <D.7478>:
  D.7480 = current->next;
  prev->next = D.7480;
  goto <D.7481>;
  <D.7479>:
  list = current->next;
  <D.7481>:
  current->next = 0B;
  <D.7477>:
  D.7482 = list;
  return D.7482;
}


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

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


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

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

    next = list->next;
    list->next = prev;
    prev = list;
    list = next;
  }
  <D.7306>:
  if (list != 0B) goto <D.7305>; else goto <D.7307>;
  <D.7307>:
  D.7486 = prev;
  return D.7486;
}


monoeg_g_slist_insert_sorted (struct GSList * list, void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GSList * D.7490;
  void * D.7494;
  int D.7495;
  struct GSList * D.7496;
  void * D.7497;
  int D.7498;
  struct GSList * prev;

  prev = 0B;
  if (func == 0B) goto <D.7488>; else goto <D.7489>;
  <D.7488>:
  D.7490 = list;
  return D.7490;
  <D.7489>:
  if (list == 0B) goto <D.7491>; else goto <D.7493>;
  <D.7493>:
  D.7494 = list->data;
  D.7495 = func (D.7494, data);
  if (D.7495 > 0) goto <D.7491>; else goto <D.7492>;
  <D.7491>:
  D.7490 = monoeg_g_slist_prepend (list, data);
  return D.7490;
  <D.7492>:
  prev = list;
  goto <D.7316>;
  <D.7315>:
  D.7496 = prev->next;
  D.7497 = D.7496->data;
  D.7498 = func (D.7497, data);
  if (D.7498 > 0) goto <D.7314>; else goto <D.7499>;
  <D.7499>:
  prev = prev->next;
  <D.7316>:
  D.7496 = prev->next;
  if (D.7496 != 0B) goto <D.7315>; else goto <D.7314>;
  <D.7314>:
  insert_after (prev, data);
  D.7490 = list;
  return D.7490;
}


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

  index = 0;
  goto <D.7323>;
  <D.7322>:
  D.7501 = list->data;
  if (D.7501 == data) goto <D.7502>; else goto <D.7503>;
  <D.7502>:
  D.7504 = index;
  return D.7504;
  <D.7503>:
  index = index + 1;
  list = list->next;
  <D.7323>:
  if (list != 0B) goto <D.7322>; else goto <D.7324>;
  <D.7324>:
  D.7504 = -1;
  return D.7504;
}


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

  goto <D.7331>;
  <D.7330>:
  if (n == 0) goto <D.7329>; else goto <D.7506>;
  <D.7506>:
  n = n + 4294967295;
  list = list->next;
  <D.7331>:
  if (list != 0B) goto <D.7330>; else goto <D.7329>;
  <D.7329>:
  D.7507 = list;
  return D.7507;
}


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

  node = monoeg_g_slist_nth (list, n);
  if (node != 0B) goto <D.7511>; else goto <D.7512>;
  <D.7511>:
  iftmp.3 = node->data;
  goto <D.7513>;
  <D.7512>:
  iftmp.3 = 0B;
  <D.7513>:
  D.7509 = iftmp.3;
  return D.7509;
}


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

  if (list == 0B) goto <D.7515>; else goto <D.7517>;
  <D.7517>:
  D.7518 = list->next;
  if (D.7518 == 0B) goto <D.7515>; else goto <D.7516>;
  <D.7515>:
  D.7519 = list;
  return D.7519;
  <D.7516>:
  D.7519 = do_sort (list, func);
  return D.7519;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.7521;
  void * D.7522;
  int D.7523;
  struct GSList * D.7527;
  struct list_node * D.7528;
  int D.7529;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.7521 = list->data;
        D.7522 = next->data;
        D.7523 = func (D.7521, D.7522);
        if (D.7523 > 0) goto <D.7524>; else goto <D.7525>;
        <D.7524>:
        next->next = list;
        next = list;
        list = list->next;
        <D.7525>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.7387>:
      if (list != 0B) goto <D.7526>; else goto <D.7388>;
      <D.7526>:
      D.7527 = list->next;
      if (D.7527 != 0B) goto <D.7386>; else goto <D.7388>;
      <D.7388>:
      D.7529 = si.n_ranks;
      D.7528 = sweep_up (&si, list, D.7529);
      return D.7528;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.7533;
  unsigned int rank.4;
  struct list_node * D.7539;
  gint (*<T1632>) (const void *, const void *) D.7540;
  struct list_node * D.7544;
  struct list_node * D.7545;
  int D.7551;
  int i;

  D.7533 = si->n_ranks;
  if (D.7533 < rank) goto <D.7534>; else goto <D.7535>;
  <D.7534>:
  rank.4 = (unsigned int) rank;
  if (rank.4 > 28) goto <D.7537>; else goto <D.7538>;
  <D.7537>:
  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.7538>:
  D.7533 = si->n_ranks;
  D.7539 = sweep_up (si, 0B, D.7533);
  D.7540 = si->func;
  list = merge_lists (D.7539, list, D.7540);
  i = si->n_ranks;
  goto <D.7374>;
  <D.7373>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.7374>:
  if (i < rank) goto <D.7373>; else goto <D.7375>;
  <D.7375>:
  goto <D.7541>;
  <D.7535>:
  if (rank != 0) goto <D.7542>; else goto <D.7543>;
  <D.7542>:
  D.7544 = sweep_up (si, 0B, rank);
  D.7540 = si->func;
  list = merge_lists (D.7544, list, D.7540);
  <D.7543>:
  i = rank;
  goto <D.7377>;
  <D.7376>:
  D.7545 = si->ranks[i];
  D.7540 = si->func;
  list = merge_lists (D.7545, list, D.7540);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.7377>:
  D.7533 = si->n_ranks;
  if (D.7533 > i) goto <D.7546>; else goto <D.7378>;
  <D.7546>:
  D.7545 = si->ranks[i];
  if (D.7545 != 0B) goto <D.7376>; else goto <D.7378>;
  <D.7378>:
  <D.7541>:
  if (i == 28) goto <D.7547>; else goto <D.7548>;
  <D.7547>:
  i = i + -1;
  <D.7548>:
  D.7533 = si->n_ranks;
  if (D.7533 <= i) goto <D.7549>; else goto <D.7550>;
  <D.7549>:
  D.7551 = i + 1;
  si->n_ranks = D.7551;
  <D.7550>:
  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.7552;
  void * D.7553;
  int D.7554;
  struct list_node * D.7558;
  _Bool D.7559;
  _Bool D.7560;
  _Bool D.7561;
  struct list_node * iftmp.5;
  struct list_node * D.7566;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.7356>;
      <D.7355>:
      D.7552 = first->data;
      D.7553 = second->data;
      D.7554 = func (D.7552, D.7553);
      if (D.7554 > 0) goto <D.7555>; else goto <D.7556>;
      <D.7555>:
      *pos = second;
      second = second->next;
      goto <D.7557>;
      <D.7556>:
      *pos = first;
      first = first->next;
      <D.7557>:
      D.7558 = *pos;
      pos = &D.7558->next;
      <D.7356>:
      D.7559 = first != 0B;
      D.7560 = second != 0B;
      D.7561 = D.7559 & D.7560;
      if (D.7561 != 0) goto <D.7355>; else goto <D.7357>;
      <D.7357>:
      if (first != 0B) goto <D.7563>; else goto <D.7564>;
      <D.7563>:
      iftmp.5 = first;
      goto <D.7565>;
      <D.7564>:
      iftmp.5 = second;
      <D.7565>:
      *pos = iftmp.5;
      D.7566 = list;
      return D.7566;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  struct list_node * D.7569;
  gint (*<T1632>) (const void *, const void *) D.7570;
  struct list_node * D.7571;
  int i;

  i = si->min_rank;
  goto <D.7365>;
  <D.7364>:
  D.7569 = si->ranks[i];
  D.7570 = si->func;
  list = merge_lists (D.7569, list, D.7570);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.7365>:
  if (i < upto) goto <D.7364>; else goto <D.7366>;
  <D.7366>:
  D.7571 = list;
  return D.7571;
}