monoeg_g_list_alloc ()
{
  struct GList * D.5130;

  D.5130 = monoeg_malloc0 (24);
  return D.5130;
}


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

  if (list != 0B) goto <D.5134>; else goto <D.5135>;
  <D.5134>:
  iftmp.0 = list->prev;
  goto <D.5136>;
  <D.5135>:
  iftmp.0 = 0B;
  <D.5136>:
  D.5132 = new_node (iftmp.0, data, list);
  return D.5132;
}


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

  node = monoeg_g_list_alloc ();
  node->data = data;
  node->prev = prev;
  node->next = next;
  if (prev != 0B) goto <D.5138>; else goto <D.5139>;
  <D.5138>:
  prev->next = node;
  <D.5139>:
  if (next != 0B) goto <D.5140>; else goto <D.5141>;
  <D.5140>:
  next->prev = node;
  <D.5141>:
  D.5142 = node;
  return D.5142;
}


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


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

    next = list->next;
    monoeg_g_list_free_1 (list);
    list = next;
  }
  <D.4943>:
  if (list != 0B) goto <D.4942>; else goto <D.4944>;
  <D.4944>:
}


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

  D.5144 = monoeg_g_list_last (list);
  node = new_node (D.5144, data, 0B);
  if (list != 0B) goto <D.5147>; else goto <D.5148>;
  <D.5147>:
  iftmp.1 = list;
  goto <D.5149>;
  <D.5148>:
  iftmp.1 = node;
  <D.5149>:
  D.5145 = iftmp.1;
  return D.5145;
}


monoeg_g_list_concat (struct GList * list1, struct GList * list2)
{
  _Bool D.5151;
  _Bool D.5152;
  _Bool D.5153;
  struct GList * D.5156;
  struct GList * D.5157;
  struct GList * D.5158;
  struct GList * iftmp.2;

  D.5151 = list1 != 0B;
  D.5152 = list2 != 0B;
  D.5153 = D.5151 & D.5152;
  if (D.5153 != 0) goto <D.5154>; else goto <D.5155>;
  <D.5154>:
  D.5156 = monoeg_g_list_last (list1);
  list2->prev = D.5156;
  D.5157 = list2->prev;
  D.5157->next = list2;
  <D.5155>:
  if (list1 != 0B) goto <D.5160>; else goto <D.5161>;
  <D.5160>:
  iftmp.2 = list1;
  goto <D.5162>;
  <D.5161>:
  iftmp.2 = list2;
  <D.5162>:
  D.5158 = iftmp.2;
  return D.5158;
}


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

  length = 0;
  goto <D.4959>;
  <D.4958>:
  length = length + 1;
  list = list->next;
  <D.4959>:
  if (list != 0B) goto <D.4958>; else goto <D.4960>;
  <D.4960>:
  D.5164 = length;
  return D.5164;
}


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

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.5166>; else goto <D.5167>;
  <D.5166>:
  D.5168 = list;
  return D.5168;
  <D.5167>:
  if (current == list) goto <D.5169>; else goto <D.5170>;
  <D.5169>:
  list = list->next;
  <D.5170>:
  D.5171 = disconnect_node (current);
  monoeg_g_list_free_1 (D.5171);
  D.5168 = list;
  return D.5168;
}


disconnect_node (struct GList * node)
{
  struct GList * D.5173;
  struct GList * D.5176;
  struct GList * D.5179;

  D.5173 = node->next;
  if (D.5173 != 0B) goto <D.5174>; else goto <D.5175>;
  <D.5174>:
  D.5173 = node->next;
  D.5176 = node->prev;
  D.5173->prev = D.5176;
  <D.5175>:
  D.5176 = node->prev;
  if (D.5176 != 0B) goto <D.5177>; else goto <D.5178>;
  <D.5177>:
  D.5176 = node->prev;
  D.5173 = node->next;
  D.5176->next = D.5173;
  <D.5178>:
  D.5179 = node;
  return D.5179;
}


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

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.5181>; else goto <D.5182>;
  <D.5181>:
  D.5183 = list;
  return D.5183;
  <D.5182>:
  goto <D.4972>;
  <D.4971>:
  if (current == list) goto <D.5184>; else goto <D.5185>;
  <D.5184>:
  list = list->next;
  <D.5185>:
  D.5186 = disconnect_node (current);
  monoeg_g_list_free_1 (D.5186);
  current = monoeg_g_list_find (list, data);
  <D.4972>:
  if (current != 0B) goto <D.4971>; else goto <D.4973>;
  <D.4973>:
  D.5183 = list;
  return D.5183;
}


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

  if (list == link) goto <D.5188>; else goto <D.5189>;
  <D.5188>:
  list = list->next;
  <D.5189>:
  disconnect_node (link);
  link->next = 0B;
  link->prev = 0B;
  D.5190 = list;
  return D.5190;
}


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

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


