GC_hblk_fl_from_blocks (word blocks_needed)
{
  int D.5313;
  long unsigned int D.5316;
  long unsigned int D.5317;
  long unsigned int D.5318;

  if (blocks_needed <= 32) goto <D.5311>; else goto <D.5312>;
  <D.5311>:
  D.5313 = (int) blocks_needed;
  return D.5313;
  <D.5312>:
  if (blocks_needed > 255) goto <D.5314>; else goto <D.5315>;
  <D.5314>:
  D.5313 = 60;
  return D.5313;
  <D.5315>:
  D.5316 = blocks_needed + 4294967264;
  D.5317 = D.5316 / 8;
  D.5318 = D.5317 + 32;
  D.5313 = (int) D.5318;
  return D.5313;
}


GC_print_hblkfreelist ()
{
  long unsigned int h.0;
  long unsigned int D.5323;
  struct bottom_index * D.5324;
  long unsigned int D.5325;
  long unsigned int D.5326;
  long int h.1;
  long int sz.2;
  struct hblk * D.5329;
  long unsigned int D.5333;
  struct hblk * D.5334;
  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.5139>;
  <D.5138>:
  h = GC_hblkfreelist[i];
  if (h != 0B) goto <D.5320>; else goto <D.5321>;
  <D.5320>:
  GC_printf ("Free list %ld:\n", i, 0, 0, 0, 0, 0);
  <D.5321>:
  goto <D.5136>;
  <D.5135>:
  h.0 = (long unsigned int) h;
  D.5323 = h.0 >> 22;
  D.5324 = GC_arrays._top_index[D.5323];
  h.0 = (long unsigned int) h;
  D.5325 = h.0 >> 12;
  D.5326 = D.5325 & 1023;
  hhdr = D.5324->index[D.5326];
  sz = hhdr->hb_sz;
  h.1 = (long int) h;
  sz.2 = (long int) sz;
  GC_printf ("\t0x%lx size %lu ", h.1, sz.2, 0, 0, 0, 0);
  total_free = total_free + sz;
  D.5329 = GC_is_black_listed (h, 4096);
  if (D.5329 != 0B) goto <D.5330>; else goto <D.5331>;
  <D.5330>:
  GC_printf ("start black listed\n", 0, 0, 0, 0, 0, 0);
  goto <D.5332>;
  <D.5331>:
  D.5333 = hhdr->hb_sz;
  D.5334 = GC_is_black_listed (h, D.5333);
  if (D.5334 != 0B) goto <D.5335>; else goto <D.5336>;
  <D.5335>:
  GC_printf ("partially black listed\n", 0, 0, 0, 0, 0, 0);
  goto <D.5337>;
  <D.5336>:
  GC_printf ("not black listed\n", 0, 0, 0, 0, 0, 0);
  <D.5337>:
  <D.5332>:
  h = hhdr->hb_next;
  <D.5136>:
  if (h != 0B) goto <D.5135>; else goto <D.5137>;
  <D.5137>:
  i = i + 1;
  <D.5139>:
  if (i <= 60) goto <D.5138>; else goto <D.5140>;
  <D.5140>:
  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.5340;
  struct bottom_index * D.5341;
  long unsigned int D.5342;
  long unsigned int D.5343;
  int D.5346;
  struct hblk * h;
  struct hdr * hhdr;
  int i;

  i = 0;
  goto <D.5151>;
  <D.5150>:
  h = GC_hblkfreelist[i];
  goto <D.5148>;
  <D.5147>:
  h.4 = (long unsigned int) h;
  D.5340 = h.4 >> 22;
  D.5341 = GC_arrays._top_index[D.5340];
  h.4 = (long unsigned int) h;
  D.5342 = h.4 >> 12;
  D.5343 = D.5342 & 1023;
  hhdr = D.5341->index[D.5343];
  if (hhdr == wanted) goto <D.5344>; else goto <D.5345>;
  <D.5344>:
  D.5346 = i;
  return D.5346;
  <D.5345>:
  h = hhdr->hb_next;
  <D.5148>:
  if (h != 0B) goto <D.5147>; else goto <D.5149>;
  <D.5149>:
  i = i + 1;
  <D.5151>:
  if (i <= 60) goto <D.5150>; else goto <D.5152>;
  <D.5152>:
  D.5346 = -1;
  return D.5346;
}


