GC_has_other_debug_info (char * p)
{
  long unsigned int ohdr.0;
  long unsigned int body.1;
  long unsigned int D.5153;
  long unsigned int D.5154;
  GC_bool D.5156;
  long unsigned int D.5157;
  long unsigned int D.5160;
  long unsigned int D.5161;
  long unsigned int D.5164;
  long unsigned int D.5165;
  sizetype D.5166;
  word * D.5167;
  long unsigned int D.5168;
  long unsigned int D.5169;
  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.5153 = ohdr.0 ^ body.1;
  D.5154 = D.5153 & 18446744073709547520;
  if (D.5154 != 0) goto <D.5149>; else goto <D.5155>;
  <D.5155>:
  if (sz <= 39) goto <D.5149>; else goto <D.5150>;
  <D.5149>:
  D.5156 = 0;
  return D.5156;
  <D.5150>:
  D.5157 = ohdr->oh_sz;
  if (D.5157 == sz) goto <D.5158>; else goto <D.5159>;
  <D.5158>:
  D.5156 = 0;
  return D.5156;
  <D.5159>:
  D.5160 = ohdr->oh_sf;
  body.1 = (long unsigned int) body;
  D.5161 = body.1 ^ 4275891659;
  if (D.5160 == D.5161) goto <D.5162>; else goto <D.5163>;
  <D.5162>:
  D.5156 = 1;
  return D.5156;
  <D.5163>:
  D.5164 = sz >> 3;
  D.5165 = D.5164 * 8;
  D.5166 = D.5165 + 18446744073709551608;
  D.5167 = ohdr + D.5166;
  D.5168 = *D.5167;
  body.1 = (long unsigned int) body;
  D.5169 = body.1 ^ 3168718319;
  if (D.5168 == D.5169) goto <D.5170>; else goto <D.5171>;
  <D.5170>:
  D.5156 = 1;
  return D.5156;
  <D.5171>:
  D.5156 = 0;
  return D.5156;
}


GC_store_debug_info (char * p, word sz, const char * string, word integer)
{
  int D.5173;
  long unsigned int result.2;
  long unsigned int D.5177;
  long unsigned int D.5178;
  long unsigned int D.5179;
  long unsigned int D.5180;
  sizetype D.5181;
  word * D.5182;
  long unsigned int D.5183;
  long unsigned int D.5184;
  long unsigned int D.5185;
  word * D.5186;
  long unsigned int D.5187;
  long unsigned int D.5188;
  char * D.5189;
  register word * result;

  result = p + 32;
  D.5173 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5173 != 0) goto <D.5174>; else goto <D.5175>;
  <D.5174>:
  GC_lock ();
  <D.5175>:
  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.5177 = result.2 ^ 4275891659;
  MEM[(struct oh *)p].oh_sf = D.5177;
  D.5178 = GC_size (p);
  D.5179 = D.5178 >> 3;
  D.5180 = D.5179 * 8;
  D.5181 = D.5180 + 18446744073709551608;
  D.5182 = p + D.5181;
  D.5183 = sz + 7;
  D.5184 = D.5183 >> 3;
  D.5185 = D.5184 * 8;
  D.5186 = result + D.5185;
  result.2 = (long unsigned int) result;
  D.5187 = result.2 ^ 3168718319;
  *D.5186 = D.5187;
  D.5188 = *D.5186;
  *D.5182 = D.5188;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5189 = result;
  return D.5189;
}


