GC_push_finalizer_structures ()
{
  GC_push_all (&GC_ll_hashtbl.head, &MEM[(void *)&GC_ll_hashtbl + 8B]);
  GC_push_all (&GC_dl_hashtbl.head, &MEM[(void *)&GC_dl_hashtbl + 8B]);
  GC_push_all (&fo_head, &MEM[(void *)&fo_head + 8B]);
  GC_push_all (&GC_finalize_now, &MEM[(void *)&GC_finalize_now + 8B]);
}


GC_grow_table (struct hash_chain_entry * * * table, signed_word * log_size_ptr)
{
  long int D.5650;
  word iftmp.0;
  int D.5654;
  int D.5656;
  long unsigned int D.5657;
  struct hash_chain_entry * * D.5663;
  long unsigned int D.5664;
  struct hash_chain_entry * * D.5665;
  long unsigned int D.5666;
  long unsigned int D.5667;
  long unsigned int real_key.1;
  long unsigned int D.5669;
  unsigned int D.5670;
  int D.5671;
  long unsigned int D.5672;
  unsigned int D.5673;
  unsigned int D.5674;
  unsigned int D.5675;
  unsigned int D.5676;
  unsigned int D.5677;
  long unsigned int D.5678;
  long unsigned int D.5679;
  struct hash_chain_entry * * D.5680;
  struct hash_chain_entry * D.5681;
  long int D.5682;
  register word i;
  register struct hash_chain_entry * p;
  int log_old_size;
  register int log_new_size;
  word old_size;
  register word new_size;
  struct hash_chain_entry * * new_table;

  D.5650 = *log_size_ptr;
  log_old_size = (int) D.5650;
  log_new_size = log_old_size + 1;
  if (log_old_size != -1) goto <D.5652>; else goto <D.5653>;
  <D.5652>:
  D.5654 = 1 << log_old_size;
  iftmp.0 = (word) D.5654;
  goto <D.5655>;
  <D.5653>:
  iftmp.0 = 0;
  <D.5655>:
  old_size = iftmp.0;
  D.5656 = 1 << log_new_size;
  new_size = (word) D.5656;
  D.5657 = new_size * 8;
  new_table = GC_generic_malloc_inner_ignore_off_page (D.5657, 1);
  if (new_table == 0B) goto <D.5658>; else goto <D.5659>;
  <D.5658>:
  if (table == 0B) goto <D.5660>; else goto <D.5661>;
  <D.5660>:
  GC_abort ("Insufficient space for initial table allocation");
  goto <D.5662>;
  <D.5661>:
  return;
  <D.5662>:
  <D.5659>:
  i = 0;
  goto <D.5394>;
  <D.5393>:
  D.5663 = *table;
  D.5664 = i * 8;
  D.5665 = D.5663 + D.5664;
  p = *D.5665;
  goto <D.5391>;
  <D.5390>:
  {
    register char * real_key;
    register struct hash_chain_entry * next;
    register int new_hash;

    D.5666 = p->hidden_key;
    D.5667 = ~D.5666;
    real_key = (char *) D.5667;
    next = p->next;
    real_key.1 = (long unsigned int) real_key;
    D.5669 = real_key.1 >> 3;
    D.5670 = (unsigned int) D.5669;
    real_key.1 = (long unsigned int) real_key;
    D.5671 = log_new_size + 3;
    D.5672 = real_key.1 >> D.5671;
    D.5673 = (unsigned int) D.5672;
    D.5674 = D.5670 ^ D.5673;
    D.5675 = (unsigned int) new_size;
    D.5676 = D.5675 + 4294967295;
    D.5677 = D.5674 & D.5676;
    new_hash = (int) D.5677;
    D.5678 = (long unsigned int) new_hash;
    D.5679 = D.5678 * 8;
    D.5680 = new_table + D.5679;
    D.5681 = *D.5680;
    p->next = D.5681;
    D.5678 = (long unsigned int) new_hash;
    D.5679 = D.5678 * 8;
    D.5680 = new_table + D.5679;
    *D.5680 = p;
    p = next;
  }
  <D.5391>:
  if (p != 0B) goto <D.5390>; else goto <D.5392>;
  <D.5392>:
  i = i + 1;
  <D.5394>:
  if (i < old_size) goto <D.5393>; else goto <D.5395>;
  <D.5395>:
  D.5682 = (long int) log_new_size;
  *log_size_ptr = D.5682;
  *table = new_table;
}


GC_register_disappearing_link (void * * link)
{
  int D.5686;
  char * base;

  base = GC_base (link);
  if (base == 0B) goto <D.5684>; else goto <D.5685>;
  <D.5684>:
  GC_abort ("Bad arg to GC_register_disappearing_link");
  <D.5685>:
  D.5686 = GC_general_register_disappearing_link (link, base);
  return D.5686;
}


GC_general_register_disappearing_link (void * * link, void * obj)
{
  int D.5688;

  D.5688 = GC_register_disappearing_link_inner (&GC_dl_hashtbl, link, obj);
  return D.5688;
}


