GC_has_other_debug_info (char * p)
{
  long unsigned int ohdr.0;
  long unsigned int body.1;
  long unsigned int D.5564;
  long unsigned int D.5565;
  GC_bool D.5567;
  long unsigned int D.5568;
  long unsigned int D.5571;
  long unsigned int D.5572;
  long unsigned int D.5575;
  long unsigned int D.5576;
  sizetype D.5577;
  word * D.5578;
  long unsigned int D.5579;
  long unsigned int D.5580;
  register struct oh * ohdr;
  register char * body;
  register word sz;

  ohdr = p;
  body = ohdr + 32;
  sz = GC_size (ohdr);
  ohdr.0 = (long unsigned int) ohdr;
  body.1 = (long unsigned int) body;
  D.5564 = ohdr.0 ^ body.1;
  D.5565 = D.5564 & 18446744073709547520;
  if (D.5565 != 0) goto <D.5560>; else goto <D.5566>;
  <D.5566>:
  if (sz <= 39) goto <D.5560>; else goto <D.5561>;
  <D.5560>:
  D.5567 = 0;
  return D.5567;
  <D.5561>:
  D.5568 = ohdr->oh_sz;
  if (D.5568 == sz) goto <D.5569>; else goto <D.5570>;
  <D.5569>:
  D.5567 = 0;
  return D.5567;
  <D.5570>:
  D.5571 = ohdr->oh_sf;
  body.1 = (long unsigned int) body;
  D.5572 = body.1 ^ 4275891659;
  if (D.5571 == D.5572) goto <D.5573>; else goto <D.5574>;
  <D.5573>:
  D.5567 = 1;
  return D.5567;
  <D.5574>:
  D.5575 = sz >> 3;
  D.5576 = D.5575 * 8;
  D.5577 = D.5576 + 18446744073709551608;
  D.5578 = ohdr + D.5577;
  D.5579 = *D.5578;
  body.1 = (long unsigned int) body;
  D.5580 = body.1 ^ 3168718319;
  if (D.5579 == D.5580) goto <D.5581>; else goto <D.5582>;
  <D.5581>:
  D.5567 = 1;
  return D.5567;
  <D.5582>:
  D.5567 = 0;
  return D.5567;
}


GC_store_debug_info (char * p, word sz, const char * string, word integer)
{
  int D.5584;
  long unsigned int result.2;
  long unsigned int D.5588;
  long unsigned int D.5589;
  long unsigned int D.5590;
  long unsigned int D.5591;
  sizetype D.5592;
  word * D.5593;
  long unsigned int D.5594;
  long unsigned int D.5595;
  long unsigned int D.5596;
  word * D.5597;
  long unsigned int D.5598;
  long unsigned int D.5599;
  char * D.5600;
  register word * result;

  result = p + 32;
  D.5584 = GC_test_and_set (&GC_allocate_lock);
  if (D.5584 != 0) goto <D.5585>; else goto <D.5586>;
  <D.5585>:
  GC_lock ();
  <D.5586>:
  MEM[(struct oh *)p].oh_string = string;
  MEM[(struct oh *)p].oh_int = integer;
  MEM[(struct oh *)p].oh_sz = sz;
  result.2 = (long unsigned int) result;
  D.5588 = result.2 ^ 4275891659;
  MEM[(struct oh *)p].oh_sf = D.5588;
  D.5589 = GC_size (p);
  D.5590 = D.5589 >> 3;
  D.5591 = D.5590 * 8;
  D.5592 = D.5591 + 18446744073709551608;
  D.5593 = p + D.5592;
  D.5594 = sz + 7;
  D.5595 = D.5594 >> 3;
  D.5596 = D.5595 * 8;
  D.5597 = result + D.5596;
  result.2 = (long unsigned int) result;
  D.5598 = result.2 ^ 3168718319;
  *D.5597 = D.5598;
  D.5599 = *D.5597;
  *D.5593 = D.5599;
  GC_clear (&GC_allocate_lock);
  D.5600 = result;
  return D.5600;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.5602;
  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.5602 = oldval;
  return D.5602;
}


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


