GC_add_leaked (char * leaked)
{
  unsigned int GC_n_leaked.0;
  unsigned int GC_n_leaked.1;
  unsigned int GC_n_leaked.2;

  GC_n_leaked.0 = GC_n_leaked;
  if (GC_n_leaked.0 <= 39) goto <D.7995>; else goto <D.7996>;
  <D.7995>:
  GC_have_errors = 1;
  GC_n_leaked.0 = GC_n_leaked;
  GC_n_leaked.1 = GC_n_leaked.0;
  GC_n_leaked.2 = GC_n_leaked.1 + 1;
  GC_n_leaked = GC_n_leaked.2;
  GC_leaked[GC_n_leaked.1] = leaked;
  GC_set_mark_bit (leaked);
  <D.7996>:
}


GC_print_all_errors ()
{
  int D.7999;
  int printing_errors.3;
  int GC_debugging_started.4;
  void (*<T10dc>) (void) GC_print_all_smashed.5;
  long unsigned int p.6;
  long unsigned int D.8010;
  struct bottom_index * D.8011;
  long unsigned int D.8012;
  long unsigned int D.8013;
  struct hdr * D.8014;
  unsigned char D.8015;
  void (*<T1a15>) (char *) GC_print_heap_obj.7;
  unsigned int GC_n_leaked.8;
  unsigned int i;

  D.7999 = GC_test_and_set (&GC_allocate_lock);
  if (D.7999 != 0) goto <D.8000>; else goto <D.8001>;
  <D.8000>:
  GC_lock ();
  <D.8001>:
  printing_errors.3 = printing_errors;
  if (printing_errors.3 != 0) goto <D.8003>; else goto <D.8004>;
  <D.8003>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.8004>:
  printing_errors = 1;
  GC_clear (&GC_allocate_lock);
  GC_debugging_started.4 = GC_debugging_started;
  if (GC_debugging_started.4 != 0) goto <D.8006>; else goto <D.8007>;
  <D.8006>:
  GC_print_all_smashed.5 = GC_print_all_smashed;
  GC_print_all_smashed.5 ();
  <D.8007>:
  i = 0;
  goto <D.7711>;
  <D.7710>:
  {
    char * p;

    p = GC_leaked[i];
    p.6 = (long unsigned int) p;
    D.8010 = p.6 >> 22;
    D.8011 = GC_arrays._top_index[D.8010];
    p.6 = (long unsigned int) p;
    D.8012 = p.6 >> 12;
    D.8013 = D.8012 & 1023;
    D.8014 = D.8011->index[D.8013];
    D.8015 = D.8014->hb_obj_kind;
    if (D.8015 == 0) goto <D.8016>; else goto <D.8017>;
    <D.8016>:
    GC_err_puts ("Leaked atomic object at ");
    goto <D.8018>;
    <D.8017>:
    GC_err_puts ("Leaked composite object at ");
    <D.8018>:
    GC_print_heap_obj.7 = GC_print_heap_obj;
    GC_print_heap_obj.7 (p);
    GC_err_puts ("\n");
    GC_free (p);
    GC_leaked[i] = 0B;
  }
  i = i + 1;
  <D.7711>:
  GC_n_leaked.8 = GC_n_leaked;
  if (i < GC_n_leaked.8) goto <D.7710>; else goto <D.7712>;
  <D.7712>:
  GC_n_leaked = 0;
  printing_errors = 0;
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.8022;
  unsigned int D.8023;

  D.8023 = __sync_lock_test_and_set_4 (addr, 1);
  D.8022 = (int) D.8023;
  return D.8022;
}


GC_clear (volatile unsigned int * addr)
{
  __sync_synchronize ();
  *addr = 0;
}


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

  p = &hhdr->hb_marks[0];
  plim = &hhdr->hb_marks[32];
  goto <D.7719>;
  <D.7718>:
  p.9 = p;
  p = p.9 + 4;
  D.8026 = *p.9;
  if (D.8026 != 0) goto <D.8027>; else goto <D.8028>;
  <D.8027>:
  D.8029 = 0;
  return D.8029;
  <D.8028>:
  <D.7719>:
  if (p < plim) goto <D.7718>; else goto <D.7720>;
  <D.7720>:
  D.8029 = 1;
  return D.8029;
}


GC_block_nearly_full1 (struct hdr * hhdr, word pat1)
{
  long unsigned int D.8031;
  long unsigned int D.8032;
  long unsigned int D.8033;
  GC_bool D.8038;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  i = 0;
  goto <D.7728>;
  <D.7727>:
  D.8031 = hhdr->hb_marks[i];
  D.8032 = ~pat1;
  D.8033 = D.8031 | D.8032;
  if (D.8033 != 4294967295) goto <D.8034>; else goto <D.8035>;
  <D.8034>:
  misses = misses + 1;
  if (misses > 2) goto <D.8036>; else goto <D.8037>;
  <D.8036>:
  D.8038 = 0;
  return D.8038;
  <D.8037>:
  <D.8035>:
  i = i + 1;
  <D.7728>:
  if (i <= 31) goto <D.7727>; else goto <D.7729>;
  <D.7729>:
  D.8038 = 1;
  return D.8038;
}


