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.5849>; else goto <D.5850>;
  <D.5849>:
  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.5850>:
}


GC_print_all_errors ()
{
  int D.5853;
  int printing_errors.3;
  int GC_debugging_started.4;
  void (*<T6fb>) (void) GC_print_all_smashed.5;
  struct hdr * D.5863;
  unsigned char D.5864;
  void (*<T1077>) (char *) GC_print_heap_obj.6;
  unsigned int GC_n_leaked.7;
  unsigned int i;

  D.5853 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5853 != 0) goto <D.5854>; else goto <D.5855>;
  <D.5854>:
  GC_lock ();
  <D.5855>:
  printing_errors.3 = printing_errors;
  if (printing_errors.3 != 0) goto <D.5857>; else goto <D.5858>;
  <D.5857>:
  pthread_mutex_unlock (&GC_allocate_ml);
  return;
  <D.5858>:
  printing_errors = 1;
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_debugging_started.4 = GC_debugging_started;
  if (GC_debugging_started.4 != 0) goto <D.5860>; else goto <D.5861>;
  <D.5860>:
  GC_print_all_smashed.5 = GC_print_all_smashed;
  GC_print_all_smashed.5 ();
  <D.5861>:
  i = 0;
  goto <D.5551>;
  <D.5550>:
  {
    char * p;

    p = GC_leaked[i];
    D.5863 = GC_find_header (p);
    D.5864 = D.5863->hb_obj_kind;
    if (D.5864 == 0) goto <D.5865>; else goto <D.5866>;
    <D.5865>:
    GC_err_puts ("Leaked atomic object at ");
    goto <D.5867>;
    <D.5866>:
    GC_err_puts ("Leaked composite object at ");
    <D.5867>:
    GC_print_heap_obj.6 = GC_print_heap_obj;
    GC_print_heap_obj.6 (p);
    GC_err_puts ("\n");
    GC_free (p);
    GC_leaked[i] = 0B;
  }
  i = i + 1;
  <D.5551>:
  GC_n_leaked.7 = GC_n_leaked;
  if (i < GC_n_leaked.7) goto <D.5550>; else goto <D.5552>;
  <D.5552>:
  GC_n_leaked = 0;
  printing_errors = 0;
}


GC_block_empty (struct hdr * hhdr)
{
  word * p.8;
  long unsigned int D.5872;
  GC_bool D.5875;
  register word * p;
  register word * plim;

  p = &hhdr->hb_marks[0];
  plim = &hhdr->hb_marks[8];
  goto <D.5559>;
  <D.5558>:
  p.8 = p;
  p = p.8 + 8;
  D.5872 = *p.8;
  if (D.5872 != 0) goto <D.5873>; else goto <D.5874>;
  <D.5873>:
  D.5875 = 0;
  return D.5875;
  <D.5874>:
  <D.5559>:
  if (p < plim) goto <D.5558>; else goto <D.5560>;
  <D.5560>:
  D.5875 = 1;
  return D.5875;
}


GC_block_nearly_full1 (struct hdr * hhdr, word pat1)
{
  long unsigned int D.5877;
  long unsigned int D.5878;
  long unsigned int D.5879;
  GC_bool D.5884;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  i = 0;
  goto <D.5568>;
  <D.5567>:
  D.5877 = hhdr->hb_marks[i];
  D.5878 = ~pat1;
  D.5879 = D.5877 | D.5878;
  if (D.5879 != 18446744073709551615) goto <D.5880>; else goto <D.5881>;
  <D.5880>:
  misses = misses + 1;
  if (misses != 0) goto <D.5882>; else goto <D.5883>;
  <D.5882>:
  D.5884 = 0;
  return D.5884;
  <D.5883>:
  <D.5881>:
  i = i + 1;
  <D.5568>:
  if (i <= 7) goto <D.5567>; else goto <D.5569>;
  <D.5569>:
  D.5884 = 1;
  return D.5884;
}


GC_block_nearly_full3 (struct hdr * hhdr, word pat1, word pat2, word pat3)
{
  GC_bool D.5888;
  long unsigned int D.5889;
  long unsigned int D.5890;
  long unsigned int D.5891;
  unsigned int D.5896;
  long unsigned int D.5897;
  long unsigned int D.5898;
  long unsigned int D.5899;
  unsigned int D.5904;
  long unsigned int D.5905;
  long unsigned int D.5906;
  long unsigned int D.5907;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  if (0 != 0) goto <D.5886>; else goto <D.5887>;
  <D.5886>:
  D.5888 = 2;
  return D.5888;
  <D.5887>:
  i = 0;
  goto <D.5579>;
  <D.5578>:
  D.5889 = hhdr->hb_marks[i];
  D.5890 = ~pat1;
  D.5891 = D.5889 | D.5890;
  if (D.5891 != 18446744073709551615) goto <D.5892>; else goto <D.5893>;
  <D.5892>:
  misses = misses + 1;
  if (misses != 0) goto <D.5894>; else goto <D.5895>;
  <D.5894>:
  D.5888 = 0;
  return D.5888;
  <D.5895>:
  <D.5893>:
  D.5896 = i + 1;
  D.5897 = hhdr->hb_marks[D.5896];
  D.5898 = ~pat2;
  D.5899 = D.5897 | D.5898;
  if (D.5899 != 18446744073709551615) goto <D.5900>; else goto <D.5901>;
  <D.5900>:
  misses = misses + 1;
  if (misses != 0) goto <D.5902>; else goto <D.5903>;
  <D.5902>:
  D.5888 = 0;
  return D.5888;
  <D.5903>:
  <D.5901>:
  D.5904 = i + 2;
  D.5905 = hhdr->hb_marks[D.5904];
  D.5906 = ~pat3;
  D.5907 = D.5905 | D.5906;
  if (D.5907 != 18446744073709551615) goto <D.5908>; else goto <D.5909>;
  <D.5908>:
  misses = misses + 1;
  if (misses != 0) goto <D.5910>; else goto <D.5911>;
  <D.5910>:
  D.5888 = 0;
  return D.5888;
  <D.5911>:
  <D.5909>:
  i = i + 3;
  <D.5579>:
  if (i <= 5) goto <D.5578>; else goto <D.5580>;
  <D.5580>:
  D.5888 = 1;
  return D.5888;
}


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

  D.5913 = hhdr->hb_sz;
  sz = (int) D.5913;
  switch (sz) <default: <D.5593>, case 1: <D.5585>, case 2: <D.5586>, case 4: <D.5587>, case 6: <D.5588>, case 8: <D.5589>, case 12: <D.5590>, case 16: <D.5591>, case 32: <D.5592>>
  <D.5585>:
  D.5914 = GC_block_nearly_full1 (hhdr, 18446744073709551615);
  return D.5914;
  <D.5586>:
  D.5914 = GC_block_nearly_full1 (hhdr, 6148914691236517205);
  return D.5914;
  <D.5587>:
  D.5914 = GC_block_nearly_full1 (hhdr, 1229782938247303441);
  return D.5914;
  <D.5588>:
  D.5914 = GC_block_nearly_full3 (hhdr, 1171221845949812801, 4684887383799251204, 292805461487453200);
  return D.5914;
  <D.5589>:
  D.5914 = GC_block_nearly_full1 (hhdr, 72340172838076673);
  return D.5914;
  <D.5590>:
  D.5914 = GC_block_nearly_full3 (hhdr, 1153203048319815681, 72075190519988480, 4504699407499280);
  return D.5914;
  <D.5591>:
  D.5914 = GC_block_nearly_full1 (hhdr, 281479271743489);
  return D.5914;
  <D.5592>:
  D.5914 = GC_block_nearly_full1 (hhdr, 4294967297);
  return D.5914;
  <D.5593>:
  D.5914 = 2;
  return D.5914;
}


