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.5418>; else goto <D.5419>;
  <D.5418>:
  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.5419>:
}


GC_print_all_errors ()
{
  int D.5422;
  int printing_errors.3;
  int GC_debugging_started.4;
  void (*<T630>) (void) GC_print_all_smashed.5;
  long unsigned int p.6;
  long unsigned int D.5433;
  struct bottom_index * D.5434;
  long unsigned int D.5435;
  long unsigned int D.5436;
  struct hdr * D.5437;
  unsigned char D.5438;
  void (*<Tfa3>) (char *) GC_print_heap_obj.7;
  unsigned int GC_n_leaked.8;
  unsigned int i;

  D.5422 = _test_and_set (&GC_allocate_lock, 1);
  if (D.5422 != 0) goto <D.5423>; else goto <D.5424>;
  <D.5423>:
  GC_lock ();
  <D.5424>:
  printing_errors.3 = printing_errors;
  if (printing_errors.3 != 0) goto <D.5426>; else goto <D.5427>;
  <D.5426>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.5427>:
  printing_errors = 1;
  GC_clear (&GC_allocate_lock);
  GC_debugging_started.4 = GC_debugging_started;
  if (GC_debugging_started.4 != 0) goto <D.5429>; else goto <D.5430>;
  <D.5429>:
  GC_print_all_smashed.5 = GC_print_all_smashed;
  GC_print_all_smashed.5 ();
  <D.5430>:
  i = 0;
  goto <D.5136>;
  <D.5135>:
  {
    char * p;

    p = GC_leaked[i];
    p.6 = (long unsigned int) p;
    D.5433 = p.6 >> 22;
    D.5434 = GC_arrays._top_index[D.5433];
    p.6 = (long unsigned int) p;
    D.5435 = p.6 >> 12;
    D.5436 = D.5435 & 1023;
    D.5437 = D.5434->index[D.5436];
    D.5438 = D.5437->hb_obj_kind;
    if (D.5438 == 0) goto <D.5439>; else goto <D.5440>;
    <D.5439>:
    GC_err_puts ("Leaked atomic object at ");
    goto <D.5441>;
    <D.5440>:
    GC_err_puts ("Leaked composite object at ");
    <D.5441>:
    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.5136>:
  GC_n_leaked.8 = GC_n_leaked;
  if (i < GC_n_leaked.8) goto <D.5135>; else goto <D.5137>;
  <D.5137>:
  GC_n_leaked = 0;
  printing_errors = 0;
}


_test_and_set (int * __p, int __v)
{
  int D.5445;
  int __r;
  int __t;

  __asm__ __volatile__("/* Inline test and set */
.set	push
	.set	mips2
	sync
	1:
	ll	%0,%3
	move	%1,%4
	beq	%0,%4,2f
	sc	%1,%2
	beqz	%1,1b
sync
	.set	pop
	2:
	/* End test and set */" : "=&r" __r, "=&r" __t, "=m" *__p : "m" *__p, "r" __v : "memory");
  D.5445 = __r;
  return D.5445;
}


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


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

  p = &hhdr->hb_marks[0];
  plim = &hhdr->hb_marks[32];
  goto <D.5144>;
  <D.5143>:
  p.9 = p;
  p = p.9 + 4;
  D.5448 = *p.9;
  if (D.5448 != 0) goto <D.5449>; else goto <D.5450>;
  <D.5449>:
  D.5451 = 0;
  return D.5451;
  <D.5450>:
  <D.5144>:
  if (p < plim) goto <D.5143>; else goto <D.5145>;
  <D.5145>:
  D.5451 = 1;
  return D.5451;
}


GC_block_nearly_full1 (struct hdr * hhdr, word pat1)
{
  long unsigned int D.5453;
  long unsigned int D.5454;
  long unsigned int D.5455;
  GC_bool D.5460;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  i = 0;
  goto <D.5153>;
  <D.5152>:
  D.5453 = hhdr->hb_marks[i];
  D.5454 = ~pat1;
  D.5455 = D.5453 | D.5454;
  if (D.5455 != 4294967295) goto <D.5456>; else goto <D.5457>;
  <D.5456>:
  misses = misses + 1;
  if (misses > 2) goto <D.5458>; else goto <D.5459>;
  <D.5458>:
  D.5460 = 0;
  return D.5460;
  <D.5459>:
  <D.5457>:
  i = i + 1;
  <D.5153>:
  if (i <= 31) goto <D.5152>; else goto <D.5154>;
  <D.5154>:
  D.5460 = 1;
  return D.5460;
}


GC_block_nearly_full3 (struct hdr * hhdr, word pat1, word pat2, word pat3)
{
  GC_bool D.5464;
  long unsigned int D.5465;
  long unsigned int D.5466;
  long unsigned int D.5467;
  unsigned int D.5472;
  long unsigned int D.5473;
  long unsigned int D.5474;
  long unsigned int D.5475;
  unsigned int D.5480;
  long unsigned int D.5481;
  long unsigned int D.5482;
  long unsigned int D.5483;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  if (0 != 0) goto <D.5462>; else goto <D.5463>;
  <D.5462>:
  D.5464 = 2;
  return D.5464;
  <D.5463>:
  i = 0;
  goto <D.5164>;
  <D.5163>:
  D.5465 = hhdr->hb_marks[i];
  D.5466 = ~pat1;
  D.5467 = D.5465 | D.5466;
  if (D.5467 != 4294967295) goto <D.5468>; else goto <D.5469>;
  <D.5468>:
  misses = misses + 1;
  if (misses > 2) goto <D.5470>; else goto <D.5471>;
  <D.5470>:
  D.5464 = 0;
  return D.5464;
  <D.5471>:
  <D.5469>:
  D.5472 = i + 1;
  D.5473 = hhdr->hb_marks[D.5472];
  D.5474 = ~pat2;
  D.5475 = D.5473 | D.5474;
  if (D.5475 != 4294967295) goto <D.5476>; else goto <D.5477>;
  <D.5476>:
  misses = misses + 1;
  if (misses > 2) goto <D.5478>; else goto <D.5479>;
  <D.5478>:
  D.5464 = 0;
  return D.5464;
  <D.5479>:
  <D.5477>:
  D.5480 = i + 2;
  D.5481 = hhdr->hb_marks[D.5480];
  D.5482 = ~pat3;
  D.5483 = D.5481 | D.5482;
  if (D.5483 != 4294967295) goto <D.5484>; else goto <D.5485>;
  <D.5484>:
  misses = misses + 1;
  if (misses > 2) goto <D.5486>; else goto <D.5487>;
  <D.5486>:
  D.5464 = 0;
  return D.5464;
  <D.5487>:
  <D.5485>:
  i = i + 3;
  <D.5164>:
  if (i <= 29) goto <D.5163>; else goto <D.5165>;
  <D.5165>:
  D.5464 = 1;
  return D.5464;
}


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

  D.5489 = hhdr->hb_sz;
  sz = (int) D.5489;
  switch (sz) <default: <D.5178>, case 1: <D.5170>, case 2: <D.5171>, case 4: <D.5172>, case 6: <D.5173>, case 8: <D.5174>, case 12: <D.5175>, case 16: <D.5176>, case 32: <D.5177>>
  <D.5170>:
  D.5490 = GC_block_nearly_full1 (hhdr, 4294967295);
  return D.5490;
  <D.5171>:
  D.5490 = GC_block_nearly_full1 (hhdr, 1431655765);
  return D.5490;
  <D.5172>:
  D.5490 = GC_block_nearly_full1 (hhdr, 286331153);
  return D.5490;
  <D.5173>:
  D.5490 = GC_block_nearly_full3 (hhdr, 1090785345, 272696336, 68174084);
  return D.5490;
  <D.5174>:
  D.5490 = GC_block_nearly_full1 (hhdr, 16843009);
  return D.5490;
  <D.5175>:
  D.5490 = GC_block_nearly_full3 (hhdr, 16781313, 268501008, 1048832);
  return D.5490;
  <D.5176>:
  D.5490 = GC_block_nearly_full1 (hhdr, 65537);
  return D.5490;
  <D.5177>:
  D.5490 = GC_block_nearly_full1 (hhdr, 1);
  return D.5490;
  <D.5178>:
  D.5490 = 2;
  return D.5490;
}