GC_block_nearly_full3 (struct hdr * hhdr, word pat1, word pat2, word pat3)
{
  GC_bool D.8042;
  long unsigned int D.8043;
  long unsigned int D.8044;
  long unsigned int D.8045;
  unsigned int D.8050;
  long unsigned int D.8051;
  long unsigned int D.8052;
  long unsigned int D.8053;
  unsigned int D.8058;
  long unsigned int D.8059;
  long unsigned int D.8060;
  long unsigned int D.8061;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  if (0 != 0) goto <D.8040>; else goto <D.8041>;
  <D.8040>:
  D.8042 = 2;
  return D.8042;
  <D.8041>:
  i = 0;
  goto <D.7739>;
  <D.7738>:
  D.8043 = hhdr->hb_marks[i];
  D.8044 = ~pat1;
  D.8045 = D.8043 | D.8044;
  if (D.8045 != 4294967295) goto <D.8046>; else goto <D.8047>;
  <D.8046>:
  misses = misses + 1;
  if (misses > 2) goto <D.8048>; else goto <D.8049>;
  <D.8048>:
  D.8042 = 0;
  return D.8042;
  <D.8049>:
  <D.8047>:
  D.8050 = i + 1;
  D.8051 = hhdr->hb_marks[D.8050];
  D.8052 = ~pat2;
  D.8053 = D.8051 | D.8052;
  if (D.8053 != 4294967295) goto <D.8054>; else goto <D.8055>;
  <D.8054>:
  misses = misses + 1;
  if (misses > 2) goto <D.8056>; else goto <D.8057>;
  <D.8056>:
  D.8042 = 0;
  return D.8042;
  <D.8057>:
  <D.8055>:
  D.8058 = i + 2;
  D.8059 = hhdr->hb_marks[D.8058];
  D.8060 = ~pat3;
  D.8061 = D.8059 | D.8060;
  if (D.8061 != 4294967295) goto <D.8062>; else goto <D.8063>;
  <D.8062>:
  misses = misses + 1;
  if (misses > 2) goto <D.8064>; else goto <D.8065>;
  <D.8064>:
  D.8042 = 0;
  return D.8042;
  <D.8065>:
  <D.8063>:
  i = i + 3;
  <D.7739>:
  if (i <= 29) goto <D.7738>; else goto <D.7740>;
  <D.7740>:
  D.8042 = 1;
  return D.8042;
}


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

  D.8067 = hhdr->hb_sz;
  sz = (int) D.8067;
  switch (sz) <default: <D.7753>, case 1: <D.7745>, case 2: <D.7746>, case 4: <D.7747>, case 6: <D.7748>, case 8: <D.7749>, case 12: <D.7750>, case 16: <D.7751>, case 32: <D.7752>>
  <D.7745>:
  D.8068 = GC_block_nearly_full1 (hhdr, 4294967295);
  return D.8068;
  <D.7746>:
  D.8068 = GC_block_nearly_full1 (hhdr, 1431655765);
  return D.8068;
  <D.7747>:
  D.8068 = GC_block_nearly_full1 (hhdr, 286331153);
  return D.8068;
  <D.7748>:
  D.8068 = GC_block_nearly_full3 (hhdr, 1090785345, 272696336, 68174084);
  return D.8068;
  <D.7749>:
  D.8068 = GC_block_nearly_full1 (hhdr, 16843009);
  return D.8068;
  <D.7750>:
  D.8068 = GC_block_nearly_full3 (hhdr, 16781313, 268501008, 1048832);
  return D.8068;
  <D.7751>:
  D.8068 = GC_block_nearly_full1 (hhdr, 65537);
  return D.8068;
  <D.7752>:
  D.8068 = GC_block_nearly_full1 (hhdr, 1);
  return D.8068;
  <D.7753>:
  D.8068 = 2;
  return D.8068;
}


GC_reclaim_clear (struct hblk * hbp, struct hdr * hhdr, word sz, char * list)
{
  long unsigned int hbp.10;
  long unsigned int D.8071;
  long unsigned int D.8072;
  long unsigned int D.8073;
  int D.8074;
  long unsigned int D.8075;
  int D.8076;
  long unsigned int D.8077;
  long unsigned int D.8078;
  long unsigned int D.8081;
  word * p.11;
  long unsigned int word_no.12;
  long unsigned int D.8085;
  char * D.8086;
  register int word_no;
  register word * p;
  register word * q;
  register word * plim;

  p = &hbp->hb_body;
  word_no = 0;
  hbp.10 = (long unsigned int) hbp;
  D.8071 = sz << 2;
  D.8072 = hbp.10 - D.8071;
  D.8073 = D.8072 + 4096;
  plim = (word *) D.8073;
  goto <D.7768>;
  <D.7767>:
  D.8074 = word_no >> 5;
  D.8075 = hhdr->hb_marks[D.8074];
  D.8076 = word_no & 31;
  D.8077 = D.8075 >> D.8076;
  D.8078 = D.8077 & 1;
  if (D.8078 != 0) goto <D.8079>; else goto <D.8080>;
  <D.8079>:
  D.8081 = sz * 4;
  p = p + D.8081;
  goto <D.8082>;
  <D.8080>:
  MEM[(char * *)p] = list;
  list = p;
  D.8081 = sz * 4;
  q = p + D.8081;
  p = p + 4;
  goto <D.7765>;
  <D.7764>:
  p.11 = p;
  p = p.11 + 4;
  *p.11 = 0;
  <D.7765>:
  if (p < q) goto <D.7764>; else goto <D.7766>;
  <D.7766>:
  <D.8082>:
  word_no.12 = (long unsigned int) word_no;
  D.8085 = word_no.12 + sz;
  word_no = (int) D.8085;
  <D.7768>:
  if (p <= plim) goto <D.7767>; else goto <D.7769>;
  <D.7769>:
  D.8086 = list;
  return D.8086;
}


GC_reclaim_clear2 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.13;
  long unsigned int D.8089;
  word * mark_word_addr.14;
  long unsigned int D.8091;
  long unsigned int list.15;
  word * D.8095;
  long unsigned int D.8096;
  word * D.8099;
  word * D.8100;
  long unsigned int D.8101;
  word * D.8104;
  word * D.8105;
  long unsigned int D.8106;
  word * D.8109;
  word * D.8110;
  long unsigned int i.16;
  char * D.8112;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.13 = (long unsigned int) hbp;
  D.8089 = hbp.13 + 4096;
  plim = (word *) D.8089;
  goto <D.7784>;
  <D.7783>:
  mark_word_addr.14 = mark_word_addr;
  mark_word_addr = mark_word_addr.14 + 4;
  mark_word = *mark_word_addr.14;
  i = 0;
  goto <D.7781>;
  <D.7780>:
  D.8091 = mark_word & 1;
  if (D.8091 == 0) goto <D.8092>; else goto <D.8093>;
  <D.8092>:
  list.15 = (long unsigned int) list;
  *p = list.15;
  list = p;
  D.8095 = p + 4;
  *D.8095 = 0;
  <D.8093>:
  D.8096 = mark_word & 4;
  if (D.8096 == 0) goto <D.8097>; else goto <D.8098>;
  <D.8097>:
  D.8099 = p + 8;
  list.15 = (long unsigned int) list;
  *D.8099 = list.15;
  list = p + 8;
  D.8100 = p + 12;
  *D.8100 = 0;
  <D.8098>:
  D.8101 = mark_word & 16;
  if (D.8101 == 0) goto <D.8102>; else goto <D.8103>;
  <D.8102>:
  D.8104 = p + 16;
  list.15 = (long unsigned int) list;
  *D.8104 = list.15;
  list = p + 16;
  D.8105 = p + 20;
  *D.8105 = 0;
  <D.8103>:
  D.8106 = mark_word & 64;
  if (D.8106 == 0) goto <D.8107>; else goto <D.8108>;
  <D.8107>:
  D.8109 = p + 24;
  list.15 = (long unsigned int) list;
  *D.8109 = list.15;
  list = p + 24;
  D.8110 = p + 28;
  *D.8110 = 0;
  <D.8108>:
  p = p + 32;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.7781>:
  i.16 = (long unsigned int) i;
  if (i.16 <= 31) goto <D.7780>; else goto <D.7782>;
  <D.7782>:
  <D.7784>:
  if (p < plim) goto <D.7783>; else goto <D.7785>;
  <D.7785>:
  D.8112 = list;
  return D.8112;
}