GC_reclaim_clear (struct hblk * hbp, struct hdr * hhdr, word sz, char * list, signed_word * count)
{
  long unsigned int hbp.9;
  long unsigned int D.5917;
  long unsigned int D.5918;
  long unsigned int D.5919;
  int D.5920;
  long unsigned int D.5921;
  int D.5922;
  long unsigned int D.5923;
  long unsigned int D.5924;
  long unsigned int D.5927;
  long unsigned int n_words_found.10;
  long unsigned int D.5930;
  word * p.11;
  unsigned int D.5932;
  unsigned int word_no.12;
  unsigned int D.5934;
  long int D.5935;
  long int D.5936;
  char * D.5937;
  register int word_no;
  register word * p;
  register word * q;
  register word * plim;
  signed_word n_words_found;

  n_words_found = 0;
  p = &hbp->hb_body;
  word_no = 0;
  hbp.9 = (long unsigned int) hbp;
  D.5917 = sz << 3;
  D.5918 = hbp.9 - D.5917;
  D.5919 = D.5918 + 4096;
  plim = (word *) D.5919;
  goto <D.5610>;
  <D.5609>:
  D.5920 = word_no >> 6;
  D.5921 = hhdr->hb_marks[D.5920];
  D.5922 = word_no & 63;
  D.5923 = D.5921 >> D.5922;
  D.5924 = D.5923 & 1;
  if (D.5924 != 0) goto <D.5925>; else goto <D.5926>;
  <D.5925>:
  D.5927 = sz * 8;
  p = p + D.5927;
  goto <D.5928>;
  <D.5926>:
  n_words_found.10 = (long unsigned int) n_words_found;
  D.5930 = n_words_found.10 + sz;
  n_words_found = (signed_word) D.5930;
  MEM[(char * *)p] = list;
  list = p;
  D.5927 = sz * 8;
  q = p + D.5927;
  p = p + 8;
  goto <D.5607>;
  <D.5606>:
  p.11 = p;
  p = p.11 + 8;
  *p.11 = 0;
  <D.5607>:
  if (p < q) goto <D.5606>; else goto <D.5608>;
  <D.5608>:
  <D.5928>:
  D.5932 = (unsigned int) sz;
  word_no.12 = (unsigned int) word_no;
  D.5934 = D.5932 + word_no.12;
  word_no = (int) D.5934;
  <D.5610>:
  if (p <= plim) goto <D.5609>; else goto <D.5611>;
  <D.5611>:
  D.5935 = *count;
  D.5936 = D.5935 + n_words_found;
  *count = D.5936;
  D.5937 = list;
  return D.5937;
}


GC_reclaim_clear2 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.13;
  long unsigned int D.5940;
  word * mark_word_addr.14;
  long unsigned int D.5942;
  long unsigned int list.15;
  word * D.5946;
  long unsigned int D.5947;
  word * D.5950;
  word * D.5951;
  long unsigned int D.5952;
  word * D.5955;
  word * D.5956;
  long unsigned int D.5957;
  word * D.5960;
  word * D.5961;
  unsigned int i.16;
  long int D.5963;
  long int D.5964;
  char * D.5965;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.13 = (long unsigned int) hbp;
  D.5940 = hbp.13 + 4096;
  plim = (word *) D.5940;
  goto <D.5628>;
  <D.5627>:
  mark_word_addr.14 = mark_word_addr;
  mark_word_addr = mark_word_addr.14 + 8;
  mark_word = *mark_word_addr.14;
  i = 0;
  goto <D.5625>;
  <D.5624>:
  D.5942 = mark_word & 1;
  if (D.5942 == 0) goto <D.5943>; else goto <D.5944>;
  <D.5943>:
  list.15 = (long unsigned int) list;
  *p = list.15;
  list = p;
  D.5946 = p + 8;
  *D.5946 = 0;
  n_words_found = n_words_found + 2;
  <D.5944>:
  D.5947 = mark_word & 4;
  if (D.5947 == 0) goto <D.5948>; else goto <D.5949>;
  <D.5948>:
  D.5950 = p + 16;
  list.15 = (long unsigned int) list;
  *D.5950 = list.15;
  list = p + 16;
  D.5951 = p + 24;
  *D.5951 = 0;
  n_words_found = n_words_found + 2;
  <D.5949>:
  D.5952 = mark_word & 16;
  if (D.5952 == 0) goto <D.5953>; else goto <D.5954>;
  <D.5953>:
  D.5955 = p + 32;
  list.15 = (long unsigned int) list;
  *D.5955 = list.15;
  list = p + 32;
  D.5956 = p + 40;
  *D.5956 = 0;
  n_words_found = n_words_found + 2;
  <D.5954>:
  D.5957 = mark_word & 64;
  if (D.5957 == 0) goto <D.5958>; else goto <D.5959>;
  <D.5958>:
  D.5960 = p + 48;
  list.15 = (long unsigned int) list;
  *D.5960 = list.15;
  list = p + 48;
  D.5961 = p + 56;
  *D.5961 = 0;
  n_words_found = n_words_found + 2;
  <D.5959>:
  p = p + 64;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.5625>:
  i.16 = (unsigned int) i;
  if (i.16 <= 63) goto <D.5624>; else goto <D.5626>;
  <D.5626>:
  <D.5628>:
  if (p < plim) goto <D.5627>; else goto <D.5629>;
  <D.5629>:
  D.5963 = *count;
  D.5964 = D.5963 + n_words_found;
  *count = D.5964;
  D.5965 = list;
  return D.5965;
}


