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.5499>; else goto <D.5500>;
  <D.5499>:
  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.5500>:
}


GC_print_all_errors ()
{
  int D.5503;
  int printing_errors.3;
  int GC_debugging_started.4;
  void (*<T640>) (void) GC_print_all_smashed.5;
  long unsigned int p.6;
  long unsigned int D.5514;
  struct bottom_index * D.5515;
  long unsigned int D.5516;
  long unsigned int D.5517;
  struct hdr * D.5518;
  unsigned char D.5519;
  void (*<Tfd6>) (char *) GC_print_heap_obj.7;
  unsigned int GC_n_leaked.8;
  unsigned int i;

  D.5503 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5503 != 0) goto <D.5504>; else goto <D.5505>;
  <D.5504>:
  GC_lock ();
  <D.5505>:
  printing_errors.3 = printing_errors;
  if (printing_errors.3 != 0) goto <D.5507>; else goto <D.5508>;
  <D.5507>:
  pthread_mutex_unlock (&GC_allocate_ml);
  return;
  <D.5508>:
  printing_errors = 1;
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_debugging_started.4 = GC_debugging_started;
  if (GC_debugging_started.4 != 0) goto <D.5510>; else goto <D.5511>;
  <D.5510>:
  GC_print_all_smashed.5 = GC_print_all_smashed;
  GC_print_all_smashed.5 ();
  <D.5511>:
  i = 0;
  goto <D.5201>;
  <D.5200>:
  {
    char * p;

    p = GC_leaked[i];
    p.6 = (long unsigned int) p;
    D.5514 = p.6 >> 22;
    D.5515 = GC_arrays._top_index[D.5514];
    p.6 = (long unsigned int) p;
    D.5516 = p.6 >> 12;
    D.5517 = D.5516 & 1023;
    D.5518 = D.5515->index[D.5517];
    D.5519 = D.5518->hb_obj_kind;
    if (D.5519 == 0) goto <D.5520>; else goto <D.5521>;
    <D.5520>:
    GC_err_puts ("Leaked atomic object at ");
    goto <D.5522>;
    <D.5521>:
    GC_err_puts ("Leaked composite object at ");
    <D.5522>:
    GC_print_heap_obj.7 = GC_print_heap_obj;
    GC_print_heap_obj.7 (p);
    GC_err_puts ("\n");
    GC_free (p);
    GC_leaked[i] = 0B;
  }
  i = i + 1;
  <D.5201>:
  GC_n_leaked.8 = GC_n_leaked;
  if (i < GC_n_leaked.8) goto <D.5200>; else goto <D.5202>;
  <D.5202>:
  GC_n_leaked = 0;
  printing_errors = 0;
}


GC_block_empty (struct hdr * hhdr)
{
  word * p.9;
  long unsigned int D.5527;
  GC_bool D.5530;
  register word * p;
  register word * plim;

  p = &hhdr->hb_marks[0];
  plim = &hhdr->hb_marks[32];
  goto <D.5209>;
  <D.5208>:
  p.9 = p;
  p = p.9 + 4;
  D.5527 = *p.9;
  if (D.5527 != 0) goto <D.5528>; else goto <D.5529>;
  <D.5528>:
  D.5530 = 0;
  return D.5530;
  <D.5529>:
  <D.5209>:
  if (p < plim) goto <D.5208>; else goto <D.5210>;
  <D.5210>:
  D.5530 = 1;
  return D.5530;
}


GC_block_nearly_full1 (struct hdr * hhdr, word pat1)
{
  long unsigned int D.5532;
  long unsigned int D.5533;
  long unsigned int D.5534;
  GC_bool D.5539;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  i = 0;
  goto <D.5218>;
  <D.5217>:
  D.5532 = hhdr->hb_marks[i];
  D.5533 = ~pat1;
  D.5534 = D.5532 | D.5533;
  if (D.5534 != 4294967295) goto <D.5535>; else goto <D.5536>;
  <D.5535>:
  misses = misses + 1;
  if (misses > 2) goto <D.5537>; else goto <D.5538>;
  <D.5537>:
  D.5539 = 0;
  return D.5539;
  <D.5538>:
  <D.5536>:
  i = i + 1;
  <D.5218>:
  if (i <= 31) goto <D.5217>; else goto <D.5219>;
  <D.5219>:
  D.5539 = 1;
  return D.5539;
}


GC_block_nearly_full3 (struct hdr * hhdr, word pat1, word pat2, word pat3)
{
  GC_bool D.5543;
  long unsigned int D.5544;
  long unsigned int D.5545;
  long unsigned int D.5546;
  unsigned int D.5551;
  long unsigned int D.5552;
  long unsigned int D.5553;
  long unsigned int D.5554;
  unsigned int D.5559;
  long unsigned int D.5560;
  long unsigned int D.5561;
  long unsigned int D.5562;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  if (0 != 0) goto <D.5541>; else goto <D.5542>;
  <D.5541>:
  D.5543 = 2;
  return D.5543;
  <D.5542>:
  i = 0;
  goto <D.5229>;
  <D.5228>:
  D.5544 = hhdr->hb_marks[i];
  D.5545 = ~pat1;
  D.5546 = D.5544 | D.5545;
  if (D.5546 != 4294967295) goto <D.5547>; else goto <D.5548>;
  <D.5547>:
  misses = misses + 1;
  if (misses > 2) goto <D.5549>; else goto <D.5550>;
  <D.5549>:
  D.5543 = 0;
  return D.5543;
  <D.5550>:
  <D.5548>:
  D.5551 = i + 1;
  D.5552 = hhdr->hb_marks[D.5551];
  D.5553 = ~pat2;
  D.5554 = D.5552 | D.5553;
  if (D.5554 != 4294967295) goto <D.5555>; else goto <D.5556>;
  <D.5555>:
  misses = misses + 1;
  if (misses > 2) goto <D.5557>; else goto <D.5558>;
  <D.5557>:
  D.5543 = 0;
  return D.5543;
  <D.5558>:
  <D.5556>:
  D.5559 = i + 2;
  D.5560 = hhdr->hb_marks[D.5559];
  D.5561 = ~pat3;
  D.5562 = D.5560 | D.5561;
  if (D.5562 != 4294967295) goto <D.5563>; else goto <D.5564>;
  <D.5563>:
  misses = misses + 1;
  if (misses > 2) goto <D.5565>; else goto <D.5566>;
  <D.5565>:
  D.5543 = 0;
  return D.5543;
  <D.5566>:
  <D.5564>:
  i = i + 3;
  <D.5229>:
  if (i <= 29) goto <D.5228>; else goto <D.5230>;
  <D.5230>:
  D.5543 = 1;
  return D.5543;
}


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

  D.5568 = hhdr->hb_sz;
  sz = (int) D.5568;
  switch (sz) <default: <D.5243>, case 1: <D.5235>, case 2: <D.5236>, case 4: <D.5237>, case 6: <D.5238>, case 8: <D.5239>, case 12: <D.5240>, case 16: <D.5241>, case 32: <D.5242>>
  <D.5235>:
  D.5569 = GC_block_nearly_full1 (hhdr, 4294967295);
  return D.5569;
  <D.5236>:
  D.5569 = GC_block_nearly_full1 (hhdr, 1431655765);
  return D.5569;
  <D.5237>:
  D.5569 = GC_block_nearly_full1 (hhdr, 286331153);
  return D.5569;
  <D.5238>:
  D.5569 = GC_block_nearly_full3 (hhdr, 1090785345, 272696336, 68174084);
  return D.5569;
  <D.5239>:
  D.5569 = GC_block_nearly_full1 (hhdr, 16843009);
  return D.5569;
  <D.5240>:
  D.5569 = GC_block_nearly_full3 (hhdr, 16781313, 268501008, 1048832);
  return D.5569;
  <D.5241>:
  D.5569 = GC_block_nearly_full1 (hhdr, 65537);
  return D.5569;
  <D.5242>:
  D.5569 = GC_block_nearly_full1 (hhdr, 1);
  return D.5569;
  <D.5243>:
  D.5569 = 2;
  return D.5569;
}