GC_check_annotated_obj (struct oh * ohdr)
{
  long unsigned int D.5604;
  int GC_all_interior_pointers.3;
  long unsigned int D.5606;
  long unsigned int D.5607;
  long unsigned int D.5608;
  char * D.5611;
  long unsigned int D.5612;
  long unsigned int body.4;
  long unsigned int D.5614;
  long unsigned int D.5617;
  long unsigned int D.5618;
  sizetype D.5619;
  word * D.5620;
  long unsigned int D.5621;
  long unsigned int D.5622;
  long unsigned int D.5625;
  long unsigned int D.5626;
  long unsigned int D.5627;
  word * D.5628;
  long unsigned int D.5629;
  register char * body;
  register word gc_sz;

  body = ohdr + 32;
  gc_sz = GC_size (ohdr);
  D.5604 = ohdr->oh_sz;
  GC_all_interior_pointers.3 = GC_all_interior_pointers;
  D.5606 = (long unsigned int) GC_all_interior_pointers.3;
  D.5607 = D.5604 - D.5606;
  D.5608 = D.5607 + 40;
  if (D.5608 > gc_sz) goto <D.5609>; else goto <D.5610>;
  <D.5609>:
  D.5611 = &ohdr->oh_sz;
  return D.5611;
  <D.5610>:
  D.5612 = ohdr->oh_sf;
  body.4 = (long unsigned int) body;
  D.5614 = body.4 ^ 4275891659;
  if (D.5612 != D.5614) goto <D.5615>; else goto <D.5616>;
  <D.5615>:
  D.5611 = &ohdr->oh_sf;
  return D.5611;
  <D.5616>:
  D.5617 = gc_sz >> 3;
  D.5618 = D.5617 * 8;
  D.5619 = D.5618 + 18446744073709551608;
  D.5620 = ohdr + D.5619;
  D.5621 = *D.5620;
  body.4 = (long unsigned int) body;
  D.5622 = body.4 ^ 3168718319;
  if (D.5621 != D.5622) goto <D.5623>; else goto <D.5624>;
  <D.5623>:
  D.5617 = gc_sz >> 3;
  D.5618 = D.5617 * 8;
  D.5619 = D.5618 + 18446744073709551608;
  D.5611 = ohdr + D.5619;
  return D.5611;
  <D.5624>:
  D.5604 = ohdr->oh_sz;
  D.5625 = D.5604 + 7;
  D.5626 = D.5625 >> 3;
  D.5627 = D.5626 * 8;
  D.5628 = body + D.5627;
  D.5629 = *D.5628;
  body.4 = (long unsigned int) body;
  D.5622 = body.4 ^ 3168718319;
  if (D.5629 != D.5622) goto <D.5630>; else goto <D.5631>;
  <D.5630>:
  D.5604 = ohdr->oh_sz;
  D.5625 = D.5604 + 7;
  D.5626 = D.5625 >> 3;
  D.5627 = D.5626 * 8;
  D.5611 = body + D.5627;
  return D.5611;
  <D.5631>:
  D.5611 = 0B;
  return D.5611;
}


GC_register_describe_type_fn (int kind, void (*GC_describe_type_fn) (void *, char *) fn)
{
  GC_describe_type_fns[kind] = fn;
}