GC_reclaim_clear (struct hblk * hbp, struct hdr * hhdr, word sz, char * list)
{
  long unsigned int hbp.10;
  long unsigned int D.5493;
  long unsigned int D.5494;
  long unsigned int D.5495;
  int D.5496;
  long unsigned int D.5497;
  int D.5498;
  long unsigned int D.5499;
  long unsigned int D.5500;
  long unsigned int D.5503;
  word * p.11;
  long unsigned int word_no.12;
  long unsigned int D.5507;
  char * D.5508;
  register int word_no;
  register word * p;
  register word * q;
  register word * plim;

  p = &hbp->hb_body;
  word_no = 0;
  hbp.10 = (long unsigned int) hbp;
  D.5493 = sz << 2;
  D.5494 = hbp.10 - D.5493;
  D.5495 = D.5494 + 4096;
  plim = (word *) D.5495;
  goto <D.5193>;
  <D.5192>:
  D.5496 = word_no >> 5;
  D.5497 = hhdr->hb_marks[D.5496];
  D.5498 = word_no & 31;
  D.5499 = D.5497 >> D.5498;
  D.5500 = D.5499 & 1;
  if (D.5500 != 0) goto <D.5501>; else goto <D.5502>;
  <D.5501>:
  D.5503 = sz * 4;
  p = p + D.5503;
  goto <D.5504>;
  <D.5502>:
  MEM[(char * *)p] = list;
  list = p;
  D.5503 = sz * 4;
  q = p + D.5503;
  p = p + 4;
  goto <D.5190>;
  <D.5189>:
  p.11 = p;
  p = p.11 + 4;
  *p.11 = 0;
  <D.5190>:
  if (p < q) goto <D.5189>; else goto <D.5191>;
  <D.5191>:
  <D.5504>:
  word_no.12 = (long unsigned int) word_no;
  D.5507 = word_no.12 + sz;
  word_no = (int) D.5507;
  <D.5193>:
  if (p <= plim) goto <D.5192>; else goto <D.5194>;
  <D.5194>:
  D.5508 = list;
  return D.5508;
}


GC_reclaim_clear2 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.13;
  long unsigned int D.5511;
  word * mark_word_addr.14;
  long unsigned int D.5513;
  long unsigned int list.15;
  word * D.5517;
  long unsigned int D.5518;
  word * D.5521;
  word * D.5522;
  long unsigned int D.5523;
  word * D.5526;
  word * D.5527;
  long unsigned int D.5528;
  word * D.5531;
  word * D.5532;
  long unsigned int i.16;
  char * D.5534;
  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.13 = (long unsigned int) hbp;
  D.5511 = hbp.13 + 4096;
  plim = (word *) D.5511;
  goto <D.5209>;
  <D.5208>:
  mark_word_addr.14 = mark_word_addr;
  mark_word_addr = mark_word_addr.14 + 4;
  mark_word = *mark_word_addr.14;
  i = 0;
  goto <D.5206>;
  <D.5205>:
  D.5513 = mark_word & 1;
  if (D.5513 == 0) goto <D.5514>; else goto <D.5515>;
  <D.5514>:
  list.15 = (long unsigned int) list;
  *p = list.15;
  list = p;
  D.5517 = p + 4;
  *D.5517 = 0;
  <D.5515>:
  D.5518 = mark_word & 4;
  if (D.5518 == 0) goto <D.5519>; else goto <D.5520>;
  <D.5519>:
  D.5521 = p + 8;
  list.15 = (long unsigned int) list;
  *D.5521 = list.15;
  list = p + 8;
  D.5522 = p + 12;
  *D.5522 = 0;
  <D.5520>:
  D.5523 = mark_word & 16;
  if (D.5523 == 0) goto <D.5524>; else goto <D.5525>;
  <D.5524>:
  D.5526 = p + 16;
  list.15 = (long unsigned int) list;
  *D.5526 = list.15;
  list = p + 16;
  D.5527 = p + 20;
  *D.5527 = 0;
  <D.5525>:
  D.5528 = mark_word & 64;
  if (D.5528 == 0) goto <D.5529>; else goto <D.5530>;
  <D.5529>:
  D.5531 = p + 24;
  list.15 = (long unsigned int) list;
  *D.5531 = list.15;
  list = p + 24;
  D.5532 = p + 28;
  *D.5532 = 0;
  <D.5530>:
  p = p + 32;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.5206>:
  i.16 = (long unsigned int) i;
  if (i.16 <= 31) goto <D.5205>; else goto <D.5207>;
  <D.5207>:
  <D.5209>:
  if (p < plim) goto <D.5208>; else goto <D.5210>;
  <D.5210>:
  D.5534 = list;
  return D.5534;
}


