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

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


GC_print_all_errors ()
{
  int D.5935;
  int printing_errors.2;
  int GC_debugging_started.3;
  void (*<T771>) (void) GC_print_all_smashed.4;
  struct hdr * D.5945;
  unsigned char D.5946;
  void (*<T1119>) (char *) GC_print_heap_obj.5;
  unsigned int GC_n_leaked.6;
  unsigned int i;

  D.5935 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5935 != 0) goto <D.5936>; else goto <D.5937>;
  <D.5936>:
  GC_lock ();
  <D.5937>:
  printing_errors.2 = printing_errors;
  if (printing_errors.2 != 0) goto <D.5939>; else goto <D.5940>;
  <D.5939>:
  pthread_mutex_unlock (&GC_allocate_ml);
  return;
  <D.5940>:
  printing_errors = 1;
  pthread_mutex_unlock (&GC_allocate_ml);
  GC_debugging_started.3 = GC_debugging_started;
  if (GC_debugging_started.3 != 0) goto <D.5942>; else goto <D.5943>;
  <D.5942>:
  GC_print_all_smashed.4 = GC_print_all_smashed;
  GC_print_all_smashed.4 ();
  <D.5943>:
  i = 0;
  goto <D.5633>;
  <D.5632>:
  {
    char * p;

    p = GC_leaked[i];
    D.5945 = GC_find_header (p);
    D.5946 = D.5945->hb_obj_kind;
    if (D.5946 == 0) goto <D.5947>; else goto <D.5948>;
    <D.5947>:
    GC_err_puts ("Leaked atomic object at ");
    goto <D.5949>;
    <D.5948>:
    GC_err_puts ("Leaked composite object at ");
    <D.5949>:
    GC_print_heap_obj.5 = GC_print_heap_obj;
    GC_print_heap_obj.5 (p);
    GC_err_puts ("\n");
    GC_free (p);
    GC_leaked[i] = 0B;
  }
  i = i + 1;
  <D.5633>:
  GC_n_leaked.6 = GC_n_leaked;
  if (i < GC_n_leaked.6) goto <D.5632>; else goto <D.5634>;
  <D.5634>:
  GC_n_leaked = 0;
  printing_errors = 0;
}


GC_block_empty (struct hdr * hhdr)
{
  word * p.7;
  long unsigned int D.5954;
  GC_bool D.5957;
  register word * p;
  register word * plim;

  p = &hhdr->hb_marks[0];
  plim = &hhdr->hb_marks[8];
  goto <D.5641>;
  <D.5640>:
  p.7 = p;
  p = p.7 + 8;
  D.5954 = *p.7;
  if (D.5954 != 0) goto <D.5955>; else goto <D.5956>;
  <D.5955>:
  D.5957 = 0;
  return D.5957;
  <D.5956>:
  <D.5641>:
  if (p < plim) goto <D.5640>; else goto <D.5642>;
  <D.5642>:
  D.5957 = 1;
  return D.5957;
}


GC_block_nearly_full1 (struct hdr * hhdr, word pat1)
{
  long unsigned int D.5959;
  long unsigned int D.5960;
  long unsigned int D.5961;
  GC_bool D.5966;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  i = 0;
  goto <D.5650>;
  <D.5649>:
  D.5959 = hhdr->hb_marks[i];
  D.5960 = ~pat1;
  D.5961 = D.5959 | D.5960;
  if (D.5961 != 18446744073709551615) goto <D.5962>; else goto <D.5963>;
  <D.5962>:
  misses = misses + 1;
  if (misses != 0) goto <D.5964>; else goto <D.5965>;
  <D.5964>:
  D.5966 = 0;
  return D.5966;
  <D.5965>:
  <D.5963>:
  i = i + 1;
  <D.5650>:
  if (i <= 7) goto <D.5649>; else goto <D.5651>;
  <D.5651>:
  D.5966 = 1;
  return D.5966;
}


GC_block_nearly_full3 (struct hdr * hhdr, word pat1, word pat2, word pat3)
{
  GC_bool D.5970;
  long unsigned int D.5971;
  long unsigned int D.5972;
  long unsigned int D.5973;
  unsigned int D.5978;
  long unsigned int D.5979;
  long unsigned int D.5980;
  long unsigned int D.5981;
  unsigned int D.5986;
  long unsigned int D.5987;
  long unsigned int D.5988;
  long unsigned int D.5989;
  unsigned int i;
  unsigned int misses;

  misses = 0;
  if (0 != 0) goto <D.5968>; else goto <D.5969>;
  <D.5968>:
  D.5970 = 2;
  return D.5970;
  <D.5969>:
  i = 0;
  goto <D.5661>;
  <D.5660>:
  D.5971 = hhdr->hb_marks[i];
  D.5972 = ~pat1;
  D.5973 = D.5971 | D.5972;
  if (D.5973 != 18446744073709551615) goto <D.5974>; else goto <D.5975>;
  <D.5974>:
  misses = misses + 1;
  if (misses != 0) goto <D.5976>; else goto <D.5977>;
  <D.5976>:
  D.5970 = 0;
  return D.5970;
  <D.5977>:
  <D.5975>:
  D.5978 = i + 1;
  D.5979 = hhdr->hb_marks[D.5978];
  D.5980 = ~pat2;
  D.5981 = D.5979 | D.5980;
  if (D.5981 != 18446744073709551615) goto <D.5982>; else goto <D.5983>;
  <D.5982>:
  misses = misses + 1;
  if (misses != 0) goto <D.5984>; else goto <D.5985>;
  <D.5984>:
  D.5970 = 0;
  return D.5970;
  <D.5985>:
  <D.5983>:
  D.5986 = i + 2;
  D.5987 = hhdr->hb_marks[D.5986];
  D.5988 = ~pat3;
  D.5989 = D.5987 | D.5988;
  if (D.5989 != 18446744073709551615) goto <D.5990>; else goto <D.5991>;
  <D.5990>:
  misses = misses + 1;
  if (misses != 0) goto <D.5992>; else goto <D.5993>;
  <D.5992>:
  D.5970 = 0;
  return D.5970;
  <D.5993>:
  <D.5991>:
  i = i + 3;
  <D.5661>:
  if (i <= 5) goto <D.5660>; else goto <D.5662>;
  <D.5662>:
  D.5970 = 1;
  return D.5970;
}


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

  D.5995 = hhdr->hb_sz;
  sz = (int) D.5995;
  switch (sz) <default: <D.5675>, case 1: <D.5667>, case 2: <D.5668>, case 4: <D.5669>, case 6: <D.5670>, case 8: <D.5671>, case 12: <D.5672>, case 16: <D.5673>, case 32: <D.5674>>
  <D.5667>:
  D.5996 = GC_block_nearly_full1 (hhdr, 18446744073709551615);
  return D.5996;
  <D.5668>:
  D.5996 = GC_block_nearly_full1 (hhdr, 6148914691236517205);
  return D.5996;
  <D.5669>:
  D.5996 = GC_block_nearly_full1 (hhdr, 1229782938247303441);
  return D.5996;
  <D.5670>:
  D.5996 = GC_block_nearly_full3 (hhdr, 1171221845949812801, 4684887383799251204, 292805461487453200);
  return D.5996;
  <D.5671>:
  D.5996 = GC_block_nearly_full1 (hhdr, 72340172838076673);
  return D.5996;
  <D.5672>:
  D.5996 = GC_block_nearly_full3 (hhdr, 1153203048319815681, 72075190519988480, 4504699407499280);
  return D.5996;
  <D.5673>:
  D.5996 = GC_block_nearly_full1 (hhdr, 281479271743489);
  return D.5996;
  <D.5674>:
  D.5996 = GC_block_nearly_full1 (hhdr, 4294967297);
  return D.5996;
  <D.5675>:
  D.5996 = 2;
  return D.5996;
}