GC_reclaim_clear4 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.17;
  long unsigned int D.8115;
  word * mark_word_addr.18;
  long unsigned int D.8117;
  long unsigned int list.19;
  word * D.8121;
  word * D.8122;
  word * D.8123;
  long unsigned int D.8124;
  word * D.8127;
  word * D.8128;
  word * D.8129;
  word * D.8130;
  long unsigned int D.8131;
  word * D.8134;
  word * D.8135;
  word * D.8136;
  word * D.8137;
  long unsigned int D.8138;
  word * D.8141;
  word * D.8142;
  word * D.8143;
  word * D.8144;
  long unsigned int D.8145;
  word * D.8148;
  word * D.8149;
  word * D.8150;
  word * D.8151;
  long unsigned int D.8152;
  word * D.8155;
  word * D.8156;
  word * D.8157;
  word * D.8158;
  long unsigned int D.8159;
  word * D.8162;
  word * D.8163;
  word * D.8164;
  word * D.8165;
  long unsigned int D.8166;
  word * D.8169;
  word * D.8170;
  word * D.8171;
  word * D.8172;
  char * D.8173;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.17 = (long unsigned int) hbp;
  D.8115 = hbp.17 + 4096;
  plim = (word *) D.8115;
  goto <D.7796>;
  <D.7795>:
  mark_word_addr.18 = mark_word_addr;
  mark_word_addr = mark_word_addr.18 + 4;
  mark_word = *mark_word_addr.18;
  D.8117 = mark_word & 1;
  if (D.8117 == 0) goto <D.8118>; else goto <D.8119>;
  <D.8118>:
  list.19 = (long unsigned int) list;
  *p = list.19;
  list = p;
  D.8121 = p + 4;
  *D.8121 = 0;
  D.8122 = p + 8;
  *D.8122 = 0;
  D.8123 = p + 12;
  *D.8123 = 0;
  <D.8119>:
  D.8124 = mark_word & 16;
  if (D.8124 == 0) goto <D.8125>; else goto <D.8126>;
  <D.8125>:
  D.8127 = p + 16;
  list.19 = (long unsigned int) list;
  *D.8127 = list.19;
  list = p + 16;
  D.8128 = p + 20;
  *D.8128 = 0;
  D.8129 = p + 24;
  *D.8129 = 0;
  D.8130 = p + 28;
  *D.8130 = 0;
  <D.8126>:
  D.8131 = mark_word & 256;
  if (D.8131 == 0) goto <D.8132>; else goto <D.8133>;
  <D.8132>:
  D.8134 = p + 32;
  list.19 = (long unsigned int) list;
  *D.8134 = list.19;
  list = p + 32;
  D.8135 = p + 36;
  *D.8135 = 0;
  D.8136 = p + 40;
  *D.8136 = 0;
  D.8137 = p + 44;
  *D.8137 = 0;
  <D.8133>:
  D.8138 = mark_word & 4096;
  if (D.8138 == 0) goto <D.8139>; else goto <D.8140>;
  <D.8139>:
  D.8141 = p + 48;
  list.19 = (long unsigned int) list;
  *D.8141 = list.19;
  list = p + 48;
  D.8142 = p + 52;
  *D.8142 = 0;
  D.8143 = p + 56;
  *D.8143 = 0;
  D.8144 = p + 60;
  *D.8144 = 0;
  <D.8140>:
  D.8145 = mark_word & 65536;
  if (D.8145 == 0) goto <D.8146>; else goto <D.8147>;
  <D.8146>:
  D.8148 = p + 64;
  list.19 = (long unsigned int) list;
  *D.8148 = list.19;
  list = p + 64;
  D.8149 = p + 68;
  *D.8149 = 0;
  D.8150 = p + 72;
  *D.8150 = 0;
  D.8151 = p + 76;
  *D.8151 = 0;
  <D.8147>:
  D.8152 = mark_word & 1048576;
  if (D.8152 == 0) goto <D.8153>; else goto <D.8154>;
  <D.8153>:
  D.8155 = p + 80;
  list.19 = (long unsigned int) list;
  *D.8155 = list.19;
  list = p + 80;
  D.8156 = p + 84;
  *D.8156 = 0;
  D.8157 = p + 88;
  *D.8157 = 0;
  D.8158 = p + 92;
  *D.8158 = 0;
  <D.8154>:
  D.8159 = mark_word & 16777216;
  if (D.8159 == 0) goto <D.8160>; else goto <D.8161>;
  <D.8160>:
  D.8162 = p + 96;
  list.19 = (long unsigned int) list;
  *D.8162 = list.19;
  list = p + 96;
  D.8163 = p + 100;
  *D.8163 = 0;
  D.8164 = p + 104;
  *D.8164 = 0;
  D.8165 = p + 108;
  *D.8165 = 0;
  <D.8161>:
  D.8166 = mark_word & 268435456;
  if (D.8166 == 0) goto <D.8167>; else goto <D.8168>;
  <D.8167>:
  D.8169 = p + 112;
  list.19 = (long unsigned int) list;
  *D.8169 = list.19;
  list = p + 112;
  D.8170 = p + 116;
  *D.8170 = 0;
  D.8171 = p + 120;
  *D.8171 = 0;
  D.8172 = p + 124;
  *D.8172 = 0;
  <D.8168>:
  p = p + 128;
  <D.7796>:
  if (p < plim) goto <D.7795>; else goto <D.7797>;
  <D.7797>:
  D.8173 = list;
  return D.8173;
}


