GC_hblk_fl_from_blocks (word blocks_needed)
{
  int D.5377;
  long unsigned int D.5380;
  long unsigned int D.5381;
  long unsigned int D.5382;

  if (blocks_needed <= 32) goto <D.5375>; else goto <D.5376>;
  <D.5375>:
  D.5377 = (int) blocks_needed;
  return D.5377;
  <D.5376>:
  if (blocks_needed > 255) goto <D.5378>; else goto <D.5379>;
  <D.5378>:
  D.5377 = 60;
  return D.5377;
  <D.5379>:
  D.5380 = blocks_needed + 4294967264;
  D.5381 = D.5380 / 8;
  D.5382 = D.5381 + 32;
  D.5377 = (int) D.5382;
  return D.5377;
}


GC_print_hblkfreelist ()
{
  long unsigned int h.0;
  long unsigned int D.5387;
  struct bottom_index * D.5388;
  long unsigned int D.5389;
  long unsigned int D.5390;
  long int sz.1;
  long int h.2;
  struct hblk * D.5393;
  long unsigned int D.5397;
  struct hblk * D.5398;
  long int total_free.3;
  struct hblk * h;
  word total_free;
  struct hdr * hhdr;
  word sz;
  int i;

  total_free = 0;
  i = 0;
  goto <D.5203>;
  <D.5202>:
  h = GC_hblkfreelist[i];
  if (h != 0B) goto <D.5384>; else goto <D.5385>;
  <D.5384>:
  GC_printf ("Free list %ld:\n", i, 0, 0, 0, 0, 0);
  <D.5385>:
  goto <D.5200>;
  <D.5199>:
  h.0 = (long unsigned int) h;
  D.5387 = h.0 >> 22;
  D.5388 = GC_arrays._top_index[D.5387];
  h.0 = (long unsigned int) h;
  D.5389 = h.0 >> 12;
  D.5390 = D.5389 & 1023;
  hhdr = D.5388->index[D.5390];
  sz = hhdr->hb_sz;
  sz.1 = (long int) sz;
  h.2 = (long int) h;
  GC_printf ("\t0x%lx size %lu ", h.2, sz.1, 0, 0, 0, 0);
  total_free = total_free + sz;
  D.5393 = GC_is_black_listed (h, 4096);
  if (D.5393 != 0B) goto <D.5394>; else goto <D.5395>;
  <D.5394>:
  GC_printf ("start black listed\n", 0, 0, 0, 0, 0, 0);
  goto <D.5396>;
  <D.5395>:
  D.5397 = hhdr->hb_sz;
  D.5398 = GC_is_black_listed (h, D.5397);
  if (D.5398 != 0B) goto <D.5399>; else goto <D.5400>;
  <D.5399>:
  GC_printf ("partially black listed\n", 0, 0, 0, 0, 0, 0);
  goto <D.5401>;
  <D.5400>:
  GC_printf ("not black listed\n", 0, 0, 0, 0, 0, 0);
  <D.5401>:
  <D.5396>:
  h = hhdr->hb_next;
  <D.5200>:
  if (h != 0B) goto <D.5199>; else goto <D.5201>;
  <D.5201>:
  i = i + 1;
  <D.5203>:
  if (i <= 60) goto <D.5202>; else goto <D.5204>;
  <D.5204>:
  total_free.3 = (long int) total_free;
  GC_printf ("Total of %lu bytes on free list\n", total_free.3, 0, 0, 0, 0, 0);
}


free_list_index_of (struct hdr * wanted)
{
  long unsigned int h.4;
  long unsigned int D.5404;
  struct bottom_index * D.5405;
  long unsigned int D.5406;
  long unsigned int D.5407;
  int D.5410;
  struct hblk * h;
  struct hdr * hhdr;
  int i;

  i = 0;
  goto <D.5215>;
  <D.5214>:
  h = GC_hblkfreelist[i];
  goto <D.5212>;
  <D.5211>:
  h.4 = (long unsigned int) h;
  D.5404 = h.4 >> 22;
  D.5405 = GC_arrays._top_index[D.5404];
  h.4 = (long unsigned int) h;
  D.5406 = h.4 >> 12;
  D.5407 = D.5406 & 1023;
  hhdr = D.5405->index[D.5407];
  if (hhdr == wanted) goto <D.5408>; else goto <D.5409>;
  <D.5408>:
  D.5410 = i;
  return D.5410;
  <D.5409>:
  h = hhdr->hb_next;
  <D.5212>:
  if (h != 0B) goto <D.5211>; else goto <D.5213>;
  <D.5213>:
  i = i + 1;
  <D.5215>:
  if (i <= 60) goto <D.5214>; else goto <D.5216>;
  <D.5216>:
  D.5410 = -1;
  return D.5410;
}