GC_register_disappearing_link_inner (struct dl_hashtbl_s * dl_hashtbl, void * * link, void * obj)
{
  long unsigned int link.2;
  long unsigned int D.5691;
  int D.5694;
  long int D.5699;
  long unsigned int D.5701;
  int D.5702;
  long unsigned int D.5703;
  struct disappearing_link * * * D.5704;
  signed_word * D.5705;
  int GC_print_stats.3;
  int D.5709;
  long int D.5710;
  long unsigned int D.5711;
  unsigned int D.5712;
  unsigned int D.5713;
  unsigned int D.5714;
  int D.5715;
  long unsigned int D.5716;
  unsigned int D.5717;
  unsigned int D.5718;
  int D.5719;
  unsigned int D.5720;
  unsigned int D.5721;
  struct disappearing_link * * D.5722;
  long unsigned int D.5723;
  long unsigned int D.5724;
  struct disappearing_link * * D.5725;
  long unsigned int D.5726;
  long unsigned int D.5727;
  long unsigned int obj.4;
  long unsigned int D.5731;
  int D.5732;
  void * (*<T398>) (size_t) GC_oom_fn.5;
  unsigned int GC_finalization_failures.6;
  unsigned int GC_finalization_failures.7;
  int D.5740;
  struct disappearing_link * D.5743;
  long unsigned int D.5744;
  struct disappearing_link * curr_dl;
  int index;
  struct disappearing_link * new_dl;

  link.2 = (long unsigned int) link;
  D.5691 = link.2 & 7;
  if (D.5691 != 0) goto <D.5692>; else goto <D.5693>;
  <D.5692>:
  GC_abort ("Bad arg to GC_general_register_disappearing_link");
  <D.5693>:
  D.5694 = GC_test_and_set (&GC_allocate_lock);
  if (D.5694 != 0) goto <D.5695>; else goto <D.5696>;
  <D.5695>:
  GC_lock ();
  <D.5696>:
  D.5699 = dl_hashtbl->log_size;
  if (D.5699 == -1) goto <D.5697>; else goto <D.5700>;
  <D.5700>:
  D.5701 = dl_hashtbl->entries;
  D.5699 = dl_hashtbl->log_size;
  D.5702 = (int) D.5699;
  D.5703 = 1 << D.5702;
  if (D.5701 > D.5703) goto <D.5697>; else goto <D.5698>;
  <D.5697>:
  D.5704 = &dl_hashtbl->head;
  D.5705 = &dl_hashtbl->log_size;
  GC_grow_table (D.5704, D.5705);
  GC_print_stats.3 = GC_print_stats;
  if (GC_print_stats.3 != 0) goto <D.5707>; else goto <D.5708>;
  <D.5707>:
  D.5699 = dl_hashtbl->log_size;
  D.5702 = (int) D.5699;
  D.5709 = 1 << D.5702;
  D.5710 = (long int) D.5709;
  GC_printf ("Grew dl table to %lu entries\n", D.5710, 0, 0, 0, 0, 0);
  <D.5708>:
  <D.5698>:
  link.2 = (long unsigned int) link;
  D.5711 = link.2 >> 3;
  D.5712 = (unsigned int) D.5711;
  link.2 = (long unsigned int) link;
  D.5699 = dl_hashtbl->log_size;
  D.5713 = (unsigned int) D.5699;
  D.5714 = D.5713 + 3;
  D.5715 = (int) D.5714;
  D.5716 = link.2 >> D.5715;
  D.5717 = (unsigned int) D.5716;
  D.5718 = D.5712 ^ D.5717;
  D.5699 = dl_hashtbl->log_size;
  D.5702 = (int) D.5699;
  D.5709 = 1 << D.5702;
  D.5719 = D.5709 + -1;
  D.5720 = (unsigned int) D.5719;
  D.5721 = D.5718 & D.5720;
  index = (int) D.5721;
  D.5722 = dl_hashtbl->head;
  D.5723 = (long unsigned int) index;
  D.5724 = D.5723 * 8;
  D.5725 = D.5722 + D.5724;
  curr_dl = *D.5725;
  D.5722 = dl_hashtbl->head;
  D.5723 = (long unsigned int) index;
  D.5724 = D.5723 * 8;
  D.5725 = D.5722 + D.5724;
  curr_dl = *D.5725;
  goto <D.5413>;
  <D.5412>:
  D.5726 = curr_dl->prolog.hidden_key;
  link.2 = (long unsigned int) link;
  D.5727 = ~link.2;
  if (D.5726 == D.5727) goto <D.5728>; else goto <D.5729>;
  <D.5728>:
  obj.4 = (long unsigned int) obj;
  D.5731 = ~obj.4;
  curr_dl->dl_hidden_obj = D.5731;
  GC_clear (&GC_allocate_lock);
  D.5732 = 1;
  return D.5732;
  <D.5729>:
  curr_dl = curr_dl->prolog.next;
  <D.5413>:
  if (curr_dl != 0B) goto <D.5412>; else goto <D.5414>;
  <D.5414>:
  new_dl = GC_generic_malloc_inner (24, 1);
  if (new_dl == 0B) goto <D.5733>; else goto <D.5734>;
  <D.5733>:
  GC_clear (&GC_allocate_lock);
  GC_oom_fn.5 = GC_oom_fn;
  new_dl = GC_oom_fn.5 (24);
  if (new_dl == 0B) goto <D.5736>; else goto <D.5737>;
  <D.5736>:
  GC_finalization_failures.6 = GC_finalization_failures;
  GC_finalization_failures.7 = GC_finalization_failures.6 + 1;
  GC_finalization_failures = GC_finalization_failures.7;
  D.5732 = 0;
  return D.5732;
  <D.5737>:
  D.5740 = GC_test_and_set (&GC_allocate_lock);
  if (D.5740 != 0) goto <D.5741>; else goto <D.5742>;
  <D.5741>:
  GC_lock ();
  <D.5742>:
  <D.5734>:
  obj.4 = (long unsigned int) obj;
  D.5731 = ~obj.4;
  new_dl->dl_hidden_obj = D.5731;
  link.2 = (long unsigned int) link;
  D.5727 = ~link.2;
  new_dl->prolog.hidden_key = D.5727;
  D.5722 = dl_hashtbl->head;
  D.5723 = (long unsigned int) index;
  D.5724 = D.5723 * 8;
  D.5725 = D.5722 + D.5724;
  D.5743 = *D.5725;
  new_dl->prolog.next = D.5743;
  D.5722 = dl_hashtbl->head;
  D.5723 = (long unsigned int) index;
  D.5724 = D.5723 * 8;
  D.5725 = D.5722 + D.5724;
  *D.5725 = new_dl;
  D.5701 = dl_hashtbl->entries;
  D.5744 = D.5701 + 1;
  dl_hashtbl->entries = D.5744;
  GC_clear (&GC_allocate_lock);
  D.5732 = 0;
  return D.5732;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.5746;
  int oldval;
  int temp;

  temp = 1;
  __asm__ __volatile__("1:	lwarx %0,0,%1
	cmpwi %0, 0
	bne 2f
	stwcx. %2,0,%1
	bne- 1b
	sync
2:	
" : "=&r" oldval : "r" addr, "r" temp : "memory", "cr0");
  D.5746 = oldval;
  return D.5746;
}


GC_clear (volatile unsigned int * addr)
{
  __asm__ __volatile__("lwsync" :  :  : "memory");
  *addr = 0;
}


GC_unregister_disappearing_link (void * * link)
{
  int D.5748;

  D.5748 = GC_unregister_disappearing_link_inner (&GC_dl_hashtbl, link);
  return D.5748;
}


GC_unregister_disappearing_link_inner (struct dl_hashtbl_s * dl_hashtbl, void * * link)
{
  int D.5750;
  long unsigned int link.8;
  long unsigned int D.5754;
  unsigned int D.5755;
  long int D.5756;
  unsigned int D.5757;
  unsigned int D.5758;
  int D.5759;
  long unsigned int D.5760;
  unsigned int D.5761;
  unsigned int D.5762;
  int D.5763;
  int D.5764;
  int D.5765;
  unsigned int D.5766;
  unsigned int D.5767;
  long unsigned int D.5768;
  struct disappearing_link * * D.5770;
  long unsigned int D.5771;
  long unsigned int D.5772;
  struct disappearing_link * * D.5773;
  long unsigned int D.5774;
  long unsigned int D.5775;
  struct hash_chain_entry * D.5780;
  long unsigned int D.5782;
  long unsigned int D.5783;
  int D.5784;
  struct disappearing_link * curr_dl;
  struct disappearing_link * prev_dl;
  int index;
  void out = <<< error >>>;

  D.5750 = GC_test_and_set (&GC_allocate_lock);
  if (D.5750 != 0) goto <D.5751>; else goto <D.5752>;
  <D.5751>:
  GC_lock ();
  <D.5752>:
  link.8 = (long unsigned int) link;
  D.5754 = link.8 >> 3;
  D.5755 = (unsigned int) D.5754;
  link.8 = (long unsigned int) link;
  D.5756 = dl_hashtbl->log_size;
  D.5757 = (unsigned int) D.5756;
  D.5758 = D.5757 + 3;
  D.5759 = (int) D.5758;
  D.5760 = link.8 >> D.5759;
  D.5761 = (unsigned int) D.5760;
  D.5762 = D.5755 ^ D.5761;
  D.5756 = dl_hashtbl->log_size;
  D.5763 = (int) D.5756;
  D.5764 = 1 << D.5763;
  D.5765 = D.5764 + -1;
  D.5766 = (unsigned int) D.5765;
  D.5767 = D.5762 & D.5766;
  index = (int) D.5767;
  link.8 = (long unsigned int) link;
  D.5768 = link.8 & 7;
  if (D.5768 != 0) goto out; else goto <D.5769>;
  <D.5769>:
  prev_dl = 0B;
  D.5770 = dl_hashtbl->head;
  D.5771 = (long unsigned int) index;
  D.5772 = D.5771 * 8;
  D.5773 = D.5770 + D.5772;
  curr_dl = *D.5773;
  goto <D.5427>;
  <D.5426>:
  D.5774 = curr_dl->prolog.hidden_key;
  link.8 = (long unsigned int) link;
  D.5775 = ~link.8;
  if (D.5774 == D.5775) goto <D.5776>; else goto <D.5777>;
  <D.5776>:
  if (prev_dl == 0B) goto <D.5778>; else goto <D.5779>;
  <D.5778>:
  D.5770 = dl_hashtbl->head;
  D.5771 = (long unsigned int) index;
  D.5772 = D.5771 * 8;
  D.5773 = D.5770 + D.5772;
  D.5780 = curr_dl->prolog.next;
  *D.5773 = D.5780;
  goto <D.5781>;
  <D.5779>:
  D.5780 = curr_dl->prolog.next;
  prev_dl->prolog.next = D.5780;
  <D.5781>:
  D.5782 = dl_hashtbl->entries;
  D.5783 = D.5782 + 18446744073709551615;
  dl_hashtbl->entries = D.5783;
  GC_clear (&GC_allocate_lock);
  GC_free (curr_dl);
  D.5784 = 1;
  return D.5784;
  <D.5777>:
  prev_dl = curr_dl;
  curr_dl = curr_dl->prolog.next;
  <D.5427>:
  if (curr_dl != 0B) goto <D.5426>; else goto <D.5428>;
  <D.5428>:
  out:
  GC_clear (&GC_allocate_lock);
  D.5784 = 0;
  return D.5784;
}


GC_register_long_link (void * * link, void * obj)
{
  int D.5786;

  D.5786 = GC_register_disappearing_link_inner (&GC_ll_hashtbl, link, obj);
  return D.5786;
}


GC_unregister_long_link (void * * link)
{
  int D.5788;

  D.5788 = GC_unregister_disappearing_link_inner (&GC_ll_hashtbl, link);
  return D.5788;
}


GC_normal_finalize_mark_proc (char * p)
{
  struct mse * GC_mark_stack_top.9;
  struct mse * GC_mark_stack_top.10;
  struct mse * GC_mark_stack.11;
  long unsigned int GC_mark_stack_size.12;
  long unsigned int D.5797;
  struct mse * D.5798;
  struct mse * GC_mark_stack_top.13;
  struct hdr * hhdr;

  hhdr = GC_find_header (p);
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.5790>; else goto <D.5791>;
    <D.5790>:
    goto <D.5792>;
    <D.5791>:
    GC_mark_stack_top.9 = GC_mark_stack_top;
    GC_mark_stack_top.10 = GC_mark_stack_top.9 + 16;
    GC_mark_stack_top = GC_mark_stack_top.10;
    GC_mark_stack.11 = GC_mark_stack;
    GC_mark_stack_size.12 = GC_mark_stack_size;
    D.5797 = GC_mark_stack_size.12 * 16;
    D.5798 = GC_mark_stack.11 + D.5797;
    GC_mark_stack_top.9 = GC_mark_stack_top;
    if (D.5798 <= GC_mark_stack_top.9) goto <D.5799>; else goto <D.5800>;
    <D.5799>:
    GC_mark_stack_top.9 = GC_mark_stack_top;
    GC_mark_stack_top.13 = GC_signal_mark_stack_overflow (GC_mark_stack_top.9);
    GC_mark_stack_top = GC_mark_stack_top.13;
    <D.5800>:
    GC_mark_stack_top.9 = GC_mark_stack_top;
    GC_mark_stack_top.9->mse_start = p;
    GC_mark_stack_top.9 = GC_mark_stack_top;
    GC_mark_stack_top.9->mse_descr = _descr;
    <D.5792>:
  }
}


