GC_add_leaked (char * leaked)
{
  unsigned int GC_n_leaked.0;
  unsigned int GC_n_leaked.1;
  unsigned int GC_n_leaked.2;

  GC_n_leaked.0 = GC_n_leaked;
  if (GC_n_leaked.0 <= 39) goto <D.6325>; else goto <D.6326>;
  <D.6325>:
  GC_have_errors = 1;
  GC_n_leaked.0 = GC_n_leaked;
  GC_n_leaked.1 = GC_n_leaked.0;
  GC_n_leaked.2 = GC_n_leaked.1 + 1;
  GC_n_leaked = GC_n_leaked.2;
  GC_leaked[GC_n_leaked.1] = leaked;
  GC_set_mark_bit (leaked);
  <D.6326>:
}


GC_print_all_errors ()
{
  int D.6329;
  int printing_errors.3;
  int GC_debugging_started.4;
  void (*<T714>) (void) GC_print_all_smashed.5;
  struct hdr * D.6339;
  unsigned char D.6340;
  void (*<T10e0>) (char *) GC_print_heap_obj.6;
  unsigned int GC_n_leaked.7;
  unsigned int i;

  D.6329 = GC_test_and_set (&GC_allocate_lock);
  if (D.6329 != 0) goto <D.6330>; else goto <D.6331>;
  <D.6330>:
  GC_lock ();
  <D.6331>:
  printing_errors.3 = printing_errors;
  if (printing_errors.3 != 0) goto <D.6333>; else goto <D.6334>;
  <D.6333>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.6334>:
  printing_errors = 1;
  GC_clear (&GC_allocate_lock);
  GC_debugging_started.4 = GC_debugging_started;
  if (GC_debugging_started.4 != 0) goto <D.6336>; else goto <D.6337>;
  <D.6336>:
  GC_print_all_smashed.5 = GC_print_all_smashed;
  GC_print_all_smashed.5 ();
  <D.6337>:
  i = 0;
  goto <D.6043>;
  <D.6042>:
  {
    char * p;

    p = GC_leaked[i];
    D.6339 = GC_find_header (p);
    D.6340 = D.6339->hb_obj_kind;
    if (D.6340 == 0) goto <D.6341>; else goto <D.6342>;
    <D.6341>:
    GC_err_puts ("Leaked atomic object at ");
    goto <D.6343>;
    <D.6342>:
    GC_err_puts ("Leaked composite object at ");
    <D.6343>:
    GC_print_heap_obj.6 = GC_print_heap_obj;
    GC_print_heap_obj.6 (p);
    GC_err_puts ("\n");
    GC_free (p);
    GC_leaked[i] = 0B;
  }
  i = i + 1;
  <D.6043>:
  GC_n_leaked.7 = GC_n_leaked;
  if (i < GC_n_leaked.7) goto <D.6042>; else goto <D.6044>;
  <D.6044>:
  GC_n_leaked = 0;
  printing_errors = 0;
}


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

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


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


GC_block_empty (struct hdr * hhdr)
{
  word * p.8;
  long unsigned int D.6350;
  GC_bool D.6353;
  register word * p;
  register word * plim;

  p = &hhdr->hb_marks[0];
  plim = &hhdr->hb_marks[8];
  goto <D.6051>;
  <D.6050>:
  p.8 = p;
  p = p.8 + 8;
  D.6350 = *p.8;
  if (D.6350 != 0) goto <D.6351>; else goto <D.6352>;
  <D.6351>:
  D.6353 = 0;
  return D.6353;
  <D.6352>:
  <D.6051>:
  if (p < plim) goto <D.6050>; else goto <D.6052>;
  <D.6052>:
  D.6353 = 1;
  return D.6353;
}


GC_block_nearly_full1 (struct hdr * hhdr, word pat1)
{
  long unsigned int D.6355;
  long unsigned int D.6356;
  long unsigned int D.6357;
  GC_bool D.6362;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  i = 0;
  goto <D.6060>;
  <D.6059>:
  D.6355 = hhdr->hb_marks[i];
  D.6356 = ~pat1;
  D.6357 = D.6355 | D.6356;
  if (D.6357 != 18446744073709551615) goto <D.6358>; else goto <D.6359>;
  <D.6358>:
  misses = misses + 1;
  if (misses != 0) goto <D.6360>; else goto <D.6361>;
  <D.6360>:
  D.6362 = 0;
  return D.6362;
  <D.6361>:
  <D.6359>:
  i = i + 1;
  <D.6060>:
  if (i <= 7) goto <D.6059>; else goto <D.6061>;
  <D.6061>:
  D.6362 = 1;
  return D.6362;
}


GC_block_nearly_full3 (struct hdr * hhdr, word pat1, word pat2, word pat3)
{
  GC_bool D.6366;
  long unsigned int D.6367;
  long unsigned int D.6368;
  long unsigned int D.6369;
  unsigned int D.6374;
  long unsigned int D.6375;
  long unsigned int D.6376;
  long unsigned int D.6377;
  unsigned int D.6382;
  long unsigned int D.6383;
  long unsigned int D.6384;
  long unsigned int D.6385;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  if (0 != 0) goto <D.6364>; else goto <D.6365>;
  <D.6364>:
  D.6366 = 2;
  return D.6366;
  <D.6365>:
  i = 0;
  goto <D.6071>;
  <D.6070>:
  D.6367 = hhdr->hb_marks[i];
  D.6368 = ~pat1;
  D.6369 = D.6367 | D.6368;
  if (D.6369 != 18446744073709551615) goto <D.6370>; else goto <D.6371>;
  <D.6370>:
  misses = misses + 1;
  if (misses != 0) goto <D.6372>; else goto <D.6373>;
  <D.6372>:
  D.6366 = 0;
  return D.6366;
  <D.6373>:
  <D.6371>:
  D.6374 = i + 1;
  D.6375 = hhdr->hb_marks[D.6374];
  D.6376 = ~pat2;
  D.6377 = D.6375 | D.6376;
  if (D.6377 != 18446744073709551615) goto <D.6378>; else goto <D.6379>;
  <D.6378>:
  misses = misses + 1;
  if (misses != 0) goto <D.6380>; else goto <D.6381>;
  <D.6380>:
  D.6366 = 0;
  return D.6366;
  <D.6381>:
  <D.6379>:
  D.6382 = i + 2;
  D.6383 = hhdr->hb_marks[D.6382];
  D.6384 = ~pat3;
  D.6385 = D.6383 | D.6384;
  if (D.6385 != 18446744073709551615) goto <D.6386>; else goto <D.6387>;
  <D.6386>:
  misses = misses + 1;
  if (misses != 0) goto <D.6388>; else goto <D.6389>;
  <D.6388>:
  D.6366 = 0;
  return D.6366;
  <D.6389>:
  <D.6387>:
  i = i + 3;
  <D.6071>:
  if (i <= 5) goto <D.6070>; else goto <D.6072>;
  <D.6072>:
  D.6366 = 1;
  return D.6366;
}


