GC_has_other_debug_info (char * p)
{
  long unsigned int ohdr.0;
  long unsigned int body.1;
  long unsigned int D.5071;
  long unsigned int D.5072;
  GC_bool D.5074;
  long unsigned int D.5075;
  long unsigned int D.5078;
  long unsigned int D.5079;
  long unsigned int D.5082;
  long unsigned int D.5083;
  sizetype D.5084;
  word * D.5085;
  long unsigned int D.5086;
  long unsigned int D.5087;
  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.5071 = ohdr.0 ^ body.1;
  D.5072 = D.5071 & 18446744073709547520;
  if (D.5072 != 0) goto <D.5067>; else goto <D.5073>;
  <D.5073>:
  if (sz <= 39) goto <D.5067>; else goto <D.5068>;
  <D.5067>:
  D.5074 = 0;
  return D.5074;
  <D.5068>:
  D.5075 = ohdr->oh_sz;
  if (D.5075 == sz) goto <D.5076>; else goto <D.5077>;
  <D.5076>:
  D.5074 = 0;
  return D.5074;
  <D.5077>:
  D.5078 = ohdr->oh_sf;
  body.1 = (long unsigned int) body;
  D.5079 = body.1 ^ 4275891659;
  if (D.5078 == D.5079) goto <D.5080>; else goto <D.5081>;
  <D.5080>:
  D.5074 = 1;
  return D.5074;
  <D.5081>:
  D.5082 = sz >> 3;
  D.5083 = D.5082 * 8;
  D.5084 = D.5083 + 18446744073709551608;
  D.5085 = ohdr + D.5084;
  D.5086 = *D.5085;
  body.1 = (long unsigned int) body;
  D.5087 = body.1 ^ 3168718319;
  if (D.5086 == D.5087) goto <D.5088>; else goto <D.5089>;
  <D.5088>:
  D.5074 = 1;
  return D.5074;
  <D.5089>:
  D.5074 = 0;
  return D.5074;
}


GC_store_debug_info (char * p, word sz, const char * string, word integer)
{
  int D.5091;
  long unsigned int result.2;
  long unsigned int D.5095;
  long unsigned int D.5096;
  long unsigned int D.5097;
  long unsigned int D.5098;
  sizetype D.5099;
  word * D.5100;
  long unsigned int D.5101;
  long unsigned int D.5102;
  long unsigned int D.5103;
  word * D.5104;
  long unsigned int D.5105;
  long unsigned int D.5106;
  char * D.5107;
  register word * result;

  result = p + 32;
  D.5091 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5091 != 0) goto <D.5092>; else goto <D.5093>;
  <D.5092>:
  GC_lock ();
  <D.5093>:
  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.5095 = result.2 ^ 4275891659;
  MEM[(struct oh *)p].oh_sf = D.5095;
  D.5096 = GC_size (p);
  D.5097 = D.5096 >> 3;
  D.5098 = D.5097 * 8;
  D.5099 = D.5098 + 18446744073709551608;
  D.5100 = p + D.5099;
  D.5101 = sz + 7;
  D.5102 = D.5101 >> 3;
  D.5103 = D.5102 * 8;
  D.5104 = result + D.5103;
  result.2 = (long unsigned int) result;
  D.5105 = result.2 ^ 3168718319;
  *D.5104 = D.5105;
  D.5106 = *D.5104;
  *D.5100 = D.5106;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.5107 = result;
  return D.5107;
}


