GC_hblk_fl_from_blocks (word blocks_needed)
{
  int D.7890;
  long unsigned int D.7893;
  long unsigned int D.7894;
  long unsigned int D.7895;

  if (blocks_needed <= 32) goto <D.7888>; else goto <D.7889>;
  <D.7888>:
  D.7890 = (int) blocks_needed;
  return D.7890;
  <D.7889>:
  if (blocks_needed > 255) goto <D.7891>; else goto <D.7892>;
  <D.7891>:
  D.7890 = 60;
  return D.7890;
  <D.7892>:
  D.7893 = blocks_needed + 4294967264;
  D.7894 = D.7893 / 8;
  D.7895 = D.7894 + 32;
  D.7890 = (int) D.7895;
  return D.7890;
}


GC_print_hblkfreelist ()
{
  long unsigned int h.0;
  long unsigned int D.7900;
  struct bottom_index * D.7901;
  long unsigned int D.7902;
  long unsigned int D.7903;
  long int h.1;
  long int sz.2;
  struct hblk * D.7906;
  long unsigned int D.7910;
  struct hblk * D.7911;
  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.7714>;
  <D.7713>:
  h = GC_hblkfreelist[i];
  if (h != 0B) goto <D.7897>; else goto <D.7898>;
  <D.7897>:
  GC_printf ("Free list %ld:\n", i, 0, 0, 0, 0, 0);
  <D.7898>:
  goto <D.7711>;
  <D.7710>:
  h.0 = (long unsigned int) h;
  D.7900 = h.0 >> 22;
  D.7901 = GC_arrays._top_index[D.7900];
  h.0 = (long unsigned int) h;
  D.7902 = h.0 >> 12;
  D.7903 = D.7902 & 1023;
  hhdr = D.7901->index[D.7903];
  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.7906 = GC_is_black_listed (h, 4096);
  if (D.7906 != 0B) goto <D.7907>; else goto <D.7908>;
  <D.7907>:
  GC_printf ("start black listed\n", 0, 0, 0, 0, 0, 0);
  goto <D.7909>;
  <D.7908>:
  D.7910 = hhdr->hb_sz;
  D.7911 = GC_is_black_listed (h, D.7910);
  if (D.7911 != 0B) goto <D.7912>; else goto <D.7913>;
  <D.7912>:
  GC_printf ("partially black listed\n", 0, 0, 0, 0, 0, 0);
  goto <D.7914>;
  <D.7913>:
  GC_printf ("not black listed\n", 0, 0, 0, 0, 0, 0);
  <D.7914>:
  <D.7909>:
  h = hhdr->hb_next;
  <D.7711>:
  if (h != 0B) goto <D.7710>; else goto <D.7712>;
  <D.7712>:
  i = i + 1;
  <D.7714>:
  if (i <= 60) goto <D.7713>; else goto <D.7715>;
  <D.7715>:
  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.7917;
  struct bottom_index * D.7918;
  long unsigned int D.7919;
  long unsigned int D.7920;
  int D.7923;
  struct hblk * h;
  struct hdr * hhdr;
  int i;

  i = 0;
  goto <D.7726>;
  <D.7725>:
  h = GC_hblkfreelist[i];
  goto <D.7723>;
  <D.7722>:
  h.4 = (long unsigned int) h;
  D.7917 = h.4 >> 22;
  D.7918 = GC_arrays._top_index[D.7917];
  h.4 = (long unsigned int) h;
  D.7919 = h.4 >> 12;
  D.7920 = D.7919 & 1023;
  hhdr = D.7918->index[D.7920];
  if (hhdr == wanted) goto <D.7921>; else goto <D.7922>;
  <D.7921>:
  D.7923 = i;
  return D.7923;
  <D.7922>:
  h = hhdr->hb_next;
  <D.7723>:
  if (h != 0B) goto <D.7722>; else goto <D.7724>;
  <D.7724>:
  i = i + 1;
  <D.7726>:
  if (i <= 60) goto <D.7725>; else goto <D.7727>;
  <D.7727>:
  D.7923 = -1;
  return D.7923;
}