GC_reclaim_clear4 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.17;
  long unsigned int D.5537;
  word * mark_word_addr.18;
  long unsigned int D.5539;
  long unsigned int list.19;
  word * D.5543;
  word * D.5544;
  word * D.5545;
  long unsigned int D.5546;
  word * D.5549;
  word * D.5550;
  word * D.5551;
  word * D.5552;
  long unsigned int D.5553;
  word * D.5556;
  word * D.5557;
  word * D.5558;
  word * D.5559;
  long unsigned int D.5560;
  word * D.5563;
  word * D.5564;
  word * D.5565;
  word * D.5566;
  long unsigned int D.5567;
  word * D.5570;
  word * D.5571;
  word * D.5572;
  word * D.5573;
  long unsigned int D.5574;
  word * D.5577;
  word * D.5578;
  word * D.5579;
  word * D.5580;
  long unsigned int D.5581;
  word * D.5584;
  word * D.5585;
  word * D.5586;
  word * D.5587;
  long unsigned int D.5588;
  word * D.5591;
  word * D.5592;
  word * D.5593;
  word * D.5594;
  char * D.5595;
  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.17 = (long unsigned int) hbp;
  D.5537 = hbp.17 + 4096;
  plim = (word *) D.5537;
  goto <D.5221>;
  <D.5220>:
  mark_word_addr.18 = mark_word_addr;
  mark_word_addr = mark_word_addr.18 + 4;
  mark_word = *mark_word_addr.18;
  D.5539 = mark_word & 1;
  if (D.5539 == 0) goto <D.5540>; else goto <D.5541>;
  <D.5540>:
  list.19 = (long unsigned int) list;
  *p = list.19;
  list = p;
  D.5543 = p + 4;
  *D.5543 = 0;
  D.5544 = p + 8;
  *D.5544 = 0;
  D.5545 = p + 12;
  *D.5545 = 0;
  <D.5541>:
  D.5546 = mark_word & 16;
  if (D.5546 == 0) goto <D.5547>; else goto <D.5548>;
  <D.5547>:
  D.5549 = p + 16;
  list.19 = (long unsigned int) list;
  *D.5549 = list.19;
  list = p + 16;
  D.5550 = p + 20;
  *D.5550 = 0;
  D.5551 = p + 24;
  *D.5551 = 0;
  D.5552 = p + 28;
  *D.5552 = 0;
  <D.5548>:
  D.5553 = mark_word & 256;
  if (D.5553 == 0) goto <D.5554>; else goto <D.5555>;
  <D.5554>:
  D.5556 = p + 32;
  list.19 = (long unsigned int) list;
  *D.5556 = list.19;
  list = p + 32;
  D.5557 = p + 36;
  *D.5557 = 0;
  D.5558 = p + 40;
  *D.5558 = 0;
  D.5559 = p + 44;
  *D.5559 = 0;
  <D.5555>:
  D.5560 = mark_word & 4096;
  if (D.5560 == 0) goto <D.5561>; else goto <D.5562>;
  <D.5561>:
  D.5563 = p + 48;
  list.19 = (long unsigned int) list;
  *D.5563 = list.19;
  list = p + 48;
  D.5564 = p + 52;
  *D.5564 = 0;
  D.5565 = p + 56;
  *D.5565 = 0;
  D.5566 = p + 60;
  *D.5566 = 0;
  <D.5562>:
  D.5567 = mark_word & 65536;
  if (D.5567 == 0) goto <D.5568>; else goto <D.5569>;
  <D.5568>:
  D.5570 = p + 64;
  list.19 = (long unsigned int) list;
  *D.5570 = list.19;
  list = p + 64;
  D.5571 = p + 68;
  *D.5571 = 0;
  D.5572 = p + 72;
  *D.5572 = 0;
  D.5573 = p + 76;
  *D.5573 = 0;
  <D.5569>:
  D.5574 = mark_word & 1048576;
  if (D.5574 == 0) goto <D.5575>; else goto <D.5576>;
  <D.5575>:
  D.5577 = p + 80;
  list.19 = (long unsigned int) list;
  *D.5577 = list.19;
  list = p + 80;
  D.5578 = p + 84;
  *D.5578 = 0;
  D.5579 = p + 88;
  *D.5579 = 0;
  D.5580 = p + 92;
  *D.5580 = 0;
  <D.5576>:
  D.5581 = mark_word & 16777216;
  if (D.5581 == 0) goto <D.5582>; else goto <D.5583>;
  <D.5582>:
  D.5584 = p + 96;
  list.19 = (long unsigned int) list;
  *D.5584 = list.19;
  list = p + 96;
  D.5585 = p + 100;
  *D.5585 = 0;
  D.5586 = p + 104;
  *D.5586 = 0;
  D.5587 = p + 108;
  *D.5587 = 0;
  <D.5583>:
  D.5588 = mark_word & 268435456;
  if (D.5588 == 0) goto <D.5589>; else goto <D.5590>;
  <D.5589>:
  D.5591 = p + 112;
  list.19 = (long unsigned int) list;
  *D.5591 = list.19;
  list = p + 112;
  D.5592 = p + 116;
  *D.5592 = 0;
  D.5593 = p + 120;
  *D.5593 = 0;
  D.5594 = p + 124;
  *D.5594 = 0;
  <D.5590>:
  p = p + 128;
  <D.5221>:
  if (p < plim) goto <D.5220>; else goto <D.5222>;
  <D.5222>:
  D.5595 = list;
  return D.5595;
}