GC_reclaim_clear (struct hblk * hbp, struct hdr * hhdr, word sz, char * list, signed_word * count)
{
  long unsigned int hbp.8;
  long unsigned int D.5999;
  long unsigned int D.6000;
  long unsigned int D.6001;
  int D.6002;
  long unsigned int D.6003;
  int D.6004;
  long unsigned int D.6005;
  long unsigned int D.6006;
  long unsigned int D.6009;
  long unsigned int n_words_found.9;
  long unsigned int D.6012;
  word * p.10;
  unsigned int D.6014;
  unsigned int word_no.11;
  unsigned int D.6016;
  long int D.6017;
  long int D.6018;
  char * D.6019;
  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.8 = (long unsigned int) hbp;
  D.5999 = sz << 3;
  D.6000 = hbp.8 - D.5999;
  D.6001 = D.6000 + 4096;
  plim = (word *) D.6001;
  goto <D.5692>;
  <D.5691>:
  D.6002 = word_no >> 6;
  D.6003 = hhdr->hb_marks[D.6002];
  D.6004 = word_no & 63;
  D.6005 = D.6003 >> D.6004;
  D.6006 = D.6005 & 1;
  if (D.6006 != 0) goto <D.6007>; else goto <D.6008>;
  <D.6007>:
  D.6009 = sz * 8;
  p = p + D.6009;
  goto <D.6010>;
  <D.6008>:
  n_words_found.9 = (long unsigned int) n_words_found;
  D.6012 = n_words_found.9 + sz;
  n_words_found = (signed_word) D.6012;
  MEM[(char * *)p] = list;
  list = p;
  D.6009 = sz * 8;
  q = p + D.6009;
  p = p + 8;
  goto <D.5689>;
  <D.5688>:
  p.10 = p;
  p = p.10 + 8;
  *p.10 = 0;
  <D.5689>:
  if (p < q) goto <D.5688>; else goto <D.5690>;
  <D.5690>:
  <D.6010>:
  D.6014 = (unsigned int) sz;
  word_no.11 = (unsigned int) word_no;
  D.6016 = D.6014 + word_no.11;
  word_no = (int) D.6016;
  <D.5692>:
  if (p <= plim) goto <D.5691>; else goto <D.5693>;
  <D.5693>:
  D.6017 = *count;
  D.6018 = D.6017 + n_words_found;
  *count = D.6018;
  D.6019 = list;
  return D.6019;
}


GC_reclaim_clear2 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.12;
  long unsigned int D.6022;
  word * mark_word_addr.13;
  long unsigned int D.6024;
  long unsigned int list.14;
  word * D.6028;
  long unsigned int D.6029;
  word * D.6032;
  word * D.6033;
  long unsigned int D.6034;
  word * D.6037;
  word * D.6038;
  long unsigned int D.6039;
  word * D.6042;
  word * D.6043;
  unsigned int i.15;
  long int D.6045;
  long int D.6046;
  char * D.6047;
  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.12 = (long unsigned int) hbp;
  D.6022 = hbp.12 + 4096;
  plim = (word *) D.6022;
  goto <D.5710>;
  <D.5709>:
  mark_word_addr.13 = mark_word_addr;
  mark_word_addr = mark_word_addr.13 + 8;
  mark_word = *mark_word_addr.13;
  i = 0;
  goto <D.5707>;
  <D.5706>:
  D.6024 = mark_word & 1;
  if (D.6024 == 0) goto <D.6025>; else goto <D.6026>;
  <D.6025>:
  list.14 = (long unsigned int) list;
  *p = list.14;
  list = p;
  D.6028 = p + 8;
  *D.6028 = 0;
  n_words_found = n_words_found + 2;
  <D.6026>:
  D.6029 = mark_word & 4;
  if (D.6029 == 0) goto <D.6030>; else goto <D.6031>;
  <D.6030>:
  D.6032 = p + 16;
  list.14 = (long unsigned int) list;
  *D.6032 = list.14;
  list = p + 16;
  D.6033 = p + 24;
  *D.6033 = 0;
  n_words_found = n_words_found + 2;
  <D.6031>:
  D.6034 = mark_word & 16;
  if (D.6034 == 0) goto <D.6035>; else goto <D.6036>;
  <D.6035>:
  D.6037 = p + 32;
  list.14 = (long unsigned int) list;
  *D.6037 = list.14;
  list = p + 32;
  D.6038 = p + 40;
  *D.6038 = 0;
  n_words_found = n_words_found + 2;
  <D.6036>:
  D.6039 = mark_word & 64;
  if (D.6039 == 0) goto <D.6040>; else goto <D.6041>;
  <D.6040>:
  D.6042 = p + 48;
  list.14 = (long unsigned int) list;
  *D.6042 = list.14;
  list = p + 48;
  D.6043 = p + 56;
  *D.6043 = 0;
  n_words_found = n_words_found + 2;
  <D.6041>:
  p = p + 64;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.5707>:
  i.15 = (unsigned int) i;
  if (i.15 <= 63) goto <D.5706>; else goto <D.5708>;
  <D.5708>:
  <D.5710>:
  if (p < plim) goto <D.5709>; else goto <D.5711>;
  <D.5711>:
  D.6045 = *count;
  D.6046 = D.6045 + n_words_found;
  *count = D.6046;
  D.6047 = list;
  return D.6047;
}