GC_ignore_self_finalize_mark_proc (char * p)
{
  long unsigned int D.5802;
  long unsigned int D.5803;
  sizetype D.5804;
  long unsigned int D.5805;
  sizetype D.5808;
  void * GC_least_plausible_heap_addr.14;
  void * GC_greatest_plausible_heap_addr.15;
  struct mse * GC_mark_stack_top.16;
  struct mse * GC_mark_stack_limit.17;
  struct GC_ms_entry * GC_mark_stack_top.18;
  struct hdr * hhdr;
  word descr;
  char * q;
  char * r;
  char * scan_limit;
  char * target_limit;

  hhdr = GC_find_header (p);
  descr = hhdr->hb_descr;
  D.5802 = hhdr->hb_sz;
  D.5803 = D.5802 << 3;
  D.5804 = D.5803 + 18446744073709551615;
  target_limit = p + D.5804;
  D.5805 = descr & 3;
  if (D.5805 == 0) goto <D.5806>; else goto <D.5807>;
  <D.5806>:
  D.5808 = descr + 18446744073709551608;
  scan_limit = p + D.5808;
  goto <D.5809>;
  <D.5807>:
  scan_limit = target_limit + 18446744073709551609;
  <D.5809>:
  q = p;
  goto <D.5451>;
  <D.5450>:
  r = MEM[(char * *)q];
  if (r < p) goto <D.5810>; else goto <D.5812>;
  <D.5812>:
  if (r > target_limit) goto <D.5810>; else goto <D.5811>;
  <D.5810>:
  GC_least_plausible_heap_addr.14 = GC_least_plausible_heap_addr;
  if (r >= GC_least_plausible_heap_addr.14) goto <D.5814>; else goto <D.5815>;
  <D.5814>:
  GC_greatest_plausible_heap_addr.15 = GC_greatest_plausible_heap_addr;
  if (r < GC_greatest_plausible_heap_addr.15) goto <D.5817>; else goto <D.5818>;
  <D.5817>:
  GC_mark_stack_top.16 = GC_mark_stack_top;
  GC_mark_stack_limit.17 = GC_mark_stack_limit;
  GC_mark_stack_top.18 = GC_mark_and_push (r, GC_mark_stack_top.16, GC_mark_stack_limit.17, q);
  GC_mark_stack_top = GC_mark_stack_top.18;
  <D.5818>:
  <D.5815>:
  <D.5811>:
  q = q + 8;
  <D.5451>:
  if (q <= scan_limit) goto <D.5450>; else goto <D.5452>;
  <D.5452>:
}


GC_null_finalize_mark_proc (char * p)
{

}


