monoeg_g_list_alloc ()
{
  struct GList * D.7389;

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


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

  if (list != 0B) goto <D.7393>; else goto <D.7394>;
  <D.7393>:
  iftmp.0 = list->prev;
  goto <D.7395>;
  <D.7394>:
  iftmp.0 = 0B;
  <D.7395>:
  D.7391 = new_node (iftmp.0, data, list);
  return D.7391;
}


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

  node = monoeg_g_list_alloc ();
  node->data = data;
  node->prev = prev;
  node->next = next;
  if (prev != 0B) goto <D.7397>; else goto <D.7398>;
  <D.7397>:
  prev->next = node;
  <D.7398>:
  if (next != 0B) goto <D.7399>; else goto <D.7400>;
  <D.7399>:
  next->prev = node;
  <D.7400>:
  D.7401 = node;
  return D.7401;
}


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


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

    next = list->next;
    monoeg_g_list_free_1 (list);
    list = next;
  }
  <D.7200>:
  if (list != 0B) goto <D.7199>; else goto <D.7201>;
  <D.7201>:
}


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

  D.7403 = monoeg_g_list_last (list);
  node = new_node (D.7403, data, 0B);
  if (list != 0B) goto <D.7406>; else goto <D.7407>;
  <D.7406>:
  iftmp.1 = list;
  goto <D.7408>;
  <D.7407>:
  iftmp.1 = node;
  <D.7408>:
  D.7404 = iftmp.1;
  return D.7404;
}


monoeg_g_list_concat (struct GList * list1, struct GList * list2)
{
  _Bool D.7410;
  _Bool D.7411;
  _Bool D.7412;
  struct GList * D.7415;
  struct GList * D.7416;
  struct GList * D.7417;
  struct GList * iftmp.2;

  D.7410 = list1 != 0B;
  D.7411 = list2 != 0B;
  D.7412 = D.7410 & D.7411;
  if (D.7412 != 0) goto <D.7413>; else goto <D.7414>;
  <D.7413>:
  D.7415 = monoeg_g_list_last (list1);
  list2->prev = D.7415;
  D.7416 = list2->prev;
  D.7416->next = list2;
  <D.7414>:
  if (list1 != 0B) goto <D.7419>; else goto <D.7420>;
  <D.7419>:
  iftmp.2 = list1;
  goto <D.7421>;
  <D.7420>:
  iftmp.2 = list2;
  <D.7421>:
  D.7417 = iftmp.2;
  return D.7417;
}


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

  length = 0;
  goto <D.7216>;
  <D.7215>:
  length = length + 1;
  list = list->next;
  <D.7216>:
  if (list != 0B) goto <D.7215>; else goto <D.7217>;
  <D.7217>:
  D.7423 = length;
  return D.7423;
}


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

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.7425>; else goto <D.7426>;
  <D.7425>:
  D.7427 = list;
  return D.7427;
  <D.7426>:
  if (current == list) goto <D.7428>; else goto <D.7429>;
  <D.7428>:
  list = list->next;
  <D.7429>:
  D.7430 = disconnect_node (current);
  monoeg_g_list_free_1 (D.7430);
  D.7427 = list;
  return D.7427;
}


disconnect_node (struct GList * node)
{
  struct GList * D.7432;
  struct GList * D.7435;
  struct GList * D.7438;

  D.7432 = node->next;
  if (D.7432 != 0B) goto <D.7433>; else goto <D.7434>;
  <D.7433>:
  D.7432 = node->next;
  D.7435 = node->prev;
  D.7432->prev = D.7435;
  <D.7434>:
  D.7435 = node->prev;
  if (D.7435 != 0B) goto <D.7436>; else goto <D.7437>;
  <D.7436>:
  D.7435 = node->prev;
  D.7432 = node->next;
  D.7435->next = D.7432;
  <D.7437>:
  D.7438 = node;
  return D.7438;
}


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

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.7440>; else goto <D.7441>;
  <D.7440>:
  D.7442 = list;
  return D.7442;
  <D.7441>:
  goto <D.7229>;
  <D.7228>:
  if (current == list) goto <D.7443>; else goto <D.7444>;
  <D.7443>:
  list = list->next;
  <D.7444>:
  D.7445 = disconnect_node (current);
  monoeg_g_list_free_1 (D.7445);
  current = monoeg_g_list_find (list, data);
  <D.7229>:
  if (current != 0B) goto <D.7228>; else goto <D.7230>;
  <D.7230>:
  D.7442 = list;
  return D.7442;
}


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

  if (list == link) goto <D.7447>; else goto <D.7448>;
  <D.7447>:
  list = list->next;
  <D.7448>:
  disconnect_node (link);
  link->next = 0B;
  link->prev = 0B;
  D.7449 = list;
  return D.7449;
}


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

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