GC_block_nearly_full (struct hdr * hhdr)
{
  long unsigned int D.6391;
  GC_bool D.6392;
  int sz;

  D.6391 = hhdr->hb_sz;
  sz = (int) D.6391;
  switch (sz) <default: <D.6085>, case 1: <D.6077>, case 2: <D.6078>, case 4: <D.6079>, case 6: <D.6080>, case 8: <D.6081>, case 12: <D.6082>, case 16: <D.6083>, case 32: <D.6084>>
  <D.6077>:
  D.6392 = GC_block_nearly_full1 (hhdr, 18446744073709551615);
  return D.6392;
  <D.6078>:
  D.6392 = GC_block_nearly_full1 (hhdr, 6148914691236517205);
  return D.6392;
  <D.6079>:
  D.6392 = GC_block_nearly_full1 (hhdr, 1229782938247303441);
  return D.6392;
  <D.6080>:
  D.6392 = GC_block_nearly_full3 (hhdr, 1171221845949812801, 4684887383799251204, 292805461487453200);
  return D.6392;
  <D.6081>:
  D.6392 = GC_block_nearly_full1 (hhdr, 72340172838076673);
  return D.6392;
  <D.6082>:
  D.6392 = GC_block_nearly_full3 (hhdr, 1153203048319815681, 72075190519988480, 4504699407499280);
  return D.6392;
  <D.6083>:
  D.6392 = GC_block_nearly_full1 (hhdr, 281479271743489);
  return D.6392;
  <D.6084>:
  D.6392 = GC_block_nearly_full1 (hhdr, 4294967297);
  return D.6392;
  <D.6085>:
  D.6392 = 2;
  return D.6392;
}


GC_reclaim_clear (struct hblk * hbp, struct hdr * hhdr, word sz, char * list)
{
  long unsigned int hbp.9;
  long unsigned int D.6395;
  long unsigned int D.6396;
  long unsigned int D.6397;
  int D.6398;
  long unsigned int D.6399;
  int D.6400;
  long unsigned int D.6401;
  long unsigned int D.6402;
  long unsigned int D.6405;
  word * p.10;
  unsigned int D.6408;
  unsigned int word_no.11;
  unsigned int D.6410;
  char * D.6411;
  register int word_no;
  register word * p;
  register word * q;
  register word * plim;

  p = &hbp->hb_body;
  word_no = 0;
  hbp.9 = (long unsigned int) hbp;
  D.6395 = sz << 3;
  D.6396 = hbp.9 - D.6395;
  D.6397 = D.6396 + 4096;
  plim = (word *) D.6397;
  goto <D.6100>;
  <D.6099>:
  D.6398 = word_no >> 6;
  D.6399 = hhdr->hb_marks[D.6398];
  D.6400 = word_no & 63;
  D.6401 = D.6399 >> D.6400;
  D.6402 = D.6401 & 1;
  if (D.6402 != 0) goto <D.6403>; else goto <D.6404>;
  <D.6403>:
  D.6405 = sz * 8;
  p = p + D.6405;
  goto <D.6406>;
  <D.6404>:
  MEM[(char * *)p] = list;
  list = p;
  D.6405 = sz * 8;
  q = p + D.6405;
  p = p + 8;
  goto <D.6097>;
  <D.6096>:
  p.10 = p;
  p = p.10 + 8;
  *p.10 = 0;
  <D.6097>:
  if (p < q) goto <D.6096>; else goto <D.6098>;
  <D.6098>:
  <D.6406>:
  D.6408 = (unsigned int) sz;
  word_no.11 = (unsigned int) word_no;
  D.6410 = D.6408 + word_no.11;
  word_no = (int) D.6410;
  <D.6100>:
  if (p <= plim) goto <D.6099>; else goto <D.6101>;
  <D.6101>:
  D.6411 = list;
  return D.6411;
}


GC_reclaim_clear2 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.12;
  long unsigned int D.6414;
  word * mark_word_addr.13;
  long unsigned int D.6416;
  long unsigned int list.14;
  word * D.6420;
  long unsigned int D.6421;
  word * D.6424;
  word * D.6425;
  long unsigned int D.6426;
  word * D.6429;
  word * D.6430;
  long unsigned int D.6431;
  word * D.6434;
  word * D.6435;
  unsigned int i.15;
  char * D.6437;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.12 = (long unsigned int) hbp;
  D.6414 = hbp.12 + 4096;
  plim = (word *) D.6414;
  goto <D.6116>;
  <D.6115>:
  mark_word_addr.13 = mark_word_addr;
  mark_word_addr = mark_word_addr.13 + 8;
  mark_word = *mark_word_addr.13;
  i = 0;
  goto <D.6113>;
  <D.6112>:
  D.6416 = mark_word & 1;
  if (D.6416 == 0) goto <D.6417>; else goto <D.6418>;
  <D.6417>:
  list.14 = (long unsigned int) list;
  *p = list.14;
  list = p;
  D.6420 = p + 8;
  *D.6420 = 0;
  <D.6418>:
  D.6421 = mark_word & 4;
  if (D.6421 == 0) goto <D.6422>; else goto <D.6423>;
  <D.6422>:
  D.6424 = p + 16;
  list.14 = (long unsigned int) list;
  *D.6424 = list.14;
  list = p + 16;
  D.6425 = p + 24;
  *D.6425 = 0;
  <D.6423>:
  D.6426 = mark_word & 16;
  if (D.6426 == 0) goto <D.6427>; else goto <D.6428>;
  <D.6427>:
  D.6429 = p + 32;
  list.14 = (long unsigned int) list;
  *D.6429 = list.14;
  list = p + 32;
  D.6430 = p + 40;
  *D.6430 = 0;
  <D.6428>:
  D.6431 = mark_word & 64;
  if (D.6431 == 0) goto <D.6432>; else goto <D.6433>;
  <D.6432>:
  D.6434 = p + 48;
  list.14 = (long unsigned int) list;
  *D.6434 = list.14;
  list = p + 48;
  D.6435 = p + 56;
  *D.6435 = 0;
  <D.6433>:
  p = p + 64;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.6113>:
  i.15 = (unsigned int) i;
  if (i.15 <= 63) goto <D.6112>; else goto <D.6114>;
  <D.6114>:
  <D.6116>:
  if (p < plim) goto <D.6115>; else goto <D.6117>;
  <D.6117>:
  D.6437 = list;
  return D.6437;
}


