monoeg_g_list_alloc ()
{
  struct GList * D.5233;

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


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

  if (list != 0B) goto <D.5237>; else goto <D.5238>;
  <D.5237>:
  iftmp.0 = list->prev;
  goto <D.5239>;
  <D.5238>:
  iftmp.0 = 0B;
  <D.5239>:
  D.5235 = new_node (iftmp.0, data, list);
  return D.5235;
}


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

  node = monoeg_g_list_alloc ();
  node->data = data;
  node->prev = prev;
  node->next = next;
  if (prev != 0B) goto <D.5241>; else goto <D.5242>;
  <D.5241>:
  prev->next = node;
  <D.5242>:
  if (next != 0B) goto <D.5243>; else goto <D.5244>;
  <D.5243>:
  next->prev = node;
  <D.5244>:
  D.5245 = node;
  return D.5245;
}


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


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

    next = list->next;
    monoeg_g_list_free_1 (list);
    list = next;
  }
  <D.5046>:
  if (list != 0B) goto <D.5045>; else goto <D.5047>;
  <D.5047>:
}


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

  D.5247 = monoeg_g_list_last (list);
  node = new_node (D.5247, data, 0B);
  if (list != 0B) goto <D.5250>; else goto <D.5251>;
  <D.5250>:
  iftmp.1 = list;
  goto <D.5252>;
  <D.5251>:
  iftmp.1 = node;
  <D.5252>:
  D.5248 = iftmp.1;
  return D.5248;
}


monoeg_g_list_concat (struct GList * list1, struct GList * list2)
{
  struct GList * D.5258;
  struct GList * D.5259;
  struct GList * D.5260;
  struct GList * iftmp.2;

  if (list1 != 0B) goto <D.5254>; else goto <D.5255>;
  <D.5254>:
  if (list2 != 0B) goto <D.5256>; else goto <D.5257>;
  <D.5256>:
  D.5258 = monoeg_g_list_last (list1);
  list2->prev = D.5258;
  D.5259 = list2->prev;
  D.5259->next = list2;
  <D.5257>:
  <D.5255>:
  if (list1 != 0B) goto <D.5262>; else goto <D.5263>;
  <D.5262>:
  iftmp.2 = list1;
  goto <D.5264>;
  <D.5263>:
  iftmp.2 = list2;
  <D.5264>:
  D.5260 = iftmp.2;
  return D.5260;
}


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

  length = 0;
  goto <D.5062>;
  <D.5061>:
  length = length + 1;
  list = list->next;
  <D.5062>:
  if (list != 0B) goto <D.5061>; else goto <D.5063>;
  <D.5063>:
  D.5266 = length;
  return D.5266;
}


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

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.5268>; else goto <D.5269>;
  <D.5268>:
  D.5270 = list;
  return D.5270;
  <D.5269>:
  if (current == list) goto <D.5271>; else goto <D.5272>;
  <D.5271>:
  list = list->next;
  <D.5272>:
  D.5273 = disconnect_node (current);
  monoeg_g_list_free_1 (D.5273);
  D.5270 = list;
  return D.5270;
}


disconnect_node (struct GList * node)
{
  struct GList * D.5275;
  struct GList * D.5278;
  struct GList * D.5281;

  D.5275 = node->next;
  if (D.5275 != 0B) goto <D.5276>; else goto <D.5277>;
  <D.5276>:
  D.5275 = node->next;
  D.5278 = node->prev;
  D.5275->prev = D.5278;
  <D.5277>:
  D.5278 = node->prev;
  if (D.5278 != 0B) goto <D.5279>; else goto <D.5280>;
  <D.5279>:
  D.5278 = node->prev;
  D.5275 = node->next;
  D.5278->next = D.5275;
  <D.5280>:
  D.5281 = node;
  return D.5281;
}


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

  current = monoeg_g_list_find (list, data);
  if (current == 0B) goto <D.5283>; else goto <D.5284>;
  <D.5283>:
  D.5285 = list;
  return D.5285;
  <D.5284>:
  goto <D.5075>;
  <D.5074>:
  if (current == list) goto <D.5286>; else goto <D.5287>;
  <D.5286>:
  list = list->next;
  <D.5287>:
  D.5288 = disconnect_node (current);
  monoeg_g_list_free_1 (D.5288);
  current = monoeg_g_list_find (list, data);
  <D.5075>:
  if (current != 0B) goto <D.5074>; else goto <D.5076>;
  <D.5076>:
  D.5285 = list;
  return D.5285;
}


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

  if (list == link) goto <D.5290>; else goto <D.5291>;
  <D.5290>:
  list = list->next;
  <D.5291>:
  disconnect_node (link);
  link->next = 0B;
  link->prev = 0B;
  D.5292 = list;
  return D.5292;
}


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

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