monoeg_g_list_find (struct GList * list, const void * data)
{
  void * D.5194;
  struct GList * D.5197;

  goto <D.4987>;
  <D.4986>:
  D.5194 = list->data;
  if (D.5194 == data) goto <D.5195>; else goto <D.5196>;
  <D.5195>:
  D.5197 = list;
  return D.5197;
  <D.5196>:
  list = list->next;
  <D.4987>:
  if (list != 0B) goto <D.4986>; else goto <D.4988>;
  <D.4988>:
  D.5197 = 0B;
  return D.5197;
}


monoeg_g_list_find_custom (struct GList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.5201;
  void * D.5202;
  int D.5203;

  if (func == 0B) goto <D.5199>; else goto <D.5200>;
  <D.5199>:
  D.5201 = 0B;
  return D.5201;
  <D.5200>:
  goto <D.4995>;
  <D.4994>:
  D.5202 = list->data;
  D.5203 = func (D.5202, data);
  if (D.5203 == 0) goto <D.5204>; else goto <D.5205>;
  <D.5204>:
  D.5201 = list;
  return D.5201;
  <D.5205>:
  list = list->next;
  <D.4995>:
  if (list != 0B) goto <D.4994>; else goto <D.4996>;
  <D.4996>:
  D.5201 = 0B;
  return D.5201;
}


monoeg_g_list_reverse (struct GList * list)
{
  struct GList * D.5207;
  struct GList * D.5208;
  struct GList * reverse;

  reverse = 0B;
  goto <D.5002>;
  <D.5001>:
  reverse = list;
  list = reverse->next;
  D.5207 = reverse->prev;
  reverse->next = D.5207;
  reverse->prev = list;
  <D.5002>:
  if (list != 0B) goto <D.5001>; else goto <D.5003>;
  <D.5003>:
  D.5208 = reverse;
  return D.5208;
}


monoeg_g_list_first (struct GList * list)
{
  struct GList * D.5212;
  struct GList * D.5213;

  if (list == 0B) goto <D.5210>; else goto <D.5211>;
  <D.5210>:
  D.5212 = 0B;
  return D.5212;
  <D.5211>:
  goto <D.5008>;
  <D.5007>:
  list = list->prev;
  <D.5008>:
  D.5213 = list->prev;
  if (D.5213 != 0B) goto <D.5007>; else goto <D.5009>;
  <D.5009>:
  D.5212 = list;
  return D.5212;
}