GC_dump_regions ()
{
  char * D.5348;
  long unsigned int D.5349;
  unsigned int D.5350;
  long unsigned int GC_n_heap_sects.5;
  char * D.5353;
  long int start.6;
  long int end.7;
  long unsigned int p.8;
  long unsigned int D.5357;
  struct bottom_index * D.5358;
  long unsigned int D.5359;
  long unsigned int D.5360;
  long int p.9;
  long unsigned int hhdr.10;
  long int hhdr.11;
  map_entry_type * D.5366;
  map_entry_type * GC_invalid_map.12;
  long unsigned int D.5370;
  long unsigned int D.5371;
  long int D.5372;
  unsigned char D.5373;
  int D.5374;
  int D.5375;
  long unsigned int D.5385;
  long int D.5386;
  long unsigned int D.5387;
  long unsigned int D.5388;
  long unsigned int D.5389;
  unsigned int i;
  char * start;
  char * end;
  char * p;
  size_t bytes;
  struct hdr * hhdr;

  i = 0;
  goto <D.5170>;
  <D.5169>:
  start = GC_arrays._heap_sects[i].hs_start;
  bytes = GC_arrays._heap_sects[i].hs_bytes;
  end = start + bytes;
  goto <D.5162>;
  <D.5161>:
  i = i + 1;
  D.5348 = GC_arrays._heap_sects[i].hs_start;
  D.5349 = GC_arrays._heap_sects[i].hs_bytes;
  end = D.5348 + D.5349;
  <D.5162>:
  D.5350 = i + 1;
  GC_n_heap_sects.5 = GC_n_heap_sects;
  if (D.5350 < GC_n_heap_sects.5) goto <D.5352>; else goto <D.5163>;
  <D.5352>:
  D.5350 = i + 1;
  D.5353 = GC_arrays._heap_sects[D.5350].hs_start;
  if (D.5353 == end) goto <D.5161>; else goto <D.5163>;
  <D.5163>:
  start.6 = (long int) start;
  end.7 = (long int) end;
  GC_printf ("***Section from 0x%lx to 0x%lx\n", start.6, end.7, 0, 0, 0, 0);
  p = start;
  goto <D.5164>;
  <D.5167>:
  p.8 = (long unsigned int) p;
  D.5357 = p.8 >> 22;
  D.5358 = GC_arrays._top_index[D.5357];
  p.8 = (long unsigned int) p;
  D.5359 = p.8 >> 12;
  D.5360 = D.5359 & 1023;
  hhdr = D.5358->index[D.5360];
  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.5363>; else goto <D.5364>;
  <D.5363>:
  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.5164>;
  <D.5364>:
  D.5366 = hhdr->hb_map;
  GC_invalid_map.12 = GC_invalid_map;
  if (D.5366 == GC_invalid_map.12) goto <D.5368>; else goto <D.5369>;
  <D.5368>:
  {
    int correct_index;
    int actual_index;

    D.5370 = hhdr->hb_sz;
    D.5371 = D.5370 >> 12;
    correct_index = GC_hblk_fl_from_blocks (D.5371);
    D.5370 = hhdr->hb_sz;
    D.5372 = (long int) D.5370;
    GC_printf ("\tfree block of size 0x%lx bytes", D.5372, 0, 0, 0, 0, 0);
    D.5373 = hhdr->hb_flags;
    D.5374 = (int) D.5373;
    D.5375 = D.5374 & 2;
    if (D.5375 == 0) goto <D.5376>; else goto <D.5377>;
    <D.5376>:
    GC_printf ("\n", 0, 0, 0, 0, 0, 0);
    goto <D.5378>;
    <D.5377>:
    GC_printf ("(unmapped)\n", 0, 0, 0, 0, 0, 0);
    <D.5378>:
    actual_index = free_list_index_of (hhdr);
    if (actual_index == -1) goto <D.5379>; else goto <D.5380>;
    <D.5379>:
    GC_printf ("\t\tBlock not on free list %ld!!\n", correct_index, 0, 0, 0, 0, 0);
    goto <D.5381>;
    <D.5380>:
    if (correct_index != actual_index) goto <D.5382>; else goto <D.5383>;
    <D.5382>:
    GC_printf ("\t\tBlock on list %ld, should be on %ld!!\n", actual_index, correct_index, 0, 0, 0, 0);
    <D.5383>:
    <D.5381>:
    D.5370 = hhdr->hb_sz;
    p = p + D.5370;
  }
  goto <D.5384>;
  <D.5369>:
  D.5370 = hhdr->hb_sz;
  D.5385 = D.5370 << 2;
  D.5386 = (long int) D.5385;
  GC_printf ("\tused for blocks of size 0x%lx bytes\n", D.5386, 0, 0, 0, 0, 0);
  D.5370 = hhdr->hb_sz;
  D.5385 = D.5370 << 2;
  D.5387 = D.5385 + 4095;
  D.5388 = D.5387 >> 12;
  D.5389 = D.5388 * 4096;
  p = p + D.5389;
  <D.5384>:
  <D.5164>:
  if (p < end) goto <D.5167>; else goto <D.5168>;
  <D.5168>:
  i = i + 1;
  <D.5170>:
  GC_n_heap_sects.5 = GC_n_heap_sects;
  if (i < GC_n_heap_sects.5) goto <D.5169>; else goto <D.5171>;
  <D.5171>:
}


GC_remove_from_fl (struct hdr * hhdr, int n)
{
  struct hblk * D.5390;
  long unsigned int D.5395;
  long unsigned int D.5396;
  struct hblk * D.5398;
  long unsigned int D.5400;
  long unsigned int D.5401;
  struct bottom_index * D.5402;
  long unsigned int D.5403;
  long unsigned int D.5404;
  long unsigned int D.5407;
  long unsigned int D.5408;
  struct bottom_index * D.5409;
  long unsigned int D.5410;
  long unsigned int D.5411;
  int index;

  D.5390 = hhdr->hb_prev;
  if (D.5390 == 0B) goto <D.5391>; else goto <D.5392>;
  <D.5391>:
  if (n == -1) goto <D.5393>; else goto <D.5394>;
  <D.5393>:
  D.5395 = hhdr->hb_sz;
  D.5396 = D.5395 >> 12;
  index = GC_hblk_fl_from_blocks (D.5396);
  goto <D.5397>;
  <D.5394>:
  index = n;
  <D.5397>:
  D.5398 = hhdr->hb_next;
  GC_hblkfreelist[index] = D.5398;
  goto <D.5399>;
  <D.5392>:
  {
    struct hdr * phdr;

    D.5390 = hhdr->hb_prev;
    D.5400 = (long unsigned int) D.5390;
    D.5401 = D.5400 >> 22;
    D.5402 = GC_arrays._top_index[D.5401];
    D.5390 = hhdr->hb_prev;
    D.5400 = (long unsigned int) D.5390;
    D.5403 = D.5400 >> 12;
    D.5404 = D.5403 & 1023;
    phdr = D.5402->index[D.5404];
    D.5398 = hhdr->hb_next;
    phdr->hb_next = D.5398;
  }
  <D.5399>:
  D.5398 = hhdr->hb_next;
  if (D.5398 != 0B) goto <D.5405>; else goto <D.5406>;
  <D.5405>:
  {
    struct hdr * nhdr;

    D.5398 = hhdr->hb_next;
    D.5407 = (long unsigned int) D.5398;
    D.5408 = D.5407 >> 22;
    D.5409 = GC_arrays._top_index[D.5408];
    D.5398 = hhdr->hb_next;
    D.5407 = (long unsigned int) D.5398;
    D.5410 = D.5407 >> 12;
    D.5411 = D.5410 & 1023;
    nhdr = D.5409->index[D.5411];
    D.5390 = hhdr->hb_prev;
    nhdr->hb_prev = D.5390;
  }
  <D.5406>:
}