GC_reclaim_clear (struct hblk * hbp, struct hdr * hhdr, word sz, char * list, signed_word * count)
{
  long unsigned int hbp.10;
  long unsigned int D.5572;
  long unsigned int D.5573;
  long unsigned int D.5574;
  int D.5575;
  long unsigned int D.5576;
  int D.5577;
  long unsigned int D.5578;
  long unsigned int D.5579;
  long unsigned int D.5582;
  long unsigned int n_words_found.11;
  long unsigned int D.5585;
  word * p.12;
  long unsigned int word_no.13;
  long unsigned int D.5588;
  long int D.5589;
  long int D.5590;
  char * D.5591;
  register int word_no;
  register word * p;
  register word * q;
  register word * plim;
  signed_word n_words_found;

  n_words_found = 0;
  p = &hbp->hb_body;
  word_no = 0;
  hbp.10 = (long unsigned int) hbp;
  D.5572 = sz << 2;
  D.5573 = hbp.10 - D.5572;
  D.5574 = D.5573 + 4096;
  plim = (word *) D.5574;
  goto <D.5260>;
  <D.5259>:
  D.5575 = word_no >> 5;
  D.5576 = hhdr->hb_marks[D.5575];
  D.5577 = word_no & 31;
  D.5578 = D.5576 >> D.5577;
  D.5579 = D.5578 & 1;
  if (D.5579 != 0) goto <D.5580>; else goto <D.5581>;
  <D.5580>:
  D.5582 = sz * 4;
  p = p + D.5582;
  goto <D.5583>;
  <D.5581>:
  n_words_found.11 = (long unsigned int) n_words_found;
  D.5585 = n_words_found.11 + sz;
  n_words_found = (signed_word) D.5585;
  MEM[(char * *)p] = list;
  list = p;
  D.5582 = sz * 4;
  q = p + D.5582;
  p = p + 4;
  goto <D.5257>;
  <D.5256>:
  p.12 = p;
  p = p.12 + 4;
  *p.12 = 0;
  <D.5257>:
  if (p < q) goto <D.5256>; else goto <D.5258>;
  <D.5258>:
  <D.5583>:
  word_no.13 = (long unsigned int) word_no;
  D.5588 = word_no.13 + sz;
  word_no = (int) D.5588;
  <D.5260>:
  if (p <= plim) goto <D.5259>; else goto <D.5261>;
  <D.5261>:
  D.5589 = *count;
  D.5590 = D.5589 + n_words_found;
  *count = D.5590;
  D.5591 = list;
  return D.5591;
}


GC_reclaim_clear2 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.14;
  long unsigned int D.5594;
  word * mark_word_addr.15;
  long unsigned int D.5596;
  long unsigned int list.16;
  word * D.5600;
  long unsigned int D.5601;
  word * D.5604;
  word * D.5605;
  long unsigned int D.5606;
  word * D.5609;
  word * D.5610;
  long unsigned int D.5611;
  word * D.5614;
  word * D.5615;
  long unsigned int i.17;
  long int D.5617;
  long int D.5618;
  char * D.5619;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.14 = (long unsigned int) hbp;
  D.5594 = hbp.14 + 4096;
  plim = (word *) D.5594;
  goto <D.5278>;
  <D.5277>:
  mark_word_addr.15 = mark_word_addr;
  mark_word_addr = mark_word_addr.15 + 4;
  mark_word = *mark_word_addr.15;
  i = 0;
  goto <D.5275>;
  <D.5274>:
  D.5596 = mark_word & 1;
  if (D.5596 == 0) goto <D.5597>; else goto <D.5598>;
  <D.5597>:
  list.16 = (long unsigned int) list;
  *p = list.16;
  list = p;
  D.5600 = p + 4;
  *D.5600 = 0;
  n_words_found = n_words_found + 2;
  <D.5598>:
  D.5601 = mark_word & 4;
  if (D.5601 == 0) goto <D.5602>; else goto <D.5603>;
  <D.5602>:
  D.5604 = p + 8;
  list.16 = (long unsigned int) list;
  *D.5604 = list.16;
  list = p + 8;
  D.5605 = p + 12;
  *D.5605 = 0;
  n_words_found = n_words_found + 2;
  <D.5603>:
  D.5606 = mark_word & 16;
  if (D.5606 == 0) goto <D.5607>; else goto <D.5608>;
  <D.5607>:
  D.5609 = p + 16;
  list.16 = (long unsigned int) list;
  *D.5609 = list.16;
  list = p + 16;
  D.5610 = p + 20;
  *D.5610 = 0;
  n_words_found = n_words_found + 2;
  <D.5608>:
  D.5611 = mark_word & 64;
  if (D.5611 == 0) goto <D.5612>; else goto <D.5613>;
  <D.5612>:
  D.5614 = p + 24;
  list.16 = (long unsigned int) list;
  *D.5614 = list.16;
  list = p + 24;
  D.5615 = p + 28;
  *D.5615 = 0;
  n_words_found = n_words_found + 2;
  <D.5613>:
  p = p + 32;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.5275>:
  i.17 = (long unsigned int) i;
  if (i.17 <= 31) goto <D.5274>; else goto <D.5276>;
  <D.5276>:
  <D.5278>:
  if (p < plim) goto <D.5277>; else goto <D.5279>;
  <D.5279>:
  D.5617 = *count;
  D.5618 = D.5617 + n_words_found;
  *count = D.5618;
  D.5619 = list;
  return D.5619;
}