GC_reclaim_clear4 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.17;
  long unsigned int D.5968;
  word * mark_word_addr.18;
  long unsigned int D.5970;
  long unsigned int list.19;
  word * D.5974;
  word * D.5975;
  word * D.5976;
  long unsigned int D.5977;
  word * D.5980;
  word * D.5981;
  word * D.5982;
  word * D.5983;
  long unsigned int D.5984;
  word * D.5987;
  word * D.5988;
  word * D.5989;
  word * D.5990;
  long unsigned int D.5991;
  word * D.5994;
  word * D.5995;
  word * D.5996;
  word * D.5997;
  long unsigned int D.5998;
  word * D.6001;
  word * D.6002;
  word * D.6003;
  word * D.6004;
  long unsigned int D.6005;
  word * D.6008;
  word * D.6009;
  word * D.6010;
  word * D.6011;
  long unsigned int D.6012;
  word * D.6015;
  word * D.6016;
  word * D.6017;
  word * D.6018;
  long unsigned int D.6019;
  word * D.6022;
  word * D.6023;
  word * D.6024;
  word * D.6025;
  long unsigned int D.6026;
  word * D.6029;
  word * D.6030;
  word * D.6031;
  word * D.6032;
  long unsigned int D.6033;
  word * D.6036;
  word * D.6037;
  word * D.6038;
  word * D.6039;
  long unsigned int D.6040;
  word * D.6043;
  word * D.6044;
  word * D.6045;
  word * D.6046;
  long unsigned int D.6047;
  word * D.6050;
  word * D.6051;
  word * D.6052;
  word * D.6053;
  long unsigned int D.6054;
  word * D.6057;
  word * D.6058;
  word * D.6059;
  word * D.6060;
  long unsigned int D.6061;
  word * D.6064;
  word * D.6065;
  word * D.6066;
  word * D.6067;
  long unsigned int D.6068;
  word * D.6071;
  word * D.6072;
  word * D.6073;
  word * D.6074;
  long unsigned int D.6075;
  word * D.6078;
  word * D.6079;
  word * D.6080;
  word * D.6081;
  long int D.6082;
  long int D.6083;
  char * D.6084;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.17 = (long unsigned int) hbp;
  D.5968 = hbp.17 + 4096;
  plim = (word *) D.5968;
  goto <D.5642>;
  <D.5641>:
  mark_word_addr.18 = mark_word_addr;
  mark_word_addr = mark_word_addr.18 + 8;
  mark_word = *mark_word_addr.18;
  D.5970 = mark_word & 1;
  if (D.5970 == 0) goto <D.5971>; else goto <D.5972>;
  <D.5971>:
  list.19 = (long unsigned int) list;
  *p = list.19;
  list = p;
  D.5974 = p + 8;
  *D.5974 = 0;
  D.5975 = p + 16;
  *D.5975 = 0;
  D.5976 = p + 24;
  *D.5976 = 0;
  n_words_found = n_words_found + 4;
  <D.5972>:
  D.5977 = mark_word & 16;
  if (D.5977 == 0) goto <D.5978>; else goto <D.5979>;
  <D.5978>:
  D.5980 = p + 32;
  list.19 = (long unsigned int) list;
  *D.5980 = list.19;
  list = p + 32;
  D.5981 = p + 40;
  *D.5981 = 0;
  D.5982 = p + 48;
  *D.5982 = 0;
  D.5983 = p + 56;
  *D.5983 = 0;
  n_words_found = n_words_found + 4;
  <D.5979>:
  D.5984 = mark_word & 256;
  if (D.5984 == 0) goto <D.5985>; else goto <D.5986>;
  <D.5985>:
  D.5987 = p + 64;
  list.19 = (long unsigned int) list;
  *D.5987 = list.19;
  list = p + 64;
  D.5988 = p + 72;
  *D.5988 = 0;
  D.5989 = p + 80;
  *D.5989 = 0;
  D.5990 = p + 88;
  *D.5990 = 0;
  n_words_found = n_words_found + 4;
  <D.5986>:
  D.5991 = mark_word & 4096;
  if (D.5991 == 0) goto <D.5992>; else goto <D.5993>;
  <D.5992>:
  D.5994 = p + 96;
  list.19 = (long unsigned int) list;
  *D.5994 = list.19;
  list = p + 96;
  D.5995 = p + 104;
  *D.5995 = 0;
  D.5996 = p + 112;
  *D.5996 = 0;
  D.5997 = p + 120;
  *D.5997 = 0;
  n_words_found = n_words_found + 4;
  <D.5993>:
  D.5998 = mark_word & 65536;
  if (D.5998 == 0) goto <D.5999>; else goto <D.6000>;
  <D.5999>:
  D.6001 = p + 128;
  list.19 = (long unsigned int) list;
  *D.6001 = list.19;
  list = p + 128;
  D.6002 = p + 136;
  *D.6002 = 0;
  D.6003 = p + 144;
  *D.6003 = 0;
  D.6004 = p + 152;
  *D.6004 = 0;
  n_words_found = n_words_found + 4;
  <D.6000>:
  D.6005 = mark_word & 1048576;
  if (D.6005 == 0) goto <D.6006>; else goto <D.6007>;
  <D.6006>:
  D.6008 = p + 160;
  list.19 = (long unsigned int) list;
  *D.6008 = list.19;
  list = p + 160;
  D.6009 = p + 168;
  *D.6009 = 0;
  D.6010 = p + 176;
  *D.6010 = 0;
  D.6011 = p + 184;
  *D.6011 = 0;
  n_words_found = n_words_found + 4;
  <D.6007>:
  D.6012 = mark_word & 16777216;
  if (D.6012 == 0) goto <D.6013>; else goto <D.6014>;
  <D.6013>:
  D.6015 = p + 192;
  list.19 = (long unsigned int) list;
  *D.6015 = list.19;
  list = p + 192;
  D.6016 = p + 200;
  *D.6016 = 0;
  D.6017 = p + 208;
  *D.6017 = 0;
  D.6018 = p + 216;
  *D.6018 = 0;
  n_words_found = n_words_found + 4;
  <D.6014>:
  D.6019 = mark_word & 268435456;
  if (D.6019 == 0) goto <D.6020>; else goto <D.6021>;
  <D.6020>:
  D.6022 = p + 224;
  list.19 = (long unsigned int) list;
  *D.6022 = list.19;
  list = p + 224;
  D.6023 = p + 232;
  *D.6023 = 0;
  D.6024 = p + 240;
  *D.6024 = 0;
  D.6025 = p + 248;
  *D.6025 = 0;
  n_words_found = n_words_found + 4;
  <D.6021>:
  D.6026 = mark_word & 4294967296;
  if (D.6026 == 0) goto <D.6027>; else goto <D.6028>;
  <D.6027>:
  D.6029 = p + 256;
  list.19 = (long unsigned int) list;
  *D.6029 = list.19;
  list = p + 256;
  D.6030 = p + 264;
  *D.6030 = 0;
  D.6031 = p + 272;
  *D.6031 = 0;
  D.6032 = p + 280;
  *D.6032 = 0;
  n_words_found = n_words_found + 4;
  <D.6028>:
  D.6033 = mark_word & 68719476736;
  if (D.6033 == 0) goto <D.6034>; else goto <D.6035>;
  <D.6034>:
  D.6036 = p + 288;
  list.19 = (long unsigned int) list;
  *D.6036 = list.19;
  list = p + 288;
  D.6037 = p + 296;
  *D.6037 = 0;
  D.6038 = p + 304;
  *D.6038 = 0;
  D.6039 = p + 312;
  *D.6039 = 0;
  n_words_found = n_words_found + 4;
  <D.6035>:
  D.6040 = mark_word & 1099511627776;
  if (D.6040 == 0) goto <D.6041>; else goto <D.6042>;
  <D.6041>:
  D.6043 = p + 320;
  list.19 = (long unsigned int) list;
  *D.6043 = list.19;
  list = p + 320;
  D.6044 = p + 328;
  *D.6044 = 0;
  D.6045 = p + 336;
  *D.6045 = 0;
  D.6046 = p + 344;
  *D.6046 = 0;
  n_words_found = n_words_found + 4;
  <D.6042>:
  D.6047 = mark_word & 17592186044416;
  if (D.6047 == 0) goto <D.6048>; else goto <D.6049>;
  <D.6048>:
  D.6050 = p + 352;
  list.19 = (long unsigned int) list;
  *D.6050 = list.19;
  list = p + 352;
  D.6051 = p + 360;
  *D.6051 = 0;
  D.6052 = p + 368;
  *D.6052 = 0;
  D.6053 = p + 376;
  *D.6053 = 0;
  n_words_found = n_words_found + 4;
  <D.6049>:
  D.6054 = mark_word & 281474976710656;
  if (D.6054 == 0) goto <D.6055>; else goto <D.6056>;
  <D.6055>:
  D.6057 = p + 384;
  list.19 = (long unsigned int) list;
  *D.6057 = list.19;
  list = p + 384;
  D.6058 = p + 392;
  *D.6058 = 0;
  D.6059 = p + 400;
  *D.6059 = 0;
  D.6060 = p + 408;
  *D.6060 = 0;
  n_words_found = n_words_found + 4;
  <D.6056>:
  D.6061 = mark_word & 4503599627370496;
  if (D.6061 == 0) goto <D.6062>; else goto <D.6063>;
  <D.6062>:
  D.6064 = p + 416;
  list.19 = (long unsigned int) list;
  *D.6064 = list.19;
  list = p + 416;
  D.6065 = p + 424;
  *D.6065 = 0;
  D.6066 = p + 432;
  *D.6066 = 0;
  D.6067 = p + 440;
  *D.6067 = 0;
  n_words_found = n_words_found + 4;
  <D.6063>:
  D.6068 = mark_word & 72057594037927936;
  if (D.6068 == 0) goto <D.6069>; else goto <D.6070>;
  <D.6069>:
  D.6071 = p + 448;
  list.19 = (long unsigned int) list;
  *D.6071 = list.19;
  list = p + 448;
  D.6072 = p + 456;
  *D.6072 = 0;
  D.6073 = p + 464;
  *D.6073 = 0;
  D.6074 = p + 472;
  *D.6074 = 0;
  n_words_found = n_words_found + 4;
  <D.6070>:
  D.6075 = mark_word & 1152921504606846976;
  if (D.6075 == 0) goto <D.6076>; else goto <D.6077>;
  <D.6076>:
  D.6078 = p + 480;
  list.19 = (long unsigned int) list;
  *D.6078 = list.19;
  list = p + 480;
  D.6079 = p + 488;
  *D.6079 = 0;
  D.6080 = p + 496;
  *D.6080 = 0;
  D.6081 = p + 504;
  *D.6081 = 0;
  n_words_found = n_words_found + 4;
  <D.6077>:
  p = p + 512;
  <D.5642>:
  if (p < plim) goto <D.5641>; else goto <D.5643>;
  <D.5643>:
  D.6082 = *count;
  D.6083 = D.6082 + n_words_found;
  *count = D.6083;
  D.6084 = list;
  return D.6084;
}