GC_reclaim_uninit (struct hblk * hbp, struct hdr * hhdr, word sz, char * list)
{
  long unsigned int hbp.20;
  long unsigned int D.8176;
  long unsigned int D.8177;
  long unsigned int D.8178;
  int D.8179;
  long unsigned int D.8180;
  int D.8181;
  long unsigned int D.8182;
  long unsigned int D.8183;
  long unsigned int D.8186;
  long unsigned int word_no.21;
  long unsigned int D.8188;
  char * D.8189;
  register int word_no;
  register word * p;
  register word * plim;

  word_no = 0;
  p = &hbp->hb_body;
  hbp.20 = (long unsigned int) hbp;
  D.8176 = sz << 2;
  D.8177 = hbp.20 - D.8176;
  D.8178 = D.8177 + 4096;
  plim = (word *) D.8178;
  goto <D.7808>;
  <D.7807>:
  D.8179 = word_no >> 5;
  D.8180 = hhdr->hb_marks[D.8179];
  D.8181 = word_no & 31;
  D.8182 = D.8180 >> D.8181;
  D.8183 = D.8182 & 1;
  if (D.8183 == 0) goto <D.8184>; else goto <D.8185>;
  <D.8184>:
  MEM[(char * *)p] = list;
  list = p;
  <D.8185>:
  D.8186 = sz * 4;
  p = p + D.8186;
  word_no.21 = (long unsigned int) word_no;
  D.8188 = word_no.21 + sz;
  word_no = (int) D.8188;
  <D.7808>:
  if (p <= plim) goto <D.7807>; else goto <D.7809>;
  <D.7809>:
  D.8189 = list;
  return D.8189;
}


GC_reclaim_check (struct hblk * hbp, struct hdr * hhdr, word sz)
{
  long unsigned int hbp.22;
  long unsigned int D.8192;
  long unsigned int D.8193;
  long unsigned int D.8194;
  int D.8195;
  long unsigned int D.8196;
  int D.8197;
  long unsigned int D.8198;
  long unsigned int D.8199;
  int D.8202;
  sizetype D.8203;
  char * D.8204;
  long unsigned int D.8205;
  long unsigned int word_no.23;
  long unsigned int D.8207;
  register int word_no;
  register word * p;
  register word * plim;

  word_no = 0;
  p = &hbp->hb_body;
  hbp.22 = (long unsigned int) hbp;
  D.8192 = sz << 2;
  D.8193 = hbp.22 - D.8192;
  D.8194 = D.8193 + 4096;
  plim = (word *) D.8194;
  goto <D.7819>;
  <D.7818>:
  D.8195 = word_no >> 5;
  D.8196 = hhdr->hb_marks[D.8195];
  D.8197 = word_no & 31;
  D.8198 = D.8196 >> D.8197;
  D.8199 = D.8198 & 1;
  if (D.8199 == 0) goto <D.8200>; else goto <D.8201>;
  <D.8200>:
  D.8202 = word_no << 2;
  D.8203 = (sizetype) D.8202;
  D.8204 = hbp + D.8203;
  GC_add_leaked (D.8204);
  <D.8201>:
  D.8205 = sz * 4;
  p = p + D.8205;
  word_no.23 = (long unsigned int) word_no;
  D.8207 = word_no.23 + sz;
  word_no = (int) D.8207;
  <D.7819>:
  if (p <= plim) goto <D.7818>; else goto <D.7820>;
  <D.7820>:
}


GC_reclaim_uninit2 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.24;
  long unsigned int D.8209;
  word * mark_word_addr.25;
  long unsigned int D.8211;
  long unsigned int list.26;
  long unsigned int D.8215;
  word * D.8218;
  long unsigned int D.8219;
  word * D.8222;
  long unsigned int D.8223;
  word * D.8226;
  long unsigned int i.27;
  char * D.8228;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.24 = (long unsigned int) hbp;
  D.8209 = hbp.24 + 4096;
  plim = (word *) D.8209;
  goto <D.7835>;
  <D.7834>:
  mark_word_addr.25 = mark_word_addr;
  mark_word_addr = mark_word_addr.25 + 4;
  mark_word = *mark_word_addr.25;
  i = 0;
  goto <D.7832>;
  <D.7831>:
  D.8211 = mark_word & 1;
  if (D.8211 == 0) goto <D.8212>; else goto <D.8213>;
  <D.8212>:
  list.26 = (long unsigned int) list;
  *p = list.26;
  list = p;
  <D.8213>:
  D.8215 = mark_word & 4;
  if (D.8215 == 0) goto <D.8216>; else goto <D.8217>;
  <D.8216>:
  D.8218 = p + 8;
  list.26 = (long unsigned int) list;
  *D.8218 = list.26;
  list = p + 8;
  <D.8217>:
  D.8219 = mark_word & 16;
  if (D.8219 == 0) goto <D.8220>; else goto <D.8221>;
  <D.8220>:
  D.8222 = p + 16;
  list.26 = (long unsigned int) list;
  *D.8222 = list.26;
  list = p + 16;
  <D.8221>:
  D.8223 = mark_word & 64;
  if (D.8223 == 0) goto <D.8224>; else goto <D.8225>;
  <D.8224>:
  D.8226 = p + 24;
  list.26 = (long unsigned int) list;
  *D.8226 = list.26;
  list = p + 24;
  <D.8225>:
  p = p + 32;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.7832>:
  i.27 = (long unsigned int) i;
  if (i.27 <= 31) goto <D.7831>; else goto <D.7833>;
  <D.7833>:
  <D.7835>:
  if (p < plim) goto <D.7834>; else goto <D.7836>;
  <D.7836>:
  D.8228 = list;
  return D.8228;
}


