GC_hblk_fl_from_blocks (word blocks_needed)
{
  int D.5879;
  long unsigned int D.5882;
  long unsigned int D.5883;
  unsigned int D.5884;
  unsigned int D.5885;

  if (blocks_needed <= 32) goto <D.5877>; else goto <D.5878>;
  <D.5877>:
  D.5879 = (int) blocks_needed;
  return D.5879;
  <D.5878>:
  if (blocks_needed > 255) goto <D.5880>; else goto <D.5881>;
  <D.5880>:
  D.5879 = 60;
  return D.5879;
  <D.5881>:
  D.5882 = blocks_needed + 18446744073709551584;
  D.5883 = D.5882 / 8;
  D.5884 = (unsigned int) D.5883;
  D.5885 = D.5884 + 32;
  D.5879 = (int) D.5885;
  return D.5879;
}


GC_print_hblkfreelist ()
{
  long int D.5889;
  long int h.0;
  long int sz.1;
  struct hblk * D.5892;
  long unsigned int D.5896;
  struct hblk * D.5897;
  long int total_free.2;
  struct hblk * h;
  word total_free;
  struct hdr * hhdr;
  word sz;
  int i;

  total_free = 0;
  i = 0;
  goto <D.5635>;
  <D.5634>:
  h = GC_hblkfreelist[i];
  if (h != 0B) goto <D.5887>; else goto <D.5888>;
  <D.5887>:
  D.5889 = (long int) i;
  GC_printf ("Free list %ld:\n", D.5889, 0, 0, 0, 0, 0);
  <D.5888>:
  goto <D.5632>;
  <D.5631>:
  hhdr = GC_find_header (h);
  sz = hhdr->hb_sz;
  h.0 = (long int) h;
  sz.1 = (long int) sz;
  GC_printf ("\t0x%lx size %lu ", h.0, sz.1, 0, 0, 0, 0);
  total_free = total_free + sz;
  D.5892 = GC_is_black_listed (h, 4096);
  if (D.5892 != 0B) goto <D.5893>; else goto <D.5894>;
  <D.5893>:
  GC_printf ("start black listed\n", 0, 0, 0, 0, 0, 0);
  goto <D.5895>;
  <D.5894>:
  D.5896 = hhdr->hb_sz;
  D.5897 = GC_is_black_listed (h, D.5896);
  if (D.5897 != 0B) goto <D.5898>; else goto <D.5899>;
  <D.5898>:
  GC_printf ("partially black listed\n", 0, 0, 0, 0, 0, 0);
  goto <D.5900>;
  <D.5899>:
  GC_printf ("not black listed\n", 0, 0, 0, 0, 0, 0);
  <D.5900>:
  <D.5895>:
  h = hhdr->hb_next;
  <D.5632>:
  if (h != 0B) goto <D.5631>; else goto <D.5633>;
  <D.5633>:
  i = i + 1;
  <D.5635>:
  if (i <= 60) goto <D.5634>; else goto <D.5636>;
  <D.5636>:
  total_free.2 = (long int) total_free;
  GC_printf ("Total of %lu bytes on free list\n", total_free.2, 0, 0, 0, 0, 0);
}


free_list_index_of (struct hdr * wanted)
{
  int D.5904;
  struct hblk * h;
  struct hdr * hhdr;
  int i;

  i = 0;
  goto <D.5647>;
  <D.5646>:
  h = GC_hblkfreelist[i];
  goto <D.5644>;
  <D.5643>:
  hhdr = GC_find_header (h);
  if (hhdr == wanted) goto <D.5902>; else goto <D.5903>;
  <D.5902>:
  D.5904 = i;
  return D.5904;
  <D.5903>:
  h = hhdr->hb_next;
  <D.5644>:
  if (h != 0B) goto <D.5643>; else goto <D.5645>;
  <D.5645>:
  i = i + 1;
  <D.5647>:
  if (i <= 60) goto <D.5646>; else goto <D.5648>;
  <D.5648>:
  D.5904 = -1;
  return D.5904;
}


GC_dump_regions ()
{
  char * D.5906;
  long unsigned int D.5907;
  unsigned int D.5908;
  long unsigned int D.5909;
  long unsigned int GC_n_heap_sects.3;
  char * D.5912;
  long int start.4;
  long int end.5;
  long int p.6;
  long unsigned int hhdr.7;
  long int hhdr.8;
  map_entry_type * D.5920;
  map_entry_type * GC_invalid_map.9;
  long unsigned int D.5924;
  long unsigned int D.5925;
  long int D.5926;
  unsigned char D.5927;
  int D.5928;
  int D.5929;
  long int D.5935;
  long int D.5939;
  long unsigned int D.5941;
  long int D.5942;
  long unsigned int D.5943;
  long unsigned int D.5944;
  long unsigned int D.5945;
  long unsigned int D.5946;
  unsigned int i;
  char * start;
  char * end;
  char * p;
  size_t bytes;
  struct hdr * hhdr;

  i = 0;
  goto <D.5666>;
  <D.5665>:
  start = GC_arrays._heap_sects[i].hs_start;
  bytes = GC_arrays._heap_sects[i].hs_bytes;
  end = start + bytes;
  goto <D.5658>;
  <D.5657>:
  i = i + 1;
  D.5906 = GC_arrays._heap_sects[i].hs_start;
  D.5907 = GC_arrays._heap_sects[i].hs_bytes;
  end = D.5906 + D.5907;
  <D.5658>:
  D.5908 = i + 1;
  D.5909 = (long unsigned int) D.5908;
  GC_n_heap_sects.3 = GC_n_heap_sects;
  if (D.5909 < GC_n_heap_sects.3) goto <D.5911>; else goto <D.5659>;
  <D.5911>:
  D.5908 = i + 1;
  D.5912 = GC_arrays._heap_sects[D.5908].hs_start;
  if (D.5912 == end) goto <D.5657>; else goto <D.5659>;
  <D.5659>:
  start.4 = (long int) start;
  end.5 = (long int) end;
  GC_printf ("***Section from 0x%lx to 0x%lx\n", start.4, end.5, 0, 0, 0, 0);
  p = start;
  goto <D.5660>;
  <D.5663>:
  hhdr = GC_find_header (p);
  p.6 = (long int) p;
  GC_printf ("\t0x%lx ", p.6, 0, 0, 0, 0, 0);
  hhdr.7 = (long unsigned int) hhdr;
  if (hhdr.7 <= 4095) goto <D.5917>; else goto <D.5918>;
  <D.5917>:
  hhdr.8 = (long int) hhdr;
  GC_printf ("Missing header!!(%ld)\n", hhdr.8, 0, 0, 0, 0, 0);
  p = p + 4096;
  // predicted unlikely by continue predictor.
  goto <D.5660>;
  <D.5918>:
  D.5920 = hhdr->hb_map;
  GC_invalid_map.9 = GC_invalid_map;
  if (D.5920 == GC_invalid_map.9) goto <D.5922>; else goto <D.5923>;
  <D.5922>:
  {
    int correct_index;
    int actual_index;

    D.5924 = hhdr->hb_sz;
    D.5925 = D.5924 >> 12;
    correct_index = GC_hblk_fl_from_blocks (D.5925);
    D.5924 = hhdr->hb_sz;
    D.5926 = (long int) D.5924;
    GC_printf ("\tfree block of size 0x%lx bytes", D.5926, 0, 0, 0, 0, 0);
    D.5927 = hhdr->hb_flags;
    D.5928 = (int) D.5927;
    D.5929 = D.5928 & 2;
    if (D.5929 == 0) goto <D.5930>; else goto <D.5931>;
    <D.5930>:
    GC_printf ("\n", 0, 0, 0, 0, 0, 0);
    goto <D.5932>;
    <D.5931>:
    GC_printf ("(unmapped)\n", 0, 0, 0, 0, 0, 0);
    <D.5932>:
    actual_index = free_list_index_of (hhdr);
    if (actual_index == -1) goto <D.5933>; else goto <D.5934>;
    <D.5933>:
    D.5935 = (long int) correct_index;
    GC_printf ("\t\tBlock not on free list %ld!!\n", D.5935, 0, 0, 0, 0, 0);
    goto <D.5936>;
    <D.5934>:
    if (correct_index != actual_index) goto <D.5937>; else goto <D.5938>;
    <D.5937>:
    D.5939 = (long int) actual_index;
    D.5935 = (long int) correct_index;
    GC_printf ("\t\tBlock on list %ld, should be on %ld!!\n", D.5939, D.5935, 0, 0, 0, 0);
    <D.5938>:
    <D.5936>:
    D.5924 = hhdr->hb_sz;
    p = p + D.5924;
  }
  goto <D.5940>;
  <D.5923>:
  D.5924 = hhdr->hb_sz;
  D.5941 = D.5924 << 3;
  D.5942 = (long int) D.5941;
  GC_printf ("\tused for blocks of size 0x%lx bytes\n", D.5942, 0, 0, 0, 0, 0);
  D.5924 = hhdr->hb_sz;
  D.5941 = D.5924 << 3;
  D.5943 = D.5941 + 4095;
  D.5944 = D.5943 >> 12;
  D.5945 = D.5944 * 4096;
  p = p + D.5945;
  <D.5940>:
  <D.5660>:
  if (p < end) goto <D.5663>; else goto <D.5664>;
  <D.5664>:
  i = i + 1;
  <D.5666>:
  D.5946 = (long unsigned int) i;
  GC_n_heap_sects.3 = GC_n_heap_sects;
  if (D.5946 < GC_n_heap_sects.3) goto <D.5665>; else goto <D.5667>;
  <D.5667>:
}