GC_check_annotated_obj (struct oh * ohdr)
{
  long unsigned int D.5191;
  int GC_all_interior_pointers.3;
  long unsigned int D.5193;
  long unsigned int D.5194;
  long unsigned int D.5195;
  char * D.5198;
  long unsigned int D.5199;
  long unsigned int body.4;
  long unsigned int D.5201;
  long unsigned int D.5204;
  long unsigned int D.5205;
  sizetype D.5206;
  word * D.5207;
  long unsigned int D.5208;
  long unsigned int D.5209;
  long unsigned int D.5212;
  long unsigned int D.5213;
  long unsigned int D.5214;
  word * D.5215;
  long unsigned int D.5216;
  register char * body;
  register word gc_sz;

  body = ohdr + 32;
  gc_sz = GC_size (ohdr);
  D.5191 = ohdr->oh_sz;
  GC_all_interior_pointers.3 = GC_all_interior_pointers;
  D.5193 = (long unsigned int) GC_all_interior_pointers.3;
  D.5194 = D.5191 - D.5193;
  D.5195 = D.5194 + 40;
  if (D.5195 > gc_sz) goto <D.5196>; else goto <D.5197>;
  <D.5196>:
  D.5198 = &ohdr->oh_sz;
  return D.5198;
  <D.5197>:
  D.5199 = ohdr->oh_sf;
  body.4 = (long unsigned int) body;
  D.5201 = body.4 ^ 4275891659;
  if (D.5199 != D.5201) goto <D.5202>; else goto <D.5203>;
  <D.5202>:
  D.5198 = &ohdr->oh_sf;
  return D.5198;
  <D.5203>:
  D.5204 = gc_sz >> 3;
  D.5205 = D.5204 * 8;
  D.5206 = D.5205 + 18446744073709551608;
  D.5207 = ohdr + D.5206;
  D.5208 = *D.5207;
  body.4 = (long unsigned int) body;
  D.5209 = body.4 ^ 3168718319;
  if (D.5208 != D.5209) goto <D.5210>; else goto <D.5211>;
  <D.5210>:
  D.5204 = gc_sz >> 3;
  D.5205 = D.5204 * 8;
  D.5206 = D.5205 + 18446744073709551608;
  D.5198 = ohdr + D.5206;
  return D.5198;
  <D.5211>:
  D.5191 = ohdr->oh_sz;
  D.5212 = D.5191 + 7;
  D.5213 = D.5212 >> 3;
  D.5214 = D.5213 * 8;
  D.5215 = body + D.5214;
  D.5216 = *D.5215;
  body.4 = (long unsigned int) body;
  D.5209 = body.4 ^ 3168718319;
  if (D.5216 != D.5209) goto <D.5217>; else goto <D.5218>;
  <D.5217>:
  D.5191 = ohdr->oh_sz;
  D.5212 = D.5191 + 7;
  D.5213 = D.5212 >> 3;
  D.5214 = D.5213 * 8;
  D.5198 = body + D.5214;
  return D.5198;
  <D.5218>:
  D.5198 = 0B;
  return D.5198;
}


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.5220;
  void (*<T908>) (void *, char *) D.5222;
  void * D.5224;
  int D.5225;
  long int D.5227;
  long unsigned int D.5228;
  long int D.5229;
  struct hdr * hhdr;
  char buffer[41];
  int kind;

  try
    {
      hhdr = GC_find_header (p);
      D.5220 = hhdr->hb_obj_kind;
      kind = (int) D.5220;
      D.5222 = GC_describe_type_fns[kind];
      if (D.5222 != 0B) goto <D.5223>; else goto <D.5221>;
      <D.5223>:
      D.5224 = GC_base (p);
      D.5225 = GC_is_marked (D.5224);
      if (D.5225 != 0) goto <D.5226>; else goto <D.5221>;
      <D.5226>:
      buffer[40] = 0;
      D.5222 = GC_describe_type_fns[kind];
      D.5222 (p, &buffer);
      GC_err_puts (&buffer);
      goto <D.4953>;
      <D.5221>:
      switch (kind) <default: <D.4958>, case 0: <D.4952>, case 1: <D.4954>, case 2: <D.4955>, case 3: <D.4956>, case 4: <D.4957>>
      <D.4952>:
      GC_err_puts ("PTRFREE");
      goto <D.4953>;
      <D.4954>:
      GC_err_puts ("NORMAL");
      goto <D.4953>;
      <D.4955>:
      GC_err_puts ("UNCOLLECTABLE");
      goto <D.4953>;
      <D.4956>:
      GC_err_puts ("ATOMIC UNCOLLECTABLE");
      goto <D.4953>;
      <D.4957>:
      GC_err_puts ("STUBBORN");
      goto <D.4953>;
      <D.4958>:
      D.5227 = (long int) kind;
      D.5228 = hhdr->hb_descr;
      D.5229 = (long int) D.5228;
      GC_err_printf ("kind %ld, descr 0x%lx", D.5227, D.5229, 0, 0, 0, 0);
      <D.4953>:
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


GC_print_obj (char * p)
{
  long unsigned int ohdr.5;
  long unsigned int D.5231;
  long int D.5232;
  const char * D.5233;
  long unsigned int D.5234;
  long int D.5235;
  long unsigned int D.5236;
  long int D.5237;
  struct oh * D.5238;
  register struct oh * ohdr;

  ohdr = GC_base (p);
  ohdr.5 = (long unsigned int) ohdr;
  D.5231 = ohdr.5 + 32;
  D.5232 = (long int) D.5231;
  GC_err_printf ("0x%lx (", D.5232, 0, 0, 0, 0, 0);
  D.5233 = ohdr->oh_string;
  GC_err_puts (D.5233);
  D.5234 = ohdr->oh_int;
  D.5235 = (long int) D.5234;
  D.5236 = ohdr->oh_sz;
  D.5237 = (long int) D.5236;
  GC_err_printf (":%ld, sz=%ld, ", D.5235, D.5237, 0, 0, 0, 0);
  D.5238 = ohdr + 32;
  GC_print_type (D.5238);
  GC_err_puts (")\n");
}


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

  D.5239 = GC_has_other_debug_info (p);
  if (D.5239 != 0) goto <D.5240>; else goto <D.5241>;
  <D.5240>:
  GC_print_obj (p);
  goto <D.5242>;
  <D.5241>:
  GC_default_print_heap_obj_proc (p);
  <D.5242>:
}