GC_dump_regions ()
{
  char * D.7925;
  long unsigned int D.7926;
  unsigned int D.7927;
  long unsigned int GC_n_heap_sects.5;
  char * D.7930;
  long int start.6;
  long int end.7;
  long unsigned int p.8;
  long unsigned int D.7934;
  struct bottom_index * D.7935;
  long unsigned int D.7936;
  long unsigned int D.7937;
  long int p.9;
  long unsigned int hhdr.10;
  long int hhdr.11;
  map_entry_type * D.7943;
  map_entry_type * GC_invalid_map.12;
  long unsigned int D.7947;
  long unsigned int D.7948;
  long int D.7949;
  unsigned char D.7950;
  int D.7951;
  int D.7952;
  long unsigned int D.7962;
  long int D.7963;
  long unsigned int D.7964;
  long unsigned int D.7965;
  long unsigned int D.7966;
  unsigned int i;
  char * start;
  char * end;
  char * p;
  size_t bytes;
  struct hdr * hhdr;

  i = 0;
  goto <D.7745>;
  <D.7744>:
  start = GC_arrays._heap_sects[i].hs_start;
  bytes = GC_arrays._heap_sects[i].hs_bytes;
  end = start + bytes;
  goto <D.7737>;
  <D.7736>:
  i = i + 1;
  D.7925 = GC_arrays._heap_sects[i].hs_start;
  D.7926 = GC_arrays._heap_sects[i].hs_bytes;
  end = D.7925 + D.7926;
  <D.7737>:
  D.7927 = i + 1;
  GC_n_heap_sects.5 = GC_n_heap_sects;
  if (D.7927 < GC_n_heap_sects.5) goto <D.7929>; else goto <D.7738>;
  <D.7929>:
  D.7927 = i + 1;
  D.7930 = GC_arrays._heap_sects[D.7927].hs_start;
  if (D.7930 == end) goto <D.7736>; else goto <D.7738>;
  <D.7738>:
  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.7739>;
  <D.7742>:
  p.8 = (long unsigned int) p;
  D.7934 = p.8 >> 22;
  D.7935 = GC_arrays._top_index[D.7934];
  p.8 = (long unsigned int) p;
  D.7936 = p.8 >> 12;
  D.7937 = D.7936 & 1023;
  hhdr = D.7935->index[D.7937];
  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.7940>; else goto <D.7941>;
  <D.7940>:
  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.7739>;
  <D.7941>:
  D.7943 = hhdr->hb_map;
  GC_invalid_map.12 = GC_invalid_map;
  if (D.7943 == GC_invalid_map.12) goto <D.7945>; else goto <D.7946>;
  <D.7945>:
  {
    int correct_index;
    int actual_index;

    D.7947 = hhdr->hb_sz;
    D.7948 = D.7947 >> 12;
    correct_index = GC_hblk_fl_from_blocks (D.7948);
    D.7947 = hhdr->hb_sz;
    D.7949 = (long int) D.7947;
    GC_printf ("\tfree block of size 0x%lx bytes", D.7949, 0, 0, 0, 0, 0);
    D.7950 = hhdr->hb_flags;
    D.7951 = (int) D.7950;
    D.7952 = D.7951 & 2;
    if (D.7952 == 0) goto <D.7953>; else goto <D.7954>;
    <D.7953>:
    GC_printf ("\n", 0, 0, 0, 0, 0, 0);
    goto <D.7955>;
    <D.7954>:
    GC_printf ("(unmapped)\n", 0, 0, 0, 0, 0, 0);
    <D.7955>:
    actual_index = free_list_index_of (hhdr);
    if (actual_index == -1) goto <D.7956>; else goto <D.7957>;
    <D.7956>:
    GC_printf ("\t\tBlock not on free list %ld!!\n", correct_index, 0, 0, 0, 0, 0);
    goto <D.7958>;
    <D.7957>:
    if (correct_index != actual_index) goto <D.7959>; else goto <D.7960>;
    <D.7959>:
    GC_printf ("\t\tBlock on list %ld, should be on %ld!!\n", actual_index, correct_index, 0, 0, 0, 0);
    <D.7960>:
    <D.7958>:
    D.7947 = hhdr->hb_sz;
    p = p + D.7947;
  }
  goto <D.7961>;
  <D.7946>:
  D.7947 = hhdr->hb_sz;
  D.7962 = D.7947 << 2;
  D.7963 = (long int) D.7962;
  GC_printf ("\tused for blocks of size 0x%lx bytes\n", D.7963, 0, 0, 0, 0, 0);
  D.7947 = hhdr->hb_sz;
  D.7962 = D.7947 << 2;
  D.7964 = D.7962 + 4095;
  D.7965 = D.7964 >> 12;
  D.7966 = D.7965 * 4096;
  p = p + D.7966;
  <D.7961>:
  <D.7739>:
  if (p < end) goto <D.7742>; else goto <D.7743>;
  <D.7743>:
  i = i + 1;
  <D.7745>:
  GC_n_heap_sects.5 = GC_n_heap_sects;
  if (i < GC_n_heap_sects.5) goto <D.7744>; else goto <D.7746>;
  <D.7746>:
}


GC_remove_from_fl (struct hdr * hhdr, int n)
{
  struct hblk * D.7967;
  long unsigned int D.7972;
  long unsigned int D.7973;
  struct hblk * D.7975;
  long unsigned int D.7977;
  long unsigned int D.7978;
  struct bottom_index * D.7979;
  long unsigned int D.7980;
  long unsigned int D.7981;
  long unsigned int D.7984;
  long unsigned int D.7985;
  struct bottom_index * D.7986;
  long unsigned int D.7987;
  long unsigned int D.7988;
  int index;

  D.7967 = hhdr->hb_prev;
  if (D.7967 == 0B) goto <D.7968>; else goto <D.7969>;
  <D.7968>:
  if (n == -1) goto <D.7970>; else goto <D.7971>;
  <D.7970>:
  D.7972 = hhdr->hb_sz;
  D.7973 = D.7972 >> 12;
  index = GC_hblk_fl_from_blocks (D.7973);
  goto <D.7974>;
  <D.7971>:
  index = n;
  <D.7974>:
  D.7975 = hhdr->hb_next;
  GC_hblkfreelist[index] = D.7975;
  goto <D.7976>;
  <D.7969>:
  {
    struct hdr * phdr;

    D.7967 = hhdr->hb_prev;
    D.7977 = (long unsigned int) D.7967;
    D.7978 = D.7977 >> 22;
    D.7979 = GC_arrays._top_index[D.7978];
    D.7967 = hhdr->hb_prev;
    D.7977 = (long unsigned int) D.7967;
    D.7980 = D.7977 >> 12;
    D.7981 = D.7980 & 1023;
    phdr = D.7979->index[D.7981];
    D.7975 = hhdr->hb_next;
    phdr->hb_next = D.7975;
  }
  <D.7976>:
  D.7975 = hhdr->hb_next;
  if (D.7975 != 0B) goto <D.7982>; else goto <D.7983>;
  <D.7982>:
  {
    struct hdr * nhdr;

    D.7975 = hhdr->hb_next;
    D.7984 = (long unsigned int) D.7975;
    D.7985 = D.7984 >> 22;
    D.7986 = GC_arrays._top_index[D.7985];
    D.7975 = hhdr->hb_next;
    D.7984 = (long unsigned int) D.7975;
    D.7987 = D.7984 >> 12;
    D.7988 = D.7987 & 1023;
    nhdr = D.7986->index[D.7988];
    D.7967 = hhdr->hb_prev;
    nhdr->hb_prev = D.7967;
  }
  <D.7983>:
}