GC_remove_from_fl (struct hdr * hhdr, int n)
{
  struct hblk * D.5947;
  long unsigned int D.5952;
  long unsigned int D.5953;
  struct hblk * D.5955;
  long unsigned int D.5957;
  long unsigned int D.5958;
  long unsigned int D.5959;
  struct bottom_index * D.5961;
  long unsigned int D.5962;
  long unsigned int D.5963;
  long unsigned int D.5966;
  long unsigned int D.5967;
  long unsigned int D.5968;
  long unsigned int D.5970;
  long unsigned int D.5971;
  int index;

  D.5947 = hhdr->hb_prev;
  if (D.5947 == 0B) goto <D.5948>; else goto <D.5949>;
  <D.5948>:
  if (n == -1) goto <D.5950>; else goto <D.5951>;
  <D.5950>:
  D.5952 = hhdr->hb_sz;
  D.5953 = D.5952 >> 12;
  index = GC_hblk_fl_from_blocks (D.5953);
  goto <D.5954>;
  <D.5951>:
  index = n;
  <D.5954>:
  D.5955 = hhdr->hb_next;
  GC_hblkfreelist[index] = D.5955;
  goto <D.5956>;
  <D.5949>:
  {
    struct hdr * phdr;

    {
      register struct hdr * * _ha;

      {
        register struct bottom_index * bi;

        {
          register word hi;
          register struct bottom_index * _bi;

          D.5947 = hhdr->hb_prev;
          D.5957 = (long unsigned int) D.5947;
          hi = D.5957 >> 22;
          D.5958 = hi & 2047;
          _bi = GC_arrays._top_index[D.5958];
          goto <D.5686>;
          <D.5685>:
          _bi = _bi->hash_link;
          <D.5686>:
          D.5959 = _bi->key;
          if (D.5959 != hi) goto <D.5960>; else goto <D.5687>;
          <D.5960>:
          D.5961 = GC_arrays._all_nils;
          if (D.5961 != _bi) goto <D.5685>; else goto <D.5687>;
          <D.5687>:
          bi = _bi;
        }
        D.5947 = hhdr->hb_prev;
        D.5957 = (long unsigned int) D.5947;
        D.5962 = D.5957 >> 12;
        D.5963 = D.5962 & 1023;
        _ha = &bi->index[D.5963];
      }
      phdr = *_ha;
    }
    D.5955 = hhdr->hb_next;
    phdr->hb_next = D.5955;
  }
  <D.5956>:
  D.5955 = hhdr->hb_next;
  if (D.5955 != 0B) goto <D.5964>; else goto <D.5965>;
  <D.5964>:
  {
    struct hdr * nhdr;

    {
      register struct hdr * * _ha;

      {
        register struct bottom_index * bi;

        {
          register word hi;
          register struct bottom_index * _bi;

          D.5955 = hhdr->hb_next;
          D.5966 = (long unsigned int) D.5955;
          hi = D.5966 >> 22;
          D.5967 = hi & 2047;
          _bi = GC_arrays._top_index[D.5967];
          goto <D.5694>;
          <D.5693>:
          _bi = _bi->hash_link;
          <D.5694>:
          D.5968 = _bi->key;
          if (D.5968 != hi) goto <D.5969>; else goto <D.5695>;
          <D.5969>:
          D.5961 = GC_arrays._all_nils;
          if (D.5961 != _bi) goto <D.5693>; else goto <D.5695>;
          <D.5695>:
          bi = _bi;
        }
        D.5955 = hhdr->hb_next;
        D.5966 = (long unsigned int) D.5955;
        D.5970 = D.5966 >> 12;
        D.5971 = D.5970 & 1023;
        _ha = &bi->index[D.5971];
      }
      nhdr = *_ha;
    }
    D.5947 = hhdr->hb_prev;
    nhdr->hb_prev = D.5947;
  }
  <D.5965>:
}