GC_reclaim_uninit (struct hblk * hbp, struct hdr * hhdr, word sz, char * list, signed_word * count)
{
  long unsigned int hbp.20;
  long unsigned int D.6087;
  long unsigned int D.6088;
  long unsigned int D.6089;
  int D.6090;
  long unsigned int D.6091;
  int D.6092;
  long unsigned int D.6093;
  long unsigned int D.6094;
  long unsigned int n_words_found.21;
  long unsigned int D.6098;
  long unsigned int D.6099;
  unsigned int D.6100;
  unsigned int word_no.22;
  unsigned int D.6102;
  long int D.6103;
  long int D.6104;
  char * D.6105;
  register int word_no;
  register word * p;
  register word * plim;
  signed_word n_words_found;

  word_no = 0;
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.20 = (long unsigned int) hbp;
  D.6087 = sz << 3;
  D.6088 = hbp.20 - D.6087;
  D.6089 = D.6088 + 4096;
  plim = (word *) D.6089;
  goto <D.5656>;
  <D.5655>:
  D.6090 = word_no >> 6;
  D.6091 = hhdr->hb_marks[D.6090];
  D.6092 = word_no & 63;
  D.6093 = D.6091 >> D.6092;
  D.6094 = D.6093 & 1;
  if (D.6094 == 0) goto <D.6095>; else goto <D.6096>;
  <D.6095>:
  n_words_found.21 = (long unsigned int) n_words_found;
  D.6098 = n_words_found.21 + sz;
  n_words_found = (signed_word) D.6098;
  MEM[(char * *)p] = list;
  list = p;
  <D.6096>:
  D.6099 = sz * 8;
  p = p + D.6099;
  D.6100 = (unsigned int) sz;
  word_no.22 = (unsigned int) word_no;
  D.6102 = D.6100 + word_no.22;
  word_no = (int) D.6102;
  <D.5656>:
  if (p <= plim) goto <D.5655>; else goto <D.5657>;
  <D.5657>:
  D.6103 = *count;
  D.6104 = D.6103 + n_words_found;
  *count = D.6104;
  D.6105 = list;
  return D.6105;
}


GC_reclaim_check (struct hblk * hbp, struct hdr * hhdr, word sz)
{
  long unsigned int hbp.23;
  long unsigned int D.6108;
  long unsigned int D.6109;
  long unsigned int D.6110;
  int D.6111;
  long unsigned int D.6112;
  int D.6113;
  long unsigned int D.6114;
  long unsigned int D.6115;
  int D.6118;
  sizetype D.6119;
  char * D.6120;
  long unsigned int D.6121;
  unsigned int D.6122;
  unsigned int word_no.24;
  unsigned int D.6124;
  register int word_no;
  register word * p;
  register word * plim;

  word_no = 0;
  p = &hbp->hb_body;
  hbp.23 = (long unsigned int) hbp;
  D.6108 = sz << 3;
  D.6109 = hbp.23 - D.6108;
  D.6110 = D.6109 + 4096;
  plim = (word *) D.6110;
  goto <D.5667>;
  <D.5666>:
  D.6111 = word_no >> 6;
  D.6112 = hhdr->hb_marks[D.6111];
  D.6113 = word_no & 63;
  D.6114 = D.6112 >> D.6113;
  D.6115 = D.6114 & 1;
  if (D.6115 == 0) goto <D.6116>; else goto <D.6117>;
  <D.6116>:
  D.6118 = word_no << 3;
  D.6119 = (sizetype) D.6118;
  D.6120 = hbp + D.6119;
  GC_add_leaked (D.6120);
  <D.6117>:
  D.6121 = sz * 8;
  p = p + D.6121;
  D.6122 = (unsigned int) sz;
  word_no.24 = (unsigned int) word_no;
  D.6124 = D.6122 + word_no.24;
  word_no = (int) D.6124;
  <D.5667>:
  if (p <= plim) goto <D.5666>; else goto <D.5668>;
  <D.5668>:
}