GC_free_block_ending_at (struct hblk * h)
{
  long unsigned int p.13;
  long unsigned int D.7990;
  struct bottom_index * D.7991;
  long unsigned int D.7992;
  long unsigned int D.7993;
  long unsigned int phdr.14;
  long unsigned int D.7995;
  sizetype D.7996;
  _Bool D.7997;
  _Bool D.7998;
  _Bool D.7999;
  map_entry_type * D.8002;
  map_entry_type * GC_invalid_map.15;
  struct hblk * D.8006;
  struct hblk * D.8007;
  long unsigned int D.8012;
  char * D.8013;
  struct hblk * p;
  struct hdr * phdr;

  p = h + 4294963200;
  p.13 = (long unsigned int) p;
  D.7990 = p.13 >> 22;
  D.7991 = GC_arrays._top_index[D.7990];
  p.13 = (long unsigned int) p;
  D.7992 = p.13 >> 12;
  D.7993 = D.7992 & 1023;
  phdr = D.7991->index[D.7993];
  goto <D.7767>;
  <D.7766>:
  phdr.14 = (long unsigned int) phdr;
  D.7995 = phdr.14 * 4096;
  D.7996 = -D.7995;
  p = p + D.7996;
  p.13 = (long unsigned int) p;
  D.7990 = p.13 >> 22;
  D.7991 = GC_arrays._top_index[D.7990];
  p.13 = (long unsigned int) p;
  D.7992 = p.13 >> 12;
  D.7993 = D.7992 & 1023;
  phdr = D.7991->index[D.7993];
  <D.7767>:
  D.7997 = phdr != 0B;
  phdr.14 = (long unsigned int) phdr;
  D.7998 = phdr.14 <= 4095;
  D.7999 = D.7997 & D.7998;
  if (D.7999 != 0) goto <D.7766>; else goto <D.7768>;
  <D.7768>:
  if (phdr != 0B) goto <D.8000>; else goto <D.8001>;
  <D.8000>:
  D.8002 = phdr->hb_map;
  GC_invalid_map.15 = GC_invalid_map;
  if (D.8002 == GC_invalid_map.15) goto <D.8004>; else goto <D.8005>;
  <D.8004>:
  D.8006 = p;
  return D.8006;
  <D.8005>:
  D.8006 = 0B;
  return D.8006;
  <D.8001>:
  D.8007 = h + 4294963200;
  p = GC_prev_block (D.8007);
  if (p != 0B) goto <D.8008>; else goto <D.8009>;
  <D.8008>:
  p.13 = (long unsigned int) p;
  D.7990 = p.13 >> 22;
  D.7991 = GC_arrays._top_index[D.7990];
  p.13 = (long unsigned int) p;
  D.7992 = p.13 >> 12;
  D.7993 = D.7992 & 1023;
  phdr = D.7991->index[D.7993];
  D.8002 = phdr->hb_map;
  GC_invalid_map.15 = GC_invalid_map;
  if (D.8002 == GC_invalid_map.15) goto <D.8010>; else goto <D.8011>;
  <D.8010>:
  D.8012 = phdr->hb_sz;
  D.8013 = p + D.8012;
  if (D.8013 == h) goto <D.8014>; else goto <D.8015>;
  <D.8014>:
  D.8006 = p;
  return D.8006;
  <D.8015>:
  <D.8011>:
  <D.8009>:
  D.8006 = 0B;
  return D.8006;
}


GC_add_to_fl (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.8017;
  long unsigned int D.8018;
  long unsigned int second.16;
  long unsigned int D.8022;
  struct bottom_index * D.8023;
  long unsigned int D.8024;
  long unsigned int D.8025;
  int index;
  struct hblk * second;
  struct hdr * second_hdr;

  D.8017 = hhdr->hb_sz;
  D.8018 = D.8017 >> 12;
  index = GC_hblk_fl_from_blocks (D.8018);
  second = GC_hblkfreelist[index];
  GC_hblkfreelist[index] = h;
  hhdr->hb_next = second;
  hhdr->hb_prev = 0B;
  if (second != 0B) goto <D.8019>; else goto <D.8020>;
  <D.8019>:
  second.16 = (long unsigned int) second;
  D.8022 = second.16 >> 22;
  D.8023 = GC_arrays._top_index[D.8022];
  second.16 = (long unsigned int) second;
  D.8024 = second.16 >> 12;
  D.8025 = D.8024 & 1023;
  second_hdr = D.8023->index[D.8025];
  second_hdr->hb_prev = h;
  <D.8020>:
  GC_invalidate_map (hhdr);
}


GC_unmap_old ()
{
  long unsigned int h.17;
  long unsigned int D.8027;
  struct bottom_index * D.8028;
  long unsigned int D.8029;
  long unsigned int D.8030;
  unsigned char D.8031;
  int D.8032;
  int D.8033;
  long unsigned int GC_gc_no.18;
  short unsigned int D.8037;
  long unsigned int D.8040;
  long unsigned int D.8042;
  unsigned char D.8045;
  struct hblk * h;
  struct hdr * hhdr;
  word sz;
  short unsigned int last_rec;
  short unsigned int threshold;
  int i;

  i = 0;
  goto <D.7790>;
  <D.7789>:
  h = GC_hblkfreelist[i];
  goto <D.7787>;
  <D.7786>:
  h.17 = (long unsigned int) h;
  D.8027 = h.17 >> 22;
  D.8028 = GC_arrays._top_index[D.8027];
  h.17 = (long unsigned int) h;
  D.8029 = h.17 >> 12;
  D.8030 = D.8029 & 1023;
  hhdr = D.8028->index[D.8030];
  D.8031 = hhdr->hb_flags;
  D.8032 = (int) D.8031;
  D.8033 = D.8032 & 2;
  if (D.8033 != 0) goto <D.8034>; else goto <D.8035>;
  <D.8034>:
  // predicted unlikely by continue predictor.
  goto <D.7785>;
  <D.8035>:
  GC_gc_no.18 = GC_gc_no;
  D.8037 = (short unsigned int) GC_gc_no.18;
  threshold = D.8037 + 65530;
  last_rec = hhdr->hb_last_reclaimed;
  D.8040 = (long unsigned int) last_rec;
  GC_gc_no.18 = GC_gc_no;
  if (D.8040 > GC_gc_no.18) goto <D.8038>; else goto <D.8041>;
  <D.8041>:
  if (last_rec < threshold) goto <D.8038>; else goto <D.8039>;
  <D.8038>:
  D.8042 = (long unsigned int) threshold;
  GC_gc_no.18 = GC_gc_no;
  if (D.8042 < GC_gc_no.18) goto <D.8043>; else goto <D.8044>;
  <D.8043>:
  sz = hhdr->hb_sz;
  GC_unmap (h, sz);
  D.8031 = hhdr->hb_flags;
  D.8045 = D.8031 | 2;
  hhdr->hb_flags = D.8045;
  <D.8044>:
  <D.8039>:
  <D.7785>:
  h = hhdr->hb_next;
  <D.7787>:
  if (h != 0B) goto <D.7786>; else goto <D.7788>;
  <D.7788>:
  i = i + 1;
  <D.7790>:
  if (i <= 60) goto <D.7789>; else goto <D.7791>;
  <D.7791>:
}


