GC_has_other_debug_info (char * p)
{
  long unsigned int ohdr.0;
  long unsigned int body.1;
  long unsigned int D.7234;
  long unsigned int D.7235;
  GC_bool D.7237;
  long unsigned int D.7238;
  long unsigned int D.7241;
  long unsigned int D.7242;
  long unsigned int D.7245;
  sizetype D.7246;
  sizetype D.7247;
  word * D.7248;
  long unsigned int D.7249;
  long unsigned int D.7250;
  register struct oh * ohdr;
  register char * body;
  register word sz;

  ohdr = p;
  body = ohdr + 16;
  sz = GC_size (ohdr);
  ohdr.0 = (long unsigned int) ohdr;
  body.1 = (long unsigned int) body;
  D.7234 = ohdr.0 ^ body.1;
  D.7235 = D.7234 & 4294963200;
  if (D.7235 != 0) goto <D.7230>; else goto <D.7236>;
  <D.7236>:
  if (sz <= 19) goto <D.7230>; else goto <D.7231>;
  <D.7230>:
  D.7237 = 0;
  return D.7237;
  <D.7231>:
  D.7238 = ohdr->oh_sz;
  if (D.7238 == sz) goto <D.7239>; else goto <D.7240>;
  <D.7239>:
  D.7237 = 0;
  return D.7237;
  <D.7240>:
  D.7241 = ohdr->oh_sf;
  body.1 = (long unsigned int) body;
  D.7242 = body.1 ^ 4275891659;
  if (D.7241 == D.7242) goto <D.7243>; else goto <D.7244>;
  <D.7243>:
  D.7237 = 1;
  return D.7237;
  <D.7244>:
  D.7245 = sz >> 2;
  D.7246 = D.7245 + 1073741823;
  D.7247 = D.7246 * 4;
  D.7248 = ohdr + D.7247;
  D.7249 = *D.7248;
  body.1 = (long unsigned int) body;
  D.7250 = body.1 ^ 3168718319;
  if (D.7249 == D.7250) goto <D.7251>; else goto <D.7252>;
  <D.7251>:
  D.7237 = 1;
  return D.7237;
  <D.7252>:
  D.7237 = 0;
  return D.7237;
}


GC_store_debug_info (char * p, word sz, const char * string, word integer)
{
  int D.7254;
  long unsigned int result.2;
  long unsigned int D.7258;
  unsigned int D.7259;
  unsigned int D.7260;
  sizetype D.7261;
  sizetype D.7262;
  word * D.7263;
  long unsigned int D.7264;
  long unsigned int D.7265;
  long unsigned int D.7266;
  word * D.7267;
  long unsigned int D.7268;
  long unsigned int D.7269;
  char * D.7270;
  register word * result;

  result = p + 16;
  D.7254 = GC_test_and_set (&GC_allocate_lock);
  if (D.7254 != 0) goto <D.7255>; else goto <D.7256>;
  <D.7255>:
  GC_lock ();
  <D.7256>:
  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.7258 = result.2 ^ 4275891659;
  MEM[(struct oh *)p].oh_sf = D.7258;
  D.7259 = GC_size (p);
  D.7260 = D.7259 >> 2;
  D.7261 = D.7260 + 1073741823;
  D.7262 = D.7261 * 4;
  D.7263 = p + D.7262;
  D.7264 = sz + 3;
  D.7265 = D.7264 >> 2;
  D.7266 = D.7265 * 4;
  D.7267 = result + D.7266;
  result.2 = (long unsigned int) result;
  D.7268 = result.2 ^ 3168718319;
  *D.7267 = D.7268;
  D.7269 = *D.7267;
  *D.7263 = D.7269;
  GC_clear (&GC_allocate_lock);
  D.7270 = result;
  return D.7270;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.7272;
  unsigned int D.7273;

  D.7273 = __sync_lock_test_and_set_4 (addr, 1);
  D.7272 = (int) D.7273;
  return D.7272;
}


GC_clear (volatile unsigned int * addr)
{
  __sync_synchronize ();
  *addr = 0;
}