GC_reclaim_uninit (struct hblk * hbp, struct hdr * hhdr, word sz, char * list)
{
  long unsigned int hbp.20;
  long unsigned int D.5598;
  long unsigned int D.5599;
  long unsigned int D.5600;
  int D.5601;
  long unsigned int D.5602;
  int D.5603;
  long unsigned int D.5604;
  long unsigned int D.5605;
  long unsigned int D.5608;
  long unsigned int word_no.21;
  long unsigned int D.5610;
  char * D.5611;
  register int word_no;
  register word * p;
  register word * plim;

  word_no = 0;
  p = &hbp->hb_body;
  hbp.20 = (long unsigned int) hbp;
  D.5598 = sz << 2;
  D.5599 = hbp.20 - D.5598;
  D.5600 = D.5599 + 4096;
  plim = (word *) D.5600;
  goto <D.5233>;
  <D.5232>:
  D.5601 = word_no >> 5;
  D.5602 = hhdr->hb_marks[D.5601];
  D.5603 = word_no & 31;
  D.5604 = D.5602 >> D.5603;
  D.5605 = D.5604 & 1;
  if (D.5605 == 0) goto <D.5606>; else goto <D.5607>;
  <D.5606>:
  MEM[(char * *)p] = list;
  list = p;
  <D.5607>:
  D.5608 = sz * 4;
  p = p + D.5608;
  word_no.21 = (long unsigned int) word_no;
  D.5610 = word_no.21 + sz;
  word_no = (int) D.5610;
  <D.5233>:
  if (p <= plim) goto <D.5232>; else goto <D.5234>;
  <D.5234>:
  D.5611 = list;
  return D.5611;
}


GC_reclaim_check (struct hblk * hbp, struct hdr * hhdr, word sz)
{
  long unsigned int hbp.22;
  long unsigned int D.5614;
  long unsigned int D.5615;
  long unsigned int D.5616;
  int D.5617;
  long unsigned int D.5618;
  int D.5619;
  long unsigned int D.5620;
  long unsigned int D.5621;
  int D.5624;
  sizetype D.5625;
  char * D.5626;
  long unsigned int D.5627;
  long unsigned int word_no.23;
  long unsigned int D.5629;
  register int word_no;
  register word * p;
  register word * plim;

  word_no = 0;
  p = &hbp->hb_body;
  hbp.22 = (long unsigned int) hbp;
  D.5614 = sz << 2;
  D.5615 = hbp.22 - D.5614;
  D.5616 = D.5615 + 4096;
  plim = (word *) D.5616;
  goto <D.5244>;
  <D.5243>:
  D.5617 = word_no >> 5;
  D.5618 = hhdr->hb_marks[D.5617];
  D.5619 = word_no & 31;
  D.5620 = D.5618 >> D.5619;
  D.5621 = D.5620 & 1;
  if (D.5621 == 0) goto <D.5622>; else goto <D.5623>;
  <D.5622>:
  D.5624 = word_no << 2;
  D.5625 = (sizetype) D.5624;
  D.5626 = hbp + D.5625;
  GC_add_leaked (D.5626);
  <D.5623>:
  D.5627 = sz * 4;
  p = p + D.5627;
  word_no.23 = (long unsigned int) word_no;
  D.5629 = word_no.23 + sz;
  word_no = (int) D.5629;
  <D.5244>:
  if (p <= plim) goto <D.5243>; else goto <D.5245>;
  <D.5245>:
}


GC_reclaim_uninit2 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.24;
  long unsigned int D.5631;
  word * mark_word_addr.25;
  long unsigned int D.5633;
  long unsigned int list.26;
  long unsigned int D.5637;
  word * D.5640;
  long unsigned int D.5641;
  word * D.5644;
  long unsigned int D.5645;
  word * D.5648;
  long unsigned int i.27;
  char * D.5650;
  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.24 = (long unsigned int) hbp;
  D.5631 = hbp.24 + 4096;
  plim = (word *) D.5631;
  goto <D.5260>;
  <D.5259>:
  mark_word_addr.25 = mark_word_addr;
  mark_word_addr = mark_word_addr.25 + 4;
  mark_word = *mark_word_addr.25;
  i = 0;
  goto <D.5257>;
  <D.5256>:
  D.5633 = mark_word & 1;
  if (D.5633 == 0) goto <D.5634>; else goto <D.5635>;
  <D.5634>:
  list.26 = (long unsigned int) list;
  *p = list.26;
  list = p;
  <D.5635>:
  D.5637 = mark_word & 4;
  if (D.5637 == 0) goto <D.5638>; else goto <D.5639>;
  <D.5638>:
  D.5640 = p + 8;
  list.26 = (long unsigned int) list;
  *D.5640 = list.26;
  list = p + 8;
  <D.5639>:
  D.5641 = mark_word & 16;
  if (D.5641 == 0) goto <D.5642>; else goto <D.5643>;
  <D.5642>:
  D.5644 = p + 16;
  list.26 = (long unsigned int) list;
  *D.5644 = list.26;
  list = p + 16;
  <D.5643>:
  D.5645 = mark_word & 64;
  if (D.5645 == 0) goto <D.5646>; else goto <D.5647>;
  <D.5646>:
  D.5648 = p + 24;
  list.26 = (long unsigned int) list;
  *D.5648 = list.26;
  list = p + 24;
  <D.5647>:
  p = p + 32;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.5257>:
  i.27 = (long unsigned int) i;
  if (i.27 <= 31) goto <D.5256>; else goto <D.5258>;
  <D.5258>:
  <D.5260>:
  if (p < plim) goto <D.5259>; else goto <D.5261>;
  <D.5261>:
  D.5650 = list;
  return D.5650;
}