GC_reclaim_uninit4 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.28;
  long unsigned int D.8231;
  word * mark_word_addr.29;
  long unsigned int D.8233;
  long unsigned int list.30;
  long unsigned int D.8237;
  word * D.8240;
  long unsigned int D.8241;
  word * D.8244;
  long unsigned int D.8245;
  word * D.8248;
  long unsigned int D.8249;
  word * D.8252;
  long unsigned int D.8253;
  word * D.8256;
  long unsigned int D.8257;
  word * D.8260;
  long unsigned int D.8261;
  word * D.8264;
  char * D.8265;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.28 = (long unsigned int) hbp;
  D.8231 = hbp.28 + 4096;
  plim = (word *) D.8231;
  goto <D.7847>;
  <D.7846>:
  mark_word_addr.29 = mark_word_addr;
  mark_word_addr = mark_word_addr.29 + 4;
  mark_word = *mark_word_addr.29;
  D.8233 = mark_word & 1;
  if (D.8233 == 0) goto <D.8234>; else goto <D.8235>;
  <D.8234>:
  list.30 = (long unsigned int) list;
  *p = list.30;
  list = p;
  <D.8235>:
  D.8237 = mark_word & 16;
  if (D.8237 == 0) goto <D.8238>; else goto <D.8239>;
  <D.8238>:
  D.8240 = p + 16;
  list.30 = (long unsigned int) list;
  *D.8240 = list.30;
  list = p + 16;
  <D.8239>:
  D.8241 = mark_word & 256;
  if (D.8241 == 0) goto <D.8242>; else goto <D.8243>;
  <D.8242>:
  D.8244 = p + 32;
  list.30 = (long unsigned int) list;
  *D.8244 = list.30;
  list = p + 32;
  <D.8243>:
  D.8245 = mark_word & 4096;
  if (D.8245 == 0) goto <D.8246>; else goto <D.8247>;
  <D.8246>:
  D.8248 = p + 48;
  list.30 = (long unsigned int) list;
  *D.8248 = list.30;
  list = p + 48;
  <D.8247>:
  D.8249 = mark_word & 65536;
  if (D.8249 == 0) goto <D.8250>; else goto <D.8251>;
  <D.8250>:
  D.8252 = p + 64;
  list.30 = (long unsigned int) list;
  *D.8252 = list.30;
  list = p + 64;
  <D.8251>:
  D.8253 = mark_word & 1048576;
  if (D.8253 == 0) goto <D.8254>; else goto <D.8255>;
  <D.8254>:
  D.8256 = p + 80;
  list.30 = (long unsigned int) list;
  *D.8256 = list.30;
  list = p + 80;
  <D.8255>:
  D.8257 = mark_word & 16777216;
  if (D.8257 == 0) goto <D.8258>; else goto <D.8259>;
  <D.8258>:
  D.8260 = p + 96;
  list.30 = (long unsigned int) list;
  *D.8260 = list.30;
  list = p + 96;
  <D.8259>:
  D.8261 = mark_word & 268435456;
  if (D.8261 == 0) goto <D.8262>; else goto <D.8263>;
  <D.8262>:
  D.8264 = p + 112;
  list.30 = (long unsigned int) list;
  *D.8264 = list.30;
  list = p + 112;
  <D.8263>:
  p = p + 128;
  <D.7847>:
  if (p < plim) goto <D.7846>; else goto <D.7848>;
  <D.7848>:
  D.8265 = list;
  return D.8265;
}


GC_reclaim1 (struct hblk * hbp, struct hdr * hhdr, char * list)
{
  long unsigned int hbp.31;
  long unsigned int D.8268;
  word * mark_word_addr.32;
  long unsigned int D.8270;
  long unsigned int list.33;
  long unsigned int D.8274;
  word * D.8277;
  long unsigned int D.8278;
  word * D.8281;
  long unsigned int D.8282;
  word * D.8285;
  long unsigned int i.34;
  char * D.8287;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;

  mark_word_addr = &hhdr->hb_marks[0];
  p = &hbp->hb_body;
  hbp.31 = (long unsigned int) hbp;
  D.8268 = hbp.31 + 4096;
  plim = (word *) D.8268;
  goto <D.7863>;
  <D.7862>:
  mark_word_addr.32 = mark_word_addr;
  mark_word_addr = mark_word_addr.32 + 4;
  mark_word = *mark_word_addr.32;
  i = 0;
  goto <D.7860>;
  <D.7859>:
  D.8270 = mark_word & 1;
  if (D.8270 == 0) goto <D.8271>; else goto <D.8272>;
  <D.8271>:
  list.33 = (long unsigned int) list;
  *p = list.33;
  list = p;
  <D.8272>:
  D.8274 = mark_word & 2;
  if (D.8274 == 0) goto <D.8275>; else goto <D.8276>;
  <D.8275>:
  D.8277 = p + 4;
  list.33 = (long unsigned int) list;
  *D.8277 = list.33;
  list = p + 4;
  <D.8276>:
  D.8278 = mark_word & 4;
  if (D.8278 == 0) goto <D.8279>; else goto <D.8280>;
  <D.8279>:
  D.8281 = p + 8;
  list.33 = (long unsigned int) list;
  *D.8281 = list.33;
  list = p + 8;
  <D.8280>:
  D.8282 = mark_word & 8;
  if (D.8282 == 0) goto <D.8283>; else goto <D.8284>;
  <D.8283>:
  D.8285 = p + 12;
  list.33 = (long unsigned int) list;
  *D.8285 = list.33;
  list = p + 12;
  <D.8284>:
  p = p + 16;
  mark_word = mark_word >> 4;
  i = i + 4;
  <D.7860>:
  i.34 = (long unsigned int) i;
  if (i.34 <= 31) goto <D.7859>; else goto <D.7861>;
  <D.7861>:
  <D.7863>:
  if (p < plim) goto <D.7862>; else goto <D.7864>;
  <D.7864>:
  D.8287 = list;
  return D.8287;
}