GC_check_annotated_obj (struct oh * ohdr)
{
  long unsigned int D.7275;
  int GC_all_interior_pointers.3;
  long unsigned int GC_all_interior_pointers.4;
  long unsigned int D.7278;
  long unsigned int D.7279;
  char * D.7282;
  long unsigned int D.7283;
  long unsigned int body.5;
  long unsigned int D.7285;
  long unsigned int D.7288;
  sizetype D.7289;
  sizetype D.7290;
  word * D.7291;
  long unsigned int D.7292;
  long unsigned int D.7293;
  long unsigned int D.7296;
  long unsigned int D.7297;
  long unsigned int D.7298;
  word * D.7299;
  long unsigned int D.7300;
  register char * body;
  register word gc_sz;

  body = ohdr + 16;
  gc_sz = GC_size (ohdr);
  D.7275 = ohdr->oh_sz;
  GC_all_interior_pointers.3 = GC_all_interior_pointers;
  GC_all_interior_pointers.4 = (long unsigned int) GC_all_interior_pointers.3;
  D.7278 = D.7275 - GC_all_interior_pointers.4;
  D.7279 = D.7278 + 20;
  if (D.7279 > gc_sz) goto <D.7280>; else goto <D.7281>;
  <D.7280>:
  D.7282 = &ohdr->oh_sz;
  return D.7282;
  <D.7281>:
  D.7283 = ohdr->oh_sf;
  body.5 = (long unsigned int) body;
  D.7285 = body.5 ^ 4275891659;
  if (D.7283 != D.7285) goto <D.7286>; else goto <D.7287>;
  <D.7286>:
  D.7282 = &ohdr->oh_sf;
  return D.7282;
  <D.7287>:
  D.7288 = gc_sz >> 2;
  D.7289 = D.7288 + 1073741823;
  D.7290 = D.7289 * 4;
  D.7291 = ohdr + D.7290;
  D.7292 = *D.7291;
  body.5 = (long unsigned int) body;
  D.7293 = body.5 ^ 3168718319;
  if (D.7292 != D.7293) goto <D.7294>; else goto <D.7295>;
  <D.7294>:
  D.7288 = gc_sz >> 2;
  D.7289 = D.7288 + 1073741823;
  D.7290 = D.7289 * 4;
  D.7282 = ohdr + D.7290;
  return D.7282;
  <D.7295>:
  D.7275 = ohdr->oh_sz;
  D.7296 = D.7275 + 3;
  D.7297 = D.7296 >> 2;
  D.7298 = D.7297 * 4;
  D.7299 = body + D.7298;
  D.7300 = *D.7299;
  body.5 = (long unsigned int) body;
  D.7293 = body.5 ^ 3168718319;
  if (D.7300 != D.7293) goto <D.7301>; else goto <D.7302>;
  <D.7301>:
  D.7275 = ohdr->oh_sz;
  D.7296 = D.7275 + 3;
  D.7297 = D.7296 >> 2;
  D.7298 = D.7297 * 4;
  D.7282 = body + D.7298;
  return D.7282;
  <D.7302>:
  D.7282 = 0B;
  return D.7282;
}


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.7304;
  void (*<T11f7>) (void *, char *) D.7306;
  void * D.7308;
  int D.7309;
  long unsigned int D.7311;
  long int D.7312;
  struct hdr * hhdr;
  char buffer[41];
  int kind;

  try
    {
      hhdr = GC_find_header (p);
      D.7304 = hhdr->hb_obj_kind;
      kind = (int) D.7304;
      D.7306 = GC_describe_type_fns[kind];
      if (D.7306 != 0B) goto <D.7307>; else goto <D.7305>;
      <D.7307>:
      D.7308 = GC_base (p);
      D.7309 = GC_is_marked (D.7308);
      if (D.7309 != 0) goto <D.7310>; else goto <D.7305>;
      <D.7310>:
      buffer[40] = 0;
      D.7306 = GC_describe_type_fns[kind];
      D.7306 (p, &buffer);
      GC_err_puts (&buffer);
      goto <D.7032>;
      <D.7305>:
      switch (kind) <default: <D.7037>, case 0: <D.7031>, case 1: <D.7033>, case 2: <D.7034>, case 3: <D.7035>, case 4: <D.7036>>
      <D.7031>:
      GC_err_puts ("PTRFREE");
      goto <D.7032>;
      <D.7033>:
      GC_err_puts ("NORMAL");
      goto <D.7032>;
      <D.7034>:
      GC_err_puts ("UNCOLLECTABLE");
      goto <D.7032>;
      <D.7035>:
      GC_err_puts ("ATOMIC UNCOLLECTABLE");
      goto <D.7032>;
      <D.7036>:
      GC_err_puts ("STUBBORN");
      goto <D.7032>;
      <D.7037>:
      D.7311 = hhdr->hb_descr;
      D.7312 = (long int) D.7311;
      GC_err_printf ("kind %ld, descr 0x%lx", kind, D.7312, 0, 0, 0, 0);
      <D.7032>:
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


GC_print_obj (char * p)
{
  long unsigned int ohdr.6;
  long unsigned int D.7314;
  long int D.7315;
  const char * D.7316;
  long unsigned int D.7317;
  long int D.7318;
  long unsigned int D.7319;
  long int D.7320;
  char * D.7321;
  register struct oh * ohdr;

  ohdr = GC_base (p);
  ohdr.6 = (long unsigned int) ohdr;
  D.7314 = ohdr.6 + 16;
  D.7315 = (long int) D.7314;
  GC_err_printf ("0x%lx (", D.7315, 0, 0, 0, 0, 0);
  D.7316 = ohdr->oh_string;
  GC_err_puts (D.7316);
  D.7317 = ohdr->oh_int;
  D.7318 = (long int) D.7317;
  D.7319 = ohdr->oh_sz;
  D.7320 = (long int) D.7319;
  GC_err_printf (":%ld, sz=%ld, ", D.7318, D.7320, 0, 0, 0, 0);
  D.7321 = ohdr + 16;
  GC_print_type (D.7321);
  GC_err_puts (")\n");
}


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

  D.7322 = GC_has_other_debug_info (p);
  if (D.7322 != 0) goto <D.7323>; else goto <D.7324>;
  <D.7323>:
  GC_print_obj (p);
  goto <D.7325>;
  <D.7324>:
  GC_default_print_heap_obj_proc (p);
  <D.7325>:
}