GC_register_finalizer_inner (void * obj, void (*GC_finalization_proc) (void *, void *) fn, void * cd, void (*GC_finalization_proc) (void *, void *) * ofn, void * * ocd, void (*<Tdfc>) () mp)
{
  int D.5822;
  long int log_fo_table_size.19;
  int D.5829;
  long unsigned int D.5830;
  long unsigned int GC_fo_entries.20;
  int GC_print_stats.21;
  int D.5835;
  long int D.5836;
  long unsigned int base.22;
  long unsigned int D.5838;
  unsigned int D.5839;
  unsigned int D.5840;
  unsigned int D.5841;
  int D.5842;
  long unsigned int D.5843;
  unsigned int D.5844;
  unsigned int D.5845;
  int D.5846;
  unsigned int D.5847;
  unsigned int D.5848;
  struct finalizable_object * * fo_head.23;
  long unsigned int D.5850;
  long unsigned int D.5851;
  struct finalizable_object * * D.5852;
  long unsigned int D.5853;
  long unsigned int D.5854;
  char * D.5859;
  void (*<T3fc>) (void *, void *) D.5862;
  struct hash_chain_entry * D.5865;
  long unsigned int GC_fo_entries.24;
  long unsigned int D.5880;
  long unsigned int D.5881;
  struct bottom_index * D.5883;
  long unsigned int D.5884;
  long unsigned int D.5885;
  void * (*<T398>) (size_t) GC_oom_fn.25;
  unsigned int GC_finalization_failures.26;
  unsigned int GC_finalization_failures.27;
  int D.5895;
  long unsigned int D.5898;
  struct finalizable_object * D.5899;
  long unsigned int GC_fo_entries.28;
  char * base;
  struct finalizable_object * curr_fo;
  struct finalizable_object * prev_fo;
  int index;
  struct finalizable_object * new_fo;
  struct hdr * hhdr;

  D.5822 = GC_test_and_set (&GC_allocate_lock);
  if (D.5822 != 0) goto <D.5823>; else goto <D.5824>;
  <D.5823>:
  GC_lock ();
  <D.5824>:
  log_fo_table_size.19 = log_fo_table_size;
  if (log_fo_table_size.19 == -1) goto <D.5825>; else goto <D.5828>;
  <D.5828>:
  log_fo_table_size.19 = log_fo_table_size;
  D.5829 = (int) log_fo_table_size.19;
  D.5830 = 1 << D.5829;
  GC_fo_entries.20 = GC_fo_entries;
  if (D.5830 < GC_fo_entries.20) goto <D.5825>; else goto <D.5826>;
  <D.5825>:
  GC_grow_table (&fo_head, &log_fo_table_size);
  GC_print_stats.21 = GC_print_stats;
  if (GC_print_stats.21 != 0) goto <D.5833>; else goto <D.5834>;
  <D.5833>:
  log_fo_table_size.19 = log_fo_table_size;
  D.5829 = (int) log_fo_table_size.19;
  D.5835 = 1 << D.5829;
  D.5836 = (long int) D.5835;
  GC_printf ("Grew fo table to %lu entries\n", D.5836, 0, 0, 0, 0, 0);
  <D.5834>:
  <D.5826>:
  base = obj;
  base.22 = (long unsigned int) base;
  D.5838 = base.22 >> 3;
  D.5839 = (unsigned int) D.5838;
  base.22 = (long unsigned int) base;
  log_fo_table_size.19 = log_fo_table_size;
  D.5840 = (unsigned int) log_fo_table_size.19;
  D.5841 = D.5840 + 3;
  D.5842 = (int) D.5841;
  D.5843 = base.22 >> D.5842;
  D.5844 = (unsigned int) D.5843;
  D.5845 = D.5839 ^ D.5844;
  log_fo_table_size.19 = log_fo_table_size;
  D.5829 = (int) log_fo_table_size.19;
  D.5835 = 1 << D.5829;
  D.5846 = D.5835 + -1;
  D.5847 = (unsigned int) D.5846;
  D.5848 = D.5845 & D.5847;
  index = (int) D.5848;
  prev_fo = 0B;
  fo_head.23 = fo_head;
  D.5850 = (long unsigned int) index;
  D.5851 = D.5850 * 8;
  D.5852 = fo_head.23 + D.5851;
  curr_fo = *D.5852;
  goto <D.5471>;
  <D.5470>:
  D.5853 = curr_fo->prolog.hidden_key;
  base.22 = (long unsigned int) base;
  D.5854 = ~base.22;
  if (D.5853 == D.5854) goto <D.5855>; else goto <D.5856>;
  <D.5855>:
  if (ocd != 0B) goto <D.5857>; else goto <D.5858>;
  <D.5857>:
  D.5859 = curr_fo->fo_client_data;
  *ocd = D.5859;
  <D.5858>:
  if (ofn != 0B) goto <D.5860>; else goto <D.5861>;
  <D.5860>:
  D.5862 = curr_fo->fo_fn;
  *ofn = D.5862;
  <D.5861>:
  if (prev_fo == 0B) goto <D.5863>; else goto <D.5864>;
  <D.5863>:
  fo_head.23 = fo_head;
  D.5850 = (long unsigned int) index;
  D.5851 = D.5850 * 8;
  D.5852 = fo_head.23 + D.5851;
  D.5865 = curr_fo->prolog.next;
  *D.5852 = D.5865;
  goto <D.5866>;
  <D.5864>:
  D.5865 = curr_fo->prolog.next;
  prev_fo->prolog.next = D.5865;
  <D.5866>:
  if (fn == 0B) goto <D.5867>; else goto <D.5868>;
  <D.5867>:
  GC_fo_entries.20 = GC_fo_entries;
  GC_fo_entries.24 = GC_fo_entries.20 + 18446744073709551615;
  GC_fo_entries = GC_fo_entries.24;
  goto <D.5870>;
  <D.5868>:
  curr_fo->fo_fn = fn;
  curr_fo->fo_client_data = cd;
  curr_fo->fo_mark_proc = mp;
  if (prev_fo == 0B) goto <D.5871>; else goto <D.5872>;
  <D.5871>:
  fo_head.23 = fo_head;
  D.5850 = (long unsigned int) index;
  D.5851 = D.5850 * 8;
  D.5852 = fo_head.23 + D.5851;
  *D.5852 = curr_fo;
  goto <D.5873>;
  <D.5872>:
  prev_fo->prolog.next = curr_fo;
  <D.5873>:
  <D.5870>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.5856>:
  prev_fo = curr_fo;
  curr_fo = curr_fo->prolog.next;
  <D.5471>:
  if (curr_fo != 0B) goto <D.5470>; else goto <D.5472>;
  <D.5472>:
  if (ofn != 0B) goto <D.5874>; else goto <D.5875>;
  <D.5874>:
  *ofn = 0B;
  <D.5875>:
  if (ocd != 0B) goto <D.5876>; else goto <D.5877>;
  <D.5876>:
  *ocd = 0B;
  <D.5877>:
  if (fn == 0B) goto <D.5878>; else goto <D.5879>;
  <D.5878>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.5879>:
  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        base.22 = (long unsigned int) base;
        hi = base.22 >> 22;
        D.5880 = hi & 2047;
        _bi = GC_arrays._top_index[D.5880];
        goto <D.5478>;
        <D.5477>:
        _bi = _bi->hash_link;
        <D.5478>:
        D.5881 = _bi->key;
        if (D.5881 != hi) goto <D.5882>; else goto <D.5479>;
        <D.5882>:
        D.5883 = GC_arrays._all_nils;
        if (D.5883 != _bi) goto <D.5477>; else goto <D.5479>;
        <D.5479>:
        bi = _bi;
      }
      base.22 = (long unsigned int) base;
      D.5884 = base.22 >> 12;
      D.5885 = D.5884 & 1023;
      _ha = &bi->index[D.5885];
    }
    hhdr = *_ha;
  }
  if (hhdr == 0B) goto <D.5886>; else goto <D.5887>;
  <D.5886>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.5887>:
  new_fo = GC_generic_malloc_inner (48, 1);
  if (new_fo == 0B) goto <D.5888>; else goto <D.5889>;
  <D.5888>:
  GC_clear (&GC_allocate_lock);
  GC_oom_fn.25 = GC_oom_fn;
  new_fo = GC_oom_fn.25 (48);
  if (new_fo == 0B) goto <D.5891>; else goto <D.5892>;
  <D.5891>:
  GC_finalization_failures.26 = GC_finalization_failures;
  GC_finalization_failures.27 = GC_finalization_failures.26 + 1;
  GC_finalization_failures = GC_finalization_failures.27;
  return;
  <D.5892>:
  D.5895 = GC_test_and_set (&GC_allocate_lock);
  if (D.5895 != 0) goto <D.5896>; else goto <D.5897>;
  <D.5896>:
  GC_lock ();
  <D.5897>:
  <D.5889>:
  base.22 = (long unsigned int) base;
  D.5854 = ~base.22;
  new_fo->prolog.hidden_key = D.5854;
  new_fo->fo_fn = fn;
  new_fo->fo_client_data = cd;
  D.5898 = hhdr->hb_sz;
  new_fo->fo_object_size = D.5898;
  new_fo->fo_mark_proc = mp;
  fo_head.23 = fo_head;
  D.5850 = (long unsigned int) index;
  D.5851 = D.5850 * 8;
  D.5852 = fo_head.23 + D.5851;
  D.5899 = *D.5852;
  new_fo->prolog.next = D.5899;
  GC_fo_entries.20 = GC_fo_entries;
  GC_fo_entries.28 = GC_fo_entries.20 + 1;
  GC_fo_entries = GC_fo_entries.28;
  fo_head.23 = fo_head;
  D.5850 = (long unsigned int) index;
  D.5851 = D.5850 * 8;
  D.5852 = fo_head.23 + D.5851;
  *D.5852 = new_fo;
  GC_clear (&GC_allocate_lock);
}


GC_register_finalizer (void * obj, void (*GC_finalization_proc) (void *, void *) fn, void * cd, void (*GC_finalization_proc) (void *, void *) * ofn, void * * ocd)
{
  GC_register_finalizer_inner (obj, fn, cd, ofn, ocd, GC_normal_finalize_mark_proc);
}


GC_register_finalizer_ignore_self (void * obj, void (*GC_finalization_proc) (void *, void *) fn, void * cd, void (*GC_finalization_proc) (void *, void *) * ofn, void * * ocd)
{
  GC_register_finalizer_inner (obj, fn, cd, ofn, ocd, GC_ignore_self_finalize_mark_proc);
}


GC_register_finalizer_no_order (void * obj, void (*GC_finalization_proc) (void *, void *) fn, void * cd, void (*GC_finalization_proc) (void *, void *) * ofn, void * * ocd)
{
  GC_register_finalizer_inner (obj, fn, cd, ofn, ocd, GC_null_finalize_mark_proc);
}


GC_dump_finalization ()
{
  int iftmp.29;
  long int log_fo_table_size.30;
  int D.5906;
  struct finalizable_object * * fo_head.31;
  long unsigned int D.5909;
  long unsigned int D.5910;
  struct finalizable_object * * D.5911;
  long unsigned int D.5912;
  long unsigned int D.5913;
  long int real_ptr.32;
  struct finalizable_object * curr_fo;
  char * real_ptr;
  int fo_size;
  int i;

  log_fo_table_size.30 = log_fo_table_size;
  if (log_fo_table_size.30 != -1) goto <D.5904>; else goto <D.5905>;
  <D.5904>:
  log_fo_table_size.30 = log_fo_table_size;
  D.5906 = (int) log_fo_table_size.30;
  iftmp.29 = 1 << D.5906;
  goto <D.5907>;
  <D.5905>:
  iftmp.29 = 0;
  <D.5907>:
  fo_size = iftmp.29;
  GC_printf ("Disappearing (short) links:\n", 0, 0, 0, 0, 0, 0);
  GC_dump_finalization_links (&GC_dl_hashtbl);
  GC_printf ("Disappearing long links:\n", 0, 0, 0, 0, 0, 0);
  GC_dump_finalization_links (&GC_ll_hashtbl);
  GC_printf ("Finalizers:\n", 0, 0, 0, 0, 0, 0);
  i = 0;
  goto <D.5525>;
  <D.5524>:
  fo_head.31 = fo_head;
  D.5909 = (long unsigned int) i;
  D.5910 = D.5909 * 8;
  D.5911 = fo_head.31 + D.5910;
  curr_fo = *D.5911;
  goto <D.5522>;
  <D.5521>:
  D.5912 = curr_fo->prolog.hidden_key;
  D.5913 = ~D.5912;
  real_ptr = (char *) D.5913;
  real_ptr.32 = (long int) real_ptr;
  GC_printf ("Finalizable object: 0x%lx\n", real_ptr.32, 0, 0, 0, 0, 0);
  curr_fo = curr_fo->prolog.next;
  <D.5522>:
  if (curr_fo != 0B) goto <D.5521>; else goto <D.5523>;
  <D.5523>:
  i = i + 1;
  <D.5525>:
  if (i < fo_size) goto <D.5524>; else goto <D.5526>;
  <D.5526>:
}