GC_reclaim_uninit2 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.25;
  long unsigned int D.6126;
  word * mark_word_addr.26;
  long unsigned int D.6128;
  long unsigned int list.27;
  long unsigned int D.6132;
  word * D.6135;
  long unsigned int D.6136;
  word * D.6139;
  long unsigned int D.6140;
  word * D.6143;
  unsigned int i.28;
  long int D.6145;
  long int D.6146;
  char * D.6147;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.25 = (long unsigned int) hbp;
  D.6126 = hbp.25 + 4096;
  plim = (word *) D.6126;
  goto <D.5685>;
  <D.5684>:
  mark_word_addr.26 = mark_word_addr;
  mark_word_addr = mark_word_addr.26 + 8;
  mark_word = *mark_word_addr.26;
  i = 0;
  goto <D.5682>;
  <D.5681>:
  D.6128 = mark_word & 1;
  if (D.6128 == 0) goto <D.6129>; else goto <D.6130>;
  <D.6129>:
  list.27 = (long unsigned int) list;
  *p = list.27;
  list = p;
  n_words_found = n_words_found + 2;
  <D.6130>:
  D.6132 = mark_word & 4;
  if (D.6132 == 0) goto <D.6133>; else goto <D.6134>;
  <D.6133>:
  D.6135 = p + 16;
  list.27 = (long unsigned int) list;
  *D.6135 = list.27;
  list = p + 16;
  n_words_found = n_words_found + 2;
  <D.6134>:
  D.6136 = mark_word & 16;
  if (D.6136 == 0) goto <D.6137>; else goto <D.6138>;
  <D.6137>:
  D.6139 = p + 32;
  list.27 = (long unsigned int) list;
  *D.6139 = list.27;
  list = p + 32;
  n_words_found = n_words_found + 2;
  <D.6138>:
  D.6140 = mark_word & 64;
  if (D.6140 == 0) goto <D.6141>; else goto <D.6142>;
  <D.6141>:
  D.6143 = p + 48;
  list.27 = (long unsigned int) list;
  *D.6143 = list.27;
  list = p + 48;
  n_words_found = n_words_found + 2;
  <D.6142>:
  p = p + 64;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.5682>:
  i.28 = (unsigned int) i;
  if (i.28 <= 63) goto <D.5681>; else goto <D.5683>;
  <D.5683>:
  <D.5685>:
  if (p < plim) goto <D.5684>; else goto <D.5686>;
  <D.5686>:
  D.6145 = *count;
  D.6146 = D.6145 + n_words_found;
  *count = D.6146;
  D.6147 = list;
  return D.6147;
}


GC_reclaim_uninit4 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.29;
  long unsigned int D.6150;
  word * mark_word_addr.30;
  long unsigned int D.6152;
  long unsigned int list.31;
  long unsigned int D.6156;
  word * D.6159;
  long unsigned int D.6160;
  word * D.6163;
  long unsigned int D.6164;
  word * D.6167;
  long unsigned int D.6168;
  word * D.6171;
  long unsigned int D.6172;
  word * D.6175;
  long unsigned int D.6176;
  word * D.6179;
  long unsigned int D.6180;
  word * D.6183;
  long unsigned int D.6184;
  word * D.6187;
  long unsigned int D.6188;
  word * D.6191;
  long unsigned int D.6192;
  word * D.6195;
  long unsigned int D.6196;
  word * D.6199;
  long unsigned int D.6200;
  word * D.6203;
  long unsigned int D.6204;
  word * D.6207;
  long unsigned int D.6208;
  word * D.6211;
  long unsigned int D.6212;
  word * D.6215;
  long int D.6216;
  long int D.6217;
  char * D.6218;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.29 = (long unsigned int) hbp;
  D.6150 = hbp.29 + 4096;
  plim = (word *) D.6150;
  goto <D.5699>;
  <D.5698>:
  mark_word_addr.30 = mark_word_addr;
  mark_word_addr = mark_word_addr.30 + 8;
  mark_word = *mark_word_addr.30;
  D.6152 = mark_word & 1;
  if (D.6152 == 0) goto <D.6153>; else goto <D.6154>;
  <D.6153>:
  list.31 = (long unsigned int) list;
  *p = list.31;
  list = p;
  n_words_found = n_words_found + 4;
  <D.6154>:
  D.6156 = mark_word & 16;
  if (D.6156 == 0) goto <D.6157>; else goto <D.6158>;
  <D.6157>:
  D.6159 = p + 32;
  list.31 = (long unsigned int) list;
  *D.6159 = list.31;
  list = p + 32;
  n_words_found = n_words_found + 4;
  <D.6158>:
  D.6160 = mark_word & 256;
  if (D.6160 == 0) goto <D.6161>; else goto <D.6162>;
  <D.6161>:
  D.6163 = p + 64;
  list.31 = (long unsigned int) list;
  *D.6163 = list.31;
  list = p + 64;
  n_words_found = n_words_found + 4;
  <D.6162>:
  D.6164 = mark_word & 4096;
  if (D.6164 == 0) goto <D.6165>; else goto <D.6166>;
  <D.6165>:
  D.6167 = p + 96;
  list.31 = (long unsigned int) list;
  *D.6167 = list.31;
  list = p + 96;
  n_words_found = n_words_found + 4;
  <D.6166>:
  D.6168 = mark_word & 65536;
  if (D.6168 == 0) goto <D.6169>; else goto <D.6170>;
  <D.6169>:
  D.6171 = p + 128;
  list.31 = (long unsigned int) list;
  *D.6171 = list.31;
  list = p + 128;
  n_words_found = n_words_found + 4;
  <D.6170>:
  D.6172 = mark_word & 1048576;
  if (D.6172 == 0) goto <D.6173>; else goto <D.6174>;
  <D.6173>:
  D.6175 = p + 160;
  list.31 = (long unsigned int) list;
  *D.6175 = list.31;
  list = p + 160;
  n_words_found = n_words_found + 4;
  <D.6174>:
  D.6176 = mark_word & 16777216;
  if (D.6176 == 0) goto <D.6177>; else goto <D.6178>;
  <D.6177>:
  D.6179 = p + 192;
  list.31 = (long unsigned int) list;
  *D.6179 = list.31;
  list = p + 192;
  n_words_found = n_words_found + 4;
  <D.6178>:
  D.6180 = mark_word & 268435456;
  if (D.6180 == 0) goto <D.6181>; else goto <D.6182>;
  <D.6181>:
  D.6183 = p + 224;
  list.31 = (long unsigned int) list;
  *D.6183 = list.31;
  list = p + 224;
  n_words_found = n_words_found + 4;
  <D.6182>:
  D.6184 = mark_word & 4294967296;
  if (D.6184 == 0) goto <D.6185>; else goto <D.6186>;
  <D.6185>:
  D.6187 = p + 256;
  list.31 = (long unsigned int) list;
  *D.6187 = list.31;
  list = p + 256;
  n_words_found = n_words_found + 4;
  <D.6186>:
  D.6188 = mark_word & 68719476736;
  if (D.6188 == 0) goto <D.6189>; else goto <D.6190>;
  <D.6189>:
  D.6191 = p + 288;
  list.31 = (long unsigned int) list;
  *D.6191 = list.31;
  list = p + 288;
  n_words_found = n_words_found + 4;
  <D.6190>:
  D.6192 = mark_word & 1099511627776;
  if (D.6192 == 0) goto <D.6193>; else goto <D.6194>;
  <D.6193>:
  D.6195 = p + 320;
  list.31 = (long unsigned int) list;
  *D.6195 = list.31;
  list = p + 320;
  n_words_found = n_words_found + 4;
  <D.6194>:
  D.6196 = mark_word & 17592186044416;
  if (D.6196 == 0) goto <D.6197>; else goto <D.6198>;
  <D.6197>:
  D.6199 = p + 352;
  list.31 = (long unsigned int) list;
  *D.6199 = list.31;
  list = p + 352;
  n_words_found = n_words_found + 4;
  <D.6198>:
  D.6200 = mark_word & 281474976710656;
  if (D.6200 == 0) goto <D.6201>; else goto <D.6202>;
  <D.6201>:
  D.6203 = p + 384;
  list.31 = (long unsigned int) list;
  *D.6203 = list.31;
  list = p + 384;
  n_words_found = n_words_found + 4;
  <D.6202>:
  D.6204 = mark_word & 4503599627370496;
  if (D.6204 == 0) goto <D.6205>; else goto <D.6206>;
  <D.6205>:
  D.6207 = p + 416;
  list.31 = (long unsigned int) list;
  *D.6207 = list.31;
  list = p + 416;
  n_words_found = n_words_found + 4;
  <D.6206>:
  D.6208 = mark_word & 72057594037927936;
  if (D.6208 == 0) goto <D.6209>; else goto <D.6210>;
  <D.6209>:
  D.6211 = p + 448;
  list.31 = (long unsigned int) list;
  *D.6211 = list.31;
  list = p + 448;
  n_words_found = n_words_found + 4;
  <D.6210>:
  D.6212 = mark_word & 1152921504606846976;
  if (D.6212 == 0) goto <D.6213>; else goto <D.6214>;
  <D.6213>:
  D.6215 = p + 480;
  list.31 = (long unsigned int) list;
  *D.6215 = list.31;
  list = p + 480;
  n_words_found = n_words_found + 4;
  <D.6214>:
  p = p + 512;
  <D.5699>:
  if (p < plim) goto <D.5698>; else goto <D.5700>;
  <D.5700>:
  D.6216 = *count;
  D.6217 = D.6216 + n_words_found;
  *count = D.6217;
  D.6218 = list;
  return D.6218;
}