GC_print_smashed_obj (char * p, char * clobbered_addr)
{
  long int clobbered_addr.7;
  long int p.8;
  word * D.7331;
  const char * D.7333;
  unsigned int D.7334;
  int GC_all_interior_pointers.9;
  unsigned int GC_all_interior_pointers.10;
  unsigned int D.7337;
  unsigned int D.7338;
  long int D.7339;
  char D.7340;
  long unsigned int D.7344;
  long int D.7345;
  long unsigned int D.7346;
  long int D.7347;
  register struct oh * ohdr;

  ohdr = GC_base (p);
  clobbered_addr.7 = (long int) clobbered_addr;
  p.8 = (long int) p;
  GC_err_printf ("0x%lx in object at 0x%lx(", clobbered_addr.7, p.8, 0, 0, 0, 0);
  D.7331 = &ohdr->oh_sz;
  if (D.7331 >= clobbered_addr) goto <D.7328>; else goto <D.7332>;
  <D.7332>:
  D.7333 = ohdr->oh_string;
  if (D.7333 == 0B) goto <D.7328>; else goto <D.7329>;
  <D.7328>:
  D.7334 = GC_size (ohdr);
  GC_all_interior_pointers.9 = GC_all_interior_pointers;
  GC_all_interior_pointers.10 = (unsigned int) GC_all_interior_pointers.9;
  D.7337 = D.7334 + GC_all_interior_pointers.10;
  D.7338 = D.7337 + 4294967276;
  D.7339 = (long int) D.7338;
  GC_err_printf ("<smashed>, appr. sz = %ld)\n", D.7339, 0, 0, 0, 0, 0);
  goto <D.7330>;
  <D.7329>:
  D.7333 = ohdr->oh_string;
  D.7340 = *D.7333;
  if (D.7340 == 0) goto <D.7341>; else goto <D.7342>;
  <D.7341>:
  GC_err_puts ("EMPTY(smashed?)");
  goto <D.7343>;
  <D.7342>:
  D.7333 = ohdr->oh_string;
  GC_err_puts (D.7333);
  <D.7343>:
  D.7344 = ohdr->oh_int;
  D.7345 = (long int) D.7344;
  D.7346 = ohdr->oh_sz;
  D.7347 = (long int) D.7346;
  GC_err_printf (":%ld, sz=%ld)\n", D.7345, D.7347, 0, 0, 0, 0);
  <D.7330>:
}


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 (16);
}


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

  GC_register_displacement (offset);
  D.7348 = offset + 16;
  GC_register_displacement (D.7348);
}