GC_reclaim_uninit4 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.28;
  long unsigned int D.5653;
  word * mark_word_addr.29;
  long unsigned int D.5655;
  long unsigned int list.30;
  long unsigned int D.5659;
  word * D.5662;
  long unsigned int D.5663;
  word * D.5666;
  long unsigned int D.5667;
  word * D.5670;
  long unsigned int D.5671;
  word * D.5674;
  long unsigned int D.5675;
  word * D.5678;
  long unsigned int D.5679;
  word * D.5682;
  long unsigned int D.5683;
  word * D.5686;
  char * D.5687;
  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.28 = (long unsigned int) hbp;
  D.5653 = hbp.28 + 4096;
  plim = (word *) D.5653;
  goto <D.5272>;
  <D.5271>:
  mark_word_addr.29 = mark_word_addr;
  mark_word_addr = mark_word_addr.29 + 4;
  mark_word = *mark_word_addr.29;
  D.5655 = mark_word & 1;
  if (D.5655 == 0) goto <D.5656>; else goto <D.5657>;
  <D.5656>:
  list.30 = (long unsigned int) list;
  *p = list.30;
  list = p;
  <D.5657>:
  D.5659 = mark_word & 16;
  if (D.5659 == 0) goto <D.5660>; else goto <D.5661>;
  <D.5660>:
  D.5662 = p + 16;
  list.30 = (long unsigned int) list;
  *D.5662 = list.30;
  list = p + 16;
  <D.5661>:
  D.5663 = mark_word & 256;
  if (D.5663 == 0) goto <D.5664>; else goto <D.5665>;
  <D.5664>:
  D.5666 = p + 32;
  list.30 = (long unsigned int) list;
  *D.5666 = list.30;
  list = p + 32;
  <D.5665>:
  D.5667 = mark_word & 4096;
  if (D.5667 == 0) goto <D.5668>; else goto <D.5669>;
  <D.5668>:
  D.5670 = p + 48;
  list.30 = (long unsigned int) list;
  *D.5670 = list.30;
  list = p + 48;
  <D.5669>:
  D.5671 = mark_word & 65536;
  if (D.5671 == 0) goto <D.5672>; else goto <D.5673>;
  <D.5672>:
  D.5674 = p + 64;
  list.30 = (long unsigned int) list;
  *D.5674 = list.30;
  list = p + 64;
  <D.5673>:
  D.5675 = mark_word & 1048576;
  if (D.5675 == 0) goto <D.5676>; else goto <D.5677>;
  <D.5676>:
  D.5678 = p + 80;
  list.30 = (long unsigned int) list;
  *D.5678 = list.30;
  list = p + 80;
  <D.5677>:
  D.5679 = mark_word & 16777216;
  if (D.5679 == 0) goto <D.5680>; else goto <D.5681>;
  <D.5680>:
  D.5682 = p + 96;
  list.30 = (long unsigned int) list;
  *D.5682 = list.30;
  list = p + 96;
  <D.5681>:
  D.5683 = mark_word & 268435456;
  if (D.5683 == 0) goto <D.5684>; else goto <D.5685>;
  <D.5684>:
  D.5686 = p + 112;
  list.30 = (long unsigned int) list;
  *D.5686 = list.30;
  list = p + 112;
  <D.5685>:
  p = p + 128;
  <D.5272>:
  if (p < plim) goto <D.5271>; else goto <D.5273>;
  <D.5273>:
  D.5687 = list;
  return D.5687;
}


GC_reclaim1 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.31;
  long unsigned int D.5690;
  word * mark_word_addr.32;
  long unsigned int D.5692;
  long unsigned int list.33;
  long unsigned int D.5696;
  word * D.5699;
  long unsigned int D.5700;
  word * D.5703;
  long unsigned int D.5704;
  word * D.5707;
  long unsigned int i.34;
  char * D.5709;
  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.31 = (long unsigned int) hbp;
  D.5690 = hbp.31 + 4096;
  plim = (word *) D.5690;
  goto <D.5288>;
  <D.5287>:
  mark_word_addr.32 = mark_word_addr;
  mark_word_addr = mark_word_addr.32 + 4;
  mark_word = *mark_word_addr.32;
  i = 0;
  goto <D.5285>;
  <D.5284>:
  D.5692 = mark_word & 1;
  if (D.5692 == 0) goto <D.5693>; else goto <D.5694>;
  <D.5693>:
  list.33 = (long unsigned int) list;
  *p = list.33;
  list = p;
  <D.5694>:
  D.5696 = mark_word & 2;
  if (D.5696 == 0) goto <D.5697>; else goto <D.5698>;
  <D.5697>:
  D.5699 = p + 4;
  list.33 = (long unsigned int) list;
  *D.5699 = list.33;
  list = p + 4;
  <D.5698>:
  D.5700 = mark_word & 4;
  if (D.5700 == 0) goto <D.5701>; else goto <D.5702>;
  <D.5701>:
  D.5703 = p + 8;
  list.33 = (long unsigned int) list;
  *D.5703 = list.33;
  list = p + 8;
  <D.5702>:
  D.5704 = mark_word & 8;
  if (D.5704 == 0) goto <D.5705>; else goto <D.5706>;
  <D.5705>:
  D.5707 = p + 12;
  list.33 = (long unsigned int) list;
  *D.5707 = list.33;
  list = p + 12;
  <D.5706>:
  p = p + 16;
  mark_word = mark_word >> 4;
  i = i + 4;
  <D.5285>:
  i.34 = (long unsigned int) i;
  if (i.34 <= 31) goto <D.5284>; else goto <D.5286>;
  <D.5286>:
  <D.5288>:
  if (p < plim) goto <D.5287>; else goto <D.5289>;
  <D.5289>:
  D.5709 = list;
  return D.5709;
}