GC_reclaim_clear4 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.18;
  long unsigned int D.5622;
  word * mark_word_addr.19;
  long unsigned int D.5624;
  long unsigned int list.20;
  word * D.5628;
  word * D.5629;
  word * D.5630;
  long unsigned int D.5631;
  word * D.5634;
  word * D.5635;
  word * D.5636;
  word * D.5637;
  long unsigned int D.5638;
  word * D.5641;
  word * D.5642;
  word * D.5643;
  word * D.5644;
  long unsigned int D.5645;
  word * D.5648;
  word * D.5649;
  word * D.5650;
  word * D.5651;
  long unsigned int D.5652;
  word * D.5655;
  word * D.5656;
  word * D.5657;
  word * D.5658;
  long unsigned int D.5659;
  word * D.5662;
  word * D.5663;
  word * D.5664;
  word * D.5665;
  long unsigned int D.5666;
  word * D.5669;
  word * D.5670;
  word * D.5671;
  word * D.5672;
  long unsigned int D.5673;
  word * D.5676;
  word * D.5677;
  word * D.5678;
  word * D.5679;
  long int D.5680;
  long int D.5681;
  char * D.5682;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.18 = (long unsigned int) hbp;
  D.5622 = hbp.18 + 4096;
  plim = (word *) D.5622;
  goto <D.5292>;
  <D.5291>:
  mark_word_addr.19 = mark_word_addr;
  mark_word_addr = mark_word_addr.19 + 4;
  mark_word = *mark_word_addr.19;
  D.5624 = mark_word & 1;
  if (D.5624 == 0) goto <D.5625>; else goto <D.5626>;
  <D.5625>:
  list.20 = (long unsigned int) list;
  *p = list.20;
  list = p;
  D.5628 = p + 4;
  *D.5628 = 0;
  D.5629 = p + 8;
  *D.5629 = 0;
  D.5630 = p + 12;
  *D.5630 = 0;
  n_words_found = n_words_found + 4;
  <D.5626>:
  D.5631 = mark_word & 16;
  if (D.5631 == 0) goto <D.5632>; else goto <D.5633>;
  <D.5632>:
  D.5634 = p + 16;
  list.20 = (long unsigned int) list;
  *D.5634 = list.20;
  list = p + 16;
  D.5635 = p + 20;
  *D.5635 = 0;
  D.5636 = p + 24;
  *D.5636 = 0;
  D.5637 = p + 28;
  *D.5637 = 0;
  n_words_found = n_words_found + 4;
  <D.5633>:
  D.5638 = mark_word & 256;
  if (D.5638 == 0) goto <D.5639>; else goto <D.5640>;
  <D.5639>:
  D.5641 = p + 32;
  list.20 = (long unsigned int) list;
  *D.5641 = list.20;
  list = p + 32;
  D.5642 = p + 36;
  *D.5642 = 0;
  D.5643 = p + 40;
  *D.5643 = 0;
  D.5644 = p + 44;
  *D.5644 = 0;
  n_words_found = n_words_found + 4;
  <D.5640>:
  D.5645 = mark_word & 4096;
  if (D.5645 == 0) goto <D.5646>; else goto <D.5647>;
  <D.5646>:
  D.5648 = p + 48;
  list.20 = (long unsigned int) list;
  *D.5648 = list.20;
  list = p + 48;
  D.5649 = p + 52;
  *D.5649 = 0;
  D.5650 = p + 56;
  *D.5650 = 0;
  D.5651 = p + 60;
  *D.5651 = 0;
  n_words_found = n_words_found + 4;
  <D.5647>:
  D.5652 = mark_word & 65536;
  if (D.5652 == 0) goto <D.5653>; else goto <D.5654>;
  <D.5653>:
  D.5655 = p + 64;
  list.20 = (long unsigned int) list;
  *D.5655 = list.20;
  list = p + 64;
  D.5656 = p + 68;
  *D.5656 = 0;
  D.5657 = p + 72;
  *D.5657 = 0;
  D.5658 = p + 76;
  *D.5658 = 0;
  n_words_found = n_words_found + 4;
  <D.5654>:
  D.5659 = mark_word & 1048576;
  if (D.5659 == 0) goto <D.5660>; else goto <D.5661>;
  <D.5660>:
  D.5662 = p + 80;
  list.20 = (long unsigned int) list;
  *D.5662 = list.20;
  list = p + 80;
  D.5663 = p + 84;
  *D.5663 = 0;
  D.5664 = p + 88;
  *D.5664 = 0;
  D.5665 = p + 92;
  *D.5665 = 0;
  n_words_found = n_words_found + 4;
  <D.5661>:
  D.5666 = mark_word & 16777216;
  if (D.5666 == 0) goto <D.5667>; else goto <D.5668>;
  <D.5667>:
  D.5669 = p + 96;
  list.20 = (long unsigned int) list;
  *D.5669 = list.20;
  list = p + 96;
  D.5670 = p + 100;
  *D.5670 = 0;
  D.5671 = p + 104;
  *D.5671 = 0;
  D.5672 = p + 108;
  *D.5672 = 0;
  n_words_found = n_words_found + 4;
  <D.5668>:
  D.5673 = mark_word & 268435456;
  if (D.5673 == 0) goto <D.5674>; else goto <D.5675>;
  <D.5674>:
  D.5676 = p + 112;
  list.20 = (long unsigned int) list;
  *D.5676 = list.20;
  list = p + 112;
  D.5677 = p + 116;
  *D.5677 = 0;
  D.5678 = p + 120;
  *D.5678 = 0;
  D.5679 = p + 124;
  *D.5679 = 0;
  n_words_found = n_words_found + 4;
  <D.5675>:
  p = p + 128;
  <D.5292>:
  if (p < plim) goto <D.5291>; else goto <D.5293>;
  <D.5293>:
  D.5680 = *count;
  D.5681 = D.5680 + n_words_found;
  *count = D.5681;
  D.5682 = list;
  return D.5682;
}