GC_dump_regions ()
{
  char * D.5412;
  long unsigned int D.5413;
  unsigned int D.5414;
  long unsigned int GC_n_heap_sects.5;
  char * D.5417;
  long int end.6;
  long int start.7;
  long unsigned int p.8;
  long unsigned int D.5421;
  struct bottom_index * D.5422;
  long unsigned int D.5423;
  long unsigned int D.5424;
  long int p.9;
  long unsigned int hhdr.10;
  long int hhdr.11;
  map_entry_type * D.5430;
  map_entry_type * GC_invalid_map.12;
  long unsigned int D.5434;
  long unsigned int D.5435;
  long int D.5436;
  unsigned char D.5437;
  int D.5438;
  int D.5439;
  long unsigned int D.5449;
  long int D.5450;
  long unsigned int D.5451;
  long unsigned int D.5452;
  long unsigned int D.5453;
  unsigned int i;
  char * start;
  char * end;
  char * p;
  size_t bytes;
  struct hdr * hhdr;

  i = 0;
  goto <D.5234>;
  <D.5233>:
  start = GC_arrays._heap_sects[i].hs_start;
  bytes = GC_arrays._heap_sects[i].hs_bytes;
  end = start + bytes;
  goto <D.5226>;
  <D.5225>:
  i = i + 1;
  D.5412 = GC_arrays._heap_sects[i].hs_start;
  D.5413 = GC_arrays._heap_sects[i].hs_bytes;
  end = D.5412 + D.5413;
  <D.5226>:
  D.5414 = i + 1;
  GC_n_heap_sects.5 = GC_n_heap_sects;
  if (D.5414 < GC_n_heap_sects.5) goto <D.5416>; else goto <D.5227>;
  <D.5416>:
  D.5414 = i + 1;
  D.5417 = GC_arrays._heap_sects[D.5414].hs_start;
  if (D.5417 == end) goto <D.5225>; else goto <D.5227>;
  <D.5227>:
  end.6 = (long int) end;
  start.7 = (long int) start;
  GC_printf ("***Section from 0x%lx to 0x%lx\n", start.7, end.6, 0, 0, 0, 0);
  p = start;
  goto <D.5228>;
  <D.5231>:
  p.8 = (long unsigned int) p;
  D.5421 = p.8 >> 22;
  D.5422 = GC_arrays._top_index[D.5421];
  p.8 = (long unsigned int) p;
  D.5423 = p.8 >> 12;
  D.5424 = D.5423 & 1023;
  hhdr = D.5422->index[D.5424];
  p.9 = (long int) p;
  GC_printf ("\t0x%lx ", p.9, 0, 0, 0, 0, 0);
  hhdr.10 = (long unsigned int) hhdr;
  if (hhdr.10 <= 4095) goto <D.5427>; else goto <D.5428>;
  <D.5427>:
  hhdr.11 = (long int) hhdr;
  GC_printf ("Missing header!!(%ld)\n", hhdr.11, 0, 0, 0, 0, 0);
  p = p + 4096;
  // predicted unlikely by continue predictor.
  goto <D.5228>;
  <D.5428>:
  D.5430 = hhdr->hb_map;
  GC_invalid_map.12 = GC_invalid_map;
  if (D.5430 == GC_invalid_map.12) goto <D.5432>; else goto <D.5433>;
  <D.5432>:
  {
    int correct_index;
    int actual_index;

    D.5434 = hhdr->hb_sz;
    D.5435 = D.5434 >> 12;
    correct_index = GC_hblk_fl_from_blocks (D.5435);
    D.5434 = hhdr->hb_sz;
    D.5436 = (long int) D.5434;
    GC_printf ("\tfree block of size 0x%lx bytes", D.5436, 0, 0, 0, 0, 0);
    D.5437 = hhdr->hb_flags;
    D.5438 = (int) D.5437;
    D.5439 = D.5438 & 2;
    if (D.5439 == 0) goto <D.5440>; else goto <D.5441>;
    <D.5440>:
    GC_printf ("\n", 0, 0, 0, 0, 0, 0);
    goto <D.5442>;
    <D.5441>:
    GC_printf ("(unmapped)\n", 0, 0, 0, 0, 0, 0);
    <D.5442>:
    actual_index = free_list_index_of (hhdr);
    if (actual_index == -1) goto <D.5443>; else goto <D.5444>;
    <D.5443>:
    GC_printf ("\t\tBlock not on free list %ld!!\n", correct_index, 0, 0, 0, 0, 0);
    goto <D.5445>;
    <D.5444>:
    if (correct_index != actual_index) goto <D.5446>; else goto <D.5447>;
    <D.5446>:
    GC_printf ("\t\tBlock on list %ld, should be on %ld!!\n", actual_index, correct_index, 0, 0, 0, 0);
    <D.5447>:
    <D.5445>:
    D.5434 = hhdr->hb_sz;
    p = p + D.5434;
  }
  goto <D.5448>;
  <D.5433>:
  D.5434 = hhdr->hb_sz;
  D.5449 = D.5434 << 2;
  D.5450 = (long int) D.5449;
  GC_printf ("\tused for blocks of size 0x%lx bytes\n", D.5450, 0, 0, 0, 0, 0);
  D.5434 = hhdr->hb_sz;
  D.5449 = D.5434 << 2;
  D.5451 = D.5449 + 4095;
  D.5452 = D.5451 >> 12;
  D.5453 = D.5452 * 4096;
  p = p + D.5453;
  <D.5448>:
  <D.5228>:
  if (p < end) goto <D.5231>; else goto <D.5232>;
  <D.5232>:
  i = i + 1;
  <D.5234>:
  GC_n_heap_sects.5 = GC_n_heap_sects;
  if (i < GC_n_heap_sects.5) goto <D.5233>; else goto <D.5235>;
  <D.5235>:
}


GC_remove_from_fl (struct hdr * hhdr, int n)
{
  struct hblk * D.5454;
  long unsigned int D.5459;
  long unsigned int D.5460;
  struct hblk * D.5462;
  long unsigned int D.5464;
  long unsigned int D.5465;
  struct bottom_index * D.5466;
  long unsigned int D.5467;
  long unsigned int D.5468;
  long unsigned int D.5471;
  long unsigned int D.5472;
  struct bottom_index * D.5473;
  long unsigned int D.5474;
  long unsigned int D.5475;
  int index;

  D.5454 = hhdr->hb_prev;
  if (D.5454 == 0B) goto <D.5455>; else goto <D.5456>;
  <D.5455>:
  if (n == -1) goto <D.5457>; else goto <D.5458>;
  <D.5457>:
  D.5459 = hhdr->hb_sz;
  D.5460 = D.5459 >> 12;
  index = GC_hblk_fl_from_blocks (D.5460);
  goto <D.5461>;
  <D.5458>:
  index = n;
  <D.5461>:
  D.5462 = hhdr->hb_next;
  GC_hblkfreelist[index] = D.5462;
  goto <D.5463>;
  <D.5456>:
  {
    struct hdr * phdr;

    D.5454 = hhdr->hb_prev;
    D.5464 = (long unsigned int) D.5454;
    D.5465 = D.5464 >> 22;
    D.5466 = GC_arrays._top_index[D.5465];
    D.5454 = hhdr->hb_prev;
    D.5464 = (long unsigned int) D.5454;
    D.5467 = D.5464 >> 12;
    D.5468 = D.5467 & 1023;
    phdr = D.5466->index[D.5468];
    D.5462 = hhdr->hb_next;
    phdr->hb_next = D.5462;
  }
  <D.5463>:
  D.5462 = hhdr->hb_next;
  if (D.5462 != 0B) goto <D.5469>; else goto <D.5470>;
  <D.5469>:
  {
    struct hdr * nhdr;

    D.5462 = hhdr->hb_next;
    D.5471 = (long unsigned int) D.5462;
    D.5472 = D.5471 >> 22;
    D.5473 = GC_arrays._top_index[D.5472];
    D.5462 = hhdr->hb_next;
    D.5471 = (long unsigned int) D.5462;
    D.5474 = D.5471 >> 12;
    D.5475 = D.5474 & 1023;
    nhdr = D.5473->index[D.5475];
    D.5454 = hhdr->hb_prev;
    nhdr->hb_prev = D.5454;
  }
  <D.5470>:
}