monoeg_g_list_find (struct GList * list, const void * data)
{
  void * D.5296;
  struct GList * D.5299;

  goto <D.5090>;
  <D.5089>:
  D.5296 = list->data;
  if (D.5296 == data) goto <D.5297>; else goto <D.5298>;
  <D.5297>:
  D.5299 = list;
  return D.5299;
  <D.5298>:
  list = list->next;
  <D.5090>:
  if (list != 0B) goto <D.5089>; else goto <D.5091>;
  <D.5091>:
  D.5299 = 0B;
  return D.5299;
}


monoeg_g_list_find_custom (struct GList * list, const void * data, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.5303;
  void * D.5304;
  int D.5305;

  if (func == 0B) goto <D.5301>; else goto <D.5302>;
  <D.5301>:
  D.5303 = 0B;
  return D.5303;
  <D.5302>:
  goto <D.5098>;
  <D.5097>:
  D.5304 = list->data;
  D.5305 = func (D.5304, data);
  if (D.5305 == 0) goto <D.5306>; else goto <D.5307>;
  <D.5306>:
  D.5303 = list;
  return D.5303;
  <D.5307>:
  list = list->next;
  <D.5098>:
  if (list != 0B) goto <D.5097>; else goto <D.5099>;
  <D.5099>:
  D.5303 = 0B;
  return D.5303;
}


monoeg_g_list_reverse (struct GList * list)
{
  struct GList * D.5309;
  struct GList * D.5310;
  struct GList * reverse;

  reverse = 0B;
  goto <D.5105>;
  <D.5104>:
  reverse = list;
  list = reverse->next;
  D.5309 = reverse->prev;
  reverse->next = D.5309;
  reverse->prev = list;
  <D.5105>:
  if (list != 0B) goto <D.5104>; else goto <D.5106>;
  <D.5106>:
  D.5310 = reverse;
  return D.5310;
}


monoeg_g_list_first (struct GList * list)
{
  struct GList * D.5314;
  struct GList * D.5315;

  if (list == 0B) goto <D.5312>; else goto <D.5313>;
  <D.5312>:
  D.5314 = 0B;
  return D.5314;
  <D.5313>:
  goto <D.5111>;
  <D.5110>:
  list = list->prev;
  <D.5111>:
  D.5315 = list->prev;
  if (D.5315 != 0B) goto <D.5110>; else goto <D.5112>;
  <D.5112>:
  D.5314 = list;
  return D.5314;
}