GC_merge_unmapped ()
{
  long unsigned int h.19;
  long unsigned int D.8047;
  struct bottom_index * D.8048;
  long unsigned int D.8049;
  long unsigned int D.8050;
  long unsigned int D.8051;
  long unsigned int next.20;
  long unsigned int D.8053;
  struct bottom_index * D.8054;
  long unsigned int D.8055;
  long unsigned int D.8056;
  map_entry_type * D.8060;
  map_entry_type * GC_invalid_map.21;
  unsigned char D.8063;
  int D.8064;
  int D.8065;
  unsigned char D.8071;
  unsigned char D.8073;
  int D.8074;
  int D.8075;
  unsigned char D.8081;
  short unsigned int D.8082;
  long unsigned int D.8084;
  long unsigned int D.8085;
  long unsigned int D.8086;
  struct hblk * h;
  struct hblk * next;
  struct hdr * hhdr;
  struct hdr * nexthdr;
  word size;
  word nextsize;
  int i;

  i = 0;
  goto <D.7806>;
  <D.7805>:
  h = GC_hblkfreelist[i];
  goto <D.7803>;
  <D.7802>:
  h.19 = (long unsigned int) h;
  D.8047 = h.19 >> 22;
  D.8048 = GC_arrays._top_index[D.8047];
  h.19 = (long unsigned int) h;
  D.8049 = h.19 >> 12;
  D.8050 = D.8049 & 1023;
  hhdr = D.8048->index[D.8050];
  size = hhdr->hb_sz;
  h.19 = (long unsigned int) h;
  D.8051 = h.19 + size;
  next = (struct hblk *) D.8051;
  next.20 = (long unsigned int) next;
  D.8053 = next.20 >> 22;
  D.8054 = GC_arrays._top_index[D.8053];
  next.20 = (long unsigned int) next;
  D.8055 = next.20 >> 12;
  D.8056 = D.8055 & 1023;
  nexthdr = D.8054->index[D.8056];
  if (nexthdr != 0B) goto <D.8059>; else goto <D.8057>;
  <D.8059>:
  D.8060 = nexthdr->hb_map;
  GC_invalid_map.21 = GC_invalid_map;
  if (D.8060 == GC_invalid_map.21) goto <D.8062>; else goto <D.8057>;
  <D.8062>:
  nextsize = nexthdr->hb_sz;
  D.8063 = hhdr->hb_flags;
  D.8064 = (int) D.8063;
  D.8065 = D.8064 & 2;
  if (D.8065 == 0) goto <D.8066>; else goto <D.8067>;
  <D.8066>:
  if (size > nextsize) goto <D.8068>; else goto <D.8069>;
  <D.8068>:
  GC_remap (next, nextsize);
  goto <D.8070>;
  <D.8069>:
  GC_unmap (h, size);
  D.8063 = hhdr->hb_flags;
  D.8071 = D.8063 | 2;
  hhdr->hb_flags = D.8071;
  <D.8070>:
  goto <D.8072>;
  <D.8067>:
  D.8073 = nexthdr->hb_flags;
  D.8074 = (int) D.8073;
  D.8075 = D.8074 & 2;
  if (D.8075 == 0) goto <D.8076>; else goto <D.8077>;
  <D.8076>:
  if (size > nextsize) goto <D.8078>; else goto <D.8079>;
  <D.8078>:
  GC_unmap (next, nextsize);
  goto <D.8080>;
  <D.8079>:
  GC_remap (h, size);
  D.8063 = hhdr->hb_flags;
  D.8081 = D.8063 & 253;
  hhdr->hb_flags = D.8081;
  D.8082 = nexthdr->hb_last_reclaimed;
  hhdr->hb_last_reclaimed = D.8082;
  <D.8080>:
  goto <D.8083>;
  <D.8077>:
  D.8084 = nexthdr->hb_sz;
  GC_unmap_gap (h, size, next, D.8084);
  <D.8083>:
  <D.8072>:
  GC_remove_from_fl (hhdr, i);
  GC_remove_from_fl (nexthdr, -1);
  D.8085 = hhdr->hb_sz;
  D.8084 = nexthdr->hb_sz;
  D.8086 = D.8085 + D.8084;
  hhdr->hb_sz = D.8086;
  GC_remove_header (next);
  GC_add_to_fl (h, hhdr);
  h = GC_hblkfreelist[i];
  goto <D.8058>;
  <D.8057>:
  h = hhdr->hb_next;
  <D.8058>:
  <D.7803>:
  if (h != 0B) goto <D.7802>; else goto <D.7804>;
  <D.7804>:
  i = i + 1;
  <D.7806>:
  if (i <= 60) goto <D.7805>; else goto <D.7807>;
  <D.7807>:
}