GC_check_annotated_obj (struct oh * ohdr)
{
  long unsigned int D.5109;
  int GC_all_interior_pointers.3;
  long unsigned int D.5111;
  long unsigned int D.5112;
  long unsigned int D.5113;
  char * D.5116;
  long unsigned int D.5117;
  long unsigned int body.4;
  long unsigned int D.5119;
  long unsigned int D.5122;
  long unsigned int D.5123;
  sizetype D.5124;
  word * D.5125;
  long unsigned int D.5126;
  long unsigned int D.5127;
  long unsigned int D.5130;
  long unsigned int D.5131;
  long unsigned int D.5132;
  word * D.5133;
  long unsigned int D.5134;
  register char * body;
  register word gc_sz;

  body = ohdr + 32;
  gc_sz = GC_size (ohdr);
  D.5109 = ohdr->oh_sz;
  GC_all_interior_pointers.3 = GC_all_interior_pointers;
  D.5111 = (long unsigned int) GC_all_interior_pointers.3;
  D.5112 = D.5109 - D.5111;
  D.5113 = D.5112 + 40;
  if (D.5113 > gc_sz) goto <D.5114>; else goto <D.5115>;
  <D.5114>:
  D.5116 = &ohdr->oh_sz;
  return D.5116;
  <D.5115>:
  D.5117 = ohdr->oh_sf;
  body.4 = (long unsigned int) body;
  D.5119 = body.4 ^ 4275891659;
  if (D.5117 != D.5119) goto <D.5120>; else goto <D.5121>;
  <D.5120>:
  D.5116 = &ohdr->oh_sf;
  return D.5116;
  <D.5121>:
  D.5122 = gc_sz >> 3;
  D.5123 = D.5122 * 8;
  D.5124 = D.5123 + 18446744073709551608;
  D.5125 = ohdr + D.5124;
  D.5126 = *D.5125;
  body.4 = (long unsigned int) body;
  D.5127 = body.4 ^ 3168718319;
  if (D.5126 != D.5127) goto <D.5128>; else goto <D.5129>;
  <D.5128>:
  D.5122 = gc_sz >> 3;
  D.5123 = D.5122 * 8;
  D.5124 = D.5123 + 18446744073709551608;
  D.5116 = ohdr + D.5124;
  return D.5116;
  <D.5129>:
  D.5109 = ohdr->oh_sz;
  D.5130 = D.5109 + 7;
  D.5131 = D.5130 >> 3;
  D.5132 = D.5131 * 8;
  D.5133 = body + D.5132;
  D.5134 = *D.5133;
  body.4 = (long unsigned int) body;
  D.5127 = body.4 ^ 3168718319;
  if (D.5134 != D.5127) goto <D.5135>; else goto <D.5136>;
  <D.5135>:
  D.5109 = ohdr->oh_sz;
  D.5130 = D.5109 + 7;
  D.5131 = D.5130 >> 3;
  D.5132 = D.5131 * 8;
  D.5116 = body + D.5132;
  return D.5116;
  <D.5136>:
  D.5116 = 0B;
  return D.5116;
}


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.5138;
  void (*<T865>) (void *, char *) D.5140;
  void * D.5142;
  int D.5143;
  long unsigned int D.5145;
  long int D.5146;
  long int D.5147;
  struct hdr * hhdr;
  char buffer[41];
  int kind;

  try
    {
      hhdr = GC_find_header (p);
      D.5138 = hhdr->hb_obj_kind;
      kind = (int) D.5138;
      D.5140 = GC_describe_type_fns[kind];
      if (D.5140 != 0B) goto <D.5141>; else goto <D.5139>;
      <D.5141>:
      D.5142 = GC_base (p);
      D.5143 = GC_is_marked (D.5142);
      if (D.5143 != 0) goto <D.5144>; else goto <D.5139>;
      <D.5144>:
      buffer[40] = 0;
      D.5140 = GC_describe_type_fns[kind];
      D.5140 (p, &buffer);
      GC_err_puts (&buffer);
      goto <D.4871>;
      <D.5139>:
      switch (kind) <default: <D.4876>, case 0: <D.4870>, case 1: <D.4872>, case 2: <D.4873>, case 3: <D.4874>, case 4: <D.4875>>
      <D.4870>:
      GC_err_puts ("PTRFREE");
      goto <D.4871>;
      <D.4872>:
      GC_err_puts ("NORMAL");
      goto <D.4871>;
      <D.4873>:
      GC_err_puts ("UNCOLLECTABLE");
      goto <D.4871>;
      <D.4874>:
      GC_err_puts ("ATOMIC UNCOLLECTABLE");
      goto <D.4871>;
      <D.4875>:
      GC_err_puts ("STUBBORN");
      goto <D.4871>;
      <D.4876>:
      D.5145 = hhdr->hb_descr;
      D.5146 = (long int) D.5145;
      D.5147 = (long int) kind;
      GC_err_printf ("kind %ld, descr 0x%lx", D.5147, D.5146, 0, 0, 0, 0);
      <D.4871>:
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


GC_print_obj (char * p)
{
  long unsigned int ohdr.5;
  long unsigned int D.5149;
  long int D.5150;
  const char * D.5151;
  long unsigned int D.5152;
  long int D.5153;
  long unsigned int D.5154;
  long int D.5155;
  char * D.5156;
  register struct oh * ohdr;

  ohdr = GC_base (p);
  ohdr.5 = (long unsigned int) ohdr;
  D.5149 = ohdr.5 + 32;
  D.5150 = (long int) D.5149;
  GC_err_printf ("0x%lx (", D.5150, 0, 0, 0, 0, 0);
  D.5151 = ohdr->oh_string;
  GC_err_puts (D.5151);
  D.5152 = ohdr->oh_sz;
  D.5153 = (long int) D.5152;
  D.5154 = ohdr->oh_int;
  D.5155 = (long int) D.5154;
  GC_err_printf (":%ld, sz=%ld, ", D.5155, D.5153, 0, 0, 0, 0);
  D.5156 = ohdr + 32;
  GC_print_type (D.5156);
  GC_err_puts (")\n");
}


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

  D.5157 = GC_has_other_debug_info (p);
  if (D.5157 != 0) goto <D.5158>; else goto <D.5159>;
  <D.5158>:
  GC_print_obj (p);
  goto <D.5160>;
  <D.5159>:
  GC_default_print_heap_obj_proc (p);
  <D.5160>:
}