GC_reclaim_generic (struct hblk * hbp, struct hdr * hhdr, word sz, GC_bool init, char * list)
{
  long unsigned int D.8289;
  _Bool D.8290;
  int D.8291;
  unsigned char D.8295;
  int D.8296;
  int D.8297;
  char * D.8300;
  char * result;

  result = list;
  D.8289 = hhdr->hb_descr;
  D.8290 = D.8289 == 0;
  D.8291 = (int) D.8290;
  GC_remove_protection (hbp, 1, D.8291);
  if (init != 0) goto <D.8292>; else goto <D.8293>;
  <D.8292>:
  switch (sz) <default: <D.7877>, case 1: <D.7873>, case 2: <D.7875>, case 4: <D.7876>>
  <D.7873>:
  result = GC_reclaim1 (hbp, hhdr, list);
  goto <D.7874>;
  <D.7875>:
  result = GC_reclaim_clear2 (hbp, hhdr, list);
  goto <D.7874>;
  <D.7876>:
  result = GC_reclaim_clear4 (hbp, hhdr, list);
  goto <D.7874>;
  <D.7877>:
  result = GC_reclaim_clear (hbp, hhdr, sz, list);
  goto <D.7874>;
  <D.7874>:
  goto <D.8294>;
  <D.8293>:
  switch (sz) <default: <D.7882>, case 1: <D.7878>, case 2: <D.7880>, case 4: <D.7881>>
  <D.7878>:
  result = GC_reclaim1 (hbp, hhdr, list);
  goto <D.7879>;
  <D.7880>:
  result = GC_reclaim_uninit2 (hbp, hhdr, list);
  goto <D.7879>;
  <D.7881>:
  result = GC_reclaim_uninit4 (hbp, hhdr, list);
  goto <D.7879>;
  <D.7882>:
  result = GC_reclaim_uninit (hbp, hhdr, sz, list);
  goto <D.7879>;
  <D.7879>:
  <D.8294>:
  D.8295 = hhdr->hb_obj_kind;
  D.8296 = (int) D.8295;
  D.8297 = D.8296 & -2;
  if (D.8297 == 2) goto <D.8298>; else goto <D.8299>;
  <D.8298>:
  GC_set_hdr_marks (hhdr);
  <D.8299>:
  D.8300 = result;
  return D.8300;
}


GC_reclaim_small_nonempty_block (struct hblk * hbp, int report_if_found)
{
  long unsigned int hbp.35;
  long unsigned int D.8303;
  struct bottom_index * D.8304;
  long unsigned int D.8305;
  long unsigned int D.8306;
  unsigned char D.8307;
  char * * D.8308;
  long unsigned int D.8309;
  long unsigned int GC_gc_no.36;
  short unsigned int D.8311;
  int iftmp.37;
  int D.8319;
  int GC_debugging_started.38;
  char * D.8322;
  char * D.8323;
  struct hdr * hhdr;
  word sz;
  int kind;
  struct obj_kind * ok;
  char * * flh;

  hbp.35 = (long unsigned int) hbp;
  D.8303 = hbp.35 >> 22;
  D.8304 = GC_arrays._top_index[D.8303];
  hbp.35 = (long unsigned int) hbp;
  D.8305 = hbp.35 >> 12;
  D.8306 = D.8305 & 1023;
  hhdr = D.8304->index[D.8306];
  sz = hhdr->hb_sz;
  D.8307 = hhdr->hb_obj_kind;
  kind = (int) D.8307;
  ok = &GC_obj_kinds[kind];
  D.8308 = ok->ok_freelist;
  D.8309 = sz * 4;
  flh = D.8308 + D.8309;
  GC_gc_no.36 = GC_gc_no;
  D.8311 = (short unsigned int) GC_gc_no.36;
  hhdr->hb_last_reclaimed = D.8311;
  if (report_if_found != 0) goto <D.8312>; else goto <D.8313>;
  <D.8312>:
  GC_reclaim_check (hbp, hhdr, sz);
  goto <D.8314>;
  <D.8313>:
  D.8319 = ok->ok_init;
  if (D.8319 != 0) goto <D.8316>; else goto <D.8320>;
  <D.8320>:
  GC_debugging_started.38 = GC_debugging_started;
  if (GC_debugging_started.38 != 0) goto <D.8316>; else goto <D.8317>;
  <D.8316>:
  iftmp.37 = 1;
  goto <D.8318>;
  <D.8317>:
  iftmp.37 = 0;
  <D.8318>:
  D.8322 = *flh;
  D.8323 = GC_reclaim_generic (hbp, hhdr, sz, iftmp.37, D.8322);
  *flh = D.8323;
  <D.8314>:
}


GC_reclaim_block (struct hblk * hbp, word report_if_found)
{
  long unsigned int hbp.39;
  long unsigned int D.8325;
  struct bottom_index * D.8326;
  long unsigned int D.8327;
  long unsigned int D.8328;
  unsigned char D.8329;
  int D.8330;
  long unsigned int D.8333;
  long unsigned int D.8334;
  long unsigned int D.8340;
  long unsigned int D.8341;
  long unsigned int D.8344;
  long unsigned int D.8345;
  long unsigned int D.8346;
  int report_if_found.40;
  int D.8355;
  struct hblk * * D.8358;
  long unsigned int D.8359;
  struct hblk * D.8360;
  register struct hdr * hhdr;
  register word sz;
  register struct obj_kind * ok;
  struct hblk * * rlh;

  hbp.39 = (long unsigned int) hbp;
  D.8325 = hbp.39 >> 22;
  D.8326 = GC_arrays._top_index[D.8325];
  hbp.39 = (long unsigned int) hbp;
  D.8327 = hbp.39 >> 12;
  D.8328 = D.8327 & 1023;
  hhdr = D.8326->index[D.8328];
  sz = hhdr->hb_sz;
  D.8329 = hhdr->hb_obj_kind;
  D.8330 = (int) D.8329;
  ok = &GC_obj_kinds[D.8330];
  if (sz > 512) goto <D.8331>; else goto <D.8332>;
  <D.8331>:
  D.8333 = hhdr->hb_marks[0];
  D.8334 = D.8333 & 1;
  if (D.8334 == 0) goto <D.8335>; else goto <D.8336>;
  <D.8335>:
  if (report_if_found != 0) goto <D.8337>; else goto <D.8338>;
  <D.8337>:
  GC_add_leaked (hbp);
  goto <D.8339>;
  <D.8338>:
  {
    word blocks;

    D.8340 = sz << 2;
    D.8341 = D.8340 + 4095;
    blocks = D.8341 >> 12;
    if (blocks > 1) goto <D.8342>; else goto <D.8343>;
    <D.8342>:
    D.8344 = GC_arrays._large_allocd_bytes;
    D.8345 = blocks * 4096;
    D.8346 = D.8344 - D.8345;
    GC_arrays._large_allocd_bytes = D.8346;
    <D.8343>:
    GC_freehblk (hbp);
  }
  <D.8339>:
  <D.8336>:
  goto <D.8347>;
  <D.8332>:
  {
    GC_bool empty;

    empty = GC_block_empty (hhdr);
    if (report_if_found != 0) goto <D.8348>; else goto <D.8349>;
    <D.8348>:
    report_if_found.40 = (int) report_if_found;
    GC_reclaim_small_nonempty_block (hbp, report_if_found.40);
    goto <D.8351>;
    <D.8349>:
    if (empty != 0) goto <D.8352>; else goto <D.8353>;
    <D.8352>:
    GC_freehblk (hbp);
    goto <D.8354>;
    <D.8353>:
    D.8355 = GC_block_nearly_full (hhdr);
    if (D.8355 != 1) goto <D.8356>; else goto <D.8357>;
    <D.8356>:
    D.8358 = ok->ok_reclaim_list;
    D.8359 = sz * 4;
    rlh = D.8358 + D.8359;
    D.8360 = *rlh;
    hhdr->hb_next = D.8360;
    *rlh = hbp;
    <D.8357>:
    <D.8354>:
    <D.8351>:
  }
  <D.8347>:
}