GC_reclaim_clear4 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.16;
  long unsigned int D.6050;
  word * mark_word_addr.17;
  long unsigned int D.6052;
  long unsigned int list.18;
  word * D.6056;
  word * D.6057;
  word * D.6058;
  long unsigned int D.6059;
  word * D.6062;
  word * D.6063;
  word * D.6064;
  word * D.6065;
  long unsigned int D.6066;
  word * D.6069;
  word * D.6070;
  word * D.6071;
  word * D.6072;
  long unsigned int D.6073;
  word * D.6076;
  word * D.6077;
  word * D.6078;
  word * D.6079;
  long unsigned int D.6080;
  word * D.6083;
  word * D.6084;
  word * D.6085;
  word * D.6086;
  long unsigned int D.6087;
  word * D.6090;
  word * D.6091;
  word * D.6092;
  word * D.6093;
  long unsigned int D.6094;
  word * D.6097;
  word * D.6098;
  word * D.6099;
  word * D.6100;
  long unsigned int D.6101;
  word * D.6104;
  word * D.6105;
  word * D.6106;
  word * D.6107;
  long unsigned int D.6108;
  word * D.6111;
  word * D.6112;
  word * D.6113;
  word * D.6114;
  long unsigned int D.6115;
  word * D.6118;
  word * D.6119;
  word * D.6120;
  word * D.6121;
  long unsigned int D.6122;
  word * D.6125;
  word * D.6126;
  word * D.6127;
  word * D.6128;
  long unsigned int D.6129;
  word * D.6132;
  word * D.6133;
  word * D.6134;
  word * D.6135;
  long unsigned int D.6136;
  word * D.6139;
  word * D.6140;
  word * D.6141;
  word * D.6142;
  long unsigned int D.6143;
  word * D.6146;
  word * D.6147;
  word * D.6148;
  word * D.6149;
  long unsigned int D.6150;
  word * D.6153;
  word * D.6154;
  word * D.6155;
  word * D.6156;
  long unsigned int D.6157;
  word * D.6160;
  word * D.6161;
  word * D.6162;
  word * D.6163;
  long int D.6164;
  long int D.6165;
  char * D.6166;
  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.16 = (long unsigned int) hbp;
  D.6050 = hbp.16 + 4096;
  plim = (word *) D.6050;
  goto <D.5724>;
  <D.5723>:
  mark_word_addr.17 = mark_word_addr;
  mark_word_addr = mark_word_addr.17 + 8;
  mark_word = *mark_word_addr.17;
  D.6052 = mark_word & 1;
  if (D.6052 == 0) goto <D.6053>; else goto <D.6054>;
  <D.6053>:
  list.18 = (long unsigned int) list;
  *p = list.18;
  list = p;
  D.6056 = p + 8;
  *D.6056 = 0;
  D.6057 = p + 16;
  *D.6057 = 0;
  D.6058 = p + 24;
  *D.6058 = 0;
  n_words_found = n_words_found + 4;
  <D.6054>:
  D.6059 = mark_word & 16;
  if (D.6059 == 0) goto <D.6060>; else goto <D.6061>;
  <D.6060>:
  D.6062 = p + 32;
  list.18 = (long unsigned int) list;
  *D.6062 = list.18;
  list = p + 32;
  D.6063 = p + 40;
  *D.6063 = 0;
  D.6064 = p + 48;
  *D.6064 = 0;
  D.6065 = p + 56;
  *D.6065 = 0;
  n_words_found = n_words_found + 4;
  <D.6061>:
  D.6066 = mark_word & 256;
  if (D.6066 == 0) goto <D.6067>; else goto <D.6068>;
  <D.6067>:
  D.6069 = p + 64;
  list.18 = (long unsigned int) list;
  *D.6069 = list.18;
  list = p + 64;
  D.6070 = p + 72;
  *D.6070 = 0;
  D.6071 = p + 80;
  *D.6071 = 0;
  D.6072 = p + 88;
  *D.6072 = 0;
  n_words_found = n_words_found + 4;
  <D.6068>:
  D.6073 = mark_word & 4096;
  if (D.6073 == 0) goto <D.6074>; else goto <D.6075>;
  <D.6074>:
  D.6076 = p + 96;
  list.18 = (long unsigned int) list;
  *D.6076 = list.18;
  list = p + 96;
  D.6077 = p + 104;
  *D.6077 = 0;
  D.6078 = p + 112;
  *D.6078 = 0;
  D.6079 = p + 120;
  *D.6079 = 0;
  n_words_found = n_words_found + 4;
  <D.6075>:
  D.6080 = mark_word & 65536;
  if (D.6080 == 0) goto <D.6081>; else goto <D.6082>;
  <D.6081>:
  D.6083 = p + 128;
  list.18 = (long unsigned int) list;
  *D.6083 = list.18;
  list = p + 128;
  D.6084 = p + 136;
  *D.6084 = 0;
  D.6085 = p + 144;
  *D.6085 = 0;
  D.6086 = p + 152;
  *D.6086 = 0;
  n_words_found = n_words_found + 4;
  <D.6082>:
  D.6087 = mark_word & 1048576;
  if (D.6087 == 0) goto <D.6088>; else goto <D.6089>;
  <D.6088>:
  D.6090 = p + 160;
  list.18 = (long unsigned int) list;
  *D.6090 = list.18;
  list = p + 160;
  D.6091 = p + 168;
  *D.6091 = 0;
  D.6092 = p + 176;
  *D.6092 = 0;
  D.6093 = p + 184;
  *D.6093 = 0;
  n_words_found = n_words_found + 4;
  <D.6089>:
  D.6094 = mark_word & 16777216;
  if (D.6094 == 0) goto <D.6095>; else goto <D.6096>;
  <D.6095>:
  D.6097 = p + 192;
  list.18 = (long unsigned int) list;
  *D.6097 = list.18;
  list = p + 192;
  D.6098 = p + 200;
  *D.6098 = 0;
  D.6099 = p + 208;
  *D.6099 = 0;
  D.6100 = p + 216;
  *D.6100 = 0;
  n_words_found = n_words_found + 4;
  <D.6096>:
  D.6101 = mark_word & 268435456;
  if (D.6101 == 0) goto <D.6102>; else goto <D.6103>;
  <D.6102>:
  D.6104 = p + 224;
  list.18 = (long unsigned int) list;
  *D.6104 = list.18;
  list = p + 224;
  D.6105 = p + 232;
  *D.6105 = 0;
  D.6106 = p + 240;
  *D.6106 = 0;
  D.6107 = p + 248;
  *D.6107 = 0;
  n_words_found = n_words_found + 4;
  <D.6103>:
  D.6108 = mark_word & 4294967296;
  if (D.6108 == 0) goto <D.6109>; else goto <D.6110>;
  <D.6109>:
  D.6111 = p + 256;
  list.18 = (long unsigned int) list;
  *D.6111 = list.18;
  list = p + 256;
  D.6112 = p + 264;
  *D.6112 = 0;
  D.6113 = p + 272;
  *D.6113 = 0;
  D.6114 = p + 280;
  *D.6114 = 0;
  n_words_found = n_words_found + 4;
  <D.6110>:
  D.6115 = mark_word & 68719476736;
  if (D.6115 == 0) goto <D.6116>; else goto <D.6117>;
  <D.6116>:
  D.6118 = p + 288;
  list.18 = (long unsigned int) list;
  *D.6118 = list.18;
  list = p + 288;
  D.6119 = p + 296;
  *D.6119 = 0;
  D.6120 = p + 304;
  *D.6120 = 0;
  D.6121 = p + 312;
  *D.6121 = 0;
  n_words_found = n_words_found + 4;
  <D.6117>:
  D.6122 = mark_word & 1099511627776;
  if (D.6122 == 0) goto <D.6123>; else goto <D.6124>;
  <D.6123>:
  D.6125 = p + 320;
  list.18 = (long unsigned int) list;
  *D.6125 = list.18;
  list = p + 320;
  D.6126 = p + 328;
  *D.6126 = 0;
  D.6127 = p + 336;
  *D.6127 = 0;
  D.6128 = p + 344;
  *D.6128 = 0;
  n_words_found = n_words_found + 4;
  <D.6124>:
  D.6129 = mark_word & 17592186044416;
  if (D.6129 == 0) goto <D.6130>; else goto <D.6131>;
  <D.6130>:
  D.6132 = p + 352;
  list.18 = (long unsigned int) list;
  *D.6132 = list.18;
  list = p + 352;
  D.6133 = p + 360;
  *D.6133 = 0;
  D.6134 = p + 368;
  *D.6134 = 0;
  D.6135 = p + 376;
  *D.6135 = 0;
  n_words_found = n_words_found + 4;
  <D.6131>:
  D.6136 = mark_word & 281474976710656;
  if (D.6136 == 0) goto <D.6137>; else goto <D.6138>;
  <D.6137>:
  D.6139 = p + 384;
  list.18 = (long unsigned int) list;
  *D.6139 = list.18;
  list = p + 384;
  D.6140 = p + 392;
  *D.6140 = 0;
  D.6141 = p + 400;
  *D.6141 = 0;
  D.6142 = p + 408;
  *D.6142 = 0;
  n_words_found = n_words_found + 4;
  <D.6138>:
  D.6143 = mark_word & 4503599627370496;
  if (D.6143 == 0) goto <D.6144>; else goto <D.6145>;
  <D.6144>:
  D.6146 = p + 416;
  list.18 = (long unsigned int) list;
  *D.6146 = list.18;
  list = p + 416;
  D.6147 = p + 424;
  *D.6147 = 0;
  D.6148 = p + 432;
  *D.6148 = 0;
  D.6149 = p + 440;
  *D.6149 = 0;
  n_words_found = n_words_found + 4;
  <D.6145>:
  D.6150 = mark_word & 72057594037927936;
  if (D.6150 == 0) goto <D.6151>; else goto <D.6152>;
  <D.6151>:
  D.6153 = p + 448;
  list.18 = (long unsigned int) list;
  *D.6153 = list.18;
  list = p + 448;
  D.6154 = p + 456;
  *D.6154 = 0;
  D.6155 = p + 464;
  *D.6155 = 0;
  D.6156 = p + 472;
  *D.6156 = 0;
  n_words_found = n_words_found + 4;
  <D.6152>:
  D.6157 = mark_word & 1152921504606846976;
  if (D.6157 == 0) goto <D.6158>; else goto <D.6159>;
  <D.6158>:
  D.6160 = p + 480;
  list.18 = (long unsigned int) list;
  *D.6160 = list.18;
  list = p + 480;
  D.6161 = p + 488;
  *D.6161 = 0;
  D.6162 = p + 496;
  *D.6162 = 0;
  D.6163 = p + 504;
  *D.6163 = 0;
  n_words_found = n_words_found + 4;
  <D.6159>:
  p = p + 512;
  <D.5724>:
  if (p < plim) goto <D.5723>; else goto <D.5725>;
  <D.5725>:
  D.6164 = *count;
  D.6165 = D.6164 + n_words_found;
  *count = D.6165;
  D.6166 = list;
  return D.6166;
}