GC_reclaim_clear4 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.16;
  long unsigned int D.6440;
  word * mark_word_addr.17;
  long unsigned int D.6442;
  long unsigned int list.18;
  word * D.6446;
  word * D.6447;
  word * D.6448;
  long unsigned int D.6449;
  word * D.6452;
  word * D.6453;
  word * D.6454;
  word * D.6455;
  long unsigned int D.6456;
  word * D.6459;
  word * D.6460;
  word * D.6461;
  word * D.6462;
  long unsigned int D.6463;
  word * D.6466;
  word * D.6467;
  word * D.6468;
  word * D.6469;
  long unsigned int D.6470;
  word * D.6473;
  word * D.6474;
  word * D.6475;
  word * D.6476;
  long unsigned int D.6477;
  word * D.6480;
  word * D.6481;
  word * D.6482;
  word * D.6483;
  long unsigned int D.6484;
  word * D.6487;
  word * D.6488;
  word * D.6489;
  word * D.6490;
  long unsigned int D.6491;
  word * D.6494;
  word * D.6495;
  word * D.6496;
  word * D.6497;
  long unsigned int D.6498;
  word * D.6501;
  word * D.6502;
  word * D.6503;
  word * D.6504;
  long unsigned int D.6505;
  word * D.6508;
  word * D.6509;
  word * D.6510;
  word * D.6511;
  long unsigned int D.6512;
  word * D.6515;
  word * D.6516;
  word * D.6517;
  word * D.6518;
  long unsigned int D.6519;
  word * D.6522;
  word * D.6523;
  word * D.6524;
  word * D.6525;
  long unsigned int D.6526;
  word * D.6529;
  word * D.6530;
  word * D.6531;
  word * D.6532;
  long unsigned int D.6533;
  word * D.6536;
  word * D.6537;
  word * D.6538;
  word * D.6539;
  long unsigned int D.6540;
  word * D.6543;
  word * D.6544;
  word * D.6545;
  word * D.6546;
  long unsigned int D.6547;
  word * D.6550;
  word * D.6551;
  word * D.6552;
  word * D.6553;
  char * D.6554;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.16 = (long unsigned int) hbp;
  D.6440 = hbp.16 + 4096;
  plim = (word *) D.6440;
  goto <D.6128>;
  <D.6127>:
  mark_word_addr.17 = mark_word_addr;
  mark_word_addr = mark_word_addr.17 + 8;
  mark_word = *mark_word_addr.17;
  D.6442 = mark_word & 1;
  if (D.6442 == 0) goto <D.6443>; else goto <D.6444>;
  <D.6443>:
  list.18 = (long unsigned int) list;
  *p = list.18;
  list = p;
  D.6446 = p + 8;
  *D.6446 = 0;
  D.6447 = p + 16;
  *D.6447 = 0;
  D.6448 = p + 24;
  *D.6448 = 0;
  <D.6444>:
  D.6449 = mark_word & 16;
  if (D.6449 == 0) goto <D.6450>; else goto <D.6451>;
  <D.6450>:
  D.6452 = p + 32;
  list.18 = (long unsigned int) list;
  *D.6452 = list.18;
  list = p + 32;
  D.6453 = p + 40;
  *D.6453 = 0;
  D.6454 = p + 48;
  *D.6454 = 0;
  D.6455 = p + 56;
  *D.6455 = 0;
  <D.6451>:
  D.6456 = mark_word & 256;
  if (D.6456 == 0) goto <D.6457>; else goto <D.6458>;
  <D.6457>:
  D.6459 = p + 64;
  list.18 = (long unsigned int) list;
  *D.6459 = list.18;
  list = p + 64;
  D.6460 = p + 72;
  *D.6460 = 0;
  D.6461 = p + 80;
  *D.6461 = 0;
  D.6462 = p + 88;
  *D.6462 = 0;
  <D.6458>:
  D.6463 = mark_word & 4096;
  if (D.6463 == 0) goto <D.6464>; else goto <D.6465>;
  <D.6464>:
  D.6466 = p + 96;
  list.18 = (long unsigned int) list;
  *D.6466 = list.18;
  list = p + 96;
  D.6467 = p + 104;
  *D.6467 = 0;
  D.6468 = p + 112;
  *D.6468 = 0;
  D.6469 = p + 120;
  *D.6469 = 0;
  <D.6465>:
  D.6470 = mark_word & 65536;
  if (D.6470 == 0) goto <D.6471>; else goto <D.6472>;
  <D.6471>:
  D.6473 = p + 128;
  list.18 = (long unsigned int) list;
  *D.6473 = list.18;
  list = p + 128;
  D.6474 = p + 136;
  *D.6474 = 0;
  D.6475 = p + 144;
  *D.6475 = 0;
  D.6476 = p + 152;
  *D.6476 = 0;
  <D.6472>:
  D.6477 = mark_word & 1048576;
  if (D.6477 == 0) goto <D.6478>; else goto <D.6479>;
  <D.6478>:
  D.6480 = p + 160;
  list.18 = (long unsigned int) list;
  *D.6480 = list.18;
  list = p + 160;
  D.6481 = p + 168;
  *D.6481 = 0;
  D.6482 = p + 176;
  *D.6482 = 0;
  D.6483 = p + 184;
  *D.6483 = 0;
  <D.6479>:
  D.6484 = mark_word & 16777216;
  if (D.6484 == 0) goto <D.6485>; else goto <D.6486>;
  <D.6485>:
  D.6487 = p + 192;
  list.18 = (long unsigned int) list;
  *D.6487 = list.18;
  list = p + 192;
  D.6488 = p + 200;
  *D.6488 = 0;
  D.6489 = p + 208;
  *D.6489 = 0;
  D.6490 = p + 216;
  *D.6490 = 0;
  <D.6486>:
  D.6491 = mark_word & 268435456;
  if (D.6491 == 0) goto <D.6492>; else goto <D.6493>;
  <D.6492>:
  D.6494 = p + 224;
  list.18 = (long unsigned int) list;
  *D.6494 = list.18;
  list = p + 224;
  D.6495 = p + 232;
  *D.6495 = 0;
  D.6496 = p + 240;
  *D.6496 = 0;
  D.6497 = p + 248;
  *D.6497 = 0;
  <D.6493>:
  D.6498 = mark_word & 4294967296;
  if (D.6498 == 0) goto <D.6499>; else goto <D.6500>;
  <D.6499>:
  D.6501 = p + 256;
  list.18 = (long unsigned int) list;
  *D.6501 = list.18;
  list = p + 256;
  D.6502 = p + 264;
  *D.6502 = 0;
  D.6503 = p + 272;
  *D.6503 = 0;
  D.6504 = p + 280;
  *D.6504 = 0;
  <D.6500>:
  D.6505 = mark_word & 68719476736;
  if (D.6505 == 0) goto <D.6506>; else goto <D.6507>;
  <D.6506>:
  D.6508 = p + 288;
  list.18 = (long unsigned int) list;
  *D.6508 = list.18;
  list = p + 288;
  D.6509 = p + 296;
  *D.6509 = 0;
  D.6510 = p + 304;
  *D.6510 = 0;
  D.6511 = p + 312;
  *D.6511 = 0;
  <D.6507>:
  D.6512 = mark_word & 1099511627776;
  if (D.6512 == 0) goto <D.6513>; else goto <D.6514>;
  <D.6513>:
  D.6515 = p + 320;
  list.18 = (long unsigned int) list;
  *D.6515 = list.18;
  list = p + 320;
  D.6516 = p + 328;
  *D.6516 = 0;
  D.6517 = p + 336;
  *D.6517 = 0;
  D.6518 = p + 344;
  *D.6518 = 0;
  <D.6514>:
  D.6519 = mark_word & 17592186044416;
  if (D.6519 == 0) goto <D.6520>; else goto <D.6521>;
  <D.6520>:
  D.6522 = p + 352;
  list.18 = (long unsigned int) list;
  *D.6522 = list.18;
  list = p + 352;
  D.6523 = p + 360;
  *D.6523 = 0;
  D.6524 = p + 368;
  *D.6524 = 0;
  D.6525 = p + 376;
  *D.6525 = 0;
  <D.6521>:
  D.6526 = mark_word & 281474976710656;
  if (D.6526 == 0) goto <D.6527>; else goto <D.6528>;
  <D.6527>:
  D.6529 = p + 384;
  list.18 = (long unsigned int) list;
  *D.6529 = list.18;
  list = p + 384;
  D.6530 = p + 392;
  *D.6530 = 0;
  D.6531 = p + 400;
  *D.6531 = 0;
  D.6532 = p + 408;
  *D.6532 = 0;
  <D.6528>:
  D.6533 = mark_word & 4503599627370496;
  if (D.6533 == 0) goto <D.6534>; else goto <D.6535>;
  <D.6534>:
  D.6536 = p + 416;
  list.18 = (long unsigned int) list;
  *D.6536 = list.18;
  list = p + 416;
  D.6537 = p + 424;
  *D.6537 = 0;
  D.6538 = p + 432;
  *D.6538 = 0;
  D.6539 = p + 440;
  *D.6539 = 0;
  <D.6535>:
  D.6540 = mark_word & 72057594037927936;
  if (D.6540 == 0) goto <D.6541>; else goto <D.6542>;
  <D.6541>:
  D.6543 = p + 448;
  list.18 = (long unsigned int) list;
  *D.6543 = list.18;
  list = p + 448;
  D.6544 = p + 456;
  *D.6544 = 0;
  D.6545 = p + 464;
  *D.6545 = 0;
  D.6546 = p + 472;
  *D.6546 = 0;
  <D.6542>:
  D.6547 = mark_word & 1152921504606846976;
  if (D.6547 == 0) goto <D.6548>; else goto <D.6549>;
  <D.6548>:
  D.6550 = p + 480;
  list.18 = (long unsigned int) list;
  *D.6550 = list.18;
  list = p + 480;
  D.6551 = p + 488;
  *D.6551 = 0;
  D.6552 = p + 496;
  *D.6552 = 0;
  D.6553 = p + 504;
  *D.6553 = 0;
  <D.6549>:
  p = p + 512;
  <D.6128>:
  if (p < plim) goto <D.6127>; else goto <D.6129>;
  <D.6129>:
  D.6554 = list;
  return D.6554;
}