GC_get_first_part (struct hblk * h, struct hdr * hhdr, word bytes, int index)
{
  struct hblk * D.8089;
  long unsigned int h.22;
  long unsigned int D.8091;
  void (*<T1151>) (char *, GC_word) GC_current_warn_proc.23;
  long unsigned int D.8095;
  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.8087>; else goto <D.8088>;
  <D.8087>:
  D.8089 = h;
  return D.8089;
  <D.8088>:
  h.22 = (long unsigned int) h;
  D.8091 = h.22 + bytes;
  rest = (struct hblk *) D.8091;
  rest_hdr = GC_install_header (rest);
  if (rest_hdr == 0B) goto <D.8092>; else goto <D.8093>;
  <D.8092>:
  GC_current_warn_proc.23 = GC_current_warn_proc;
  GC_current_warn_proc.23 ("GC Warning: Header allocation failed: Dropping block.\n", 0);
  D.8089 = 0B;
  return D.8089;
  <D.8093>:
  D.8095 = total_size - bytes;
  rest_hdr->hb_sz = D.8095;
  rest_hdr->hb_flags = 0;
  GC_add_to_fl (rest, rest_hdr);
  D.8089 = h;
  return D.8089;
}


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.8099;
  long unsigned int prev.26;
  long unsigned int D.8103;
  struct bottom_index * D.8104;
  long unsigned int D.8105;
  long unsigned int D.8106;
  struct hdr * D.8107;
  long unsigned int next.27;
  long unsigned int D.8112;
  struct bottom_index * D.8113;
  long unsigned int D.8114;
  long unsigned int D.8115;
  struct hdr * D.8116;
  long unsigned int GC_gc_no.28;
  short unsigned int D.8118;
  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.8099 = total_size - h_size;
  nhdr->hb_sz = D.8099;
  nhdr->hb_flags = 0;
  if (prev != 0B) goto <D.8100>; else goto <D.8101>;
  <D.8100>:
  prev.26 = (long unsigned int) prev;
  D.8103 = prev.26 >> 22;
  D.8104 = GC_arrays._top_index[D.8103];
  prev.26 = (long unsigned int) prev;
  D.8105 = prev.26 >> 12;
  D.8106 = D.8105 & 1023;
  D.8107 = D.8104->index[D.8106];
  D.8107->hb_next = n;
  goto <D.8108>;
  <D.8101>:
  GC_hblkfreelist[index] = n;
  <D.8108>:
  if (next != 0B) goto <D.8109>; else goto <D.8110>;
  <D.8109>:
  next.27 = (long unsigned int) next;
  D.8112 = next.27 >> 22;
  D.8113 = GC_arrays._top_index[D.8112];
  next.27 = (long unsigned int) next;
  D.8114 = next.27 >> 12;
  D.8115 = D.8114 & 1023;
  D.8116 = D.8113->index[D.8115];
  D.8116->hb_prev = n;
  <D.8110>:
  GC_gc_no.28 = GC_gc_no;
  D.8118 = (short unsigned int) GC_gc_no.28;
  hhdr->hb_last_reclaimed = D.8118;
  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.8119;
  long unsigned int D.8120;
  struct hblk * D.8123;
  word blocks;
  int start_list;
  int i;

  D.8119 = sz << 2;
  D.8120 = D.8119 + 4095;
  blocks = D.8120 >> 12;
  start_list = GC_hblk_fl_from_blocks (blocks);
  i = start_list;
  goto <D.7839>;
  <D.7838>:
  {
    struct hblk * result;

    result = GC_allochblk_nth (sz, kind, flags, i);
    if (result != 0B) goto <D.8121>; else goto <D.8122>;
    <D.8121>:
    D.8123 = result;
    return D.8123;
    <D.8122>:
  }
  i = i + 1;
  <D.7839>:
  if (i <= 60) goto <D.7838>; else goto <D.7840>;
  <D.7840>:
  D.8123 = 0B;
  return D.8123;
}