GC_reclaim_uninit (struct hblk * hbp, struct hdr * hhdr, word sz, char * list, signed_word * count)
{
  long unsigned int hbp.19;
  long unsigned int D.6169;
  long unsigned int D.6170;
  long unsigned int D.6171;
  int D.6172;
  long unsigned int D.6173;
  int D.6174;
  long unsigned int D.6175;
  long unsigned int D.6176;
  long unsigned int n_words_found.20;
  long unsigned int D.6180;
  long unsigned int D.6181;
  unsigned int D.6182;
  unsigned int word_no.21;
  unsigned int D.6184;
  long int D.6185;
  long int D.6186;
  char * D.6187;
  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.19 = (long unsigned int) hbp;
  D.6169 = sz << 3;
  D.6170 = hbp.19 - D.6169;
  D.6171 = D.6170 + 4096;
  plim = (word *) D.6171;
  goto <D.5738>;
  <D.5737>:
  D.6172 = word_no >> 6;
  D.6173 = hhdr->hb_marks[D.6172];
  D.6174 = word_no & 63;
  D.6175 = D.6173 >> D.6174;
  D.6176 = D.6175 & 1;
  if (D.6176 == 0) goto <D.6177>; else goto <D.6178>;
  <D.6177>:
  n_words_found.20 = (long unsigned int) n_words_found;
  D.6180 = n_words_found.20 + sz;
  n_words_found = (signed_word) D.6180;
  MEM[(char * *)p] = list;
  list = p;
  <D.6178>:
  D.6181 = sz * 8;
  p = p + D.6181;
  D.6182 = (unsigned int) sz;
  word_no.21 = (unsigned int) word_no;
  D.6184 = D.6182 + word_no.21;
  word_no = (int) D.6184;
  <D.5738>:
  if (p <= plim) goto <D.5737>; else goto <D.5739>;
  <D.5739>:
  D.6185 = *count;
  D.6186 = D.6185 + n_words_found;
  *count = D.6186;
  D.6187 = list;
  return D.6187;
}


GC_reclaim_check (struct hblk * hbp, struct hdr * hhdr, word sz)
{
  long unsigned int hbp.22;
  long unsigned int D.6190;
  long unsigned int D.6191;
  long unsigned int D.6192;
  int D.6193;
  long unsigned int D.6194;
  int D.6195;
  long unsigned int D.6196;
  long unsigned int D.6197;
  int D.6200;
  sizetype D.6201;
  char * D.6202;
  long unsigned int D.6203;
  unsigned int D.6204;
  unsigned int word_no.23;
  unsigned int D.6206;
  register int word_no;
  register word * p;
  register word * plim;

  word_no = 0;
  p = &hbp->hb_body;
  hbp.22 = (long unsigned int) hbp;
  D.6190 = sz << 3;
  D.6191 = hbp.22 - D.6190;
  D.6192 = D.6191 + 4096;
  plim = (word *) D.6192;
  goto <D.5749>;
  <D.5748>:
  D.6193 = word_no >> 6;
  D.6194 = hhdr->hb_marks[D.6193];
  D.6195 = word_no & 63;
  D.6196 = D.6194 >> D.6195;
  D.6197 = D.6196 & 1;
  if (D.6197 == 0) goto <D.6198>; else goto <D.6199>;
  <D.6198>:
  D.6200 = word_no << 3;
  D.6201 = (sizetype) D.6200;
  D.6202 = hbp + D.6201;
  GC_add_leaked (D.6202);
  <D.6199>:
  D.6203 = sz * 8;
  p = p + D.6203;
  D.6204 = (unsigned int) sz;
  word_no.23 = (unsigned int) word_no;
  D.6206 = D.6204 + word_no.23;
  word_no = (int) D.6206;
  <D.5749>:
  if (p <= plim) goto <D.5748>; else goto <D.5750>;
  <D.5750>:
}