GC_reclaim_uninit (struct hblk * hbp, struct hdr * hhdr, word sz, char * list)
{
  long unsigned int hbp.19;
  long unsigned int D.6557;
  long unsigned int D.6558;
  long unsigned int D.6559;
  int D.6560;
  long unsigned int D.6561;
  int D.6562;
  long unsigned int D.6563;
  long unsigned int D.6564;
  long unsigned int D.6567;
  unsigned int D.6568;
  unsigned int word_no.20;
  unsigned int D.6570;
  char * D.6571;
  register int word_no;
  register word * p;
  register word * plim;

  word_no = 0;
  p = &hbp->hb_body;
  hbp.19 = (long unsigned int) hbp;
  D.6557 = sz << 3;
  D.6558 = hbp.19 - D.6557;
  D.6559 = D.6558 + 4096;
  plim = (word *) D.6559;
  goto <D.6140>;
  <D.6139>:
  D.6560 = word_no >> 6;
  D.6561 = hhdr->hb_marks[D.6560];
  D.6562 = word_no & 63;
  D.6563 = D.6561 >> D.6562;
  D.6564 = D.6563 & 1;
  if (D.6564 == 0) goto <D.6565>; else goto <D.6566>;
  <D.6565>:
  MEM[(char * *)p] = list;
  list = p;
  <D.6566>:
  D.6567 = sz * 8;
  p = p + D.6567;
  D.6568 = (unsigned int) sz;
  word_no.20 = (unsigned int) word_no;
  D.6570 = D.6568 + word_no.20;
  word_no = (int) D.6570;
  <D.6140>:
  if (p <= plim) goto <D.6139>; else goto <D.6141>;
  <D.6141>:
  D.6571 = list;
  return D.6571;
}


GC_reclaim_check (struct hblk * hbp, struct hdr * hhdr, word sz)
{
  long unsigned int hbp.21;
  long unsigned int D.6574;
  long unsigned int D.6575;
  long unsigned int D.6576;
  int D.6577;
  long unsigned int D.6578;
  int D.6579;
  long unsigned int D.6580;
  long unsigned int D.6581;
  int D.6584;
  sizetype D.6585;
  char * D.6586;
  long unsigned int D.6587;
  unsigned int D.6588;
  unsigned int word_no.22;
  unsigned int D.6590;
  register int word_no;
  register word * p;
  register word * plim;

  word_no = 0;
  p = &hbp->hb_body;
  hbp.21 = (long unsigned int) hbp;
  D.6574 = sz << 3;
  D.6575 = hbp.21 - D.6574;
  D.6576 = D.6575 + 4096;
  plim = (word *) D.6576;
  goto <D.6151>;
  <D.6150>:
  D.6577 = word_no >> 6;
  D.6578 = hhdr->hb_marks[D.6577];
  D.6579 = word_no & 63;
  D.6580 = D.6578 >> D.6579;
  D.6581 = D.6580 & 1;
  if (D.6581 == 0) goto <D.6582>; else goto <D.6583>;
  <D.6582>:
  D.6584 = word_no << 3;
  D.6585 = (sizetype) D.6584;
  D.6586 = hbp + D.6585;
  GC_add_leaked (D.6586);
  <D.6583>:
  D.6587 = sz * 8;
  p = p + D.6587;
  D.6588 = (unsigned int) sz;
  word_no.22 = (unsigned int) word_no;
  D.6590 = D.6588 + word_no.22;
  word_no = (int) D.6590;
  <D.6151>:
  if (p <= plim) goto <D.6150>; else goto <D.6152>;
  <D.6152>:
}