GC_allochblk_nth (word sz, int kind, unsigned char flags, int n)
{
  long unsigned int D.8125;
  long unsigned int D.8126;
  long unsigned int D.8127;
  long unsigned int D.8128;
  long unsigned int hbp.29;
  long unsigned int D.8130;
  struct bottom_index * D.8131;
  long unsigned int D.8132;
  long unsigned int D.8133;
  long unsigned int D.8134;
  int GC_use_entire_heap.30;
  int GC_dont_gc.31;
  long unsigned int D.8147;
  long unsigned int D.8148;
  long unsigned int D.8149;
  long unsigned int D.8150;
  int GC_incremental.32;
  long unsigned int GC_time_limit.33;
  int D.8156;
  long unsigned int thishbp.34;
  long unsigned int D.8162;
  struct bottom_index * D.8163;
  long unsigned int D.8164;
  long unsigned int D.8165;
  long unsigned int D.8166;
  _Bool D.8167;
  _Bool D.8168;
  _Bool D.8169;
  long unsigned int size_needed.35;
  struct hblk * D.8173;
  int D.8176;
  _Bool D.8179;
  _Bool D.8180;
  _Bool D.8181;
  sizetype size_avail.36;
  sizetype size_needed.37;
  sizetype D.8186;
  signed_word iftmp.38;
  int D.8188;
  int D.8189;
  long unsigned int eff_size_needed.39;
  int hbp.40;
  int lasthbp.41;
  int D.8197;
  unsigned char D.8204;
  int D.8205;
  int D.8206;
  unsigned char D.8209;
  long unsigned int GC_black_list_spacing.42;
  long int GC_black_list_spacing.43;
  long int D.8216;
  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 (*<T1151>) (char *, GC_word) GC_current_warn_proc.47;
  _Bool D.8224;
  _Bool D.8225;
  _Bool D.8226;
  int GC_find_leak.48;
  unsigned int count.49;
  unsigned int count.50;
  unsigned int D.8236;
  long unsigned int D.8239;
  long unsigned int D.8240;
  long unsigned int D.8241;
  long unsigned int D.8242;
  long unsigned int D.8243;
  long unsigned int D.8244;
  int GC_debugging_started.51;
  struct hblk * D.8253;
  int D.8260;
  int D.8263;
  long int D.8266;
  long unsigned int D.8267;
  long unsigned int D.8268;
  _Bool D.8269;
  int D.8270;
  long unsigned int D.8271;
  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.8125 = sz << 2;
  D.8126 = D.8125 + 4095;
  D.8127 = D.8126 >> 12;
  D.8128 = D.8127 * 4096;
  size_needed = (signed_word) D.8128;
  hbp = GC_hblkfreelist[n];
  goto <D.7872>;
  <D.7871>:
  hbp.29 = (long unsigned int) hbp;
  D.8130 = hbp.29 >> 22;
  D.8131 = GC_arrays._top_index[D.8130];
  hbp.29 = (long unsigned int) hbp;
  D.8132 = hbp.29 >> 12;
  D.8133 = D.8132 & 1023;
  hhdr = D.8131->index[D.8133];
  D.8134 = hhdr->hb_sz;
  size_avail = (signed_word) D.8134;
  if (size_avail < size_needed) goto <D.8135>; else goto <D.8136>;
  <D.8135>:
  // predicted unlikely by continue predictor.
  goto <D.7853>;
  <D.8136>:
  if (size_avail != size_needed) goto <D.8139>; else goto <D.8140>;
  <D.8139>:
  GC_use_entire_heap.30 = GC_use_entire_heap;
  if (GC_use_entire_heap.30 == 0) goto <D.8142>; else goto <D.8143>;
  <D.8142>:
  GC_dont_gc.31 = GC_dont_gc;
  if (GC_dont_gc.31 == 0) goto <D.8145>; else goto <D.8146>;
  <D.8145>:
  D.8147 = GC_arrays._heapsize;
  D.8148 = GC_arrays._large_free_bytes;
  D.8149 = D.8147 - D.8148;
  D.8150 = GC_arrays._requested_heapsize;
  if (D.8149 >= D.8150) goto <D.8151>; else goto <D.8152>;
  <D.8151>:
  GC_incremental.32 = GC_incremental;
  if (GC_incremental.32 == 0) goto <D.8137>; else goto <D.8154>;
  <D.8154>:
  GC_time_limit.33 = GC_time_limit;
  if (GC_time_limit.33 == 999999) goto <D.8137>; else goto <D.8138>;
  <D.8137>:
  D.8156 = GC_should_collect ();
  if (D.8156 != 0) goto <D.8157>; else goto <D.8158>;
  <D.8157>:
  // predicted unlikely by continue predictor.
  goto <D.7853>;
  <D.8158>:
  <D.8138>:
  <D.8152>:
  <D.8146>:
  <D.8143>:
  <D.8140>:
  {
    signed_word next_size;

    thishbp = hhdr->hb_next;
    if (thishbp != 0B) goto <D.8159>; else goto <D.8160>;
    <D.8159>:
    thishbp.34 = (long unsigned int) thishbp;
    D.8162 = thishbp.34 >> 22;
    D.8163 = GC_arrays._top_index[D.8162];
    thishbp.34 = (long unsigned int) thishbp;
    D.8164 = thishbp.34 >> 12;
    D.8165 = D.8164 & 1023;
    thishdr = D.8163->index[D.8165];
    D.8166 = thishdr->hb_sz;
    next_size = (signed_word) D.8166;
    D.8167 = next_size < size_avail;
    D.8168 = next_size >= size_needed;
    D.8169 = D.8167 & D.8168;
    if (D.8169 != 0) goto <D.8170>; else goto <D.8171>;
    <D.8170>:
    size_needed.35 = (long unsigned int) size_needed;
    D.8173 = GC_is_black_listed (thishbp, size_needed.35);
    if (D.8173 == 0B) goto <D.8174>; else goto <D.8175>;
    <D.8174>:
    // predicted unlikely by continue predictor.
    goto <D.7853>;
    <D.8175>:
    <D.8171>:
    <D.8160>:
  }
  D.8176 = kind & -2;
  if (D.8176 != 2) goto <D.8177>; else goto <D.8178>;
  <D.8177>:
  D.8179 = kind != 0;
  size_needed.35 = (long unsigned int) size_needed;
  D.8180 = size_needed.35 > 8192;
  D.8181 = D.8179 | D.8180;
  if (D.8181 != 0) goto <D.8182>; else goto <D.8183>;
  <D.8182>:
  {
    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.8186 = size_avail.36 - size_needed.37;
    search_end = hbp + D.8186;
    orig_avail = size_avail;
    D.8188 = (int) flags;
    D.8189 = D.8188 & 1;
    if (D.8189 == 0) goto <D.8190>; else goto <D.8191>;
    <D.8190>:
    iftmp.38 = size_needed;
    goto <D.8192>;
    <D.8191>:
    iftmp.38 = 4096;
    <D.8192>:
    eff_size_needed = iftmp.38;
    goto <D.7860>;
    <D.7859>:
    lasthbp = thishbp;
    <D.7860>:
    if (lasthbp <= search_end) goto <D.8193>; else goto <D.7861>;
    <D.8193>:
    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.7859>; else goto <D.7861>;
    <D.7861>:
    hbp.40 = (int) hbp;
    lasthbp.41 = (int) lasthbp;
    D.8197 = hbp.40 - lasthbp.41;
    size_avail = D.8197 + size_avail;
    thishbp = lasthbp;
    if (size_avail >= size_needed) goto <D.8198>; else goto <D.8199>;
    <D.8198>:
    if (thishbp != hbp) goto <D.8200>; else goto <D.8201>;
    <D.8200>:
    thishdr = GC_install_header (thishbp);
    if (thishdr != 0B) goto <D.8202>; else goto <D.8203>;
    <D.8202>:
    D.8204 = hhdr->hb_flags;
    D.8205 = (int) D.8204;
    D.8206 = D.8205 & 2;
    if (D.8206 != 0) goto <D.8207>; else goto <D.8208>;
    <D.8207>:
    D.8134 = hhdr->hb_sz;
    GC_remap (hbp, D.8134);
    D.8204 = hhdr->hb_flags;
    D.8209 = D.8204 & 253;
    hhdr->hb_flags = D.8209;
    <D.8208>:
    GC_split_block (hbp, hhdr, thishbp, thishdr, n);
    hbp = thishbp;
    hhdr = thishdr;
    <D.8203>:
    <D.8201>:
    goto <D.8210>;
    <D.8199>:
    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.8215>; else goto <D.8211>;
    <D.8215>:
    D.8216 = 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.8216 > GC_black_list_spacing.43) goto <D.8217>; else goto <D.8211>;
    <D.8217>:
    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.8221>; else goto <D.8222>;
    <D.8221>:
    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.8222>:
    size_avail = orig_avail;
    goto <D.8212>;
    <D.8211>:
    D.8224 = size_avail == 0;
    D.8225 = size_needed == 4096;
    D.8226 = D.8224 & D.8225;
    if (D.8226 != 0) goto <D.8227>; else goto <D.8228>;
    <D.8227>:
    D.8204 = hhdr->hb_flags;
    D.8205 = (int) D.8204;
    D.8206 = D.8205 & 2;
    if (D.8206 == 0) goto <D.8229>; else goto <D.8230>;
    <D.8229>:
    GC_find_leak.48 = GC_find_leak;
    if (GC_find_leak.48 == 0) goto <D.8232>; else goto <D.8233>;
    <D.8232>:
    {
      static unsigned int count = 0;

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

        total_size = hhdr->hb_sz;
        D.8239 = total_size >> 12;
        D.8240 = D.8239 * 4096;
        limit = hbp + D.8240;
        prev = hhdr->hb_prev;
        D.8241 = GC_arrays._words_wasted;
        D.8242 = total_size >> 2;
        D.8243 = D.8241 + D.8242;
        GC_arrays._words_wasted = D.8243;
        D.8148 = GC_arrays._large_free_bytes;
        D.8244 = D.8148 - total_size;
        GC_arrays._large_free_bytes = D.8244;
        GC_remove_from_fl (hhdr, n);
        h = hbp;
        goto <D.7868>;
        <D.7867>:
        if (h == hbp) goto <D.8245>; else goto <D.8247>;
        <D.8247>:
        hhdr = GC_install_header (h);
        if (hhdr != 0B) goto <D.8245>; else goto <D.8246>;
        <D.8245>:
        setup_header (hhdr, 1024, 0, 0);
        GC_debugging_started.51 = GC_debugging_started;
        if (GC_debugging_started.51 != 0) goto <D.8249>; else goto <D.8250>;
        <D.8249>:
        memset (h, 0, 4096);
        <D.8250>:
        <D.8246>:
        h = h + 4096;
        <D.7868>:
        if (h < limit) goto <D.7867>; else goto <D.7869>;
        <D.7869>:
        hbp = prev;
        if (hbp == 0B) goto <D.8251>; else goto <D.8252>;
        <D.8251>:
        D.8188 = (int) flags;
        D.8253 = GC_allochblk_nth (sz, kind, D.8188, n);
        return D.8253;
        <D.8252>:
        hbp.29 = (long unsigned int) hbp;
        D.8130 = hbp.29 >> 22;
        D.8131 = GC_arrays._top_index[D.8130];
        hbp.29 = (long unsigned int) hbp;
        D.8132 = hbp.29 >> 12;
        D.8133 = D.8132 & 1023;
        hhdr = D.8131->index[D.8133];
      }
      <D.8238>:
    }
    <D.8233>:
    <D.8230>:
    <D.8228>:
    <D.8212>:
    <D.8210>:
  }
  <D.8183>:
  <D.8178>:
  if (size_avail >= size_needed) goto <D.8254>; else goto <D.8255>;
  <D.8254>:
  D.8204 = hhdr->hb_flags;
  D.8205 = (int) D.8204;
  D.8206 = D.8205 & 2;
  if (D.8206 != 0) goto <D.8256>; else goto <D.8257>;
  <D.8256>:
  D.8134 = hhdr->hb_sz;
  GC_remap (hbp, D.8134);
  D.8204 = hhdr->hb_flags;
  D.8209 = D.8204 & 253;
  hhdr->hb_flags = D.8209;
  <D.8257>:
  hbp = GC_get_first_part (hbp, hhdr, size_needed, n);
  goto <D.7870>;
  <D.8255>:
  <D.7853>:
  hbp = hhdr->hb_next;
  <D.7872>:
  if (hbp != 0B) goto <D.7871>; else goto <D.7870>;
  <D.7870>:
  if (hbp == 0B) goto <D.8258>; else goto <D.8259>;
  <D.8258>:
  D.8253 = 0B;
  return D.8253;
  <D.8259>:
  size_needed.35 = (long unsigned int) size_needed;
  D.8260 = GC_install_counts (hbp, size_needed.35);
  if (D.8260 == 0) goto <D.8261>; else goto <D.8262>;
  <D.8261>:
  D.8253 = 0B;
  return D.8253;
  <D.8262>:
  D.8188 = (int) flags;
  D.8263 = setup_header (hhdr, sz, kind, D.8188);
  if (D.8263 == 0) goto <D.8264>; else goto <D.8265>;
  <D.8264>:
  size_needed.35 = (long unsigned int) size_needed;
  GC_remove_counts (hbp, size_needed.35);
  D.8253 = 0B;
  return D.8253;
  <D.8265>:
  D.8266 = size_needed >> 12;
  D.8267 = (long unsigned int) D.8266;
  D.8268 = hhdr->hb_descr;
  D.8269 = D.8268 == 0;
  D.8270 = (int) D.8269;
  GC_remove_protection (hbp, D.8267, D.8270);
  {
    extern unsigned int GC_fail_count;

    GC_fail_count = 0;
  }
  D.8148 = GC_arrays._large_free_bytes;
  size_needed.35 = (long unsigned int) size_needed;
  D.8271 = D.8148 - size_needed.35;
  GC_arrays._large_free_bytes = D.8271;
  D.8253 = hbp;
  return D.8253;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.8275;
  int D.8280;
  void * D.8282;
  unsigned int D.8283;

  D.8275 = __builtin_constant_p (__len);
  if (D.8275 != 0) goto <D.8276>; else goto <D.8277>;
  <D.8276>:
  if (__len == 0) goto <D.8278>; else goto <D.8279>;
  <D.8278>:
  D.8280 = __builtin_constant_p (__ch);
  if (D.8280 == 0) goto <D.8273>; else goto <D.8281>;
  <D.8281>:
  if (__ch != 0) goto <D.8273>; else goto <D.8274>;
  <D.8273>:
  __warn_memset_zero_len ();
  D.8282 = __dest;
  return D.8282;
  <D.8274>:
  <D.8279>:
  <D.8277>:
  D.8283 = __builtin_object_size (__dest, 0);
  D.8282 = __builtin___memset_chk (__dest, __ch, __len, D.8283);
  return D.8282;
}