GC_free_block_ending_at (struct hblk * h)
{
  long unsigned int p.13;
  long unsigned int D.5413;
  struct bottom_index * D.5414;
  long unsigned int D.5415;
  long unsigned int D.5416;
  long unsigned int phdr.14;
  long unsigned int D.5418;
  sizetype D.5419;
  map_entry_type * D.5423;
  map_entry_type * GC_invalid_map.15;
  struct hblk * D.5427;
  struct hblk * D.5428;
  long unsigned int D.5433;
  char * D.5434;
  struct hblk * p;
  struct hdr * phdr;

  p = h + 4294963200;
  p.13 = (long unsigned int) p;
  D.5413 = p.13 >> 22;
  D.5414 = GC_arrays._top_index[D.5413];
  p.13 = (long unsigned int) p;
  D.5415 = p.13 >> 12;
  D.5416 = D.5415 & 1023;
  phdr = D.5414->index[D.5416];
  goto <D.5192>;
  <D.5191>:
  phdr.14 = (long unsigned int) phdr;
  D.5418 = phdr.14 * 4096;
  D.5419 = -D.5418;
  p = p + D.5419;
  p.13 = (long unsigned int) p;
  D.5413 = p.13 >> 22;
  D.5414 = GC_arrays._top_index[D.5413];
  p.13 = (long unsigned int) p;
  D.5415 = p.13 >> 12;
  D.5416 = D.5415 & 1023;
  phdr = D.5414->index[D.5416];
  <D.5192>:
  if (phdr != 0B) goto <D.5420>; else goto <D.5193>;
  <D.5420>:
  phdr.14 = (long unsigned int) phdr;
  if (phdr.14 <= 4095) goto <D.5191>; else goto <D.5193>;
  <D.5193>:
  if (phdr != 0B) goto <D.5421>; else goto <D.5422>;
  <D.5421>:
  D.5423 = phdr->hb_map;
  GC_invalid_map.15 = GC_invalid_map;
  if (D.5423 == GC_invalid_map.15) goto <D.5425>; else goto <D.5426>;
  <D.5425>:
  D.5427 = p;
  return D.5427;
  <D.5426>:
  D.5427 = 0B;
  return D.5427;
  <D.5422>:
  D.5428 = h + 4294963200;
  p = GC_prev_block (D.5428);
  if (p != 0B) goto <D.5429>; else goto <D.5430>;
  <D.5429>:
  p.13 = (long unsigned int) p;
  D.5413 = p.13 >> 22;
  D.5414 = GC_arrays._top_index[D.5413];
  p.13 = (long unsigned int) p;
  D.5415 = p.13 >> 12;
  D.5416 = D.5415 & 1023;
  phdr = D.5414->index[D.5416];
  D.5423 = phdr->hb_map;
  GC_invalid_map.15 = GC_invalid_map;
  if (D.5423 == GC_invalid_map.15) goto <D.5431>; else goto <D.5432>;
  <D.5431>:
  D.5433 = phdr->hb_sz;
  D.5434 = p + D.5433;
  if (D.5434 == h) goto <D.5435>; else goto <D.5436>;
  <D.5435>:
  D.5427 = p;
  return D.5427;
  <D.5436>:
  <D.5432>:
  <D.5430>:
  D.5427 = 0B;
  return D.5427;
}


GC_add_to_fl (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.5438;
  long unsigned int D.5439;
  long unsigned int second.16;
  long unsigned int D.5443;
  struct bottom_index * D.5444;
  long unsigned int D.5445;
  long unsigned int D.5446;
  int index;
  struct hblk * second;
  struct hdr * second_hdr;

  D.5438 = hhdr->hb_sz;
  D.5439 = D.5438 >> 12;
  index = GC_hblk_fl_from_blocks (D.5439);
  second = GC_hblkfreelist[index];
  GC_hblkfreelist[index] = h;
  hhdr->hb_next = second;
  hhdr->hb_prev = 0B;
  if (second != 0B) goto <D.5440>; else goto <D.5441>;
  <D.5440>:
  second.16 = (long unsigned int) second;
  D.5443 = second.16 >> 22;
  D.5444 = GC_arrays._top_index[D.5443];
  second.16 = (long unsigned int) second;
  D.5445 = second.16 >> 12;
  D.5446 = D.5445 & 1023;
  second_hdr = D.5444->index[D.5446];
  second_hdr->hb_prev = h;
  <D.5441>:
  GC_invalidate_map (hhdr);
}


GC_unmap_old ()
{
  long unsigned int h.17;
  long unsigned int D.5448;
  struct bottom_index * D.5449;
  long unsigned int D.5450;
  long unsigned int D.5451;
  unsigned char D.5452;
  int D.5453;
  int D.5454;
  long unsigned int GC_gc_no.18;
  short unsigned int D.5458;
  long unsigned int D.5461;
  long unsigned int D.5463;
  unsigned char D.5466;
  struct hblk * h;
  struct hdr * hhdr;
  word sz;
  short unsigned int last_rec;
  short unsigned int threshold;
  int i;

  i = 0;
  goto <D.5215>;
  <D.5214>:
  h = GC_hblkfreelist[i];
  goto <D.5212>;
  <D.5211>:
  h.17 = (long unsigned int) h;
  D.5448 = h.17 >> 22;
  D.5449 = GC_arrays._top_index[D.5448];
  h.17 = (long unsigned int) h;
  D.5450 = h.17 >> 12;
  D.5451 = D.5450 & 1023;
  hhdr = D.5449->index[D.5451];
  D.5452 = hhdr->hb_flags;
  D.5453 = (int) D.5452;
  D.5454 = D.5453 & 2;
  if (D.5454 != 0) goto <D.5455>; else goto <D.5456>;
  <D.5455>:
  // predicted unlikely by continue predictor.
  goto <D.5210>;
  <D.5456>:
  GC_gc_no.18 = GC_gc_no;
  D.5458 = (short unsigned int) GC_gc_no.18;
  threshold = D.5458 + 65530;
  last_rec = hhdr->hb_last_reclaimed;
  D.5461 = (long unsigned int) last_rec;
  GC_gc_no.18 = GC_gc_no;
  if (D.5461 > GC_gc_no.18) goto <D.5459>; else goto <D.5462>;
  <D.5462>:
  if (last_rec < threshold) goto <D.5459>; else goto <D.5460>;
  <D.5459>:
  D.5463 = (long unsigned int) threshold;
  GC_gc_no.18 = GC_gc_no;
  if (D.5463 < GC_gc_no.18) goto <D.5464>; else goto <D.5465>;
  <D.5464>:
  sz = hhdr->hb_sz;
  GC_unmap (h, sz);
  D.5452 = hhdr->hb_flags;
  D.5466 = D.5452 | 2;
  hhdr->hb_flags = D.5466;
  <D.5465>:
  <D.5460>:
  <D.5210>:
  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>:
}