GC_reclaim_uninit2 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.23;
  long unsigned int D.6592;
  word * mark_word_addr.24;
  long unsigned int D.6594;
  long unsigned int list.25;
  long unsigned int D.6598;
  word * D.6601;
  long unsigned int D.6602;
  word * D.6605;
  long unsigned int D.6606;
  word * D.6609;
  unsigned int i.26;
  char * D.6611;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.23 = (long unsigned int) hbp;
  D.6592 = hbp.23 + 4096;
  plim = (word *) D.6592;
  goto <D.6167>;
  <D.6166>:
  mark_word_addr.24 = mark_word_addr;
  mark_word_addr = mark_word_addr.24 + 8;
  mark_word = *mark_word_addr.24;
  i = 0;
  goto <D.6164>;
  <D.6163>:
  D.6594 = mark_word & 1;
  if (D.6594 == 0) goto <D.6595>; else goto <D.6596>;
  <D.6595>:
  list.25 = (long unsigned int) list;
  *p = list.25;
  list = p;
  <D.6596>:
  D.6598 = mark_word & 4;
  if (D.6598 == 0) goto <D.6599>; else goto <D.6600>;
  <D.6599>:
  D.6601 = p + 16;
  list.25 = (long unsigned int) list;
  *D.6601 = list.25;
  list = p + 16;
  <D.6600>:
  D.6602 = mark_word & 16;
  if (D.6602 == 0) goto <D.6603>; else goto <D.6604>;
  <D.6603>:
  D.6605 = p + 32;
  list.25 = (long unsigned int) list;
  *D.6605 = list.25;
  list = p + 32;
  <D.6604>:
  D.6606 = mark_word & 64;
  if (D.6606 == 0) goto <D.6607>; else goto <D.6608>;
  <D.6607>:
  D.6609 = p + 48;
  list.25 = (long unsigned int) list;
  *D.6609 = list.25;
  list = p + 48;
  <D.6608>:
  p = p + 64;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.6164>:
  i.26 = (unsigned int) i;
  if (i.26 <= 63) goto <D.6163>; else goto <D.6165>;
  <D.6165>:
  <D.6167>:
  if (p < plim) goto <D.6166>; else goto <D.6168>;
  <D.6168>:
  D.6611 = list;
  return D.6611;
}


GC_reclaim_uninit4 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.27;
  long unsigned int D.6614;
  word * mark_word_addr.28;
  long unsigned int D.6616;
  long unsigned int list.29;
  long unsigned int D.6620;
  word * D.6623;
  long unsigned int D.6624;
  word * D.6627;
  long unsigned int D.6628;
  word * D.6631;
  long unsigned int D.6632;
  word * D.6635;
  long unsigned int D.6636;
  word * D.6639;
  long unsigned int D.6640;
  word * D.6643;
  long unsigned int D.6644;
  word * D.6647;
  long unsigned int D.6648;
  word * D.6651;
  long unsigned int D.6652;
  word * D.6655;
  long unsigned int D.6656;
  word * D.6659;
  long unsigned int D.6660;
  word * D.6663;
  long unsigned int D.6664;
  word * D.6667;
  long unsigned int D.6668;
  word * D.6671;
  long unsigned int D.6672;
  word * D.6675;
  long unsigned int D.6676;
  word * D.6679;
  char * D.6680;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.27 = (long unsigned int) hbp;
  D.6614 = hbp.27 + 4096;
  plim = (word *) D.6614;
  goto <D.6179>;
  <D.6178>:
  mark_word_addr.28 = mark_word_addr;
  mark_word_addr = mark_word_addr.28 + 8;
  mark_word = *mark_word_addr.28;
  D.6616 = mark_word & 1;
  if (D.6616 == 0) goto <D.6617>; else goto <D.6618>;
  <D.6617>:
  list.29 = (long unsigned int) list;
  *p = list.29;
  list = p;
  <D.6618>:
  D.6620 = mark_word & 16;
  if (D.6620 == 0) goto <D.6621>; else goto <D.6622>;
  <D.6621>:
  D.6623 = p + 32;
  list.29 = (long unsigned int) list;
  *D.6623 = list.29;
  list = p + 32;
  <D.6622>:
  D.6624 = mark_word & 256;
  if (D.6624 == 0) goto <D.6625>; else goto <D.6626>;
  <D.6625>:
  D.6627 = p + 64;
  list.29 = (long unsigned int) list;
  *D.6627 = list.29;
  list = p + 64;
  <D.6626>:
  D.6628 = mark_word & 4096;
  if (D.6628 == 0) goto <D.6629>; else goto <D.6630>;
  <D.6629>:
  D.6631 = p + 96;
  list.29 = (long unsigned int) list;
  *D.6631 = list.29;
  list = p + 96;
  <D.6630>:
  D.6632 = mark_word & 65536;
  if (D.6632 == 0) goto <D.6633>; else goto <D.6634>;
  <D.6633>:
  D.6635 = p + 128;
  list.29 = (long unsigned int) list;
  *D.6635 = list.29;
  list = p + 128;
  <D.6634>:
  D.6636 = mark_word & 1048576;
  if (D.6636 == 0) goto <D.6637>; else goto <D.6638>;
  <D.6637>:
  D.6639 = p + 160;
  list.29 = (long unsigned int) list;
  *D.6639 = list.29;
  list = p + 160;
  <D.6638>:
  D.6640 = mark_word & 16777216;
  if (D.6640 == 0) goto <D.6641>; else goto <D.6642>;
  <D.6641>:
  D.6643 = p + 192;
  list.29 = (long unsigned int) list;
  *D.6643 = list.29;
  list = p + 192;
  <D.6642>:
  D.6644 = mark_word & 268435456;
  if (D.6644 == 0) goto <D.6645>; else goto <D.6646>;
  <D.6645>:
  D.6647 = p + 224;
  list.29 = (long unsigned int) list;
  *D.6647 = list.29;
  list = p + 224;
  <D.6646>:
  D.6648 = mark_word & 4294967296;
  if (D.6648 == 0) goto <D.6649>; else goto <D.6650>;
  <D.6649>:
  D.6651 = p + 256;
  list.29 = (long unsigned int) list;
  *D.6651 = list.29;
  list = p + 256;
  <D.6650>:
  D.6652 = mark_word & 68719476736;
  if (D.6652 == 0) goto <D.6653>; else goto <D.6654>;
  <D.6653>:
  D.6655 = p + 288;
  list.29 = (long unsigned int) list;
  *D.6655 = list.29;
  list = p + 288;
  <D.6654>:
  D.6656 = mark_word & 1099511627776;
  if (D.6656 == 0) goto <D.6657>; else goto <D.6658>;
  <D.6657>:
  D.6659 = p + 320;
  list.29 = (long unsigned int) list;
  *D.6659 = list.29;
  list = p + 320;
  <D.6658>:
  D.6660 = mark_word & 17592186044416;
  if (D.6660 == 0) goto <D.6661>; else goto <D.6662>;
  <D.6661>:
  D.6663 = p + 352;
  list.29 = (long unsigned int) list;
  *D.6663 = list.29;
  list = p + 352;
  <D.6662>:
  D.6664 = mark_word & 281474976710656;
  if (D.6664 == 0) goto <D.6665>; else goto <D.6666>;
  <D.6665>:
  D.6667 = p + 384;
  list.29 = (long unsigned int) list;
  *D.6667 = list.29;
  list = p + 384;
  <D.6666>:
  D.6668 = mark_word & 4503599627370496;
  if (D.6668 == 0) goto <D.6669>; else goto <D.6670>;
  <D.6669>:
  D.6671 = p + 416;
  list.29 = (long unsigned int) list;
  *D.6671 = list.29;
  list = p + 416;
  <D.6670>:
  D.6672 = mark_word & 72057594037927936;
  if (D.6672 == 0) goto <D.6673>; else goto <D.6674>;
  <D.6673>:
  D.6675 = p + 448;
  list.29 = (long unsigned int) list;
  *D.6675 = list.29;
  list = p + 448;
  <D.6674>:
  D.6676 = mark_word & 1152921504606846976;
  if (D.6676 == 0) goto <D.6677>; else goto <D.6678>;
  <D.6677>:
  D.6679 = p + 480;
  list.29 = (long unsigned int) list;
  *D.6679 = list.29;
  list = p + 480;
  <D.6678>:
  p = p + 512;
  <D.6179>:
  if (p < plim) goto <D.6178>; else goto <D.6180>;
  <D.6180>:
  D.6680 = list;
  return D.6680;
}