GC_free_block_ending_at (struct hblk * h)
{
  long unsigned int p.13;
  long unsigned int D.5477;
  struct bottom_index * D.5478;
  long unsigned int D.5479;
  long unsigned int D.5480;
  long unsigned int phdr.14;
  long unsigned int D.5482;
  sizetype D.5483;
  _Bool D.5484;
  _Bool D.5485;
  _Bool D.5486;
  map_entry_type * D.5489;
  map_entry_type * GC_invalid_map.15;
  struct hblk * D.5493;
  struct hblk * D.5494;
  long unsigned int D.5499;
  char * D.5500;
  struct hblk * p;
  struct hdr * phdr;

  p = h + 4294963200;
  p.13 = (long unsigned int) p;
  D.5477 = p.13 >> 22;
  D.5478 = GC_arrays._top_index[D.5477];
  p.13 = (long unsigned int) p;
  D.5479 = p.13 >> 12;
  D.5480 = D.5479 & 1023;
  phdr = D.5478->index[D.5480];
  goto <D.5256>;
  <D.5255>:
  phdr.14 = (long unsigned int) phdr;
  D.5482 = phdr.14 * 4096;
  D.5483 = -D.5482;
  p = p + D.5483;
  p.13 = (long unsigned int) p;
  D.5477 = p.13 >> 22;
  D.5478 = GC_arrays._top_index[D.5477];
  p.13 = (long unsigned int) p;
  D.5479 = p.13 >> 12;
  D.5480 = D.5479 & 1023;
  phdr = D.5478->index[D.5480];
  <D.5256>:
  D.5484 = phdr != 0B;
  phdr.14 = (long unsigned int) phdr;
  D.5485 = phdr.14 <= 4095;
  D.5486 = D.5484 & D.5485;
  if (D.5486 != 0) goto <D.5255>; else goto <D.5257>;
  <D.5257>:
  if (phdr != 0B) goto <D.5487>; else goto <D.5488>;
  <D.5487>:
  D.5489 = phdr->hb_map;
  GC_invalid_map.15 = GC_invalid_map;
  if (D.5489 == GC_invalid_map.15) goto <D.5491>; else goto <D.5492>;
  <D.5491>:
  D.5493 = p;
  return D.5493;
  <D.5492>:
  D.5493 = 0B;
  return D.5493;
  <D.5488>:
  D.5494 = h + 4294963200;
  p = GC_prev_block (D.5494);
  if (p != 0B) goto <D.5495>; else goto <D.5496>;
  <D.5495>:
  p.13 = (long unsigned int) p;
  D.5477 = p.13 >> 22;
  D.5478 = GC_arrays._top_index[D.5477];
  p.13 = (long unsigned int) p;
  D.5479 = p.13 >> 12;
  D.5480 = D.5479 & 1023;
  phdr = D.5478->index[D.5480];
  D.5489 = phdr->hb_map;
  GC_invalid_map.15 = GC_invalid_map;
  if (D.5489 == GC_invalid_map.15) goto <D.5497>; else goto <D.5498>;
  <D.5497>:
  D.5499 = phdr->hb_sz;
  D.5500 = p + D.5499;
  if (D.5500 == h) goto <D.5501>; else goto <D.5502>;
  <D.5501>:
  D.5493 = p;
  return D.5493;
  <D.5502>:
  <D.5498>:
  <D.5496>:
  D.5493 = 0B;
  return D.5493;
}


GC_add_to_fl (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.5504;
  long unsigned int D.5505;
  long unsigned int second.16;
  long unsigned int D.5509;
  struct bottom_index * D.5510;
  long unsigned int D.5511;
  long unsigned int D.5512;
  int index;
  struct hblk * second;
  struct hdr * second_hdr;

  D.5504 = hhdr->hb_sz;
  D.5505 = D.5504 >> 12;
  index = GC_hblk_fl_from_blocks (D.5505);
  second = GC_hblkfreelist[index];
  GC_hblkfreelist[index] = h;
  hhdr->hb_next = second;
  hhdr->hb_prev = 0B;
  if (second != 0B) goto <D.5506>; else goto <D.5507>;
  <D.5506>:
  second.16 = (long unsigned int) second;
  D.5509 = second.16 >> 22;
  D.5510 = GC_arrays._top_index[D.5509];
  second.16 = (long unsigned int) second;
  D.5511 = second.16 >> 12;
  D.5512 = D.5511 & 1023;
  second_hdr = D.5510->index[D.5512];
  second_hdr->hb_prev = h;
  <D.5507>:
  GC_invalidate_map (hhdr);
}


GC_unmap_old ()
{
  long unsigned int h.17;
  long unsigned int D.5514;
  struct bottom_index * D.5515;
  long unsigned int D.5516;
  long unsigned int D.5517;
  unsigned char D.5518;
  int D.5519;
  int D.5520;
  long unsigned int GC_gc_no.18;
  short unsigned int D.5524;
  long unsigned int D.5527;
  long unsigned int D.5529;
  unsigned char D.5532;
  struct hblk * h;
  struct hdr * hhdr;
  word sz;
  short unsigned int last_rec;
  short unsigned int threshold;
  int i;

  i = 0;
  goto <D.5279>;
  <D.5278>:
  h = GC_hblkfreelist[i];
  goto <D.5276>;
  <D.5275>:
  h.17 = (long unsigned int) h;
  D.5514 = h.17 >> 22;
  D.5515 = GC_arrays._top_index[D.5514];
  h.17 = (long unsigned int) h;
  D.5516 = h.17 >> 12;
  D.5517 = D.5516 & 1023;
  hhdr = D.5515->index[D.5517];
  D.5518 = hhdr->hb_flags;
  D.5519 = (int) D.5518;
  D.5520 = D.5519 & 2;
  if (D.5520 != 0) goto <D.5521>; else goto <D.5522>;
  <D.5521>:
  // predicted unlikely by continue predictor.
  goto <D.5274>;
  <D.5522>:
  GC_gc_no.18 = GC_gc_no;
  D.5524 = (short unsigned int) GC_gc_no.18;
  threshold = D.5524 + 65530;
  last_rec = hhdr->hb_last_reclaimed;
  D.5527 = (long unsigned int) last_rec;
  GC_gc_no.18 = GC_gc_no;
  if (D.5527 > GC_gc_no.18) goto <D.5525>; else goto <D.5528>;
  <D.5528>:
  if (last_rec < threshold) goto <D.5525>; else goto <D.5526>;
  <D.5525>:
  D.5529 = (long unsigned int) threshold;
  GC_gc_no.18 = GC_gc_no;
  if (D.5529 < GC_gc_no.18) goto <D.5530>; else goto <D.5531>;
  <D.5530>:
  sz = hhdr->hb_sz;
  GC_unmap (h, sz);
  D.5518 = hhdr->hb_flags;
  D.5532 = D.5518 | 2;
  hhdr->hb_flags = D.5532;
  <D.5531>:
  <D.5526>:
  <D.5274>:
  h = hhdr->hb_next;
  <D.5276>:
  if (h != 0B) goto <D.5275>; else goto <D.5277>;
  <D.5277>:
  i = i + 1;
  <D.5279>:
  if (i <= 60) goto <D.5278>; else goto <D.5280>;
  <D.5280>:
}