GC_merge_unmapped ()
{
  long unsigned int h.19;
  long unsigned int D.5468;
  struct bottom_index * D.5469;
  long unsigned int D.5470;
  long unsigned int D.5471;
  long unsigned int D.5472;
  long unsigned int next.20;
  long unsigned int D.5474;
  struct bottom_index * D.5475;
  long unsigned int D.5476;
  long unsigned int D.5477;
  map_entry_type * D.5481;
  map_entry_type * GC_invalid_map.21;
  unsigned char D.5484;
  int D.5485;
  int D.5486;
  unsigned char D.5492;
  unsigned char D.5494;
  int D.5495;
  int D.5496;
  unsigned char D.5502;
  short unsigned int D.5503;
  long unsigned int D.5505;
  long unsigned int D.5506;
  long unsigned int D.5507;
  struct hblk * h;
  struct hblk * next;
  struct hdr * hhdr;
  struct hdr * nexthdr;
  word size;
  word nextsize;
  int i;

  i = 0;
  goto <D.5231>;
  <D.5230>:
  h = GC_hblkfreelist[i];
  goto <D.5228>;
  <D.5227>:
  h.19 = (long unsigned int) h;
  D.5468 = h.19 >> 22;
  D.5469 = GC_arrays._top_index[D.5468];
  h.19 = (long unsigned int) h;
  D.5470 = h.19 >> 12;
  D.5471 = D.5470 & 1023;
  hhdr = D.5469->index[D.5471];
  size = hhdr->hb_sz;
  h.19 = (long unsigned int) h;
  D.5472 = h.19 + size;
  next = (struct hblk *) D.5472;
  next.20 = (long unsigned int) next;
  D.5474 = next.20 >> 22;
  D.5475 = GC_arrays._top_index[D.5474];
  next.20 = (long unsigned int) next;
  D.5476 = next.20 >> 12;
  D.5477 = D.5476 & 1023;
  nexthdr = D.5475->index[D.5477];
  if (nexthdr != 0B) goto <D.5480>; else goto <D.5478>;
  <D.5480>:
  D.5481 = nexthdr->hb_map;
  GC_invalid_map.21 = GC_invalid_map;
  if (D.5481 == GC_invalid_map.21) goto <D.5483>; else goto <D.5478>;
  <D.5483>:
  nextsize = nexthdr->hb_sz;
  D.5484 = hhdr->hb_flags;
  D.5485 = (int) D.5484;
  D.5486 = D.5485 & 2;
  if (D.5486 == 0) goto <D.5487>; else goto <D.5488>;
  <D.5487>:
  if (size > nextsize) goto <D.5489>; else goto <D.5490>;
  <D.5489>:
  GC_remap (next, nextsize);
  goto <D.5491>;
  <D.5490>:
  GC_unmap (h, size);
  D.5484 = hhdr->hb_flags;
  D.5492 = D.5484 | 2;
  hhdr->hb_flags = D.5492;
  <D.5491>:
  goto <D.5493>;
  <D.5488>:
  D.5494 = nexthdr->hb_flags;
  D.5495 = (int) D.5494;
  D.5496 = D.5495 & 2;
  if (D.5496 == 0) goto <D.5497>; else goto <D.5498>;
  <D.5497>:
  if (size > nextsize) goto <D.5499>; else goto <D.5500>;
  <D.5499>:
  GC_unmap (next, nextsize);
  goto <D.5501>;
  <D.5500>:
  GC_remap (h, size);
  D.5484 = hhdr->hb_flags;
  D.5502 = D.5484 & 253;
  hhdr->hb_flags = D.5502;
  D.5503 = nexthdr->hb_last_reclaimed;
  hhdr->hb_last_reclaimed = D.5503;
  <D.5501>:
  goto <D.5504>;
  <D.5498>:
  D.5505 = nexthdr->hb_sz;
  GC_unmap_gap (h, size, next, D.5505);
  <D.5504>:
  <D.5493>:
  GC_remove_from_fl (hhdr, i);
  GC_remove_from_fl (nexthdr, -1);
  D.5506 = hhdr->hb_sz;
  D.5505 = nexthdr->hb_sz;
  D.5507 = D.5506 + D.5505;
  hhdr->hb_sz = D.5507;
  GC_remove_header (next);
  GC_add_to_fl (h, hhdr);
  h = GC_hblkfreelist[i];
  goto <D.5479>;
  <D.5478>:
  h = hhdr->hb_next;
  <D.5479>:
  <D.5228>:
  if (h != 0B) goto <D.5227>; else goto <D.5229>;
  <D.5229>:
  i = i + 1;
  <D.5231>:
  if (i <= 60) goto <D.5230>; else goto <D.5232>;
  <D.5232>:
}