GC_reclaim1 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.30;
  long unsigned int D.6683;
  word * mark_word_addr.31;
  long unsigned int D.6685;
  long unsigned int list.32;
  long unsigned int D.6689;
  word * D.6692;
  long unsigned int D.6693;
  word * D.6696;
  long unsigned int D.6697;
  word * D.6700;
  unsigned int i.33;
  char * D.6702;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.30 = (long unsigned int) hbp;
  D.6683 = hbp.30 + 4096;
  plim = (word *) D.6683;
  goto <D.6195>;
  <D.6194>:
  mark_word_addr.31 = mark_word_addr;
  mark_word_addr = mark_word_addr.31 + 8;
  mark_word = *mark_word_addr.31;
  i = 0;
  goto <D.6192>;
  <D.6191>:
  D.6685 = mark_word & 1;
  if (D.6685 == 0) goto <D.6686>; else goto <D.6687>;
  <D.6686>:
  list.32 = (long unsigned int) list;
  *p = list.32;
  list = p;
  <D.6687>:
  D.6689 = mark_word & 2;
  if (D.6689 == 0) goto <D.6690>; else goto <D.6691>;
  <D.6690>:
  D.6692 = p + 8;
  list.32 = (long unsigned int) list;
  *D.6692 = list.32;
  list = p + 8;
  <D.6691>:
  D.6693 = mark_word & 4;
  if (D.6693 == 0) goto <D.6694>; else goto <D.6695>;
  <D.6694>:
  D.6696 = p + 16;
  list.32 = (long unsigned int) list;
  *D.6696 = list.32;
  list = p + 16;
  <D.6695>:
  D.6697 = mark_word & 8;
  if (D.6697 == 0) goto <D.6698>; else goto <D.6699>;
  <D.6698>:
  D.6700 = p + 24;
  list.32 = (long unsigned int) list;
  *D.6700 = list.32;
  list = p + 24;
  <D.6699>:
  p = p + 32;
  mark_word = mark_word >> 4;
  i = i + 4;
  <D.6192>:
  i.33 = (unsigned int) i;
  if (i.33 <= 63) goto <D.6191>; else goto <D.6193>;
  <D.6193>:
  <D.6195>:
  if (p < plim) goto <D.6194>; else goto <D.6196>;
  <D.6196>:
  D.6702 = list;
  return D.6702;
}


GC_reclaim_generic (struct hblk * hbp, struct hdr * hhdr, word sz, GC_bool init, char * list)
{
  long unsigned int D.6704;
  _Bool D.6705;
  int D.6706;
  unsigned char D.6710;
  int D.6711;
  int D.6712;
  char * D.6715;
  char * result;

  result = list;
  D.6704 = hhdr->hb_descr;
  D.6705 = D.6704 == 0;
  D.6706 = (int) D.6705;
  GC_remove_protection (hbp, 1, D.6706);
  if (init != 0) goto <D.6707>; else goto <D.6708>;
  <D.6707>:
  switch (sz) <default: <D.6209>, case 1: <D.6205>, case 2: <D.6207>, case 4: <D.6208>>
  <D.6205>:
  result = GC_reclaim1 (hbp, hhdr, list);
  goto <D.6206>;
  <D.6207>:
  result = GC_reclaim_clear2 (hbp, hhdr, list);
  goto <D.6206>;
  <D.6208>:
  result = GC_reclaim_clear4 (hbp, hhdr, list);
  goto <D.6206>;
  <D.6209>:
  result = GC_reclaim_clear (hbp, hhdr, sz, list);
  goto <D.6206>;
  <D.6206>:
  goto <D.6709>;
  <D.6708>:
  switch (sz) <default: <D.6214>, case 1: <D.6210>, case 2: <D.6212>, case 4: <D.6213>>
  <D.6210>:
  result = GC_reclaim1 (hbp, hhdr, list);
  goto <D.6211>;
  <D.6212>:
  result = GC_reclaim_uninit2 (hbp, hhdr, list);
  goto <D.6211>;
  <D.6213>:
  result = GC_reclaim_uninit4 (hbp, hhdr, list);
  goto <D.6211>;
  <D.6214>:
  result = GC_reclaim_uninit (hbp, hhdr, sz, list);
  goto <D.6211>;
  <D.6211>:
  <D.6709>:
  D.6710 = hhdr->hb_obj_kind;
  D.6711 = (int) D.6710;
  D.6712 = D.6711 & -2;
  if (D.6712 == 2) goto <D.6713>; else goto <D.6714>;
  <D.6713>:
  GC_set_hdr_marks (hhdr);
  <D.6714>:
  D.6715 = result;
  return D.6715;
}


GC_reclaim_small_nonempty_block (struct hblk * hbp, int report_if_found)
{
  unsigned char D.6717;
  char * * D.6718;
  long unsigned int D.6719;
  long unsigned int GC_gc_no.34;
  short unsigned int D.6721;
  int iftmp.35;
  int D.6729;
  int GC_debugging_started.36;
  char * D.6732;
  char * D.6733;
  struct hdr * hhdr;
  word sz;
  int kind;
  struct obj_kind * ok;
  char * * flh;

  hhdr = GC_find_header (hbp);
  sz = hhdr->hb_sz;
  D.6717 = hhdr->hb_obj_kind;
  kind = (int) D.6717;
  ok = &GC_obj_kinds[kind];
  D.6718 = ok->ok_freelist;
  D.6719 = sz * 8;
  flh = D.6718 + D.6719;
  GC_gc_no.34 = GC_gc_no;
  D.6721 = (short unsigned int) GC_gc_no.34;
  hhdr->hb_last_reclaimed = D.6721;
  if (report_if_found != 0) goto <D.6722>; else goto <D.6723>;
  <D.6722>:
  GC_reclaim_check (hbp, hhdr, sz);
  goto <D.6724>;
  <D.6723>:
  D.6729 = ok->ok_init;
  if (D.6729 != 0) goto <D.6726>; else goto <D.6730>;
  <D.6730>:
  GC_debugging_started.36 = GC_debugging_started;
  if (GC_debugging_started.36 != 0) goto <D.6726>; else goto <D.6727>;
  <D.6726>:
  iftmp.35 = 1;
  goto <D.6728>;
  <D.6727>:
  iftmp.35 = 0;
  <D.6728>:
  D.6732 = *flh;
  D.6733 = GC_reclaim_generic (hbp, hhdr, sz, iftmp.35, D.6732);
  *flh = D.6733;
  <D.6724>:
}