GC_free_block_ending_at (struct hblk * h)
{
  long unsigned int p.10;
  long unsigned int D.5973;
  long unsigned int D.5974;
  struct bottom_index * D.5976;
  long unsigned int D.5977;
  long unsigned int D.5978;
  long unsigned int phdr.11;
  long unsigned int D.5980;
  sizetype D.5981;
  map_entry_type * D.5985;
  map_entry_type * GC_invalid_map.12;
  struct hblk * D.5989;
  struct hblk * D.5990;
  long unsigned int D.5995;
  char * D.5996;
  struct hblk * p;
  struct hdr * phdr;

  p = h + 18446744073709547520;
  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        p.10 = (long unsigned int) p;
        hi = p.10 >> 22;
        D.5973 = hi & 2047;
        _bi = GC_arrays._top_index[D.5973];
        goto <D.5706>;
        <D.5705>:
        _bi = _bi->hash_link;
        <D.5706>:
        D.5974 = _bi->key;
        if (D.5974 != hi) goto <D.5975>; else goto <D.5707>;
        <D.5975>:
        D.5976 = GC_arrays._all_nils;
        if (D.5976 != _bi) goto <D.5705>; else goto <D.5707>;
        <D.5707>:
        bi = _bi;
      }
      p.10 = (long unsigned int) p;
      D.5977 = p.10 >> 12;
      D.5978 = D.5977 & 1023;
      _ha = &bi->index[D.5978];
    }
    phdr = *_ha;
  }
  goto <D.5709>;
  <D.5708>:
  phdr.11 = (long unsigned int) phdr;
  D.5980 = phdr.11 * 4096;
  D.5981 = -D.5980;
  p = p + D.5981;
  phdr = GC_find_header (p);
  <D.5709>:
  if (phdr != 0B) goto <D.5982>; else goto <D.5710>;
  <D.5982>:
  phdr.11 = (long unsigned int) phdr;
  if (phdr.11 <= 4095) goto <D.5708>; else goto <D.5710>;
  <D.5710>:
  if (phdr != 0B) goto <D.5983>; else goto <D.5984>;
  <D.5983>:
  D.5985 = phdr->hb_map;
  GC_invalid_map.12 = GC_invalid_map;
  if (D.5985 == GC_invalid_map.12) goto <D.5987>; else goto <D.5988>;
  <D.5987>:
  D.5989 = p;
  return D.5989;
  <D.5988>:
  D.5989 = 0B;
  return D.5989;
  <D.5984>:
  D.5990 = h + 18446744073709547520;
  p = GC_prev_block (D.5990);
  if (p != 0B) goto <D.5991>; else goto <D.5992>;
  <D.5991>:
  phdr = GC_find_header (p);
  D.5985 = phdr->hb_map;
  GC_invalid_map.12 = GC_invalid_map;
  if (D.5985 == GC_invalid_map.12) goto <D.5993>; else goto <D.5994>;
  <D.5993>:
  D.5995 = phdr->hb_sz;
  D.5996 = p + D.5995;
  if (D.5996 == h) goto <D.5997>; else goto <D.5998>;
  <D.5997>:
  D.5989 = p;
  return D.5989;
  <D.5998>:
  <D.5994>:
  <D.5992>:
  D.5989 = 0B;
  return D.5989;
}


GC_add_to_fl (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.6000;
  long unsigned int D.6001;
  long unsigned int second.13;
  long unsigned int D.6005;
  long unsigned int D.6006;
  struct bottom_index * D.6008;
  long unsigned int D.6009;
  long unsigned int D.6010;
  int index;
  struct hblk * second;
  struct hdr * second_hdr;

  D.6000 = hhdr->hb_sz;
  D.6001 = D.6000 >> 12;
  index = GC_hblk_fl_from_blocks (D.6001);
  second = GC_hblkfreelist[index];
  GC_hblkfreelist[index] = h;
  hhdr->hb_next = second;
  hhdr->hb_prev = 0B;
  if (second != 0B) goto <D.6002>; else goto <D.6003>;
  <D.6002>:
  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        second.13 = (long unsigned int) second;
        hi = second.13 >> 22;
        D.6005 = hi & 2047;
        _bi = GC_arrays._top_index[D.6005];
        goto <D.5723>;
        <D.5722>:
        _bi = _bi->hash_link;
        <D.5723>:
        D.6006 = _bi->key;
        if (D.6006 != hi) goto <D.6007>; else goto <D.5724>;
        <D.6007>:
        D.6008 = GC_arrays._all_nils;
        if (D.6008 != _bi) goto <D.5722>; else goto <D.5724>;
        <D.5724>:
        bi = _bi;
      }
      second.13 = (long unsigned int) second;
      D.6009 = second.13 >> 12;
      D.6010 = D.6009 & 1023;
      _ha = &bi->index[D.6010];
    }
    second_hdr = *_ha;
  }
  second_hdr->hb_prev = h;
  <D.6003>:
  GC_invalidate_map (hhdr);
}


GC_unmap_old ()
{
  unsigned char D.6011;
  int D.6012;
  int D.6013;
  long unsigned int GC_gc_no.14;
  short unsigned int D.6017;
  long unsigned int D.6020;
  long unsigned int D.6022;
  unsigned char D.6025;
  struct hblk * h;
  struct hdr * hhdr;
  word sz;
  short unsigned int last_rec;
  short unsigned int threshold;
  int i;

  i = 0;
  goto <D.5739>;
  <D.5738>:
  h = GC_hblkfreelist[i];
  goto <D.5736>;
  <D.5735>:
  hhdr = GC_find_header (h);
  D.6011 = hhdr->hb_flags;
  D.6012 = (int) D.6011;
  D.6013 = D.6012 & 2;
  if (D.6013 != 0) goto <D.6014>; else goto <D.6015>;
  <D.6014>:
  // predicted unlikely by continue predictor.
  goto <D.5734>;
  <D.6015>:
  GC_gc_no.14 = GC_gc_no;
  D.6017 = (short unsigned int) GC_gc_no.14;
  threshold = D.6017 + 65530;
  last_rec = hhdr->hb_last_reclaimed;
  D.6020 = (long unsigned int) last_rec;
  GC_gc_no.14 = GC_gc_no;
  if (D.6020 > GC_gc_no.14) goto <D.6018>; else goto <D.6021>;
  <D.6021>:
  if (last_rec < threshold) goto <D.6018>; else goto <D.6019>;
  <D.6018>:
  D.6022 = (long unsigned int) threshold;
  GC_gc_no.14 = GC_gc_no;
  if (D.6022 < GC_gc_no.14) goto <D.6023>; else goto <D.6024>;
  <D.6023>:
  sz = hhdr->hb_sz;
  GC_unmap (h, sz);
  D.6011 = hhdr->hb_flags;
  D.6025 = D.6011 | 2;
  hhdr->hb_flags = D.6025;
  <D.6024>:
  <D.6019>:
  <D.5734>:
  h = hhdr->hb_next;
  <D.5736>:
  if (h != 0B) goto <D.5735>; else goto <D.5737>;
  <D.5737>:
  i = i + 1;
  <D.5739>:
  if (i <= 60) goto <D.5738>; else goto <D.5740>;
  <D.5740>:
}