GC_reclaim_generic (struct hblk * hbp, struct hdr * hhdr, word sz, GC_bool init, char * list)
{
  long unsigned int D.5711;
  _Bool D.5712;
  int D.5713;
  unsigned char D.5717;
  int D.5718;
  int D.5719;
  char * D.5722;
  char * result;

  result = list;
  D.5711 = hhdr->hb_descr;
  D.5712 = D.5711 == 0;
  D.5713 = (int) D.5712;
  GC_remove_protection (hbp, 1, D.5713);
  if (init != 0) goto <D.5714>; else goto <D.5715>;
  <D.5714>:
  switch (sz) <default: <D.5302>, case 1: <D.5298>, case 2: <D.5300>, case 4: <D.5301>>
  <D.5298>:
  result = GC_reclaim1 (hbp, hhdr, list);
  goto <D.5299>;
  <D.5300>:
  result = GC_reclaim_clear2 (hbp, hhdr, list);
  goto <D.5299>;
  <D.5301>:
  result = GC_reclaim_clear4 (hbp, hhdr, list);
  goto <D.5299>;
  <D.5302>:
  result = GC_reclaim_clear (hbp, hhdr, sz, list);
  goto <D.5299>;
  <D.5299>:
  goto <D.5716>;
  <D.5715>:
  switch (sz) <default: <D.5307>, case 1: <D.5303>, case 2: <D.5305>, case 4: <D.5306>>
  <D.5303>:
  result = GC_reclaim1 (hbp, hhdr, list);
  goto <D.5304>;
  <D.5305>:
  result = GC_reclaim_uninit2 (hbp, hhdr, list);
  goto <D.5304>;
  <D.5306>:
  result = GC_reclaim_uninit4 (hbp, hhdr, list);
  goto <D.5304>;
  <D.5307>:
  result = GC_reclaim_uninit (hbp, hhdr, sz, list);
  goto <D.5304>;
  <D.5304>:
  <D.5716>:
  D.5717 = hhdr->hb_obj_kind;
  D.5718 = (int) D.5717;
  D.5719 = D.5718 & -2;
  if (D.5719 == 2) goto <D.5720>; else goto <D.5721>;
  <D.5720>:
  GC_set_hdr_marks (hhdr);
  <D.5721>:
  D.5722 = result;
  return D.5722;
}


GC_reclaim_small_nonempty_block (struct hblk * hbp, int report_if_found)
{
  long unsigned int hbp.35;
  long unsigned int D.5725;
  struct bottom_index * D.5726;
  long unsigned int D.5727;
  long unsigned int D.5728;
  unsigned char D.5729;
  char * * D.5730;
  long unsigned int D.5731;
  long unsigned int GC_gc_no.36;
  short unsigned int D.5733;
  int iftmp.37;
  int D.5741;
  int GC_debugging_started.38;
  char * D.5744;
  char * D.5745;
  struct hdr * hhdr;
  word sz;
  int kind;
  struct obj_kind * ok;
  char * * flh;

  hbp.35 = (long unsigned int) hbp;
  D.5725 = hbp.35 >> 22;
  D.5726 = GC_arrays._top_index[D.5725];
  hbp.35 = (long unsigned int) hbp;
  D.5727 = hbp.35 >> 12;
  D.5728 = D.5727 & 1023;
  hhdr = D.5726->index[D.5728];
  sz = hhdr->hb_sz;
  D.5729 = hhdr->hb_obj_kind;
  kind = (int) D.5729;
  ok = &GC_obj_kinds[kind];
  D.5730 = ok->ok_freelist;
  D.5731 = sz * 4;
  flh = D.5730 + D.5731;
  GC_gc_no.36 = GC_gc_no;
  D.5733 = (short unsigned int) GC_gc_no.36;
  hhdr->hb_last_reclaimed = D.5733;
  if (report_if_found != 0) goto <D.5734>; else goto <D.5735>;
  <D.5734>:
  GC_reclaim_check (hbp, hhdr, sz);
  goto <D.5736>;
  <D.5735>:
  D.5741 = ok->ok_init;
  if (D.5741 != 0) goto <D.5738>; else goto <D.5742>;
  <D.5742>:
  GC_debugging_started.38 = GC_debugging_started;
  if (GC_debugging_started.38 != 0) goto <D.5738>; else goto <D.5739>;
  <D.5738>:
  iftmp.37 = 1;
  goto <D.5740>;
  <D.5739>:
  iftmp.37 = 0;
  <D.5740>:
  D.5744 = *flh;
  D.5745 = GC_reclaim_generic (hbp, hhdr, sz, iftmp.37, D.5744);
  *flh = D.5745;
  <D.5736>:
}