GC_reclaim_block (struct hblk * hbp, word report_if_found)
{
  unsigned char D.6734;
  int D.6735;
  long unsigned int D.6738;
  long unsigned int D.6739;
  long unsigned int D.6745;
  long unsigned int D.6746;
  long unsigned int D.6749;
  long unsigned int D.6750;
  long unsigned int D.6751;
  int D.6755;
  int D.6760;
  struct hblk * * D.6763;
  long unsigned int D.6764;
  struct hblk * D.6765;
  register struct hdr * hhdr;
  register word sz;
  register struct obj_kind * ok;
  struct hblk * * rlh;

  hhdr = GC_find_header (hbp);
  sz = hhdr->hb_sz;
  D.6734 = hhdr->hb_obj_kind;
  D.6735 = (int) D.6734;
  ok = &GC_obj_kinds[D.6735];
  if (sz > 256) goto <D.6736>; else goto <D.6737>;
  <D.6736>:
  D.6738 = hhdr->hb_marks[0];
  D.6739 = D.6738 & 1;
  if (D.6739 == 0) goto <D.6740>; else goto <D.6741>;
  <D.6740>:
  if (report_if_found != 0) goto <D.6742>; else goto <D.6743>;
  <D.6742>:
  GC_add_leaked (hbp);
  goto <D.6744>;
  <D.6743>:
  {
    word blocks;

    D.6745 = sz << 3;
    D.6746 = D.6745 + 4095;
    blocks = D.6746 >> 12;
    if (blocks > 1) goto <D.6747>; else goto <D.6748>;
    <D.6747>:
    D.6749 = GC_arrays._large_allocd_bytes;
    D.6750 = blocks * 4096;
    D.6751 = D.6749 - D.6750;
    GC_arrays._large_allocd_bytes = D.6751;
    <D.6748>:
    GC_freehblk (hbp);
  }
  <D.6744>:
  <D.6741>:
  goto <D.6752>;
  <D.6737>:
  {
    GC_bool empty;

    empty = GC_block_empty (hhdr);
    if (report_if_found != 0) goto <D.6753>; else goto <D.6754>;
    <D.6753>:
    D.6755 = (int) report_if_found;
    GC_reclaim_small_nonempty_block (hbp, D.6755);
    goto <D.6756>;
    <D.6754>:
    if (empty != 0) goto <D.6757>; else goto <D.6758>;
    <D.6757>:
    GC_freehblk (hbp);
    goto <D.6759>;
    <D.6758>:
    D.6760 = GC_block_nearly_full (hhdr);
    if (D.6760 != 1) goto <D.6761>; else goto <D.6762>;
    <D.6761>:
    D.6763 = ok->ok_reclaim_list;
    D.6764 = sz * 8;
    rlh = D.6763 + D.6764;
    D.6765 = *rlh;
    hhdr->hb_next = D.6765;
    *rlh = hbp;
    <D.6762>:
    <D.6759>:
    <D.6756>:
  }
  <D.6752>:
}


GC_n_set_marks (struct hdr * hhdr)
{
  long unsigned int D.6766;
  int D.6767;
  int D.6768;
  register int result;
  register int i;

  result = 0;
  i = 0;
  goto <D.6251>;
  <D.6250>:
  D.6766 = hhdr->hb_marks[i];
  D.6767 = set_bits (D.6766);
  result = D.6767 + result;
  i = i + 1;
  <D.6251>:
  if (i <= 7) goto <D.6250>; else goto <D.6252>;
  <D.6252>:
  D.6768 = result;
  return D.6768;
}


set_bits (word n)
{
  long unsigned int D.6770;
  int D.6773;
  register word m;
  register int result;

  m = n;
  result = 0;
  goto <D.6243>;
  <D.6242>:
  D.6770 = m & 1;
  if (D.6770 != 0) goto <D.6771>; else goto <D.6772>;
  <D.6771>:
  result = result + 1;
  <D.6772>:
  m = m >> 1;
  <D.6243>:
  if (m != 0) goto <D.6242>; else goto <D.6244>;
  <D.6244>:
  D.6773 = result;
  return D.6773;
}


GC_print_block_descr (struct hblk * h, word dummy)
{
  long unsigned int D.6775;
  unsigned char D.6776;
  long int D.6777;
  long int bytes.37;
  int D.6779;
  long int D.6780;
  long unsigned int D.6781;
  long unsigned int D.6782;
  long unsigned int D.6783;
  long unsigned int D.6784;
  register struct hdr * hhdr;
  register size_t bytes;
  struct Print_stats * ps;

  hhdr = GC_find_header (h);
  D.6775 = hhdr->hb_sz;
  bytes = D.6775 << 3;
  D.6776 = hhdr->hb_obj_kind;
  D.6777 = (long int) D.6776;
  bytes.37 = (long int) bytes;
  D.6779 = GC_n_set_marks (hhdr);
  D.6780 = (long int) D.6779;
  GC_printf ("(%lu:%lu,%lu)", D.6777, bytes.37, D.6780, 0, 0, 0);
  bytes = bytes + 4095;
  bytes = bytes & 18446744073709547520;
  ps = (struct Print_stats *) dummy;
  D.6781 = ps->total_bytes;
  D.6782 = D.6781 + bytes;
  ps->total_bytes = D.6782;
  D.6783 = ps->number_of_blocks;
  D.6784 = D.6783 + 1;
  ps->number_of_blocks = D.6784;
}


GC_print_block_list ()
{
  long unsigned int pstats.38;
  long unsigned int D.6786;
  long int D.6787;
  long unsigned int D.6788;
  long int D.6789;
  struct Print_stats pstats;

  try
    {
      GC_printf ("(kind(0=ptrfree,1=normal,2=unc.,%lu=stubborn):size_in_bytes, #_marks_set)\n", 4, 0, 0, 0, 0, 0);
      pstats.number_of_blocks = 0;
      pstats.total_bytes = 0;
      pstats.38 = (long unsigned int) &pstats;
      GC_apply_to_all_blocks (GC_print_block_descr, pstats.38);
      D.6786 = pstats.number_of_blocks;
      D.6787 = (long int) D.6786;
      D.6788 = pstats.total_bytes;
      D.6789 = (long int) D.6788;
      GC_printf ("\nblocks = %lu, bytes = %lu\n", D.6787, D.6789, 0, 0, 0, 0);
    }
  finally
    {
      pstats = {CLOBBER};
    }
}