GC_print_smashed_obj (char * p, char * clobbered_addr)
{
  long int clobbered_addr.6;
  long int p.7;
  word * D.5248;
  const char * D.5250;
  long unsigned int D.5251;
  int GC_all_interior_pointers.8;
  long unsigned int D.5253;
  long unsigned int D.5254;
  long unsigned int D.5255;
  long int D.5256;
  char D.5257;
  long unsigned int D.5261;
  long int D.5262;
  long unsigned int D.5263;
  long int D.5264;
  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.5248 = &ohdr->oh_sz;
  if (D.5248 >= clobbered_addr) goto <D.5245>; else goto <D.5249>;
  <D.5249>:
  D.5250 = ohdr->oh_string;
  if (D.5250 == 0B) goto <D.5245>; else goto <D.5246>;
  <D.5245>:
  D.5251 = GC_size (ohdr);
  GC_all_interior_pointers.8 = GC_all_interior_pointers;
  D.5253 = (long unsigned int) GC_all_interior_pointers.8;
  D.5254 = D.5251 + D.5253;
  D.5255 = D.5254 + 18446744073709551576;
  D.5256 = (long int) D.5255;
  GC_err_printf ("<smashed>, appr. sz = %ld)\n", D.5256, 0, 0, 0, 0, 0);
  goto <D.5247>;
  <D.5246>:
  D.5250 = ohdr->oh_string;
  D.5257 = *D.5250;
  if (D.5257 == 0) goto <D.5258>; else goto <D.5259>;
  <D.5258>:
  GC_err_puts ("EMPTY(smashed?)");
  goto <D.5260>;
  <D.5259>:
  D.5250 = ohdr->oh_string;
  GC_err_puts (D.5250);
  <D.5260>:
  D.5261 = ohdr->oh_int;
  D.5262 = (long int) D.5261;
  D.5263 = ohdr->oh_sz;
  D.5264 = (long int) D.5263;
  GC_err_printf (":%ld, sz=%ld)\n", D.5262, D.5264, 0, 0, 0, 0);
  <D.5247>:
}


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.5265;

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


GC_debug_malloc (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.9;
  long unsigned int D.5267;
  long unsigned int D.5268;
  long unsigned int D.5269;
  long int lb.10;
  long int D.5273;
  void * D.5274;
  int GC_debugging_started.11;
  long unsigned int D.5278;
  void * result;

  GC_all_interior_pointers.9 = GC_all_interior_pointers;
  D.5267 = (long unsigned int) GC_all_interior_pointers.9;
  D.5268 = lb - D.5267;
  D.5269 = D.5268 + 40;
  result = GC_malloc (D.5269);
  if (result == 0B) goto <D.5270>; else goto <D.5271>;
  <D.5270>:
  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.5273 = (long int) i;
  GC_err_printf (":%ld)\n", D.5273, 0, 0, 0, 0, 0);
  D.5274 = 0B;
  return D.5274;
  <D.5271>:
  GC_debugging_started.11 = GC_debugging_started;
  if (GC_debugging_started.11 == 0) goto <D.5276>; else goto <D.5277>;
  <D.5276>:
  GC_start_debugging ();
  <D.5277>:
  D.5278 = (long unsigned int) i;
  D.5274 = GC_store_debug_info (result, lb, s, D.5278);
  return D.5274;
}