GC_reclaim1 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.32;
  long unsigned int D.6221;
  word * mark_word_addr.33;
  long unsigned int D.6223;
  long unsigned int list.34;
  long unsigned int D.6227;
  word * D.6230;
  long unsigned int D.6231;
  word * D.6234;
  long unsigned int D.6235;
  word * D.6238;
  unsigned int i.35;
  long int D.6240;
  long int D.6241;
  char * D.6242;
  register word * mark_word_addr;
  register word * p;
  register word * plim;
  register word mark_word;
  register int i;
  signed_word n_words_found;

  mark_word_addr = &hhdr->hb_marks[0];
  n_words_found = 0;
  p = &hbp->hb_body;
  hbp.32 = (long unsigned int) hbp;
  D.6221 = hbp.32 + 4096;
  plim = (word *) D.6221;
  goto <D.5717>;
  <D.5716>:
  mark_word_addr.33 = mark_word_addr;
  mark_word_addr = mark_word_addr.33 + 8;
  mark_word = *mark_word_addr.33;
  i = 0;
  goto <D.5714>;
  <D.5713>:
  D.6223 = mark_word & 1;
  if (D.6223 == 0) goto <D.6224>; else goto <D.6225>;
  <D.6224>:
  list.34 = (long unsigned int) list;
  *p = list.34;
  list = p;
  n_words_found = n_words_found + 1;
  <D.6225>:
  D.6227 = mark_word & 2;
  if (D.6227 == 0) goto <D.6228>; else goto <D.6229>;
  <D.6228>:
  D.6230 = p + 8;
  list.34 = (long unsigned int) list;
  *D.6230 = list.34;
  list = p + 8;
  n_words_found = n_words_found + 1;
  <D.6229>:
  D.6231 = mark_word & 4;
  if (D.6231 == 0) goto <D.6232>; else goto <D.6233>;
  <D.6232>:
  D.6234 = p + 16;
  list.34 = (long unsigned int) list;
  *D.6234 = list.34;
  list = p + 16;
  n_words_found = n_words_found + 1;
  <D.6233>:
  D.6235 = mark_word & 8;
  if (D.6235 == 0) goto <D.6236>; else goto <D.6237>;
  <D.6236>:
  D.6238 = p + 24;
  list.34 = (long unsigned int) list;
  *D.6238 = list.34;
  list = p + 24;
  n_words_found = n_words_found + 1;
  <D.6237>:
  p = p + 32;
  mark_word = mark_word >> 4;
  i = i + 4;
  <D.5714>:
  i.35 = (unsigned int) i;
  if (i.35 <= 63) goto <D.5713>; else goto <D.5715>;
  <D.5715>:
  <D.5717>:
  if (p < plim) goto <D.5716>; else goto <D.5718>;
  <D.5718>:
  D.6240 = *count;
  D.6241 = D.6240 + n_words_found;
  *count = D.6241;
  D.6242 = list;
  return D.6242;
}


GC_reclaim_generic (struct hblk * hbp, struct hdr * hhdr, word sz, GC_bool init, char * list, signed_word * count)
{
  long unsigned int D.6244;
  _Bool D.6245;
  int D.6246;
  unsigned char D.6250;
  int D.6251;
  int D.6252;
  char * D.6255;
  char * result;

  result = list;
  D.6244 = hhdr->hb_descr;
  D.6245 = D.6244 == 0;
  D.6246 = (int) D.6245;
  GC_remove_protection (hbp, 1, D.6246);
  if (init != 0) goto <D.6247>; else goto <D.6248>;
  <D.6247>:
  switch (sz) <default: <D.5732>, case 1: <D.5728>, case 2: <D.5730>, case 4: <D.5731>>
  <D.5728>:
  result = GC_reclaim1 (hbp, hhdr, list, count);
  goto <D.5729>;
  <D.5730>:
  result = GC_reclaim_clear2 (hbp, hhdr, list, count);
  goto <D.5729>;
  <D.5731>:
  result = GC_reclaim_clear4 (hbp, hhdr, list, count);
  goto <D.5729>;
  <D.5732>:
  result = GC_reclaim_clear (hbp, hhdr, sz, list, count);
  goto <D.5729>;
  <D.5729>:
  goto <D.6249>;
  <D.6248>:
  switch (sz) <default: <D.5737>, case 1: <D.5733>, case 2: <D.5735>, case 4: <D.5736>>
  <D.5733>:
  result = GC_reclaim1 (hbp, hhdr, list, count);
  goto <D.5734>;
  <D.5735>:
  result = GC_reclaim_uninit2 (hbp, hhdr, list, count);
  goto <D.5734>;
  <D.5736>:
  result = GC_reclaim_uninit4 (hbp, hhdr, list, count);
  goto <D.5734>;
  <D.5737>:
  result = GC_reclaim_uninit (hbp, hhdr, sz, list, count);
  goto <D.5734>;
  <D.5734>:
  <D.6249>:
  D.6250 = hhdr->hb_obj_kind;
  D.6251 = (int) D.6250;
  D.6252 = D.6251 & -2;
  if (D.6252 == 2) goto <D.6253>; else goto <D.6254>;
  <D.6253>:
  GC_set_hdr_marks (hhdr);
  <D.6254>:
  D.6255 = result;
  return D.6255;
}