GC_merge_unmapped ()
{
  long unsigned int h.19;
  long unsigned int D.5534;
  struct bottom_index * D.5535;
  long unsigned int D.5536;
  long unsigned int D.5537;
  long unsigned int D.5538;
  long unsigned int next.20;
  long unsigned int D.5540;
  struct bottom_index * D.5541;
  long unsigned int D.5542;
  long unsigned int D.5543;
  map_entry_type * D.5547;
  map_entry_type * GC_invalid_map.21;
  unsigned char D.5550;
  int D.5551;
  int D.5552;
  unsigned char D.5558;
  unsigned char D.5560;
  int D.5561;
  int D.5562;
  unsigned char D.5568;
  short unsigned int D.5569;
  long unsigned int D.5571;
  long unsigned int D.5572;
  long unsigned int D.5573;
  struct hblk * h;
  struct hblk * next;
  struct hdr * hhdr;
  struct hdr * nexthdr;
  word size;
  word nextsize;
  int i;

  i = 0;
  goto <D.5295>;
  <D.5294>:
  h = GC_hblkfreelist[i];
  goto <D.5292>;
  <D.5291>:
  h.19 = (long unsigned int) h;
  D.5534 = h.19 >> 22;
  D.5535 = GC_arrays._top_index[D.5534];
  h.19 = (long unsigned int) h;
  D.5536 = h.19 >> 12;
  D.5537 = D.5536 & 1023;
  hhdr = D.5535->index[D.5537];
  size = hhdr->hb_sz;
  h.19 = (long unsigned int) h;
  D.5538 = h.19 + size;
  next = (struct hblk *) D.5538;
  next.20 = (long unsigned int) next;
  D.5540 = next.20 >> 22;
  D.5541 = GC_arrays._top_index[D.5540];
  next.20 = (long unsigned int) next;
  D.5542 = next.20 >> 12;
  D.5543 = D.5542 & 1023;
  nexthdr = D.5541->index[D.5543];
  if (nexthdr != 0B) goto <D.5546>; else goto <D.5544>;
  <D.5546>:
  D.5547 = nexthdr->hb_map;
  GC_invalid_map.21 = GC_invalid_map;
  if (D.5547 == GC_invalid_map.21) goto <D.5549>; else goto <D.5544>;
  <D.5549>:
  nextsize = nexthdr->hb_sz;
  D.5550 = hhdr->hb_flags;
  D.5551 = (int) D.5550;
  D.5552 = D.5551 & 2;
  if (D.5552 == 0) goto <D.5553>; else goto <D.5554>;
  <D.5553>:
  if (size > nextsize) goto <D.5555>; else goto <D.5556>;
  <D.5555>:
  GC_remap (next, nextsize);
  goto <D.5557>;
  <D.5556>:
  GC_unmap (h, size);
  D.5550 = hhdr->hb_flags;
  D.5558 = D.5550 | 2;
  hhdr->hb_flags = D.5558;
  <D.5557>:
  goto <D.5559>;
  <D.5554>:
  D.5560 = nexthdr->hb_flags;
  D.5561 = (int) D.5560;
  D.5562 = D.5561 & 2;
  if (D.5562 == 0) goto <D.5563>; else goto <D.5564>;
  <D.5563>:
  if (size > nextsize) goto <D.5565>; else goto <D.5566>;
  <D.5565>:
  GC_unmap (next, nextsize);
  goto <D.5567>;
  <D.5566>:
  GC_remap (h, size);
  D.5550 = hhdr->hb_flags;
  D.5568 = D.5550 & 253;
  hhdr->hb_flags = D.5568;
  D.5569 = nexthdr->hb_last_reclaimed;
  hhdr->hb_last_reclaimed = D.5569;
  <D.5567>:
  goto <D.5570>;
  <D.5564>:
  D.5571 = nexthdr->hb_sz;
  GC_unmap_gap (h, size, next, D.5571);
  <D.5570>:
  <D.5559>:
  GC_remove_from_fl (hhdr, i);
  GC_remove_from_fl (nexthdr, -1);
  D.5572 = hhdr->hb_sz;
  D.5571 = nexthdr->hb_sz;
  D.5573 = D.5572 + D.5571;
  hhdr->hb_sz = D.5573;
  GC_remove_header (next);
  GC_add_to_fl (h, hhdr);
  h = GC_hblkfreelist[i];
  goto <D.5545>;
  <D.5544>:
  h = hhdr->hb_next;
  <D.5545>:
  <D.5292>:
  if (h != 0B) goto <D.5291>; else goto <D.5293>;
  <D.5293>:
  i = i + 1;
  <D.5295>:
  if (i <= 60) goto <D.5294>; else goto <D.5296>;
  <D.5296>:
}


GC_get_first_part (struct hblk * h, struct hdr * hhdr, word bytes, int index)
{
  struct hblk * D.5576;
  long unsigned int h.22;
  long unsigned int D.5578;
  void (*<T6b5>) (char *, GC_word) GC_current_warn_proc.23;
  long unsigned int D.5582;
  word total_size;
  struct hblk * rest;
  struct hdr * rest_hdr;

  total_size = hhdr->hb_sz;
  GC_remove_from_fl (hhdr, index);
  if (total_size == bytes) goto <D.5574>; else goto <D.5575>;
  <D.5574>:
  D.5576 = h;
  return D.5576;
  <D.5575>:
  h.22 = (long unsigned int) h;
  D.5578 = h.22 + bytes;
  rest = (struct hblk *) D.5578;
  rest_hdr = GC_install_header (rest);
  if (rest_hdr == 0B) goto <D.5579>; else goto <D.5580>;
  <D.5579>:
  GC_current_warn_proc.23 = GC_current_warn_proc;
  GC_current_warn_proc.23 ("GC Warning: Header allocation failed: Dropping block.\n", 0);
  D.5576 = 0B;
  return D.5576;
  <D.5580>:
  D.5582 = total_size - bytes;
  rest_hdr->hb_sz = D.5582;
  rest_hdr->hb_flags = 0;
  GC_add_to_fl (rest, rest_hdr);
  D.5576 = h;
  return D.5576;
}


GC_split_block (struct hblk * h, struct hdr * hhdr, struct hblk * n, struct hdr * nhdr, int index)
{
  long unsigned int n.24;
  long unsigned int h.25;
  long unsigned int D.5586;
  long unsigned int prev.26;
  long unsigned int D.5590;
  struct bottom_index * D.5591;
  long unsigned int D.5592;
  long unsigned int D.5593;
  struct hdr * D.5594;
  long unsigned int next.27;
  long unsigned int D.5599;
  struct bottom_index * D.5600;
  long unsigned int D.5601;
  long unsigned int D.5602;
  struct hdr * D.5603;
  long unsigned int GC_gc_no.28;
  short unsigned int D.5605;
  word total_size;
  word h_size;
  struct hblk * prev;
  struct hblk * next;

  total_size = hhdr->hb_sz;
  n.24 = (long unsigned int) n;
  h.25 = (long unsigned int) h;
  h_size = n.24 - h.25;
  prev = hhdr->hb_prev;
  next = hhdr->hb_next;
  nhdr->hb_prev = prev;
  nhdr->hb_next = next;
  D.5586 = total_size - h_size;
  nhdr->hb_sz = D.5586;
  nhdr->hb_flags = 0;
  if (prev != 0B) goto <D.5587>; else goto <D.5588>;
  <D.5587>:
  prev.26 = (long unsigned int) prev;
  D.5590 = prev.26 >> 22;
  D.5591 = GC_arrays._top_index[D.5590];
  prev.26 = (long unsigned int) prev;
  D.5592 = prev.26 >> 12;
  D.5593 = D.5592 & 1023;
  D.5594 = D.5591->index[D.5593];
  D.5594->hb_next = n;
  goto <D.5595>;
  <D.5588>:
  GC_hblkfreelist[index] = n;
  <D.5595>:
  if (next != 0B) goto <D.5596>; else goto <D.5597>;
  <D.5596>:
  next.27 = (long unsigned int) next;
  D.5599 = next.27 >> 22;
  D.5600 = GC_arrays._top_index[D.5599];
  next.27 = (long unsigned int) next;
  D.5601 = next.27 >> 12;
  D.5602 = D.5601 & 1023;
  D.5603 = D.5600->index[D.5602];
  D.5603->hb_prev = n;
  <D.5597>:
  GC_gc_no.28 = GC_gc_no;
  D.5605 = (short unsigned int) GC_gc_no.28;
  hhdr->hb_last_reclaimed = D.5605;
  hhdr->hb_sz = h_size;
  GC_add_to_fl (h, hhdr);
  GC_invalidate_map (nhdr);
}