GC_merge_unmapped ()
{
  long unsigned int h.15;
  long unsigned int D.6027;
  long unsigned int D.6028;
  struct bottom_index * D.6030;
  long unsigned int D.6031;
  long unsigned int D.6032;
  long unsigned int D.6033;
  long unsigned int next.16;
  long unsigned int D.6035;
  long unsigned int D.6036;
  long unsigned int D.6038;
  long unsigned int D.6039;
  map_entry_type * D.6043;
  map_entry_type * GC_invalid_map.17;
  unsigned char D.6046;
  int D.6047;
  int D.6048;
  unsigned char D.6054;
  unsigned char D.6056;
  int D.6057;
  int D.6058;
  unsigned char D.6064;
  short unsigned int D.6065;
  long unsigned int D.6067;
  long unsigned int D.6068;
  long unsigned int D.6069;
  struct hblk * h;
  struct hblk * next;
  struct hdr * hhdr;
  struct hdr * nexthdr;
  word size;
  word nextsize;
  int i;

  i = 0;
  goto <D.5769>;
  <D.5768>:
  h = GC_hblkfreelist[i];
  goto <D.5766>;
  <D.5765>:
  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        h.15 = (long unsigned int) h;
        hi = h.15 >> 22;
        D.6027 = hi & 2047;
        _bi = GC_arrays._top_index[D.6027];
        goto <D.5756>;
        <D.5755>:
        _bi = _bi->hash_link;
        <D.5756>:
        D.6028 = _bi->key;
        if (D.6028 != hi) goto <D.6029>; else goto <D.5757>;
        <D.6029>:
        D.6030 = GC_arrays._all_nils;
        if (D.6030 != _bi) goto <D.5755>; else goto <D.5757>;
        <D.5757>:
        bi = _bi;
      }
      h.15 = (long unsigned int) h;
      D.6031 = h.15 >> 12;
      D.6032 = D.6031 & 1023;
      _ha = &bi->index[D.6032];
    }
    hhdr = *_ha;
  }
  size = hhdr->hb_sz;
  h.15 = (long unsigned int) h;
  D.6033 = h.15 + size;
  next = (struct hblk *) D.6033;
  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        next.16 = (long unsigned int) next;
        hi = next.16 >> 22;
        D.6035 = hi & 2047;
        _bi = GC_arrays._top_index[D.6035];
        goto <D.5763>;
        <D.5762>:
        _bi = _bi->hash_link;
        <D.5763>:
        D.6036 = _bi->key;
        if (D.6036 != hi) goto <D.6037>; else goto <D.5764>;
        <D.6037>:
        D.6030 = GC_arrays._all_nils;
        if (D.6030 != _bi) goto <D.5762>; else goto <D.5764>;
        <D.5764>:
        bi = _bi;
      }
      next.16 = (long unsigned int) next;
      D.6038 = next.16 >> 12;
      D.6039 = D.6038 & 1023;
      _ha = &bi->index[D.6039];
    }
    nexthdr = *_ha;
  }
  if (nexthdr != 0B) goto <D.6042>; else goto <D.6040>;
  <D.6042>:
  D.6043 = nexthdr->hb_map;
  GC_invalid_map.17 = GC_invalid_map;
  if (D.6043 == GC_invalid_map.17) goto <D.6045>; else goto <D.6040>;
  <D.6045>:
  nextsize = nexthdr->hb_sz;
  D.6046 = hhdr->hb_flags;
  D.6047 = (int) D.6046;
  D.6048 = D.6047 & 2;
  if (D.6048 == 0) goto <D.6049>; else goto <D.6050>;
  <D.6049>:
  if (size > nextsize) goto <D.6051>; else goto <D.6052>;
  <D.6051>:
  GC_remap (next, nextsize);
  goto <D.6053>;
  <D.6052>:
  GC_unmap (h, size);
  D.6046 = hhdr->hb_flags;
  D.6054 = D.6046 | 2;
  hhdr->hb_flags = D.6054;
  <D.6053>:
  goto <D.6055>;
  <D.6050>:
  D.6056 = nexthdr->hb_flags;
  D.6057 = (int) D.6056;
  D.6058 = D.6057 & 2;
  if (D.6058 == 0) goto <D.6059>; else goto <D.6060>;
  <D.6059>:
  if (size > nextsize) goto <D.6061>; else goto <D.6062>;
  <D.6061>:
  GC_unmap (next, nextsize);
  goto <D.6063>;
  <D.6062>:
  GC_remap (h, size);
  D.6046 = hhdr->hb_flags;
  D.6064 = D.6046 & 253;
  hhdr->hb_flags = D.6064;
  D.6065 = nexthdr->hb_last_reclaimed;
  hhdr->hb_last_reclaimed = D.6065;
  <D.6063>:
  goto <D.6066>;
  <D.6060>:
  D.6067 = nexthdr->hb_sz;
  GC_unmap_gap (h, size, next, D.6067);
  <D.6066>:
  <D.6055>:
  GC_remove_from_fl (hhdr, i);
  GC_remove_from_fl (nexthdr, -1);
  D.6068 = hhdr->hb_sz;
  D.6067 = nexthdr->hb_sz;
  D.6069 = D.6068 + D.6067;
  hhdr->hb_sz = D.6069;
  GC_remove_header (next);
  GC_add_to_fl (h, hhdr);
  h = GC_hblkfreelist[i];
  goto <D.6041>;
  <D.6040>:
  h = hhdr->hb_next;
  <D.6041>:
  <D.5766>:
  if (h != 0B) goto <D.5765>; else goto <D.5767>;
  <D.5767>:
  i = i + 1;
  <D.5769>:
  if (i <= 60) goto <D.5768>; else goto <D.5770>;
  <D.5770>:
}


GC_get_first_part (struct hblk * h, struct hdr * hhdr, word bytes, int index)
{
  struct hblk * D.6072;
  long unsigned int h.18;
  long unsigned int D.6074;
  void (*<T7e6>) (char *, GC_word) GC_current_warn_proc.19;
  long unsigned int D.6078;
  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.6070>; else goto <D.6071>;
  <D.6070>:
  D.6072 = h;
  return D.6072;
  <D.6071>:
  h.18 = (long unsigned int) h;
  D.6074 = h.18 + bytes;
  rest = (struct hblk *) D.6074;
  rest_hdr = GC_install_header (rest);
  if (rest_hdr == 0B) goto <D.6075>; else goto <D.6076>;
  <D.6075>:
  GC_current_warn_proc.19 = GC_current_warn_proc;
  GC_current_warn_proc.19 ("GC Warning: Header allocation failed: Dropping block.\n", 0);
  D.6072 = 0B;
  return D.6072;
  <D.6076>:
  D.6078 = total_size - bytes;
  rest_hdr->hb_sz = D.6078;
  rest_hdr->hb_flags = 0;
  GC_add_to_fl (rest, rest_hdr);
  D.6072 = h;
  return D.6072;
}