GC_debug_malloc (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.11;
  unsigned int GC_all_interior_pointers.12;
  unsigned int D.7351;
  unsigned int D.7352;
  long int lb.13;
  void * D.7356;
  int GC_debugging_started.14;
  long unsigned int i.15;
  void * result;

  GC_all_interior_pointers.11 = GC_all_interior_pointers;
  GC_all_interior_pointers.12 = (unsigned int) GC_all_interior_pointers.11;
  D.7351 = lb - GC_all_interior_pointers.12;
  D.7352 = D.7351 + 20;
  result = GC_malloc (D.7352);
  if (result == 0B) goto <D.7353>; else goto <D.7354>;
  <D.7353>:
  lb.13 = (long int) lb;
  GC_err_printf ("GC_debug_malloc(%ld) returning NIL (", lb.13, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  GC_err_printf (":%ld)\n", i, 0, 0, 0, 0, 0);
  D.7356 = 0B;
  return D.7356;
  <D.7354>:
  GC_debugging_started.14 = GC_debugging_started;
  if (GC_debugging_started.14 == 0) goto <D.7358>; else goto <D.7359>;
  <D.7358>:
  GC_start_debugging ();
  <D.7359>:
  i.15 = (long unsigned int) i;
  D.7356 = GC_store_debug_info (result, lb, s, i.15);
  return D.7356;
}


GC_debug_malloc_ignore_off_page (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.16;
  unsigned int GC_all_interior_pointers.17;
  unsigned int D.7364;
  unsigned int D.7365;
  long int lb.18;
  void * D.7369;
  int GC_debugging_started.19;
  long unsigned int i.20;
  void * result;

  GC_all_interior_pointers.16 = GC_all_interior_pointers;
  GC_all_interior_pointers.17 = (unsigned int) GC_all_interior_pointers.16;
  D.7364 = lb - GC_all_interior_pointers.17;
  D.7365 = D.7364 + 20;
  result = GC_malloc_ignore_off_page (D.7365);
  if (result == 0B) goto <D.7366>; else goto <D.7367>;
  <D.7366>:
  lb.18 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_ignore_off_page(%ld) returning NIL (", lb.18, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  GC_err_printf (":%ld)\n", i, 0, 0, 0, 0, 0);
  D.7369 = 0B;
  return D.7369;
  <D.7367>:
  GC_debugging_started.19 = GC_debugging_started;
  if (GC_debugging_started.19 == 0) goto <D.7371>; else goto <D.7372>;
  <D.7371>:
  GC_start_debugging ();
  <D.7372>:
  i.20 = (long unsigned int) i;
  D.7369 = GC_store_debug_info (result, lb, s, i.20);
  return D.7369;
}


GC_debug_malloc_atomic_ignore_off_page (size_t lb, const char * s, int i)
{
  int GC_all_interior_pointers.21;
  unsigned int GC_all_interior_pointers.22;
  unsigned int D.7377;
  unsigned int D.7378;
  long int lb.23;
  void * D.7382;
  int GC_debugging_started.24;
  long unsigned int i.25;
  void * result;

  GC_all_interior_pointers.21 = GC_all_interior_pointers;
  GC_all_interior_pointers.22 = (unsigned int) GC_all_interior_pointers.21;
  D.7377 = lb - GC_all_interior_pointers.22;
  D.7378 = D.7377 + 20;
  result = GC_malloc_atomic_ignore_off_page (D.7378);
  if (result == 0B) goto <D.7379>; else goto <D.7380>;
  <D.7379>:
  lb.23 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_atomic_ignore_off_page(%ld) returning NIL (", lb.23, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  GC_err_printf (":%ld)\n", i, 0, 0, 0, 0, 0);
  D.7382 = 0B;
  return D.7382;
  <D.7380>:
  GC_debugging_started.24 = GC_debugging_started;
  if (GC_debugging_started.24 == 0) goto <D.7384>; else goto <D.7385>;
  <D.7384>:
  GC_start_debugging ();
  <D.7385>:
  i.25 = (long unsigned int) i;
  D.7382 = GC_store_debug_info (result, lb, s, i.25);
  return D.7382;
}


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

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


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.26;
  unsigned int GC_all_interior_pointers.27;
  unsigned int D.7392;
  unsigned int D.7393;
  long int lb.28;
  void * D.7397;
  int GC_debugging_started.29;
  long unsigned int i.30;
  void * result;

  GC_all_interior_pointers.26 = GC_all_interior_pointers;
  GC_all_interior_pointers.27 = (unsigned int) GC_all_interior_pointers.26;
  D.7392 = lb - GC_all_interior_pointers.27;
  D.7393 = D.7392 + 20;
  result = GC_malloc_atomic (D.7393);
  if (result == 0B) goto <D.7394>; else goto <D.7395>;
  <D.7394>:
  lb.28 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_atomic(%ld) returning NIL (", lb.28, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  GC_err_printf (":%ld)\n", i, 0, 0, 0, 0, 0);
  D.7397 = 0B;
  return D.7397;
  <D.7395>:
  GC_debugging_started.29 = GC_debugging_started;
  if (GC_debugging_started.29 == 0) goto <D.7399>; else goto <D.7400>;
  <D.7399>:
  GC_start_debugging ();
  <D.7400>:
  i.30 = (long unsigned int) i;
  D.7397 = GC_store_debug_info (result, lb, s, i.30);
  return D.7397;
}


GC_debug_malloc_uncollectable (size_t lb, const char * s, int i)
{
  unsigned int D.7403;
  long int lb.31;
  void * D.7407;
  int GC_debugging_started.32;
  long unsigned int i.33;
  void * result;

  D.7403 = lb + 20;
  result = GC_malloc_uncollectable (D.7403);
  if (result == 0B) goto <D.7404>; else goto <D.7405>;
  <D.7404>:
  lb.31 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_uncollectable(%ld) returning NIL (", lb.31, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  GC_err_printf (":%ld)\n", i, 0, 0, 0, 0, 0);
  D.7407 = 0B;
  return D.7407;
  <D.7405>:
  GC_debugging_started.32 = GC_debugging_started;
  if (GC_debugging_started.32 == 0) goto <D.7409>; else goto <D.7410>;
  <D.7409>:
  GC_start_debugging ();
  <D.7410>:
  i.33 = (long unsigned int) i;
  D.7407 = GC_store_debug_info (result, lb, s, i.33);
  return D.7407;
}