GC_get_first_part (struct hblk * h, struct hdr * hhdr, word bytes, int index)
{
  struct hblk * D.5510;
  long unsigned int h.22;
  long unsigned int D.5512;
  void (*<T6a5>) (char *, GC_word) GC_current_warn_proc.23;
  long unsigned int D.5516;
  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.5508>; else goto <D.5509>;
  <D.5508>:
  D.5510 = h;
  return D.5510;
  <D.5509>:
  h.22 = (long unsigned int) h;
  D.5512 = h.22 + bytes;
  rest = (struct hblk *) D.5512;
  rest_hdr = GC_install_header (rest);
  if (rest_hdr == 0B) goto <D.5513>; else goto <D.5514>;
  <D.5513>:
  GC_current_warn_proc.23 = GC_current_warn_proc;
  GC_current_warn_proc.23 ("GC Warning: Header allocation failed: Dropping block.\n", 0);
  D.5510 = 0B;
  return D.5510;
  <D.5514>:
  D.5516 = total_size - bytes;
  rest_hdr->hb_sz = D.5516;
  rest_hdr->hb_flags = 0;
  GC_add_to_fl (rest, rest_hdr);
  D.5510 = h;
  return D.5510;
}


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.5520;
  long unsigned int prev.26;
  long unsigned int D.5524;
  struct bottom_index * D.5525;
  long unsigned int D.5526;
  long unsigned int D.5527;
  struct hdr * D.5528;
  long unsigned int next.27;
  long unsigned int D.5533;
  struct bottom_index * D.5534;
  long unsigned int D.5535;
  long unsigned int D.5536;
  struct hdr * D.5537;
  long unsigned int GC_gc_no.28;
  short unsigned int D.5539;
  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.5520 = total_size - h_size;
  nhdr->hb_sz = D.5520;
  nhdr->hb_flags = 0;
  if (prev != 0B) goto <D.5521>; else goto <D.5522>;
  <D.5521>:
  prev.26 = (long unsigned int) prev;
  D.5524 = prev.26 >> 22;
  D.5525 = GC_arrays._top_index[D.5524];
  prev.26 = (long unsigned int) prev;
  D.5526 = prev.26 >> 12;
  D.5527 = D.5526 & 1023;
  D.5528 = D.5525->index[D.5527];
  D.5528->hb_next = n;
  goto <D.5529>;
  <D.5522>:
  GC_hblkfreelist[index] = n;
  <D.5529>:
  if (next != 0B) goto <D.5530>; else goto <D.5531>;
  <D.5530>:
  next.27 = (long unsigned int) next;
  D.5533 = next.27 >> 22;
  D.5534 = GC_arrays._top_index[D.5533];
  next.27 = (long unsigned int) next;
  D.5535 = next.27 >> 12;
  D.5536 = D.5535 & 1023;
  D.5537 = D.5534->index[D.5536];
  D.5537->hb_prev = n;
  <D.5531>:
  GC_gc_no.28 = GC_gc_no;
  D.5539 = (short unsigned int) GC_gc_no.28;
  hhdr->hb_last_reclaimed = D.5539;
  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.5540;
  long unsigned int D.5541;
  struct hblk * D.5544;
  word blocks;
  int start_list;
  int i;

  D.5540 = sz << 2;
  D.5541 = D.5540 + 4095;
  blocks = D.5541 >> 12;
  start_list = GC_hblk_fl_from_blocks (blocks);
  i = start_list;
  goto <D.5264>;
  <D.5263>:
  {
    struct hblk * result;

    result = GC_allochblk_nth (sz, kind, flags, i);
    if (result != 0B) goto <D.5542>; else goto <D.5543>;
    <D.5542>:
    D.5544 = result;
    return D.5544;
    <D.5543>:
  }
  i = i + 1;
  <D.5264>:
  if (i <= 60) goto <D.5263>; else goto <D.5265>;
  <D.5265>:
  D.5544 = 0B;
  return D.5544;
}