GC_print_smashed_obj (char * p, char * clobbered_addr)
{
  long int p.6;
  long int clobbered_addr.7;
  word * D.5166;
  const char * D.5168;
  long unsigned int D.5169;
  int GC_all_interior_pointers.8;
  long unsigned int D.5171;
  long unsigned int D.5172;
  long unsigned int D.5173;
  long int D.5174;
  char D.5175;
  long unsigned int D.5179;
  long int D.5180;
  long unsigned int D.5181;
  long int D.5182;
  register struct oh * ohdr;

  ohdr = GC_base (p);
  p.6 = (long int) p;
  clobbered_addr.7 = (long int) clobbered_addr;
  GC_err_printf ("0x%lx in object at 0x%lx(", clobbered_addr.7, p.6, 0, 0, 0, 0);
  D.5166 = &ohdr->oh_sz;
  if (D.5166 >= clobbered_addr) goto <D.5163>; else goto <D.5167>;
  <D.5167>:
  D.5168 = ohdr->oh_string;
  if (D.5168 == 0B) goto <D.5163>; else goto <D.5164>;
  <D.5163>:
  D.5169 = GC_size (ohdr);
  GC_all_interior_pointers.8 = GC_all_interior_pointers;
  D.5171 = (long unsigned int) GC_all_interior_pointers.8;
  D.5172 = D.5169 + D.5171;
  D.5173 = D.5172 + 18446744073709551576;
  D.5174 = (long int) D.5173;
  GC_err_printf ("<smashed>, appr. sz = %ld)\n", D.5174, 0, 0, 0, 0, 0);
  goto <D.5165>;
  <D.5164>:
  D.5168 = ohdr->oh_string;
  D.5175 = *D.5168;
  if (D.5175 == 0) goto <D.5176>; else goto <D.5177>;
  <D.5176>:
  GC_err_puts ("EMPTY(smashed?)");
  goto <D.5178>;
  <D.5177>:
  D.5168 = ohdr->oh_string;
  GC_err_puts (D.5168);
  <D.5178>:
  D.5179 = ohdr->oh_sz;
  D.5180 = (long int) D.5179;
  D.5181 = ohdr->oh_int;
  D.5182 = (long int) D.5181;
  GC_err_printf (":%ld, sz=%ld)\n", D.5182, D.5180, 0, 0, 0, 0);
  <D.5165>:
}


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

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