monoeg_g_list_find (struct GList * list, const void * data)
{
  void * D.7453;
  struct GList * D.7456;

  goto <D.7244>;
  <D.7243>:
  D.7453 = list->data;
  if (D.7453 == data) goto <D.7454>; else goto <D.7455>;
  <D.7454>:
  D.7456 = list;
  return D.7456;
  <D.7455>:
  list = list->next;
  <D.7244>:
  if (list != 0B) goto <D.7243>; else goto <D.7245>;
  <D.7245>:
  D.7456 = 0B;
  return D.7456;
}


monoeg_g_list_find_custom (struct GList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.7460;
  void * D.7461;
  int D.7462;

  if (func == 0B) goto <D.7458>; else goto <D.7459>;
  <D.7458>:
  D.7460 = 0B;
  return D.7460;
  <D.7459>:
  goto <D.7252>;
  <D.7251>:
  D.7461 = list->data;
  D.7462 = func (D.7461, data);
  if (D.7462 == 0) goto <D.7463>; else goto <D.7464>;
  <D.7463>:
  D.7460 = list;
  return D.7460;
  <D.7464>:
  list = list->next;
  <D.7252>:
  if (list != 0B) goto <D.7251>; else goto <D.7253>;
  <D.7253>:
  D.7460 = 0B;
  return D.7460;
}


monoeg_g_list_reverse (struct GList * list)
{
  struct GList * D.7466;
  struct GList * D.7467;
  struct GList * reverse;

  reverse = 0B;
  goto <D.7259>;
  <D.7258>:
  reverse = list;
  list = reverse->next;
  D.7466 = reverse->prev;
  reverse->next = D.7466;
  reverse->prev = list;
  <D.7259>:
  if (list != 0B) goto <D.7258>; else goto <D.7260>;
  <D.7260>:
  D.7467 = reverse;
  return D.7467;
}


monoeg_g_list_first (struct GList * list)
{
  struct GList * D.7471;
  struct GList * D.7472;

  if (list == 0B) goto <D.7469>; else goto <D.7470>;
  <D.7469>:
  D.7471 = 0B;
  return D.7471;
  <D.7470>:
  goto <D.7265>;
  <D.7264>:
  list = list->prev;
  <D.7265>:
  D.7472 = list->prev;
  if (D.7472 != 0B) goto <D.7264>; else goto <D.7266>;
  <D.7266>:
  D.7471 = list;
  return D.7471;
}