GC_reclaim_uninit (struct hblk * hbp, struct hdr * hhdr, word sz, char * list, signed_word * count)
{
  long unsigned int hbp.21;
  long unsigned int D.5685;
  long unsigned int D.5686;
  long unsigned int D.5687;
  int D.5688;
  long unsigned int D.5689;
  int D.5690;
  long unsigned int D.5691;
  long unsigned int D.5692;
  long unsigned int n_words_found.22;
  long unsigned int D.5696;
  long unsigned int D.5697;
  long unsigned int word_no.23;
  long unsigned int D.5699;
  long int D.5700;
  long int D.5701;
  char * D.5702;
  register int word_no;
  register word * p;
  register word * plim;
  signed_word n_words_found;

  word_no = 0;
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.21 = (long unsigned int) hbp;
  D.5685 = sz << 2;
  D.5686 = hbp.21 - D.5685;
  D.5687 = D.5686 + 4096;
  plim = (word *) D.5687;
  goto <D.5306>;
  <D.5305>:
  D.5688 = word_no >> 5;
  D.5689 = hhdr->hb_marks[D.5688];
  D.5690 = word_no & 31;
  D.5691 = D.5689 >> D.5690;
  D.5692 = D.5691 & 1;
  if (D.5692 == 0) goto <D.5693>; else goto <D.5694>;
  <D.5693>:
  n_words_found.22 = (long unsigned int) n_words_found;
  D.5696 = n_words_found.22 + sz;
  n_words_found = (signed_word) D.5696;
  MEM[(char * *)p] = list;
  list = p;
  <D.5694>:
  D.5697 = sz * 4;
  p = p + D.5697;
  word_no.23 = (long unsigned int) word_no;
  D.5699 = word_no.23 + sz;
  word_no = (int) D.5699;
  <D.5306>:
  if (p <= plim) goto <D.5305>; else goto <D.5307>;
  <D.5307>:
  D.5700 = *count;
  D.5701 = D.5700 + n_words_found;
  *count = D.5701;
  D.5702 = list;
  return D.5702;
}


GC_reclaim_check (struct hblk * hbp, struct hdr * hhdr, word sz)
{
  long unsigned int hbp.24;
  long unsigned int D.5705;
  long unsigned int D.5706;
  long unsigned int D.5707;
  int D.5708;
  long unsigned int D.5709;
  int D.5710;
  long unsigned int D.5711;
  long unsigned int D.5712;
  int D.5715;
  sizetype D.5716;
  char * D.5717;
  long unsigned int D.5718;
  long unsigned int word_no.25;
  long unsigned int D.5720;
  register int word_no;
  register word * p;
  register word * plim;

  word_no = 0;
  p = &hbp->hb_body;
  hbp.24 = (long unsigned int) hbp;
  D.5705 = sz << 2;
  D.5706 = hbp.24 - D.5705;
  D.5707 = D.5706 + 4096;
  plim = (word *) D.5707;
  goto <D.5317>;
  <D.5316>:
  D.5708 = word_no >> 5;
  D.5709 = hhdr->hb_marks[D.5708];
  D.5710 = word_no & 31;
  D.5711 = D.5709 >> D.5710;
  D.5712 = D.5711 & 1;
  if (D.5712 == 0) goto <D.5713>; else goto <D.5714>;
  <D.5713>:
  D.5715 = word_no << 2;
  D.5716 = (sizetype) D.5715;
  D.5717 = hbp + D.5716;
  GC_add_leaked (D.5717);
  <D.5714>:
  D.5718 = sz * 4;
  p = p + D.5718;
  word_no.25 = (long unsigned int) word_no;
  D.5720 = word_no.25 + sz;
  word_no = (int) D.5720;
  <D.5317>:
  if (p <= plim) goto <D.5316>; else goto <D.5318>;
  <D.5318>:
}


GC_reclaim_uninit2 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.26;
  long unsigned int D.5722;
  word * mark_word_addr.27;
  long unsigned int D.5724;
  long unsigned int list.28;
  long unsigned int D.5728;
  word * D.5731;
  long unsigned int D.5732;
  word * D.5735;
  long unsigned int D.5736;
  word * D.5739;
  long unsigned int i.29;
  long int D.5741;
  long int D.5742;
  char * D.5743;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.26 = (long unsigned int) hbp;
  D.5722 = hbp.26 + 4096;
  plim = (word *) D.5722;
  goto <D.5335>;
  <D.5334>:
  mark_word_addr.27 = mark_word_addr;
  mark_word_addr = mark_word_addr.27 + 4;
  mark_word = *mark_word_addr.27;
  i = 0;
  goto <D.5332>;
  <D.5331>:
  D.5724 = mark_word & 1;
  if (D.5724 == 0) goto <D.5725>; else goto <D.5726>;
  <D.5725>:
  list.28 = (long unsigned int) list;
  *p = list.28;
  list = p;
  n_words_found = n_words_found + 2;
  <D.5726>:
  D.5728 = mark_word & 4;
  if (D.5728 == 0) goto <D.5729>; else goto <D.5730>;
  <D.5729>:
  D.5731 = p + 8;
  list.28 = (long unsigned int) list;
  *D.5731 = list.28;
  list = p + 8;
  n_words_found = n_words_found + 2;
  <D.5730>:
  D.5732 = mark_word & 16;
  if (D.5732 == 0) goto <D.5733>; else goto <D.5734>;
  <D.5733>:
  D.5735 = p + 16;
  list.28 = (long unsigned int) list;
  *D.5735 = list.28;
  list = p + 16;
  n_words_found = n_words_found + 2;
  <D.5734>:
  D.5736 = mark_word & 64;
  if (D.5736 == 0) goto <D.5737>; else goto <D.5738>;
  <D.5737>:
  D.5739 = p + 24;
  list.28 = (long unsigned int) list;
  *D.5739 = list.28;
  list = p + 24;
  n_words_found = n_words_found + 2;
  <D.5738>:
  p = p + 32;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.5332>:
  i.29 = (long unsigned int) i;
  if (i.29 <= 31) goto <D.5331>; else goto <D.5333>;
  <D.5333>:
  <D.5335>:
  if (p < plim) goto <D.5334>; else goto <D.5336>;
  <D.5336>:
  D.5741 = *count;
  D.5742 = D.5741 + n_words_found;
  *count = D.5742;
  D.5743 = list;
  return D.5743;
}