GC_reclaim_uninit2 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.24;
  long unsigned int D.6208;
  word * mark_word_addr.25;
  long unsigned int D.6210;
  long unsigned int list.26;
  long unsigned int D.6214;
  word * D.6217;
  long unsigned int D.6218;
  word * D.6221;
  long unsigned int D.6222;
  word * D.6225;
  unsigned int i.27;
  long int D.6227;
  long int D.6228;
  char * D.6229;
  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.24 = (long unsigned int) hbp;
  D.6208 = hbp.24 + 4096;
  plim = (word *) D.6208;
  goto <D.5767>;
  <D.5766>:
  mark_word_addr.25 = mark_word_addr;
  mark_word_addr = mark_word_addr.25 + 8;
  mark_word = *mark_word_addr.25;
  i = 0;
  goto <D.5764>;
  <D.5763>:
  D.6210 = mark_word & 1;
  if (D.6210 == 0) goto <D.6211>; else goto <D.6212>;
  <D.6211>:
  list.26 = (long unsigned int) list;
  *p = list.26;
  list = p;
  n_words_found = n_words_found + 2;
  <D.6212>:
  D.6214 = mark_word & 4;
  if (D.6214 == 0) goto <D.6215>; else goto <D.6216>;
  <D.6215>:
  D.6217 = p + 16;
  list.26 = (long unsigned int) list;
  *D.6217 = list.26;
  list = p + 16;
  n_words_found = n_words_found + 2;
  <D.6216>:
  D.6218 = mark_word & 16;
  if (D.6218 == 0) goto <D.6219>; else goto <D.6220>;
  <D.6219>:
  D.6221 = p + 32;
  list.26 = (long unsigned int) list;
  *D.6221 = list.26;
  list = p + 32;
  n_words_found = n_words_found + 2;
  <D.6220>:
  D.6222 = mark_word & 64;
  if (D.6222 == 0) goto <D.6223>; else goto <D.6224>;
  <D.6223>:
  D.6225 = p + 48;
  list.26 = (long unsigned int) list;
  *D.6225 = list.26;
  list = p + 48;
  n_words_found = n_words_found + 2;
  <D.6224>:
  p = p + 64;
  mark_word = mark_word >> 8;
  i = i + 8;
  <D.5764>:
  i.27 = (unsigned int) i;
  if (i.27 <= 63) goto <D.5763>; else goto <D.5765>;
  <D.5765>:
  <D.5767>:
  if (p < plim) goto <D.5766>; else goto <D.5768>;
  <D.5768>:
  D.6227 = *count;
  D.6228 = D.6227 + n_words_found;
  *count = D.6228;
  D.6229 = list;
  return D.6229;
}


GC_reclaim_uninit4 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.28;
  long unsigned int D.6232;
  word * mark_word_addr.29;
  long unsigned int D.6234;
  long unsigned int list.30;
  long unsigned int D.6238;
  word * D.6241;
  long unsigned int D.6242;
  word * D.6245;
  long unsigned int D.6246;
  word * D.6249;
  long unsigned int D.6250;
  word * D.6253;
  long unsigned int D.6254;
  word * D.6257;
  long unsigned int D.6258;
  word * D.6261;
  long unsigned int D.6262;
  word * D.6265;
  long unsigned int D.6266;
  word * D.6269;
  long unsigned int D.6270;
  word * D.6273;
  long unsigned int D.6274;
  word * D.6277;
  long unsigned int D.6278;
  word * D.6281;
  long unsigned int D.6282;
  word * D.6285;
  long unsigned int D.6286;
  word * D.6289;
  long unsigned int D.6290;
  word * D.6293;
  long unsigned int D.6294;
  word * D.6297;
  long int D.6298;
  long int D.6299;
  char * D.6300;
  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.28 = (long unsigned int) hbp;
  D.6232 = hbp.28 + 4096;
  plim = (word *) D.6232;
  goto <D.5781>;
  <D.5780>:
  mark_word_addr.29 = mark_word_addr;
  mark_word_addr = mark_word_addr.29 + 8;
  mark_word = *mark_word_addr.29;
  D.6234 = mark_word & 1;
  if (D.6234 == 0) goto <D.6235>; else goto <D.6236>;
  <D.6235>:
  list.30 = (long unsigned int) list;
  *p = list.30;
  list = p;
  n_words_found = n_words_found + 4;
  <D.6236>:
  D.6238 = mark_word & 16;
  if (D.6238 == 0) goto <D.6239>; else goto <D.6240>;
  <D.6239>:
  D.6241 = p + 32;
  list.30 = (long unsigned int) list;
  *D.6241 = list.30;
  list = p + 32;
  n_words_found = n_words_found + 4;
  <D.6240>:
  D.6242 = mark_word & 256;
  if (D.6242 == 0) goto <D.6243>; else goto <D.6244>;
  <D.6243>:
  D.6245 = p + 64;
  list.30 = (long unsigned int) list;
  *D.6245 = list.30;
  list = p + 64;
  n_words_found = n_words_found + 4;
  <D.6244>:
  D.6246 = mark_word & 4096;
  if (D.6246 == 0) goto <D.6247>; else goto <D.6248>;
  <D.6247>:
  D.6249 = p + 96;
  list.30 = (long unsigned int) list;
  *D.6249 = list.30;
  list = p + 96;
  n_words_found = n_words_found + 4;
  <D.6248>:
  D.6250 = mark_word & 65536;
  if (D.6250 == 0) goto <D.6251>; else goto <D.6252>;
  <D.6251>:
  D.6253 = p + 128;
  list.30 = (long unsigned int) list;
  *D.6253 = list.30;
  list = p + 128;
  n_words_found = n_words_found + 4;
  <D.6252>:
  D.6254 = mark_word & 1048576;
  if (D.6254 == 0) goto <D.6255>; else goto <D.6256>;
  <D.6255>:
  D.6257 = p + 160;
  list.30 = (long unsigned int) list;
  *D.6257 = list.30;
  list = p + 160;
  n_words_found = n_words_found + 4;
  <D.6256>:
  D.6258 = mark_word & 16777216;
  if (D.6258 == 0) goto <D.6259>; else goto <D.6260>;
  <D.6259>:
  D.6261 = p + 192;
  list.30 = (long unsigned int) list;
  *D.6261 = list.30;
  list = p + 192;
  n_words_found = n_words_found + 4;
  <D.6260>:
  D.6262 = mark_word & 268435456;
  if (D.6262 == 0) goto <D.6263>; else goto <D.6264>;
  <D.6263>:
  D.6265 = p + 224;
  list.30 = (long unsigned int) list;
  *D.6265 = list.30;
  list = p + 224;
  n_words_found = n_words_found + 4;
  <D.6264>:
  D.6266 = mark_word & 4294967296;
  if (D.6266 == 0) goto <D.6267>; else goto <D.6268>;
  <D.6267>:
  D.6269 = p + 256;
  list.30 = (long unsigned int) list;
  *D.6269 = list.30;
  list = p + 256;
  n_words_found = n_words_found + 4;
  <D.6268>:
  D.6270 = mark_word & 68719476736;
  if (D.6270 == 0) goto <D.6271>; else goto <D.6272>;
  <D.6271>:
  D.6273 = p + 288;
  list.30 = (long unsigned int) list;
  *D.6273 = list.30;
  list = p + 288;
  n_words_found = n_words_found + 4;
  <D.6272>:
  D.6274 = mark_word & 1099511627776;
  if (D.6274 == 0) goto <D.6275>; else goto <D.6276>;
  <D.6275>:
  D.6277 = p + 320;
  list.30 = (long unsigned int) list;
  *D.6277 = list.30;
  list = p + 320;
  n_words_found = n_words_found + 4;
  <D.6276>:
  D.6278 = mark_word & 17592186044416;
  if (D.6278 == 0) goto <D.6279>; else goto <D.6280>;
  <D.6279>:
  D.6281 = p + 352;
  list.30 = (long unsigned int) list;
  *D.6281 = list.30;
  list = p + 352;
  n_words_found = n_words_found + 4;
  <D.6280>:
  D.6282 = mark_word & 281474976710656;
  if (D.6282 == 0) goto <D.6283>; else goto <D.6284>;
  <D.6283>:
  D.6285 = p + 384;
  list.30 = (long unsigned int) list;
  *D.6285 = list.30;
  list = p + 384;
  n_words_found = n_words_found + 4;
  <D.6284>:
  D.6286 = mark_word & 4503599627370496;
  if (D.6286 == 0) goto <D.6287>; else goto <D.6288>;
  <D.6287>:
  D.6289 = p + 416;
  list.30 = (long unsigned int) list;
  *D.6289 = list.30;
  list = p + 416;
  n_words_found = n_words_found + 4;
  <D.6288>:
  D.6290 = mark_word & 72057594037927936;
  if (D.6290 == 0) goto <D.6291>; else goto <D.6292>;
  <D.6291>:
  D.6293 = p + 448;
  list.30 = (long unsigned int) list;
  *D.6293 = list.30;
  list = p + 448;
  n_words_found = n_words_found + 4;
  <D.6292>:
  D.6294 = mark_word & 1152921504606846976;
  if (D.6294 == 0) goto <D.6295>; else goto <D.6296>;
  <D.6295>:
  D.6297 = p + 480;
  list.30 = (long unsigned int) list;
  *D.6297 = list.30;
  list = p + 480;
  n_words_found = n_words_found + 4;
  <D.6296>:
  p = p + 512;
  <D.5781>:
  if (p < plim) goto <D.5780>; else goto <D.5782>;
  <D.5782>:
  D.6298 = *count;
  D.6299 = D.6298 + n_words_found;
  *count = D.6299;
  D.6300 = list;
  return D.6300;
}