GC_debug_malloc_ignore_off_page (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.12;
  long unsigned int D.5281;
  long unsigned int D.5282;
  long unsigned int D.5283;
  long int lb.13;
  long int D.5287;
  void * D.5288;
  int GC_debugging_started.14;
  long unsigned int D.5292;
  void * result;

  GC_all_interior_pointers.12 = GC_all_interior_pointers;
  D.5281 = (long unsigned int) GC_all_interior_pointers.12;
  D.5282 = lb - D.5281;
  D.5283 = D.5282 + 40;
  result = GC_malloc_ignore_off_page (D.5283);
  if (result == 0B) goto <D.5284>; else goto <D.5285>;
  <D.5284>:
  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.5287 = (long int) i;
  GC_err_printf (":%ld)\n", D.5287, 0, 0, 0, 0, 0);
  D.5288 = 0B;
  return D.5288;
  <D.5285>:
  GC_debugging_started.14 = GC_debugging_started;
  if (GC_debugging_started.14 == 0) goto <D.5290>; else goto <D.5291>;
  <D.5290>:
  GC_start_debugging ();
  <D.5291>:
  D.5292 = (long unsigned int) i;
  D.5288 = GC_store_debug_info (result, lb, s, D.5292);
  return D.5288;
}


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.5295;
  long unsigned int D.5296;
  long unsigned int D.5297;
  long int lb.16;
  long int D.5301;
  void * D.5302;
  int GC_debugging_started.17;
  long unsigned int D.5306;
  void * result;

  GC_all_interior_pointers.15 = GC_all_interior_pointers;
  D.5295 = (long unsigned int) GC_all_interior_pointers.15;
  D.5296 = lb - D.5295;
  D.5297 = D.5296 + 40;
  result = GC_malloc_atomic_ignore_off_page (D.5297);
  if (result == 0B) goto <D.5298>; else goto <D.5299>;
  <D.5298>:
  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.5301 = (long int) i;
  GC_err_printf (":%ld)\n", D.5301, 0, 0, 0, 0, 0);
  D.5302 = 0B;
  return D.5302;
  <D.5299>:
  GC_debugging_started.17 = GC_debugging_started;
  if (GC_debugging_started.17 == 0) goto <D.5304>; else goto <D.5305>;
  <D.5304>:
  GC_start_debugging ();
  <D.5305>:
  D.5306 = (long unsigned int) i;
  D.5302 = GC_store_debug_info (result, lb, s, D.5306);
  return D.5302;
}


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

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


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.5311;
  long unsigned int D.5312;
  long unsigned int D.5313;
  long int lb.19;
  long int D.5317;
  void * D.5318;
  int GC_debugging_started.20;
  long unsigned int D.5322;
  void * result;

  GC_all_interior_pointers.18 = GC_all_interior_pointers;
  D.5311 = (long unsigned int) GC_all_interior_pointers.18;
  D.5312 = lb - D.5311;
  D.5313 = D.5312 + 40;
  result = GC_malloc_atomic (D.5313);
  if (result == 0B) goto <D.5314>; else goto <D.5315>;
  <D.5314>:
  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.5317 = (long int) i;
  GC_err_printf (":%ld)\n", D.5317, 0, 0, 0, 0, 0);
  D.5318 = 0B;
  return D.5318;
  <D.5315>:
  GC_debugging_started.20 = GC_debugging_started;
  if (GC_debugging_started.20 == 0) goto <D.5320>; else goto <D.5321>;
  <D.5320>:
  GC_start_debugging ();
  <D.5321>:
  D.5322 = (long unsigned int) i;
  D.5318 = GC_store_debug_info (result, lb, s, D.5322);
  return D.5318;
}