GC_allochblk_nth (word sz, int kind, unsigned char flags, int n)
{
  long unsigned int D.5546;
  long unsigned int D.5547;
  long unsigned int D.5548;
  long unsigned int D.5549;
  long unsigned int hbp.29;
  long unsigned int D.5551;
  struct bottom_index * D.5552;
  long unsigned int D.5553;
  long unsigned int D.5554;
  long unsigned int D.5555;
  int GC_use_entire_heap.30;
  int GC_dont_gc.31;
  long unsigned int D.5568;
  long unsigned int D.5569;
  long unsigned int D.5570;
  long unsigned int D.5571;
  int GC_incremental.32;
  long unsigned int GC_time_limit.33;
  int D.5577;
  long unsigned int thishbp.34;
  long unsigned int D.5583;
  struct bottom_index * D.5584;
  long unsigned int D.5585;
  long unsigned int D.5586;
  long unsigned int D.5587;
  long unsigned int size_needed.35;
  struct hblk * D.5593;
  int D.5598;
  sizetype size_avail.36;
  sizetype size_needed.37;
  sizetype D.5604;
  signed_word iftmp.38;
  int D.5606;
  int D.5607;
  long unsigned int eff_size_needed.39;
  int hbp.40;
  int lasthbp.41;
  int D.5615;
  unsigned char D.5622;
  int D.5623;
  int D.5624;
  unsigned char D.5627;
  long unsigned int GC_black_list_spacing.42;
  long int GC_black_list_spacing.43;
  long int D.5634;
  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 (*<T6a5>) (char *, GC_word) GC_current_warn_proc.47;
  int GC_find_leak.48;
  unsigned int count.49;
  unsigned int count.50;
  unsigned int D.5653;
  long unsigned int D.5656;
  long unsigned int D.5657;
  long unsigned int D.5658;
  long unsigned int D.5659;
  long unsigned int D.5660;
  long unsigned int D.5661;
  int GC_debugging_started.51;
  struct hblk * D.5670;
  int D.5677;
  int D.5680;
  long int D.5683;
  long unsigned int D.5684;
  long unsigned int D.5685;
  _Bool D.5686;
  int D.5687;
  long unsigned int D.5688;
  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.5546 = sz << 2;
  D.5547 = D.5546 + 4095;
  D.5548 = D.5547 >> 12;
  D.5549 = D.5548 * 4096;
  size_needed = (signed_word) D.5549;
  hbp = GC_hblkfreelist[n];
  goto <D.5297>;
  <D.5296>:
  hbp.29 = (long unsigned int) hbp;
  D.5551 = hbp.29 >> 22;
  D.5552 = GC_arrays._top_index[D.5551];
  hbp.29 = (long unsigned int) hbp;
  D.5553 = hbp.29 >> 12;
  D.5554 = D.5553 & 1023;
  hhdr = D.5552->index[D.5554];
  D.5555 = hhdr->hb_sz;
  size_avail = (signed_word) D.5555;
  if (size_avail < size_needed) goto <D.5556>; else goto <D.5557>;
  <D.5556>:
  // predicted unlikely by continue predictor.
  goto <D.5278>;
  <D.5557>:
  if (size_avail != size_needed) goto <D.5560>; else goto <D.5561>;
  <D.5560>:
  GC_use_entire_heap.30 = GC_use_entire_heap;
  if (GC_use_entire_heap.30 == 0) goto <D.5563>; else goto <D.5564>;
  <D.5563>:
  GC_dont_gc.31 = GC_dont_gc;
  if (GC_dont_gc.31 == 0) goto <D.5566>; else goto <D.5567>;
  <D.5566>:
  D.5568 = GC_arrays._heapsize;
  D.5569 = GC_arrays._large_free_bytes;
  D.5570 = D.5568 - D.5569;
  D.5571 = GC_arrays._requested_heapsize;
  if (D.5570 >= D.5571) goto <D.5572>; else goto <D.5573>;
  <D.5572>:
  GC_incremental.32 = GC_incremental;
  if (GC_incremental.32 == 0) goto <D.5558>; else goto <D.5575>;
  <D.5575>:
  GC_time_limit.33 = GC_time_limit;
  if (GC_time_limit.33 == 999999) goto <D.5558>; else goto <D.5559>;
  <D.5558>:
  D.5577 = GC_should_collect ();
  if (D.5577 != 0) goto <D.5578>; else goto <D.5579>;
  <D.5578>:
  // predicted unlikely by continue predictor.
  goto <D.5278>;
  <D.5579>:
  <D.5559>:
  <D.5573>:
  <D.5567>:
  <D.5564>:
  <D.5561>:
  {
    signed_word next_size;

    thishbp = hhdr->hb_next;
    if (thishbp != 0B) goto <D.5580>; else goto <D.5581>;
    <D.5580>:
    thishbp.34 = (long unsigned int) thishbp;
    D.5583 = thishbp.34 >> 22;
    D.5584 = GC_arrays._top_index[D.5583];
    thishbp.34 = (long unsigned int) thishbp;
    D.5585 = thishbp.34 >> 12;
    D.5586 = D.5585 & 1023;
    thishdr = D.5584->index[D.5586];
    D.5587 = thishdr->hb_sz;
    next_size = (signed_word) D.5587;
    if (next_size < size_avail) goto <D.5588>; else goto <D.5589>;
    <D.5588>:
    if (next_size >= size_needed) goto <D.5590>; else goto <D.5591>;
    <D.5590>:
    size_needed.35 = (long unsigned int) size_needed;
    D.5593 = GC_is_black_listed (thishbp, size_needed.35);
    if (D.5593 == 0B) goto <D.5594>; else goto <D.5595>;
    <D.5594>:
    // predicted unlikely by continue predictor.
    goto <D.5278>;
    <D.5595>:
    <D.5591>:
    <D.5589>:
    <D.5581>:
  }
  D.5598 = kind & -2;
  if (D.5598 != 2) goto <D.5599>; else goto <D.5600>;
  <D.5599>:
  if (kind != 0) goto <D.5596>; else goto <D.5601>;
  <D.5601>:
  size_needed.35 = (long unsigned int) size_needed;
  if (size_needed.35 > 8192) goto <D.5596>; else goto <D.5597>;
  <D.5596>:
  {
    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.5604 = size_avail.36 - size_needed.37;
    search_end = hbp + D.5604;
    orig_avail = size_avail;
    D.5606 = (int) flags;
    D.5607 = D.5606 & 1;
    if (D.5607 == 0) goto <D.5608>; else goto <D.5609>;
    <D.5608>:
    iftmp.38 = size_needed;
    goto <D.5610>;
    <D.5609>:
    iftmp.38 = 4096;
    <D.5610>:
    eff_size_needed = iftmp.38;
    goto <D.5285>;
    <D.5284>:
    lasthbp = thishbp;
    <D.5285>:
    if (lasthbp <= search_end) goto <D.5611>; else goto <D.5286>;
    <D.5611>:
    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.5284>; else goto <D.5286>;
    <D.5286>:
    hbp.40 = (int) hbp;
    lasthbp.41 = (int) lasthbp;
    D.5615 = hbp.40 - lasthbp.41;
    size_avail = D.5615 + size_avail;
    thishbp = lasthbp;
    if (size_avail >= size_needed) goto <D.5616>; else goto <D.5617>;
    <D.5616>:
    if (thishbp != hbp) goto <D.5618>; else goto <D.5619>;
    <D.5618>:
    thishdr = GC_install_header (thishbp);
    if (thishdr != 0B) goto <D.5620>; else goto <D.5621>;
    <D.5620>:
    D.5622 = hhdr->hb_flags;
    D.5623 = (int) D.5622;
    D.5624 = D.5623 & 2;
    if (D.5624 != 0) goto <D.5625>; else goto <D.5626>;
    <D.5625>:
    D.5555 = hhdr->hb_sz;
    GC_remap (hbp, D.5555);
    D.5622 = hhdr->hb_flags;
    D.5627 = D.5622 & 253;
    hhdr->hb_flags = D.5627;
    <D.5626>:
    GC_split_block (hbp, hhdr, thishbp, thishdr, n);
    hbp = thishbp;
    hhdr = thishdr;
    <D.5621>:
    <D.5619>:
    goto <D.5628>;
    <D.5617>:
    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.5633>; else goto <D.5629>;
    <D.5633>:
    D.5634 = 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.5634 > GC_black_list_spacing.43) goto <D.5635>; else goto <D.5629>;
    <D.5635>:
    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.5639>; else goto <D.5640>;
    <D.5639>:
    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.5640>:
    size_avail = orig_avail;
    goto <D.5630>;
    <D.5629>:
    if (size_avail == 0) goto <D.5642>; else goto <D.5643>;
    <D.5642>:
    if (size_needed == 4096) goto <D.5644>; else goto <D.5645>;
    <D.5644>:
    D.5622 = hhdr->hb_flags;
    D.5623 = (int) D.5622;
    D.5624 = D.5623 & 2;
    if (D.5624 == 0) goto <D.5646>; else goto <D.5647>;
    <D.5646>:
    GC_find_leak.48 = GC_find_leak;
    if (GC_find_leak.48 == 0) goto <D.5649>; else goto <D.5650>;
    <D.5649>:
    {
      static unsigned int count = 0;

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

        total_size = hhdr->hb_sz;
        D.5656 = total_size >> 12;
        D.5657 = D.5656 * 4096;
        limit = hbp + D.5657;
        prev = hhdr->hb_prev;
        D.5658 = GC_arrays._words_wasted;
        D.5659 = total_size >> 2;
        D.5660 = D.5658 + D.5659;
        GC_arrays._words_wasted = D.5660;
        D.5569 = GC_arrays._large_free_bytes;
        D.5661 = D.5569 - total_size;
        GC_arrays._large_free_bytes = D.5661;
        GC_remove_from_fl (hhdr, n);
        h = hbp;
        goto <D.5293>;
        <D.5292>:
        if (h == hbp) goto <D.5662>; else goto <D.5664>;
        <D.5664>:
        hhdr = GC_install_header (h);
        if (hhdr != 0B) goto <D.5662>; else goto <D.5663>;
        <D.5662>:
        setup_header (hhdr, 1024, 0, 0);
        GC_debugging_started.51 = GC_debugging_started;
        if (GC_debugging_started.51 != 0) goto <D.5666>; else goto <D.5667>;
        <D.5666>:
        memset (h, 0, 4096);
        <D.5667>:
        <D.5663>:
        h = h + 4096;
        <D.5293>:
        if (h < limit) goto <D.5292>; else goto <D.5294>;
        <D.5294>:
        hbp = prev;
        if (hbp == 0B) goto <D.5668>; else goto <D.5669>;
        <D.5668>:
        D.5606 = (int) flags;
        D.5670 = GC_allochblk_nth (sz, kind, D.5606, n);
        return D.5670;
        <D.5669>:
        hbp.29 = (long unsigned int) hbp;
        D.5551 = hbp.29 >> 22;
        D.5552 = GC_arrays._top_index[D.5551];
        hbp.29 = (long unsigned int) hbp;
        D.5553 = hbp.29 >> 12;
        D.5554 = D.5553 & 1023;
        hhdr = D.5552->index[D.5554];
      }
      <D.5655>:
    }
    <D.5650>:
    <D.5647>:
    <D.5645>:
    <D.5643>:
    <D.5630>:
    <D.5628>:
  }
  <D.5597>:
  <D.5600>:
  if (size_avail >= size_needed) goto <D.5671>; else goto <D.5672>;
  <D.5671>:
  D.5622 = hhdr->hb_flags;
  D.5623 = (int) D.5622;
  D.5624 = D.5623 & 2;
  if (D.5624 != 0) goto <D.5673>; else goto <D.5674>;
  <D.5673>:
  D.5555 = hhdr->hb_sz;
  GC_remap (hbp, D.5555);
  D.5622 = hhdr->hb_flags;
  D.5627 = D.5622 & 253;
  hhdr->hb_flags = D.5627;
  <D.5674>:
  hbp = GC_get_first_part (hbp, hhdr, size_needed, n);
  goto <D.5295>;
  <D.5672>:
  <D.5278>:
  hbp = hhdr->hb_next;
  <D.5297>:
  if (hbp != 0B) goto <D.5296>; else goto <D.5295>;
  <D.5295>:
  if (hbp == 0B) goto <D.5675>; else goto <D.5676>;
  <D.5675>:
  D.5670 = 0B;
  return D.5670;
  <D.5676>:
  size_needed.35 = (long unsigned int) size_needed;
  D.5677 = GC_install_counts (hbp, size_needed.35);
  if (D.5677 == 0) goto <D.5678>; else goto <D.5679>;
  <D.5678>:
  D.5670 = 0B;
  return D.5670;
  <D.5679>:
  D.5606 = (int) flags;
  D.5680 = setup_header (hhdr, sz, kind, D.5606);
  if (D.5680 == 0) goto <D.5681>; else goto <D.5682>;
  <D.5681>:
  size_needed.35 = (long unsigned int) size_needed;
  GC_remove_counts (hbp, size_needed.35);
  D.5670 = 0B;
  return D.5670;
  <D.5682>:
  D.5683 = size_needed >> 12;
  D.5684 = (long unsigned int) D.5683;
  D.5685 = hhdr->hb_descr;
  D.5686 = D.5685 == 0;
  D.5687 = (int) D.5686;
  GC_remove_protection (hbp, D.5684, D.5687);
  {
    extern unsigned int GC_fail_count;

    GC_fail_count = 0;
  }
  D.5569 = GC_arrays._large_free_bytes;
  size_needed.35 = (long unsigned int) size_needed;
  D.5688 = D.5569 - size_needed.35;
  GC_arrays._large_free_bytes = D.5688;
  D.5670 = hbp;
  return D.5670;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5692;
  int D.5697;
  void * D.5699;
  unsigned int D.5700;

  D.5692 = __builtin_constant_p (__len);
  if (D.5692 != 0) goto <D.5693>; else goto <D.5694>;
  <D.5693>:
  if (__len == 0) goto <D.5695>; else goto <D.5696>;
  <D.5695>:
  D.5697 = __builtin_constant_p (__ch);
  if (D.5697 == 0) goto <D.5690>; else goto <D.5698>;
  <D.5698>:
  if (__ch != 0) goto <D.5690>; else goto <D.5691>;
  <D.5690>:
  __warn_memset_zero_len ();
  D.5699 = __dest;
  return D.5699;
  <D.5691>:
  <D.5696>:
  <D.5694>:
  D.5700 = __builtin_object_size (__dest, 0);
  D.5699 = __builtin___memset_chk (__dest, __ch, __len, D.5700);
  return D.5699;
}