GC_n_set_marks (struct hdr * hhdr)
{
  long unsigned int D.8361;
  int D.8362;
  int D.8363;
  register int result;
  register int i;

  result = 0;
  i = 0;
  goto <D.7919>;
  <D.7918>:
  D.8361 = hhdr->hb_marks[i];
  D.8362 = set_bits (D.8361);
  result = D.8362 + result;
  i = i + 1;
  <D.7919>:
  if (i <= 31) goto <D.7918>; else goto <D.7920>;
  <D.7920>:
  D.8363 = result;
  return D.8363;
}


set_bits (word n)
{
  long unsigned int D.8365;
  int D.8368;
  register word m;
  register int result;

  m = n;
  result = 0;
  goto <D.7911>;
  <D.7910>:
  D.8365 = m & 1;
  if (D.8365 != 0) goto <D.8366>; else goto <D.8367>;
  <D.8366>:
  result = result + 1;
  <D.8367>:
  m = m >> 1;
  <D.7911>:
  if (m != 0) goto <D.7910>; else goto <D.7912>;
  <D.7912>:
  D.8368 = result;
  return D.8368;
}


GC_print_block_descr (struct hblk * h, word dummy)
{
  long unsigned int h.41;
  long unsigned int D.8371;
  struct bottom_index * D.8372;
  long unsigned int D.8373;
  long unsigned int D.8374;
  long unsigned int D.8375;
  unsigned char D.8376;
  long int D.8377;
  long int bytes.42;
  int D.8379;
  unsigned int D.8380;
  unsigned int D.8381;
  unsigned int D.8382;
  unsigned int D.8383;
  register struct hdr * hhdr;
  register size_t bytes;
  struct Print_stats * ps;

  h.41 = (long unsigned int) h;
  D.8371 = h.41 >> 22;
  D.8372 = GC_arrays._top_index[D.8371];
  h.41 = (long unsigned int) h;
  D.8373 = h.41 >> 12;
  D.8374 = D.8373 & 1023;
  hhdr = D.8372->index[D.8374];
  D.8375 = hhdr->hb_sz;
  bytes = D.8375 << 2;
  D.8376 = hhdr->hb_obj_kind;
  D.8377 = (long int) D.8376;
  bytes.42 = (long int) bytes;
  D.8379 = GC_n_set_marks (hhdr);
  GC_printf ("(%lu:%lu,%lu)", D.8377, bytes.42, D.8379, 0, 0, 0);
  bytes = bytes + 4095;
  bytes = bytes & 4294963200;
  ps = (struct Print_stats *) dummy;
  D.8380 = ps->total_bytes;
  D.8381 = D.8380 + bytes;
  ps->total_bytes = D.8381;
  D.8382 = ps->number_of_blocks;
  D.8383 = D.8382 + 1;
  ps->number_of_blocks = D.8383;
}


GC_print_block_list ()
{
  long unsigned int pstats.43;
  unsigned int D.8385;
  long int D.8386;
  unsigned int D.8387;
  long int D.8388;
  struct Print_stats pstats;

  try
    {
      GC_printf ("(kind(0=ptrfree,1=normal,2=unc.,%lu=stubborn):size_in_bytes, #_marks_set)\n", 4, 0, 0, 0, 0, 0);
      pstats.number_of_blocks = 0;
      pstats.total_bytes = 0;
      pstats.43 = (long unsigned int) &pstats;
      GC_apply_to_all_blocks (GC_print_block_descr, pstats.43);
      D.8385 = pstats.number_of_blocks;
      D.8386 = (long int) D.8385;
      D.8387 = pstats.total_bytes;
      D.8388 = (long int) D.8387;
      GC_printf ("\nblocks = %lu, bytes = %lu\n", D.8386, D.8388, 0, 0, 0, 0);
    }
  finally
    {
      pstats = {CLOBBER};
    }
}


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

  next = *flp;
  goto <D.7936>;
  <D.7935>:
  *flp = 0B;
  flp = next;
  next = *flp;
  <D.7936>:
  if (next != 0B) goto <D.7935>; else goto <D.7937>;
  <D.7937>:
}