GC_reclaim_block (struct hblk * hbp, word report_if_found)
{
  long unsigned int hbp.39;
  long unsigned int D.5747;
  struct bottom_index * D.5748;
  long unsigned int D.5749;
  long unsigned int D.5750;
  unsigned char D.5751;
  int D.5752;
  long unsigned int D.5755;
  long unsigned int D.5756;
  long unsigned int D.5762;
  long unsigned int D.5763;
  long unsigned int D.5766;
  long unsigned int D.5767;
  long unsigned int D.5768;
  int report_if_found.40;
  int D.5777;
  struct hblk * * D.5780;
  long unsigned int D.5781;
  struct hblk * D.5782;
  register struct hdr * hhdr;
  register word sz;
  register struct obj_kind * ok;
  struct hblk * * rlh;

  hbp.39 = (long unsigned int) hbp;
  D.5747 = hbp.39 >> 22;
  D.5748 = GC_arrays._top_index[D.5747];
  hbp.39 = (long unsigned int) hbp;
  D.5749 = hbp.39 >> 12;
  D.5750 = D.5749 & 1023;
  hhdr = D.5748->index[D.5750];
  sz = hhdr->hb_sz;
  D.5751 = hhdr->hb_obj_kind;
  D.5752 = (int) D.5751;
  ok = &GC_obj_kinds[D.5752];
  if (sz > 512) goto <D.5753>; else goto <D.5754>;
  <D.5753>:
  D.5755 = hhdr->hb_marks[0];
  D.5756 = D.5755 & 1;
  if (D.5756 == 0) goto <D.5757>; else goto <D.5758>;
  <D.5757>:
  if (report_if_found != 0) goto <D.5759>; else goto <D.5760>;
  <D.5759>:
  GC_add_leaked (hbp);
  goto <D.5761>;
  <D.5760>:
  {
    word blocks;

    D.5762 = sz << 2;
    D.5763 = D.5762 + 4095;
    blocks = D.5763 >> 12;
    if (blocks > 1) goto <D.5764>; else goto <D.5765>;
    <D.5764>:
    D.5766 = GC_arrays._large_allocd_bytes;
    D.5767 = blocks * 4096;
    D.5768 = D.5766 - D.5767;
    GC_arrays._large_allocd_bytes = D.5768;
    <D.5765>:
    GC_freehblk (hbp);
  }
  <D.5761>:
  <D.5758>:
  goto <D.5769>;
  <D.5754>:
  {
    GC_bool empty;

    empty = GC_block_empty (hhdr);
    if (report_if_found != 0) goto <D.5770>; else goto <D.5771>;
    <D.5770>:
    report_if_found.40 = (int) report_if_found;
    GC_reclaim_small_nonempty_block (hbp, report_if_found.40);
    goto <D.5773>;
    <D.5771>:
    if (empty != 0) goto <D.5774>; else goto <D.5775>;
    <D.5774>:
    GC_freehblk (hbp);
    goto <D.5776>;
    <D.5775>:
    D.5777 = GC_block_nearly_full (hhdr);
    if (D.5777 != 1) goto <D.5778>; else goto <D.5779>;
    <D.5778>:
    D.5780 = ok->ok_reclaim_list;
    D.5781 = sz * 4;
    rlh = D.5780 + D.5781;
    D.5782 = *rlh;
    hhdr->hb_next = D.5782;
    *rlh = hbp;
    <D.5779>:
    <D.5776>:
    <D.5773>:
  }
  <D.5769>:
}


GC_n_set_marks (struct hdr * hhdr)
{
  long unsigned int D.5783;
  int D.5784;
  int D.5785;
  register int result;
  register int i;

  result = 0;
  i = 0;
  goto <D.5344>;
  <D.5343>:
  D.5783 = hhdr->hb_marks[i];
  D.5784 = set_bits (D.5783);
  result = D.5784 + result;
  i = i + 1;
  <D.5344>:
  if (i <= 31) goto <D.5343>; else goto <D.5345>;
  <D.5345>:
  D.5785 = result;
  return D.5785;
}


set_bits (word n)
{
  long unsigned int D.5787;
  int D.5790;
  register word m;
  register int result;

  m = n;
  result = 0;
  goto <D.5336>;
  <D.5335>:
  D.5787 = m & 1;
  if (D.5787 != 0) goto <D.5788>; else goto <D.5789>;
  <D.5788>:
  result = result + 1;
  <D.5789>:
  m = m >> 1;
  <D.5336>:
  if (m != 0) goto <D.5335>; else goto <D.5337>;
  <D.5337>:
  D.5790 = result;
  return D.5790;
}


GC_print_block_descr (struct hblk * h, word dummy)
{
  long unsigned int h.41;
  long unsigned int D.5793;
  struct bottom_index * D.5794;
  long unsigned int D.5795;
  long unsigned int D.5796;
  long unsigned int D.5797;
  unsigned char D.5798;
  long int D.5799;
  long int bytes.42;
  int D.5801;
  unsigned int D.5802;
  unsigned int D.5803;
  unsigned int D.5804;
  unsigned int D.5805;
  register struct hdr * hhdr;
  register size_t bytes;
  struct Print_stats * ps;

  h.41 = (long unsigned int) h;
  D.5793 = h.41 >> 22;
  D.5794 = GC_arrays._top_index[D.5793];
  h.41 = (long unsigned int) h;
  D.5795 = h.41 >> 12;
  D.5796 = D.5795 & 1023;
  hhdr = D.5794->index[D.5796];
  D.5797 = hhdr->hb_sz;
  bytes = D.5797 << 2;
  D.5798 = hhdr->hb_obj_kind;
  D.5799 = (long int) D.5798;
  bytes.42 = (long int) bytes;
  D.5801 = GC_n_set_marks (hhdr);
  GC_printf ("(%lu:%lu,%lu)", D.5799, bytes.42, D.5801, 0, 0, 0);
  bytes = bytes + 4095;
  bytes = bytes & 4294963200;
  ps = (struct Print_stats *) dummy;
  D.5802 = ps->total_bytes;
  D.5803 = D.5802 + bytes;
  ps->total_bytes = D.5803;
  D.5804 = ps->number_of_blocks;
  D.5805 = D.5804 + 1;
  ps->number_of_blocks = D.5805;
}


GC_print_block_list ()
{
  long unsigned int pstats.43;
  unsigned int D.5807;
  long int D.5808;
  unsigned int D.5809;
  long int D.5810;
  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.43 = (long unsigned int) &pstats;
      GC_apply_to_all_blocks (GC_print_block_descr, pstats.43);
      D.5807 = pstats.number_of_blocks;
      D.5808 = (long int) D.5807;
      D.5809 = pstats.total_bytes;
      D.5810 = (long int) D.5809;
      GC_printf ("\nblocks = %lu, bytes = %lu\n", D.5808, D.5810, 0, 0, 0, 0);
    }
  finally
    {
      pstats = {CLOBBER};
    }
}


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

  next = *flp;
  goto <D.5361>;
  <D.5360>:
  *flp = 0B;
  flp = next;
  next = *flp;
  <D.5361>:
  if (next != 0B) goto <D.5360>; else goto <D.5362>;
  <D.5362>:
}