GC_debug_malloc (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.9;
  long unsigned int D.5185;
  long unsigned int D.5186;
  long unsigned int D.5187;
  long int lb.10;
  long int D.5191;
  void * D.5192;
  int GC_debugging_started.11;
  long unsigned int D.5196;
  void * result;

  GC_all_interior_pointers.9 = GC_all_interior_pointers;
  D.5185 = (long unsigned int) GC_all_interior_pointers.9;
  D.5186 = lb - D.5185;
  D.5187 = D.5186 + 40;
  result = GC_malloc (D.5187);
  if (result == 0B) goto <D.5188>; else goto <D.5189>;
  <D.5188>:
  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.5191 = (long int) i;
  GC_err_printf (":%ld)\n", D.5191, 0, 0, 0, 0, 0);
  D.5192 = 0B;
  return D.5192;
  <D.5189>:
  GC_debugging_started.11 = GC_debugging_started;
  if (GC_debugging_started.11 == 0) goto <D.5194>; else goto <D.5195>;
  <D.5194>:
  GC_start_debugging ();
  <D.5195>:
  D.5196 = (long unsigned int) i;
  D.5192 = GC_store_debug_info (result, lb, s, D.5196);
  return D.5192;
}


GC_debug_malloc_ignore_off_page (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.12;
  long unsigned int D.5199;
  long unsigned int D.5200;
  long unsigned int D.5201;
  long int lb.13;
  long int D.5205;
  void * D.5206;
  int GC_debugging_started.14;
  long unsigned int D.5210;
  void * result;

  GC_all_interior_pointers.12 = GC_all_interior_pointers;
  D.5199 = (long unsigned int) GC_all_interior_pointers.12;
  D.5200 = lb - D.5199;
  D.5201 = D.5200 + 40;
  result = GC_malloc_ignore_off_page (D.5201);
  if (result == 0B) goto <D.5202>; else goto <D.5203>;
  <D.5202>:
  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.5205 = (long int) i;
  GC_err_printf (":%ld)\n", D.5205, 0, 0, 0, 0, 0);
  D.5206 = 0B;
  return D.5206;
  <D.5203>:
  GC_debugging_started.14 = GC_debugging_started;
  if (GC_debugging_started.14 == 0) goto <D.5208>; else goto <D.5209>;
  <D.5208>:
  GC_start_debugging ();
  <D.5209>:
  D.5210 = (long unsigned int) i;
  D.5206 = GC_store_debug_info (result, lb, s, D.5210);
  return D.5206;
}


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.5213;
  long unsigned int D.5214;
  long unsigned int D.5215;
  long int lb.16;
  long int D.5219;
  void * D.5220;
  int GC_debugging_started.17;
  long unsigned int D.5224;
  void * result;

  GC_all_interior_pointers.15 = GC_all_interior_pointers;
  D.5213 = (long unsigned int) GC_all_interior_pointers.15;
  D.5214 = lb - D.5213;
  D.5215 = D.5214 + 40;
  result = GC_malloc_atomic_ignore_off_page (D.5215);
  if (result == 0B) goto <D.5216>; else goto <D.5217>;
  <D.5216>:
  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.5219 = (long int) i;
  GC_err_printf (":%ld)\n", D.5219, 0, 0, 0, 0, 0);
  D.5220 = 0B;
  return D.5220;
  <D.5217>:
  GC_debugging_started.17 = GC_debugging_started;
  if (GC_debugging_started.17 == 0) goto <D.5222>; else goto <D.5223>;
  <D.5222>:
  GC_start_debugging ();
  <D.5223>:
  D.5224 = (long unsigned int) i;
  D.5220 = GC_store_debug_info (result, lb, s, D.5224);
  return D.5220;
}


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

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


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.5229;
  long unsigned int D.5230;
  long unsigned int D.5231;
  long int lb.19;
  long int D.5235;
  void * D.5236;
  int GC_debugging_started.20;
  long unsigned int D.5240;
  void * result;

  GC_all_interior_pointers.18 = GC_all_interior_pointers;
  D.5229 = (long unsigned int) GC_all_interior_pointers.18;
  D.5230 = lb - D.5229;
  D.5231 = D.5230 + 40;
  result = GC_malloc_atomic (D.5231);
  if (result == 0B) goto <D.5232>; else goto <D.5233>;
  <D.5232>:
  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.5235 = (long int) i;
  GC_err_printf (":%ld)\n", D.5235, 0, 0, 0, 0, 0);
  D.5236 = 0B;
  return D.5236;
  <D.5233>:
  GC_debugging_started.20 = GC_debugging_started;
  if (GC_debugging_started.20 == 0) goto <D.5238>; else goto <D.5239>;
  <D.5238>:
  GC_start_debugging ();
  <D.5239>:
  D.5240 = (long unsigned int) i;
  D.5236 = GC_store_debug_info (result, lb, s, D.5240);
  return D.5236;
}