GC_clear_fl_links (char * * flp)
{
  char * next;

  next = *flp;
  goto <D.6268>;
  <D.6267>:
  *flp = 0B;
  flp = next;
  next = *flp;
  <D.6268>:
  if (next != 0B) goto <D.6267>; else goto <D.6269>;
  <D.6269>:
}


GC_start_reclaim (int report_if_found)
{
  long unsigned int D.6790;
  _Bool D.6791;
  char * * D.6796;
  char * D.6797;
  int GC_n_kinds.39;
  long unsigned int D.6804;
  int kind;

  kind = 0;
  goto <D.6288>;
  <D.6287>:
  {
    char * * fop;
    char * * lim;
    struct hblk * * rlp;
    struct hblk * * rlim;
    struct hblk * * rlist;
    GC_bool should_clobber;

    rlist = GC_obj_kinds[kind].ok_reclaim_list;
    D.6790 = GC_obj_kinds[kind].ok_descriptor;
    D.6791 = D.6790 != 0;
    should_clobber = (GC_bool) D.6791;
    if (rlist == 0B) goto <D.6792>; else goto <D.6793>;
    <D.6792>:
    // predicted unlikely by continue predictor.
    goto <D.6280>;
    <D.6793>:
    if (report_if_found == 0) goto <D.6794>; else goto <D.6795>;
    <D.6794>:
    D.6796 = GC_obj_kinds[kind].ok_freelist;
    lim = D.6796 + 2056;
    fop = GC_obj_kinds[kind].ok_freelist;
    goto <D.6282>;
    <D.6281>:
    D.6797 = *fop;
    if (D.6797 != 0B) goto <D.6798>; else goto <D.6799>;
    <D.6798>:
    if (should_clobber != 0) goto <D.6800>; else goto <D.6801>;
    <D.6800>:
    GC_clear_fl_links (fop);
    goto <D.6802>;
    <D.6801>:
    *fop = 0B;
    <D.6802>:
    <D.6799>:
    fop = fop + 8;
    <D.6282>:
    if (fop < lim) goto <D.6281>; else goto <D.6283>;
    <D.6283>:
    <D.6795>:
    rlim = rlist + 2056;
    rlp = rlist;
    goto <D.6285>;
    <D.6284>:
    *rlp = 0B;
    rlp = rlp + 8;
    <D.6285>:
    if (rlp < rlim) goto <D.6284>; else goto <D.6286>;
    <D.6286>:
  }
  <D.6280>:
  kind = kind + 1;
  <D.6288>:
  GC_n_kinds.39 = GC_n_kinds;
  if (kind < GC_n_kinds.39) goto <D.6287>; else goto <D.6289>;
  <D.6289>:
  D.6804 = (long unsigned int) report_if_found;
  GC_apply_to_all_blocks (GC_reclaim_block, D.6804);
}


GC_continue_reclaim (word sz, int kind)
{
  char * * D.6805;
  long unsigned int D.6806;
  struct hblk * D.6809;
  char * D.6810;
  register struct hdr * hhdr;
  register struct hblk * hbp;
  register struct obj_kind * ok;
  struct hblk * * rlh;
  char * * flh;

  ok = &GC_obj_kinds[kind];
  rlh = ok->ok_reclaim_list;
  D.6805 = ok->ok_freelist;
  D.6806 = sz * 8;
  flh = D.6805 + D.6806;
  if (rlh == 0B) goto <D.6807>; else goto <D.6808>;
  <D.6807>:
  return;
  <D.6808>:
  D.6806 = sz * 8;
  rlh = rlh + D.6806;
  goto <D.6301>;
  <D.6300>:
  hhdr = GC_find_header (hbp);
  D.6809 = hhdr->hb_next;
  *rlh = D.6809;
  GC_reclaim_small_nonempty_block (hbp, 0);
  D.6810 = *flh;
  if (D.6810 != 0B) goto <D.6299>; else goto <D.6811>;
  <D.6811>:
  <D.6301>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.6300>; else goto <D.6299>;
  <D.6299>:
}


GC_reclaim_all (int (*GC_stop_func) (void) stop_func, GC_bool ignore_old)
{
  long unsigned int D.6815;
  int D.6818;
  GC_bool D.6821;
  struct hblk * D.6822;
  short unsigned int D.6826;
  long unsigned int D.6827;
  long unsigned int GC_gc_no.40;
  long unsigned int D.6829;
  int GC_n_kinds.41;
  register word sz;
  register int kind;
  register struct hdr * hhdr;
  register struct hblk * hbp;
  register struct obj_kind * ok;
  struct hblk * * rlp;
  struct hblk * * rlh;

  kind = 0;
  goto <D.6321>;
  <D.6320>:
  ok = &GC_obj_kinds[kind];
  rlp = ok->ok_reclaim_list;
  if (rlp == 0B) goto <D.6813>; else goto <D.6814>;
  <D.6813>:
  // predicted unlikely by continue predictor.
  goto <D.6313>;
  <D.6814>:
  sz = 1;
  goto <D.6318>;
  <D.6317>:
  D.6815 = sz * 8;
  rlh = rlp + D.6815;
  goto <D.6315>;
  <D.6314>:
  if (stop_func != 0B) goto <D.6816>; else goto <D.6817>;
  <D.6816>:
  D.6818 = stop_func ();
  if (D.6818 != 0) goto <D.6819>; else goto <D.6820>;
  <D.6819>:
  D.6821 = 0;
  return D.6821;
  <D.6820>:
  <D.6817>:
  hhdr = GC_find_header (hbp);
  D.6822 = hhdr->hb_next;
  *rlh = D.6822;
  if (ignore_old == 0) goto <D.6823>; else goto <D.6825>;
  <D.6825>:
  D.6826 = hhdr->hb_last_reclaimed;
  D.6827 = (long unsigned int) D.6826;
  GC_gc_no.40 = GC_gc_no;
  D.6829 = GC_gc_no.40 + 18446744073709551615;
  if (D.6827 == D.6829) goto <D.6823>; else goto <D.6824>;
  <D.6823>:
  GC_reclaim_small_nonempty_block (hbp, 0);
  <D.6824>:
  <D.6315>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.6314>; else goto <D.6316>;
  <D.6316>:
  sz = sz + 1;
  <D.6318>:
  if (sz <= 256) goto <D.6317>; else goto <D.6319>;
  <D.6319>:
  <D.6313>:
  kind = kind + 1;
  <D.6321>:
  GC_n_kinds.41 = GC_n_kinds;
  if (kind < GC_n_kinds.41) goto <D.6320>; else goto <D.6322>;
  <D.6322>:
  D.6821 = 1;
  return D.6821;
}