GC_debug_malloc_uncollectable (size_t lb, const char * s, int i)
{
  long unsigned int D.5324;
  long int lb.21;
  long int D.5328;
  void * D.5329;
  int GC_debugging_started.22;
  long unsigned int D.5333;
  void * result;

  D.5324 = lb + 40;
  result = GC_malloc_uncollectable (D.5324);
  if (result == 0B) goto <D.5325>; else goto <D.5326>;
  <D.5325>:
  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.5328 = (long int) i;
  GC_err_printf (":%ld)\n", D.5328, 0, 0, 0, 0, 0);
  D.5329 = 0B;
  return D.5329;
  <D.5326>:
  GC_debugging_started.22 = GC_debugging_started;
  if (GC_debugging_started.22 == 0) goto <D.5331>; else goto <D.5332>;
  <D.5331>:
  GC_start_debugging ();
  <D.5332>:
  D.5333 = (long unsigned int) i;
  D.5329 = GC_store_debug_info (result, lb, s, D.5333);
  return D.5329;
}


GC_debug_malloc_atomic_uncollectable (size_t lb, const char * s, int i)
{
  long unsigned int D.5335;
  long int lb.23;
  long int D.5339;
  void * D.5340;
  int GC_debugging_started.24;
  long unsigned int D.5344;
  void * result;

  D.5335 = lb + 40;
  result = GC_malloc_atomic_uncollectable (D.5335);
  if (result == 0B) goto <D.5336>; else goto <D.5337>;
  <D.5336>:
  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.5339 = (long int) i;
  GC_err_printf (":%ld)\n", D.5339, 0, 0, 0, 0, 0);
  D.5340 = 0B;
  return D.5340;
  <D.5337>:
  GC_debugging_started.24 = GC_debugging_started;
  if (GC_debugging_started.24 == 0) goto <D.5342>; else goto <D.5343>;
  <D.5342>:
  GC_start_debugging ();
  <D.5343>:
  D.5344 = (long unsigned int) i;
  D.5340 = GC_store_debug_info (result, lb, s, D.5344);
  return D.5340;
}


GC_debug_free (void * p)
{
  long int p.25;
  long int base.26;
  long int D.5352;
  long unsigned int D.5358;
  long unsigned int D.5359;
  long unsigned int D.5363;
  int GC_find_leak.27;
  unsigned char D.5368;
  long unsigned int D.5376;
  long unsigned int D.5377;
  word * D.5378;
  register void * base;
  register char * clobbered;

  if (p == 0B) goto <D.5346>; else goto <D.5347>;
  <D.5346>:
  return;
  <D.5347>:
  base = GC_base (p);
  if (base == 0B) goto <D.5348>; else goto <D.5349>;
  <D.5348>:
  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.5349>:
  p.25 = (long int) p;
  base.26 = (long int) base;
  D.5352 = p.25 - base.26;
  if (D.5352 != 32) goto <D.5353>; else goto <D.5354>;
  <D.5353>:
  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.5355>;
  <D.5354>:
  clobbered = GC_check_annotated_obj (base);
  if (clobbered != 0B) goto <D.5356>; else goto <D.5357>;
  <D.5356>:
  D.5358 = MEM[(struct oh *)base].oh_sz;
  D.5359 = GC_size (base);
  if (D.5358 == D.5359) goto <D.5360>; else goto <D.5361>;
  <D.5360>:
  GC_err_puts ("GC_debug_free: found previously deallocated (?) object at ");
  goto <D.5362>;
  <D.5361>:
  GC_err_puts ("GC_debug_free: found smashed location at ");
  <D.5362>:
  GC_print_smashed_obj (p, clobbered);
  <D.5357>:
  D.5363 = GC_size (base);
  MEM[(struct oh *)base].oh_sz = D.5363;
  <D.5355>:
  GC_find_leak.27 = GC_find_leak;
  if (GC_find_leak.27 != 0) goto <D.5365>; else goto <D.5366>;
  <D.5365>:
  GC_free (base);
  goto <D.5367>;
  <D.5366>:
  {
    register struct hdr * hhdr;
    GC_bool uncollectable;

    hhdr = GC_find_header (p);
    uncollectable = 0;
    D.5368 = hhdr->hb_obj_kind;
    if (D.5368 == 2) goto <D.5369>; else goto <D.5370>;
    <D.5369>:
    uncollectable = 1;
    <D.5370>:
    D.5368 = hhdr->hb_obj_kind;
    if (D.5368 == 3) goto <D.5371>; else goto <D.5372>;
    <D.5371>:
    uncollectable = 1;
    <D.5372>:
    if (uncollectable != 0) goto <D.5373>; else goto <D.5374>;
    <D.5373>:
    GC_free (base);
    goto <D.5375>;
    <D.5374>:
    {
      size_t i;
      size_t obj_sz;

      D.5376 = hhdr->hb_sz;
      obj_sz = D.5376 + 18446744073709551612;
      i = 0;
      goto <D.5040>;
      <D.5039>:
      D.5377 = i * 8;
      D.5378 = p + D.5377;
      *D.5378 = 3735928559;
      i = i + 1;
      <D.5040>:
      if (i < obj_sz) goto <D.5039>; else goto <D.5041>;
      <D.5041>:
    }
    <D.5375>:
  }
  <D.5367>:
}


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

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