GC_debug_malloc_uncollectable (size_t lb, const char * s, int i)
{
  long unsigned int D.5242;
  long int lb.21;
  long int D.5246;
  void * D.5247;
  int GC_debugging_started.22;
  long unsigned int D.5251;
  void * result;

  D.5242 = lb + 40;
  result = GC_malloc_uncollectable (D.5242);
  if (result == 0B) goto <D.5243>; else goto <D.5244>;
  <D.5243>:
  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.5246 = (long int) i;
  GC_err_printf (":%ld)\n", D.5246, 0, 0, 0, 0, 0);
  D.5247 = 0B;
  return D.5247;
  <D.5244>:
  GC_debugging_started.22 = GC_debugging_started;
  if (GC_debugging_started.22 == 0) goto <D.5249>; else goto <D.5250>;
  <D.5249>:
  GC_start_debugging ();
  <D.5250>:
  D.5251 = (long unsigned int) i;
  D.5247 = GC_store_debug_info (result, lb, s, D.5251);
  return D.5247;
}


GC_debug_malloc_atomic_uncollectable (size_t lb, const char * s, int i)
{
  long unsigned int D.5253;
  long int lb.23;
  long int D.5257;
  void * D.5258;
  int GC_debugging_started.24;
  long unsigned int D.5262;
  void * result;

  D.5253 = lb + 40;
  result = GC_malloc_atomic_uncollectable (D.5253);
  if (result == 0B) goto <D.5254>; else goto <D.5255>;
  <D.5254>:
  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.5257 = (long int) i;
  GC_err_printf (":%ld)\n", D.5257, 0, 0, 0, 0, 0);
  D.5258 = 0B;
  return D.5258;
  <D.5255>:
  GC_debugging_started.24 = GC_debugging_started;
  if (GC_debugging_started.24 == 0) goto <D.5260>; else goto <D.5261>;
  <D.5260>:
  GC_start_debugging ();
  <D.5261>:
  D.5262 = (long unsigned int) i;
  D.5258 = GC_store_debug_info (result, lb, s, D.5262);
  return D.5258;
}


GC_debug_free (void * p)
{
  long int p.25;
  long int p.26;
  long int base.27;
  long int D.5271;
  long unsigned int D.5277;
  long unsigned int D.5278;
  long unsigned int D.5282;
  int GC_find_leak.28;
  unsigned char D.5287;
  long unsigned int D.5295;
  long unsigned int D.5296;
  word * D.5297;
  register void * base;
  register char * clobbered;

  if (p == 0B) goto <D.5264>; else goto <D.5265>;
  <D.5264>:
  return;
  <D.5265>:
  base = GC_base (p);
  if (base == 0B) goto <D.5266>; else goto <D.5267>;
  <D.5266>:
  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.5267>:
  p.26 = (long int) p;
  base.27 = (long int) base;
  D.5271 = p.26 - base.27;
  if (D.5271 != 32) goto <D.5272>; else goto <D.5273>;
  <D.5272>:
  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.5274>;
  <D.5273>:
  clobbered = GC_check_annotated_obj (base);
  if (clobbered != 0B) goto <D.5275>; else goto <D.5276>;
  <D.5275>:
  D.5277 = MEM[(struct oh *)base].oh_sz;
  D.5278 = GC_size (base);
  if (D.5277 == D.5278) goto <D.5279>; else goto <D.5280>;
  <D.5279>:
  GC_err_puts ("GC_debug_free: found previously deallocated (?) object at ");
  goto <D.5281>;
  <D.5280>:
  GC_err_puts ("GC_debug_free: found smashed location at ");
  <D.5281>:
  GC_print_smashed_obj (p, clobbered);
  <D.5276>:
  D.5282 = GC_size (base);
  MEM[(struct oh *)base].oh_sz = D.5282;
  <D.5274>:
  GC_find_leak.28 = GC_find_leak;
  if (GC_find_leak.28 != 0) goto <D.5284>; else goto <D.5285>;
  <D.5284>:
  GC_free (base);
  goto <D.5286>;
  <D.5285>:
  {
    register struct hdr * hhdr;
    GC_bool uncollectable;

    hhdr = GC_find_header (p);
    uncollectable = 0;
    D.5287 = hhdr->hb_obj_kind;
    if (D.5287 == 2) goto <D.5288>; else goto <D.5289>;
    <D.5288>:
    uncollectable = 1;
    <D.5289>:
    D.5287 = hhdr->hb_obj_kind;
    if (D.5287 == 3) goto <D.5290>; else goto <D.5291>;
    <D.5290>:
    uncollectable = 1;
    <D.5291>:
    if (uncollectable != 0) goto <D.5292>; else goto <D.5293>;
    <D.5292>:
    GC_free (base);
    goto <D.5294>;
    <D.5293>:
    {
      size_t i;
      size_t obj_sz;

      D.5295 = hhdr->hb_sz;
      obj_sz = D.5295 + 18446744073709551612;
      i = 0;
      goto <D.4958>;
      <D.4957>:
      D.5296 = i * 8;
      D.5297 = p + D.5296;
      *D.5297 = 3735928559;
      i = i + 1;
      <D.4958>:
      if (i < obj_sz) goto <D.4957>; else goto <D.4959>;
      <D.4959>:
    }
    <D.5294>:
  }
  <D.5286>:
}


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

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