GC_dump_finalization_links (struct dl_hashtbl_s * dl_hashtbl)
{
  size_t iftmp.33;
  long int D.5916;
  int D.5919;
  int D.5920;
  struct disappearing_link * * D.5922;
  long unsigned int D.5923;
  long unsigned int D.5924;
  struct disappearing_link * * D.5925;
  long unsigned int D.5926;
  long unsigned int D.5927;
  long unsigned int D.5928;
  long unsigned int D.5929;
  long int real_ptr.34;
  long int real_link.35;
  long unsigned int D.5932;
  struct disappearing_link * curr_dl;
  char * real_ptr;
  char * real_link;
  size_t dl_size;
  int i;

  D.5916 = dl_hashtbl->log_size;
  if (D.5916 != -1) goto <D.5917>; else goto <D.5918>;
  <D.5917>:
  D.5916 = dl_hashtbl->log_size;
  D.5919 = (int) D.5916;
  D.5920 = 1 << D.5919;
  iftmp.33 = (size_t) D.5920;
  goto <D.5921>;
  <D.5918>:
  iftmp.33 = 0;
  <D.5921>:
  dl_size = iftmp.33;
  i = 0;
  goto <D.5513>;
  <D.5512>:
  D.5922 = dl_hashtbl->head;
  D.5923 = (long unsigned int) i;
  D.5924 = D.5923 * 8;
  D.5925 = D.5922 + D.5924;
  curr_dl = *D.5925;
  goto <D.5510>;
  <D.5509>:
  D.5926 = curr_dl->dl_hidden_obj;
  D.5927 = ~D.5926;
  real_ptr = (char *) D.5927;
  D.5928 = curr_dl->prolog.hidden_key;
  D.5929 = ~D.5928;
  real_link = (char *) D.5929;
  real_ptr.34 = (long int) real_ptr;
  real_link.35 = (long int) real_link;
  GC_printf ("Object: %lx, link: %lx\n", real_ptr.34, real_link.35, 0, 0, 0, 0);
  curr_dl = curr_dl->prolog.next;
  <D.5510>:
  if (curr_dl != 0B) goto <D.5509>; else goto <D.5511>;
  <D.5511>:
  i = i + 1;
  <D.5513>:
  D.5932 = (long unsigned int) i;
  if (D.5932 < dl_size) goto <D.5512>; else goto <D.5514>;
  <D.5514>:
}