GC_split_block (struct hblk * h, struct hdr * hhdr, struct hblk * n, struct hdr * nhdr, int index)
{
  long unsigned int n.20;
  long unsigned int h.21;
  long unsigned int D.6082;
  struct hdr * D.6085;
  struct hdr * D.6089;
  long unsigned int GC_gc_no.22;
  short unsigned int D.6091;
  word total_size;
  word h_size;
  struct hblk * prev;
  struct hblk * next;

  total_size = hhdr->hb_sz;
  n.20 = (long unsigned int) n;
  h.21 = (long unsigned int) h;
  h_size = n.20 - h.21;
  prev = hhdr->hb_prev;
  next = hhdr->hb_next;
  nhdr->hb_prev = prev;
  nhdr->hb_next = next;
  D.6082 = total_size - h_size;
  nhdr->hb_sz = D.6082;
  nhdr->hb_flags = 0;
  if (prev != 0B) goto <D.6083>; else goto <D.6084>;
  <D.6083>:
  D.6085 = GC_find_header (prev);
  D.6085->hb_next = n;
  goto <D.6086>;
  <D.6084>:
  GC_hblkfreelist[index] = n;
  <D.6086>:
  if (next != 0B) goto <D.6087>; else goto <D.6088>;
  <D.6087>:
  D.6089 = GC_find_header (next);
  D.6089->hb_prev = n;
  <D.6088>:
  GC_gc_no.22 = GC_gc_no;
  D.6091 = (short unsigned int) GC_gc_no.22;
  hhdr->hb_last_reclaimed = D.6091;
  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.6092;
  long unsigned int D.6093;
  struct hblk * D.6096;
  word blocks;
  int start_list;
  int i;

  D.6092 = sz << 3;
  D.6093 = D.6092 + 4095;
  blocks = D.6093 >> 12;
  start_list = GC_hblk_fl_from_blocks (blocks);
  i = start_list;
  goto <D.5802>;
  <D.5801>:
  {
    struct hblk * result;

    result = GC_allochblk_nth (sz, kind, flags, i);
    if (result != 0B) goto <D.6094>; else goto <D.6095>;
    <D.6094>:
    D.6096 = result;
    return D.6096;
    <D.6095>:
  }
  i = i + 1;
  <D.5802>:
  if (i <= 60) goto <D.5801>; else goto <D.5803>;
  <D.5803>:
  D.6096 = 0B;
  return D.6096;
}