GC_debug_realloc (void * p, size_t lb, const char * s, int i)
{
  void * D.5383;
  long int p.28;
  long int base.29;
  long int D.5388;
  unsigned char D.5391;
  int D.5392;
  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.5381>; else goto <D.5382>;
  <D.5381>:
  D.5383 = GC_debug_malloc (lb, s, i);
  return D.5383;
  <D.5382>:
  if (base == 0B) goto <D.5384>; else goto <D.5385>;
  <D.5384>:
  p.28 = (long int) p;
  GC_err_printf ("Attempt to reallocate invalid pointer %lx\n", p.28, 0, 0, 0, 0, 0);
  GC_abort ("realloc(invalid pointer)");
  <D.5385>:
  p.28 = (long int) p;
  base.29 = (long int) base;
  D.5388 = p.28 - base.29;
  if (D.5388 != 32) goto <D.5389>; else goto <D.5390>;
  <D.5389>:
  p.28 = (long int) p;
  GC_err_printf ("GC_debug_realloc called on pointer %lx wo debugging info\n", p.28, 0, 0, 0, 0, 0);
  D.5383 = GC_realloc (p, lb);
  return D.5383;
  <D.5390>:
  hhdr = GC_find_header (base);
  D.5391 = hhdr->hb_obj_kind;
  D.5392 = (int) D.5391;
  switch (D.5392) <default: <D.5064>, case 0: <D.5061>, case 1: <D.5059>, case 2: <D.5062>, case 3: <D.5063>>
  <D.5059>:
  result = GC_debug_malloc (lb, s, i);
  goto <D.5060>;
  <D.5061>:
  result = GC_debug_malloc_atomic (lb, s, i);
  goto <D.5060>;
  <D.5062>:
  result = GC_debug_malloc_uncollectable (lb, s, i);
  goto <D.5060>;
  <D.5063>:
  result = GC_debug_malloc_atomic_uncollectable (lb, s, i);
  goto <D.5060>;
  <D.5064>:
  GC_err_puts ("GC_debug_realloc: encountered bad kind\n");
  GC_abort ("bad kind");
  <D.5060>:
  clobbered = GC_check_annotated_obj (base);
  if (clobbered != 0B) goto <D.5393>; else goto <D.5394>;
  <D.5393>:
  GC_err_puts ("GC_debug_realloc: found smashed location at ");
  GC_print_smashed_obj (p, clobbered);
  <D.5394>:
  old_sz = MEM[(struct oh *)base].oh_sz;
  if (old_sz < copy_sz) goto <D.5395>; else goto <D.5396>;
  <D.5395>:
  copy_sz = old_sz;
  <D.5396>:
  if (result == 0B) goto <D.5397>; else goto <D.5398>;
  <D.5397>:
  D.5383 = 0B;
  return D.5383;
  <D.5398>:
  memcpy (result, p, copy_sz);
  GC_debug_free (p);
  D.5383 = result;
  return D.5383;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.5400;
  long unsigned int D.5401;

  D.5401 = __builtin_object_size (__dest, 0);
  D.5400 = __builtin___memcpy_chk (__dest, __src, __len, D.5401);
  return D.5400;
}


GC_add_smashed (char * smashed)
{
  unsigned int GC_n_smashed.30;
  unsigned int D.5406;

  GC_n_smashed.30 = GC_n_smashed;
  GC_smashed[GC_n_smashed.30] = smashed;
  GC_n_smashed.30 = GC_n_smashed;
  if (GC_n_smashed.30 <= 18) goto <D.5404>; else goto <D.5405>;
  <D.5404>:
  GC_n_smashed.30 = GC_n_smashed;
  D.5406 = GC_n_smashed.30 + 1;
  GC_n_smashed = D.5406;
  <D.5405>:
  GC_have_errors = 1;
}