GC_finalize ()
{
  int iftmp.36;
  long int log_fo_table_size.37;
  int D.5937;
  struct finalizable_object * * fo_head.38;
  long unsigned int D.5940;
  long unsigned int D.5941;
  struct finalizable_object * * D.5942;
  long unsigned int D.5943;
  long unsigned int D.5944;
  int D.5945;
  void (*<Tdfc>) () D.5948;
  struct mse * GC_mark_stack_top.39;
  struct mse * GC_mark_stack.40;
  long unsigned int GC_mark_stack_size.41;
  long unsigned int D.5952;
  struct mse * D.5953;
  struct mse * GC_mark_stack_top.42;
  int D.5955;
  int GC_mark_state.43;
  int D.5959;
  int D.5960;
  void (*<T41b>) (char *, GC_word) GC_current_warn_proc.44;
  long unsigned int real_ptr.45;
  int D.5965;
  int GC_java_finalization.46;
  long unsigned int GC_fo_entries.47;
  long unsigned int GC_fo_entries.48;
  struct finalizable_object * GC_finalize_now.49;
  long unsigned int D.5977;
  long unsigned int D.5978;
  int GC_all_interior_pointers.50;
  int D.5980;
  long unsigned int D.5981;
  long unsigned int D.5982;
  long unsigned int D.5983;
  long unsigned int D.5984;
  long unsigned int D.5985;
  long unsigned int D.5986;
  long unsigned int D.5987;
  long unsigned int D.5988;
  int D.5992;
  struct mse * GC_mark_stack_top.51;
  int D.5998;
  int D.6001;
  struct finalizable_object * curr_fo;
  struct finalizable_object * prev_fo;
  struct finalizable_object * next_fo;
  char * real_ptr;
  register int i;
  int fo_size;

  log_fo_table_size.37 = log_fo_table_size;
  if (log_fo_table_size.37 != -1) goto <D.5935>; else goto <D.5936>;
  <D.5935>:
  log_fo_table_size.37 = log_fo_table_size;
  D.5937 = (int) log_fo_table_size.37;
  iftmp.36 = 1 << D.5937;
  goto <D.5938>;
  <D.5936>:
  iftmp.36 = 0;
  <D.5938>:
  fo_size = iftmp.36;
  GC_make_disappearing_links_disappear (&GC_dl_hashtbl);
  i = 0;
  goto <D.5577>;
  <D.5576>:
  fo_head.38 = fo_head;
  D.5940 = (long unsigned int) i;
  D.5941 = D.5940 * 8;
  D.5942 = fo_head.38 + D.5941;
  curr_fo = *D.5942;
  goto <D.5574>;
  <D.5573>:
  D.5943 = curr_fo->prolog.hidden_key;
  D.5944 = ~D.5943;
  real_ptr = (char *) D.5944;
  D.5945 = GC_is_marked (real_ptr);
  if (D.5945 == 0) goto <D.5946>; else goto <D.5947>;
  <D.5946>:
  D.5948 = curr_fo->fo_mark_proc;
  D.5948 (real_ptr);
  goto <D.5568>;
  <D.5567>:
  GC_mark_stack_top.39 = GC_mark_stack_top;
  GC_mark_stack.40 = GC_mark_stack;
  GC_mark_stack.40 = GC_mark_stack;
  GC_mark_stack_size.41 = GC_mark_stack_size;
  D.5952 = GC_mark_stack_size.41 * 16;
  D.5953 = GC_mark_stack.40 + D.5952;
  GC_mark_stack_top.42 = GC_mark_from (GC_mark_stack_top.39, GC_mark_stack.40, D.5953);
  GC_mark_stack_top = GC_mark_stack_top.42;
  <D.5568>:
  D.5955 = GC_mark_stack_empty ();
  if (D.5955 == 0) goto <D.5567>; else goto <D.5569>;
  <D.5569>:
  GC_mark_state.43 = GC_mark_state;
  if (GC_mark_state.43 != 0) goto <D.5957>; else goto <D.5958>;
  <D.5957>:
  GC_set_mark_bit (real_ptr);
  goto <D.5571>;
  <D.5570>:
  <D.5571>:
  D.5959 = GC_mark_some (0B);
  if (D.5959 == 0) goto <D.5570>; else goto <D.5572>;
  <D.5572>:
  <D.5958>:
  D.5960 = GC_is_marked (real_ptr);
  if (D.5960 != 0) goto <D.5961>; else goto <D.5962>;
  <D.5961>:
  GC_current_warn_proc.44 = GC_current_warn_proc;
  real_ptr.45 = (long unsigned int) real_ptr;
  GC_current_warn_proc.44 ("GC Warning: Finalization cycle involving %lx\n", real_ptr.45);
  <D.5962>:
  <D.5947>:
  curr_fo = curr_fo->prolog.next;
  <D.5574>:
  if (curr_fo != 0B) goto <D.5573>; else goto <D.5575>;
  <D.5575>:
  i = i + 1;
  <D.5577>:
  if (i < fo_size) goto <D.5576>; else goto <D.5578>;
  <D.5578>:
  GC_arrays._words_finalized = 0;
  i = 0;
  goto <D.5583>;
  <D.5582>:
  fo_head.38 = fo_head;
  D.5940 = (long unsigned int) i;
  D.5941 = D.5940 * 8;
  D.5942 = fo_head.38 + D.5941;
  curr_fo = *D.5942;
  prev_fo = 0B;
  goto <D.5580>;
  <D.5579>:
  D.5943 = curr_fo->prolog.hidden_key;
  D.5944 = ~D.5943;
  real_ptr = (char *) D.5944;
  D.5965 = GC_is_marked (real_ptr);
  if (D.5965 == 0) goto <D.5966>; else goto <D.5967>;
  <D.5966>:
  GC_java_finalization.46 = GC_java_finalization;
  if (GC_java_finalization.46 == 0) goto <D.5969>; else goto <D.5970>;
  <D.5969>:
  GC_set_mark_bit (real_ptr);
  <D.5970>:
  next_fo = curr_fo->prolog.next;
  if (prev_fo == 0B) goto <D.5971>; else goto <D.5972>;
  <D.5971>:
  fo_head.38 = fo_head;
  D.5940 = (long unsigned int) i;
  D.5941 = D.5940 * 8;
  D.5942 = fo_head.38 + D.5941;
  *D.5942 = next_fo;
  goto <D.5973>;
  <D.5972>:
  prev_fo->prolog.next = next_fo;
  <D.5973>:
  GC_fo_entries.47 = GC_fo_entries;
  GC_fo_entries.48 = GC_fo_entries.47 + 18446744073709551615;
  GC_fo_entries = GC_fo_entries.48;
  GC_finalize_now.49 = GC_finalize_now;
  curr_fo->prolog.next = GC_finalize_now.49;
  GC_finalize_now = curr_fo;
  D.5943 = curr_fo->prolog.hidden_key;
  D.5944 = ~D.5943;
  curr_fo->prolog.hidden_key = D.5944;
  D.5977 = GC_arrays._words_finalized;
  D.5978 = curr_fo->fo_object_size;
  GC_all_interior_pointers.50 = GC_all_interior_pointers;
  D.5980 = GC_all_interior_pointers.50 + 7;
  D.5981 = (long unsigned int) D.5980;
  D.5982 = D.5978 + D.5981;
  D.5983 = D.5982 >> 3;
  GC_all_interior_pointers.50 = GC_all_interior_pointers;
  D.5980 = GC_all_interior_pointers.50 + 7;
  D.5984 = (long unsigned int) D.5980;
  D.5985 = D.5984 + 48;
  D.5986 = D.5985 >> 3;
  D.5987 = D.5983 + D.5986;
  D.5988 = D.5977 + D.5987;
  GC_arrays._words_finalized = D.5988;
  curr_fo = next_fo;
  goto <D.5989>;
  <D.5967>:
  prev_fo = curr_fo;
  curr_fo = curr_fo->prolog.next;
  <D.5989>:
  <D.5580>:
  if (curr_fo != 0B) goto <D.5579>; else goto <D.5581>;
  <D.5581>:
  i = i + 1;
  <D.5583>:
  if (i < fo_size) goto <D.5582>; else goto <D.5584>;
  <D.5584>:
  GC_java_finalization.46 = GC_java_finalization;
  if (GC_java_finalization.46 != 0) goto <D.5990>; else goto <D.5991>;
  <D.5990>:
  curr_fo = GC_finalize_now;
  goto <D.5592>;
  <D.5591>:
  D.5943 = curr_fo->prolog.hidden_key;
  real_ptr = (char *) D.5943;
  D.5992 = GC_is_marked (real_ptr);
  if (D.5992 == 0) goto <D.5993>; else goto <D.5994>;
  <D.5993>:
  D.5948 = curr_fo->fo_mark_proc;
  if (D.5948 == GC_null_finalize_mark_proc) goto <D.5995>; else goto <D.5996>;
  <D.5995>:
  GC_normal_finalize_mark_proc (real_ptr);
  goto <D.5586>;
  <D.5585>:
  GC_mark_stack_top.39 = GC_mark_stack_top;
  GC_mark_stack.40 = GC_mark_stack;
  GC_mark_stack.40 = GC_mark_stack;
  GC_mark_stack_size.41 = GC_mark_stack_size;
  D.5952 = GC_mark_stack_size.41 * 16;
  D.5953 = GC_mark_stack.40 + D.5952;
  GC_mark_stack_top.51 = GC_mark_from (GC_mark_stack_top.39, GC_mark_stack.40, D.5953);
  GC_mark_stack_top = GC_mark_stack_top.51;
  <D.5586>:
  D.5998 = GC_mark_stack_empty ();
  if (D.5998 == 0) goto <D.5585>; else goto <D.5587>;
  <D.5587>:
  GC_mark_state.43 = GC_mark_state;
  if (GC_mark_state.43 != 0) goto <D.5999>; else goto <D.6000>;
  <D.5999>:
  GC_set_mark_bit (real_ptr);
  goto <D.5589>;
  <D.5588>:
  <D.5589>:
  D.6001 = GC_mark_some (0B);
  if (D.6001 == 0) goto <D.5588>; else goto <D.5590>;
  <D.5590>:
  <D.6000>:
  <D.5996>:
  GC_set_mark_bit (real_ptr);
  <D.5994>:
  curr_fo = curr_fo->prolog.next;
  <D.5592>:
  if (curr_fo != 0B) goto <D.5591>; else goto <D.5593>;
  <D.5593>:
  <D.5991>:
  GC_remove_dangling_disappearing_links (&GC_dl_hashtbl);
  GC_make_disappearing_links_disappear (&GC_ll_hashtbl);
  GC_remove_dangling_disappearing_links (&GC_ll_hashtbl);
}


GC_make_disappearing_links_disappear (struct dl_hashtbl_s * dl_hashtbl)
{
  int iftmp.52;
  long int D.6003;
  int D.6006;
  struct disappearing_link * * D.6008;
  long unsigned int D.6009;
  long unsigned int D.6010;
  struct disappearing_link * * D.6011;
  long unsigned int D.6012;
  long unsigned int D.6013;
  long unsigned int D.6014;
  long unsigned int D.6015;
  int D.6016;
  long unsigned int D.6022;
  long unsigned int D.6023;
  struct disappearing_link * curr_dl;
  struct disappearing_link * prev_dl;
  struct disappearing_link * next_dl;
  char * real_ptr;
  char * real_link;
  register int i;
  int dl_size;

  D.6003 = dl_hashtbl->log_size;
  if (D.6003 != -1) goto <D.6004>; else goto <D.6005>;
  <D.6004>:
  D.6003 = dl_hashtbl->log_size;
  D.6006 = (int) D.6003;
  iftmp.52 = 1 << D.6006;
  goto <D.6007>;
  <D.6005>:
  iftmp.52 = 0;
  <D.6007>:
  dl_size = iftmp.52;
  i = 0;
  goto <D.5541>;
  <D.5540>:
  D.6008 = dl_hashtbl->head;
  D.6009 = (long unsigned int) i;
  D.6010 = D.6009 * 8;
  D.6011 = D.6008 + D.6010;
  curr_dl = *D.6011;
  prev_dl = 0B;
  goto <D.5538>;
  <D.5537>:
  D.6012 = curr_dl->dl_hidden_obj;
  D.6013 = ~D.6012;
  real_ptr = (char *) D.6013;
  D.6014 = curr_dl->prolog.hidden_key;
  D.6015 = ~D.6014;
  real_link = (char *) D.6015;
  D.6016 = GC_is_marked (real_ptr);
  if (D.6016 == 0) goto <D.6017>; else goto <D.6018>;
  <D.6017>:
  MEM[(word *)real_link] = 0;
  next_dl = curr_dl->prolog.next;
  if (prev_dl == 0B) goto <D.6019>; else goto <D.6020>;
  <D.6019>:
  D.6008 = dl_hashtbl->head;
  D.6009 = (long unsigned int) i;
  D.6010 = D.6009 * 8;
  D.6011 = D.6008 + D.6010;
  *D.6011 = next_dl;
  goto <D.6021>;
  <D.6020>:
  prev_dl->prolog.next = next_dl;
  <D.6021>:
  GC_clear_mark_bit (curr_dl);
  D.6022 = dl_hashtbl->entries;
  D.6023 = D.6022 + 18446744073709551615;
  dl_hashtbl->entries = D.6023;
  curr_dl = next_dl;
  goto <D.6024>;
  <D.6018>:
  prev_dl = curr_dl;
  curr_dl = curr_dl->prolog.next;
  <D.6024>:
  <D.5538>:
  if (curr_dl != 0B) goto <D.5537>; else goto <D.5539>;
  <D.5539>:
  i = i + 1;
  <D.5541>:
  if (i < dl_size) goto <D.5540>; else goto <D.5542>;
  <D.5542>:
}