GC_debug_malloc_atomic_uncollectable (size_t lb, const char * s, int i)
{
  unsigned int D.7413;
  long int lb.34;
  void * D.7417;
  int GC_debugging_started.35;
  long unsigned int i.36;
  void * result;

  D.7413 = lb + 20;
  result = GC_malloc_atomic_uncollectable (D.7413);
  if (result == 0B) goto <D.7414>; else goto <D.7415>;
  <D.7414>:
  lb.34 = (long int) lb;
  GC_err_printf ("GC_debug_malloc_atomic_uncollectable(%ld) returning NIL (", lb.34, 0, 0, 0, 0, 0);
  GC_err_puts (s);
  GC_err_printf (":%ld)\n", i, 0, 0, 0, 0, 0);
  D.7417 = 0B;
  return D.7417;
  <D.7415>:
  GC_debugging_started.35 = GC_debugging_started;
  if (GC_debugging_started.35 == 0) goto <D.7419>; else goto <D.7420>;
  <D.7419>:
  GC_start_debugging ();
  <D.7420>:
  i.36 = (long unsigned int) i;
  D.7417 = GC_store_debug_info (result, lb, s, i.36);
  return D.7417;
}


GC_debug_free (void * p)
{
  long int p.37;
  int p.38;
  int base.39;
  int D.7430;
  long unsigned int D.7436;
  unsigned int D.7437;
  unsigned int D.7441;
  int GC_find_leak.40;
  long unsigned int p.41;
  long unsigned int D.7447;
  struct bottom_index * D.7448;
  long unsigned int D.7449;
  long unsigned int D.7450;
  unsigned char D.7451;
  long unsigned int D.7459;
  unsigned int D.7460;
  word * D.7461;
  register void * base;
  register char * clobbered;

  if (p == 0B) goto <D.7423>; else goto <D.7424>;
  <D.7423>:
  return;
  <D.7424>:
  base = GC_base (p);
  if (base == 0B) goto <D.7425>; else goto <D.7426>;
  <D.7425>:
  p.37 = (long int) p;
  GC_err_printf ("Attempt to free invalid pointer %lx\n", p.37, 0, 0, 0, 0, 0);
  GC_abort ("free(invalid pointer)");
  <D.7426>:
  p.38 = (int) p;
  base.39 = (int) base;
  D.7430 = p.38 - base.39;
  if (D.7430 != 16) goto <D.7431>; else goto <D.7432>;
  <D.7431>:
  p.37 = (long int) p;
  GC_err_printf ("GC_debug_free called on pointer %lx wo debugging info\n", p.37, 0, 0, 0, 0, 0);
  goto <D.7433>;
  <D.7432>:
  clobbered = GC_check_annotated_obj (base);
  if (clobbered != 0B) goto <D.7434>; else goto <D.7435>;
  <D.7434>:
  D.7436 = MEM[(struct oh *)base].oh_sz;
  D.7437 = GC_size (base);
  if (D.7436 == D.7437) goto <D.7438>; else goto <D.7439>;
  <D.7438>:
  GC_err_puts ("GC_debug_free: found previously deallocated (?) object at ");
  goto <D.7440>;
  <D.7439>:
  GC_err_puts ("GC_debug_free: found smashed location at ");
  <D.7440>:
  GC_print_smashed_obj (p, clobbered);
  <D.7435>:
  D.7441 = GC_size (base);
  MEM[(struct oh *)base].oh_sz = D.7441;
  <D.7433>:
  GC_find_leak.40 = GC_find_leak;
  if (GC_find_leak.40 != 0) goto <D.7443>; else goto <D.7444>;
  <D.7443>:
  GC_free (base);
  goto <D.7445>;
  <D.7444>:
  {
    register struct hdr * hhdr;
    GC_bool uncollectable;

    p.41 = (long unsigned int) p;
    D.7447 = p.41 >> 22;
    D.7448 = GC_arrays._top_index[D.7447];
    p.41 = (long unsigned int) p;
    D.7449 = p.41 >> 12;
    D.7450 = D.7449 & 1023;
    hhdr = D.7448->index[D.7450];
    uncollectable = 0;
    D.7451 = hhdr->hb_obj_kind;
    if (D.7451 == 2) goto <D.7452>; else goto <D.7453>;
    <D.7452>:
    uncollectable = 1;
    <D.7453>:
    D.7451 = hhdr->hb_obj_kind;
    if (D.7451 == 3) goto <D.7454>; else goto <D.7455>;
    <D.7454>:
    uncollectable = 1;
    <D.7455>:
    if (uncollectable != 0) goto <D.7456>; else goto <D.7457>;
    <D.7456>:
    GC_free (base);
    goto <D.7458>;
    <D.7457>:
    {
      size_t i;
      size_t obj_sz;

      D.7459 = hhdr->hb_sz;
      obj_sz = D.7459 + 4294967292;
      i = 0;
      goto <D.7119>;
      <D.7118>:
      D.7460 = i * 4;
      D.7461 = p + D.7460;
      *D.7461 = 3735928559;
      i = i + 1;
      <D.7119>:
      if (i < obj_sz) goto <D.7118>; else goto <D.7120>;
      <D.7120>:
    }
    <D.7458>:
  }
  <D.7445>:
}


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

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