GC_print_all_smashed_proc ()
{
  unsigned int GC_n_smashed.31;
  char * D.5410;
  void * D.5411;
  unsigned int i;

  GC_n_smashed.31 = GC_n_smashed;
  if (GC_n_smashed.31 == 0) goto <D.5408>; else goto <D.5409>;
  <D.5408>:
  return;
  <D.5409>:
  GC_err_puts ("GC_check_heap_block: found smashed heap objects:\n");
  i = 0;
  goto <D.5074>;
  <D.5073>:
  D.5410 = GC_smashed[i];
  D.5411 = GC_base (D.5410);
  D.5410 = GC_smashed[i];
  GC_print_smashed_obj (D.5411, D.5410);
  GC_smashed[i] = 0B;
  i = i + 1;
  <D.5074>:
  GC_n_smashed.31 = GC_n_smashed;
  if (i < GC_n_smashed.31) goto <D.5073>; else goto <D.5075>;
  <D.5075>:
  GC_n_smashed = 0;
}


GC_check_heap_block (struct hblk * hbp, word dummy)
{
  long unsigned int hbp.32;
  long unsigned int D.5417;
  long unsigned int D.5418;
  long unsigned int D.5419;
  int D.5420;
  long unsigned int D.5421;
  int D.5422;
  long unsigned int D.5423;
  long unsigned int D.5424;
  int D.5427;
  unsigned int D.5432;
  unsigned int word_no.33;
  unsigned int D.5434;
  long unsigned int D.5435;
  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.5413>; else goto <D.5414>;
  <D.5413>:
  plim = p;
  goto <D.5415>;
  <D.5414>:
  hbp.32 = (long unsigned int) hbp;
  D.5417 = sz << 3;
  D.5418 = hbp.32 - D.5417;
  D.5419 = D.5418 + 4096;
  plim = (word *) D.5419;
  <D.5415>:
  goto <D.5087>;
  <D.5086>:
  D.5420 = word_no >> 6;
  D.5421 = hhdr->hb_marks[D.5420];
  D.5422 = word_no & 63;
  D.5423 = D.5421 >> D.5422;
  D.5424 = D.5423 & 1;
  if (D.5424 != 0) goto <D.5425>; else goto <D.5426>;
  <D.5425>:
  D.5427 = GC_has_other_debug_info (p);
  if (D.5427 != 0) goto <D.5428>; else goto <D.5429>;
  <D.5428>:
  {
    char * clobbered;

    clobbered = GC_check_annotated_obj (p);
    if (clobbered != 0B) goto <D.5430>; else goto <D.5431>;
    <D.5430>:
    GC_add_smashed (clobbered);
    <D.5431>:
  }
  <D.5429>:
  <D.5426>:
  D.5432 = (unsigned int) sz;
  word_no.33 = (unsigned int) word_no;
  D.5434 = D.5432 + word_no.33;
  word_no = (int) D.5434;
  D.5435 = sz * 8;
  p = p + D.5435;
  <D.5087>:
  if (p <= plim) goto <D.5086>; else goto <D.5088>;
  <D.5088>:
}


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.5436;
  struct closure * result;

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