monoeg_g_list_last (struct GList * list)
{
  struct GList * D.7476;
  struct GList * D.7477;

  if (list == 0B) goto <D.7474>; else goto <D.7475>;
  <D.7474>:
  D.7476 = 0B;
  return D.7476;
  <D.7475>:
  goto <D.7271>;
  <D.7270>:
  list = list->next;
  <D.7271>:
  D.7477 = list->next;
  if (D.7477 != 0B) goto <D.7270>; else goto <D.7272>;
  <D.7272>:
  D.7476 = list;
  return D.7476;
}


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

  prev = 0B;
  if (func == 0B) goto <D.7479>; else goto <D.7480>;
  <D.7479>:
  D.7481 = list;
  return D.7481;
  <D.7480>:
  current = list;
  goto <D.7283>;
  <D.7282>:
  D.7482 = current->data;
  D.7483 = func (D.7482, data);
  if (D.7483 > 0) goto <D.7281>; else goto <D.7484>;
  <D.7484>:
  prev = current;
  current = current->next;
  <D.7283>:
  if (current != 0B) goto <D.7282>; else goto <D.7281>;
  <D.7281>:
  node = new_node (prev, data, current);
  if (list == current) goto <D.7486>; else goto <D.7487>;
  <D.7486>:
  iftmp.3 = node;
  goto <D.7488>;
  <D.7487>:
  iftmp.3 = list;
  <D.7488>:
  D.7481 = iftmp.3;
  return D.7481;
}


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

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

    D.7492 = sibling->prev;
    node = new_node (D.7492, data, sibling);
    if (list == sibling) goto <D.7495>; else goto <D.7496>;
    <D.7495>:
    iftmp.4 = node;
    goto <D.7497>;
    <D.7496>:
    iftmp.4 = list;
    <D.7497>:
    D.7493 = iftmp.4;
    return D.7493;
  }
  <D.7491>:
  D.7493 = monoeg_g_list_append (list, data);
  return D.7493;
}


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

  goto <D.7296>;
  <D.7295>:
  D.7499 = list->data;
  func (D.7499, user_data);
  list = list->next;
  <D.7296>:
  if (list != 0B) goto <D.7295>; else goto <D.7297>;
  <D.7297>:
}


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

  index = 0;
  goto <D.7304>;
  <D.7303>:
  D.7500 = list->data;
  if (D.7500 == data) goto <D.7501>; else goto <D.7502>;
  <D.7501>:
  D.7503 = index;
  return D.7503;
  <D.7502>:
  index = index + 1;
  list = list->next;
  <D.7304>:
  if (list != 0B) goto <D.7303>; else goto <D.7305>;
  <D.7305>:
  D.7503 = -1;
  return D.7503;
}


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

  goto <D.7312>;
  <D.7311>:
  if (n == 0) goto <D.7310>; else goto <D.7505>;
  <D.7505>:
  n = n + 4294967295;
  list = list->next;
  <D.7312>:
  if (list != 0B) goto <D.7311>; else goto <D.7310>;
  <D.7310>:
  D.7506 = list;
  return D.7506;
}


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

  node = monoeg_g_list_nth (list, n);
  if (node != 0B) goto <D.7510>; else goto <D.7511>;
  <D.7510>:
  iftmp.5 = node->data;
  goto <D.7512>;
  <D.7511>:
  iftmp.5 = 0B;
  <D.7512>:
  D.7508 = iftmp.5;
  return D.7508;
}


monoeg_g_list_copy (struct GList * list)
{
  void * D.7516;
  struct GList * D.7517;
  struct GList * copy;

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

    D.7516 = list->data;
    tmp = new_node (0B, D.7516, 0B);
    copy = tmp;
    list = list->next;
    goto <D.7324>;
    <D.7323>:
    D.7516 = list->data;
    tmp = new_node (tmp, D.7516, 0B);
    list = list->next;
    <D.7324>:
    if (list != 0B) goto <D.7323>; else goto <D.7325>;
    <D.7325>:
  }
  <D.7515>:
  D.7517 = copy;
  return D.7517;
}