GC_debug_realloc (void * p, size_t lb, const char * s, int i)
{
  void * D.5302;
  long int p.29;
  long int p.30;
  long int base.31;
  long int D.5308;
  unsigned char D.5311;
  int D.5312;
  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.5300>; else goto <D.5301>;
  <D.5300>:
  D.5302 = GC_debug_malloc (lb, s, i);
  return D.5302;
  <D.5301>:
  if (base == 0B) goto <D.5303>; else goto <D.5304>;
  <D.5303>:
  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.5304>:
  p.30 = (long int) p;
  base.31 = (long int) base;
  D.5308 = p.30 - base.31;
  if (D.5308 != 32) goto <D.5309>; else goto <D.5310>;
  <D.5309>:
  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.5302 = GC_realloc (p, lb);
  return D.5302;
  <D.5310>:
  hhdr = GC_find_header (base);
  D.5311 = hhdr->hb_obj_kind;
  D.5312 = (int) D.5311;
  switch (D.5312) <default: <D.4982>, case 0: <D.4979>, case 1: <D.4977>, case 2: <D.4980>, case 3: <D.4981>>
  <D.4977>:
  result = GC_debug_malloc (lb, s, i);
  goto <D.4978>;
  <D.4979>:
  result = GC_debug_malloc_atomic (lb, s, i);
  goto <D.4978>;
  <D.4980>:
  result = GC_debug_malloc_uncollectable (lb, s, i);
  goto <D.4978>;
  <D.4981>:
  result = GC_debug_malloc_atomic_uncollectable (lb, s, i);
  goto <D.4978>;
  <D.4982>:
  GC_err_puts ("GC_debug_realloc: encountered bad kind\n");
  GC_abort ("bad kind");
  <D.4978>:
  clobbered = GC_check_annotated_obj (base);
  if (clobbered != 0B) goto <D.5313>; else goto <D.5314>;
  <D.5313>:
  GC_err_puts ("GC_debug_realloc: found smashed location at ");
  GC_print_smashed_obj (p, clobbered);
  <D.5314>:
  old_sz = MEM[(struct oh *)base].oh_sz;
  if (old_sz < copy_sz) goto <D.5315>; else goto <D.5316>;
  <D.5315>:
  copy_sz = old_sz;
  <D.5316>:
  if (result == 0B) goto <D.5317>; else goto <D.5318>;
  <D.5317>:
  D.5302 = 0B;
  return D.5302;
  <D.5318>:
  memcpy (result, p, copy_sz);
  GC_debug_free (p);
  D.5302 = result;
  return D.5302;
}


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

  D.5321 = __builtin_object_size (__dest, 0);
  D.5320 = __builtin___memcpy_chk (__dest, __src, __len, D.5321);
  return D.5320;
}


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.5324>; else goto <D.5325>;
  <D.5324>:
  GC_n_smashed.32 = GC_n_smashed;
  GC_n_smashed.33 = GC_n_smashed.32 + 1;
  GC_n_smashed = GC_n_smashed.33;
  <D.5325>:
  GC_have_errors = 1;
}