GC_reclaim1 (struct hblk * hbp, struct hdr * hhdr, char * list, signed_word * count)
{
  long unsigned int hbp.31;
  long unsigned int D.6303;
  word * mark_word_addr.32;
  long unsigned int D.6305;
  long unsigned int list.33;
  long unsigned int D.6309;
  word * D.6312;
  long unsigned int D.6313;
  word * D.6316;
  long unsigned int D.6317;
  word * D.6320;
  unsigned int i.34;
  long int D.6322;
  long int D.6323;
  char * D.6324;
  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.31 = (long unsigned int) hbp;
  D.6303 = hbp.31 + 4096;
  plim = (word *) D.6303;
  goto <D.5799>;
  <D.5798>:
  mark_word_addr.32 = mark_word_addr;
  mark_word_addr = mark_word_addr.32 + 8;
  mark_word = *mark_word_addr.32;
  i = 0;
  goto <D.5796>;
  <D.5795>:
  D.6305 = mark_word & 1;
  if (D.6305 == 0) goto <D.6306>; else goto <D.6307>;
  <D.6306>:
  list.33 = (long unsigned int) list;
  *p = list.33;
  list = p;
  n_words_found = n_words_found + 1;
  <D.6307>:
  D.6309 = mark_word & 2;
  if (D.6309 == 0) goto <D.6310>; else goto <D.6311>;
  <D.6310>:
  D.6312 = p + 8;
  list.33 = (long unsigned int) list;
  *D.6312 = list.33;
  list = p + 8;
  n_words_found = n_words_found + 1;
  <D.6311>:
  D.6313 = mark_word & 4;
  if (D.6313 == 0) goto <D.6314>; else goto <D.6315>;
  <D.6314>:
  D.6316 = p + 16;
  list.33 = (long unsigned int) list;
  *D.6316 = list.33;
  list = p + 16;
  n_words_found = n_words_found + 1;
  <D.6315>:
  D.6317 = mark_word & 8;
  if (D.6317 == 0) goto <D.6318>; else goto <D.6319>;
  <D.6318>:
  D.6320 = p + 24;
  list.33 = (long unsigned int) list;
  *D.6320 = list.33;
  list = p + 24;
  n_words_found = n_words_found + 1;
  <D.6319>:
  p = p + 32;
  mark_word = mark_word >> 4;
  i = i + 4;
  <D.5796>:
  i.34 = (unsigned int) i;
  if (i.34 <= 63) goto <D.5795>; else goto <D.5797>;
  <D.5797>:
  <D.5799>:
  if (p < plim) goto <D.5798>; else goto <D.5800>;
  <D.5800>:
  D.6322 = *count;
  D.6323 = D.6322 + n_words_found;
  *count = D.6323;
  D.6324 = list;
  return D.6324;
}


GC_reclaim_generic (struct hblk * hbp, struct hdr * hhdr, word sz, GC_bool init, char * list, signed_word * count)
{
  long unsigned int D.6326;
  _Bool D.6327;
  int D.6328;
  unsigned char D.6332;
  int D.6333;
  int D.6334;
  char * D.6337;
  char * result;

  result = list;
  D.6326 = hhdr->hb_descr;
  D.6327 = D.6326 == 0;
  D.6328 = (int) D.6327;
  GC_remove_protection (hbp, 1, D.6328);
  if (init != 0) goto <D.6329>; else goto <D.6330>;
  <D.6329>:
  switch (sz) <default: <D.5814>, case 1: <D.5810>, case 2: <D.5812>, case 4: <D.5813>>
  <D.5810>:
  result = GC_reclaim1 (hbp, hhdr, list, count);
  goto <D.5811>;
  <D.5812>:
  result = GC_reclaim_clear2 (hbp, hhdr, list, count);
  goto <D.5811>;
  <D.5813>:
  result = GC_reclaim_clear4 (hbp, hhdr, list, count);
  goto <D.5811>;
  <D.5814>:
  result = GC_reclaim_clear (hbp, hhdr, sz, list, count);
  goto <D.5811>;
  <D.5811>:
  goto <D.6331>;
  <D.6330>:
  switch (sz) <default: <D.5819>, case 1: <D.5815>, case 2: <D.5817>, case 4: <D.5818>>
  <D.5815>:
  result = GC_reclaim1 (hbp, hhdr, list, count);
  goto <D.5816>;
  <D.5817>:
  result = GC_reclaim_uninit2 (hbp, hhdr, list, count);
  goto <D.5816>;
  <D.5818>:
  result = GC_reclaim_uninit4 (hbp, hhdr, list, count);
  goto <D.5816>;
  <D.5819>:
  result = GC_reclaim_uninit (hbp, hhdr, sz, list, count);
  goto <D.5816>;
  <D.5816>:
  <D.6331>:
  D.6332 = hhdr->hb_obj_kind;
  D.6333 = (int) D.6332;
  D.6334 = D.6333 & -2;
  if (D.6334 == 2) goto <D.6335>; else goto <D.6336>;
  <D.6335>:
  GC_set_hdr_marks (hhdr);
  <D.6336>:
  D.6337 = result;
  return D.6337;
}