GC_allochblk (word sz, int kind, unsigned int flags)
{
  long unsigned int D.5606;
  long unsigned int D.5607;
  struct hblk * D.5610;
  word blocks;
  int start_list;
  int i;

  D.5606 = sz << 2;
  D.5607 = D.5606 + 4095;
  blocks = D.5607 >> 12;
  start_list = GC_hblk_fl_from_blocks (blocks);
  i = start_list;
  goto <D.5328>;
  <D.5327>:
  {
    struct hblk * result;

    result = GC_allochblk_nth (sz, kind, flags, i);
    if (result != 0B) goto <D.5608>; else goto <D.5609>;
    <D.5608>:
    D.5610 = result;
    return D.5610;
    <D.5609>:
  }
  i = i + 1;
  <D.5328>:
  if (i <= 60) goto <D.5327>; else goto <D.5329>;
  <D.5329>:
  D.5610 = 0B;
  return D.5610;
}


GC_allochblk_nth (word sz, int kind, unsigned char flags, int n)
{
  long unsigned int D.5612;
  long unsigned int D.5613;
  long unsigned int D.5614;
  long unsigned int D.5615;
  long unsigned int hbp.29;
  long unsigned int D.5617;
  struct bottom_index * D.5618;
  long unsigned int D.5619;
  long unsigned int D.5620;
  long unsigned int D.5621;
  int GC_use_entire_heap.30;
  int GC_dont_gc.31;
  long unsigned int D.5634;
  long unsigned int D.5635;
  long unsigned int D.5636;
  long unsigned int D.5637;
  int GC_incremental.32;
  long unsigned int GC_time_limit.33;
  int D.5643;
  long unsigned int thishbp.34;
  long unsigned int D.5649;
  struct bottom_index * D.5650;
  long unsigned int D.5651;
  long unsigned int D.5652;
  long unsigned int D.5653;
  _Bool D.5654;
  _Bool D.5655;
  _Bool D.5656;
  long unsigned int size_needed.35;
  struct hblk * D.5660;
  int D.5663;
  _Bool D.5666;
  _Bool D.5667;
  _Bool D.5668;
  sizetype size_avail.36;
  sizetype size_needed.37;
  sizetype D.5673;
  signed_word iftmp.38;
  int D.5675;
  int D.5676;
  long unsigned int eff_size_needed.39;
  int hbp.40;
  int lasthbp.41;
  int D.5684;
  unsigned char D.5691;
  int D.5692;
  int D.5693;
  unsigned char D.5696;
  long unsigned int GC_black_list_spacing.42;
  long int GC_black_list_spacing.43;
  long int D.5703;
  long int GC_large_alloc_warn_suppressed.44;
  long int GC_large_alloc_warn_suppressed.45;
  long int GC_large_alloc_warn_interval.46;
  void (*<T6b5>) (char *, GC_word) GC_current_warn_proc.47;
  _Bool D.5711;
  _Bool D.5712;
  _Bool D.5713;
  int GC_find_leak.48;
  unsigned int count.49;
  unsigned int count.50;
  unsigned int D.5723;
  long unsigned int D.5726;
  long unsigned int D.5727;
  long unsigned int D.5728;
  long unsigned int D.5729;
  long unsigned int D.5730;
  long unsigned int D.5731;
  int GC_debugging_started.51;
  struct hblk * D.5740;
  int D.5747;
  int D.5750;
  long unsigned int D.5753;
  _Bool D.5754;
  int D.5755;
  long int D.5756;
  long unsigned int D.5757;
  long unsigned int D.5758;
  register struct hblk * hbp;
  register struct hdr * hhdr;
  register struct hblk * thishbp;
  register struct hdr * thishdr;
  signed_word size_needed;
  signed_word size_avail;

  D.5612 = sz << 2;
  D.5613 = D.5612 + 4095;
  D.5614 = D.5613 >> 12;
  D.5615 = D.5614 * 4096;
  size_needed = (signed_word) D.5615;
  hbp = GC_hblkfreelist[n];
  goto <D.5361>;
  <D.5360>:
  hbp.29 = (long unsigned int) hbp;
  D.5617 = hbp.29 >> 22;
  D.5618 = GC_arrays._top_index[D.5617];
  hbp.29 = (long unsigned int) hbp;
  D.5619 = hbp.29 >> 12;
  D.5620 = D.5619 & 1023;
  hhdr = D.5618->index[D.5620];
  D.5621 = hhdr->hb_sz;
  size_avail = (signed_word) D.5621;
  if (size_avail < size_needed) goto <D.5622>; else goto <D.5623>;
  <D.5622>:
  // predicted unlikely by continue predictor.
  goto <D.5342>;
  <D.5623>:
  if (size_avail != size_needed) goto <D.5626>; else goto <D.5627>;
  <D.5626>:
  GC_use_entire_heap.30 = GC_use_entire_heap;
  if (GC_use_entire_heap.30 == 0) goto <D.5629>; else goto <D.5630>;
  <D.5629>:
  GC_dont_gc.31 = GC_dont_gc;
  if (GC_dont_gc.31 == 0) goto <D.5632>; else goto <D.5633>;
  <D.5632>:
  D.5634 = GC_arrays._heapsize;
  D.5635 = GC_arrays._large_free_bytes;
  D.5636 = D.5634 - D.5635;
  D.5637 = GC_arrays._requested_heapsize;
  if (D.5636 >= D.5637) goto <D.5638>; else goto <D.5639>;
  <D.5638>:
  GC_incremental.32 = GC_incremental;
  if (GC_incremental.32 == 0) goto <D.5624>; else goto <D.5641>;
  <D.5641>:
  GC_time_limit.33 = GC_time_limit;
  if (GC_time_limit.33 == 999999) goto <D.5624>; else goto <D.5625>;
  <D.5624>:
  D.5643 = GC_should_collect ();
  if (D.5643 != 0) goto <D.5644>; else goto <D.5645>;
  <D.5644>:
  // predicted unlikely by continue predictor.
  goto <D.5342>;
  <D.5645>:
  <D.5625>:
  <D.5639>:
  <D.5633>:
  <D.5630>:
  <D.5627>:
  {
    signed_word next_size;

    thishbp = hhdr->hb_next;
    if (thishbp != 0B) goto <D.5646>; else goto <D.5647>;
    <D.5646>:
    thishbp.34 = (long unsigned int) thishbp;
    D.5649 = thishbp.34 >> 22;
    D.5650 = GC_arrays._top_index[D.5649];
    thishbp.34 = (long unsigned int) thishbp;
    D.5651 = thishbp.34 >> 12;
    D.5652 = D.5651 & 1023;
    thishdr = D.5650->index[D.5652];
    D.5653 = thishdr->hb_sz;
    next_size = (signed_word) D.5653;
    D.5654 = next_size < size_avail;
    D.5655 = next_size >= size_needed;
    D.5656 = D.5654 & D.5655;
    if (D.5656 != 0) goto <D.5657>; else goto <D.5658>;
    <D.5657>:
    size_needed.35 = (long unsigned int) size_needed;
    D.5660 = GC_is_black_listed (thishbp, size_needed.35);
    if (D.5660 == 0B) goto <D.5661>; else goto <D.5662>;
    <D.5661>:
    // predicted unlikely by continue predictor.
    goto <D.5342>;
    <D.5662>:
    <D.5658>:
    <D.5647>:
  }
  D.5663 = kind & -2;
  if (D.5663 != 2) goto <D.5664>; else goto <D.5665>;
  <D.5664>:
  D.5666 = kind != 0;
  size_needed.35 = (long unsigned int) size_needed;
  D.5667 = size_needed.35 > 8192;
  D.5668 = D.5666 | D.5667;
  if (D.5668 != 0) goto <D.5669>; else goto <D.5670>;
  <D.5669>:
  {
    struct hblk * lasthbp;
    char * search_end;
    signed_word orig_avail;
    signed_word eff_size_needed;

    lasthbp = hbp;
    size_avail.36 = (sizetype) size_avail;
    size_needed.37 = (sizetype) size_needed;
    D.5673 = size_avail.36 - size_needed.37;
    search_end = hbp + D.5673;
    orig_avail = size_avail;
    D.5675 = (int) flags;
    D.5676 = D.5675 & 1;
    if (D.5676 == 0) goto <D.5677>; else goto <D.5678>;
    <D.5677>:
    iftmp.38 = size_needed;
    goto <D.5679>;
    <D.5678>:
    iftmp.38 = 4096;
    <D.5679>:
    eff_size_needed = iftmp.38;
    goto <D.5349>;
    <D.5348>:
    lasthbp = thishbp;
    <D.5349>:
    if (lasthbp <= search_end) goto <D.5680>; else goto <D.5350>;
    <D.5680>:
    eff_size_needed.39 = (long unsigned int) eff_size_needed;
    thishbp = GC_is_black_listed (lasthbp, eff_size_needed.39);
    if (thishbp != 0B) goto <D.5348>; else goto <D.5350>;
    <D.5350>:
    hbp.40 = (int) hbp;
    lasthbp.41 = (int) lasthbp;
    D.5684 = hbp.40 - lasthbp.41;
    size_avail = D.5684 + size_avail;
    thishbp = lasthbp;
    if (size_avail >= size_needed) goto <D.5685>; else goto <D.5686>;
    <D.5685>:
    if (thishbp != hbp) goto <D.5687>; else goto <D.5688>;
    <D.5687>:
    thishdr = GC_install_header (thishbp);
    if (thishdr != 0B) goto <D.5689>; else goto <D.5690>;
    <D.5689>:
    D.5691 = hhdr->hb_flags;
    D.5692 = (int) D.5691;
    D.5693 = D.5692 & 2;
    if (D.5693 != 0) goto <D.5694>; else goto <D.5695>;
    <D.5694>:
    D.5621 = hhdr->hb_sz;
    GC_remap (hbp, D.5621);
    D.5691 = hhdr->hb_flags;
    D.5696 = D.5691 & 253;
    hhdr->hb_flags = D.5696;
    <D.5695>:
    GC_split_block (hbp, hhdr, thishbp, thishdr, n);
    hbp = thishbp;
    hhdr = thishdr;
    <D.5690>:
    <D.5688>:
    goto <D.5697>;
    <D.5686>:
    GC_black_list_spacing.42 = GC_black_list_spacing;
    GC_black_list_spacing.43 = (long int) GC_black_list_spacing.42;
    if (GC_black_list_spacing.43 < size_needed) goto <D.5702>; else goto <D.5698>;
    <D.5702>:
    D.5703 = orig_avail - size_needed;
    GC_black_list_spacing.42 = GC_black_list_spacing;
    GC_black_list_spacing.43 = (long int) GC_black_list_spacing.42;
    if (D.5703 > GC_black_list_spacing.43) goto <D.5704>; else goto <D.5698>;
    <D.5704>:
    GC_large_alloc_warn_suppressed.44 = GC_large_alloc_warn_suppressed;
    GC_large_alloc_warn_suppressed.45 = GC_large_alloc_warn_suppressed.44 + 1;
    GC_large_alloc_warn_suppressed = GC_large_alloc_warn_suppressed.45;
    GC_large_alloc_warn_suppressed.44 = GC_large_alloc_warn_suppressed;
    GC_large_alloc_warn_interval.46 = GC_large_alloc_warn_interval;
    if (GC_large_alloc_warn_suppressed.44 >= GC_large_alloc_warn_interval.46) goto <D.5708>; else goto <D.5709>;
    <D.5708>:
    GC_current_warn_proc.47 = GC_current_warn_proc;
    size_needed.35 = (long unsigned int) size_needed;
    GC_current_warn_proc.47 ("GC Warning: Repeated allocation of very large block (appr. size %ld):\n\tMay lead to memory leak and poor performance.\n", size_needed.35);
    GC_large_alloc_warn_suppressed = 0;
    <D.5709>:
    size_avail = orig_avail;
    goto <D.5699>;
    <D.5698>:
    D.5711 = size_avail == 0;
    D.5712 = size_needed == 4096;
    D.5713 = D.5711 & D.5712;
    if (D.5713 != 0) goto <D.5714>; else goto <D.5715>;
    <D.5714>:
    D.5691 = hhdr->hb_flags;
    D.5692 = (int) D.5691;
    D.5693 = D.5692 & 2;
    if (D.5693 == 0) goto <D.5716>; else goto <D.5717>;
    <D.5716>:
    GC_find_leak.48 = GC_find_leak;
    if (GC_find_leak.48 == 0) goto <D.5719>; else goto <D.5720>;
    <D.5719>:
    {
      static unsigned int count = 0;

      count.49 = count;
      count.50 = count.49 + 1;
      count = count.50;
      count.49 = count;
      D.5723 = count.49 & 3;
      if (D.5723 == 0) goto <D.5724>; else goto <D.5725>;
      <D.5724>:
      {
        word total_size;
        struct hblk * limit;
        struct hblk * h;
        struct hblk * prev;

        total_size = hhdr->hb_sz;
        D.5726 = total_size >> 12;
        D.5727 = D.5726 * 4096;
        limit = hbp + D.5727;
        prev = hhdr->hb_prev;
        D.5728 = GC_arrays._words_wasted;
        D.5729 = total_size >> 2;
        D.5730 = D.5728 + D.5729;
        GC_arrays._words_wasted = D.5730;
        D.5635 = GC_arrays._large_free_bytes;
        D.5731 = D.5635 - total_size;
        GC_arrays._large_free_bytes = D.5731;
        GC_remove_from_fl (hhdr, n);
        h = hbp;
        goto <D.5357>;
        <D.5356>:
        if (h == hbp) goto <D.5732>; else goto <D.5734>;
        <D.5734>:
        hhdr = GC_install_header (h);
        if (hhdr != 0B) goto <D.5732>; else goto <D.5733>;
        <D.5732>:
        setup_header (hhdr, 1024, 0, 0);
        GC_debugging_started.51 = GC_debugging_started;
        if (GC_debugging_started.51 != 0) goto <D.5736>; else goto <D.5737>;
        <D.5736>:
        memset (h, 0, 4096);
        <D.5737>:
        <D.5733>:
        h = h + 4096;
        <D.5357>:
        if (h < limit) goto <D.5356>; else goto <D.5358>;
        <D.5358>:
        hbp = prev;
        if (hbp == 0B) goto <D.5738>; else goto <D.5739>;
        <D.5738>:
        D.5675 = (int) flags;
        D.5740 = GC_allochblk_nth (sz, kind, D.5675, n);
        return D.5740;
        <D.5739>:
        hbp.29 = (long unsigned int) hbp;
        D.5617 = hbp.29 >> 22;
        D.5618 = GC_arrays._top_index[D.5617];
        hbp.29 = (long unsigned int) hbp;
        D.5619 = hbp.29 >> 12;
        D.5620 = D.5619 & 1023;
        hhdr = D.5618->index[D.5620];
      }
      <D.5725>:
    }
    <D.5720>:
    <D.5717>:
    <D.5715>:
    <D.5699>:
    <D.5697>:
  }
  <D.5670>:
  <D.5665>:
  if (size_avail >= size_needed) goto <D.5741>; else goto <D.5742>;
  <D.5741>:
  D.5691 = hhdr->hb_flags;
  D.5692 = (int) D.5691;
  D.5693 = D.5692 & 2;
  if (D.5693 != 0) goto <D.5743>; else goto <D.5744>;
  <D.5743>:
  D.5621 = hhdr->hb_sz;
  GC_remap (hbp, D.5621);
  D.5691 = hhdr->hb_flags;
  D.5696 = D.5691 & 253;
  hhdr->hb_flags = D.5696;
  <D.5744>:
  hbp = GC_get_first_part (hbp, hhdr, size_needed, n);
  goto <D.5359>;
  <D.5742>:
  <D.5342>:
  hbp = hhdr->hb_next;
  <D.5361>:
  if (hbp != 0B) goto <D.5360>; else goto <D.5359>;
  <D.5359>:
  if (hbp == 0B) goto <D.5745>; else goto <D.5746>;
  <D.5745>:
  D.5740 = 0B;
  return D.5740;
  <D.5746>:
  size_needed.35 = (long unsigned int) size_needed;
  D.5747 = GC_install_counts (hbp, size_needed.35);
  if (D.5747 == 0) goto <D.5748>; else goto <D.5749>;
  <D.5748>:
  D.5740 = 0B;
  return D.5740;
  <D.5749>:
  D.5675 = (int) flags;
  D.5750 = setup_header (hhdr, sz, kind, D.5675);
  if (D.5750 == 0) goto <D.5751>; else goto <D.5752>;
  <D.5751>:
  size_needed.35 = (long unsigned int) size_needed;
  GC_remove_counts (hbp, size_needed.35);
  D.5740 = 0B;
  return D.5740;
  <D.5752>:
  D.5753 = hhdr->hb_descr;
  D.5754 = D.5753 == 0;
  D.5755 = (int) D.5754;
  D.5756 = size_needed >> 12;
  D.5757 = (long unsigned int) D.5756;
  GC_remove_protection (hbp, D.5757, D.5755);
  {
    extern unsigned int GC_fail_count;

    GC_fail_count = 0;
  }
  D.5635 = GC_arrays._large_free_bytes;
  size_needed.35 = (long unsigned int) size_needed;
  D.5758 = D.5635 - size_needed.35;
  GC_arrays._large_free_bytes = D.5758;
  D.5740 = hbp;
  return D.5740;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5762;
  int D.5767;
  void * D.5769;
  unsigned int D.5770;

  D.5762 = __builtin_constant_p (__len);
  if (D.5762 != 0) goto <D.5763>; else goto <D.5764>;
  <D.5763>:
  if (__len == 0) goto <D.5765>; else goto <D.5766>;
  <D.5765>:
  D.5767 = __builtin_constant_p (__ch);
  if (D.5767 == 0) goto <D.5760>; else goto <D.5768>;
  <D.5768>:
  if (__ch != 0) goto <D.5760>; else goto <D.5761>;
  <D.5760>:
  __warn_memset_zero_len ();
  D.5769 = __dest;
  return D.5769;
  <D.5761>:
  <D.5766>:
  <D.5764>:
  D.5770 = __builtin_object_size (__dest, 0);
  D.5769 = __builtin___memset_chk (__dest, __ch, __len, D.5770);
  return D.5769;
}