GC_start_reclaim (int report_if_found)
{
  long unsigned int D.5811;
  _Bool D.5812;
  char * * D.5817;
  char * D.5818;
  int GC_n_kinds.44;
  long unsigned int report_if_found.45;
  int kind;

  kind = 0;
  goto <D.5381>;
  <D.5380>:
  {
    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.5811 = GC_obj_kinds[kind].ok_descriptor;
    D.5812 = D.5811 != 0;
    should_clobber = (GC_bool) D.5812;
    if (rlist == 0B) goto <D.5813>; else goto <D.5814>;
    <D.5813>:
    // predicted unlikely by continue predictor.
    goto <D.5373>;
    <D.5814>:
    if (report_if_found == 0) goto <D.5815>; else goto <D.5816>;
    <D.5815>:
    D.5817 = GC_obj_kinds[kind].ok_freelist;
    lim = D.5817 + 2052;
    fop = GC_obj_kinds[kind].ok_freelist;
    goto <D.5375>;
    <D.5374>:
    D.5818 = *fop;
    if (D.5818 != 0B) goto <D.5819>; else goto <D.5820>;
    <D.5819>:
    if (should_clobber != 0) goto <D.5821>; else goto <D.5822>;
    <D.5821>:
    GC_clear_fl_links (fop);
    goto <D.5823>;
    <D.5822>:
    *fop = 0B;
    <D.5823>:
    <D.5820>:
    fop = fop + 4;
    <D.5375>:
    if (fop < lim) goto <D.5374>; else goto <D.5376>;
    <D.5376>:
    <D.5816>:
    rlim = rlist + 2052;
    rlp = rlist;
    goto <D.5378>;
    <D.5377>:
    *rlp = 0B;
    rlp = rlp + 4;
    <D.5378>:
    if (rlp < rlim) goto <D.5377>; else goto <D.5379>;
    <D.5379>:
  }
  <D.5373>:
  kind = kind + 1;
  <D.5381>:
  GC_n_kinds.44 = GC_n_kinds;
  if (kind < GC_n_kinds.44) goto <D.5380>; else goto <D.5382>;
  <D.5382>:
  report_if_found.45 = (long unsigned int) report_if_found;
  GC_apply_to_all_blocks (GC_reclaim_block, report_if_found.45);
}


GC_continue_reclaim (word sz, int kind)
{
  char * * D.5826;
  long unsigned int D.5827;
  long unsigned int hbp.46;
  long unsigned int D.5831;
  struct bottom_index * D.5832;
  long unsigned int D.5833;
  long unsigned int D.5834;
  struct hblk * D.5835;
  char * D.5836;
  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.5826 = ok->ok_freelist;
  D.5827 = sz * 4;
  flh = D.5826 + D.5827;
  if (rlh == 0B) goto <D.5828>; else goto <D.5829>;
  <D.5828>:
  return;
  <D.5829>:
  D.5827 = sz * 4;
  rlh = rlh + D.5827;
  goto <D.5394>;
  <D.5393>:
  hbp.46 = (long unsigned int) hbp;
  D.5831 = hbp.46 >> 22;
  D.5832 = GC_arrays._top_index[D.5831];
  hbp.46 = (long unsigned int) hbp;
  D.5833 = hbp.46 >> 12;
  D.5834 = D.5833 & 1023;
  hhdr = D.5832->index[D.5834];
  D.5835 = hhdr->hb_next;
  *rlh = D.5835;
  GC_reclaim_small_nonempty_block (hbp, 0);
  D.5836 = *flh;
  if (D.5836 != 0B) goto <D.5392>; else goto <D.5837>;
  <D.5837>:
  <D.5394>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.5393>; else goto <D.5392>;
  <D.5392>:
}


GC_reclaim_all (int (*GC_stop_func) (void) stop_func, GC_bool ignore_old)
{
  long unsigned int D.5841;
  int D.5844;
  GC_bool D.5847;
  long unsigned int hbp.47;
  long unsigned int D.5849;
  struct bottom_index * D.5850;
  long unsigned int D.5851;
  long unsigned int D.5852;
  struct hblk * D.5853;
  short unsigned int D.5857;
  long unsigned int D.5858;
  long unsigned int GC_gc_no.48;
  long unsigned int D.5860;
  int GC_n_kinds.49;
  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.5414>;
  <D.5413>:
  ok = &GC_obj_kinds[kind];
  rlp = ok->ok_reclaim_list;
  if (rlp == 0B) goto <D.5839>; else goto <D.5840>;
  <D.5839>:
  // predicted unlikely by continue predictor.
  goto <D.5406>;
  <D.5840>:
  sz = 1;
  goto <D.5411>;
  <D.5410>:
  D.5841 = sz * 4;
  rlh = rlp + D.5841;
  goto <D.5408>;
  <D.5407>:
  if (stop_func != 0B) goto <D.5842>; else goto <D.5843>;
  <D.5842>:
  D.5844 = stop_func ();
  if (D.5844 != 0) goto <D.5845>; else goto <D.5846>;
  <D.5845>:
  D.5847 = 0;
  return D.5847;
  <D.5846>:
  <D.5843>:
  hbp.47 = (long unsigned int) hbp;
  D.5849 = hbp.47 >> 22;
  D.5850 = GC_arrays._top_index[D.5849];
  hbp.47 = (long unsigned int) hbp;
  D.5851 = hbp.47 >> 12;
  D.5852 = D.5851 & 1023;
  hhdr = D.5850->index[D.5852];
  D.5853 = hhdr->hb_next;
  *rlh = D.5853;
  if (ignore_old == 0) goto <D.5854>; else goto <D.5856>;
  <D.5856>:
  D.5857 = hhdr->hb_last_reclaimed;
  D.5858 = (long unsigned int) D.5857;
  GC_gc_no.48 = GC_gc_no;
  D.5860 = GC_gc_no.48 + 4294967295;
  if (D.5858 == D.5860) goto <D.5854>; else goto <D.5855>;
  <D.5854>:
  GC_reclaim_small_nonempty_block (hbp, 0);
  <D.5855>:
  <D.5408>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.5407>; else goto <D.5409>;
  <D.5409>:
  sz = sz + 1;
  <D.5411>:
  if (sz <= 512) goto <D.5410>; else goto <D.5412>;
  <D.5412>:
  <D.5406>:
  kind = kind + 1;
  <D.5414>:
  GC_n_kinds.49 = GC_n_kinds;
  if (kind < GC_n_kinds.49) goto <D.5413>; else goto <D.5415>;
  <D.5415>:
  D.5847 = 1;
  return D.5847;
}