monoeg_g_list_last (struct GList * list)
{
  struct GList * D.5217;
  struct GList * D.5218;

  if (list == 0B) goto <D.5215>; else goto <D.5216>;
  <D.5215>:
  D.5217 = 0B;
  return D.5217;
  <D.5216>:
  goto <D.5014>;
  <D.5013>:
  list = list->next;
  <D.5014>:
  D.5218 = list->next;
  if (D.5218 != 0B) goto <D.5013>; else goto <D.5015>;
  <D.5015>:
  D.5217 = list;
  return D.5217;
}


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

  prev = 0B;
  if (func == 0B) goto <D.5220>; else goto <D.5221>;
  <D.5220>:
  D.5222 = list;
  return D.5222;
  <D.5221>:
  current = list;
  goto <D.5026>;
  <D.5025>:
  D.5223 = current->data;
  D.5224 = func (D.5223, data);
  if (D.5224 > 0) goto <D.5024>; else goto <D.5225>;
  <D.5225>:
  prev = current;
  current = current->next;
  <D.5026>:
  if (current != 0B) goto <D.5025>; else goto <D.5024>;
  <D.5024>:
  node = new_node (prev, data, current);
  if (list == current) goto <D.5227>; else goto <D.5228>;
  <D.5227>:
  iftmp.3 = node;
  goto <D.5229>;
  <D.5228>:
  iftmp.3 = list;
  <D.5229>:
  D.5222 = iftmp.3;
  return D.5222;
}


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

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

    D.5233 = sibling->prev;
    node = new_node (D.5233, data, sibling);
    if (list == sibling) goto <D.5236>; else goto <D.5237>;
    <D.5236>:
    iftmp.4 = node;
    goto <D.5238>;
    <D.5237>:
    iftmp.4 = list;
    <D.5238>:
    D.5234 = iftmp.4;
    return D.5234;
  }
  <D.5232>:
  D.5234 = monoeg_g_list_append (list, data);
  return D.5234;
}


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

  goto <D.5039>;
  <D.5038>:
  D.5240 = list->data;
  func (D.5240, user_data);
  list = list->next;
  <D.5039>:
  if (list != 0B) goto <D.5038>; else goto <D.5040>;
  <D.5040>:
}


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

  index = 0;
  goto <D.5047>;
  <D.5046>:
  D.5241 = list->data;
  if (D.5241 == data) goto <D.5242>; else goto <D.5243>;
  <D.5242>:
  D.5244 = index;
  return D.5244;
  <D.5243>:
  index = index + 1;
  list = list->next;
  <D.5047>:
  if (list != 0B) goto <D.5046>; else goto <D.5048>;
  <D.5048>:
  D.5244 = -1;
  return D.5244;
}


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

  goto <D.5055>;
  <D.5054>:
  if (n == 0) goto <D.5053>; else goto <D.5246>;
  <D.5246>:
  n = n + 4294967295;
  list = list->next;
  <D.5055>:
  if (list != 0B) goto <D.5054>; else goto <D.5053>;
  <D.5053>:
  D.5247 = list;
  return D.5247;
}


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

  node = monoeg_g_list_nth (list, n);
  if (node != 0B) goto <D.5251>; else goto <D.5252>;
  <D.5251>:
  iftmp.5 = node->data;
  goto <D.5253>;
  <D.5252>:
  iftmp.5 = 0B;
  <D.5253>:
  D.5249 = iftmp.5;
  return D.5249;
}


monoeg_g_list_copy (struct GList * list)
{
  void * D.5257;
  struct GList * D.5258;
  struct GList * copy;

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

    D.5257 = list->data;
    tmp = new_node (0B, D.5257, 0B);
    copy = tmp;
    list = list->next;
    goto <D.5067>;
    <D.5066>:
    D.5257 = list->data;
    tmp = new_node (tmp, D.5257, 0B);
    list = list->next;
    <D.5067>:
    if (list != 0B) goto <D.5066>; else goto <D.5068>;
    <D.5068>:
  }
  <D.5256>:
  D.5258 = copy;
  return D.5258;
}