GC_reclaim_uninit4 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.30;
  long unsigned int D.5746;
  word * mark_word_addr.31;
  long unsigned int D.5748;
  long unsigned int list.32;
  long unsigned int D.5752;
  word * D.5755;
  long unsigned int D.5756;
  word * D.5759;
  long unsigned int D.5760;
  word * D.5763;
  long unsigned int D.5764;
  word * D.5767;
  long unsigned int D.5768;
  word * D.5771;
  long unsigned int D.5772;
  word * D.5775;
  long unsigned int D.5776;
  word * D.5779;
  long int D.5780;
  long int D.5781;
  char * D.5782;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.30 = (long unsigned int) hbp;
  D.5746 = hbp.30 + 4096;
  plim = (word *) D.5746;
  goto <D.5349>;
  <D.5348>:
  mark_word_addr.31 = mark_word_addr;
  mark_word_addr = mark_word_addr.31 + 4;
  mark_word = *mark_word_addr.31;
  D.5748 = mark_word & 1;
  if (D.5748 == 0) goto <D.5749>; else goto <D.5750>;
  <D.5749>:
  list.32 = (long unsigned int) list;
  *p = list.32;
  list = p;
  n_words_found = n_words_found + 4;
  <D.5750>:
  D.5752 = mark_word & 16;
  if (D.5752 == 0) goto <D.5753>; else goto <D.5754>;
  <D.5753>:
  D.5755 = p + 16;
  list.32 = (long unsigned int) list;
  *D.5755 = list.32;
  list = p + 16;
  n_words_found = n_words_found + 4;
  <D.5754>:
  D.5756 = mark_word & 256;
  if (D.5756 == 0) goto <D.5757>; else goto <D.5758>;
  <D.5757>:
  D.5759 = p + 32;
  list.32 = (long unsigned int) list;
  *D.5759 = list.32;
  list = p + 32;
  n_words_found = n_words_found + 4;
  <D.5758>:
  D.5760 = mark_word & 4096;
  if (D.5760 == 0) goto <D.5761>; else goto <D.5762>;
  <D.5761>:
  D.5763 = p + 48;
  list.32 = (long unsigned int) list;
  *D.5763 = list.32;
  list = p + 48;
  n_words_found = n_words_found + 4;
  <D.5762>:
  D.5764 = mark_word & 65536;
  if (D.5764 == 0) goto <D.5765>; else goto <D.5766>;
  <D.5765>:
  D.5767 = p + 64;
  list.32 = (long unsigned int) list;
  *D.5767 = list.32;
  list = p + 64;
  n_words_found = n_words_found + 4;
  <D.5766>:
  D.5768 = mark_word & 1048576;
  if (D.5768 == 0) goto <D.5769>; else goto <D.5770>;
  <D.5769>:
  D.5771 = p + 80;
  list.32 = (long unsigned int) list;
  *D.5771 = list.32;
  list = p + 80;
  n_words_found = n_words_found + 4;
  <D.5770>:
  D.5772 = mark_word & 16777216;
  if (D.5772 == 0) goto <D.5773>; else goto <D.5774>;
  <D.5773>:
  D.5775 = p + 96;
  list.32 = (long unsigned int) list;
  *D.5775 = list.32;
  list = p + 96;
  n_words_found = n_words_found + 4;
  <D.5774>:
  D.5776 = mark_word & 268435456;
  if (D.5776 == 0) goto <D.5777>; else goto <D.5778>;
  <D.5777>:
  D.5779 = p + 112;
  list.32 = (long unsigned int) list;
  *D.5779 = list.32;
  list = p + 112;
  n_words_found = n_words_found + 4;
  <D.5778>:
  p = p + 128;
  <D.5349>:
  if (p < plim) goto <D.5348>; else goto <D.5350>;
  <D.5350>:
  D.5780 = *count;
  D.5781 = D.5780 + n_words_found;
  *count = D.5781;
  D.5782 = list;
  return D.5782;
}


GC_reclaim1 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.33;
  long unsigned int D.5785;
  word * mark_word_addr.34;
  long unsigned int D.5787;
  long unsigned int list.35;
  long unsigned int D.5791;
  word * D.5794;
  long unsigned int D.5795;
  word * D.5798;
  long unsigned int D.5799;
  word * D.5802;
  long unsigned int i.36;
  long int D.5804;
  long int D.5805;
  char * D.5806;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.33 = (long unsigned int) hbp;
  D.5785 = hbp.33 + 4096;
  plim = (word *) D.5785;
  goto <D.5367>;
  <D.5366>:
  mark_word_addr.34 = mark_word_addr;
  mark_word_addr = mark_word_addr.34 + 4;
  mark_word = *mark_word_addr.34;
  i = 0;
  goto <D.5364>;
  <D.5363>:
  D.5787 = mark_word & 1;
  if (D.5787 == 0) goto <D.5788>; else goto <D.5789>;
  <D.5788>:
  list.35 = (long unsigned int) list;
  *p = list.35;
  list = p;
  n_words_found = n_words_found + 1;
  <D.5789>:
  D.5791 = mark_word & 2;
  if (D.5791 == 0) goto <D.5792>; else goto <D.5793>;
  <D.5792>:
  D.5794 = p + 4;
  list.35 = (long unsigned int) list;
  *D.5794 = list.35;
  list = p + 4;
  n_words_found = n_words_found + 1;
  <D.5793>:
  D.5795 = mark_word & 4;
  if (D.5795 == 0) goto <D.5796>; else goto <D.5797>;
  <D.5796>:
  D.5798 = p + 8;
  list.35 = (long unsigned int) list;
  *D.5798 = list.35;
  list = p + 8;
  n_words_found = n_words_found + 1;
  <D.5797>:
  D.5799 = mark_word & 8;
  if (D.5799 == 0) goto <D.5800>; else goto <D.5801>;
  <D.5800>:
  D.5802 = p + 12;
  list.35 = (long unsigned int) list;
  *D.5802 = list.35;
  list = p + 12;
  n_words_found = n_words_found + 1;
  <D.5801>:
  p = p + 16;
  mark_word = mark_word >> 4;
  i = i + 4;
  <D.5364>:
  i.36 = (long unsigned int) i;
  if (i.36 <= 31) goto <D.5363>; else goto <D.5365>;
  <D.5365>:
  <D.5367>:
  if (p < plim) goto <D.5366>; else goto <D.5368>;
  <D.5368>:
  D.5804 = *count;
  D.5805 = D.5804 + n_words_found;
  *count = D.5805;
  D.5806 = list;
  return D.5806;
}