GC_start_reclaim (int report_if_found)
{
  long unsigned int D.8389;
  _Bool D.8390;
  char * * D.8395;
  char * D.8396;
  int GC_n_kinds.44;
  long unsigned int report_if_found.45;
  int kind;

  kind = 0;
  goto <D.7956>;
  <D.7955>:
  {
    char * * fop;
    char * * lim;
    struct hblk * * rlp;
    struct hblk * * rlim;
    struct hblk * * rlist;
    GC_bool should_clobber;

    rlist = GC_obj_kinds[kind].ok_reclaim_list;
    D.8389 = GC_obj_kinds[kind].ok_descriptor;
    D.8390 = D.8389 != 0;
    should_clobber = (GC_bool) D.8390;
    if (rlist == 0B) goto <D.8391>; else goto <D.8392>;
    <D.8391>:
    // predicted unlikely by continue predictor.
    goto <D.7948>;
    <D.8392>:
    if (report_if_found == 0) goto <D.8393>; else goto <D.8394>;
    <D.8393>:
    D.8395 = GC_obj_kinds[kind].ok_freelist;
    lim = D.8395 + 2052;
    fop = GC_obj_kinds[kind].ok_freelist;
    goto <D.7950>;
    <D.7949>:
    D.8396 = *fop;
    if (D.8396 != 0B) goto <D.8397>; else goto <D.8398>;
    <D.8397>:
    if (should_clobber != 0) goto <D.8399>; else goto <D.8400>;
    <D.8399>:
    GC_clear_fl_links (fop);
    goto <D.8401>;
    <D.8400>:
    *fop = 0B;
    <D.8401>:
    <D.8398>:
    fop = fop + 4;
    <D.7950>:
    if (fop < lim) goto <D.7949>; else goto <D.7951>;
    <D.7951>:
    <D.8394>:
    rlim = rlist + 2052;
    rlp = rlist;
    goto <D.7953>;
    <D.7952>:
    *rlp = 0B;
    rlp = rlp + 4;
    <D.7953>:
    if (rlp < rlim) goto <D.7952>; else goto <D.7954>;
    <D.7954>:
  }
  <D.7948>:
  kind = kind + 1;
  <D.7956>:
  GC_n_kinds.44 = GC_n_kinds;
  if (kind < GC_n_kinds.44) goto <D.7955>; else goto <D.7957>;
  <D.7957>:
  report_if_found.45 = (long unsigned int) report_if_found;
  GC_apply_to_all_blocks (GC_reclaim_block, report_if_found.45);
}


GC_continue_reclaim (word sz, int kind)
{
  char * * D.8404;
  long unsigned int D.8405;
  long unsigned int hbp.46;
  long unsigned int D.8409;
  struct bottom_index * D.8410;
  long unsigned int D.8411;
  long unsigned int D.8412;
  struct hblk * D.8413;
  char * D.8414;
  register struct hdr * hhdr;
  register struct hblk * hbp;
  register struct obj_kind * ok;
  struct hblk * * rlh;
  char * * flh;

  ok = &GC_obj_kinds[kind];
  rlh = ok->ok_reclaim_list;
  D.8404 = ok->ok_freelist;
  D.8405 = sz * 4;
  flh = D.8404 + D.8405;
  if (rlh == 0B) goto <D.8406>; else goto <D.8407>;
  <D.8406>:
  return;
  <D.8407>:
  D.8405 = sz * 4;
  rlh = rlh + D.8405;
  goto <D.7969>;
  <D.7968>:
  hbp.46 = (long unsigned int) hbp;
  D.8409 = hbp.46 >> 22;
  D.8410 = GC_arrays._top_index[D.8409];
  hbp.46 = (long unsigned int) hbp;
  D.8411 = hbp.46 >> 12;
  D.8412 = D.8411 & 1023;
  hhdr = D.8410->index[D.8412];
  D.8413 = hhdr->hb_next;
  *rlh = D.8413;
  GC_reclaim_small_nonempty_block (hbp, 0);
  D.8414 = *flh;
  if (D.8414 != 0B) goto <D.7967>; else goto <D.8415>;
  <D.8415>:
  <D.7969>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.7968>; else goto <D.7967>;
  <D.7967>:
}


GC_reclaim_all (int (*GC_stop_func) (void) stop_func, GC_bool ignore_old)
{
  long unsigned int D.8419;
  int D.8422;
  GC_bool D.8425;
  long unsigned int hbp.47;
  long unsigned int D.8427;
  struct bottom_index * D.8428;
  long unsigned int D.8429;
  long unsigned int D.8430;
  struct hblk * D.8431;
  short unsigned int D.8435;
  long unsigned int D.8436;
  long unsigned int GC_gc_no.48;
  long unsigned int D.8438;
  int GC_n_kinds.49;
  register word sz;
  register int kind;
  register struct hdr * hhdr;
  register struct hblk * hbp;
  register struct obj_kind * ok;
  struct hblk * * rlp;
  struct hblk * * rlh;

  kind = 0;
  goto <D.7989>;
  <D.7988>:
  ok = &GC_obj_kinds[kind];
  rlp = ok->ok_reclaim_list;
  if (rlp == 0B) goto <D.8417>; else goto <D.8418>;
  <D.8417>:
  // predicted unlikely by continue predictor.
  goto <D.7981>;
  <D.8418>:
  sz = 1;
  goto <D.7986>;
  <D.7985>:
  D.8419 = sz * 4;
  rlh = rlp + D.8419;
  goto <D.7983>;
  <D.7982>:
  if (stop_func != 0B) goto <D.8420>; else goto <D.8421>;
  <D.8420>:
  D.8422 = stop_func ();
  if (D.8422 != 0) goto <D.8423>; else goto <D.8424>;
  <D.8423>:
  D.8425 = 0;
  return D.8425;
  <D.8424>:
  <D.8421>:
  hbp.47 = (long unsigned int) hbp;
  D.8427 = hbp.47 >> 22;
  D.8428 = GC_arrays._top_index[D.8427];
  hbp.47 = (long unsigned int) hbp;
  D.8429 = hbp.47 >> 12;
  D.8430 = D.8429 & 1023;
  hhdr = D.8428->index[D.8430];
  D.8431 = hhdr->hb_next;
  *rlh = D.8431;
  if (ignore_old == 0) goto <D.8432>; else goto <D.8434>;
  <D.8434>:
  D.8435 = hhdr->hb_last_reclaimed;
  D.8436 = (long unsigned int) D.8435;
  GC_gc_no.48 = GC_gc_no;
  D.8438 = GC_gc_no.48 + 4294967295;
  if (D.8436 == D.8438) goto <D.8432>; else goto <D.8433>;
  <D.8432>:
  GC_reclaim_small_nonempty_block (hbp, 0);
  <D.8433>:
  <D.7983>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.7982>; else goto <D.7984>;
  <D.7984>:
  sz = sz + 1;
  <D.7986>:
  if (sz <= 512) goto <D.7985>; else goto <D.7987>;
  <D.7987>:
  <D.7981>:
  kind = kind + 1;
  <D.7989>:
  GC_n_kinds.49 = GC_n_kinds;
  if (kind < GC_n_kinds.49) goto <D.7988>; else goto <D.7990>;
  <D.7990>:
  D.8425 = 1;
  return D.8425;
}