GC_debug_realloc (void * p, size_t lb, const char * s, int i)
{
  void * D.7466;
  long int p.42;
  int p.43;
  int base.44;
  int D.7472;
  long unsigned int base.45;
  long unsigned int D.7476;
  struct bottom_index * D.7477;
  long unsigned int D.7478;
  long unsigned int D.7479;
  unsigned char D.7480;
  int D.7481;
  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.7464>; else goto <D.7465>;
  <D.7464>:
  D.7466 = GC_debug_malloc (lb, s, i);
  return D.7466;
  <D.7465>:
  if (base == 0B) goto <D.7467>; else goto <D.7468>;
  <D.7467>:
  p.42 = (long int) p;
  GC_err_printf ("Attempt to reallocate invalid pointer %lx\n", p.42, 0, 0, 0, 0, 0);
  GC_abort ("realloc(invalid pointer)");
  <D.7468>:
  p.43 = (int) p;
  base.44 = (int) base;
  D.7472 = p.43 - base.44;
  if (D.7472 != 16) goto <D.7473>; else goto <D.7474>;
  <D.7473>:
  p.42 = (long int) p;
  GC_err_printf ("GC_debug_realloc called on pointer %lx wo debugging info\n", p.42, 0, 0, 0, 0, 0);
  D.7466 = GC_realloc (p, lb);
  return D.7466;
  <D.7474>:
  base.45 = (long unsigned int) base;
  D.7476 = base.45 >> 22;
  D.7477 = GC_arrays._top_index[D.7476];
  base.45 = (long unsigned int) base;
  D.7478 = base.45 >> 12;
  D.7479 = D.7478 & 1023;
  hhdr = D.7477->index[D.7479];
  D.7480 = hhdr->hb_obj_kind;
  D.7481 = (int) D.7480;
  switch (D.7481) <default: <D.7143>, case 0: <D.7140>, case 1: <D.7138>, case 2: <D.7141>, case 3: <D.7142>>
  <D.7138>:
  result = GC_debug_malloc (lb, s, i);
  goto <D.7139>;
  <D.7140>:
  result = GC_debug_malloc_atomic (lb, s, i);
  goto <D.7139>;
  <D.7141>:
  result = GC_debug_malloc_uncollectable (lb, s, i);
  goto <D.7139>;
  <D.7142>:
  result = GC_debug_malloc_atomic_uncollectable (lb, s, i);
  goto <D.7139>;
  <D.7143>:
  GC_err_puts ("GC_debug_realloc: encountered bad kind\n");
  GC_abort ("bad kind");
  <D.7139>:
  clobbered = GC_check_annotated_obj (base);
  if (clobbered != 0B) goto <D.7482>; else goto <D.7483>;
  <D.7482>:
  GC_err_puts ("GC_debug_realloc: found smashed location at ");
  GC_print_smashed_obj (p, clobbered);
  <D.7483>:
  old_sz = MEM[(struct oh *)base].oh_sz;
  if (old_sz < copy_sz) goto <D.7484>; else goto <D.7485>;
  <D.7484>:
  copy_sz = old_sz;
  <D.7485>:
  if (result == 0B) goto <D.7486>; else goto <D.7487>;
  <D.7486>:
  D.7466 = 0B;
  return D.7466;
  <D.7487>:
  memcpy (result, p, copy_sz);
  GC_debug_free (p);
  D.7466 = result;
  return D.7466;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.7489;
  unsigned int D.7490;

  D.7490 = __builtin_object_size (__dest, 0);
  D.7489 = __builtin___memcpy_chk (__dest, __src, __len, D.7490);
  return D.7489;
}


GC_add_smashed (char * smashed)
{
  unsigned int GC_n_smashed.46;
  unsigned int GC_n_smashed.47;

  GC_n_smashed.46 = GC_n_smashed;
  GC_smashed[GC_n_smashed.46] = smashed;
  GC_n_smashed.46 = GC_n_smashed;
  if (GC_n_smashed.46 <= 18) goto <D.7493>; else goto <D.7494>;
  <D.7493>:
  GC_n_smashed.46 = GC_n_smashed;
  GC_n_smashed.47 = GC_n_smashed.46 + 1;
  GC_n_smashed = GC_n_smashed.47;
  <D.7494>:
  GC_have_errors = 1;
}