setup_header (struct hdr * hhdr, word sz, int kind, unsigned char flags)
{
  int D.8285;
  GC_bool D.8288;
  long unsigned int iftmp.52;
  map_entry_type * D.8293;
  unsigned char D.8294;
  int D.8295;
  long unsigned int D.8298;
  long unsigned int GC_gc_no.53;
  short unsigned int D.8300;
  register word descr;

  D.8285 = GC_add_map_entry (sz);
  if (D.8285 == 0) goto <D.8286>; else goto <D.8287>;
  <D.8286>:
  D.8288 = 0;
  return D.8288;
  <D.8287>:
  if (sz <= 512) goto <D.8290>; else goto <D.8291>;
  <D.8290>:
  iftmp.52 = sz;
  goto <D.8292>;
  <D.8291>:
  iftmp.52 = 0;
  <D.8292>:
  D.8293 = GC_arrays._obj_map[iftmp.52];
  hhdr->hb_map = D.8293;
  hhdr->hb_sz = sz;
  D.8294 = (unsigned char) kind;
  hhdr->hb_obj_kind = D.8294;
  hhdr->hb_flags = flags;
  descr = GC_obj_kinds[kind].ok_descriptor;
  D.8295 = GC_obj_kinds[kind].ok_relocate_descr;
  if (D.8295 != 0) goto <D.8296>; else goto <D.8297>;
  <D.8296>:
  D.8298 = sz << 2;
  descr = D.8298 + descr;
  <D.8297>:
  hhdr->hb_descr = descr;
  GC_clear_hdr_marks (hhdr);
  GC_gc_no.53 = GC_gc_no;
  D.8300 = (short unsigned int) GC_gc_no.53;
  hhdr->hb_last_reclaimed = D.8300;
  D.8288 = 1;
  return D.8288;
}