GC_reclaim_generic (struct hblk * hbp, struct hdr * hhdr, word sz, GC_bool init, char * list, signed_word * count)
{
  long unsigned int D.5808;
  _Bool D.5809;
  int D.5810;
  unsigned char D.5814;
  int D.5815;
  int D.5816;
  char * D.5819;
  char * result;

  result = list;
  D.5808 = hhdr->hb_descr;
  D.5809 = D.5808 == 0;
  D.5810 = (int) D.5809;
  GC_remove_protection (hbp, 1, D.5810);
  if (init != 0) goto <D.5811>; else goto <D.5812>;
  <D.5811>:
  switch (sz) <default: <D.5382>, case 1: <D.5378>, case 2: <D.5380>, case 4: <D.5381>>
  <D.5378>:
  result = GC_reclaim1 (hbp, hhdr, list, count);
  goto <D.5379>;
  <D.5380>:
  result = GC_reclaim_clear2 (hbp, hhdr, list, count);
  goto <D.5379>;
  <D.5381>:
  result = GC_reclaim_clear4 (hbp, hhdr, list, count);
  goto <D.5379>;
  <D.5382>:
  result = GC_reclaim_clear (hbp, hhdr, sz, list, count);
  goto <D.5379>;
  <D.5379>:
  goto <D.5813>;
  <D.5812>:
  switch (sz) <default: <D.5387>, case 1: <D.5383>, case 2: <D.5385>, case 4: <D.5386>>
  <D.5383>:
  result = GC_reclaim1 (hbp, hhdr, list, count);
  goto <D.5384>;
  <D.5385>:
  result = GC_reclaim_uninit2 (hbp, hhdr, list, count);
  goto <D.5384>;
  <D.5386>:
  result = GC_reclaim_uninit4 (hbp, hhdr, list, count);
  goto <D.5384>;
  <D.5387>:
  result = GC_reclaim_uninit (hbp, hhdr, sz, list, count);
  goto <D.5384>;
  <D.5384>:
  <D.5813>:
  D.5814 = hhdr->hb_obj_kind;
  D.5815 = (int) D.5814;
  D.5816 = D.5815 & -2;
  if (D.5816 == 2) goto <D.5817>; else goto <D.5818>;
  <D.5817>:
  GC_set_hdr_marks (hhdr);
  <D.5818>:
  D.5819 = result;
  return D.5819;
}


GC_reclaim_small_nonempty_block (struct hblk * hbp, int report_if_found, signed_word * count)
{
  long unsigned int hbp.37;
  long unsigned int D.5822;
  struct bottom_index * D.5823;
  long unsigned int D.5824;
  long unsigned int D.5825;
  unsigned char D.5826;
  char * * D.5827;
  long unsigned int D.5828;
  long unsigned int GC_gc_no.38;
  short unsigned int D.5830;
  char * D.5834;
  int iftmp.39;
  int D.5839;
  int GC_debugging_started.40;
  char * D.5842;
  struct hdr * hhdr;
  word sz;
  int kind;
  struct obj_kind * ok;
  char * * flh;

  hbp.37 = (long unsigned int) hbp;
  D.5822 = hbp.37 >> 22;
  D.5823 = GC_arrays._top_index[D.5822];
  hbp.37 = (long unsigned int) hbp;
  D.5824 = hbp.37 >> 12;
  D.5825 = D.5824 & 1023;
  hhdr = D.5823->index[D.5825];
  sz = hhdr->hb_sz;
  D.5826 = hhdr->hb_obj_kind;
  kind = (int) D.5826;
  ok = &GC_obj_kinds[kind];
  D.5827 = ok->ok_freelist;
  D.5828 = sz * 4;
  flh = D.5827 + D.5828;
  GC_gc_no.38 = GC_gc_no;
  D.5830 = (short unsigned int) GC_gc_no.38;
  hhdr->hb_last_reclaimed = D.5830;
  if (report_if_found != 0) goto <D.5831>; else goto <D.5832>;
  <D.5831>:
  GC_reclaim_check (hbp, hhdr, sz);
  goto <D.5833>;
  <D.5832>:
  D.5834 = *flh;
  D.5839 = ok->ok_init;
  if (D.5839 != 0) goto <D.5836>; else goto <D.5840>;
  <D.5840>:
  GC_debugging_started.40 = GC_debugging_started;
  if (GC_debugging_started.40 != 0) goto <D.5836>; else goto <D.5837>;
  <D.5836>:
  iftmp.39 = 1;
  goto <D.5838>;
  <D.5837>:
  iftmp.39 = 0;
  <D.5838>:
  D.5842 = GC_reclaim_generic (hbp, hhdr, sz, iftmp.39, D.5834, &GC_mem_found);
  *flh = D.5842;
  <D.5833>:
}