GC_remove_dangling_disappearing_links (struct dl_hashtbl_s * dl_hashtbl)
{
  int iftmp.53;
  long int D.6026;
  int D.6029;
  struct disappearing_link * * D.6031;
  long unsigned int D.6032;
  long unsigned int D.6033;
  struct disappearing_link * * D.6034;
  long unsigned int D.6035;
  long unsigned int D.6036;
  void * D.6037;
  int D.6041;
  long unsigned int D.6046;
  long unsigned int D.6047;
  struct disappearing_link * curr_dl;
  struct disappearing_link * prev_dl;
  struct disappearing_link * next_dl;
  char * real_ptr;
  char * real_link;
  register int i;
  int dl_size;

  D.6026 = dl_hashtbl->log_size;
  if (D.6026 != -1) goto <D.6027>; else goto <D.6028>;
  <D.6027>:
  D.6026 = dl_hashtbl->log_size;
  D.6029 = (int) D.6026;
  iftmp.53 = 1 << D.6029;
  goto <D.6030>;
  <D.6028>:
  iftmp.53 = 0;
  <D.6030>:
  dl_size = iftmp.53;
  i = 0;
  goto <D.5557>;
  <D.5556>:
  D.6031 = dl_hashtbl->head;
  D.6032 = (long unsigned int) i;
  D.6033 = D.6032 * 8;
  D.6034 = D.6031 + D.6033;
  curr_dl = *D.6034;
  prev_dl = 0B;
  goto <D.5554>;
  <D.5553>:
  D.6035 = curr_dl->prolog.hidden_key;
  D.6036 = ~D.6035;
  D.6037 = (void *) D.6036;
  real_link = GC_base (D.6037);
  if (real_link != 0B) goto <D.6040>; else goto <D.6038>;
  <D.6040>:
  D.6041 = GC_is_marked (real_link);
  if (D.6041 == 0) goto <D.6042>; else goto <D.6038>;
  <D.6042>:
  next_dl = curr_dl->prolog.next;
  if (prev_dl == 0B) goto <D.6043>; else goto <D.6044>;
  <D.6043>:
  D.6031 = dl_hashtbl->head;
  D.6032 = (long unsigned int) i;
  D.6033 = D.6032 * 8;
  D.6034 = D.6031 + D.6033;
  *D.6034 = next_dl;
  goto <D.6045>;
  <D.6044>:
  prev_dl->prolog.next = next_dl;
  <D.6045>:
  GC_clear_mark_bit (curr_dl);
  D.6046 = dl_hashtbl->entries;
  D.6047 = D.6046 + 18446744073709551615;
  dl_hashtbl->entries = D.6047;
  curr_dl = next_dl;
  goto <D.6039>;
  <D.6038>:
  prev_dl = curr_dl;
  curr_dl = curr_dl->prolog.next;
  <D.6039>:
  <D.5554>:
  if (curr_dl != 0B) goto <D.5553>; else goto <D.5555>;
  <D.5555>:
  i = i + 1;
  <D.5557>:
  if (i < dl_size) goto <D.5556>; else goto <D.5558>;
  <D.5558>:
}


GC_enqueue_all_finalizers ()
{
  int iftmp.54;
  long int log_fo_table_size.55;
  int D.6052;
  struct finalizable_object * * fo_head.56;
  long unsigned int D.6055;
  long unsigned int D.6056;
  struct finalizable_object * * D.6057;
  long unsigned int D.6058;
  long unsigned int D.6059;
  struct mse * GC_mark_stack_top.57;
  struct mse * GC_mark_stack.58;
  long unsigned int GC_mark_stack_size.59;
  long unsigned int D.6063;
  struct mse * D.6064;
  struct mse * GC_mark_stack_top.60;
  int D.6066;
  int GC_mark_state.61;
  int D.6070;
  long unsigned int GC_fo_entries.62;
  long unsigned int GC_fo_entries.63;
  struct finalizable_object * GC_finalize_now.64;
  long unsigned int D.6077;
  long unsigned int D.6078;
  int GC_all_interior_pointers.65;
  int D.6080;
  long unsigned int D.6081;
  long unsigned int D.6082;
  long unsigned int D.6083;
  long unsigned int D.6084;
  long unsigned int D.6085;
  long unsigned int D.6086;
  long unsigned int D.6087;
  long unsigned int D.6088;
  struct finalizable_object * curr_fo;
  struct finalizable_object * prev_fo;
  struct finalizable_object * next_fo;
  char * real_ptr;
  register int i;
  int fo_size;

  log_fo_table_size.55 = log_fo_table_size;
  if (log_fo_table_size.55 != -1) goto <D.6050>; else goto <D.6051>;
  <D.6050>:
  log_fo_table_size.55 = log_fo_table_size;
  D.6052 = (int) log_fo_table_size.55;
  iftmp.54 = 1 << D.6052;
  goto <D.6053>;
  <D.6051>:
  iftmp.54 = 0;
  <D.6053>:
  fo_size = iftmp.54;
  GC_arrays._words_finalized = 0;
  i = 0;
  goto <D.5612>;
  <D.5611>:
  fo_head.56 = fo_head;
  D.6055 = (long unsigned int) i;
  D.6056 = D.6055 * 8;
  D.6057 = fo_head.56 + D.6056;
  curr_fo = *D.6057;
  prev_fo = 0B;
  goto <D.5609>;
  <D.5608>:
  D.6058 = curr_fo->prolog.hidden_key;
  D.6059 = ~D.6058;
  real_ptr = (char *) D.6059;
  GC_normal_finalize_mark_proc (real_ptr);
  goto <D.5603>;
  <D.5602>:
  GC_mark_stack_top.57 = GC_mark_stack_top;
  GC_mark_stack.58 = GC_mark_stack;
  GC_mark_stack.58 = GC_mark_stack;
  GC_mark_stack_size.59 = GC_mark_stack_size;
  D.6063 = GC_mark_stack_size.59 * 16;
  D.6064 = GC_mark_stack.58 + D.6063;
  GC_mark_stack_top.60 = GC_mark_from (GC_mark_stack_top.57, GC_mark_stack.58, D.6064);
  GC_mark_stack_top = GC_mark_stack_top.60;
  <D.5603>:
  D.6066 = GC_mark_stack_empty ();
  if (D.6066 == 0) goto <D.5602>; else goto <D.5604>;
  <D.5604>:
  GC_mark_state.61 = GC_mark_state;
  if (GC_mark_state.61 != 0) goto <D.6068>; else goto <D.6069>;
  <D.6068>:
  GC_set_mark_bit (real_ptr);
  goto <D.5606>;
  <D.5605>:
  <D.5606>:
  D.6070 = GC_mark_some (0B);
  if (D.6070 == 0) goto <D.5605>; else goto <D.5607>;
  <D.5607>:
  <D.6069>:
  GC_set_mark_bit (real_ptr);
  next_fo = curr_fo->prolog.next;
  if (prev_fo == 0B) goto <D.6071>; else goto <D.6072>;
  <D.6071>:
  fo_head.56 = fo_head;
  D.6055 = (long unsigned int) i;
  D.6056 = D.6055 * 8;
  D.6057 = fo_head.56 + D.6056;
  *D.6057 = next_fo;
  goto <D.6073>;
  <D.6072>:
  prev_fo->prolog.next = next_fo;
  <D.6073>:
  GC_fo_entries.62 = GC_fo_entries;
  GC_fo_entries.63 = GC_fo_entries.62 + 18446744073709551615;
  GC_fo_entries = GC_fo_entries.63;
  GC_finalize_now.64 = GC_finalize_now;
  curr_fo->prolog.next = GC_finalize_now.64;
  GC_finalize_now = curr_fo;
  D.6058 = curr_fo->prolog.hidden_key;
  D.6059 = ~D.6058;
  curr_fo->prolog.hidden_key = D.6059;
  D.6077 = GC_arrays._words_finalized;
  D.6078 = curr_fo->fo_object_size;
  GC_all_interior_pointers.65 = GC_all_interior_pointers;
  D.6080 = GC_all_interior_pointers.65 + 7;
  D.6081 = (long unsigned int) D.6080;
  D.6082 = D.6078 + D.6081;
  D.6083 = D.6082 >> 3;
  GC_all_interior_pointers.65 = GC_all_interior_pointers;
  D.6080 = GC_all_interior_pointers.65 + 7;
  D.6084 = (long unsigned int) D.6080;
  D.6085 = D.6084 + 48;
  D.6086 = D.6085 >> 3;
  D.6087 = D.6083 + D.6086;
  D.6088 = D.6077 + D.6087;
  GC_arrays._words_finalized = D.6088;
  curr_fo = next_fo;
  <D.5609>:
  if (curr_fo != 0B) goto <D.5608>; else goto <D.5610>;
  <D.5610>:
  i = i + 1;
  <D.5612>:
  if (i < fo_size) goto <D.5611>; else goto <D.5613>;
  <D.5613>:
  return;
}