GC_reclaim_small_nonempty_block (struct hblk * hbp, int report_if_found, signed_word * count)
{
  unsigned char D.6257;
  char * * D.6258;
  long unsigned int D.6259;
  long unsigned int GC_gc_no.36;
  short unsigned int D.6261;
  char * D.6265;
  int iftmp.37;
  int D.6270;
  int GC_debugging_started.38;
  char * D.6273;
  struct hdr * hhdr;
  word sz;
  int kind;
  struct obj_kind * ok;
  char * * flh;

  hhdr = GC_find_header (hbp);
  sz = hhdr->hb_sz;
  D.6257 = hhdr->hb_obj_kind;
  kind = (int) D.6257;
  ok = &GC_obj_kinds[kind];
  D.6258 = ok->ok_freelist;
  D.6259 = sz * 8;
  flh = D.6258 + D.6259;
  GC_gc_no.36 = GC_gc_no;
  D.6261 = (short unsigned int) GC_gc_no.36;
  hhdr->hb_last_reclaimed = D.6261;
  if (report_if_found != 0) goto <D.6262>; else goto <D.6263>;
  <D.6262>:
  GC_reclaim_check (hbp, hhdr, sz);
  goto <D.6264>;
  <D.6263>:
  D.6265 = *flh;
  D.6270 = ok->ok_init;
  if (D.6270 != 0) goto <D.6267>; else goto <D.6271>;
  <D.6271>:
  GC_debugging_started.38 = GC_debugging_started;
  if (GC_debugging_started.38 != 0) goto <D.6267>; else goto <D.6268>;
  <D.6267>:
  iftmp.37 = 1;
  goto <D.6269>;
  <D.6268>:
  iftmp.37 = 0;
  <D.6269>:
  D.6273 = GC_reclaim_generic (hbp, hhdr, sz, iftmp.37, D.6265, &GC_mem_found);
  *flh = D.6273;
  <D.6264>:
}


GC_reclaim_block (struct hblk * hbp, word report_if_found)
{
  unsigned char D.6274;
  int D.6275;
  long unsigned int D.6278;
  long unsigned int D.6279;
  long unsigned int D.6285;
  long unsigned int D.6286;
  long unsigned int D.6289;
  long unsigned int D.6290;
  long unsigned int D.6291;
  int D.6295;
  int D.6300;
  struct hblk * * D.6303;
  long unsigned int D.6304;
  struct hblk * D.6305;
  register struct hdr * hhdr;
  register word sz;
  register struct obj_kind * ok;
  struct hblk * * rlh;

  hhdr = GC_find_header (hbp);
  sz = hhdr->hb_sz;
  D.6274 = hhdr->hb_obj_kind;
  D.6275 = (int) D.6274;
  ok = &GC_obj_kinds[D.6275];
  if (sz > 256) goto <D.6276>; else goto <D.6277>;
  <D.6276>:
  D.6278 = hhdr->hb_marks[0];
  D.6279 = D.6278 & 1;
  if (D.6279 == 0) goto <D.6280>; else goto <D.6281>;
  <D.6280>:
  if (report_if_found != 0) goto <D.6282>; else goto <D.6283>;
  <D.6282>:
  GC_add_leaked (hbp);
  goto <D.6284>;
  <D.6283>:
  {
    word blocks;

    D.6285 = sz << 3;
    D.6286 = D.6285 + 4095;
    blocks = D.6286 >> 12;
    if (blocks > 1) goto <D.6287>; else goto <D.6288>;
    <D.6287>:
    D.6289 = GC_arrays._large_allocd_bytes;
    D.6290 = blocks * 4096;
    D.6291 = D.6289 - D.6290;
    GC_arrays._large_allocd_bytes = D.6291;
    <D.6288>:
    GC_freehblk (hbp);
  }
  <D.6284>:
  <D.6281>:
  goto <D.6292>;
  <D.6277>:
  {
    GC_bool empty;

    empty = GC_block_empty (hhdr);
    if (report_if_found != 0) goto <D.6293>; else goto <D.6294>;
    <D.6293>:
    D.6295 = (int) report_if_found;
    GC_reclaim_small_nonempty_block (hbp, D.6295, &GC_mem_found);
    goto <D.6296>;
    <D.6294>:
    if (empty != 0) goto <D.6297>; else goto <D.6298>;
    <D.6297>:
    GC_freehblk (hbp);
    goto <D.6299>;
    <D.6298>:
    D.6300 = GC_block_nearly_full (hhdr);
    if (D.6300 != 1) goto <D.6301>; else goto <D.6302>;
    <D.6301>:
    D.6303 = ok->ok_reclaim_list;
    D.6304 = sz * 8;
    rlh = D.6303 + D.6304;
    D.6305 = *rlh;
    hhdr->hb_next = D.6305;
    *rlh = hbp;
    <D.6302>:
    <D.6299>:
    <D.6296>:
  }
  <D.6292>:
}


GC_n_set_marks (struct hdr * hhdr)
{
  long unsigned int D.6306;
  int D.6307;
  int D.6308;
  register int result;
  register int i;

  result = 0;
  i = 0;
  goto <D.5775>;
  <D.5774>:
  D.6306 = hhdr->hb_marks[i];
  D.6307 = set_bits (D.6306);
  result = D.6307 + result;
  i = i + 1;
  <D.5775>:
  if (i <= 7) goto <D.5774>; else goto <D.5776>;
  <D.5776>:
  D.6308 = result;
  return D.6308;
}


set_bits (word n)
{
  long unsigned int D.6310;
  int D.6313;
  register word m;
  register int result;

  m = n;
  result = 0;
  goto <D.5767>;
  <D.5766>:
  D.6310 = m & 1;
  if (D.6310 != 0) goto <D.6311>; else goto <D.6312>;
  <D.6311>:
  result = result + 1;
  <D.6312>:
  m = m >> 1;
  <D.5767>:
  if (m != 0) goto <D.5766>; else goto <D.5768>;
  <D.5768>:
  D.6313 = result;
  return D.6313;
}


GC_print_block_descr (struct hblk * h, word dummy)
{
  long unsigned int D.6315;
  int D.6316;
  long int D.6317;
  long int bytes.39;
  unsigned char D.6319;
  long int D.6320;
  long unsigned int D.6321;
  long unsigned int D.6322;
  long unsigned int D.6323;
  long unsigned int D.6324;
  register struct hdr * hhdr;
  register size_t bytes;
  struct Print_stats * ps;

  hhdr = GC_find_header (h);
  D.6315 = hhdr->hb_sz;
  bytes = D.6315 << 3;
  D.6316 = GC_n_set_marks (hhdr);
  D.6317 = (long int) D.6316;
  bytes.39 = (long int) bytes;
  D.6319 = hhdr->hb_obj_kind;
  D.6320 = (long int) D.6319;
  GC_printf ("(%lu:%lu,%lu)", D.6320, bytes.39, D.6317, 0, 0, 0);
  bytes = bytes + 4095;
  bytes = bytes & 18446744073709547520;
  ps = (struct Print_stats *) dummy;
  D.6321 = ps->total_bytes;
  D.6322 = D.6321 + bytes;
  ps->total_bytes = D.6322;
  D.6323 = ps->number_of_blocks;
  D.6324 = D.6323 + 1;
  ps->number_of_blocks = D.6324;
}