monoeg_g_list_sort (struct GList * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.7522;
  struct GList * D.7523;
  struct GList * D.7524;
  struct GList * current;

  if (list == 0B) goto <D.7519>; else goto <D.7521>;
  <D.7521>:
  D.7522 = list->next;
  if (D.7522 == 0B) goto <D.7519>; else goto <D.7520>;
  <D.7519>:
  D.7523 = list;
  return D.7523;
  <D.7520>:
  list = do_sort (list, func);
  list->prev = 0B;
  current = list;
  goto <D.7384>;
  <D.7383>:
  D.7524 = current->next;
  D.7524->prev = current;
  current = current->next;
  <D.7384>:
  D.7524 = current->next;
  if (D.7524 != 0B) goto <D.7383>; else goto <D.7385>;
  <D.7385>:
  D.7523 = list;
  return D.7523;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.7526;
  void * D.7527;
  int D.7528;
  struct GList * D.7532;
  struct list_node * D.7533;
  int D.7534;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.7526 = list->data;
        D.7527 = next->data;
        D.7528 = func (D.7526, D.7527);
        if (D.7528 > 0) goto <D.7529>; else goto <D.7530>;
        <D.7529>:
        next->next = list;
        next = list;
        list = list->next;
        <D.7530>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.7376>:
      if (list != 0B) goto <D.7531>; else goto <D.7377>;
      <D.7531>:
      D.7532 = list->next;
      if (D.7532 != 0B) goto <D.7375>; else goto <D.7377>;
      <D.7377>:
      D.7534 = si.n_ranks;
      D.7533 = sweep_up (&si, list, D.7534);
      return D.7533;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.7538;
  unsigned int rank.6;
  struct list_node * D.7544;
  gint (*<T1632>) (const void *, const void *) D.7545;
  struct list_node * D.7549;
  struct list_node * D.7550;
  int D.7556;
  int i;

  D.7538 = si->n_ranks;
  if (D.7538 < rank) goto <D.7539>; else goto <D.7540>;
  <D.7539>:
  rank.6 = (unsigned int) rank;
  if (rank.6 > 28) goto <D.7542>; else goto <D.7543>;
  <D.7542>:
  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.7543>:
  D.7538 = si->n_ranks;
  D.7544 = sweep_up (si, 0B, D.7538);
  D.7545 = si->func;
  list = merge_lists (D.7544, list, D.7545);
  i = si->n_ranks;
  goto <D.7363>;
  <D.7362>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.7363>:
  if (i < rank) goto <D.7362>; else goto <D.7364>;
  <D.7364>:
  goto <D.7546>;
  <D.7540>:
  if (rank != 0) goto <D.7547>; else goto <D.7548>;
  <D.7547>:
  D.7549 = sweep_up (si, 0B, rank);
  D.7545 = si->func;
  list = merge_lists (D.7549, list, D.7545);
  <D.7548>:
  i = rank;
  goto <D.7366>;
  <D.7365>:
  D.7550 = si->ranks[i];
  D.7545 = si->func;
  list = merge_lists (D.7550, list, D.7545);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.7366>:
  D.7538 = si->n_ranks;
  if (D.7538 > i) goto <D.7551>; else goto <D.7367>;
  <D.7551>:
  D.7550 = si->ranks[i];
  if (D.7550 != 0B) goto <D.7365>; else goto <D.7367>;
  <D.7367>:
  <D.7546>:
  if (i == 28) goto <D.7552>; else goto <D.7553>;
  <D.7552>:
  i = i + -1;
  <D.7553>:
  D.7538 = si->n_ranks;
  if (D.7538 <= i) goto <D.7554>; else goto <D.7555>;
  <D.7554>:
  D.7556 = i + 1;
  si->n_ranks = D.7556;
  <D.7555>:
  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.7557;
  void * D.7558;
  int D.7559;
  struct list_node * D.7563;
  _Bool D.7564;
  _Bool D.7565;
  _Bool D.7566;
  struct list_node * iftmp.7;
  struct list_node * D.7571;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.7345>;
      <D.7344>:
      D.7557 = first->data;
      D.7558 = second->data;
      D.7559 = func (D.7557, D.7558);
      if (D.7559 > 0) goto <D.7560>; else goto <D.7561>;
      <D.7560>:
      *pos = second;
      second = second->next;
      goto <D.7562>;
      <D.7561>:
      *pos = first;
      first = first->next;
      <D.7562>:
      D.7563 = *pos;
      pos = &D.7563->next;
      <D.7345>:
      D.7564 = first != 0B;
      D.7565 = second != 0B;
      D.7566 = D.7564 & D.7565;
      if (D.7566 != 0) goto <D.7344>; else goto <D.7346>;
      <D.7346>:
      if (first != 0B) goto <D.7568>; else goto <D.7569>;
      <D.7568>:
      iftmp.7 = first;
      goto <D.7570>;
      <D.7569>:
      iftmp.7 = second;
      <D.7570>:
      *pos = iftmp.7;
      D.7571 = list;
      return D.7571;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  struct list_node * D.7574;
  gint (*<T1632>) (const void *, const void *) D.7575;
  struct list_node * D.7576;
  int i;

  i = si->min_rank;
  goto <D.7354>;
  <D.7353>:
  D.7574 = si->ranks[i];
  D.7575 = si->func;
  list = merge_lists (D.7574, list, D.7575);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.7354>:
  if (i < upto) goto <D.7353>; else goto <D.7355>;
  <D.7355>:
  D.7576 = list;
  return D.7576;
}