GC_allochblk_nth (word sz, int kind, unsigned char flags, int n)
{
  long unsigned int D.6098;
  long unsigned int D.6099;
  long unsigned int D.6100;
  long unsigned int D.6101;
  long unsigned int hbp.23;
  long unsigned int D.6103;
  long unsigned int D.6104;
  struct bottom_index * D.6106;
  long unsigned int D.6107;
  long unsigned int D.6108;
  long unsigned int D.6109;
  int GC_use_entire_heap.24;
  int GC_dont_gc.25;
  long unsigned int D.6122;
  long unsigned int D.6123;
  long unsigned int D.6124;
  long unsigned int D.6125;
  int GC_incremental.26;
  long unsigned int GC_time_limit.27;
  int D.6131;
  long unsigned int thishbp.28;
  long unsigned int D.6137;
  long unsigned int D.6138;
  long unsigned int D.6140;
  long unsigned int D.6141;
  long unsigned int D.6142;
  long unsigned int size_needed.29;
  struct hblk * D.6148;
  int D.6153;
  sizetype size_avail.30;
  sizetype size_needed.31;
  sizetype D.6159;
  signed_word iftmp.32;
  int D.6161;
  int D.6162;
  long unsigned int eff_size_needed.33;
  long int lasthbp.34;
  long int hbp.35;
  long int D.6170;
  unsigned char D.6177;
  int D.6178;
  int D.6179;
  unsigned char D.6182;
  long unsigned int GC_black_list_spacing.36;
  long int GC_black_list_spacing.37;
  long int D.6189;
  long int GC_large_alloc_warn_suppressed.38;
  long int D.6192;
  long int GC_large_alloc_warn_interval.39;
  void (*<T7e6>) (char *, GC_word) GC_current_warn_proc.40;
  int GC_find_leak.41;
  unsigned int count.42;
  unsigned int count.43;
  unsigned int D.6208;
  long unsigned int D.6211;
  long unsigned int D.6212;
  long unsigned int D.6213;
  long unsigned int D.6214;
  long unsigned int D.6215;
  long unsigned int D.6216;
  int GC_debugging_started.44;
  struct hblk * D.6225;
  int D.6232;
  int D.6235;
  long int D.6238;
  long unsigned int D.6239;
  long unsigned int D.6240;
  _Bool D.6241;
  int D.6242;
  long unsigned int D.6243;
  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.6098 = sz << 3;
  D.6099 = D.6098 + 4095;
  D.6100 = D.6099 >> 12;
  D.6101 = D.6100 * 4096;
  size_needed = (signed_word) D.6101;
  hbp = GC_hblkfreelist[n];
  goto <D.5849>;
  <D.5848>:
  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        hbp.23 = (long unsigned int) hbp;
        hi = hbp.23 >> 22;
        D.6103 = hi & 2047;
        _bi = GC_arrays._top_index[D.6103];
        goto <D.5821>;
        <D.5820>:
        _bi = _bi->hash_link;
        <D.5821>:
        D.6104 = _bi->key;
        if (D.6104 != hi) goto <D.6105>; else goto <D.5822>;
        <D.6105>:
        D.6106 = GC_arrays._all_nils;
        if (D.6106 != _bi) goto <D.5820>; else goto <D.5822>;
        <D.5822>:
        bi = _bi;
      }
      hbp.23 = (long unsigned int) hbp;
      D.6107 = hbp.23 >> 12;
      D.6108 = D.6107 & 1023;
      _ha = &bi->index[D.6108];
    }
    hhdr = *_ha;
  }
  D.6109 = hhdr->hb_sz;
  size_avail = (signed_word) D.6109;
  if (size_avail < size_needed) goto <D.6110>; else goto <D.6111>;
  <D.6110>:
  // predicted unlikely by continue predictor.
  goto <D.5823>;
  <D.6111>:
  if (size_avail != size_needed) goto <D.6114>; else goto <D.6115>;
  <D.6114>:
  GC_use_entire_heap.24 = GC_use_entire_heap;
  if (GC_use_entire_heap.24 == 0) goto <D.6117>; else goto <D.6118>;
  <D.6117>:
  GC_dont_gc.25 = GC_dont_gc;
  if (GC_dont_gc.25 == 0) goto <D.6120>; else goto <D.6121>;
  <D.6120>:
  D.6122 = GC_arrays._heapsize;
  D.6123 = GC_arrays._large_free_bytes;
  D.6124 = D.6122 - D.6123;
  D.6125 = GC_arrays._requested_heapsize;
  if (D.6124 >= D.6125) goto <D.6126>; else goto <D.6127>;
  <D.6126>:
  GC_incremental.26 = GC_incremental;
  if (GC_incremental.26 == 0) goto <D.6112>; else goto <D.6129>;
  <D.6129>:
  GC_time_limit.27 = GC_time_limit;
  if (GC_time_limit.27 == 999999) goto <D.6112>; else goto <D.6113>;
  <D.6112>:
  D.6131 = GC_should_collect ();
  if (D.6131 != 0) goto <D.6132>; else goto <D.6133>;
  <D.6132>:
  // predicted unlikely by continue predictor.
  goto <D.5823>;
  <D.6133>:
  <D.6113>:
  <D.6127>:
  <D.6121>:
  <D.6118>:
  <D.6115>:
  {
    signed_word next_size;

    thishbp = hhdr->hb_next;
    if (thishbp != 0B) goto <D.6134>; else goto <D.6135>;
    <D.6134>:
    {
      register struct hdr * * _ha;

      {
        register struct bottom_index * bi;

        {
          register word hi;
          register struct bottom_index * _bi;

          thishbp.28 = (long unsigned int) thishbp;
          hi = thishbp.28 >> 22;
          D.6137 = hi & 2047;
          _bi = GC_arrays._top_index[D.6137];
          goto <D.5830>;
          <D.5829>:
          _bi = _bi->hash_link;
          <D.5830>:
          D.6138 = _bi->key;
          if (D.6138 != hi) goto <D.6139>; else goto <D.5831>;
          <D.6139>:
          D.6106 = GC_arrays._all_nils;
          if (D.6106 != _bi) goto <D.5829>; else goto <D.5831>;
          <D.5831>:
          bi = _bi;
        }
        thishbp.28 = (long unsigned int) thishbp;
        D.6140 = thishbp.28 >> 12;
        D.6141 = D.6140 & 1023;
        _ha = &bi->index[D.6141];
      }
      thishdr = *_ha;
    }
    D.6142 = thishdr->hb_sz;
    next_size = (signed_word) D.6142;
    if (next_size < size_avail) goto <D.6143>; else goto <D.6144>;
    <D.6143>:
    if (next_size >= size_needed) goto <D.6145>; else goto <D.6146>;
    <D.6145>:
    size_needed.29 = (long unsigned int) size_needed;
    D.6148 = GC_is_black_listed (thishbp, size_needed.29);
    if (D.6148 == 0B) goto <D.6149>; else goto <D.6150>;
    <D.6149>:
    // predicted unlikely by continue predictor.
    goto <D.5823>;
    <D.6150>:
    <D.6146>:
    <D.6144>:
    <D.6135>:
  }
  D.6153 = kind & -2;
  if (D.6153 != 2) goto <D.6154>; else goto <D.6155>;
  <D.6154>:
  if (kind != 0) goto <D.6151>; else goto <D.6156>;
  <D.6156>:
  size_needed.29 = (long unsigned int) size_needed;
  if (size_needed.29 > 8192) goto <D.6151>; else goto <D.6152>;
  <D.6151>:
  {
    struct hblk * lasthbp;
    char * search_end;
    signed_word orig_avail;
    signed_word eff_size_needed;

    lasthbp = hbp;
    size_avail.30 = (sizetype) size_avail;
    size_needed.31 = (sizetype) size_needed;
    D.6159 = size_avail.30 - size_needed.31;
    search_end = hbp + D.6159;
    orig_avail = size_avail;
    D.6161 = (int) flags;
    D.6162 = D.6161 & 1;
    if (D.6162 == 0) goto <D.6163>; else goto <D.6164>;
    <D.6163>:
    iftmp.32 = size_needed;
    goto <D.6165>;
    <D.6164>:
    iftmp.32 = 4096;
    <D.6165>:
    eff_size_needed = iftmp.32;
    goto <D.5837>;
    <D.5836>:
    lasthbp = thishbp;
    <D.5837>:
    if (lasthbp <= search_end) goto <D.6166>; else goto <D.5838>;
    <D.6166>:
    eff_size_needed.33 = (long unsigned int) eff_size_needed;
    thishbp = GC_is_black_listed (lasthbp, eff_size_needed.33);
    if (thishbp != 0B) goto <D.5836>; else goto <D.5838>;
    <D.5838>:
    lasthbp.34 = (long int) lasthbp;
    hbp.35 = (long int) hbp;
    D.6170 = lasthbp.34 - hbp.35;
    size_avail = size_avail - D.6170;
    thishbp = lasthbp;
    if (size_avail >= size_needed) goto <D.6171>; else goto <D.6172>;
    <D.6171>:
    if (thishbp != hbp) goto <D.6173>; else goto <D.6174>;
    <D.6173>:
    thishdr = GC_install_header (thishbp);
    if (thishdr != 0B) goto <D.6175>; else goto <D.6176>;
    <D.6175>:
    D.6177 = hhdr->hb_flags;
    D.6178 = (int) D.6177;
    D.6179 = D.6178 & 2;
    if (D.6179 != 0) goto <D.6180>; else goto <D.6181>;
    <D.6180>:
    D.6109 = hhdr->hb_sz;
    GC_remap (hbp, D.6109);
    D.6177 = hhdr->hb_flags;
    D.6182 = D.6177 & 253;
    hhdr->hb_flags = D.6182;
    <D.6181>:
    GC_split_block (hbp, hhdr, thishbp, thishdr, n);
    hbp = thishbp;
    hhdr = thishdr;
    <D.6176>:
    <D.6174>:
    goto <D.6183>;
    <D.6172>:
    GC_black_list_spacing.36 = GC_black_list_spacing;
    GC_black_list_spacing.37 = (long int) GC_black_list_spacing.36;
    if (size_needed > GC_black_list_spacing.37) goto <D.6188>; else goto <D.6184>;
    <D.6188>:
    D.6189 = orig_avail - size_needed;
    GC_black_list_spacing.36 = GC_black_list_spacing;
    GC_black_list_spacing.37 = (long int) GC_black_list_spacing.36;
    if (D.6189 > GC_black_list_spacing.37) goto <D.6190>; else goto <D.6184>;
    <D.6190>:
    GC_large_alloc_warn_suppressed.38 = GC_large_alloc_warn_suppressed;
    D.6192 = GC_large_alloc_warn_suppressed.38 + 1;
    GC_large_alloc_warn_suppressed = D.6192;
    GC_large_alloc_warn_suppressed.38 = GC_large_alloc_warn_suppressed;
    GC_large_alloc_warn_interval.39 = GC_large_alloc_warn_interval;
    if (GC_large_alloc_warn_suppressed.38 >= GC_large_alloc_warn_interval.39) goto <D.6194>; else goto <D.6195>;
    <D.6194>:
    GC_current_warn_proc.40 = GC_current_warn_proc;
    size_needed.29 = (long unsigned int) size_needed;
    GC_current_warn_proc.40 ("GC Warning: Repeated allocation of very large block (appr. size %ld):\n\tMay lead to memory leak and poor performance.\n", size_needed.29);
    GC_large_alloc_warn_suppressed = 0;
    <D.6195>:
    size_avail = orig_avail;
    goto <D.6185>;
    <D.6184>:
    if (size_avail == 0) goto <D.6197>; else goto <D.6198>;
    <D.6197>:
    if (size_needed == 4096) goto <D.6199>; else goto <D.6200>;
    <D.6199>:
    D.6177 = hhdr->hb_flags;
    D.6178 = (int) D.6177;
    D.6179 = D.6178 & 2;
    if (D.6179 == 0) goto <D.6201>; else goto <D.6202>;
    <D.6201>:
    GC_find_leak.41 = GC_find_leak;
    if (GC_find_leak.41 == 0) goto <D.6204>; else goto <D.6205>;
    <D.6204>:
    {
      static unsigned int count = 0;

      count.42 = count;
      count.43 = count.42 + 1;
      count = count.43;
      count.42 = count;
      D.6208 = count.42 & 3;
      if (D.6208 == 0) goto <D.6209>; else goto <D.6210>;
      <D.6209>:
      {
        word total_size;
        struct hblk * limit;
        struct hblk * h;
        struct hblk * prev;

        total_size = hhdr->hb_sz;
        D.6211 = total_size >> 12;
        D.6212 = D.6211 * 4096;
        limit = hbp + D.6212;
        prev = hhdr->hb_prev;
        D.6213 = GC_arrays._words_wasted;
        D.6214 = total_size >> 3;
        D.6215 = D.6213 + D.6214;
        GC_arrays._words_wasted = D.6215;
        D.6123 = GC_arrays._large_free_bytes;
        D.6216 = D.6123 - total_size;
        GC_arrays._large_free_bytes = D.6216;
        GC_remove_from_fl (hhdr, n);
        h = hbp;
        goto <D.5845>;
        <D.5844>:
        if (h == hbp) goto <D.6217>; else goto <D.6219>;
        <D.6219>:
        hhdr = GC_install_header (h);
        if (hhdr != 0B) goto <D.6217>; else goto <D.6218>;
        <D.6217>:
        setup_header (hhdr, 512, 0, 0);
        GC_debugging_started.44 = GC_debugging_started;
        if (GC_debugging_started.44 != 0) goto <D.6221>; else goto <D.6222>;
        <D.6221>:
        memset (h, 0, 4096);
        <D.6222>:
        <D.6218>:
        h = h + 4096;
        <D.5845>:
        if (h < limit) goto <D.5844>; else goto <D.5846>;
        <D.5846>:
        hbp = prev;
        if (hbp == 0B) goto <D.6223>; else goto <D.6224>;
        <D.6223>:
        D.6161 = (int) flags;
        D.6225 = GC_allochblk_nth (sz, kind, D.6161, n);
        return D.6225;
        <D.6224>:
        hhdr = GC_find_header (hbp);
      }
      <D.6210>:
    }
    <D.6205>:
    <D.6202>:
    <D.6200>:
    <D.6198>:
    <D.6185>:
    <D.6183>:
  }
  <D.6152>:
  <D.6155>:
  if (size_avail >= size_needed) goto <D.6226>; else goto <D.6227>;
  <D.6226>:
  D.6177 = hhdr->hb_flags;
  D.6178 = (int) D.6177;
  D.6179 = D.6178 & 2;
  if (D.6179 != 0) goto <D.6228>; else goto <D.6229>;
  <D.6228>:
  D.6109 = hhdr->hb_sz;
  GC_remap (hbp, D.6109);
  D.6177 = hhdr->hb_flags;
  D.6182 = D.6177 & 253;
  hhdr->hb_flags = D.6182;
  <D.6229>:
  hbp = GC_get_first_part (hbp, hhdr, size_needed, n);
  goto <D.5847>;
  <D.6227>:
  <D.5823>:
  hbp = hhdr->hb_next;
  <D.5849>:
  if (hbp != 0B) goto <D.5848>; else goto <D.5847>;
  <D.5847>:
  if (hbp == 0B) goto <D.6230>; else goto <D.6231>;
  <D.6230>:
  D.6225 = 0B;
  return D.6225;
  <D.6231>:
  size_needed.29 = (long unsigned int) size_needed;
  D.6232 = GC_install_counts (hbp, size_needed.29);
  if (D.6232 == 0) goto <D.6233>; else goto <D.6234>;
  <D.6233>:
  D.6225 = 0B;
  return D.6225;
  <D.6234>:
  D.6161 = (int) flags;
  D.6235 = setup_header (hhdr, sz, kind, D.6161);
  if (D.6235 == 0) goto <D.6236>; else goto <D.6237>;
  <D.6236>:
  size_needed.29 = (long unsigned int) size_needed;
  GC_remove_counts (hbp, size_needed.29);
  D.6225 = 0B;
  return D.6225;
  <D.6237>:
  D.6238 = size_needed >> 12;
  D.6239 = (long unsigned int) D.6238;
  D.6240 = hhdr->hb_descr;
  D.6241 = D.6240 == 0;
  D.6242 = (int) D.6241;
  GC_remove_protection (hbp, D.6239, D.6242);
  {
    extern unsigned int GC_fail_count;

    GC_fail_count = 0;
  }
  D.6123 = GC_arrays._large_free_bytes;
  size_needed.29 = (long unsigned int) size_needed;
  D.6243 = D.6123 - size_needed.29;
  GC_arrays._large_free_bytes = D.6243;
  D.6225 = hbp;
  return D.6225;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.6245;
  long unsigned int D.6246;

  D.6246 = __builtin_object_size (__dest, 0);
  D.6245 = __builtin___memset_chk (__dest, __ch, __len, D.6246);
  return D.6245;
}