GC_print_all_smashed_proc ()
{
  unsigned int GC_n_smashed.34;
  char * D.5330;
  void * D.5331;
  unsigned int i;

  GC_n_smashed.34 = GC_n_smashed;
  if (GC_n_smashed.34 == 0) goto <D.5328>; else goto <D.5329>;
  <D.5328>:
  return;
  <D.5329>:
  GC_err_puts ("GC_check_heap_block: found smashed heap objects:\n");
  i = 0;
  goto <D.4992>;
  <D.4991>:
  D.5330 = GC_smashed[i];
  D.5330 = GC_smashed[i];
  D.5331 = GC_base (D.5330);
  GC_print_smashed_obj (D.5331, D.5330);
  GC_smashed[i] = 0B;
  i = i + 1;
  <D.4992>:
  GC_n_smashed.34 = GC_n_smashed;
  if (i < GC_n_smashed.34) goto <D.4991>; else goto <D.4993>;
  <D.4993>:
  GC_n_smashed = 0;
}


GC_check_heap_block (struct hblk * hbp, word dummy)
{
  long unsigned int hbp.35;
  long unsigned int D.5337;
  long unsigned int D.5338;
  long unsigned int D.5339;
  int D.5340;
  long unsigned int D.5341;
  int D.5342;
  long unsigned int D.5343;
  long unsigned int D.5344;
  int D.5347;
  unsigned int D.5352;
  unsigned int word_no.36;
  unsigned int D.5354;
  long unsigned int D.5355;
  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.5333>; else goto <D.5334>;
  <D.5333>:
  plim = p;
  goto <D.5335>;
  <D.5334>:
  hbp.35 = (long unsigned int) hbp;
  D.5337 = sz << 3;
  D.5338 = hbp.35 - D.5337;
  D.5339 = D.5338 + 4096;
  plim = (word *) D.5339;
  <D.5335>:
  goto <D.5005>;
  <D.5004>:
  D.5340 = word_no >> 6;
  D.5341 = hhdr->hb_marks[D.5340];
  D.5342 = word_no & 63;
  D.5343 = D.5341 >> D.5342;
  D.5344 = D.5343 & 1;
  if (D.5344 != 0) goto <D.5345>; else goto <D.5346>;
  <D.5345>:
  D.5347 = GC_has_other_debug_info (p);
  if (D.5347 != 0) goto <D.5348>; else goto <D.5349>;
  <D.5348>:
  {
    char * clobbered;

    clobbered = GC_check_annotated_obj (p);
    if (clobbered != 0B) goto <D.5350>; else goto <D.5351>;
    <D.5350>:
    GC_add_smashed (clobbered);
    <D.5351>:
  }
  <D.5349>:
  <D.5346>:
  D.5352 = (unsigned int) sz;
  word_no.36 = (unsigned int) word_no;
  D.5354 = D.5352 + word_no.36;
  word_no = (int) D.5354;
  D.5355 = sz * 8;
  p = p + D.5355;
  <D.5005>:
  if (p <= plim) goto <D.5004>; else goto <D.5006>;
  <D.5006>:
}


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

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