monoeg_g_list_last (struct GList * list)
{
  struct GList * D.5319;
  struct GList * D.5320;

  if (list == 0B) goto <D.5317>; else goto <D.5318>;
  <D.5317>:
  D.5319 = 0B;
  return D.5319;
  <D.5318>:
  goto <D.5117>;
  <D.5116>:
  list = list->next;
  <D.5117>:
  D.5320 = list->next;
  if (D.5320 != 0B) goto <D.5116>; else goto <D.5118>;
  <D.5118>:
  D.5319 = list;
  return D.5319;
}


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

  prev = 0B;
  if (func == 0B) goto <D.5322>; else goto <D.5323>;
  <D.5322>:
  D.5324 = list;
  return D.5324;
  <D.5323>:
  current = list;
  goto <D.5129>;
  <D.5128>:
  D.5325 = current->data;
  D.5326 = func (D.5325, data);
  if (D.5326 > 0) goto <D.5127>; else goto <D.5327>;
  <D.5327>:
  prev = current;
  current = current->next;
  <D.5129>:
  if (current != 0B) goto <D.5128>; else goto <D.5127>;
  <D.5127>:
  node = new_node (prev, data, current);
  if (list == current) goto <D.5329>; else goto <D.5330>;
  <D.5329>:
  iftmp.3 = node;
  goto <D.5331>;
  <D.5330>:
  iftmp.3 = list;
  <D.5331>:
  D.5324 = iftmp.3;
  return D.5324;
}


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

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

    D.5335 = sibling->prev;
    node = new_node (D.5335, data, sibling);
    if (list == sibling) goto <D.5338>; else goto <D.5339>;
    <D.5338>:
    iftmp.4 = node;
    goto <D.5340>;
    <D.5339>:
    iftmp.4 = list;
    <D.5340>:
    D.5336 = iftmp.4;
    return D.5336;
  }
  <D.5334>:
  D.5336 = monoeg_g_list_append (list, data);
  return D.5336;
}


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

  goto <D.5142>;
  <D.5141>:
  D.5342 = list->data;
  func (D.5342, user_data);
  list = list->next;
  <D.5142>:
  if (list != 0B) goto <D.5141>; else goto <D.5143>;
  <D.5143>:
}


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

  index = 0;
  goto <D.5150>;
  <D.5149>:
  D.5343 = list->data;
  if (D.5343 == data) goto <D.5344>; else goto <D.5345>;
  <D.5344>:
  D.5346 = index;
  return D.5346;
  <D.5345>:
  index = index + 1;
  list = list->next;
  <D.5150>:
  if (list != 0B) goto <D.5149>; else goto <D.5151>;
  <D.5151>:
  D.5346 = -1;
  return D.5346;
}


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

  goto <D.5158>;
  <D.5157>:
  if (n == 0) goto <D.5156>; else goto <D.5348>;
  <D.5348>:
  n = n + 4294967295;
  list = list->next;
  <D.5158>:
  if (list != 0B) goto <D.5157>; else goto <D.5156>;
  <D.5156>:
  D.5349 = list;
  return D.5349;
}


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

  node = monoeg_g_list_nth (list, n);
  if (node != 0B) goto <D.5353>; else goto <D.5354>;
  <D.5353>:
  iftmp.5 = node->data;
  goto <D.5355>;
  <D.5354>:
  iftmp.5 = 0B;
  <D.5355>:
  D.5351 = iftmp.5;
  return D.5351;
}


monoeg_g_list_copy (struct GList * list)
{
  void * D.5359;
  struct GList * D.5360;
  struct GList * copy;

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

    D.5359 = list->data;
    tmp = new_node (0B, D.5359, 0B);
    copy = tmp;
    list = list->next;
    goto <D.5170>;
    <D.5169>:
    D.5359 = list->data;
    tmp = new_node (tmp, D.5359, 0B);
    list = list->next;
    <D.5170>:
    if (list != 0B) goto <D.5169>; else goto <D.5171>;
    <D.5171>:
  }
  <D.5358>:
  D.5360 = copy;
  return D.5360;
}


monoeg_g_list_sort (struct GList * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  struct GList * D.5365;
  struct GList * D.5366;
  struct GList * D.5367;
  struct GList * current;

  if (list == 0B) goto <D.5362>; else goto <D.5364>;
  <D.5364>:
  D.5365 = list->next;
  if (D.5365 == 0B) goto <D.5362>; else goto <D.5363>;
  <D.5362>:
  D.5366 = list;
  return D.5366;
  <D.5363>:
  list = do_sort (list, func);
  list->prev = 0B;
  current = list;
  goto <D.5230>;
  <D.5229>:
  D.5367 = current->next;
  D.5367->prev = current;
  current = current->next;
  <D.5230>:
  D.5367 = current->next;
  if (D.5367 != 0B) goto <D.5229>; else goto <D.5231>;
  <D.5231>:
  D.5366 = list;
  return D.5366;
}


do_sort (struct list_node * list, gint (*GCompareFunc) (const void *, const void *) func)
{
  void * D.5369;
  void * D.5370;
  int D.5371;
  struct GList * D.5375;
  struct list_node * D.5376;
  int D.5377;
  struct sort_info si;

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

        next = list->next;
        tail = next->next;
        D.5369 = list->data;
        D.5370 = next->data;
        D.5371 = func (D.5369, D.5370);
        if (D.5371 > 0) goto <D.5372>; else goto <D.5373>;
        <D.5372>:
        next->next = list;
        next = list;
        list = list->next;
        <D.5373>:
        next->next = 0B;
        insert_list (&si, list, 0);
        list = tail;
      }
      <D.5222>:
      if (list != 0B) goto <D.5374>; else goto <D.5223>;
      <D.5374>:
      D.5375 = list->next;
      if (D.5375 != 0B) goto <D.5221>; else goto <D.5223>;
      <D.5223>:
      D.5377 = si.n_ranks;
      D.5376 = sweep_up (&si, list, D.5377);
      return D.5376;
    }
  finally
    {
      si = {CLOBBER};
    }
}


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

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