setup_header (struct hdr * hhdr, word sz, int kind, unsigned char flags)
{
  int D.6248;
  GC_bool D.6251;
  word iftmp.45;
  map_entry_type * D.6256;
  unsigned char D.6257;
  int D.6258;
  long unsigned int D.6261;
  long unsigned int GC_gc_no.46;
  short unsigned int D.6263;
  register word descr;

  D.6248 = GC_add_map_entry (sz);
  if (D.6248 == 0) goto <D.6249>; else goto <D.6250>;
  <D.6249>:
  D.6251 = 0;
  return D.6251;
  <D.6250>:
  if (sz <= 256) goto <D.6253>; else goto <D.6254>;
  <D.6253>:
  iftmp.45 = sz;
  goto <D.6255>;
  <D.6254>:
  iftmp.45 = 0;
  <D.6255>:
  D.6256 = GC_arrays._obj_map[iftmp.45];
  hhdr->hb_map = D.6256;
  hhdr->hb_sz = sz;
  D.6257 = (unsigned char) kind;
  hhdr->hb_obj_kind = D.6257;
  hhdr->hb_flags = flags;
  descr = GC_obj_kinds[kind].ok_descriptor;
  D.6258 = GC_obj_kinds[kind].ok_relocate_descr;
  if (D.6258 != 0) goto <D.6259>; else goto <D.6260>;
  <D.6259>:
  D.6261 = sz << 3;
  descr = D.6261 + descr;
  <D.6260>:
  hhdr->hb_descr = descr;
  GC_clear_hdr_marks (hhdr);
  GC_gc_no.46 = GC_gc_no;
  D.6263 = (short unsigned int) GC_gc_no.46;
  hhdr->hb_last_reclaimed = D.6263;
  D.6251 = 1;
  return D.6251;
}