GC_freehblk (struct hblk * hbp)
{
  long unsigned int hbp.54;
  long unsigned int D.8303;
  struct bottom_index * D.8304;
  long unsigned int D.8305;
  long unsigned int D.8306;
  long unsigned int D.8307;
  long int D.8308;
  long unsigned int D.8309;
  long unsigned int D.8310;
  long unsigned int D.8311;
  long unsigned int D.8312;
  long unsigned int size.55;
  long unsigned int size.56;
  long unsigned int GC_gc_no.57;
  short unsigned int D.8316;
  map_entry_type * D.8317;
  map_entry_type * GC_invalid_map.58;
  long int hbp.59;
  long unsigned int D.8322;
  long unsigned int next.60;
  long unsigned int D.8324;
  struct bottom_index * D.8325;
  long unsigned int D.8326;
  long unsigned int D.8327;
  map_entry_type * D.8330;
  unsigned char D.8333;
  int D.8334;
  int D.8335;
  long unsigned int D.8338;
  long unsigned int D.8339;
  long unsigned int prev.61;
  long unsigned int D.8343;
  struct bottom_index * D.8344;
  long unsigned int D.8345;
  long unsigned int D.8346;
  unsigned char D.8347;
  int D.8348;
  int D.8349;
  long unsigned int D.8352;
  long unsigned int D.8353;
  long unsigned int D.8354;
  long unsigned int D.8355;
  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.8303 = hbp.54 >> 22;
  D.8304 = GC_arrays._top_index[D.8303];
  hbp.54 = (long unsigned int) hbp;
  D.8305 = hbp.54 >> 12;
  D.8306 = D.8305 & 1023;
  hhdr = D.8304->index[D.8306];
  D.8307 = hhdr->hb_sz;
  size = (signed_word) D.8307;
  D.8308 = size << 2;
  D.8309 = (long unsigned int) D.8308;
  D.8310 = D.8309 + 4095;
  D.8311 = D.8310 >> 12;
  D.8312 = D.8311 * 4096;
  size = (signed_word) D.8312;
  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.8316 = (short unsigned int) GC_gc_no.57;
  hhdr->hb_last_reclaimed = D.8316;
  D.8317 = hhdr->hb_map;
  GC_invalid_map.58 = GC_invalid_map;
  if (D.8317 == GC_invalid_map.58) goto <D.8319>; else goto <D.8320>;
  <D.8319>:
  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.8320>:
  GC_invalidate_map (hhdr);
  hbp.54 = (long unsigned int) hbp;
  size.55 = (long unsigned int) size;
  D.8322 = hbp.54 + size.55;
  next = (struct hblk *) D.8322;
  next.60 = (long unsigned int) next;
  D.8324 = next.60 >> 22;
  D.8325 = GC_arrays._top_index[D.8324];
  next.60 = (long unsigned int) next;
  D.8326 = next.60 >> 12;
  D.8327 = D.8326 & 1023;
  nexthdr = D.8325->index[D.8327];
  prev = GC_free_block_ending_at (hbp);
  if (nexthdr != 0B) goto <D.8328>; else goto <D.8329>;
  <D.8328>:
  D.8330 = nexthdr->hb_map;
  GC_invalid_map.58 = GC_invalid_map;
  if (D.8330 == GC_invalid_map.58) goto <D.8331>; else goto <D.8332>;
  <D.8331>:
  D.8333 = nexthdr->hb_flags;
  D.8334 = (int) D.8333;
  D.8335 = D.8334 & 2;
  if (D.8335 == 0) goto <D.8336>; else goto <D.8337>;
  <D.8336>:
  GC_remove_from_fl (nexthdr, -1);
  D.8307 = hhdr->hb_sz;
  D.8338 = nexthdr->hb_sz;
  D.8339 = D.8307 + D.8338;
  hhdr->hb_sz = D.8339;
  GC_remove_header (next);
  <D.8337>:
  <D.8332>:
  <D.8329>:
  if (prev != 0B) goto <D.8340>; else goto <D.8341>;
  <D.8340>:
  prev.61 = (long unsigned int) prev;
  D.8343 = prev.61 >> 22;
  D.8344 = GC_arrays._top_index[D.8343];
  prev.61 = (long unsigned int) prev;
  D.8345 = prev.61 >> 12;
  D.8346 = D.8345 & 1023;
  prevhdr = D.8344->index[D.8346];
  D.8347 = prevhdr->hb_flags;
  D.8348 = (int) D.8347;
  D.8349 = D.8348 & 2;
  if (D.8349 == 0) goto <D.8350>; else goto <D.8351>;
  <D.8350>:
  GC_remove_from_fl (prevhdr, -1);
  D.8352 = prevhdr->hb_sz;
  D.8307 = hhdr->hb_sz;
  D.8353 = D.8352 + D.8307;
  prevhdr->hb_sz = D.8353;
  GC_gc_no.57 = GC_gc_no;
  D.8316 = (short unsigned int) GC_gc_no.57;
  prevhdr->hb_last_reclaimed = D.8316;
  GC_remove_header (hbp);
  hbp = prev;
  hhdr = prevhdr;
  <D.8351>:
  <D.8341>:
  D.8354 = GC_arrays._large_free_bytes;
  size.55 = (long unsigned int) size;
  D.8355 = D.8354 + size.55;
  GC_arrays._large_free_bytes = D.8355;
  GC_add_to_fl (hbp, hhdr);
}