insert_list (struct sort_info * si, struct list_node * list, int rank)
{
  int D.5381;
  unsigned int rank.6;
  struct list_node * D.5387;
  gint (*<Tcc5>) (const void *, const void *) D.5388;
  struct list_node * D.5392;
  struct list_node * D.5393;
  int D.5399;
  int i;

  D.5381 = si->n_ranks;
  if (D.5381 < rank) goto <D.5382>; else goto <D.5383>;
  <D.5382>:
  rank.6 = (unsigned int) rank;
  if (rank.6 > 59) goto <D.5385>; else goto <D.5386>;
  <D.5385>:
  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.5386>:
  D.5381 = si->n_ranks;
  D.5387 = sweep_up (si, 0B, D.5381);
  D.5388 = si->func;
  list = merge_lists (D.5387, list, D.5388);
  i = si->n_ranks;
  goto <D.5209>;
  <D.5208>:
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5209>:
  if (i < rank) goto <D.5208>; else goto <D.5210>;
  <D.5210>:
  goto <D.5389>;
  <D.5383>:
  if (rank != 0) goto <D.5390>; else goto <D.5391>;
  <D.5390>:
  D.5392 = sweep_up (si, 0B, rank);
  D.5388 = si->func;
  list = merge_lists (D.5392, list, D.5388);
  <D.5391>:
  i = rank;
  goto <D.5212>;
  <D.5211>:
  D.5393 = si->ranks[i];
  D.5388 = si->func;
  list = merge_lists (D.5393, list, D.5388);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5212>:
  D.5381 = si->n_ranks;
  if (D.5381 > i) goto <D.5394>; else goto <D.5213>;
  <D.5394>:
  D.5393 = si->ranks[i];
  if (D.5393 != 0B) goto <D.5211>; else goto <D.5213>;
  <D.5213>:
  <D.5389>:
  if (i == 59) goto <D.5395>; else goto <D.5396>;
  <D.5395>:
  i = i + -1;
  <D.5396>:
  D.5381 = si->n_ranks;
  if (D.5381 <= i) goto <D.5397>; else goto <D.5398>;
  <D.5397>:
  D.5399 = i + 1;
  si->n_ranks = D.5399;
  <D.5398>:
  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.5400;
  void * D.5401;
  int D.5402;
  struct list_node * D.5406;
  struct list_node * iftmp.7;
  struct list_node * D.5412;
  struct list_node * list;
  struct list_node * * pos;

  try
    {
      list = 0B;
      pos = &list;
      goto <D.5191>;
      <D.5190>:
      D.5400 = first->data;
      D.5401 = second->data;
      D.5402 = func (D.5400, D.5401);
      if (D.5402 > 0) goto <D.5403>; else goto <D.5404>;
      <D.5403>:
      *pos = second;
      second = second->next;
      goto <D.5405>;
      <D.5404>:
      *pos = first;
      first = first->next;
      <D.5405>:
      D.5406 = *pos;
      pos = &D.5406->next;
      <D.5191>:
      if (first != 0B) goto <D.5407>; else goto <D.5192>;
      <D.5407>:
      if (second != 0B) goto <D.5190>; else goto <D.5192>;
      <D.5192>:
      if (first != 0B) goto <D.5409>; else goto <D.5410>;
      <D.5409>:
      iftmp.7 = first;
      goto <D.5411>;
      <D.5410>:
      iftmp.7 = second;
      <D.5411>:
      *pos = iftmp.7;
      D.5412 = list;
      return D.5412;
    }
  finally
    {
      list = {CLOBBER};
    }
}


sweep_up (struct sort_info * si, struct list_node * list, int upto)
{
  struct list_node * D.5415;
  gint (*<Tcc5>) (const void *, const void *) D.5416;
  struct list_node * D.5417;
  int i;

  i = si->min_rank;
  goto <D.5200>;
  <D.5199>:
  D.5415 = si->ranks[i];
  D.5416 = si->func;
  list = merge_lists (D.5415, list, D.5416);
  si->ranks[i] = 0B;
  i = i + 1;
  <D.5200>:
  if (i < upto) goto <D.5199>; else goto <D.5201>;
  <D.5201>:
  D.5417 = list;
  return D.5417;
}