setup_header (struct hdr * hhdr, word sz, int kind, unsigned char flags)
{
  int D.5772;
  GC_bool D.5775;
  long unsigned int iftmp.52;
  map_entry_type * D.5780;
  unsigned char D.5781;
  int D.5782;
  long unsigned int D.5785;
  long unsigned int GC_gc_no.53;
  short unsigned int D.5787;
  register word descr;

  D.5772 = GC_add_map_entry (sz);
  if (D.5772 == 0) goto <D.5773>; else goto <D.5774>;
  <D.5773>:
  D.5775 = 0;
  return D.5775;
  <D.5774>:
  if (sz <= 512) goto <D.5777>; else goto <D.5778>;
  <D.5777>:
  iftmp.52 = sz;
  goto <D.5779>;
  <D.5778>:
  iftmp.52 = 0;
  <D.5779>:
  D.5780 = GC_arrays._obj_map[iftmp.52];
  hhdr->hb_map = D.5780;
  hhdr->hb_sz = sz;
  D.5781 = (unsigned char) kind;
  hhdr->hb_obj_kind = D.5781;
  hhdr->hb_flags = flags;
  descr = GC_obj_kinds[kind].ok_descriptor;
  D.5782 = GC_obj_kinds[kind].ok_relocate_descr;
  if (D.5782 != 0) goto <D.5783>; else goto <D.5784>;
  <D.5783>:
  D.5785 = sz << 2;
  descr = D.5785 + descr;
  <D.5784>:
  hhdr->hb_descr = descr;
  GC_clear_hdr_marks (hhdr);
  GC_gc_no.53 = GC_gc_no;
  D.5787 = (short unsigned int) GC_gc_no.53;
  hhdr->hb_last_reclaimed = D.5787;
  D.5775 = 1;
  return D.5775;
}