GC_reclaim_small_nonempty_block (struct hblk * hbp, int report_if_found, signed_word * count)
{
  unsigned char D.6339;
  char * * D.6340;
  long unsigned int D.6341;
  long unsigned int GC_gc_no.35;
  short unsigned int D.6343;
  int iftmp.36;
  int D.6351;
  int GC_debugging_started.37;
  char * D.6354;
  char * D.6355;
  struct hdr * hhdr;
  word sz;
  int kind;
  struct obj_kind * ok;
  char * * flh;

  hhdr = GC_find_header (hbp);
  sz = hhdr->hb_sz;
  D.6339 = hhdr->hb_obj_kind;
  kind = (int) D.6339;
  ok = &GC_obj_kinds[kind];
  D.6340 = ok->ok_freelist;
  D.6341 = sz * 8;
  flh = D.6340 + D.6341;
  GC_gc_no.35 = GC_gc_no;
  D.6343 = (short unsigned int) GC_gc_no.35;
  hhdr->hb_last_reclaimed = D.6343;
  if (report_if_found != 0) goto <D.6344>; else goto <D.6345>;
  <D.6344>:
  GC_reclaim_check (hbp, hhdr, sz);
  goto <D.6346>;
  <D.6345>:
  D.6351 = ok->ok_init;
  if (D.6351 != 0) goto <D.6348>; else goto <D.6352>;
  <D.6352>:
  GC_debugging_started.37 = GC_debugging_started;
  if (GC_debugging_started.37 != 0) goto <D.6348>; else goto <D.6349>;
  <D.6348>:
  iftmp.36 = 1;
  goto <D.6350>;
  <D.6349>:
  iftmp.36 = 0;
  <D.6350>:
  D.6354 = *flh;
  D.6355 = GC_reclaim_generic (hbp, hhdr, sz, iftmp.36, D.6354, &GC_mem_found);
  *flh = D.6355;
  <D.6346>:
}


GC_reclaim_block (struct hblk * hbp, word report_if_found)
{
  unsigned char D.6356;
  int D.6357;
  long unsigned int D.6360;
  long unsigned int D.6361;
  long unsigned int D.6367;
  long unsigned int D.6368;
  long unsigned int D.6371;
  long unsigned int D.6372;
  long unsigned int D.6373;
  int D.6377;
  int D.6382;
  struct hblk * * D.6385;
  long unsigned int D.6386;
  struct hblk * D.6387;
  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.6356 = hhdr->hb_obj_kind;
  D.6357 = (int) D.6356;
  ok = &GC_obj_kinds[D.6357];
  if (sz > 256) goto <D.6358>; else goto <D.6359>;
  <D.6358>:
  D.6360 = hhdr->hb_marks[0];
  D.6361 = D.6360 & 1;
  if (D.6361 == 0) goto <D.6362>; else goto <D.6363>;
  <D.6362>:
  if (report_if_found != 0) goto <D.6364>; else goto <D.6365>;
  <D.6364>:
  GC_add_leaked (hbp);
  goto <D.6366>;
  <D.6365>:
  {
    word blocks;

    D.6367 = sz << 3;
    D.6368 = D.6367 + 4095;
    blocks = D.6368 >> 12;
    if (blocks > 1) goto <D.6369>; else goto <D.6370>;
    <D.6369>:
    D.6371 = GC_arrays._large_allocd_bytes;
    D.6372 = blocks * 4096;
    D.6373 = D.6371 - D.6372;
    GC_arrays._large_allocd_bytes = D.6373;
    <D.6370>:
    GC_freehblk (hbp);
  }
  <D.6366>:
  <D.6363>:
  goto <D.6374>;
  <D.6359>:
  {
    GC_bool empty;

    empty = GC_block_empty (hhdr);
    if (report_if_found != 0) goto <D.6375>; else goto <D.6376>;
    <D.6375>:
    D.6377 = (int) report_if_found;
    GC_reclaim_small_nonempty_block (hbp, D.6377, &GC_mem_found);
    goto <D.6378>;
    <D.6376>:
    if (empty != 0) goto <D.6379>; else goto <D.6380>;
    <D.6379>:
    GC_freehblk (hbp);
    goto <D.6381>;
    <D.6380>:
    D.6382 = GC_block_nearly_full (hhdr);
    if (D.6382 != 1) goto <D.6383>; else goto <D.6384>;
    <D.6383>:
    D.6385 = ok->ok_reclaim_list;
    D.6386 = sz * 8;
    rlh = D.6385 + D.6386;
    D.6387 = *rlh;
    hhdr->hb_next = D.6387;
    *rlh = hbp;
    <D.6384>:
    <D.6381>:
    <D.6378>:
  }
  <D.6374>:
}


GC_n_set_marks (struct hdr * hhdr)
{
  long unsigned int D.6388;
  int D.6389;
  int D.6390;
  register int result;
  register int i;

  result = 0;
  i = 0;
  goto <D.5857>;
  <D.5856>:
  D.6388 = hhdr->hb_marks[i];
  D.6389 = set_bits (D.6388);
  result = D.6389 + result;
  i = i + 1;
  <D.5857>:
  if (i <= 7) goto <D.5856>; else goto <D.5858>;
  <D.5858>:
  D.6390 = result;
  return D.6390;
}


set_bits (word n)
{
  long unsigned int D.6392;
  int D.6395;
  register word m;
  register int result;

  m = n;
  result = 0;
  goto <D.5849>;
  <D.5848>:
  D.6392 = m & 1;
  if (D.6392 != 0) goto <D.6393>; else goto <D.6394>;
  <D.6393>:
  result = result + 1;
  <D.6394>:
  m = m >> 1;
  <D.5849>:
  if (m != 0) goto <D.5848>; else goto <D.5850>;
  <D.5850>:
  D.6395 = result;
  return D.6395;
}


GC_print_block_descr (struct hblk * h, word dummy)
{
  long unsigned int D.6397;
  unsigned char D.6398;
  long int D.6399;
  long int bytes.38;
  int D.6401;
  long int D.6402;
  long unsigned int D.6403;
  long unsigned int D.6404;
  long unsigned int D.6405;
  long unsigned int D.6406;
  register struct hdr * hhdr;
  register size_t bytes;
  struct Print_stats * ps;

  hhdr = GC_find_header (h);
  D.6397 = hhdr->hb_sz;
  bytes = D.6397 << 3;
  D.6398 = hhdr->hb_obj_kind;
  D.6399 = (long int) D.6398;
  bytes.38 = (long int) bytes;
  D.6401 = GC_n_set_marks (hhdr);
  D.6402 = (long int) D.6401;
  GC_printf ("(%lu:%lu,%lu)", D.6399, bytes.38, D.6402, 0, 0, 0);
  bytes = bytes + 4095;
  bytes = bytes & 18446744073709547520;
  ps = (struct Print_stats *) dummy;
  D.6403 = ps->total_bytes;
  D.6404 = D.6403 + bytes;
  ps->total_bytes = D.6404;
  D.6405 = ps->number_of_blocks;
  D.6406 = D.6405 + 1;
  ps->number_of_blocks = D.6406;
}