setup_header (struct hdr * hhdr, word sz, int kind, unsigned char flags)
{
  int D.5702;
  GC_bool D.5705;
  long unsigned int iftmp.52;
  map_entry_type * D.5710;
  unsigned char D.5711;
  int D.5712;
  long unsigned int D.5715;
  long unsigned int GC_gc_no.53;
  short unsigned int D.5717;
  register word descr;

  D.5702 = GC_add_map_entry (sz);
  if (D.5702 == 0) goto <D.5703>; else goto <D.5704>;
  <D.5703>:
  D.5705 = 0;
  return D.5705;
  <D.5704>:
  if (sz <= 512) goto <D.5707>; else goto <D.5708>;
  <D.5707>:
  iftmp.52 = sz;
  goto <D.5709>;
  <D.5708>:
  iftmp.52 = 0;
  <D.5709>:
  D.5710 = GC_arrays._obj_map[iftmp.52];
  hhdr->hb_map = D.5710;
  hhdr->hb_sz = sz;
  D.5711 = (unsigned char) kind;
  hhdr->hb_obj_kind = D.5711;
  hhdr->hb_flags = flags;
  descr = GC_obj_kinds[kind].ok_descriptor;
  D.5712 = GC_obj_kinds[kind].ok_relocate_descr;
  if (D.5712 != 0) goto <D.5713>; else goto <D.5714>;
  <D.5713>:
  D.5715 = sz << 2;
  descr = D.5715 + descr;
  <D.5714>:
  hhdr->hb_descr = descr;
  GC_clear_hdr_marks (hhdr);
  GC_gc_no.53 = GC_gc_no;
  D.5717 = (short unsigned int) GC_gc_no.53;
  hhdr->hb_last_reclaimed = D.5717;
  D.5705 = 1;
  return D.5705;
}