GC_print_all_smashed_proc ()
{
  unsigned int GC_n_smashed.48;
  char * D.7499;
  void * D.7500;
  unsigned int i;

  GC_n_smashed.48 = GC_n_smashed;
  if (GC_n_smashed.48 == 0) goto <D.7497>; else goto <D.7498>;
  <D.7497>:
  return;
  <D.7498>:
  GC_err_puts ("GC_check_heap_block: found smashed heap objects:\n");
  i = 0;
  goto <D.7153>;
  <D.7152>:
  D.7499 = GC_smashed[i];
  D.7500 = GC_base (D.7499);
  D.7499 = GC_smashed[i];
  GC_print_smashed_obj (D.7500, D.7499);
  GC_smashed[i] = 0B;
  i = i + 1;
  <D.7153>:
  GC_n_smashed.48 = GC_n_smashed;
  if (i < GC_n_smashed.48) goto <D.7152>; else goto <D.7154>;
  <D.7154>:
  GC_n_smashed = 0;
}


GC_check_heap_block (struct hblk * hbp, word dummy)
{
  long unsigned int hbp.49;
  long unsigned int D.7503;
  struct bottom_index * D.7504;
  long unsigned int D.7505;
  long unsigned int D.7506;
  long unsigned int D.7510;
  long unsigned int D.7511;
  long unsigned int D.7512;
  int D.7513;
  long unsigned int D.7514;
  int D.7515;
  long unsigned int D.7516;
  long unsigned int D.7517;
  int D.7520;
  long unsigned int word_no.50;
  long unsigned int D.7526;
  long unsigned int D.7527;
  register struct hblkhdr * hhdr;
  register word sz;
  register int word_no;
  register word * p;
  register word * plim;

  hbp.49 = (long unsigned int) hbp;
  D.7503 = hbp.49 >> 22;
  D.7504 = GC_arrays._top_index[D.7503];
  hbp.49 = (long unsigned int) hbp;
  D.7505 = hbp.49 >> 12;
  D.7506 = D.7505 & 1023;
  hhdr = D.7504->index[D.7506];
  sz = hhdr->hb_sz;
  p = &hbp->hb_body;
  word_no = 0;
  if (sz > 512) goto <D.7507>; else goto <D.7508>;
  <D.7507>:
  plim = p;
  goto <D.7509>;
  <D.7508>:
  hbp.49 = (long unsigned int) hbp;
  D.7510 = sz << 2;
  D.7511 = hbp.49 - D.7510;
  D.7512 = D.7511 + 4096;
  plim = (word *) D.7512;
  <D.7509>:
  goto <D.7166>;
  <D.7165>:
  D.7513 = word_no >> 5;
  D.7514 = hhdr->hb_marks[D.7513];
  D.7515 = word_no & 31;
  D.7516 = D.7514 >> D.7515;
  D.7517 = D.7516 & 1;
  if (D.7517 != 0) goto <D.7518>; else goto <D.7519>;
  <D.7518>:
  D.7520 = GC_has_other_debug_info (p);
  if (D.7520 != 0) goto <D.7521>; else goto <D.7522>;
  <D.7521>:
  {
    char * clobbered;

    clobbered = GC_check_annotated_obj (p);
    if (clobbered != 0B) goto <D.7523>; else goto <D.7524>;
    <D.7523>:
    GC_add_smashed (clobbered);
    <D.7524>:
  }
  <D.7522>:
  <D.7519>:
  word_no.50 = (long unsigned int) word_no;
  D.7526 = word_no.50 + sz;
  word_no = (int) D.7526;
  D.7527 = sz * 4;
  p = p + D.7527;
  <D.7166>:
  if (p <= plim) goto <D.7165>; else goto <D.7167>;
  <D.7167>:
}


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

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


GC_debug_invoke_finalizer (void * obj, void * data)
{
  void (*<Tdb2>) (void *, void *) D.7530;
  void * D.7531;
  void * D.7532;
  register struct closure * cl;

  cl = data;
  D.7530 = cl->cl_fn;
  D.7531 = obj + 16;
  D.7532 = cl->cl_data;
  D.7530 (D.7531, D.7532);
}