GC_reclaim_block (struct hblk * hbp, word report_if_found)
{
  long unsigned int hbp.41;
  long unsigned int D.5844;
  struct bottom_index * D.5845;
  long unsigned int D.5846;
  long unsigned int D.5847;
  unsigned char D.5848;
  int D.5849;
  long unsigned int D.5852;
  long unsigned int D.5853;
  long unsigned int D.5859;
  long unsigned int D.5860;
  long unsigned int D.5863;
  long unsigned int D.5864;
  long unsigned int D.5865;
  int report_if_found.42;
  int D.5874;
  struct hblk * * D.5877;
  long unsigned int D.5878;
  struct hblk * D.5879;
  register struct hdr * hhdr;
  register word sz;
  register struct obj_kind * ok;
  struct hblk * * rlh;

  hbp.41 = (long unsigned int) hbp;
  D.5844 = hbp.41 >> 22;
  D.5845 = GC_arrays._top_index[D.5844];
  hbp.41 = (long unsigned int) hbp;
  D.5846 = hbp.41 >> 12;
  D.5847 = D.5846 & 1023;
  hhdr = D.5845->index[D.5847];
  sz = hhdr->hb_sz;
  D.5848 = hhdr->hb_obj_kind;
  D.5849 = (int) D.5848;
  ok = &GC_obj_kinds[D.5849];
  if (sz > 512) goto <D.5850>; else goto <D.5851>;
  <D.5850>:
  D.5852 = hhdr->hb_marks[0];
  D.5853 = D.5852 & 1;
  if (D.5853 == 0) goto <D.5854>; else goto <D.5855>;
  <D.5854>:
  if (report_if_found != 0) goto <D.5856>; else goto <D.5857>;
  <D.5856>:
  GC_add_leaked (hbp);
  goto <D.5858>;
  <D.5857>:
  {
    word blocks;

    D.5859 = sz << 2;
    D.5860 = D.5859 + 4095;
    blocks = D.5860 >> 12;
    if (blocks > 1) goto <D.5861>; else goto <D.5862>;
    <D.5861>:
    D.5863 = GC_arrays._large_allocd_bytes;
    D.5864 = blocks * 4096;
    D.5865 = D.5863 - D.5864;
    GC_arrays._large_allocd_bytes = D.5865;
    <D.5862>:
    GC_freehblk (hbp);
  }
  <D.5858>:
  <D.5855>:
  goto <D.5866>;
  <D.5851>:
  {
    GC_bool empty;

    empty = GC_block_empty (hhdr);
    if (report_if_found != 0) goto <D.5867>; else goto <D.5868>;
    <D.5867>:
    report_if_found.42 = (int) report_if_found;
    GC_reclaim_small_nonempty_block (hbp, report_if_found.42, &GC_mem_found);
    goto <D.5870>;
    <D.5868>:
    if (empty != 0) goto <D.5871>; else goto <D.5872>;
    <D.5871>:
    GC_freehblk (hbp);
    goto <D.5873>;
    <D.5872>:
    D.5874 = GC_block_nearly_full (hhdr);
    if (D.5874 != 1) goto <D.5875>; else goto <D.5876>;
    <D.5875>:
    D.5877 = ok->ok_reclaim_list;
    D.5878 = sz * 4;
    rlh = D.5877 + D.5878;
    D.5879 = *rlh;
    hhdr->hb_next = D.5879;
    *rlh = hbp;
    <D.5876>:
    <D.5873>:
    <D.5870>:
  }
  <D.5866>:
}


GC_n_set_marks (struct hdr * hhdr)
{
  long unsigned int D.5880;
  int D.5881;
  int D.5882;
  register int result;
  register int i;

  result = 0;
  i = 0;
  goto <D.5425>;
  <D.5424>:
  D.5880 = hhdr->hb_marks[i];
  D.5881 = set_bits (D.5880);
  result = D.5881 + result;
  i = i + 1;
  <D.5425>:
  if (i <= 31) goto <D.5424>; else goto <D.5426>;
  <D.5426>:
  D.5882 = result;
  return D.5882;
}


set_bits (word n)
{
  long unsigned int D.5884;
  int D.5887;
  register word m;
  register int result;

  m = n;
  result = 0;
  goto <D.5417>;
  <D.5416>:
  D.5884 = m & 1;
  if (D.5884 != 0) goto <D.5885>; else goto <D.5886>;
  <D.5885>:
  result = result + 1;
  <D.5886>:
  m = m >> 1;
  <D.5417>:
  if (m != 0) goto <D.5416>; else goto <D.5418>;
  <D.5418>:
  D.5887 = result;
  return D.5887;
}


GC_print_block_descr (struct hblk * h, word dummy)
{
  long unsigned int h.43;
  long unsigned int D.5890;
  struct bottom_index * D.5891;
  long unsigned int D.5892;
  long unsigned int D.5893;
  long unsigned int D.5894;
  int D.5895;
  long int bytes.44;
  unsigned char D.5897;
  long int D.5898;
  unsigned int D.5899;
  unsigned int D.5900;
  unsigned int D.5901;
  unsigned int D.5902;
  register struct hdr * hhdr;
  register size_t bytes;
  struct Print_stats * ps;

  h.43 = (long unsigned int) h;
  D.5890 = h.43 >> 22;
  D.5891 = GC_arrays._top_index[D.5890];
  h.43 = (long unsigned int) h;
  D.5892 = h.43 >> 12;
  D.5893 = D.5892 & 1023;
  hhdr = D.5891->index[D.5893];
  D.5894 = hhdr->hb_sz;
  bytes = D.5894 << 2;
  D.5895 = GC_n_set_marks (hhdr);
  bytes.44 = (long int) bytes;
  D.5897 = hhdr->hb_obj_kind;
  D.5898 = (long int) D.5897;
  GC_printf ("(%lu:%lu,%lu)", D.5898, bytes.44, D.5895, 0, 0, 0);
  bytes = bytes + 4095;
  bytes = bytes & 4294963200;
  ps = (struct Print_stats *) dummy;
  D.5899 = ps->total_bytes;
  D.5900 = D.5899 + bytes;
  ps->total_bytes = D.5900;
  D.5901 = ps->number_of_blocks;
  D.5902 = D.5901 + 1;
  ps->number_of_blocks = D.5902;
}


GC_print_block_list ()
{
  long unsigned int pstats.45;
  unsigned int D.5904;
  long int D.5905;
  unsigned int D.5906;
  long int D.5907;
  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.45 = (long unsigned int) &pstats;
      GC_apply_to_all_blocks (GC_print_block_descr, pstats.45);
      D.5904 = pstats.total_bytes;
      D.5905 = (long int) D.5904;
      D.5906 = pstats.number_of_blocks;
      D.5907 = (long int) D.5906;
      GC_printf ("\nblocks = %lu, bytes = %lu\n", D.5907, D.5905, 0, 0, 0, 0);
    }
  finally
    {
      pstats = {CLOBBER};
    }
}


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

  next = *flp;
  goto <D.5442>;
  <D.5441>:
  *flp = 0B;
  flp = next;
  next = *flp;
  <D.5442>:
  if (next != 0B) goto <D.5441>; else goto <D.5443>;
  <D.5443>:
}