GC_debug_invoke_finalizer (void * obj, void * data)
{
  void (*<T3fb>) (void *, void *) D.5358;
  void * D.5359;
  void * D.5360;
  register struct closure * cl;

  cl = data;
  D.5358 = cl->cl_fn;
  D.5359 = cl->cl_data;
  D.5360 = obj + 32;
  D.5358 (D.5360, D.5359);
}


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.5365;
  void * D.5371;
  void * my_old_cd.39;
  void (*<T3fb>) (void *, void *) my_old_fn.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.5361>; else goto <D.5362>;
      <D.5361>:
      return;
      <D.5362>:
      obj.37 = (long int) obj;
      base.38 = (long int) base;
      D.5365 = obj.37 - base.38;
      if (D.5365 != 32) goto <D.5366>; else goto <D.5367>;
      <D.5366>:
      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.5367>:
      if (fn == 0B) goto <D.5368>; else goto <D.5369>;
      <D.5368>:
      GC_register_finalizer (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.5370>;
      <D.5369>:
      D.5371 = GC_make_closure (fn, cd);
      GC_register_finalizer (base, GC_debug_invoke_finalizer, D.5371, &my_old_fn, &my_old_cd);
      <D.5370>:
      my_old_cd.39 = my_old_cd;
      my_old_fn.40 = my_old_fn;
      store_old (obj, my_old_fn.40, my_old_cd.39, 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 (*<T3fb>) (void *, void *) D.5385;
  void * D.5388;

  if (my_old_fn != 0B) goto <D.5377>; else goto <D.5378>;
  <D.5377>:
  if (my_old_fn != GC_debug_invoke_finalizer) goto <D.5379>; else goto <D.5380>;
  <D.5379>:
  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.5382>;
  <D.5380>:
  if (ofn != 0B) goto <D.5383>; else goto <D.5384>;
  <D.5383>:
  D.5385 = my_old_cd->cl_fn;
  *ofn = D.5385;
  <D.5384>:
  if (ocd != 0B) goto <D.5386>; else goto <D.5387>;
  <D.5386>:
  D.5388 = my_old_cd->cl_data;
  *ocd = D.5388;
  <D.5387>:
  <D.5382>:
  goto <D.5389>;
  <D.5378>:
  if (ofn != 0B) goto <D.5390>; else goto <D.5391>;
  <D.5390>:
  *ofn = 0B;
  <D.5391>:
  if (ocd != 0B) goto <D.5392>; else goto <D.5393>;
  <D.5392>:
  *ocd = 0B;
  <D.5393>:
  <D.5389>:
}


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.5398;
  void * D.5404;
  void * my_old_cd.44;
  void (*<T3fb>) (void *, void *) my_old_fn.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.5394>; else goto <D.5395>;
      <D.5394>:
      return;
      <D.5395>:
      obj.42 = (long int) obj;
      base.43 = (long int) base;
      D.5398 = obj.42 - base.43;
      if (D.5398 != 32) goto <D.5399>; else goto <D.5400>;
      <D.5399>:
      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.5400>:
      if (fn == 0B) goto <D.5401>; else goto <D.5402>;
      <D.5401>:
      GC_register_finalizer_no_order (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.5403>;
      <D.5402>:
      D.5404 = GC_make_closure (fn, cd);
      GC_register_finalizer_no_order (base, GC_debug_invoke_finalizer, D.5404, &my_old_fn, &my_old_cd);
      <D.5403>:
      my_old_cd.44 = my_old_cd;
      my_old_fn.45 = my_old_fn;
      store_old (obj, my_old_fn.45, my_old_cd.44, 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.5414;
  void * D.5420;
  void * my_old_cd.48;
  void (*<T3fb>) (void *, void *) my_old_fn.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.5410>; else goto <D.5411>;
      <D.5410>:
      return;
      <D.5411>:
      obj.46 = (long int) obj;
      base.47 = (long int) base;
      D.5414 = obj.46 - base.47;
      if (D.5414 != 32) goto <D.5415>; else goto <D.5416>;
      <D.5415>:
      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.5416>:
      if (fn == 0B) goto <D.5417>; else goto <D.5418>;
      <D.5417>:
      GC_register_finalizer_ignore_self (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.5419>;
      <D.5418>:
      D.5420 = GC_make_closure (fn, cd);
      GC_register_finalizer_ignore_self (base, GC_debug_invoke_finalizer, D.5420, &my_old_fn, &my_old_cd);
      <D.5419>:
      my_old_cd.48 = my_old_cd;
      my_old_fn.49 = my_old_fn;
      store_old (obj, my_old_fn.49, my_old_cd.48, ofn, ocd);
    }
  finally
    {
      my_old_fn = {CLOBBER};
      my_old_cd = {CLOBBER};
    }
}


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

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


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

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