GC_debug_register_finalizer (void * obj, void (*GC_finalization_proc) (void *, void *) fn, void * cd, void (*GC_finalization_proc) (void *, void *) * ofn, void * * ocd)
{
  int obj.51;
  int base.52;
  int D.7537;
  long int obj.53;
  void * D.7544;
  void (*<Tdb2>) (void *, void *) my_old_fn.54;
  void * my_old_cd.55;
  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.7533>; else goto <D.7534>;
      <D.7533>:
      return;
      <D.7534>:
      obj.51 = (int) obj;
      base.52 = (int) base;
      D.7537 = obj.51 - base.52;
      if (D.7537 != 16) goto <D.7538>; else goto <D.7539>;
      <D.7538>:
      obj.53 = (long int) obj;
      GC_err_printf ("GC_debug_register_finalizer called with non-base-pointer 0x%lx\n", obj.53, 0, 0, 0, 0, 0);
      <D.7539>:
      if (fn == 0B) goto <D.7541>; else goto <D.7542>;
      <D.7541>:
      GC_register_finalizer (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.7543>;
      <D.7542>:
      D.7544 = GC_make_closure (fn, cd);
      GC_register_finalizer (base, GC_debug_invoke_finalizer, D.7544, &my_old_fn, &my_old_cd);
      <D.7543>:
      my_old_fn.54 = my_old_fn;
      my_old_cd.55 = my_old_cd;
      store_old (obj, my_old_fn.54, my_old_cd.55, 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.56;
  void (*<Tdb2>) (void *, void *) D.7558;
  void * D.7561;

  if (my_old_fn != 0B) goto <D.7550>; else goto <D.7551>;
  <D.7550>:
  if (my_old_fn != GC_debug_invoke_finalizer) goto <D.7552>; else goto <D.7553>;
  <D.7552>:
  obj.56 = (long int) obj;
  GC_err_printf ("Debuggable object at 0x%lx had non-debug finalizer.\n", obj.56, 0, 0, 0, 0, 0);
  goto <D.7555>;
  <D.7553>:
  if (ofn != 0B) goto <D.7556>; else goto <D.7557>;
  <D.7556>:
  D.7558 = my_old_cd->cl_fn;
  *ofn = D.7558;
  <D.7557>:
  if (ocd != 0B) goto <D.7559>; else goto <D.7560>;
  <D.7559>:
  D.7561 = my_old_cd->cl_data;
  *ocd = D.7561;
  <D.7560>:
  <D.7555>:
  goto <D.7562>;
  <D.7551>:
  if (ofn != 0B) goto <D.7563>; else goto <D.7564>;
  <D.7563>:
  *ofn = 0B;
  <D.7564>:
  if (ocd != 0B) goto <D.7565>; else goto <D.7566>;
  <D.7565>:
  *ocd = 0B;
  <D.7566>:
  <D.7562>:
}


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)
{
  int obj.57;
  int base.58;
  int D.7571;
  long int obj.59;
  void * D.7578;
  void (*<Tdb2>) (void *, void *) my_old_fn.60;
  void * my_old_cd.61;
  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.7567>; else goto <D.7568>;
      <D.7567>:
      return;
      <D.7568>:
      obj.57 = (int) obj;
      base.58 = (int) base;
      D.7571 = obj.57 - base.58;
      if (D.7571 != 16) goto <D.7572>; else goto <D.7573>;
      <D.7572>:
      obj.59 = (long int) obj;
      GC_err_printf ("GC_debug_register_finalizer_no_order called with non-base-pointer 0x%lx\n", obj.59, 0, 0, 0, 0, 0);
      <D.7573>:
      if (fn == 0B) goto <D.7575>; else goto <D.7576>;
      <D.7575>:
      GC_register_finalizer_no_order (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.7577>;
      <D.7576>:
      D.7578 = GC_make_closure (fn, cd);
      GC_register_finalizer_no_order (base, GC_debug_invoke_finalizer, D.7578, &my_old_fn, &my_old_cd);
      <D.7577>:
      my_old_fn.60 = my_old_fn;
      my_old_cd.61 = my_old_cd;
      store_old (obj, my_old_fn.60, my_old_cd.61, 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)
{
  int obj.62;
  int base.63;
  int D.7588;
  long int obj.64;
  void * D.7595;
  void (*<Tdb2>) (void *, void *) my_old_fn.65;
  void * my_old_cd.66;
  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.7584>; else goto <D.7585>;
      <D.7584>:
      return;
      <D.7585>:
      obj.62 = (int) obj;
      base.63 = (int) base;
      D.7588 = obj.62 - base.63;
      if (D.7588 != 16) goto <D.7589>; else goto <D.7590>;
      <D.7589>:
      obj.64 = (long int) obj;
      GC_err_printf ("GC_debug_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n", obj.64, 0, 0, 0, 0, 0);
      <D.7590>:
      if (fn == 0B) goto <D.7592>; else goto <D.7593>;
      <D.7592>:
      GC_register_finalizer_ignore_self (base, 0B, 0B, &my_old_fn, &my_old_cd);
      goto <D.7594>;
      <D.7593>:
      D.7595 = GC_make_closure (fn, cd);
      GC_register_finalizer_ignore_self (base, GC_debug_invoke_finalizer, D.7595, &my_old_fn, &my_old_cd);
      <D.7594>:
      my_old_fn.65 = my_old_fn;
      my_old_cd.66 = my_old_cd;
      store_old (obj, my_old_fn.65, my_old_cd.66, ofn, ocd);
    }
  finally
    {
      my_old_fn = {CLOBBER};
      my_old_cd = {CLOBBER};
    }
}


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

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


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

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