GC_freehblk (struct hblk * hbp)
{
  long unsigned int hbp.54;
  long unsigned int D.5790;
  struct bottom_index * D.5791;
  long unsigned int D.5792;
  long unsigned int D.5793;
  long unsigned int D.5794;
  long int D.5795;
  long unsigned int D.5796;
  long unsigned int D.5797;
  long unsigned int D.5798;
  long unsigned int D.5799;
  long unsigned int size.55;
  long unsigned int size.56;
  long unsigned int GC_gc_no.57;
  short unsigned int D.5803;
  map_entry_type * D.5804;
  map_entry_type * GC_invalid_map.58;
  long int hbp.59;
  long unsigned int D.5809;
  long unsigned int next.60;
  long unsigned int D.5811;
  struct bottom_index * D.5812;
  long unsigned int D.5813;
  long unsigned int D.5814;
  map_entry_type * D.5817;
  unsigned char D.5820;
  int D.5821;
  int D.5822;
  long unsigned int D.5825;
  long unsigned int D.5826;
  long unsigned int prev.61;
  long unsigned int D.5830;
  struct bottom_index * D.5831;
  long unsigned int D.5832;
  long unsigned int D.5833;
  unsigned char D.5834;
  int D.5835;
  int D.5836;
  long unsigned int D.5839;
  long unsigned int D.5840;
  long unsigned int D.5841;
  long unsigned int D.5842;
  struct hblk * next;
  struct hblk * prev;
  struct hdr * hhdr;
  struct hdr * prevhdr;
  struct hdr * nexthdr;
  signed_word size;

  hbp.54 = (long unsigned int) hbp;
  D.5790 = hbp.54 >> 22;
  D.5791 = GC_arrays._top_index[D.5790];
  hbp.54 = (long unsigned int) hbp;
  D.5792 = hbp.54 >> 12;
  D.5793 = D.5792 & 1023;
  hhdr = D.5791->index[D.5793];
  D.5794 = hhdr->hb_sz;
  size = (signed_word) D.5794;
  D.5795 = size << 2;
  D.5796 = (long unsigned int) D.5795;
  D.5797 = D.5796 + 4095;
  D.5798 = D.5797 >> 12;
  D.5799 = D.5798 * 4096;
  size = (signed_word) D.5799;
  size.55 = (long unsigned int) size;
  GC_remove_counts (hbp, size.55);
  size.56 = (long unsigned int) size;
  hhdr->hb_sz = size.56;
  GC_gc_no.57 = GC_gc_no;
  D.5803 = (short unsigned int) GC_gc_no.57;
  hhdr->hb_last_reclaimed = D.5803;
  D.5804 = hhdr->hb_map;
  GC_invalid_map.58 = GC_invalid_map;
  if (D.5804 == GC_invalid_map.58) goto <D.5806>; else goto <D.5807>;
  <D.5806>:
  hbp.59 = (long int) hbp;
  GC_printf ("Duplicate large block deallocation of 0x%lx\n", hbp.59, 0, 0, 0, 0, 0);
  GC_abort ("Duplicate large block deallocation");
  <D.5807>:
  GC_invalidate_map (hhdr);
  hbp.54 = (long unsigned int) hbp;
  size.55 = (long unsigned int) size;
  D.5809 = hbp.54 + size.55;
  next = (struct hblk *) D.5809;
  next.60 = (long unsigned int) next;
  D.5811 = next.60 >> 22;
  D.5812 = GC_arrays._top_index[D.5811];
  next.60 = (long unsigned int) next;
  D.5813 = next.60 >> 12;
  D.5814 = D.5813 & 1023;
  nexthdr = D.5812->index[D.5814];
  prev = GC_free_block_ending_at (hbp);
  if (nexthdr != 0B) goto <D.5815>; else goto <D.5816>;
  <D.5815>:
  D.5817 = nexthdr->hb_map;
  GC_invalid_map.58 = GC_invalid_map;
  if (D.5817 == GC_invalid_map.58) goto <D.5818>; else goto <D.5819>;
  <D.5818>:
  D.5820 = nexthdr->hb_flags;
  D.5821 = (int) D.5820;
  D.5822 = D.5821 & 2;
  if (D.5822 == 0) goto <D.5823>; else goto <D.5824>;
  <D.5823>:
  GC_remove_from_fl (nexthdr, -1);
  D.5794 = hhdr->hb_sz;
  D.5825 = nexthdr->hb_sz;
  D.5826 = D.5794 + D.5825;
  hhdr->hb_sz = D.5826;
  GC_remove_header (next);
  <D.5824>:
  <D.5819>:
  <D.5816>:
  if (prev != 0B) goto <D.5827>; else goto <D.5828>;
  <D.5827>:
  prev.61 = (long unsigned int) prev;
  D.5830 = prev.61 >> 22;
  D.5831 = GC_arrays._top_index[D.5830];
  prev.61 = (long unsigned int) prev;
  D.5832 = prev.61 >> 12;
  D.5833 = D.5832 & 1023;
  prevhdr = D.5831->index[D.5833];
  D.5834 = prevhdr->hb_flags;
  D.5835 = (int) D.5834;
  D.5836 = D.5835 & 2;
  if (D.5836 == 0) goto <D.5837>; else goto <D.5838>;
  <D.5837>:
  GC_remove_from_fl (prevhdr, -1);
  D.5839 = prevhdr->hb_sz;
  D.5794 = hhdr->hb_sz;
  D.5840 = D.5839 + D.5794;
  prevhdr->hb_sz = D.5840;
  GC_gc_no.57 = GC_gc_no;
  D.5803 = (short unsigned int) GC_gc_no.57;
  prevhdr->hb_last_reclaimed = D.5803;
  GC_remove_header (hbp);
  hbp = prev;
  hhdr = prevhdr;
  <D.5838>:
  <D.5828>:
  D.5841 = GC_arrays._large_free_bytes;
  size.55 = (long unsigned int) size;
  D.5842 = D.5841 + size.55;
  GC_arrays._large_free_bytes = D.5842;
  GC_add_to_fl (hbp, hhdr);
}