GC_freehblk (struct hblk * hbp)
{
  long unsigned int hbp.47;
  long unsigned int D.6266;
  long unsigned int D.6267;
  struct bottom_index * D.6269;
  long unsigned int D.6270;
  long unsigned int D.6271;
  long unsigned int D.6272;
  long int D.6273;
  long unsigned int D.6274;
  long unsigned int D.6275;
  long unsigned int D.6276;
  long unsigned int D.6277;
  long unsigned int size.48;
  long unsigned int size.49;
  long unsigned int GC_gc_no.50;
  short unsigned int D.6281;
  map_entry_type * D.6282;
  map_entry_type * GC_invalid_map.51;
  long int hbp.52;
  long unsigned int D.6287;
  long unsigned int next.53;
  long unsigned int D.6289;
  long unsigned int D.6290;
  long unsigned int D.6292;
  long unsigned int D.6293;
  map_entry_type * D.6296;
  unsigned char D.6299;
  int D.6300;
  int D.6301;
  long unsigned int D.6304;
  long unsigned int D.6305;
  unsigned char D.6308;
  int D.6309;
  int D.6310;
  long unsigned int D.6313;
  long unsigned int D.6314;
  long unsigned int D.6315;
  long unsigned int D.6316;
  struct hblk * next;
  struct hblk * prev;
  struct hdr * hhdr;
  struct hdr * prevhdr;
  struct hdr * nexthdr;
  signed_word size;

  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        hbp.47 = (long unsigned int) hbp;
        hi = hbp.47 >> 22;
        D.6266 = hi & 2047;
        _bi = GC_arrays._top_index[D.6266];
        goto <D.5867>;
        <D.5866>:
        _bi = _bi->hash_link;
        <D.5867>:
        D.6267 = _bi->key;
        if (D.6267 != hi) goto <D.6268>; else goto <D.5868>;
        <D.6268>:
        D.6269 = GC_arrays._all_nils;
        if (D.6269 != _bi) goto <D.5866>; else goto <D.5868>;
        <D.5868>:
        bi = _bi;
      }
      hbp.47 = (long unsigned int) hbp;
      D.6270 = hbp.47 >> 12;
      D.6271 = D.6270 & 1023;
      _ha = &bi->index[D.6271];
    }
    hhdr = *_ha;
  }
  D.6272 = hhdr->hb_sz;
  size = (signed_word) D.6272;
  D.6273 = size << 3;
  D.6274 = (long unsigned int) D.6273;
  D.6275 = D.6274 + 4095;
  D.6276 = D.6275 >> 12;
  D.6277 = D.6276 * 4096;
  size = (signed_word) D.6277;
  size.48 = (long unsigned int) size;
  GC_remove_counts (hbp, size.48);
  size.49 = (long unsigned int) size;
  hhdr->hb_sz = size.49;
  GC_gc_no.50 = GC_gc_no;
  D.6281 = (short unsigned int) GC_gc_no.50;
  hhdr->hb_last_reclaimed = D.6281;
  D.6282 = hhdr->hb_map;
  GC_invalid_map.51 = GC_invalid_map;
  if (D.6282 == GC_invalid_map.51) goto <D.6284>; else goto <D.6285>;
  <D.6284>:
  hbp.52 = (long int) hbp;
  GC_printf ("Duplicate large block deallocation of 0x%lx\n", hbp.52, 0, 0, 0, 0, 0);
  GC_abort ("Duplicate large block deallocation");
  <D.6285>:
  GC_invalidate_map (hhdr);
  hbp.47 = (long unsigned int) hbp;
  size.48 = (long unsigned int) size;
  D.6287 = hbp.47 + size.48;
  next = (struct hblk *) D.6287;
  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        next.53 = (long unsigned int) next;
        hi = next.53 >> 22;
        D.6289 = hi & 2047;
        _bi = GC_arrays._top_index[D.6289];
        goto <D.5874>;
        <D.5873>:
        _bi = _bi->hash_link;
        <D.5874>:
        D.6290 = _bi->key;
        if (D.6290 != hi) goto <D.6291>; else goto <D.5875>;
        <D.6291>:
        D.6269 = GC_arrays._all_nils;
        if (D.6269 != _bi) goto <D.5873>; else goto <D.5875>;
        <D.5875>:
        bi = _bi;
      }
      next.53 = (long unsigned int) next;
      D.6292 = next.53 >> 12;
      D.6293 = D.6292 & 1023;
      _ha = &bi->index[D.6293];
    }
    nexthdr = *_ha;
  }
  prev = GC_free_block_ending_at (hbp);
  if (nexthdr != 0B) goto <D.6294>; else goto <D.6295>;
  <D.6294>:
  D.6296 = nexthdr->hb_map;
  GC_invalid_map.51 = GC_invalid_map;
  if (D.6296 == GC_invalid_map.51) goto <D.6297>; else goto <D.6298>;
  <D.6297>:
  D.6299 = nexthdr->hb_flags;
  D.6300 = (int) D.6299;
  D.6301 = D.6300 & 2;
  if (D.6301 == 0) goto <D.6302>; else goto <D.6303>;
  <D.6302>:
  GC_remove_from_fl (nexthdr, -1);
  D.6272 = hhdr->hb_sz;
  D.6304 = nexthdr->hb_sz;
  D.6305 = D.6272 + D.6304;
  hhdr->hb_sz = D.6305;
  GC_remove_header (next);
  <D.6303>:
  <D.6298>:
  <D.6295>:
  if (prev != 0B) goto <D.6306>; else goto <D.6307>;
  <D.6306>:
  prevhdr = GC_find_header (prev);
  D.6308 = prevhdr->hb_flags;
  D.6309 = (int) D.6308;
  D.6310 = D.6309 & 2;
  if (D.6310 == 0) goto <D.6311>; else goto <D.6312>;
  <D.6311>:
  GC_remove_from_fl (prevhdr, -1);
  D.6313 = prevhdr->hb_sz;
  D.6272 = hhdr->hb_sz;
  D.6314 = D.6313 + D.6272;
  prevhdr->hb_sz = D.6314;
  GC_gc_no.50 = GC_gc_no;
  D.6281 = (short unsigned int) GC_gc_no.50;
  prevhdr->hb_last_reclaimed = D.6281;
  GC_remove_header (hbp);
  hbp = prev;
  hhdr = prevhdr;
  <D.6312>:
  <D.6307>:
  D.6315 = GC_arrays._large_free_bytes;
  size.48 = (long unsigned int) size;
  D.6316 = D.6315 + size.48;
  GC_arrays._large_free_bytes = D.6316;
  GC_add_to_fl (hbp, hhdr);
}