GC_freehblk (struct hblk * hbp)
{
  long unsigned int hbp.54;
  long unsigned int D.5720;
  struct bottom_index * D.5721;
  long unsigned int D.5722;
  long unsigned int D.5723;
  long unsigned int D.5724;
  long int D.5725;
  long unsigned int D.5726;
  long unsigned int D.5727;
  long unsigned int D.5728;
  long unsigned int D.5729;
  long unsigned int size.55;
  long unsigned int size.56;
  long unsigned int GC_gc_no.57;
  short unsigned int D.5733;
  map_entry_type * D.5734;
  map_entry_type * GC_invalid_map.58;
  long int hbp.59;
  long unsigned int D.5739;
  long unsigned int next.60;
  long unsigned int D.5741;
  struct bottom_index * D.5742;
  long unsigned int D.5743;
  long unsigned int D.5744;
  map_entry_type * D.5747;
  unsigned char D.5750;
  int D.5751;
  int D.5752;
  long unsigned int D.5755;
  long unsigned int D.5756;
  long unsigned int prev.61;
  long unsigned int D.5760;
  struct bottom_index * D.5761;
  long unsigned int D.5762;
  long unsigned int D.5763;
  unsigned char D.5764;
  int D.5765;
  int D.5766;
  long unsigned int D.5769;
  long unsigned int D.5770;
  long unsigned int D.5771;
  long unsigned int D.5772;
  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.5720 = hbp.54 >> 22;
  D.5721 = GC_arrays._top_index[D.5720];
  hbp.54 = (long unsigned int) hbp;
  D.5722 = hbp.54 >> 12;
  D.5723 = D.5722 & 1023;
  hhdr = D.5721->index[D.5723];
  D.5724 = hhdr->hb_sz;
  size = (signed_word) D.5724;
  D.5725 = size << 2;
  D.5726 = (long unsigned int) D.5725;
  D.5727 = D.5726 + 4095;
  D.5728 = D.5727 >> 12;
  D.5729 = D.5728 * 4096;
  size = (signed_word) D.5729;
  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.5733 = (short unsigned int) GC_gc_no.57;
  hhdr->hb_last_reclaimed = D.5733;
  D.5734 = hhdr->hb_map;
  GC_invalid_map.58 = GC_invalid_map;
  if (D.5734 == GC_invalid_map.58) goto <D.5736>; else goto <D.5737>;
  <D.5736>:
  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.5737>:
  GC_invalidate_map (hhdr);
  hbp.54 = (long unsigned int) hbp;
  size.55 = (long unsigned int) size;
  D.5739 = hbp.54 + size.55;
  next = (struct hblk *) D.5739;
  next.60 = (long unsigned int) next;
  D.5741 = next.60 >> 22;
  D.5742 = GC_arrays._top_index[D.5741];
  next.60 = (long unsigned int) next;
  D.5743 = next.60 >> 12;
  D.5744 = D.5743 & 1023;
  nexthdr = D.5742->index[D.5744];
  prev = GC_free_block_ending_at (hbp);
  if (nexthdr != 0B) goto <D.5745>; else goto <D.5746>;
  <D.5745>:
  D.5747 = nexthdr->hb_map;
  GC_invalid_map.58 = GC_invalid_map;
  if (D.5747 == GC_invalid_map.58) goto <D.5748>; else goto <D.5749>;
  <D.5748>:
  D.5750 = nexthdr->hb_flags;
  D.5751 = (int) D.5750;
  D.5752 = D.5751 & 2;
  if (D.5752 == 0) goto <D.5753>; else goto <D.5754>;
  <D.5753>:
  GC_remove_from_fl (nexthdr, -1);
  D.5724 = hhdr->hb_sz;
  D.5755 = nexthdr->hb_sz;
  D.5756 = D.5724 + D.5755;
  hhdr->hb_sz = D.5756;
  GC_remove_header (next);
  <D.5754>:
  <D.5749>:
  <D.5746>:
  if (prev != 0B) goto <D.5757>; else goto <D.5758>;
  <D.5757>:
  prev.61 = (long unsigned int) prev;
  D.5760 = prev.61 >> 22;
  D.5761 = GC_arrays._top_index[D.5760];
  prev.61 = (long unsigned int) prev;
  D.5762 = prev.61 >> 12;
  D.5763 = D.5762 & 1023;
  prevhdr = D.5761->index[D.5763];
  D.5764 = prevhdr->hb_flags;
  D.5765 = (int) D.5764;
  D.5766 = D.5765 & 2;
  if (D.5766 == 0) goto <D.5767>; else goto <D.5768>;
  <D.5767>:
  GC_remove_from_fl (prevhdr, -1);
  D.5769 = prevhdr->hb_sz;
  D.5724 = hhdr->hb_sz;
  D.5770 = D.5769 + D.5724;
  prevhdr->hb_sz = D.5770;
  GC_gc_no.57 = GC_gc_no;
  D.5733 = (short unsigned int) GC_gc_no.57;
  prevhdr->hb_last_reclaimed = D.5733;
  GC_remove_header (hbp);
  hbp = prev;
  hhdr = prevhdr;
  <D.5768>:
  <D.5758>:
  D.5771 = GC_arrays._large_free_bytes;
  size.55 = (long unsigned int) size;
  D.5772 = D.5771 + size.55;
  GC_arrays._large_free_bytes = D.5772;
  GC_add_to_fl (hbp, hhdr);
}