GC_print_type (char * p)
{
  unsigned char D.5633;
  void (*<T8a1>) (void *, char *) D.5635;
  void * D.5637;
  int D.5638;
  long int D.5640;
  long unsigned int D.5641;
  long int D.5642;
  struct hdr * hhdr;
  char buffer[41];
  int kind;

  try
    {
      hhdr = GC_find_header (p);
      D.5633 = hhdr->hb_obj_kind;
      kind = (int) D.5633;
      D.5635 = GC_describe_type_fns[kind];
      if (D.5635 != 0B) goto <D.5636>; else goto <D.5634>;
      <D.5636>:
      D.5637 = GC_base (p);
      D.5638 = GC_is_marked (D.5637);
      if (D.5638 != 0) goto <D.5639>; else goto <D.5634>;
      <D.5639>:
      buffer[40] = 0;
      D.5635 = GC_describe_type_fns[kind];
      D.5635 (p, &buffer);
      GC_err_puts (&buffer);
      goto <D.5364>;
      <D.5634>:
      switch (kind) <default: <D.5369>, case 0: <D.5363>, case 1: <D.5365>, case 2: <D.5366>, case 3: <D.5367>, case 4: <D.5368>>
      <D.5363>:
      GC_err_puts ("PTRFREE");
      goto <D.5364>;
      <D.5365>:
      GC_err_puts ("NORMAL");
      goto <D.5364>;
      <D.5366>:
      GC_err_puts ("UNCOLLECTABLE");
      goto <D.5364>;
      <D.5367>:
      GC_err_puts ("ATOMIC UNCOLLECTABLE");
      goto <D.5364>;
      <D.5368>:
      GC_err_puts ("STUBBORN");
      goto <D.5364>;
      <D.5369>:
      D.5640 = (long int) kind;
      D.5641 = hhdr->hb_descr;
      D.5642 = (long int) D.5641;
      GC_err_printf ("kind %ld, descr 0x%lx", D.5640, D.5642, 0, 0, 0, 0);
      <D.5364>:
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


GC_print_obj (char * p)
{
  long unsigned int ohdr.5;
  long unsigned int D.5644;
  long int D.5645;
  const char * D.5646;
  long unsigned int D.5647;
  long int D.5648;
  long unsigned int D.5649;
  long int D.5650;
  char * D.5651;
  register struct oh * ohdr;

  ohdr = GC_base (p);
  ohdr.5 = (long unsigned int) ohdr;
  D.5644 = ohdr.5 + 32;
  D.5645 = (long int) D.5644;
  GC_err_printf ("0x%lx (", D.5645, 0, 0, 0, 0, 0);
  D.5646 = ohdr->oh_string;
  GC_err_puts (D.5646);
  D.5647 = ohdr->oh_int;
  D.5648 = (long int) D.5647;
  D.5649 = ohdr->oh_sz;
  D.5650 = (long int) D.5649;
  GC_err_printf (":%ld, sz=%ld, ", D.5648, D.5650, 0, 0, 0, 0);
  D.5651 = ohdr + 32;
  GC_print_type (D.5651);
  GC_err_puts (")\n");
}


GC_debug_print_heap_obj_proc (char * p)
{
  int D.5652;

  D.5652 = GC_has_other_debug_info (p);
  if (D.5652 != 0) goto <D.5653>; else goto <D.5654>;
  <D.5653>:
  GC_print_obj (p);
  goto <D.5655>;
  <D.5654>:
  GC_default_print_heap_obj_proc (p);
  <D.5655>:
}


GC_print_smashed_obj (char * p, char * clobbered_addr)
{
  long int clobbered_addr.6;
  long int p.7;
  word * D.5661;
  const char * D.5663;
  long unsigned int D.5664;
  int GC_all_interior_pointers.8;
  long unsigned int D.5666;
  long unsigned int D.5667;
  long unsigned int D.5668;
  long int D.5669;
  char D.5670;
  long unsigned int D.5674;
  long int D.5675;
  long unsigned int D.5676;
  long int D.5677;
  register struct oh * ohdr;

  ohdr = GC_base (p);
  clobbered_addr.6 = (long int) clobbered_addr;
  p.7 = (long int) p;
  GC_err_printf ("0x%lx in object at 0x%lx(", clobbered_addr.6, p.7, 0, 0, 0, 0);
  D.5661 = &ohdr->oh_sz;
  if (D.5661 >= clobbered_addr) goto <D.5658>; else goto <D.5662>;
  <D.5662>:
  D.5663 = ohdr->oh_string;
  if (D.5663 == 0B) goto <D.5658>; else goto <D.5659>;
  <D.5658>:
  D.5664 = GC_size (ohdr);
  GC_all_interior_pointers.8 = GC_all_interior_pointers;
  D.5666 = (long unsigned int) GC_all_interior_pointers.8;
  D.5667 = D.5664 + D.5666;
  D.5668 = D.5667 + 18446744073709551576;
  D.5669 = (long int) D.5668;
  GC_err_printf ("<smashed>, appr. sz = %ld)\n", D.5669, 0, 0, 0, 0, 0);
  goto <D.5660>;
  <D.5659>:
  D.5663 = ohdr->oh_string;
  D.5670 = *D.5663;
  if (D.5670 == 0) goto <D.5671>; else goto <D.5672>;
  <D.5671>:
  GC_err_puts ("EMPTY(smashed?)");
  goto <D.5673>;
  <D.5672>:
  D.5663 = ohdr->oh_string;
  GC_err_puts (D.5663);
  <D.5673>:
  D.5674 = ohdr->oh_int;
  D.5675 = (long int) D.5674;
  D.5676 = ohdr->oh_sz;
  D.5677 = (long int) D.5676;
  GC_err_printf (":%ld, sz=%ld)\n", D.5675, D.5677, 0, 0, 0, 0);
  <D.5660>:
}


GC_do_nothing ()
{

}


GC_start_debugging ()
{
  GC_check_heap = GC_check_heap_proc;
  GC_print_all_smashed = GC_print_all_smashed_proc;
  GC_print_heap_obj = GC_debug_print_heap_obj_proc;
  GC_debugging_started = 1;
  GC_register_displacement (32);
}


GC_debug_register_displacement (GC_word offset)
{
  long unsigned int D.5678;

  GC_register_displacement (offset);
  D.5678 = offset + 32;
  GC_register_displacement (D.5678);
}


GC_debug_malloc (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.9;
  long unsigned int D.5680;
  long unsigned int D.5681;
  long unsigned int D.5682;
  long int lb.10;
  long int D.5686;
  void * D.5687;
  int GC_debugging_started.11;
  long unsigned int D.5691;
  void * result;

  GC_all_interior_pointers.9 = GC_all_interior_pointers;
  D.5680 = (long unsigned int) GC_all_interior_pointers.9;
  D.5681 = lb - D.5680;
  D.5682 = D.5681 + 40;
  result = GC_malloc (D.5682);
  if (result == 0B) goto <D.5683>; else goto <D.5684>;
  <D.5683>:
  lb.10 = (long int) lb;
  GC_err_printf ("GC_debug_malloc(%ld) returning NIL (", lb.10, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  D.5686 = (long int) i;
  GC_err_printf (":%ld)\n", D.5686, 0, 0, 0, 0, 0);
  D.5687 = 0B;
  return D.5687;
  <D.5684>:
  GC_debugging_started.11 = GC_debugging_started;
  if (GC_debugging_started.11 == 0) goto <D.5689>; else goto <D.5690>;
  <D.5689>:
  GC_start_debugging ();
  <D.5690>:
  D.5691 = (long unsigned int) i;
  D.5687 = GC_store_debug_info (result, lb, s, D.5691);
  return D.5687;
}


GC_debug_malloc_ignore_off_page (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.12;
  long unsigned int D.5694;
  long unsigned int D.5695;
  long unsigned int D.5696;
  long int lb.13;
  long int D.5700;
  void * D.5701;
  int GC_debugging_started.14;
  long unsigned int D.5705;
  void * result;

  GC_all_interior_pointers.12 = GC_all_interior_pointers;
  D.5694 = (long unsigned int) GC_all_interior_pointers.12;
  D.5695 = lb - D.5694;
  D.5696 = D.5695 + 40;
  result = GC_malloc_ignore_off_page (D.5696);
  if (result == 0B) goto <D.5697>; else goto <D.5698>;
  <D.5697>:
  lb.13 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_ignore_off_page(%ld) returning NIL (", lb.13, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  D.5700 = (long int) i;
  GC_err_printf (":%ld)\n", D.5700, 0, 0, 0, 0, 0);
  D.5701 = 0B;
  return D.5701;
  <D.5698>:
  GC_debugging_started.14 = GC_debugging_started;
  if (GC_debugging_started.14 == 0) goto <D.5703>; else goto <D.5704>;
  <D.5703>:
  GC_start_debugging ();
  <D.5704>:
  D.5705 = (long unsigned int) i;
  D.5701 = GC_store_debug_info (result, lb, s, D.5705);
  return D.5701;
}


GC_debug_malloc_atomic_ignore_off_page (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.15;
  long unsigned int D.5708;
  long unsigned int D.5709;
  long unsigned int D.5710;
  long int lb.16;
  long int D.5714;
  void * D.5715;
  int GC_debugging_started.17;
  long unsigned int D.5719;
  void * result;

  GC_all_interior_pointers.15 = GC_all_interior_pointers;
  D.5708 = (long unsigned int) GC_all_interior_pointers.15;
  D.5709 = lb - D.5708;
  D.5710 = D.5709 + 40;
  result = GC_malloc_atomic_ignore_off_page (D.5710);
  if (result == 0B) goto <D.5711>; else goto <D.5712>;
  <D.5711>:
  lb.16 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_atomic_ignore_off_page(%ld) returning NIL (", lb.16, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  D.5714 = (long int) i;
  GC_err_printf (":%ld)\n", D.5714, 0, 0, 0, 0, 0);
  D.5715 = 0B;
  return D.5715;
  <D.5712>:
  GC_debugging_started.17 = GC_debugging_started;
  if (GC_debugging_started.17 == 0) goto <D.5717>; else goto <D.5718>;
  <D.5717>:
  GC_start_debugging ();
  <D.5718>:
  D.5719 = (long unsigned int) i;
  D.5715 = GC_store_debug_info (result, lb, s, D.5719);
  return D.5715;
}


GC_debug_malloc_stubborn (size_t lb, const char * s, int i)
{
  void * D.5721;

  D.5721 = GC_debug_malloc (lb, s, i);
  return D.5721;
}


GC_debug_change_stubborn (void * p)
{

}


GC_debug_end_stubborn_change (void * p)
{

}


GC_debug_malloc_atomic (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.18;
  long unsigned int D.5724;
  long unsigned int D.5725;
  long unsigned int D.5726;
  long int lb.19;
  long int D.5730;
  void * D.5731;
  int GC_debugging_started.20;
  long unsigned int D.5735;
  void * result;

  GC_all_interior_pointers.18 = GC_all_interior_pointers;
  D.5724 = (long unsigned int) GC_all_interior_pointers.18;
  D.5725 = lb - D.5724;
  D.5726 = D.5725 + 40;
  result = GC_malloc_atomic (D.5726);
  if (result == 0B) goto <D.5727>; else goto <D.5728>;
  <D.5727>:
  lb.19 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_atomic(%ld) returning NIL (", lb.19, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  D.5730 = (long int) i;
  GC_err_printf (":%ld)\n", D.5730, 0, 0, 0, 0, 0);
  D.5731 = 0B;
  return D.5731;
  <D.5728>:
  GC_debugging_started.20 = GC_debugging_started;
  if (GC_debugging_started.20 == 0) goto <D.5733>; else goto <D.5734>;
  <D.5733>:
  GC_start_debugging ();
  <D.5734>:
  D.5735 = (long unsigned int) i;
  D.5731 = GC_store_debug_info (result, lb, s, D.5735);
  return D.5731;
}


GC_debug_malloc_uncollectable (size_t lb, const char * s, int i)
{
  long unsigned int D.5737;
  long int lb.21;
  long int D.5741;
  void * D.5742;
  int GC_debugging_started.22;
  long unsigned int D.5746;
  void * result;

  D.5737 = lb + 40;
  result = GC_malloc_uncollectable (D.5737);
  if (result == 0B) goto <D.5738>; else goto <D.5739>;
  <D.5738>:
  lb.21 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_uncollectable(%ld) returning NIL (", lb.21, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  D.5741 = (long int) i;
  GC_err_printf (":%ld)\n", D.5741, 0, 0, 0, 0, 0);
  D.5742 = 0B;
  return D.5742;
  <D.5739>:
  GC_debugging_started.22 = GC_debugging_started;
  if (GC_debugging_started.22 == 0) goto <D.5744>; else goto <D.5745>;
  <D.5744>:
  GC_start_debugging ();
  <D.5745>:
  D.5746 = (long unsigned int) i;
  D.5742 = GC_store_debug_info (result, lb, s, D.5746);
  return D.5742;
}


GC_debug_malloc_atomic_uncollectable (size_t lb, const char * s, int i)
{
  long unsigned int D.5748;
  long int lb.23;
  long int D.5752;
  void * D.5753;
  int GC_debugging_started.24;
  long unsigned int D.5757;
  void * result;

  D.5748 = lb + 40;
  result = GC_malloc_atomic_uncollectable (D.5748);
  if (result == 0B) goto <D.5749>; else goto <D.5750>;
  <D.5749>:
  lb.23 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_atomic_uncollectable(%ld) returning NIL (", lb.23, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  D.5752 = (long int) i;
  GC_err_printf (":%ld)\n", D.5752, 0, 0, 0, 0, 0);
  D.5753 = 0B;
  return D.5753;
  <D.5750>:
  GC_debugging_started.24 = GC_debugging_started;
  if (GC_debugging_started.24 == 0) goto <D.5755>; else goto <D.5756>;
  <D.5755>:
  GC_start_debugging ();
  <D.5756>:
  D.5757 = (long unsigned int) i;
  D.5753 = GC_store_debug_info (result, lb, s, D.5757);
  return D.5753;
}


GC_debug_free (void * p)
{
  long int p.25;
  long int p.26;
  long int base.27;
  long int D.5766;
  long unsigned int D.5772;
  long unsigned int D.5773;
  long unsigned int D.5777;
  int GC_find_leak.28;
  unsigned char D.5782;
  long unsigned int D.5790;
  long unsigned int D.5791;
  word * D.5792;
  register void * base;
  register char * clobbered;

  if (p == 0B) goto <D.5759>; else goto <D.5760>;
  <D.5759>:
  return;
  <D.5760>:
  base = GC_base (p);
  if (base == 0B) goto <D.5761>; else goto <D.5762>;
  <D.5761>:
  p.25 = (long int) p;
  GC_err_printf ("Attempt to free invalid pointer %lx\n", p.25, 0, 0, 0, 0, 0);
  GC_abort ("free(invalid pointer)");
  <D.5762>:
  p.26 = (long int) p;
  base.27 = (long int) base;
  D.5766 = p.26 - base.27;
  if (D.5766 != 32) goto <D.5767>; else goto <D.5768>;
  <D.5767>:
  p.25 = (long int) p;
  GC_err_printf ("GC_debug_free called on pointer %lx wo debugging info\n", p.25, 0, 0, 0, 0, 0);
  goto <D.5769>;
  <D.5768>:
  clobbered = GC_check_annotated_obj (base);
  if (clobbered != 0B) goto <D.5770>; else goto <D.5771>;
  <D.5770>:
  D.5772 = MEM[(struct oh *)base].oh_sz;
  D.5773 = GC_size (base);
  if (D.5772 == D.5773) goto <D.5774>; else goto <D.5775>;
  <D.5774>:
  GC_err_puts ("GC_debug_free: found previously deallocated (?) object at ");
  goto <D.5776>;
  <D.5775>:
  GC_err_puts ("GC_debug_free: found smashed location at ");
  <D.5776>:
  GC_print_smashed_obj (p, clobbered);
  <D.5771>:
  D.5777 = GC_size (base);
  MEM[(struct oh *)base].oh_sz = D.5777;
  <D.5769>:
  GC_find_leak.28 = GC_find_leak;
  if (GC_find_leak.28 != 0) goto <D.5779>; else goto <D.5780>;
  <D.5779>:
  GC_free (base);
  goto <D.5781>;
  <D.5780>:
  {
    register struct hdr * hhdr;
    GC_bool uncollectable;

    hhdr = GC_find_header (p);
    uncollectable = 0;
    D.5782 = hhdr->hb_obj_kind;
    if (D.5782 == 2) goto <D.5783>; else goto <D.5784>;
    <D.5783>:
    uncollectable = 1;
    <D.5784>:
    D.5782 = hhdr->hb_obj_kind;
    if (D.5782 == 3) goto <D.5785>; else goto <D.5786>;
    <D.5785>:
    uncollectable = 1;
    <D.5786>:
    if (uncollectable != 0) goto <D.5787>; else goto <D.5788>;
    <D.5787>:
    GC_free (base);
    goto <D.5789>;
    <D.5788>:
    {
      size_t i;
      size_t obj_sz;

      D.5790 = hhdr->hb_sz;
      obj_sz = D.5790 + 18446744073709551612;
      i = 0;
      goto <D.5451>;
      <D.5450>:
      D.5791 = i * 8;
      D.5792 = p + D.5791;
      *D.5792 = 3735928559;
      i = i + 1;
      <D.5451>:
      if (i < obj_sz) goto <D.5450>; else goto <D.5452>;
      <D.5452>:
    }
    <D.5789>:
  }
  <D.5781>:
}


GC_debug_free_inner (void * p)
{
  void * D.5794;

  D.5794 = GC_base (p);
  GC_free_inner (D.5794);
}


GC_debug_realloc (void * p, size_t lb, const char * s, int i)
{
  void * D.5797;
  long int p.29;
  long int p.30;
  long int base.31;
  long int D.5803;
  unsigned char D.5806;
  int D.5807;
  register void * base;
  register char * clobbered;
  register void * result;
  register size_t copy_sz;
  register size_t old_sz;
  register struct hdr * hhdr;

  base = GC_base (p);
  copy_sz = lb;
  if (p == 0B) goto <D.5795>; else goto <D.5796>;
  <D.5795>:
  D.5797 = GC_debug_malloc (lb, s, i);
  return D.5797;
  <D.5796>:
  if (base == 0B) goto <D.5798>; else goto <D.5799>;
  <D.5798>:
  p.29 = (long int) p;
  GC_err_printf ("Attempt to reallocate invalid pointer %lx\n", p.29, 0, 0, 0, 0, 0);
  GC_abort ("realloc(invalid pointer)");
  <D.5799>:
  p.30 = (long int) p;
  base.31 = (long int) base;
  D.5803 = p.30 - base.31;
  if (D.5803 != 32) goto <D.5804>; else goto <D.5805>;
  <D.5804>:
  p.29 = (long int) p;
  GC_err_printf ("GC_debug_realloc called on pointer %lx wo debugging info\n", p.29, 0, 0, 0, 0, 0);
  D.5797 = GC_realloc (p, lb);
  return D.5797;
  <D.5805>:
  hhdr = GC_find_header (base);
  D.5806 = hhdr->hb_obj_kind;
  D.5807 = (int) D.5806;
  switch (D.5807) <default: <D.5475>, case 0: <D.5472>, case 1: <D.5470>, case 2: <D.5473>, case 3: <D.5474>>
  <D.5470>:
  result = GC_debug_malloc (lb, s, i);
  goto <D.5471>;
  <D.5472>:
  result = GC_debug_malloc_atomic (lb, s, i);
  goto <D.5471>;
  <D.5473>:
  result = GC_debug_malloc_uncollectable (lb, s, i);
  goto <D.5471>;
  <D.5474>:
  result = GC_debug_malloc_atomic_uncollectable (lb, s, i);
  goto <D.5471>;
  <D.5475>:
  GC_err_puts ("GC_debug_realloc: encountered bad kind\n");
  GC_abort ("bad kind");
  <D.5471>:
  clobbered = GC_check_annotated_obj (base);
  if (clobbered != 0B) goto <D.5808>; else goto <D.5809>;
  <D.5808>:
  GC_err_puts ("GC_debug_realloc: found smashed location at ");
  GC_print_smashed_obj (p, clobbered);
  <D.5809>:
  old_sz = MEM[(struct oh *)base].oh_sz;
  if (old_sz < copy_sz) goto <D.5810>; else goto <D.5811>;
  <D.5810>:
  copy_sz = old_sz;
  <D.5811>:
  if (result == 0B) goto <D.5812>; else goto <D.5813>;
  <D.5812>:
  D.5797 = 0B;
  return D.5797;
  <D.5813>:
  memcpy (result, p, copy_sz);
  GC_debug_free (p);
  D.5797 = result;
  return D.5797;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.5815;
  long unsigned int D.5816;

  D.5816 = __builtin_object_size (__dest, 0);
  D.5815 = __builtin___memcpy_chk (__dest, __src, __len, D.5816);
  return D.5815;
}


GC_add_smashed (char * smashed)
{
  unsigned int GC_n_smashed.32;
  unsigned int GC_n_smashed.33;

  GC_n_smashed.32 = GC_n_smashed;
  GC_smashed[GC_n_smashed.32] = smashed;
  GC_n_smashed.32 = GC_n_smashed;
  if (GC_n_smashed.32 <= 18) goto <D.5819>; else goto <D.5820>;
  <D.5819>:
  GC_n_smashed.32 = GC_n_smashed;
  GC_n_smashed.33 = GC_n_smashed.32 + 1;
  GC_n_smashed = GC_n_smashed.33;
  <D.5820>:
  GC_have_errors = 1;
}


GC_print_all_smashed_proc ()
{
  unsigned int GC_n_smashed.34;
  char * D.5825;
  void * D.5826;
  unsigned int i;

  GC_n_smashed.34 = GC_n_smashed;
  if (GC_n_smashed.34 == 0) goto <D.5823>; else goto <D.5824>;
  <D.5823>:
  return;
  <D.5824>:
  GC_err_puts ("GC_check_heap_block: found smashed heap objects:\n");
  i = 0;
  goto <D.5485>;
  <D.5484>:
  D.5825 = GC_smashed[i];
  D.5826 = GC_base (D.5825);
  D.5825 = GC_smashed[i];
  GC_print_smashed_obj (D.5826, D.5825);
  GC_smashed[i] = 0B;
  i = i + 1;
  <D.5485>:
  GC_n_smashed.34 = GC_n_smashed;
  if (i < GC_n_smashed.34) goto <D.5484>; else goto <D.5486>;
  <D.5486>:
  GC_n_smashed = 0;
}


GC_check_heap_block (struct hblk * hbp, word dummy)
{
  long unsigned int hbp.35;
  long unsigned int D.5832;
  long unsigned int D.5833;
  long unsigned int D.5834;
  int D.5835;
  long unsigned int D.5836;
  int D.5837;
  long unsigned int D.5838;
  long unsigned int D.5839;
  int D.5842;
  unsigned int D.5847;
  unsigned int word_no.36;
  unsigned int D.5849;
  long unsigned int D.5850;
  register struct hblkhdr * hhdr;
  register word sz;
  register int word_no;
  register word * p;
  register word * plim;

  hhdr = GC_find_header (hbp);
  sz = hhdr->hb_sz;
  p = &hbp->hb_body;
  word_no = 0;
  if (sz > 256) goto <D.5828>; else goto <D.5829>;
  <D.5828>:
  plim = p;
  goto <D.5830>;
  <D.5829>:
  hbp.35 = (long unsigned int) hbp;
  D.5832 = sz << 3;
  D.5833 = hbp.35 - D.5832;
  D.5834 = D.5833 + 4096;
  plim = (word *) D.5834;
  <D.5830>:
  goto <D.5498>;
  <D.5497>:
  D.5835 = word_no >> 6;
  D.5836 = hhdr->hb_marks[D.5835];
  D.5837 = word_no & 63;
  D.5838 = D.5836 >> D.5837;
  D.5839 = D.5838 & 1;
  if (D.5839 != 0) goto <D.5840>; else goto <D.5841>;
  <D.5840>:
  D.5842 = GC_has_other_debug_info (p);
  if (D.5842 != 0) goto <D.5843>; else goto <D.5844>;
  <D.5843>:
  {
    char * clobbered;

    clobbered = GC_check_annotated_obj (p);
    if (clobbered != 0B) goto <D.5845>; else goto <D.5846>;
    <D.5845>:
    GC_add_smashed (clobbered);
    <D.5846>:
  }
  <D.5844>:
  <D.5841>:
  D.5847 = (unsigned int) sz;
  word_no.36 = (unsigned int) word_no;
  D.5849 = D.5847 + word_no.36;
  word_no = (int) D.5849;
  D.5850 = sz * 8;
  p = p + D.5850;
  <D.5498>:
  if (p <= plim) goto <D.5497>; else goto <D.5499>;
  <D.5499>:
}


GC_check_heap_proc ()
{
  GC_apply_to_all_blocks (GC_check_heap_block, 0);
}


GC_make_closure (void (*GC_finalization_proc) (void *, void *) fn, void * data)
{
  void * D.5851;
  struct closure * result;

  result = GC_malloc (16);
  result->cl_fn = fn;
  result->cl_data = data;
  D.5851 = result;
  return D.5851;
}


GC_debug_invoke_finalizer (void * obj, void * data)
{
  void (*<T3fc>) (void *, void *) D.5853;
  void * D.5854;
  void * D.5855;
  register struct closure * cl;

  cl = data;
  D.5853 = cl->cl_fn;
  D.5854 = obj + 32;
  D.5855 = cl->cl_data;
  D.5853 (D.5854, D.5855);
}


GC_debug_register_finalizer (void * obj, void (*GC_finalization_proc) (void *, void *) fn, void * cd, void (*GC_finalization_proc) (void *, void *) * ofn, void * * ocd)
{
  long int obj.37;
  long int base.38;
  long int D.5860;
  void * D.5866;
  void (*<T3fc>) (void *, void *) my_old_fn.39;
  void * my_old_cd.40;
  void (*GC_finalization_proc) (void *, void *) my_old_fn;
  void * my_old_cd;
  char * base;

  try
    {
      base = GC_base (obj);
      if (base == 0B) goto <D.5856>; else goto <D.5857>;
      <D.5856>:
      return;
      <D.5857>:
      obj.37 = (long int) obj;
      base.38 = (long int) base;
      D.5860 = obj.37 - base.38;
      if (D.5860 != 32) goto <D.5861>; else goto <D.5862>;
      <D.5861>:
      obj.37 = (long int) obj;
      GC_err_printf ("GC_debug_register_finalizer called with non-base-pointer 0x%lx\n", obj.37, 0, 0, 0, 0, 0);
      <D.5862>:
      if (fn == 0B) goto <D.5863>; else goto <D.5864>;
      <D.5863>:
      GC_register_finalizer (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.5865>;
      <D.5864>:
      D.5866 = GC_make_closure (fn, cd);
      GC_register_finalizer (base, GC_debug_invoke_finalizer, D.5866, &my_old_fn, &my_old_cd);
      <D.5865>:
      my_old_fn.39 = my_old_fn;
      my_old_cd.40 = my_old_cd;
      store_old (obj, my_old_fn.39, my_old_cd.40, ofn, ocd);
    }
  finally
    {
      my_old_fn = {CLOBBER};
      my_old_cd = {CLOBBER};
    }
}


store_old (void * obj, void (*GC_finalization_proc) (void *, void *) my_old_fn, struct closure * my_old_cd, void (*GC_finalization_proc) (void *, void *) * ofn, void * * ocd)
{
  long int obj.41;
  void (*<T3fc>) (void *, void *) D.5880;
  void * D.5883;

  if (my_old_fn != 0B) goto <D.5872>; else goto <D.5873>;
  <D.5872>:
  if (my_old_fn != GC_debug_invoke_finalizer) goto <D.5874>; else goto <D.5875>;
  <D.5874>:
  obj.41 = (long int) obj;
  GC_err_printf ("Debuggable object at 0x%lx had non-debug finalizer.\n", obj.41, 0, 0, 0, 0, 0);
  goto <D.5877>;
  <D.5875>:
  if (ofn != 0B) goto <D.5878>; else goto <D.5879>;
  <D.5878>:
  D.5880 = my_old_cd->cl_fn;
  *ofn = D.5880;
  <D.5879>:
  if (ocd != 0B) goto <D.5881>; else goto <D.5882>;
  <D.5881>:
  D.5883 = my_old_cd->cl_data;
  *ocd = D.5883;
  <D.5882>:
  <D.5877>:
  goto <D.5884>;
  <D.5873>:
  if (ofn != 0B) goto <D.5885>; else goto <D.5886>;
  <D.5885>:
  *ofn = 0B;
  <D.5886>:
  if (ocd != 0B) goto <D.5887>; else goto <D.5888>;
  <D.5887>:
  *ocd = 0B;
  <D.5888>:
  <D.5884>:
}


GC_debug_register_finalizer_no_order (void * obj, void (*GC_finalization_proc) (void *, void *) fn, void * cd, void (*GC_finalization_proc) (void *, void *) * ofn, void * * ocd)
{
  long int obj.42;
  long int base.43;
  long int D.5893;
  void * D.5899;
  void (*<T3fc>) (void *, void *) my_old_fn.44;
  void * my_old_cd.45;
  void (*GC_finalization_proc) (void *, void *) my_old_fn;
  void * my_old_cd;
  char * base;

  try
    {
      base = GC_base (obj);
      if (base == 0B) goto <D.5889>; else goto <D.5890>;
      <D.5889>:
      return;
      <D.5890>:
      obj.42 = (long int) obj;
      base.43 = (long int) base;
      D.5893 = obj.42 - base.43;
      if (D.5893 != 32) goto <D.5894>; else goto <D.5895>;
      <D.5894>:
      obj.42 = (long int) obj;
      GC_err_printf ("GC_debug_register_finalizer_no_order called with non-base-pointer 0x%lx\n", obj.42, 0, 0, 0, 0, 0);
      <D.5895>:
      if (fn == 0B) goto <D.5896>; else goto <D.5897>;
      <D.5896>:
      GC_register_finalizer_no_order (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.5898>;
      <D.5897>:
      D.5899 = GC_make_closure (fn, cd);
      GC_register_finalizer_no_order (base, GC_debug_invoke_finalizer, D.5899, &my_old_fn, &my_old_cd);
      <D.5898>:
      my_old_fn.44 = my_old_fn;
      my_old_cd.45 = my_old_cd;
      store_old (obj, my_old_fn.44, my_old_cd.45, ofn, ocd);
    }
  finally
    {
      my_old_fn = {CLOBBER};
      my_old_cd = {CLOBBER};
    }
}


GC_debug_register_finalizer_ignore_self (void * obj, void (*GC_finalization_proc) (void *, void *) fn, void * cd, void (*GC_finalization_proc) (void *, void *) * ofn, void * * ocd)
{
  long int obj.46;
  long int base.47;
  long int D.5909;
  void * D.5915;
  void (*<T3fc>) (void *, void *) my_old_fn.48;
  void * my_old_cd.49;
  void (*GC_finalization_proc) (void *, void *) my_old_fn;
  void * my_old_cd;
  char * base;

  try
    {
      base = GC_base (obj);
      if (base == 0B) goto <D.5905>; else goto <D.5906>;
      <D.5905>:
      return;
      <D.5906>:
      obj.46 = (long int) obj;
      base.47 = (long int) base;
      D.5909 = obj.46 - base.47;
      if (D.5909 != 32) goto <D.5910>; else goto <D.5911>;
      <D.5910>:
      obj.46 = (long int) obj;
      GC_err_printf ("GC_debug_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n", obj.46, 0, 0, 0, 0, 0);
      <D.5911>:
      if (fn == 0B) goto <D.5912>; else goto <D.5913>;
      <D.5912>:
      GC_register_finalizer_ignore_self (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.5914>;
      <D.5913>:
      D.5915 = GC_make_closure (fn, cd);
      GC_register_finalizer_ignore_self (base, GC_debug_invoke_finalizer, D.5915, &my_old_fn, &my_old_cd);
      <D.5914>:
      my_old_fn.48 = my_old_fn;
      my_old_cd.49 = my_old_cd;
      store_old (obj, my_old_fn.48, my_old_cd.49, ofn, ocd);
    }
  finally
    {
      my_old_fn = {CLOBBER};
      my_old_cd = {CLOBBER};
    }
}


GC_debug_malloc_replacement (size_t lb)
{
  void * D.5921;

  D.5921 = GC_debug_malloc (lb, "unknown", 0);
  return D.5921;
}


GC_debug_realloc_replacement (void * p, size_t lb)
{
  void * D.5923;

  D.5923 = GC_debug_realloc (p, lb, "unknown", 0);
  return D.5923;
}