GC_start_reclaim (int report_if_found)
{
  long unsigned int D.5908;
  _Bool D.5909;
  char * * D.5914;
  char * D.5915;
  int GC_n_kinds.46;
  long unsigned int report_if_found.47;
  int kind;

  kind = 0;
  goto <D.5462>;
  <D.5461>:
  {
    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.5908 = GC_obj_kinds[kind].ok_descriptor;
    D.5909 = D.5908 != 0;
    should_clobber = (GC_bool) D.5909;
    if (rlist == 0B) goto <D.5910>; else goto <D.5911>;
    <D.5910>:
    // predicted unlikely by continue predictor.
    goto <D.5454>;
    <D.5911>:
    if (report_if_found == 0) goto <D.5912>; else goto <D.5913>;
    <D.5912>:
    D.5914 = GC_obj_kinds[kind].ok_freelist;
    lim = D.5914 + 2052;
    fop = GC_obj_kinds[kind].ok_freelist;
    goto <D.5456>;
    <D.5455>:
    D.5915 = *fop;
    if (D.5915 != 0B) goto <D.5916>; else goto <D.5917>;
    <D.5916>:
    if (should_clobber != 0) goto <D.5918>; else goto <D.5919>;
    <D.5918>:
    GC_clear_fl_links (fop);
    goto <D.5920>;
    <D.5919>:
    *fop = 0B;
    <D.5920>:
    <D.5917>:
    fop = fop + 4;
    <D.5456>:
    if (fop < lim) goto <D.5455>; else goto <D.5457>;
    <D.5457>:
    <D.5913>:
    rlim = rlist + 2052;
    rlp = rlist;
    goto <D.5459>;
    <D.5458>:
    *rlp = 0B;
    rlp = rlp + 4;
    <D.5459>:
    if (rlp < rlim) goto <D.5458>; else goto <D.5460>;
    <D.5460>:
  }
  <D.5454>:
  kind = kind + 1;
  <D.5462>:
  GC_n_kinds.46 = GC_n_kinds;
  if (kind < GC_n_kinds.46) goto <D.5461>; else goto <D.5463>;
  <D.5463>:
  report_if_found.47 = (long unsigned int) report_if_found;
  GC_apply_to_all_blocks (GC_reclaim_block, report_if_found.47);
}


GC_continue_reclaim (word sz, int kind)
{
  char * * D.5923;
  long unsigned int D.5924;
  long unsigned int hbp.48;
  long unsigned int D.5928;
  struct bottom_index * D.5929;
  long unsigned int D.5930;
  long unsigned int D.5931;
  struct hblk * D.5932;
  char * D.5933;
  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.5923 = ok->ok_freelist;
  D.5924 = sz * 4;
  flh = D.5923 + D.5924;
  if (rlh == 0B) goto <D.5925>; else goto <D.5926>;
  <D.5925>:
  return;
  <D.5926>:
  D.5924 = sz * 4;
  rlh = rlh + D.5924;
  goto <D.5475>;
  <D.5474>:
  hbp.48 = (long unsigned int) hbp;
  D.5928 = hbp.48 >> 22;
  D.5929 = GC_arrays._top_index[D.5928];
  hbp.48 = (long unsigned int) hbp;
  D.5930 = hbp.48 >> 12;
  D.5931 = D.5930 & 1023;
  hhdr = D.5929->index[D.5931];
  D.5932 = hhdr->hb_next;
  *rlh = D.5932;
  GC_reclaim_small_nonempty_block (hbp, 0, &GC_mem_found);
  D.5933 = *flh;
  if (D.5933 != 0B) goto <D.5473>; else goto <D.5934>;
  <D.5934>:
  <D.5475>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.5474>; else goto <D.5473>;
  <D.5473>:
}


GC_reclaim_all (int (*GC_stop_func) (void) stop_func, GC_bool ignore_old)
{
  long unsigned int D.5938;
  int D.5941;
  GC_bool D.5944;
  long unsigned int hbp.49;
  long unsigned int D.5946;
  struct bottom_index * D.5947;
  long unsigned int D.5948;
  long unsigned int D.5949;
  struct hblk * D.5950;
  short unsigned int D.5954;
  long unsigned int D.5955;
  long unsigned int GC_gc_no.50;
  long unsigned int D.5957;
  int GC_n_kinds.51;
  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.5495>;
  <D.5494>:
  ok = &GC_obj_kinds[kind];
  rlp = ok->ok_reclaim_list;
  if (rlp == 0B) goto <D.5936>; else goto <D.5937>;
  <D.5936>:
  // predicted unlikely by continue predictor.
  goto <D.5487>;
  <D.5937>:
  sz = 1;
  goto <D.5492>;
  <D.5491>:
  D.5938 = sz * 4;
  rlh = rlp + D.5938;
  goto <D.5489>;
  <D.5488>:
  if (stop_func != 0B) goto <D.5939>; else goto <D.5940>;
  <D.5939>:
  D.5941 = stop_func ();
  if (D.5941 != 0) goto <D.5942>; else goto <D.5943>;
  <D.5942>:
  D.5944 = 0;
  return D.5944;
  <D.5943>:
  <D.5940>:
  hbp.49 = (long unsigned int) hbp;
  D.5946 = hbp.49 >> 22;
  D.5947 = GC_arrays._top_index[D.5946];
  hbp.49 = (long unsigned int) hbp;
  D.5948 = hbp.49 >> 12;
  D.5949 = D.5948 & 1023;
  hhdr = D.5947->index[D.5949];
  D.5950 = hhdr->hb_next;
  *rlh = D.5950;
  if (ignore_old == 0) goto <D.5951>; else goto <D.5953>;
  <D.5953>:
  D.5954 = hhdr->hb_last_reclaimed;
  D.5955 = (long unsigned int) D.5954;
  GC_gc_no.50 = GC_gc_no;
  D.5957 = GC_gc_no.50 + 4294967295;
  if (D.5955 == D.5957) goto <D.5951>; else goto <D.5952>;
  <D.5951>:
  GC_reclaim_small_nonempty_block (hbp, 0, &GC_mem_found);
  <D.5952>:
  <D.5489>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.5488>; else goto <D.5490>;
  <D.5490>:
  sz = sz + 1;
  <D.5492>:
  if (sz <= 512) goto <D.5491>; else goto <D.5493>;
  <D.5493>:
  <D.5487>:
  kind = kind + 1;
  <D.5495>:
  GC_n_kinds.51 = GC_n_kinds;
  if (kind < GC_n_kinds.51) goto <D.5494>; else goto <D.5496>;
  <D.5496>:
  D.5944 = 1;
  return D.5944;
}