GC_debug_invoke_finalizer (void * obj, void * data)
{
  void (*<T471>) (void *, void *) D.5438;
  void * D.5439;
  void * D.5440;
  register struct closure * cl;

  cl = data;
  D.5438 = cl->cl_fn;
  D.5439 = obj + 32;
  D.5440 = cl->cl_data;
  D.5438 (D.5439, D.5440);
}


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.34;
  long int base.35;
  long int D.5445;
  void * D.5451;
  void (*<T471>) (void *, void *) my_old_fn.36;
  void * my_old_cd.37;
  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.5441>; else goto <D.5442>;
      <D.5441>:
      return;
      <D.5442>:
      obj.34 = (long int) obj;
      base.35 = (long int) base;
      D.5445 = obj.34 - base.35;
      if (D.5445 != 32) goto <D.5446>; else goto <D.5447>;
      <D.5446>:
      obj.34 = (long int) obj;
      GC_err_printf ("GC_debug_register_finalizer called with non-base-pointer 0x%lx\n", obj.34, 0, 0, 0, 0, 0);
      <D.5447>:
      if (fn == 0B) goto <D.5448>; else goto <D.5449>;
      <D.5448>:
      GC_register_finalizer (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.5450>;
      <D.5449>:
      D.5451 = GC_make_closure (fn, cd);
      GC_register_finalizer (base, GC_debug_invoke_finalizer, D.5451, &my_old_fn, &my_old_cd);
      <D.5450>:
      my_old_fn.36 = my_old_fn;
      my_old_cd.37 = my_old_cd;
      store_old (obj, my_old_fn.36, my_old_cd.37, 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.38;
  void (*<T471>) (void *, void *) D.5465;
  void * D.5468;

  if (my_old_fn != 0B) goto <D.5457>; else goto <D.5458>;
  <D.5457>:
  if (my_old_fn != GC_debug_invoke_finalizer) goto <D.5459>; else goto <D.5460>;
  <D.5459>:
  obj.38 = (long int) obj;
  GC_err_printf ("Debuggable object at 0x%lx had non-debug finalizer.\n", obj.38, 0, 0, 0, 0, 0);
  goto <D.5462>;
  <D.5460>:
  if (ofn != 0B) goto <D.5463>; else goto <D.5464>;
  <D.5463>:
  D.5465 = my_old_cd->cl_fn;
  *ofn = D.5465;
  <D.5464>:
  if (ocd != 0B) goto <D.5466>; else goto <D.5467>;
  <D.5466>:
  D.5468 = my_old_cd->cl_data;
  *ocd = D.5468;
  <D.5467>:
  <D.5462>:
  goto <D.5469>;
  <D.5458>:
  if (ofn != 0B) goto <D.5470>; else goto <D.5471>;
  <D.5470>:
  *ofn = 0B;
  <D.5471>:
  if (ocd != 0B) goto <D.5472>; else goto <D.5473>;
  <D.5472>:
  *ocd = 0B;
  <D.5473>:
  <D.5469>:
}


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.39;
  long int base.40;
  long int D.5478;
  void * D.5484;
  void (*<T471>) (void *, void *) my_old_fn.41;
  void * my_old_cd.42;
  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.5474>; else goto <D.5475>;
      <D.5474>:
      return;
      <D.5475>:
      obj.39 = (long int) obj;
      base.40 = (long int) base;
      D.5478 = obj.39 - base.40;
      if (D.5478 != 32) goto <D.5479>; else goto <D.5480>;
      <D.5479>:
      obj.39 = (long int) obj;
      GC_err_printf ("GC_debug_register_finalizer_no_order called with non-base-pointer 0x%lx\n", obj.39, 0, 0, 0, 0, 0);
      <D.5480>:
      if (fn == 0B) goto <D.5481>; else goto <D.5482>;
      <D.5481>:
      GC_register_finalizer_no_order (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.5483>;
      <D.5482>:
      D.5484 = GC_make_closure (fn, cd);
      GC_register_finalizer_no_order (base, GC_debug_invoke_finalizer, D.5484, &my_old_fn, &my_old_cd);
      <D.5483>:
      my_old_fn.41 = my_old_fn;
      my_old_cd.42 = my_old_cd;
      store_old (obj, my_old_fn.41, my_old_cd.42, 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.43;
  long int base.44;
  long int D.5494;
  void * D.5500;
  void (*<T471>) (void *, void *) my_old_fn.45;
  void * my_old_cd.46;
  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.5490>; else goto <D.5491>;
      <D.5490>:
      return;
      <D.5491>:
      obj.43 = (long int) obj;
      base.44 = (long int) base;
      D.5494 = obj.43 - base.44;
      if (D.5494 != 32) goto <D.5495>; else goto <D.5496>;
      <D.5495>:
      obj.43 = (long int) obj;
      GC_err_printf ("GC_debug_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n", obj.43, 0, 0, 0, 0, 0);
      <D.5496>:
      if (fn == 0B) goto <D.5497>; else goto <D.5498>;
      <D.5497>:
      GC_register_finalizer_ignore_self (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.5499>;
      <D.5498>:
      D.5500 = GC_make_closure (fn, cd);
      GC_register_finalizer_ignore_self (base, GC_debug_invoke_finalizer, D.5500, &my_old_fn, &my_old_cd);
      <D.5499>:
      my_old_fn.45 = my_old_fn;
      my_old_cd.46 = my_old_cd;
      store_old (obj, my_old_fn.45, my_old_cd.46, ofn, ocd);
    }
  finally
    {
      my_old_fn = {CLOBBER};
      my_old_cd = {CLOBBER};
    }
}


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

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


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

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