monoeg_g_list_sort (struct GList * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.5263;
  struct GList * D.5264;
  struct GList * D.5265;
  struct GList * current;

  if (list == 0B) goto <D.5260>; else goto <D.5262>;
  <D.5262>:
  D.5263 = list->next;
  if (D.5263 == 0B) goto <D.5260>; else goto <D.5261>;
  <D.5260>:
  D.5264 = list;
  return D.5264;
  <D.5261>:
  list = do_sort (list, func);
  list->prev = 0B;
  current = list;
  goto <D.5127>;
  <D.5126>:
  D.5265 = current->next;
  D.5265->prev = current;
  current = current->next;
  <D.5127>:
  D.5265 = current->next;
  if (D.5265 != 0B) goto <D.5126>; else goto <D.5128>;
  <D.5128>:
  D.5264 = list;
  return D.5264;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.5267;
  void * D.5268;
  int D.5269;
  struct GList * D.5273;
  struct list_node * D.5274;
  int D.5275;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.5267 = next->data;
        D.5268 = list->data;
        D.5269 = func (D.5268, D.5267);
        if (D.5269 > 0) goto <D.5270>; else goto <D.5271>;
        <D.5270>:
        next->next = list;
        next = list;
        list = list->next;
        <D.5271>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.5119>:
      if (list != 0B) goto <D.5272>; else goto <D.5120>;
      <D.5272>:
      D.5273 = list->next;
      if (D.5273 != 0B) goto <D.5118>; else goto <D.5120>;
      <D.5120>:
      D.5275 = si.n_ranks;
      D.5274 = sweep_up (&si, list, D.5275);
      return D.5274;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.5279;
  unsigned int rank.6;
  gint (*<Tc58>) (const void *, const void *) D.5285;
  struct list_node * D.5286;
  struct list_node * D.5290;
  struct list_node * D.5291;
  int D.5297;
  int i;

  D.5279 = si->n_ranks;
  if (D.5279 < rank) goto <D.5280>; else goto <D.5281>;
  <D.5280>:
  rank.6 = (unsigned int) rank;
  if (rank.6 > 59) goto <D.5283>; else goto <D.5284>;
  <D.5283>:
  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.5284>:
  D.5285 = si->func;
  D.5279 = si->n_ranks;
  D.5286 = sweep_up (si, 0B, D.5279);
  list = merge_lists (D.5286, list, D.5285);
  i = si->n_ranks;
  goto <D.5106>;
  <D.5105>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5106>:
  if (i < rank) goto <D.5105>; else goto <D.5107>;
  <D.5107>:
  goto <D.5287>;
  <D.5281>:
  if (rank != 0) goto <D.5288>; else goto <D.5289>;
  <D.5288>:
  D.5285 = si->func;
  D.5290 = sweep_up (si, 0B, rank);
  list = merge_lists (D.5290, list, D.5285);
  <D.5289>:
  i = rank;
  goto <D.5109>;
  <D.5108>:
  D.5285 = si->func;
  D.5291 = si->ranks[i];
  list = merge_lists (D.5291, list, D.5285);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5109>:
  D.5279 = si->n_ranks;
  if (D.5279 > i) goto <D.5292>; else goto <D.5110>;
  <D.5292>:
  D.5291 = si->ranks[i];
  if (D.5291 != 0B) goto <D.5108>; else goto <D.5110>;
  <D.5110>:
  <D.5287>:
  if (i == 59) goto <D.5293>; else goto <D.5294>;
  <D.5293>:
  i = i + -1;
  <D.5294>:
  D.5279 = si->n_ranks;
  if (D.5279 <= i) goto <D.5295>; else goto <D.5296>;
  <D.5295>:
  D.5297 = i + 1;
  si->n_ranks = D.5297;
  <D.5296>:
  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.5298;
  void * D.5299;
  int D.5300;
  struct list_node * D.5304;
  _Bool D.5305;
  _Bool D.5306;
  _Bool D.5307;
  struct list_node * iftmp.7;
  struct list_node * D.5312;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.5088>;
      <D.5087>:
      D.5298 = second->data;
      D.5299 = first->data;
      D.5300 = func (D.5299, D.5298);
      if (D.5300 > 0) goto <D.5301>; else goto <D.5302>;
      <D.5301>:
      *pos = second;
      second = second->next;
      goto <D.5303>;
      <D.5302>:
      *pos = first;
      first = first->next;
      <D.5303>:
      D.5304 = *pos;
      pos = &D.5304->next;
      <D.5088>:
      D.5305 = first != 0B;
      D.5306 = second != 0B;
      D.5307 = D.5305 & D.5306;
      if (D.5307 != 0) goto <D.5087>; else goto <D.5089>;
      <D.5089>:
      if (first != 0B) goto <D.5309>; else goto <D.5310>;
      <D.5309>:
      iftmp.7 = first;
      goto <D.5311>;
      <D.5310>:
      iftmp.7 = second;
      <D.5311>:
      *pos = iftmp.7;
      D.5312 = list;
      return D.5312;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  gint (*<Tc58>) (const void *, const void *) D.5315;
  struct list_node * D.5316;
  struct list_node * D.5317;
  int i;

  i = si->min_rank;
  goto <D.5097>;
  <D.5096>:
  D.5315 = si->func;
  D.5316 = si->ranks[i];
  list = merge_lists (D.5316, list, D.5315);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5097>:
  if (i < upto) goto <D.5096>; else goto <D.5098>;
  <D.5098>:
  D.5317 = list;
  return D.5317;
}