GC_finalize_all ()
{
  int D.6090;
  int D.6093;
  long unsigned int GC_fo_entries.66;

  D.6090 = GC_test_and_set (&GC_allocate_lock);
  if (D.6090 != 0) goto <D.6091>; else goto <D.6092>;
  <D.6091>:
  GC_lock ();
  <D.6092>:
  goto <D.5617>;
  <D.5616>:
  GC_enqueue_all_finalizers ();
  GC_clear (&GC_allocate_lock);
  GC_notify_or_invoke_finalizers ();
  D.6093 = GC_test_and_set (&GC_allocate_lock);
  if (D.6093 != 0) goto <D.6094>; else goto <D.6095>;
  <D.6094>:
  GC_lock ();
  <D.6095>:
  <D.5617>:
  GC_fo_entries.66 = GC_fo_entries;
  if (GC_fo_entries.66 != 0) goto <D.5616>; else goto <D.5618>;
  <D.5618>:
  GC_clear (&GC_allocate_lock);
}


GC_should_invoke_finalizers ()
{
  int D.6097;
  struct finalizable_object * GC_finalize_now.67;
  _Bool D.6099;

  GC_finalize_now.67 = GC_finalize_now;
  D.6099 = GC_finalize_now.67 != 0B;
  D.6097 = (int) D.6099;
  return D.6097;
}


GC_invoke_finalizers ()
{
  int D.6101;
  struct hash_chain_entry * GC_finalize_now.68;
  void (*<T3fc>) (void *, void *) D.6110;
  long unsigned int D.6111;
  void * D.6112;
  char * D.6113;
  struct finalizable_object * GC_finalize_now.69;
  long unsigned int D.6117;
  int D.6120;
  long unsigned int D.6123;
  long unsigned int D.6124;
  long unsigned int D.6125;
  int D.6126;
  struct finalizable_object * curr_fo;
  int count;
  word mem_freed_before;

  count = 0;
  goto <D.5629>;
  <D.5628>:
  D.6101 = GC_test_and_set (&GC_allocate_lock);
  if (D.6101 != 0) goto <D.6102>; else goto <D.6103>;
  <D.6102>:
  GC_lock ();
  <D.6103>:
  if (count == 0) goto <D.6104>; else goto <D.6105>;
  <D.6104>:
  mem_freed_before = GC_arrays._mem_freed;
  <D.6105>:
  curr_fo = GC_finalize_now;
  if (curr_fo != 0B) goto <D.6106>; else goto <D.6107>;
  <D.6106>:
  GC_finalize_now.68 = curr_fo->prolog.next;
  GC_finalize_now = GC_finalize_now.68;
  <D.6107>:
  GC_clear (&GC_allocate_lock);
  if (curr_fo == 0B) goto <D.5627>; else goto <D.6109>;
  <D.6109>:
  curr_fo->prolog.next = 0B;
  D.6110 = curr_fo->fo_fn;
  D.6111 = curr_fo->prolog.hidden_key;
  D.6112 = (void *) D.6111;
  D.6113 = curr_fo->fo_client_data;
  D.6110 (D.6112, D.6113);
  curr_fo->fo_client_data = 0B;
  count = count + 1;
  <D.5629>:
  GC_finalize_now.69 = GC_finalize_now;
  if (GC_finalize_now.69 != 0B) goto <D.5628>; else goto <D.5627>;
  <D.5627>:
  if (count != 0) goto <D.6115>; else goto <D.6116>;
  <D.6115>:
  D.6117 = GC_arrays._mem_freed;
  if (D.6117 != mem_freed_before) goto <D.6118>; else goto <D.6119>;
  <D.6118>:
  D.6120 = GC_test_and_set (&GC_allocate_lock);
  if (D.6120 != 0) goto <D.6121>; else goto <D.6122>;
  <D.6121>:
  GC_lock ();
  <D.6122>:
  D.6123 = GC_arrays._finalizer_mem_freed;
  D.6117 = GC_arrays._mem_freed;
  D.6124 = D.6117 - mem_freed_before;
  D.6125 = D.6123 + D.6124;
  GC_arrays._finalizer_mem_freed = D.6125;
  GC_clear (&GC_allocate_lock);
  <D.6119>:
  <D.6116>:
  D.6126 = count;
  return D.6126;
}


GC_notify_or_invoke_finalizers ()
{
  struct finalizable_object * GC_finalize_now.70;
  int GC_finalize_on_demand.71;
  void (*<T3a5>) (void) GC_finalizer_notifier.72;
  long unsigned int last_finalizer_notification.73;
  long unsigned int GC_gc_no.74;

  GC_finalize_now.70 = GC_finalize_now;
  if (GC_finalize_now.70 == 0B) goto <D.6129>; else goto <D.6130>;
  <D.6129>:
  return;
  <D.6130>:
  GC_finalize_on_demand.71 = GC_finalize_on_demand;
  if (GC_finalize_on_demand.71 == 0) goto <D.6132>; else goto <D.6133>;
  <D.6132>:
  GC_invoke_finalizers ();
  return;
  <D.6133>:
  GC_finalizer_notifier.72 = GC_finalizer_notifier;
  if (GC_finalizer_notifier.72 != 0B) goto <D.6135>; else goto <D.6136>;
  <D.6135>:
  last_finalizer_notification.73 = last_finalizer_notification;
  GC_gc_no.74 = GC_gc_no;
  if (last_finalizer_notification.73 != GC_gc_no.74) goto <D.6139>; else goto <D.6140>;
  <D.6139>:
  GC_gc_no.74 = GC_gc_no;
  last_finalizer_notification = GC_gc_no.74;
  GC_finalizer_notifier.72 = GC_finalizer_notifier;
  GC_finalizer_notifier.72 ();
  <D.6140>:
  <D.6136>:
}


GC_call_with_alloc_lock (void * (*GC_fn_type) (void *) fn, void * client_data)
{
  int D.6142;
  long unsigned int GC_lock_holder.75;
  void * D.6146;
  void * result;

  D.6142 = GC_test_and_set (&GC_allocate_lock);
  if (D.6142 != 0) goto <D.6143>; else goto <D.6144>;
  <D.6143>:
  GC_lock ();
  <D.6144>:
  GC_lock_holder.75 = pthread_self ();
  GC_lock_holder = GC_lock_holder.75;
  result = fn (client_data);
  GC_lock_holder = 18446744073709551615;
  GC_clear (&GC_allocate_lock);
  D.6146 = result;
  return D.6146;
}


GC_print_finalization_stats ()
{
  long unsigned int GC_fo_entries.76;
  long int GC_fo_entries.77;
  long unsigned int D.6150;
  long int D.6151;
  long unsigned int D.6152;
  long int D.6153;
  long int ready.78;
  struct finalizable_object * fo;
  size_t ready;

  fo = GC_finalize_now;
  ready = 0;
  GC_fo_entries.76 = GC_fo_entries;
  GC_fo_entries.77 = (long int) GC_fo_entries.76;
  D.6150 = GC_dl_hashtbl.entries;
  D.6151 = (long int) D.6150;
  D.6152 = GC_ll_hashtbl.entries;
  D.6153 = (long int) D.6152;
  GC_printf ("%lu finalization table entries; %lu/%lu short/long disappearing links alive\n", GC_fo_entries.77, D.6151, D.6153, 0, 0, 0);
  goto <D.5647>;
  <D.5646>:
  ready = ready + 1;
  fo = fo->prolog.next;
  <D.5647>:
  if (fo != 0B) goto <D.5646>; else goto <D.5648>;
  <D.5648>:
  ready.78 = (long int) ready;
  GC_printf ("%lu objects are eligible for immediate finalization\n", ready.78, 0, 0, 0, 0, 0);
}