GC_print_block_list ()
{
  long unsigned int pstats.40;
  long unsigned int D.6326;
  long int D.6327;
  long unsigned int D.6328;
  long int D.6329;
  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.40 = (long unsigned int) &pstats;
      GC_apply_to_all_blocks (GC_print_block_descr, pstats.40);
      D.6326 = pstats.total_bytes;
      D.6327 = (long int) D.6326;
      D.6328 = pstats.number_of_blocks;
      D.6329 = (long int) D.6328;
      GC_printf ("\nblocks = %lu, bytes = %lu\n", D.6329, D.6327, 0, 0, 0, 0);
    }
  finally
    {
      pstats = {CLOBBER};
    }
}


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

  next = *flp;
  goto <D.5792>;
  <D.5791>:
  *flp = 0B;
  flp = next;
  next = *flp;
  <D.5792>:
  if (next != 0B) goto <D.5791>; else goto <D.5793>;
  <D.5793>:
}


GC_start_reclaim (int report_if_found)
{
  long unsigned int D.6330;
  _Bool D.6331;
  char * * D.6336;
  char * D.6337;
  int GC_n_kinds.41;
  long unsigned int D.6344;
  int kind;

  kind = 0;
  goto <D.5812>;
  <D.5811>:
  {
    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.6330 = GC_obj_kinds[kind].ok_descriptor;
    D.6331 = D.6330 != 0;
    should_clobber = (GC_bool) D.6331;
    if (rlist == 0B) goto <D.6332>; else goto <D.6333>;
    <D.6332>:
    // predicted unlikely by continue predictor.
    goto <D.5804>;
    <D.6333>:
    if (report_if_found == 0) goto <D.6334>; else goto <D.6335>;
    <D.6334>:
    D.6336 = GC_obj_kinds[kind].ok_freelist;
    lim = D.6336 + 2056;
    fop = GC_obj_kinds[kind].ok_freelist;
    goto <D.5806>;
    <D.5805>:
    D.6337 = *fop;
    if (D.6337 != 0B) goto <D.6338>; else goto <D.6339>;
    <D.6338>:
    if (should_clobber != 0) goto <D.6340>; else goto <D.6341>;
    <D.6340>:
    GC_clear_fl_links (fop);
    goto <D.6342>;
    <D.6341>:
    *fop = 0B;
    <D.6342>:
    <D.6339>:
    fop = fop + 8;
    <D.5806>:
    if (fop < lim) goto <D.5805>; else goto <D.5807>;
    <D.5807>:
    <D.6335>:
    rlim = rlist + 2056;
    rlp = rlist;
    goto <D.5809>;
    <D.5808>:
    *rlp = 0B;
    rlp = rlp + 8;
    <D.5809>:
    if (rlp < rlim) goto <D.5808>; else goto <D.5810>;
    <D.5810>:
  }
  <D.5804>:
  kind = kind + 1;
  <D.5812>:
  GC_n_kinds.41 = GC_n_kinds;
  if (kind < GC_n_kinds.41) goto <D.5811>; else goto <D.5813>;
  <D.5813>:
  D.6344 = (long unsigned int) report_if_found;
  GC_apply_to_all_blocks (GC_reclaim_block, D.6344);
}


GC_continue_reclaim (word sz, int kind)
{
  char * * D.6345;
  long unsigned int D.6346;
  struct hblk * D.6349;
  char * D.6350;
  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.6345 = ok->ok_freelist;
  D.6346 = sz * 8;
  flh = D.6345 + D.6346;
  if (rlh == 0B) goto <D.6347>; else goto <D.6348>;
  <D.6347>:
  return;
  <D.6348>:
  D.6346 = sz * 8;
  rlh = rlh + D.6346;
  goto <D.5825>;
  <D.5824>:
  hhdr = GC_find_header (hbp);
  D.6349 = hhdr->hb_next;
  *rlh = D.6349;
  GC_reclaim_small_nonempty_block (hbp, 0, &GC_mem_found);
  D.6350 = *flh;
  if (D.6350 != 0B) goto <D.5823>; else goto <D.6351>;
  <D.6351>:
  <D.5825>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.5824>; else goto <D.5823>;
  <D.5823>:
}


GC_reclaim_all (int (*GC_stop_func) (void) stop_func, GC_bool ignore_old)
{
  long unsigned int D.6355;
  int D.6358;
  GC_bool D.6361;
  struct hblk * D.6362;
  short unsigned int D.6366;
  long unsigned int D.6367;
  long unsigned int GC_gc_no.42;
  long unsigned int D.6369;
  int GC_n_kinds.43;
  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.5845>;
  <D.5844>:
  ok = &GC_obj_kinds[kind];
  rlp = ok->ok_reclaim_list;
  if (rlp == 0B) goto <D.6353>; else goto <D.6354>;
  <D.6353>:
  // predicted unlikely by continue predictor.
  goto <D.5837>;
  <D.6354>:
  sz = 1;
  goto <D.5842>;
  <D.5841>:
  D.6355 = sz * 8;
  rlh = rlp + D.6355;
  goto <D.5839>;
  <D.5838>:
  if (stop_func != 0B) goto <D.6356>; else goto <D.6357>;
  <D.6356>:
  D.6358 = stop_func ();
  if (D.6358 != 0) goto <D.6359>; else goto <D.6360>;
  <D.6359>:
  D.6361 = 0;
  return D.6361;
  <D.6360>:
  <D.6357>:
  hhdr = GC_find_header (hbp);
  D.6362 = hhdr->hb_next;
  *rlh = D.6362;
  if (ignore_old == 0) goto <D.6363>; else goto <D.6365>;
  <D.6365>:
  D.6366 = hhdr->hb_last_reclaimed;
  D.6367 = (long unsigned int) D.6366;
  GC_gc_no.42 = GC_gc_no;
  D.6369 = GC_gc_no.42 + 18446744073709551615;
  if (D.6367 == D.6369) goto <D.6363>; else goto <D.6364>;
  <D.6363>:
  GC_reclaim_small_nonempty_block (hbp, 0, &GC_mem_found);
  <D.6364>:
  <D.5839>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.5838>; else goto <D.5840>;
  <D.5840>:
  sz = sz + 1;
  <D.5842>:
  if (sz <= 256) goto <D.5841>; else goto <D.5843>;
  <D.5843>:
  <D.5837>:
  kind = kind + 1;
  <D.5845>:
  GC_n_kinds.43 = GC_n_kinds;
  if (kind < GC_n_kinds.43) goto <D.5844>; else goto <D.5846>;
  <D.5846>:
  D.6361 = 1;
  return D.6361;
}