GC_print_block_list ()
{
  long unsigned int pstats.39;
  long unsigned int D.6408;
  long int D.6409;
  long unsigned int D.6410;
  long int D.6411;
  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.39 = (long unsigned int) &pstats;
      GC_apply_to_all_blocks (GC_print_block_descr, pstats.39);
      D.6408 = pstats.number_of_blocks;
      D.6409 = (long int) D.6408;
      D.6410 = pstats.total_bytes;
      D.6411 = (long int) D.6410;
      GC_printf ("\nblocks = %lu, bytes = %lu\n", D.6409, D.6411, 0, 0, 0, 0);
    }
  finally
    {
      pstats = {CLOBBER};
    }
}


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

  next = *flp;
  goto <D.5874>;
  <D.5873>:
  *flp = 0B;
  flp = next;
  next = *flp;
  <D.5874>:
  if (next != 0B) goto <D.5873>; else goto <D.5875>;
  <D.5875>:
}


GC_start_reclaim (int report_if_found)
{
  long unsigned int D.6412;
  _Bool D.6413;
  char * * D.6418;
  char * D.6419;
  int GC_n_kinds.40;
  long unsigned int D.6426;
  int kind;

  kind = 0;
  goto <D.5894>;
  <D.5893>:
  {
    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.6412 = GC_obj_kinds[kind].ok_descriptor;
    D.6413 = D.6412 != 0;
    should_clobber = (GC_bool) D.6413;
    if (rlist == 0B) goto <D.6414>; else goto <D.6415>;
    <D.6414>:
    // predicted unlikely by continue predictor.
    goto <D.5886>;
    <D.6415>:
    if (report_if_found == 0) goto <D.6416>; else goto <D.6417>;
    <D.6416>:
    D.6418 = GC_obj_kinds[kind].ok_freelist;
    lim = D.6418 + 2056;
    fop = GC_obj_kinds[kind].ok_freelist;
    goto <D.5888>;
    <D.5887>:
    D.6419 = *fop;
    if (D.6419 != 0B) goto <D.6420>; else goto <D.6421>;
    <D.6420>:
    if (should_clobber != 0) goto <D.6422>; else goto <D.6423>;
    <D.6422>:
    GC_clear_fl_links (fop);
    goto <D.6424>;
    <D.6423>:
    *fop = 0B;
    <D.6424>:
    <D.6421>:
    fop = fop + 8;
    <D.5888>:
    if (fop < lim) goto <D.5887>; else goto <D.5889>;
    <D.5889>:
    <D.6417>:
    rlim = rlist + 2056;
    rlp = rlist;
    goto <D.5891>;
    <D.5890>:
    *rlp = 0B;
    rlp = rlp + 8;
    <D.5891>:
    if (rlp < rlim) goto <D.5890>; else goto <D.5892>;
    <D.5892>:
  }
  <D.5886>:
  kind = kind + 1;
  <D.5894>:
  GC_n_kinds.40 = GC_n_kinds;
  if (kind < GC_n_kinds.40) goto <D.5893>; else goto <D.5895>;
  <D.5895>:
  D.6426 = (long unsigned int) report_if_found;
  GC_apply_to_all_blocks (GC_reclaim_block, D.6426);
}


GC_continue_reclaim (word sz, int kind)
{
  char * * D.6427;
  long unsigned int D.6428;
  struct hblk * D.6431;
  char * D.6432;
  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.6427 = ok->ok_freelist;
  D.6428 = sz * 8;
  flh = D.6427 + D.6428;
  if (rlh == 0B) goto <D.6429>; else goto <D.6430>;
  <D.6429>:
  return;
  <D.6430>:
  D.6428 = sz * 8;
  rlh = rlh + D.6428;
  goto <D.5907>;
  <D.5906>:
  hhdr = GC_find_header (hbp);
  D.6431 = hhdr->hb_next;
  *rlh = D.6431;
  GC_reclaim_small_nonempty_block (hbp, 0, &GC_mem_found);
  D.6432 = *flh;
  if (D.6432 != 0B) goto <D.5905>; else goto <D.6433>;
  <D.6433>:
  <D.5907>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.5906>; else goto <D.5905>;
  <D.5905>:
}


GC_reclaim_all (int (*GC_stop_func) (void) stop_func, GC_bool ignore_old)
{
  long unsigned int D.6437;
  int D.6440;
  GC_bool D.6443;
  struct hblk * D.6444;
  short unsigned int D.6448;
  long unsigned int D.6449;
  long unsigned int GC_gc_no.41;
  long unsigned int D.6451;
  int GC_n_kinds.42;
  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.5927>;
  <D.5926>:
  ok = &GC_obj_kinds[kind];
  rlp = ok->ok_reclaim_list;
  if (rlp == 0B) goto <D.6435>; else goto <D.6436>;
  <D.6435>:
  // predicted unlikely by continue predictor.
  goto <D.5919>;
  <D.6436>:
  sz = 1;
  goto <D.5924>;
  <D.5923>:
  D.6437 = sz * 8;
  rlh = rlp + D.6437;
  goto <D.5921>;
  <D.5920>:
  if (stop_func != 0B) goto <D.6438>; else goto <D.6439>;
  <D.6438>:
  D.6440 = stop_func ();
  if (D.6440 != 0) goto <D.6441>; else goto <D.6442>;
  <D.6441>:
  D.6443 = 0;
  return D.6443;
  <D.6442>:
  <D.6439>:
  hhdr = GC_find_header (hbp);
  D.6444 = hhdr->hb_next;
  *rlh = D.6444;
  if (ignore_old == 0) goto <D.6445>; else goto <D.6447>;
  <D.6447>:
  D.6448 = hhdr->hb_last_reclaimed;
  D.6449 = (long unsigned int) D.6448;
  GC_gc_no.41 = GC_gc_no;
  D.6451 = GC_gc_no.41 + 18446744073709551615;
  if (D.6449 == D.6451) goto <D.6445>; else goto <D.6446>;
  <D.6445>:
  GC_reclaim_small_nonempty_block (hbp, 0, &GC_mem_found);
  <D.6446>:
  <D.5921>:
  hbp = *rlh;
  if (hbp != 0B) goto <D.5920>; else goto <D.5922>;
  <D.5922>:
  sz = sz + 1;
  <D.5924>:
  if (sz <= 256) goto <D.5923>; else goto <D.5925>;
  <D.5925>:
  <D.5919>:
  kind = kind + 1;
  <D.5927>:
  GC_n_kinds.42 = GC_n_kinds;
  if (kind < GC_n_kinds.42) goto <D.5926>; else goto <D.5928>;
  <D.5928>:
  D.6443 = 1;
  return D.6443;
}