GC_noop (void * p)
{

}


GC_noop1 (word x)
{
  static volatile word sink;

  sink = x;
}


GC_collection_in_progress ()
{
  GC_bool D.6103;
  int GC_mark_state.0;
  _Bool D.6105;

  GC_mark_state.0 = GC_mark_state;
  D.6105 = GC_mark_state.0 != 0;
  D.6103 = (GC_bool) D.6105;
  return D.6103;
}


GC_clear_hdr_marks (struct hdr * hhdr)
{
  word[8] * D.6107;

  D.6107 = &hhdr->hb_marks;
  memset (D.6107, 0, 64);
}


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

  D.6109 = __builtin_object_size (__dest, 0);
  D.6108 = __builtin___memset_chk (__dest, __ch, __len, D.6109);
  return D.6108;
}


GC_set_hdr_marks (struct hdr * hhdr)
{
  register int i;

  i = 0;
  goto <D.5674>;
  <D.5673>:
  hhdr->hb_marks[i] = 18446744073709551615;
  i = i + 1;
  <D.5674>:
  if (i <= 7) goto <D.5673>; else goto <D.5675>;
  <D.5675>:
}


GC_set_mark_bit (char * p)
{
  long unsigned int p.1;
  long unsigned int D.6112;
  long int p.2;
  long int h.3;
  long int D.6115;
  long int D.6116;
  word[8] * D.6117;
  int D.6118;
  long unsigned int D.6119;
  long unsigned int D.6120;
  volatile word * D.6121;
  volatile GC_word * D.6122;
  int D.6123;
  long unsigned int D.6124;
  long unsigned int D.6125;
  int D.6126;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.1 = (long unsigned int) p;
  D.6112 = p.1 & 18446744073709547520;
  h = (struct hblk *) D.6112;
  hhdr = GC_find_header (h);
  p.2 = (long int) p;
  h.3 = (long int) h;
  D.6115 = p.2 - h.3;
  D.6116 = D.6115 /[ex] 8;
  word_no = (int) D.6116;
  {
    word old;

    <D.5688>:
    D.6117 = &hhdr->hb_marks;
    D.6118 = word_no >> 6;
    D.6119 = (long unsigned int) D.6118;
    D.6120 = D.6119 * 8;
    D.6121 = D.6117 + D.6120;
    old = *D.6121;
    D.6117 = &hhdr->hb_marks;
    D.6118 = word_no >> 6;
    D.6119 = (long unsigned int) D.6118;
    D.6120 = D.6119 * 8;
    D.6122 = D.6117 + D.6120;
    D.6123 = word_no & 63;
    D.6124 = 1 << D.6123;
    D.6125 = D.6124 | old;
    D.6126 = GC_compare_and_exchange (D.6122, old, D.6125);
    if (D.6126 == 0) goto <D.5688>; else goto <D.5689>;
    <D.5689>:
  }
}


GC_compare_and_exchange (volatile GC_word * addr, GC_word old, GC_word new_val)
{
  GC_bool D.6127;
  _Bool D.6128;
  int retval;

  __asm__ __volatile__("     csg %1,%2,0(%3)
     ipm %0
     srl %0,28
" : "=&d" retval, "=d" old : "d" new_val, "a" addr, "1" old : "memory", "cc");
  D.6128 = retval == 0;
  D.6127 = (GC_bool) D.6128;
  return D.6127;
}


GC_clear_mark_bit (char * p)
{
  long unsigned int p.4;
  long unsigned int D.6131;
  long int p.5;
  long int h.6;
  long int D.6134;
  long int D.6135;
  int D.6136;
  long unsigned int D.6137;
  int D.6138;
  long unsigned int D.6139;
  long unsigned int D.6140;
  long unsigned int D.6141;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.4 = (long unsigned int) p;
  D.6131 = p.4 & 18446744073709547520;
  h = (struct hblk *) D.6131;
  hhdr = GC_find_header (h);
  p.5 = (long int) p;
  h.6 = (long int) h;
  D.6134 = p.5 - h.6;
  D.6135 = D.6134 /[ex] 8;
  word_no = (int) D.6135;
  D.6136 = word_no >> 6;
  D.6136 = word_no >> 6;
  D.6137 = hhdr->hb_marks[D.6136];
  D.6138 = word_no & 63;
  D.6139 = 1 << D.6138;
  D.6140 = ~D.6139;
  D.6141 = D.6137 & D.6140;
  hhdr->hb_marks[D.6136] = D.6141;
}


GC_is_marked (char * p)
{
  long unsigned int p.7;
  long unsigned int D.6143;
  long int p.8;
  long int h.9;
  long int D.6146;
  long int D.6147;
  GC_bool D.6148;
  int D.6149;
  long unsigned int D.6150;
  int D.6151;
  long unsigned int D.6152;
  int D.6153;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.7 = (long unsigned int) p;
  D.6143 = p.7 & 18446744073709547520;
  h = (struct hblk *) D.6143;
  hhdr = GC_find_header (h);
  p.8 = (long int) p;
  h.9 = (long int) h;
  D.6146 = p.8 - h.9;
  D.6147 = D.6146 /[ex] 8;
  word_no = (int) D.6147;
  D.6149 = word_no >> 6;
  D.6150 = hhdr->hb_marks[D.6149];
  D.6151 = word_no & 63;
  D.6152 = D.6150 >> D.6151;
  D.6153 = (int) D.6152;
  D.6148 = D.6153 & 1;
  return D.6148;
}


GC_clear_marks ()
{
  GC_apply_to_all_blocks (clear_marks_for_block, 0);
  GC_objects_are_marked = 0;
  GC_mark_state = 5;
  scan_ptr = 0B;
}


clear_marks_for_block (struct hblk * h, word dummy)
{
  unsigned char D.6155;
  int D.6156;
  int D.6157;
  register struct hdr * hhdr;

  hhdr = GC_find_header (h);
  D.6155 = hhdr->hb_obj_kind;
  D.6156 = (int) D.6155;
  D.6157 = D.6156 & -2;
  if (D.6157 == 2) goto <D.6158>; else goto <D.6159>;
  <D.6158>:
  return;
  <D.6159>:
  GC_clear_hdr_marks (hhdr);
}


GC_initiate_gc ()
{
  int GC_dirty_maintained.10;
  int GC_mark_state.11;

  GC_dirty_maintained.10 = GC_dirty_maintained;
  if (GC_dirty_maintained.10 != 0) goto <D.6162>; else goto <D.6163>;
  <D.6162>:
  GC_read_dirty ();
  <D.6163>:
  GC_n_rescuing_pages = 0;
  GC_mark_state.11 = GC_mark_state;
  if (GC_mark_state.11 == 0) goto <D.6165>; else goto <D.6166>;
  <D.6165>:
  GC_mark_state = 1;
  goto <D.6167>;
  <D.6166>:
  GC_mark_state.11 = GC_mark_state;
  if (GC_mark_state.11 != 5) goto <D.6168>; else goto <D.6169>;
  <D.6168>:
  GC_abort ("unexpected state");
  <D.6169>:
  <D.6167>:
  scan_ptr = 0B;
}


GC_mark_some (char * cold_gc_frame)
{
  int GC_mark_state.12;
  GC_bool D.6171;
  struct mse * GC_mark_stack_limit.13;
  struct mse * D.6173;
  struct mse * GC_mark_stack_top.14;
  struct mse * GC_mark_stack_top.15;
  struct mse * GC_mark_stack.16;
  long unsigned int GC_mark_stack_size.17;
  long unsigned int D.6180;
  struct mse * D.6181;
  struct mse * D.6182;
  struct hblk * scan_ptr.18;
  struct hblk * D.6184;
  int GC_print_stats.19;
  long unsigned int GC_n_rescuing_pages.20;
  long int GC_n_rescuing_pages.21;
  long unsigned int D.6194;
  long unsigned int D.6195;
  struct mse * D.6196;
  struct mse * GC_mark_stack_top.22;
  int GC_parallel.23;
  struct mse * GC_mark_stack_top.24;
  struct mse * D.6204;
  struct hblk * D.6205;
  struct mse * D.6212;
  int GC_mark_stack_too_small.25;
  long unsigned int D.6216;
  struct mse * GC_mark_stack_top.26;
  struct mse * GC_mark_stack_top.27;
  struct mse * D.6223;
  int GC_objects_are_marked.28;
  struct mse * GC_mark_stack_top.29;
  struct mse * GC_mark_stack_top.30;
  struct mse * D.6233;
  struct hblk * D.6240;

  GC_mark_state.12 = GC_mark_state;
  switch (GC_mark_state.12) <default: <D.5716>, case 0: <D.5710>, case 1: <D.5711>, case 2: <D.5712>, case 3: <D.5713>, case 4: <D.5715>, case 5: <D.5714>>
  <D.5710>:
  D.6171 = 0;
  return D.6171;
  <D.5711>:
  GC_mark_stack_limit.13 = GC_mark_stack_limit;
  D.6173 = GC_mark_stack_limit.13 + 18446744073709518848;
  GC_mark_stack_top.14 = GC_mark_stack_top;
  if (D.6173 <= GC_mark_stack_top.14) goto <D.6175>; else goto <D.6176>;
  <D.6175>:
  GC_mark_stack_too_small = 1;
  GC_mark_stack_top.15 = GC_mark_stack_top;
  GC_mark_stack.16 = GC_mark_stack;
  GC_mark_stack.16 = GC_mark_stack;
  GC_mark_stack_size.17 = GC_mark_stack_size;
  D.6180 = GC_mark_stack_size.17 * 16;
  D.6181 = GC_mark_stack.16 + D.6180;
  D.6182 = GC_mark_from (GC_mark_stack_top.15, GC_mark_stack.16, D.6181);
  GC_mark_stack_top = D.6182;
  D.6171 = 0;
  return D.6171;
  <D.6176>:
  scan_ptr.18 = scan_ptr;
  D.6184 = GC_push_next_marked_dirty (scan_ptr.18);
  scan_ptr = D.6184;
  scan_ptr.18 = scan_ptr;
  if (scan_ptr.18 == 0B) goto <D.6185>; else goto <D.6186>;
  <D.6185>:
  GC_print_stats.19 = GC_print_stats;
  if (GC_print_stats.19 != 0) goto <D.6188>; else goto <D.6189>;
  <D.6188>:
  GC_n_rescuing_pages.20 = GC_n_rescuing_pages;
  GC_n_rescuing_pages.21 = (long int) GC_n_rescuing_pages.20;
  GC_printf ("Marked from %lu dirty pages\n", GC_n_rescuing_pages.21, 0, 0, 0, 0, 0);
  <D.6189>:
  GC_push_roots (0, cold_gc_frame);
  GC_objects_are_marked = 1;
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 != 5) goto <D.6192>; else goto <D.6193>;
  <D.6192>:
  GC_mark_state = 3;
  <D.6193>:
  <D.6186>:
  D.6171 = 0;
  return D.6171;
  <D.5712>:
  GC_mark_stack.16 = GC_mark_stack;
  GC_mark_stack_size.17 = GC_mark_stack_size;
  D.6194 = GC_mark_stack_size.17 / 4;
  D.6195 = D.6194 * 16;
  D.6196 = GC_mark_stack.16 + D.6195;
  GC_mark_stack_top.22 = GC_mark_stack_top;
  if (D.6196 <= GC_mark_stack_top.22) goto <D.6198>; else goto <D.6199>;
  <D.6198>:
  GC_parallel.23 = GC_parallel;
  if (GC_parallel.23 != 0) goto <D.6201>; else goto <D.6202>;
  <D.6201>:
  GC_mark_stack_too_small = 1;
  <D.6202>:
  GC_mark_stack_top.24 = GC_mark_stack_top;
  GC_mark_stack.16 = GC_mark_stack;
  GC_mark_stack.16 = GC_mark_stack;
  GC_mark_stack_size.17 = GC_mark_stack_size;
  D.6180 = GC_mark_stack_size.17 * 16;
  D.6181 = GC_mark_stack.16 + D.6180;
  D.6204 = GC_mark_from (GC_mark_stack_top.24, GC_mark_stack.16, D.6181);
  GC_mark_stack_top = D.6204;
  D.6171 = 0;
  return D.6171;
  <D.6199>:
  scan_ptr.18 = scan_ptr;
  D.6205 = GC_push_next_marked_uncollectable (scan_ptr.18);
  scan_ptr = D.6205;
  scan_ptr.18 = scan_ptr;
  if (scan_ptr.18 == 0B) goto <D.6206>; else goto <D.6207>;
  <D.6206>:
  GC_push_roots (1, cold_gc_frame);
  GC_objects_are_marked = 1;
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 != 5) goto <D.6208>; else goto <D.6209>;
  <D.6208>:
  GC_mark_state = 3;
  <D.6209>:
  <D.6207>:
  D.6171 = 0;
  return D.6171;
  <D.5713>:
  GC_parallel.23 = GC_parallel;
  if (GC_parallel.23 != 0) goto <D.6210>; else goto <D.6211>;
  <D.6210>:
  GC_do_parallel_mark ();
  GC_mark_stack.16 = GC_mark_stack;
  D.6212 = GC_mark_stack.16 + 18446744073709551600;
  GC_mark_stack_top = D.6212;
  GC_mark_stack_too_small.25 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.25 != 0) goto <D.6214>; else goto <D.6215>;
  <D.6214>:
  GC_mark_stack_size.17 = GC_mark_stack_size;
  D.6216 = GC_mark_stack_size.17 * 2;
  alloc_mark_stack (D.6216);
  <D.6215>:
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 == 3) goto <D.6217>; else goto <D.6218>;
  <D.6217>:
  GC_mark_state = 0;
  D.6171 = 1;
  return D.6171;
  <D.6218>:
  D.6171 = 0;
  return D.6171;
  <D.6211>:
  GC_mark_stack_top.26 = GC_mark_stack_top;
  GC_mark_stack.16 = GC_mark_stack;
  if (GC_mark_stack_top.26 >= GC_mark_stack.16) goto <D.6220>; else goto <D.6221>;
  <D.6220>:
  GC_mark_stack_top.27 = GC_mark_stack_top;
  GC_mark_stack.16 = GC_mark_stack;
  GC_mark_stack.16 = GC_mark_stack;
  GC_mark_stack_size.17 = GC_mark_stack_size;
  D.6180 = GC_mark_stack_size.17 * 16;
  D.6181 = GC_mark_stack.16 + D.6180;
  D.6223 = GC_mark_from (GC_mark_stack_top.27, GC_mark_stack.16, D.6181);
  GC_mark_stack_top = D.6223;
  D.6171 = 0;
  return D.6171;
  <D.6221>:
  GC_mark_state = 0;
  GC_mark_stack_too_small.25 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.25 != 0) goto <D.6224>; else goto <D.6225>;
  <D.6224>:
  GC_mark_stack_size.17 = GC_mark_stack_size;
  D.6216 = GC_mark_stack_size.17 * 2;
  alloc_mark_stack (D.6216);
  <D.6225>:
  D.6171 = 1;
  return D.6171;
  <D.5714>:
  <D.5715>:
  GC_objects_are_marked.28 = GC_objects_are_marked;
  if (GC_objects_are_marked.28 == 0) goto <D.6227>; else goto <D.6228>;
  <D.6227>:
  GC_mark_state = 2;
  D.6171 = 0;
  return D.6171;
  <D.6228>:
  GC_mark_stack_top.29 = GC_mark_stack_top;
  GC_mark_stack.16 = GC_mark_stack;
  if (GC_mark_stack_top.29 >= GC_mark_stack.16) goto <D.6230>; else goto <D.6231>;
  <D.6230>:
  GC_mark_stack_top.30 = GC_mark_stack_top;
  GC_mark_stack.16 = GC_mark_stack;
  GC_mark_stack.16 = GC_mark_stack;
  GC_mark_stack_size.17 = GC_mark_stack_size;
  D.6180 = GC_mark_stack_size.17 * 16;
  D.6181 = GC_mark_stack.16 + D.6180;
  D.6233 = GC_mark_from (GC_mark_stack_top.30, GC_mark_stack.16, D.6181);
  GC_mark_stack_top = D.6233;
  D.6171 = 0;
  return D.6171;
  <D.6231>:
  scan_ptr.18 = scan_ptr;
  if (scan_ptr.18 == 0B) goto <D.6234>; else goto <D.6235>;
  <D.6234>:
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 == 5) goto <D.6236>; else goto <D.6237>;
  <D.6236>:
  GC_mark_stack_too_small.25 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.25 != 0) goto <D.6238>; else goto <D.6239>;
  <D.6238>:
  GC_mark_stack_size.17 = GC_mark_stack_size;
  D.6216 = GC_mark_stack_size.17 * 2;
  alloc_mark_stack (D.6216);
  <D.6239>:
  GC_mark_state = 4;
  <D.6237>:
  <D.6235>:
  scan_ptr.18 = scan_ptr;
  D.6240 = GC_push_next_marked (scan_ptr.18);
  scan_ptr = D.6240;
  scan_ptr.18 = scan_ptr;
  if (scan_ptr.18 == 0B) goto <D.6241>; else goto <D.6242>;
  <D.6241>:
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 == 4) goto <D.6243>; else goto <D.6244>;
  <D.6243>:
  GC_push_roots (1, cold_gc_frame);
  GC_objects_are_marked = 1;
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 != 5) goto <D.6245>; else goto <D.6246>;
  <D.6245>:
  GC_mark_state = 3;
  <D.6246>:
  <D.6244>:
  <D.6242>:
  D.6171 = 0;
  return D.6171;
  <D.5716>:
  GC_abort ("GC_mark_some: bad state");
  D.6171 = 0;
  return D.6171;
}


alloc_mark_stack (word n)
{
  long unsigned int D.6248;
  long unsigned int GC_mark_stack_size.31;
  long unsigned int GC_page_size.32;
  long unsigned int D.6255;
  struct mse * GC_mark_stack.33;
  long unsigned int GC_mark_stack.34;
  long unsigned int D.6258;
  long unsigned int size.35;
  long unsigned int D.6262;
  long unsigned int D.6263;
  long unsigned int D.6264;
  long unsigned int D.6267;
  struct hblk * D.6268;
  long unsigned int D.6269;
  struct mse * D.6270;
  int GC_print_stats.36;
  long int GC_mark_stack_size.37;
  long int n.38;
  struct mse * D.6282;
  struct mse * new_stack;

  D.6248 = n * 16;
  new_stack = GC_scratch_alloc (D.6248);
  GC_mark_stack_too_small = 0;
  GC_mark_stack_size.31 = GC_mark_stack_size;
  if (GC_mark_stack_size.31 != 0) goto <D.6250>; else goto <D.6251>;
  <D.6250>:
  if (new_stack != 0B) goto <D.6252>; else goto <D.6253>;
  <D.6252>:
  {
    word displ;
    signed_word size;

    GC_page_size.32 = GC_page_size;
    D.6255 = GC_page_size.32 + 18446744073709551615;
    GC_mark_stack.33 = GC_mark_stack;
    GC_mark_stack.34 = (long unsigned int) GC_mark_stack.33;
    displ = D.6255 & GC_mark_stack.34;
    GC_mark_stack_size.31 = GC_mark_stack_size;
    D.6258 = GC_mark_stack_size.31 * 16;
    size = (signed_word) D.6258;
    if (displ != 0) goto <D.6259>; else goto <D.6260>;
    <D.6259>:
    GC_page_size.32 = GC_page_size;
    displ = GC_page_size.32 - displ;
    <D.6260>:
    size.35 = (long unsigned int) size;
    D.6262 = size.35 - displ;
    GC_page_size.32 = GC_page_size;
    D.6263 = -GC_page_size.32;
    D.6264 = D.6262 & D.6263;
    size = (signed_word) D.6264;
    if (size > 0) goto <D.6265>; else goto <D.6266>;
    <D.6265>:
    GC_mark_stack.33 = GC_mark_stack;
    GC_mark_stack.34 = (long unsigned int) GC_mark_stack.33;
    D.6267 = GC_mark_stack.34 + displ;
    D.6268 = (struct hblk *) D.6267;
    size.35 = (long unsigned int) size;
    GC_add_to_heap (D.6268, size.35);
    <D.6266>:
    GC_mark_stack = new_stack;
    GC_mark_stack_size = n;
    D.6269 = n * 16;
    D.6270 = new_stack + D.6269;
    GC_mark_stack_limit = D.6270;
    GC_print_stats.36 = GC_print_stats;
    if (GC_print_stats.36 != 0) goto <D.6272>; else goto <D.6273>;
    <D.6272>:
    GC_mark_stack_size.31 = GC_mark_stack_size;
    GC_mark_stack_size.37 = (long int) GC_mark_stack_size.31;
    GC_printf ("Grew mark stack to %lu frames\n", GC_mark_stack_size.37, 0, 0, 0, 0, 0);
    <D.6273>:
  }
  goto <D.6275>;
  <D.6253>:
  GC_print_stats.36 = GC_print_stats;
  if (GC_print_stats.36 != 0) goto <D.6276>; else goto <D.6277>;
  <D.6276>:
  n.38 = (long int) n;
  GC_printf ("Failed to grow mark stack to %lu frames\n", n.38, 0, 0, 0, 0, 0);
  <D.6277>:
  <D.6275>:
  goto <D.6279>;
  <D.6251>:
  if (new_stack == 0B) goto <D.6280>; else goto <D.6281>;
  <D.6280>:
  GC_err_puts ("No space for mark stack\n");
  exit (1);
  <D.6281>:
  GC_mark_stack = new_stack;
  GC_mark_stack_size = n;
  D.6269 = n * 16;
  D.6270 = new_stack + D.6269;
  GC_mark_stack_limit = D.6270;
  <D.6279>:
  GC_mark_stack.33 = GC_mark_stack;
  D.6282 = GC_mark_stack.33 + 18446744073709551600;
  GC_mark_stack_top = D.6282;
}


GC_mark_stack_empty ()
{
  GC_bool D.6283;
  struct mse * GC_mark_stack_top.39;
  struct mse * GC_mark_stack.40;
  _Bool D.6286;

  GC_mark_stack_top.39 = GC_mark_stack_top;
  GC_mark_stack.40 = GC_mark_stack;
  D.6286 = GC_mark_stack_top.39 < GC_mark_stack.40;
  D.6283 = (GC_bool) D.6286;
  return D.6283;
}


GC_find_start (char * current, struct hdr * hhdr, struct hdr * * new_hdr_p)
{
  int GC_all_interior_pointers.41;
  long unsigned int current.42;
  long unsigned int D.6294;
  long unsigned int hhdr.43;
  long unsigned int D.6296;
  sizetype D.6297;
  unsigned char D.6298;
  int D.6299;
  int D.6300;
  char * D.6303;
  long int orig.44;
  long int current.45;
  long int D.6306;
  long int D.6307;
  long unsigned int D.6308;
  long int D.6309;

  GC_all_interior_pointers.41 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.41 != 0) goto <D.6289>; else goto <D.6290>;
  <D.6289>:
  if (hhdr != 0B) goto <D.6291>; else goto <D.6292>;
  <D.6291>:
  {
    register char * orig;

    orig = current;
    current.42 = (long unsigned int) current;
    D.6294 = current.42 & 18446744073709547520;
    current = (char *) D.6294;
    <D.5725>:
    hhdr.43 = (long unsigned int) hhdr;
    D.6296 = hhdr.43 * 4096;
    D.6297 = -D.6296;
    current = current + D.6297;
    hhdr = GC_find_header (current);
    hhdr.43 = (long unsigned int) hhdr;
    if (hhdr.43 <= 4095) goto <D.5725>; else goto <D.5726>;
    <D.5726>:
    D.6298 = hhdr->hb_flags;
    D.6299 = (int) D.6298;
    D.6300 = D.6299 & 1;
    if (D.6300 != 0) goto <D.6301>; else goto <D.6302>;
    <D.6301>:
    D.6303 = orig;
    return D.6303;
    <D.6302>:
    orig.44 = (long int) orig;
    current.45 = (long int) current;
    D.6306 = orig.44 - current.45;
    D.6307 = D.6306 /[ex] 8;
    D.6308 = hhdr->hb_sz;
    D.6309 = (long int) D.6308;
    if (D.6307 >= D.6309) goto <D.6310>; else goto <D.6311>;
    <D.6310>:
    D.6303 = orig;
    return D.6303;
    <D.6311>:
    *new_hdr_p = hhdr;
    D.6303 = current;
    return D.6303;
  }
  <D.6292>:
  D.6303 = current;
  return D.6303;
  <D.6290>:
  D.6303 = current;
  return D.6303;
}


GC_invalidate_mark_state ()
{
  struct mse * GC_mark_stack.46;
  struct mse * D.6314;

  GC_mark_state = 5;
  GC_mark_stack.46 = GC_mark_stack;
  D.6314 = GC_mark_stack.46 + 18446744073709551600;
  GC_mark_stack_top = D.6314;
}


GC_signal_mark_stack_overflow (struct mse * msp)
{
  int GC_print_stats.47;
  long unsigned int GC_mark_stack_size.48;
  long int GC_mark_stack_size.49;
  struct mse * D.6320;

  GC_mark_state = 5;
  GC_mark_stack_too_small = 1;
  GC_print_stats.47 = GC_print_stats;
  if (GC_print_stats.47 != 0) goto <D.6316>; else goto <D.6317>;
  <D.6316>:
  GC_mark_stack_size.48 = GC_mark_stack_size;
  GC_mark_stack_size.49 = (long int) GC_mark_stack_size.48;
  GC_printf ("Mark stack overflow; current size = %lu entries\n", GC_mark_stack_size.49, 0, 0, 0, 0, 0);
  <D.6317>:
  D.6320 = msp + 18446744073709543424;
  return D.6320;
}


GC_mark_from (struct mse * mark_stack_top, struct mse * mark_stack, struct mse * mark_stack_limit)
{
  long unsigned int D.6322;
  int GC_parallel.50;
  struct mse * D.6330;
  long unsigned int D.6333;
  int D.6334;
  long unsigned int D.6335;
  long unsigned int D.6336;
  sizetype D.6337;
  long unsigned int D.6338;
  long unsigned int D.6339;
  unsigned int credit.51;
  unsigned int D.6341;
  long int descr.52;
  char * current.53;
  long unsigned int my_current.54;
  long unsigned int D.6351;
  long unsigned int D.6352;
  long unsigned int D.6353;
  long unsigned int D.6354;
  long unsigned int D.6358;
  long unsigned int D.6359;
  struct bottom_index * D.6361;
  long unsigned int D.6362;
  long unsigned int my_hhdr.55;
  struct hdr * GC_invalid_header.56;
  long int my_current.57;
  int D.6369;
  map_entry_type * D.6370;
  sizetype D.6371;
  map_entry_type * D.6372;
  unsigned char D.6373;
  long unsigned int D.6378;
  long unsigned int D.6379;
  long unsigned int D.6380;
  long unsigned int D.6381;
  int GC_all_interior_pointers.58;
  word[8] * D.6393;
  int D.6394;
  long unsigned int D.6395;
  long unsigned int D.6396;
  int D.6397;
  long unsigned int D.6398;
  long unsigned int D.6400;
  int D.6401;
  long unsigned int D.6407;
  long unsigned int D.6408;
  sizetype my_current.59;
  sizetype D.6410;
  sizetype D.6411;
  GC_word * D.6412;
  long unsigned int D.6413;
  long unsigned int D.6414;
  struct GC_ms_entry * (*<Tc07>) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word) D.6415;
  long unsigned int D.6416;
  sizetype D.6419;
  word * D.6420;
  sizetype D.6424;
  char * D.6425;
  long int limit.60;
  long int current_p.61;
  long int D.6432;
  unsigned int D.6433;
  unsigned int D.6434;
  char * deferred.62;
  long unsigned int my_current.63;
  long unsigned int D.6449;
  long unsigned int D.6450;
  long unsigned int D.6451;
  long unsigned int D.6452;
  long unsigned int D.6456;
  long unsigned int D.6457;
  long unsigned int D.6459;
  long unsigned int my_hhdr.64;
  long int my_current.65;
  int D.6465;
  map_entry_type * D.6466;
  sizetype D.6467;
  map_entry_type * D.6468;
  unsigned char D.6469;
  long unsigned int D.6474;
  long unsigned int D.6475;
  long unsigned int D.6476;
  long unsigned int D.6477;
  word[8] * D.6488;
  int D.6489;
  long unsigned int D.6490;
  long unsigned int D.6491;
  int D.6492;
  long unsigned int D.6493;
  long unsigned int D.6495;
  int D.6496;
  long unsigned int D.6502;
  long unsigned int D.6503;
  sizetype my_current.66;
  sizetype D.6505;
  sizetype D.6506;
  GC_word * D.6507;
  long unsigned int my_current.67;
  long unsigned int D.6509;
  long unsigned int D.6510;
  long unsigned int D.6511;
  long unsigned int D.6512;
  long unsigned int D.6516;
  long unsigned int D.6517;
  long unsigned int D.6519;
  long unsigned int my_hhdr.68;
  long int my_current.69;
  int D.6525;
  map_entry_type * D.6526;
  sizetype D.6527;
  map_entry_type * D.6528;
  unsigned char D.6529;
  long unsigned int D.6534;
  long unsigned int D.6535;
  long unsigned int D.6536;
  long unsigned int D.6537;
  word[8] * D.6548;
  int D.6549;
  long unsigned int D.6550;
  long unsigned int D.6551;
  int D.6552;
  long unsigned int D.6553;
  long unsigned int D.6555;
  int D.6556;
  long unsigned int D.6562;
  long unsigned int D.6563;
  sizetype my_current.70;
  sizetype D.6565;
  sizetype D.6566;
  GC_word * D.6567;
  long int mark_stack_top.71;
  long int mark_stack.72;
  long int D.6570;
  long int D.6571;
  long int D.6572;
  struct mse * D.6573;
  int credit;
  register word * current_p;
  register word current;
  register word * limit;
  register word descr;
  register char * greatest_ha;
  register char * least_ha;
  struct hdr_cache_entry hdr_cache[8];
  void retry = <<< error >>>;
  void exit1 = <<< error >>>;
  void next_object = <<< error >>>;
  void exit2 = <<< error >>>;
  void exit4 = <<< error >>>;

  try
    {
      credit = 4096;
      greatest_ha = GC_greatest_plausible_heap_addr;
      least_ha = GC_least_plausible_heap_addr;
      GC_objects_are_marked = 1;
      memset (&hdr_cache, 0, 128);
      goto <D.5774>;
      <D.5825>:
      current_p = mark_stack_top->mse_start;
      descr = mark_stack_top->mse_descr;
      retry:
      D.6322 = descr & 18446744073709550595;
      if (D.6322 != 0) goto <D.6323>; else goto <D.6324>;
      <D.6323>:
      {
        word tag;

        tag = descr & 3;
        switch (tag) <default: <D.6428>, case 0: <D.5747>, case 1: <D.5750>, case 2: <D.5775>, case 3: <D.5776>>
        <D.5747>:
        if (descr > 2048) goto <D.6325>; else goto <D.6326>;
        <D.6325>:
        GC_parallel.50 = GC_parallel;
        if (GC_parallel.50 != 0) goto <D.6328>; else goto <D.6329>;
        <D.6328>:
        D.6330 = mark_stack_limit + 18446744073709551600;
        if (D.6330 > mark_stack_top) goto <D.6331>; else goto <D.6332>;
        <D.6331>:
        {
          int new_size;

          D.6333 = descr / 2;
          D.6334 = (int) D.6333;
          new_size = D.6334 & -8;
          mark_stack_top->mse_start = current_p;
          D.6335 = (long unsigned int) new_size;
          D.6336 = D.6335 + 8;
          mark_stack_top->mse_descr = D.6336;
          mark_stack_top = mark_stack_top + 16;
          D.6337 = (sizetype) new_size;
          current_p = current_p + D.6337;
          D.6338 = (long unsigned int) new_size;
          descr = descr - D.6338;
          goto retry;
        }
        <D.6332>:
        <D.6329>:
        <D.6326>:
        limit = current_p + 1016;
        mark_stack_top->mse_start = limit;
        D.6339 = descr + 18446744073709550600;
        mark_stack_top->mse_descr = D.6339;
        limit = limit;
        goto <D.5749>;
        <D.5750>:
        mark_stack_top = mark_stack_top + 18446744073709551600;
        descr = descr & 18446744073709551612;
        credit.51 = (unsigned int) credit;
        D.6341 = credit.51 + 4294967040;
        credit = (int) D.6341;
        goto <D.5772>;
        <D.5771>:
        descr.52 = (long int) descr;
        if (descr.52 < 0) goto <D.6343>; else goto <D.6344>;
        <D.6343>:
        current = *current_p;
        current.53 = (char *) current;
        if (current.53 >= least_ha) goto <D.6346>; else goto <D.6347>;
        <D.6346>:
        current.53 = (char *) current;
        if (current.53 < greatest_ha) goto <D.6348>; else goto <D.6349>;
        <D.6348>:
        {
          struct hdr * my_hhdr;
          char * my_current;

          my_current = (char *) current;
          {
            struct hdr_cache_entry * hce;

            my_current.54 = (long unsigned int) my_current;
            D.6351 = my_current.54 >> 12;
            D.6352 = D.6351 & 7;
            D.6353 = D.6352 * 16;
            hce = &hdr_cache + D.6353;
            D.6354 = hce->block_addr;
            my_current.54 = (long unsigned int) my_current;
            D.6351 = my_current.54 >> 12;
            if (D.6354 == D.6351) goto <D.6355>; else goto <D.6356>;
            <D.6355>:
            my_hhdr = hce->hce_hdr;
            goto <D.6357>;
            <D.6356>:
            {
              register struct hdr * * _ha;

              {
                register struct bottom_index * bi;

                {
                  register word hi;
                  register struct bottom_index * _bi;

                  my_current.54 = (long unsigned int) my_current;
                  hi = my_current.54 >> 22;
                  D.6358 = hi & 2047;
                  _bi = GC_arrays._top_index[D.6358];
                  goto <D.5759>;
                  <D.5758>:
                  _bi = _bi->hash_link;
                  <D.5759>:
                  D.6359 = _bi->key;
                  if (D.6359 != hi) goto <D.6360>; else goto <D.5760>;
                  <D.6360>:
                  D.6361 = GC_arrays._all_nils;
                  if (D.6361 != _bi) goto <D.5758>; else goto <D.5760>;
                  <D.5760>:
                  bi = _bi;
                }
                my_current.54 = (long unsigned int) my_current;
                D.6351 = my_current.54 >> 12;
                D.6362 = D.6351 & 1023;
                _ha = &bi->index[D.6362];
              }
              my_hhdr = *_ha;
            }
            my_hhdr.55 = (long unsigned int) my_hhdr;
            if (my_hhdr.55 <= 4095) goto <D.6364>; else goto <D.6365>;
            <D.6364>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.56 = GC_invalid_header;
                  new_hdr = GC_invalid_header.56;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6367>;
            <D.6365>:
            my_current.54 = (long unsigned int) my_current;
            D.6351 = my_current.54 >> 12;
            hce->block_addr = D.6351;
            hce->hce_hdr = my_hhdr;
            <D.6367>:
            <D.6357>:
          }
          {
            int displ;
            int map_entry;

            my_current.57 = (long int) my_current;
            D.6369 = (int) my_current.57;
            displ = D.6369 & 4095;
            D.6370 = my_hhdr->hb_map;
            D.6371 = (sizetype) displ;
            D.6372 = D.6370 + D.6371;
            D.6373 = *D.6372;
            map_entry = (int) D.6373;
            displ = displ >> 3;
            if (map_entry > 253) goto <D.6374>; else goto <D.6375>;
            <D.6374>:
            if (map_entry == 254) goto <D.6376>; else goto <D.6377>;
            <D.6376>:
            D.6378 = (long unsigned int) displ;
            D.6379 = my_hhdr->hb_sz;
            D.6380 = D.6378 % D.6379;
            map_entry = (int) D.6380;
            displ = displ - map_entry;
            D.6378 = (long unsigned int) displ;
            D.6379 = my_hhdr->hb_sz;
            D.6381 = D.6378 + D.6379;
            if (D.6381 > 512) goto <D.6382>; else goto <D.6383>;
            <D.6382>:
            GC_all_interior_pointers.58 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.58 != 0) goto <D.6385>; else goto <D.6386>;
            <D.6385>:
            my_current.54 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.54);
            goto <D.6387>;
            <D.6386>:
            my_current.54 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.54);
            <D.6387>:
            goto exit1;
            <D.6383>:
            goto <D.6388>;
            <D.6377>:
            GC_all_interior_pointers.58 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.58 != 0) goto <D.6389>; else goto <D.6390>;
            <D.6389>:
            my_current.54 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.54);
            goto <D.6391>;
            <D.6390>:
            my_current.54 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.54);
            <D.6391>:
            goto exit1;
            <D.6388>:
            goto <D.6392>;
            <D.6375>:
            displ = displ - map_entry;
            <D.6392>:
            {
              register word * mark_word_addr;

              D.6393 = &my_hhdr->hb_marks;
              D.6394 = displ >> 6;
              D.6395 = (long unsigned int) D.6394;
              D.6396 = D.6395 * 8;
              mark_word_addr = D.6393 + D.6396;
              {
                word old;
                word my_bits;

                D.6397 = displ & 63;
                my_bits = 1 << D.6397;
                <D.5768>:
                old = MEM[(volatile word *)mark_word_addr];
                D.6398 = old & my_bits;
                if (D.6398 != 0) goto exit1; else goto <D.6399>;
                <D.6399>:
                D.6400 = old | my_bits;
                D.6401 = GC_compare_and_exchange (mark_word_addr, old, D.6400);
                if (D.6401 == 0) goto <D.5768>; else goto <D.5769>;
                <D.5769>:
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6402>; else goto <D.6403>;
              <D.6402>:
              goto <D.6404>;
              <D.6403>:
              mark_stack_top = mark_stack_top + 16;
              if (mark_stack_top >= mark_stack_limit) goto <D.6405>; else goto <D.6406>;
              <D.6405>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6406>:
              D.6407 = (long unsigned int) displ;
              D.6408 = D.6407 * 8;
              my_current.59 = (sizetype) my_current;
              D.6410 = my_current.59 & 18446744073709547520;
              D.6411 = D.6408 + D.6410;
              D.6412 = (GC_word *) D.6411;
              mark_stack_top->mse_start = D.6412;
              mark_stack_top->mse_descr = _descr;
              <D.6404>:
            }
          }
          exit1:
        }
        <D.6349>:
        <D.6347>:
        <D.6344>:
        descr = descr << 1;
        current_p = current_p + 8;
        <D.5772>:
        if (descr != 0) goto <D.5771>; else goto <D.5773>;
        <D.5773>:
        // predicted unlikely by continue predictor.
        goto <D.5774>;
        <D.5775>:
        mark_stack_top = mark_stack_top + 18446744073709551600;
        credit = credit + -100;
        D.6413 = descr >> 2;
        D.6414 = D.6413 & 63;
        D.6415 = GC_arrays._mark_procs[D.6414];
        D.6416 = descr >> 8;
        mark_stack_top = D.6415 (current_p, mark_stack_top, mark_stack_limit, D.6416);
        // predicted unlikely by continue predictor.
        goto <D.5774>;
        <D.5776>:
        descr.52 = (long int) descr;
        if (descr.52 >= 0) goto <D.6417>; else goto <D.6418>;
        <D.6417>:
        D.6419 = descr + 18446744073709551613;
        D.6420 = current_p + D.6419;
        descr = *D.6420;
        goto <D.6421>;
        <D.6418>:
        {
          char * type_descr;

          type_descr = MEM[(char * *)current_p];
          if (type_descr == 0B) goto <D.6422>; else goto <D.6423>;
          <D.6422>:
          mark_stack_top = mark_stack_top + 18446744073709551600;
          // predicted unlikely by continue predictor.
          goto <D.5774>;
          <D.6423>:
          D.6424 = 18446744073709551603 - descr;
          D.6425 = type_descr + D.6424;
          descr = MEM[(word *)D.6425];
        }
        <D.6421>:
        if (descr == 0) goto <D.6426>; else goto <D.6427>;
        <D.6426>:
        mark_stack_top = mark_stack_top + 18446744073709551600;
        // predicted unlikely by continue predictor.
        goto <D.5774>;
        <D.6427>:
        goto retry;
        <D.6428>:
        <D.5749>:
      }
      goto <D.6429>;
      <D.6324>:
      mark_stack_top = mark_stack_top + 18446744073709551600;
      limit = current_p + descr;
      <D.6429>:
      credit.51 = (unsigned int) credit;
      limit.60 = (long int) limit;
      current_p.61 = (long int) current_p;
      D.6432 = limit.60 - current_p.61;
      D.6433 = (unsigned int) D.6432;
      D.6434 = credit.51 - D.6433;
      credit = (int) D.6434;
      limit = limit + 18446744073709551608;
      {
        word deferred;

        <D.5781>:
        deferred = *limit;
        limit = limit + 18446744073709551608;
        deferred.62 = (char *) deferred;
        if (deferred.62 >= least_ha) goto <D.6436>; else goto <D.6437>;
        <D.6436>:
        deferred.62 = (char *) deferred;
        if (deferred.62 < greatest_ha) goto <D.5779>; else goto <D.6438>;
        <D.6438>:
        <D.6437>:
        if (current_p > limit) goto next_object; else goto <D.6439>;
        <D.6439>:
        deferred = *limit;
        limit = limit + 18446744073709551608;
        deferred.62 = (char *) deferred;
        if (deferred.62 >= least_ha) goto <D.6440>; else goto <D.6441>;
        <D.6440>:
        deferred.62 = (char *) deferred;
        if (deferred.62 < greatest_ha) goto <D.5779>; else goto <D.6442>;
        <D.6442>:
        <D.6441>:
        if (current_p > limit) goto next_object; else goto <D.6443>;
        <D.6443>:
        goto <D.5781>;
        <D.5779>:
        goto <D.5803>;
        <D.5802>:
        current = *current_p;
        current.53 = (char *) current;
        if (current.53 >= least_ha) goto <D.6444>; else goto <D.6445>;
        <D.6444>:
        current.53 = (char *) current;
        if (current.53 < greatest_ha) goto <D.6446>; else goto <D.6447>;
        <D.6446>:
        {
          struct hdr * my_hhdr;
          char * my_current;

          my_current = (char *) current;
          {
            struct hdr_cache_entry * hce;

            my_current.63 = (long unsigned int) my_current;
            D.6449 = my_current.63 >> 12;
            D.6450 = D.6449 & 7;
            D.6451 = D.6450 * 16;
            hce = &hdr_cache + D.6451;
            D.6452 = hce->block_addr;
            my_current.63 = (long unsigned int) my_current;
            D.6449 = my_current.63 >> 12;
            if (D.6452 == D.6449) goto <D.6453>; else goto <D.6454>;
            <D.6453>:
            my_hhdr = hce->hce_hdr;
            goto <D.6455>;
            <D.6454>:
            {
              register struct hdr * * _ha;

              {
                register struct bottom_index * bi;

                {
                  register word hi;
                  register struct bottom_index * _bi;

                  my_current.63 = (long unsigned int) my_current;
                  hi = my_current.63 >> 22;
                  D.6456 = hi & 2047;
                  _bi = GC_arrays._top_index[D.6456];
                  goto <D.5790>;
                  <D.5789>:
                  _bi = _bi->hash_link;
                  <D.5790>:
                  D.6457 = _bi->key;
                  if (D.6457 != hi) goto <D.6458>; else goto <D.5791>;
                  <D.6458>:
                  D.6361 = GC_arrays._all_nils;
                  if (D.6361 != _bi) goto <D.5789>; else goto <D.5791>;
                  <D.5791>:
                  bi = _bi;
                }
                my_current.63 = (long unsigned int) my_current;
                D.6449 = my_current.63 >> 12;
                D.6459 = D.6449 & 1023;
                _ha = &bi->index[D.6459];
              }
              my_hhdr = *_ha;
            }
            my_hhdr.64 = (long unsigned int) my_hhdr;
            if (my_hhdr.64 <= 4095) goto <D.6461>; else goto <D.6462>;
            <D.6461>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.56 = GC_invalid_header;
                  new_hdr = GC_invalid_header.56;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6463>;
            <D.6462>:
            my_current.63 = (long unsigned int) my_current;
            D.6449 = my_current.63 >> 12;
            hce->block_addr = D.6449;
            hce->hce_hdr = my_hhdr;
            <D.6463>:
            <D.6455>:
          }
          {
            int displ;
            int map_entry;

            my_current.65 = (long int) my_current;
            D.6465 = (int) my_current.65;
            displ = D.6465 & 4095;
            D.6466 = my_hhdr->hb_map;
            D.6467 = (sizetype) displ;
            D.6468 = D.6466 + D.6467;
            D.6469 = *D.6468;
            map_entry = (int) D.6469;
            displ = displ >> 3;
            if (map_entry > 253) goto <D.6470>; else goto <D.6471>;
            <D.6470>:
            if (map_entry == 254) goto <D.6472>; else goto <D.6473>;
            <D.6472>:
            D.6474 = (long unsigned int) displ;
            D.6475 = my_hhdr->hb_sz;
            D.6476 = D.6474 % D.6475;
            map_entry = (int) D.6476;
            displ = displ - map_entry;
            D.6474 = (long unsigned int) displ;
            D.6475 = my_hhdr->hb_sz;
            D.6477 = D.6474 + D.6475;
            if (D.6477 > 512) goto <D.6478>; else goto <D.6479>;
            <D.6478>:
            GC_all_interior_pointers.58 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.58 != 0) goto <D.6480>; else goto <D.6481>;
            <D.6480>:
            my_current.63 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.63);
            goto <D.6482>;
            <D.6481>:
            my_current.63 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.63);
            <D.6482>:
            goto exit2;
            <D.6479>:
            goto <D.6483>;
            <D.6473>:
            GC_all_interior_pointers.58 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.58 != 0) goto <D.6484>; else goto <D.6485>;
            <D.6484>:
            my_current.63 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.63);
            goto <D.6486>;
            <D.6485>:
            my_current.63 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.63);
            <D.6486>:
            goto exit2;
            <D.6483>:
            goto <D.6487>;
            <D.6471>:
            displ = displ - map_entry;
            <D.6487>:
            {
              register word * mark_word_addr;

              D.6488 = &my_hhdr->hb_marks;
              D.6489 = displ >> 6;
              D.6490 = (long unsigned int) D.6489;
              D.6491 = D.6490 * 8;
              mark_word_addr = D.6488 + D.6491;
              {
                word old;
                word my_bits;

                D.6492 = displ & 63;
                my_bits = 1 << D.6492;
                <D.5799>:
                old = MEM[(volatile word *)mark_word_addr];
                D.6493 = old & my_bits;
                if (D.6493 != 0) goto exit2; else goto <D.6494>;
                <D.6494>:
                D.6495 = old | my_bits;
                D.6496 = GC_compare_and_exchange (mark_word_addr, old, D.6495);
                if (D.6496 == 0) goto <D.5799>; else goto <D.5800>;
                <D.5800>:
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6497>; else goto <D.6498>;
              <D.6497>:
              goto <D.6499>;
              <D.6498>:
              mark_stack_top = mark_stack_top + 16;
              if (mark_stack_top >= mark_stack_limit) goto <D.6500>; else goto <D.6501>;
              <D.6500>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6501>:
              D.6502 = (long unsigned int) displ;
              D.6503 = D.6502 * 8;
              my_current.66 = (sizetype) my_current;
              D.6505 = my_current.66 & 18446744073709547520;
              D.6506 = D.6503 + D.6505;
              D.6507 = (GC_word *) D.6506;
              mark_stack_top->mse_start = D.6507;
              mark_stack_top->mse_descr = _descr;
              <D.6499>:
            }
          }
          exit2:
        }
        <D.6447>:
        <D.6445>:
        current_p = current_p + 8;
        <D.5803>:
        if (current_p <= limit) goto <D.5802>; else goto <D.5804>;
        <D.5804>:
        {
          struct hdr * my_hhdr;
          char * my_current;

          my_current = (char *) deferred;
          {
            struct hdr_cache_entry * hce;

            my_current.67 = (long unsigned int) my_current;
            D.6509 = my_current.67 >> 12;
            D.6510 = D.6509 & 7;
            D.6511 = D.6510 * 16;
            hce = &hdr_cache + D.6511;
            D.6512 = hce->block_addr;
            my_current.67 = (long unsigned int) my_current;
            D.6509 = my_current.67 >> 12;
            if (D.6512 == D.6509) goto <D.6513>; else goto <D.6514>;
            <D.6513>:
            my_hhdr = hce->hce_hdr;
            goto <D.6515>;
            <D.6514>:
            {
              register struct hdr * * _ha;

              {
                register struct bottom_index * bi;

                {
                  register word hi;
                  register struct bottom_index * _bi;

                  my_current.67 = (long unsigned int) my_current;
                  hi = my_current.67 >> 22;
                  D.6516 = hi & 2047;
                  _bi = GC_arrays._top_index[D.6516];
                  goto <D.5813>;
                  <D.5812>:
                  _bi = _bi->hash_link;
                  <D.5813>:
                  D.6517 = _bi->key;
                  if (D.6517 != hi) goto <D.6518>; else goto <D.5814>;
                  <D.6518>:
                  D.6361 = GC_arrays._all_nils;
                  if (D.6361 != _bi) goto <D.5812>; else goto <D.5814>;
                  <D.5814>:
                  bi = _bi;
                }
                my_current.67 = (long unsigned int) my_current;
                D.6509 = my_current.67 >> 12;
                D.6519 = D.6509 & 1023;
                _ha = &bi->index[D.6519];
              }
              my_hhdr = *_ha;
            }
            my_hhdr.68 = (long unsigned int) my_hhdr;
            if (my_hhdr.68 <= 4095) goto <D.6521>; else goto <D.6522>;
            <D.6521>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.56 = GC_invalid_header;
                  new_hdr = GC_invalid_header.56;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6523>;
            <D.6522>:
            my_current.67 = (long unsigned int) my_current;
            D.6509 = my_current.67 >> 12;
            hce->block_addr = D.6509;
            hce->hce_hdr = my_hhdr;
            <D.6523>:
            <D.6515>:
          }
          {
            int displ;
            int map_entry;

            my_current.69 = (long int) my_current;
            D.6525 = (int) my_current.69;
            displ = D.6525 & 4095;
            D.6526 = my_hhdr->hb_map;
            D.6527 = (sizetype) displ;
            D.6528 = D.6526 + D.6527;
            D.6529 = *D.6528;
            map_entry = (int) D.6529;
            displ = displ >> 3;
            if (map_entry > 253) goto <D.6530>; else goto <D.6531>;
            <D.6530>:
            if (map_entry == 254) goto <D.6532>; else goto <D.6533>;
            <D.6532>:
            D.6534 = (long unsigned int) displ;
            D.6535 = my_hhdr->hb_sz;
            D.6536 = D.6534 % D.6535;
            map_entry = (int) D.6536;
            displ = displ - map_entry;
            D.6534 = (long unsigned int) displ;
            D.6535 = my_hhdr->hb_sz;
            D.6537 = D.6534 + D.6535;
            if (D.6537 > 512) goto <D.6538>; else goto <D.6539>;
            <D.6538>:
            GC_all_interior_pointers.58 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.58 != 0) goto <D.6540>; else goto <D.6541>;
            <D.6540>:
            my_current.67 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.67);
            goto <D.6542>;
            <D.6541>:
            my_current.67 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.67);
            <D.6542>:
            goto exit4;
            <D.6539>:
            goto <D.6543>;
            <D.6533>:
            GC_all_interior_pointers.58 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.58 != 0) goto <D.6544>; else goto <D.6545>;
            <D.6544>:
            my_current.67 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.67);
            goto <D.6546>;
            <D.6545>:
            my_current.67 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.67);
            <D.6546>:
            goto exit4;
            <D.6543>:
            goto <D.6547>;
            <D.6531>:
            displ = displ - map_entry;
            <D.6547>:
            {
              register word * mark_word_addr;

              D.6548 = &my_hhdr->hb_marks;
              D.6549 = displ >> 6;
              D.6550 = (long unsigned int) D.6549;
              D.6551 = D.6550 * 8;
              mark_word_addr = D.6548 + D.6551;
              {
                word old;
                word my_bits;

                D.6552 = displ & 63;
                my_bits = 1 << D.6552;
                <D.5822>:
                old = MEM[(volatile word *)mark_word_addr];
                D.6553 = old & my_bits;
                if (D.6553 != 0) goto exit4; else goto <D.6554>;
                <D.6554>:
                D.6555 = old | my_bits;
                D.6556 = GC_compare_and_exchange (mark_word_addr, old, D.6555);
                if (D.6556 == 0) goto <D.5822>; else goto <D.5823>;
                <D.5823>:
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6557>; else goto <D.6558>;
              <D.6557>:
              goto <D.6559>;
              <D.6558>:
              mark_stack_top = mark_stack_top + 16;
              if (mark_stack_top >= mark_stack_limit) goto <D.6560>; else goto <D.6561>;
              <D.6560>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6561>:
              D.6562 = (long unsigned int) displ;
              D.6563 = D.6562 * 8;
              my_current.70 = (sizetype) my_current;
              D.6565 = my_current.70 & 18446744073709547520;
              D.6566 = D.6563 + D.6565;
              D.6567 = (GC_word *) D.6566;
              mark_stack_top->mse_start = D.6567;
              mark_stack_top->mse_descr = _descr;
              <D.6559>:
            }
          }
          exit4:
        }
        next_object:
      }
      <D.5774>:
      mark_stack_top.71 = (long int) mark_stack_top;
      mark_stack.72 = (long int) mark_stack;
      D.6570 = mark_stack_top.71 - mark_stack.72;
      D.6571 = (long int) credit;
      D.6572 = D.6570 | D.6571;
      if (D.6572 >= 0) goto <D.5825>; else goto <D.5826>;
      <D.5826>:
      D.6573 = mark_stack_top;
      return D.6573;
    }
  finally
    {
      hdr_cache = {CLOBBER};
    }
}


GC_steal_mark_stack (struct mse * low, struct mse * high, struct mse * local, unsigned int max, struct mse * * next)
{
  GC_word * D.6579;
  GC_word * D.6580;
  long unsigned int D.6581;
  long unsigned int D.6584;
  unsigned int D.6585;
  struct mse * D.6587;
  struct mse * p;
  struct mse * top;
  unsigned int i;

  top = local + 18446744073709551600;
  i = 0;
  p = low;
  goto <D.5844>;
  <D.5843>:
  {
    word descr;

    descr = p->mse_descr;
    if (descr != 0) goto <D.6577>; else goto <D.6578>;
    <D.6577>:
    D.6579 = &p->mse_descr;
    MEM[(volatile word *)D.6579] = 0;
    top = top + 16;
    top->mse_descr = descr;
    D.6580 = p->mse_start;
    top->mse_start = D.6580;
    i = i + 1;
    D.6581 = descr & 3;
    if (D.6581 == 0) goto <D.6582>; else goto <D.6583>;
    <D.6582>:
    D.6584 = descr >> 8;
    D.6585 = (unsigned int) D.6584;
    i = D.6585 + i;
    <D.6583>:
    <D.6578>:
  }
  p = p + 16;
  <D.5844>:
  if (p <= high) goto <D.6586>; else goto <D.5845>;
  <D.6586>:
  if (i <= max) goto <D.5843>; else goto <D.5845>;
  <D.5845>:
  *next = p;
  D.6587 = top;
  return D.6587;
}


GC_return_mark_stack (struct mse * low, struct mse * high)
{
  long int high.73;
  long int low.74;
  long int D.6593;
  long int D.6594;
  long int D.6595;
  long int my_start.75;
  struct mse * GC_mark_stack.76;
  long int GC_mark_stack.77;
  long int D.6599;
  long int D.6600;
  long unsigned int D.6601;
  long unsigned int D.6602;
  long unsigned int GC_mark_stack_size.78;
  int GC_print_stats.79;
  long unsigned int D.6610;
  long unsigned int D.6611;
  struct mse * D.6612;
  struct mse * my_top;
  struct mse * my_start;
  size_t stack_size;

  if (high < low) goto <D.6589>; else goto <D.6590>;
  <D.6589>:
  return;
  <D.6590>:
  high.73 = (long int) high;
  low.74 = (long int) low;
  D.6593 = high.73 - low.74;
  D.6594 = D.6593 /[ex] 16;
  D.6595 = D.6594 + 1;
  stack_size = (size_t) D.6595;
  GC_acquire_mark_lock ();
  my_top = GC_mark_stack_top;
  my_start = my_top + 16;
  my_start.75 = (long int) my_start;
  GC_mark_stack.76 = GC_mark_stack;
  GC_mark_stack.77 = (long int) GC_mark_stack.76;
  D.6599 = my_start.75 - GC_mark_stack.77;
  D.6600 = D.6599 /[ex] 16;
  D.6601 = (long unsigned int) D.6600;
  D.6602 = D.6601 + stack_size;
  GC_mark_stack_size.78 = GC_mark_stack_size;
  if (D.6602 > GC_mark_stack_size.78) goto <D.6604>; else goto <D.6605>;
  <D.6604>:
  GC_print_stats.79 = GC_print_stats;
  if (GC_print_stats.79 != 0) goto <D.6607>; else goto <D.6608>;
  <D.6607>:
  GC_printf ("No room to copy back mark stack.", 0, 0, 0, 0, 0, 0);
  <D.6608>:
  GC_mark_state = 5;
  GC_mark_stack_too_small = 1;
  goto <D.6609>;
  <D.6605>:
  D.6610 = stack_size * 16;
  memcpy (my_start, low, D.6610);
  D.6611 = stack_size * 16;
  D.6612 = my_top + D.6611;
  GC_mark_stack_top = D.6612;
  <D.6609>:
  GC_release_mark_lock ();
  GC_notify_all_marker ();
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.6614;
  long unsigned int D.6615;

  D.6615 = __builtin_object_size (__dest, 0);
  D.6614 = __builtin___memcpy_chk (__dest, __src, __len, D.6615);
  return D.6614;
}


GC_do_local_mark (struct mse * local_mark_stack, struct mse * local_top)
{
  struct mse * D.6617;
  long int local_top.80;
  long int local_mark_stack.81;
  long int D.6622;
  long int D.6623;
  long unsigned int D.6624;
  struct mse * GC_mark_stack_top.82;
  struct mse * GC_first_nonempty.83;
  unsigned int GC_active_count.84;
  unsigned int GC_helper_count.85;
  struct mse * D.6635;
  long int D.6638;
  long unsigned int D.6639;
  long unsigned int D.6640;
  struct mse * D.6641;
  long int new_bottom.86;
  long int D.6643;
  long int D.6644;
  long int D.6645;
  long unsigned int D.6646;
  long unsigned int D.6647;
  long int D.6648;
  sizetype D.6649;
  sizetype D.6650;
  unsigned int n;

  <D.5863>:
  n = 0;
  goto <D.5859>;
  <D.5858>:
  D.6617 = local_mark_stack + 65536;
  local_top = GC_mark_from (local_top, local_mark_stack, D.6617);
  if (local_top < local_mark_stack) goto <D.6618>; else goto <D.6619>;
  <D.6618>:
  return;
  <D.6619>:
  local_top.80 = (long int) local_top;
  local_mark_stack.81 = (long int) local_mark_stack;
  D.6622 = local_top.80 - local_mark_stack.81;
  D.6623 = D.6622 /[ex] 16;
  D.6624 = (long unsigned int) D.6623;
  if (D.6624 > 2047) goto <D.6625>; else goto <D.6626>;
  <D.6625>:
  GC_return_mark_stack (local_mark_stack, local_top);
  return;
  <D.6626>:
  n = n + 1;
  <D.5859>:
  if (n == 0) goto <D.5858>; else goto <D.5860>;
  <D.5860>:
  GC_mark_stack_top.82 = GC_mark_stack_top;
  GC_first_nonempty.83 = GC_first_nonempty;
  if (GC_mark_stack_top.82 < GC_first_nonempty.83) goto <D.6629>; else goto <D.6630>;
  <D.6629>:
  GC_active_count.84 = GC_active_count;
  GC_helper_count.85 = GC_helper_count;
  if (GC_active_count.84 < GC_helper_count.85) goto <D.6633>; else goto <D.6634>;
  <D.6633>:
  D.6635 = local_mark_stack + 16;
  if (D.6635 < local_top) goto <D.6636>; else goto <D.6637>;
  <D.6636>:
  {
    struct mse * p;
    struct mse * new_bottom;

    local_top.80 = (long int) local_top;
    local_mark_stack.81 = (long int) local_mark_stack;
    D.6622 = local_top.80 - local_mark_stack.81;
    D.6623 = D.6622 /[ex] 16;
    D.6638 = D.6623 / 2;
    D.6639 = (long unsigned int) D.6638;
    D.6640 = D.6639 * 16;
    new_bottom = local_mark_stack + D.6640;
    D.6641 = new_bottom + 18446744073709551600;
    GC_return_mark_stack (local_mark_stack, D.6641);
    local_top.80 = (long int) local_top;
    new_bottom.86 = (long int) new_bottom;
    D.6643 = local_top.80 - new_bottom.86;
    D.6644 = D.6643 /[ex] 16;
    D.6645 = D.6644 + 1;
    D.6646 = (long unsigned int) D.6645;
    D.6647 = D.6646 * 16;
    memmove (local_mark_stack, new_bottom, D.6647);
    new_bottom.86 = (long int) new_bottom;
    local_mark_stack.81 = (long int) local_mark_stack;
    D.6648 = new_bottom.86 - local_mark_stack.81;
    D.6649 = (sizetype) D.6648;
    D.6650 = -D.6649;
    local_top = local_top + D.6650;
  }
  <D.6637>:
  <D.6634>:
  <D.6630>:
  goto <D.5863>;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.6652;
  long unsigned int D.6653;

  D.6653 = __builtin_object_size (__dest, 0);
  D.6652 = __builtin___memmove_chk (__dest, __src, __len, D.6653);
  return D.6652;
}


GC_mark_local (struct mse * local_mark_stack, int id)
{
  unsigned int GC_active_count.87;
  unsigned int D.6656;
  struct mse * GC_first_nonempty.88;
  struct mse * my_first_nonempty.89;
  long unsigned int global_first_nonempty.90;
  long unsigned int my_first_nonempty.91;
  long int my_top.92;
  long int my_first_nonempty.93;
  long int D.6668;
  long int D.6669;
  long int D.6670;
  unsigned int D.6675;
  struct mse * GC_first_nonempty.94;
  struct mse * GC_mark_stack_top.95;
  struct mse * GC_first_nonempty.96;
  struct mse * GC_mark_stack_top.97;
  unsigned int GC_helper_count.98;
  unsigned int D.6688;
  unsigned int D.6695;
  struct mse * my_first_nonempty;

  try
    {
      GC_acquire_mark_lock ();
      GC_active_count.87 = GC_active_count;
      D.6656 = GC_active_count.87 + 1;
      GC_active_count = D.6656;
      GC_first_nonempty.88 = GC_first_nonempty;
      my_first_nonempty = GC_first_nonempty.88;
      GC_release_mark_lock ();
      <D.5881>:
      {
        size_t n_on_stack;
        size_t n_to_get;
        struct mse * next;
        struct mse * my_top;
        struct mse * local_top;
        struct mse * global_first_nonempty;

        global_first_nonempty = GC_first_nonempty;
        my_first_nonempty.89 = my_first_nonempty;
        if (my_first_nonempty.89 < global_first_nonempty) goto <D.6659>; else goto <D.6660>;
        <D.6659>:
        my_first_nonempty = global_first_nonempty;
        goto <D.6661>;
        <D.6660>:
        my_first_nonempty.89 = my_first_nonempty;
        if (global_first_nonempty < my_first_nonempty.89) goto <D.6662>; else goto <D.6663>;
        <D.6662>:
        global_first_nonempty.90 = (long unsigned int) global_first_nonempty;
        my_first_nonempty.89 = my_first_nonempty;
        my_first_nonempty.91 = (long unsigned int) my_first_nonempty.89;
        GC_compare_and_exchange (&GC_first_nonempty, global_first_nonempty.90, my_first_nonempty.91);
        <D.6663>:
        <D.6661>:
        my_top = GC_mark_stack_top;
        my_top.92 = (long int) my_top;
        my_first_nonempty.89 = my_first_nonempty;
        my_first_nonempty.93 = (long int) my_first_nonempty.89;
        D.6668 = my_top.92 - my_first_nonempty.93;
        D.6669 = D.6668 /[ex] 16;
        D.6670 = D.6669 + 1;
        n_on_stack = (size_t) D.6670;
        if (n_on_stack == 0) goto <D.6671>; else goto <D.6672>;
        <D.6671>:
        GC_acquire_mark_lock ();
        my_top = GC_mark_stack_top;
        my_top.92 = (long int) my_top;
        my_first_nonempty.89 = my_first_nonempty;
        my_first_nonempty.93 = (long int) my_first_nonempty.89;
        D.6668 = my_top.92 - my_first_nonempty.93;
        D.6669 = D.6668 /[ex] 16;
        D.6670 = D.6669 + 1;
        n_on_stack = (size_t) D.6670;
        if (n_on_stack == 0) goto <D.6673>; else goto <D.6674>;
        <D.6673>:
        GC_active_count.87 = GC_active_count;
        D.6675 = GC_active_count.87 + 4294967295;
        GC_active_count = D.6675;
        GC_active_count.87 = GC_active_count;
        if (GC_active_count.87 == 0) goto <D.6676>; else goto <D.6677>;
        <D.6676>:
        GC_notify_all_marker ();
        <D.6677>:
        goto <D.5877>;
        <D.5876>:
        GC_wait_marker ();
        <D.5877>:
        GC_active_count.87 = GC_active_count;
        if (GC_active_count.87 != 0) goto <D.6678>; else goto <D.5878>;
        <D.6678>:
        GC_first_nonempty.94 = GC_first_nonempty;
        GC_mark_stack_top.95 = GC_mark_stack_top;
        if (GC_first_nonempty.94 > GC_mark_stack_top.95) goto <D.5876>; else goto <D.5878>;
        <D.5878>:
        GC_active_count.87 = GC_active_count;
        if (GC_active_count.87 == 0) goto <D.6681>; else goto <D.6682>;
        <D.6681>:
        GC_first_nonempty.96 = GC_first_nonempty;
        GC_mark_stack_top.97 = GC_mark_stack_top;
        if (GC_first_nonempty.96 > GC_mark_stack_top.97) goto <D.6685>; else goto <D.6686>;
        <D.6685>:
        {
          GC_bool need_to_notify;

          need_to_notify = 0;
          GC_helper_count.98 = GC_helper_count;
          D.6688 = GC_helper_count.98 + 4294967295;
          GC_helper_count = D.6688;
          GC_helper_count.98 = GC_helper_count;
          if (GC_helper_count.98 == 0) goto <D.6689>; else goto <D.6690>;
          <D.6689>:
          need_to_notify = 1;
          <D.6690>:
          GC_release_mark_lock ();
          if (need_to_notify != 0) goto <D.6691>; else goto <D.6692>;
          <D.6691>:
          GC_notify_all_marker ();
          <D.6692>:
          return;
        }
        <D.6686>:
        <D.6682>:
        GC_active_count.87 = GC_active_count;
        D.6656 = GC_active_count.87 + 1;
        GC_active_count = D.6656;
        GC_release_mark_lock ();
        // predicted unlikely by continue predictor.
        goto <D.5880>;
        <D.6674>:
        GC_release_mark_lock ();
        <D.6672>:
        n_to_get = 5;
        if (n_on_stack <= 9) goto <D.6693>; else goto <D.6694>;
        <D.6693>:
        n_to_get = 1;
        <D.6694>:
        my_first_nonempty.89 = my_first_nonempty;
        D.6695 = (unsigned int) n_to_get;
        local_top = GC_steal_mark_stack (my_first_nonempty.89, my_top, local_mark_stack, D.6695, &my_first_nonempty);
        GC_do_local_mark (local_mark_stack, local_top);
      }
      <D.5880>:
      goto <D.5881>;
    }
  finally
    {
      my_first_nonempty = {CLOBBER};
    }
}


GC_do_parallel_mark ()
{
  int GC_help_wanted.99;
  unsigned int GC_active_count.100;
  unsigned int GC_helper_count.101;
  struct mse * GC_mark_stack.102;
  long unsigned int GC_mark_no.103;
  long unsigned int D.6707;
  struct mse local_mark_stack[4096];
  struct mse * local_top;
  struct mse * my_top;

  try
    {
      GC_acquire_mark_lock ();
      GC_help_wanted.99 = GC_help_wanted;
      if (GC_help_wanted.99 != 0) goto <D.6698>; else goto <D.6701>;
      <D.6701>:
      GC_active_count.100 = GC_active_count;
      if (GC_active_count.100 != 0) goto <D.6698>; else goto <D.6703>;
      <D.6703>:
      GC_helper_count.101 = GC_helper_count;
      if (GC_helper_count.101 != 0) goto <D.6698>; else goto <D.6699>;
      <D.6698>:
      GC_abort ("Tried to start parallel mark in bad state");
      <D.6699>:
      GC_mark_stack.102 = GC_mark_stack;
      GC_first_nonempty = GC_mark_stack.102;
      GC_active_count = 0;
      GC_helper_count = 1;
      GC_help_wanted = 1;
      GC_release_mark_lock ();
      GC_notify_all_marker ();
      GC_mark_local (&local_mark_stack, 0);
      GC_acquire_mark_lock ();
      GC_help_wanted = 0;
      goto <D.5888>;
      <D.5887>:
      GC_wait_marker ();
      <D.5888>:
      GC_helper_count.101 = GC_helper_count;
      if (GC_helper_count.101 != 0) goto <D.5887>; else goto <D.5889>;
      <D.5889>:
      GC_mark_no.103 = GC_mark_no;
      D.6707 = GC_mark_no.103 + 1;
      GC_mark_no = D.6707;
      GC_release_mark_lock ();
      GC_notify_all_marker ();
    }
  finally
    {
      local_mark_stack = {CLOBBER};
    }
}


GC_help_marker (word my_mark_no)
{
  int GC_parallel.104;
  long unsigned int GC_mark_no.105;
  int GC_help_wanted.106;
  long int D.6718;
  long int GC_markers.107;
  unsigned int D.6720;
  int my_id.108;
  struct mse local_mark_stack[4096];
  unsigned int my_id;
  struct mse * my_first_nonempty;

  try
    {
      GC_parallel.104 = GC_parallel;
      if (GC_parallel.104 == 0) goto <D.6709>; else goto <D.6710>;
      <D.6709>:
      return;
      <D.6710>:
      GC_acquire_mark_lock ();
      goto <D.5897>;
      <D.5896>:
      GC_wait_marker ();
      <D.5897>:
      GC_mark_no.105 = GC_mark_no;
      if (GC_mark_no.105 < my_mark_no) goto <D.5896>; else goto <D.6712>;
      <D.6712>:
      GC_help_wanted.106 = GC_help_wanted;
      if (GC_help_wanted.106 == 0) goto <D.6714>; else goto <D.5898>;
      <D.6714>:
      GC_mark_no.105 = GC_mark_no;
      if (GC_mark_no.105 == my_mark_no) goto <D.5896>; else goto <D.5898>;
      <D.5898>:
      my_id = GC_helper_count;
      GC_mark_no.105 = GC_mark_no;
      if (GC_mark_no.105 != my_mark_no) goto <D.6715>; else goto <D.6717>;
      <D.6717>:
      D.6718 = (long int) my_id;
      GC_markers.107 = GC_markers;
      if (D.6718 >= GC_markers.107) goto <D.6715>; else goto <D.6716>;
      <D.6715>:
      GC_release_mark_lock ();
      return;
      <D.6716>:
      D.6720 = my_id + 1;
      GC_helper_count = D.6720;
      GC_release_mark_lock ();
      my_id.108 = (int) my_id;
      GC_mark_local (&local_mark_stack, my_id.108);
    }
  finally
    {
      local_mark_stack = {CLOBBER};
    }
}


GC_mark_init ()
{
  alloc_mark_stack (4096);
}


GC_push_all (char * bottom, char * top)
{
  long unsigned int bottom.109;
  long unsigned int D.6726;
  long unsigned int D.6727;
  long unsigned int top.110;
  long unsigned int D.6729;
  struct mse * GC_mark_stack_top.111;
  struct mse * D.6734;
  struct mse * GC_mark_stack_top.112;
  struct mse * GC_mark_stack_limit.113;
  long int top.114;
  long int bottom.115;
  long int D.6741;
  struct mse * GC_mark_stack_top.116;
  struct mse * GC_mark_stack_top.117;
  register word length;

  bottom.109 = (long unsigned int) bottom;
  D.6726 = bottom.109 + 7;
  D.6727 = D.6726 & 18446744073709551608;
  bottom = (char *) D.6727;
  top.110 = (long unsigned int) top;
  D.6729 = top.110 & 18446744073709551608;
  top = (char *) D.6729;
  if (top == 0B) goto <D.6730>; else goto <D.6732>;
  <D.6732>:
  if (bottom == top) goto <D.6730>; else goto <D.6731>;
  <D.6730>:
  return;
  <D.6731>:
  GC_mark_stack_top.111 = GC_mark_stack_top;
  D.6734 = GC_mark_stack_top.111 + 16;
  GC_mark_stack_top = D.6734;
  GC_mark_stack_top.112 = GC_mark_stack_top;
  GC_mark_stack_limit.113 = GC_mark_stack_limit;
  if (GC_mark_stack_top.112 >= GC_mark_stack_limit.113) goto <D.6737>; else goto <D.6738>;
  <D.6737>:
  GC_abort ("unexpected mark stack overflow");
  <D.6738>:
  top.114 = (long int) top;
  bottom.115 = (long int) bottom;
  D.6741 = top.114 - bottom.115;
  length = (word) D.6741;
  GC_mark_stack_top.116 = GC_mark_stack_top;
  GC_mark_stack_top.116->mse_start = bottom;
  GC_mark_stack_top.117 = GC_mark_stack_top;
  GC_mark_stack_top.117->mse_descr = length;
}


GC_push_selected (char * bottom, char * top, int (*<T108d>) (struct hblk *) dirty_fn, void (*<T1090>) (char *, char *) push_fn)
{
  long int bottom.118;
  long int D.6746;
  long int D.6747;
  long int top.119;
  long int D.6749;
  char * D.6753;
  long unsigned int D.6754;
  long unsigned int D.6755;
  struct hblk * D.6758;
  int D.6759;
  int D.6762;
  int D.6765;
  struct mse * GC_mark_stack_top.120;
  long int GC_mark_stack_top.121;
  struct mse * GC_mark_stack.122;
  long int GC_mark_stack.123;
  long int D.6772;
  long int D.6773;
  long unsigned int D.6774;
  long unsigned int GC_mark_stack_size.124;
  long unsigned int D.6776;
  long unsigned int D.6777;
  struct hblk * D.6780;
  int D.6783;
  struct mse * GC_mark_stack_top.125;
  struct mse * GC_mark_stack_limit.126;
  register struct hblk * h;

  bottom.118 = (long int) bottom;
  D.6746 = bottom.118 + 7;
  D.6747 = D.6746 & -8;
  bottom = (char *) D.6747;
  top.119 = (long int) top;
  D.6749 = top.119 & -8;
  top = (char *) D.6749;
  if (top == 0B) goto <D.6750>; else goto <D.6752>;
  <D.6752>:
  if (bottom == top) goto <D.6750>; else goto <D.6751>;
  <D.6750>:
  return;
  <D.6751>:
  D.6753 = bottom + 4096;
  D.6754 = (long unsigned int) D.6753;
  D.6755 = D.6754 & 18446744073709547520;
  h = (struct hblk *) D.6755;
  if (top <= h) goto <D.6756>; else goto <D.6757>;
  <D.6756>:
  D.6758 = h + 18446744073709547520;
  D.6759 = dirty_fn (D.6758);
  if (D.6759 != 0) goto <D.6760>; else goto <D.6761>;
  <D.6760>:
  push_fn (bottom, top);
  <D.6761>:
  return;
  <D.6757>:
  D.6758 = h + 18446744073709547520;
  D.6762 = dirty_fn (D.6758);
  if (D.6762 != 0) goto <D.6763>; else goto <D.6764>;
  <D.6763>:
  push_fn (bottom, h);
  <D.6764>:
  goto <D.5923>;
  <D.5922>:
  D.6765 = dirty_fn (h);
  if (D.6765 != 0) goto <D.6766>; else goto <D.6767>;
  <D.6766>:
  GC_mark_stack_top.120 = GC_mark_stack_top;
  GC_mark_stack_top.121 = (long int) GC_mark_stack_top.120;
  GC_mark_stack.122 = GC_mark_stack;
  GC_mark_stack.123 = (long int) GC_mark_stack.122;
  D.6772 = GC_mark_stack_top.121 - GC_mark_stack.123;
  D.6773 = D.6772 /[ex] 16;
  D.6774 = (long unsigned int) D.6773;
  GC_mark_stack_size.124 = GC_mark_stack_size;
  D.6776 = GC_mark_stack_size.124 * 3;
  D.6777 = D.6776 / 4;
  if (D.6774 > D.6777) goto <D.6778>; else goto <D.6779>;
  <D.6778>:
  push_fn (h, top);
  return;
  <D.6779>:
  D.6780 = h + 4096;
  push_fn (h, D.6780);
  <D.6767>:
  h = h + 4096;
  <D.5923>:
  D.6780 = h + 4096;
  if (D.6780 <= top) goto <D.5922>; else goto <D.5924>;
  <D.5924>:
  if (h != top) goto <D.6781>; else goto <D.6782>;
  <D.6781>:
  D.6783 = dirty_fn (h);
  if (D.6783 != 0) goto <D.6784>; else goto <D.6785>;
  <D.6784>:
  push_fn (h, top);
  <D.6785>:
  <D.6782>:
  GC_mark_stack_top.125 = GC_mark_stack_top;
  GC_mark_stack_limit.126 = GC_mark_stack_limit;
  if (GC_mark_stack_top.125 >= GC_mark_stack_limit.126) goto <D.6788>; else goto <D.6789>;
  <D.6788>:
  GC_abort ("unexpected mark stack overflow");
  <D.6789>:
}


GC_true_func (struct hblk * h)
{
  GC_bool D.6791;

  D.6791 = 1;
  return D.6791;
}


GC_push_conditional (char * bottom, char * top, int all)
{
  int GC_dirty_maintained.127;

  if (all != 0) goto <D.6793>; else goto <D.6794>;
  <D.6793>:
  GC_dirty_maintained.127 = GC_dirty_maintained;
  if (GC_dirty_maintained.127 != 0) goto <D.6796>; else goto <D.6797>;
  <D.6796>:
  GC_push_all (bottom, top);
  goto <D.6798>;
  <D.6797>:
  GC_push_all (bottom, top);
  <D.6798>:
  goto <D.6799>;
  <D.6794>:
  GC_push_selected (bottom, top, GC_page_was_dirty, GC_push_all);
  <D.6799>:
}


GC_push_one (word p)
{
  char * p.128;
  void * GC_least_plausible_heap_addr.129;
  void * GC_greatest_plausible_heap_addr.130;

  p.128 = (char *) p;
  GC_least_plausible_heap_addr.129 = GC_least_plausible_heap_addr;
  if (p.128 >= GC_least_plausible_heap_addr.129) goto <D.6802>; else goto <D.6803>;
  <D.6802>:
  p.128 = (char *) p;
  GC_greatest_plausible_heap_addr.130 = GC_greatest_plausible_heap_addr;
  if (p.128 < GC_greatest_plausible_heap_addr.130) goto <D.6805>; else goto <D.6806>;
  <D.6805>:
  GC_mark_and_push_stack (p);
  <D.6806>:
  <D.6803>:
}


GC_mark_and_push (void * obj, struct GC_ms_entry * mark_stack_ptr, struct GC_ms_entry * mark_stack_limit, void * * src)
{
  long unsigned int my_current.131;
  long unsigned int D.6808;
  long unsigned int D.6809;
  struct bottom_index * D.6811;
  long unsigned int D.6812;
  long unsigned int D.6813;
  long unsigned int my_hhdr.132;
  struct hdr * GC_invalid_header.133;
  long int my_current.134;
  int D.6819;
  map_entry_type * D.6820;
  sizetype D.6821;
  map_entry_type * D.6822;
  unsigned char D.6823;
  long unsigned int D.6828;
  long unsigned int D.6829;
  long unsigned int D.6830;
  long unsigned int D.6831;
  int GC_all_interior_pointers.135;
  word[8] * D.6843;
  int D.6844;
  long unsigned int D.6845;
  long unsigned int D.6846;
  int D.6847;
  long unsigned int D.6848;
  long unsigned int D.6850;
  int D.6851;
  long unsigned int D.6857;
  long unsigned int D.6858;
  sizetype my_current.136;
  sizetype D.6860;
  sizetype D.6861;
  GC_word * D.6862;
  struct GC_ms_entry * D.6863;
  void was_marked = <<< error >>>;

  {
    struct hdr * my_hhdr;
    char * my_current;

    my_current = obj;
    {
      register struct hdr * * _ha;

      {
        register struct bottom_index * bi;

        {
          register word hi;
          register struct bottom_index * _bi;

          my_current.131 = (long unsigned int) my_current;
          hi = my_current.131 >> 22;
          D.6808 = hi & 2047;
          _bi = GC_arrays._top_index[D.6808];
          goto <D.5949>;
          <D.5948>:
          _bi = _bi->hash_link;
          <D.5949>:
          D.6809 = _bi->key;
          if (D.6809 != hi) goto <D.6810>; else goto <D.5950>;
          <D.6810>:
          D.6811 = GC_arrays._all_nils;
          if (D.6811 != _bi) goto <D.5948>; else goto <D.5950>;
          <D.5950>:
          bi = _bi;
        }
        my_current.131 = (long unsigned int) my_current;
        D.6812 = my_current.131 >> 12;
        D.6813 = D.6812 & 1023;
        _ha = &bi->index[D.6813];
      }
      my_hhdr = *_ha;
    }
    my_hhdr.132 = (long unsigned int) my_hhdr;
    if (my_hhdr.132 <= 4095) goto <D.6815>; else goto <D.6816>;
    <D.6815>:
    {
      struct hdr * new_hdr;

      try
        {
          GC_invalid_header.133 = GC_invalid_header;
          new_hdr = GC_invalid_header.133;
          my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
          my_hhdr = new_hdr;
        }
      finally
        {
          new_hdr = {CLOBBER};
        }
    }
    <D.6816>:
    {
      int displ;
      int map_entry;

      my_current.134 = (long int) my_current;
      D.6819 = (int) my_current.134;
      displ = D.6819 & 4095;
      D.6820 = my_hhdr->hb_map;
      D.6821 = (sizetype) displ;
      D.6822 = D.6820 + D.6821;
      D.6823 = *D.6822;
      map_entry = (int) D.6823;
      displ = displ >> 3;
      if (map_entry > 253) goto <D.6824>; else goto <D.6825>;
      <D.6824>:
      if (map_entry == 254) goto <D.6826>; else goto <D.6827>;
      <D.6826>:
      D.6828 = (long unsigned int) displ;
      D.6829 = my_hhdr->hb_sz;
      D.6830 = D.6828 % D.6829;
      map_entry = (int) D.6830;
      displ = displ - map_entry;
      D.6828 = (long unsigned int) displ;
      D.6829 = my_hhdr->hb_sz;
      D.6831 = D.6828 + D.6829;
      if (D.6831 > 512) goto <D.6832>; else goto <D.6833>;
      <D.6832>:
      GC_all_interior_pointers.135 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.135 != 0) goto <D.6835>; else goto <D.6836>;
      <D.6835>:
      my_current.131 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.131);
      goto <D.6837>;
      <D.6836>:
      my_current.131 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.131);
      <D.6837>:
      goto was_marked;
      <D.6833>:
      goto <D.6838>;
      <D.6827>:
      GC_all_interior_pointers.135 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.135 != 0) goto <D.6839>; else goto <D.6840>;
      <D.6839>:
      my_current.131 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.131);
      goto <D.6841>;
      <D.6840>:
      my_current.131 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.131);
      <D.6841>:
      goto was_marked;
      <D.6838>:
      goto <D.6842>;
      <D.6825>:
      displ = displ - map_entry;
      <D.6842>:
      {
        register word * mark_word_addr;

        D.6843 = &my_hhdr->hb_marks;
        D.6844 = displ >> 6;
        D.6845 = (long unsigned int) D.6844;
        D.6846 = D.6845 * 8;
        mark_word_addr = D.6843 + D.6846;
        {
          word old;
          word my_bits;

          D.6847 = displ & 63;
          my_bits = 1 << D.6847;
          <D.5958>:
          old = MEM[(volatile word *)mark_word_addr];
          D.6848 = old & my_bits;
          if (D.6848 != 0) goto was_marked; else goto <D.6849>;
          <D.6849>:
          D.6850 = old | my_bits;
          D.6851 = GC_compare_and_exchange (mark_word_addr, old, D.6850);
          if (D.6851 == 0) goto <D.5958>; else goto <D.5959>;
          <D.5959>:
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.6852>; else goto <D.6853>;
        <D.6852>:
        goto <D.6854>;
        <D.6853>:
        mark_stack_ptr = mark_stack_ptr + 16;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.6855>; else goto <D.6856>;
        <D.6855>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.6856>:
        D.6857 = (long unsigned int) displ;
        D.6858 = D.6857 * 8;
        my_current.136 = (sizetype) my_current;
        D.6860 = my_current.136 & 18446744073709547520;
        D.6861 = D.6858 + D.6860;
        D.6862 = (GC_word *) D.6861;
        mark_stack_ptr->mse_start = D.6862;
        mark_stack_ptr->mse_descr = _descr;
        <D.6854>:
      }
    }
    was_marked:
  }
  D.6863 = mark_stack_ptr;
  return D.6863;
}


GC_mark_and_push_stack (word p)
{
  long unsigned int D.6865;
  long unsigned int D.6866;
  struct bottom_index * D.6868;
  long unsigned int D.6869;
  long unsigned int D.6870;
  long unsigned int hhdr.137;
  void * p.138;
  void * D.6877;
  char * r.139;
  long unsigned int D.6879;
  int D.6880;
  int D.6882;
  map_entry_type * D.6883;
  sizetype D.6884;
  map_entry_type * D.6885;
  int GC_all_interior_pointers.140;
  void * D.6893;
  int D.6897;
  long unsigned int D.6898;
  long unsigned int D.6899;
  sizetype D.6900;
  int D.6904;
  long unsigned int D.6905;
  int D.6906;
  long unsigned int D.6907;
  long unsigned int D.6908;
  word[8] * D.6911;
  long unsigned int D.6912;
  long unsigned int D.6913;
  volatile word * D.6914;
  volatile GC_word * D.6915;
  long unsigned int D.6916;
  long unsigned int D.6917;
  int D.6918;
  struct mse * GC_mark_stack_top.141;
  struct mse * D.6923;
  struct mse * GC_mark_stack_top.142;
  struct mse * GC_mark_stack_limit.143;
  struct mse * GC_mark_stack_top.144;
  struct mse * D.6929;
  struct mse * GC_mark_stack_top.145;
  GC_word * r.146;
  struct mse * GC_mark_stack_top.147;
  register word r;
  register struct hdr * hhdr;
  register int displ;

  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        hi = p >> 22;
        D.6865 = hi & 2047;
        _bi = GC_arrays._top_index[D.6865];
        goto <D.5972>;
        <D.5971>:
        _bi = _bi->hash_link;
        <D.5972>:
        D.6866 = _bi->key;
        if (D.6866 != hi) goto <D.6867>; else goto <D.5973>;
        <D.6867>:
        D.6868 = GC_arrays._all_nils;
        if (D.6868 != _bi) goto <D.5971>; else goto <D.5973>;
        <D.5973>:
        bi = _bi;
      }
      D.6869 = p >> 12;
      D.6870 = D.6869 & 1023;
      _ha = &bi->index[D.6870];
    }
    hhdr = *_ha;
  }
  hhdr.137 = (long unsigned int) hhdr;
  if (hhdr.137 <= 4095) goto <D.6872>; else goto <D.6873>;
  <D.6872>:
  if (hhdr != 0B) goto <D.6874>; else goto <D.6875>;
  <D.6874>:
  p.138 = (void *) p;
  D.6877 = GC_base (p.138);
  r = (word) D.6877;
  r.139 = (char *) r;
  hhdr = GC_find_header (r.139);
  D.6879 = r >> 3;
  D.6880 = (int) D.6879;
  displ = D.6880 & 511;
  <D.6875>:
  goto <D.6881>;
  <D.6873>:
  {
    register map_entry_type map_entry;

    D.6882 = (int) p;
    displ = D.6882 & 4095;
    D.6883 = hhdr->hb_map;
    D.6884 = (sizetype) displ;
    D.6885 = D.6883 + D.6884;
    map_entry = *D.6885;
    if (map_entry > 252) goto <D.6886>; else goto <D.6887>;
    <D.6886>:
    if (map_entry == 254) goto <D.6888>; else goto <D.6891>;
    <D.6891>:
    GC_all_interior_pointers.140 = GC_all_interior_pointers;
    if (GC_all_interior_pointers.140 == 0) goto <D.6888>; else goto <D.6889>;
    <D.6888>:
    p.138 = (void *) p;
    D.6893 = GC_base (p.138);
    r = (word) D.6893;
    D.6879 = r >> 3;
    D.6880 = (int) D.6879;
    displ = D.6880 & 511;
    if (r == 0) goto <D.6894>; else goto <D.6895>;
    <D.6894>:
    hhdr = 0B;
    <D.6895>:
    goto <D.6890>;
    <D.6889>:
    hhdr = 0B;
    <D.6890>:
    goto <D.6896>;
    <D.6887>:
    displ = displ >> 3;
    D.6897 = (int) map_entry;
    displ = displ - D.6897;
    D.6898 = (long unsigned int) displ;
    D.6899 = D.6898 * 8;
    D.6900 = p & 18446744073709547520;
    r = D.6899 + D.6900;
    <D.6896>:
  }
  <D.6881>:
  if (hhdr == 0B) goto <D.6901>; else goto <D.6902>;
  <D.6901>:
  GC_add_to_black_list_stack (p);
  goto <D.6903>;
  <D.6902>:
  D.6904 = displ >> 6;
  D.6905 = hhdr->hb_marks[D.6904];
  D.6906 = displ & 63;
  D.6907 = D.6905 >> D.6906;
  D.6908 = D.6907 & 1;
  if (D.6908 == 0) goto <D.6909>; else goto <D.6910>;
  <D.6909>:
  {
    word old;

    <D.5976>:
    D.6911 = &hhdr->hb_marks;
    D.6904 = displ >> 6;
    D.6912 = (long unsigned int) D.6904;
    D.6913 = D.6912 * 8;
    D.6914 = D.6911 + D.6913;
    old = *D.6914;
    D.6911 = &hhdr->hb_marks;
    D.6904 = displ >> 6;
    D.6912 = (long unsigned int) D.6904;
    D.6913 = D.6912 * 8;
    D.6915 = D.6911 + D.6913;
    D.6906 = displ & 63;
    D.6916 = 1 << D.6906;
    D.6917 = D.6916 | old;
    D.6918 = GC_compare_and_exchange (D.6915, old, D.6917);
    if (D.6918 == 0) goto <D.5976>; else goto <D.5977>;
    <D.5977>:
  }
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.6919>; else goto <D.6920>;
    <D.6919>:
    goto <D.6921>;
    <D.6920>:
    GC_mark_stack_top.141 = GC_mark_stack_top;
    D.6923 = GC_mark_stack_top.141 + 16;
    GC_mark_stack_top = D.6923;
    GC_mark_stack_top.142 = GC_mark_stack_top;
    GC_mark_stack_limit.143 = GC_mark_stack_limit;
    if (GC_mark_stack_top.142 >= GC_mark_stack_limit.143) goto <D.6926>; else goto <D.6927>;
    <D.6926>:
    GC_mark_stack_top.144 = GC_mark_stack_top;
    D.6929 = GC_signal_mark_stack_overflow (GC_mark_stack_top.144);
    GC_mark_stack_top = D.6929;
    <D.6927>:
    GC_mark_stack_top.145 = GC_mark_stack_top;
    r.146 = (GC_word *) r;
    GC_mark_stack_top.145->mse_start = r.146;
    GC_mark_stack_top.147 = GC_mark_stack_top;
    GC_mark_stack_top.147->mse_descr = _descr;
    <D.6921>:
  }
  <D.6910>:
  <D.6903>:
}


GC_push_all_eager (char * bottom, char * top)
{
  long unsigned int bottom.148;
  long unsigned int D.6934;
  long unsigned int D.6935;
  long unsigned int top.149;
  long unsigned int D.6937;
  char * q.150;
  word * b;
  word * t;
  register word * p;
  register word q;
  register word * lim;
  register char * greatest_ha;
  register char * least_ha;

  bottom.148 = (long unsigned int) bottom;
  D.6934 = bottom.148 + 7;
  D.6935 = D.6934 & 18446744073709551608;
  b = (word *) D.6935;
  top.149 = (long unsigned int) top;
  D.6937 = top.149 & 18446744073709551608;
  t = (word *) D.6937;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  if (top == 0B) goto <D.6938>; else goto <D.6939>;
  <D.6938>:
  return;
  <D.6939>:
  lim = t + 18446744073709551608;
  p = b;
  goto <D.5991>;
  <D.5990>:
  q = *p;
  q.150 = (char *) q;
  if (q.150 >= least_ha) goto <D.6941>; else goto <D.6942>;
  <D.6941>:
  q.150 = (char *) q;
  if (q.150 < greatest_ha) goto <D.6943>; else goto <D.6944>;
  <D.6943>:
  GC_mark_and_push_stack (q);
  <D.6944>:
  <D.6942>:
  p = p + 8;
  <D.5991>:
  if (p <= lim) goto <D.5990>; else goto <D.5992>;
  <D.5992>:
}


GC_push_all_stack (char * bottom, char * top)
{
  int GC_all_interior_pointers.151;

  GC_all_interior_pointers.151 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.151 != 0) goto <D.6947>; else goto <D.6948>;
  <D.6947>:
  GC_push_all (bottom, top);
  goto <D.6949>;
  <D.6948>:
  GC_push_all_eager (bottom, top);
  <D.6949>:
}


GC_push_marked1 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.152;
  long unsigned int D.6951;
  word * mark_word_addr.153;
  long unsigned int D.6953;
  long unsigned int D.6956;
  long unsigned int D.6957;
  word * D.6958;
  char * q.154;
  void * q.155;
  word * mark_word_addr;
  register word * p;
  word * plim;
  register int i;
  register word q;
  register word mark_word;
  register char * greatest_ha;
  register char * least_ha;
  register struct mse * mark_stack_top;
  register struct mse * mark_stack_limit;

  mark_word_addr = &hhdr->hb_marks[0];
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  mark_stack_top = GC_mark_stack_top;
  mark_stack_limit = GC_mark_stack_limit;
  p = &h->hb_body;
  h.152 = (long unsigned int) h;
  D.6951 = h.152 + 4096;
  plim = (word *) D.6951;
  goto <D.6015>;
  <D.6014>:
  mark_word_addr.153 = mark_word_addr;
  mark_word_addr = mark_word_addr.153 + 8;
  mark_word = *mark_word_addr.153;
  i = 0;
  goto <D.6012>;
  <D.6011>:
  D.6953 = mark_word & 1;
  if (D.6953 != 0) goto <D.6954>; else goto <D.6955>;
  <D.6954>:
  D.6956 = (long unsigned int) i;
  D.6957 = D.6956 * 8;
  D.6958 = p + D.6957;
  q = *D.6958;
  q.154 = (char *) q;
  if (q.154 >= least_ha) goto <D.6960>; else goto <D.6961>;
  <D.6960>:
  q.154 = (char *) q;
  if (q.154 < greatest_ha) goto <D.6962>; else goto <D.6963>;
  <D.6962>:
  q.155 = (void *) q;
  D.6956 = (long unsigned int) i;
  D.6957 = D.6956 * 8;
  D.6958 = p + D.6957;
  mark_stack_top = GC_mark_and_push (q.155, mark_stack_top, mark_stack_limit, D.6958);
  <D.6963>:
  <D.6961>:
  <D.6955>:
  i = i + 1;
  mark_word = mark_word >> 1;
  <D.6012>:
  if (mark_word != 0) goto <D.6011>; else goto <D.6013>;
  <D.6013>:
  p = p + 512;
  <D.6015>:
  if (p < plim) goto <D.6014>; else goto <D.6016>;
  <D.6016>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked2 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.156;
  long unsigned int D.6966;
  word * mark_word_addr.157;
  long unsigned int D.6968;
  long unsigned int D.6971;
  long unsigned int D.6972;
  word * D.6973;
  char * q.158;
  void * q.159;
  sizetype D.6980;
  sizetype D.6981;
  sizetype D.6982;
  word * D.6983;
  word * mark_word_addr;
  register word * p;
  word * plim;
  register int i;
  register word q;
  register word mark_word;
  register char * greatest_ha;
  register char * least_ha;
  register struct mse * mark_stack_top;
  register struct mse * mark_stack_limit;

  mark_word_addr = &hhdr->hb_marks[0];
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  mark_stack_top = GC_mark_stack_top;
  mark_stack_limit = GC_mark_stack_limit;
  p = &h->hb_body;
  h.156 = (long unsigned int) h;
  D.6966 = h.156 + 4096;
  plim = (word *) D.6966;
  goto <D.6035>;
  <D.6034>:
  mark_word_addr.157 = mark_word_addr;
  mark_word_addr = mark_word_addr.157 + 8;
  mark_word = *mark_word_addr.157;
  i = 0;
  goto <D.6032>;
  <D.6031>:
  D.6968 = mark_word & 1;
  if (D.6968 != 0) goto <D.6969>; else goto <D.6970>;
  <D.6969>:
  D.6971 = (long unsigned int) i;
  D.6972 = D.6971 * 8;
  D.6973 = p + D.6972;
  q = *D.6973;
  q.158 = (char *) q;
  if (q.158 >= least_ha) goto <D.6975>; else goto <D.6976>;
  <D.6975>:
  q.158 = (char *) q;
  if (q.158 < greatest_ha) goto <D.6977>; else goto <D.6978>;
  <D.6977>:
  q.159 = (void *) q;
  D.6971 = (long unsigned int) i;
  D.6972 = D.6971 * 8;
  D.6973 = p + D.6972;
  mark_stack_top = GC_mark_and_push (q.159, mark_stack_top, mark_stack_limit, D.6973);
  <D.6978>:
  <D.6976>:
  D.6980 = (sizetype) i;
  D.6981 = D.6980 + 1;
  D.6982 = D.6981 * 8;
  D.6983 = p + D.6982;
  q = *D.6983;
  q.158 = (char *) q;
  if (q.158 >= least_ha) goto <D.6984>; else goto <D.6985>;
  <D.6984>:
  q.158 = (char *) q;
  if (q.158 < greatest_ha) goto <D.6986>; else goto <D.6987>;
  <D.6986>:
  q.159 = (void *) q;
  D.6971 = (long unsigned int) i;
  D.6972 = D.6971 * 8;
  D.6973 = p + D.6972;
  mark_stack_top = GC_mark_and_push (q.159, mark_stack_top, mark_stack_limit, D.6973);
  <D.6987>:
  <D.6985>:
  <D.6970>:
  i = i + 2;
  mark_word = mark_word >> 2;
  <D.6032>:
  if (mark_word != 0) goto <D.6031>; else goto <D.6033>;
  <D.6033>:
  p = p + 512;
  <D.6035>:
  if (p < plim) goto <D.6034>; else goto <D.6036>;
  <D.6036>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked4 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.160;
  long unsigned int D.6989;
  word * mark_word_addr.161;
  long unsigned int D.6991;
  long unsigned int D.6994;
  long unsigned int D.6995;
  word * D.6996;
  char * q.162;
  void * q.163;
  sizetype D.7003;
  sizetype D.7004;
  sizetype D.7005;
  word * D.7006;
  sizetype D.7011;
  sizetype D.7012;
  word * D.7013;
  sizetype D.7018;
  sizetype D.7019;
  word * D.7020;
  word * mark_word_addr;
  register word * p;
  word * plim;
  register int i;
  register word q;
  register word mark_word;
  register char * greatest_ha;
  register char * least_ha;
  register struct mse * mark_stack_top;
  register struct mse * mark_stack_limit;

  mark_word_addr = &hhdr->hb_marks[0];
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  mark_stack_top = GC_mark_stack_top;
  mark_stack_limit = GC_mark_stack_limit;
  p = &h->hb_body;
  h.160 = (long unsigned int) h;
  D.6989 = h.160 + 4096;
  plim = (word *) D.6989;
  goto <D.6055>;
  <D.6054>:
  mark_word_addr.161 = mark_word_addr;
  mark_word_addr = mark_word_addr.161 + 8;
  mark_word = *mark_word_addr.161;
  i = 0;
  goto <D.6052>;
  <D.6051>:
  D.6991 = mark_word & 1;
  if (D.6991 != 0) goto <D.6992>; else goto <D.6993>;
  <D.6992>:
  D.6994 = (long unsigned int) i;
  D.6995 = D.6994 * 8;
  D.6996 = p + D.6995;
  q = *D.6996;
  q.162 = (char *) q;
  if (q.162 >= least_ha) goto <D.6998>; else goto <D.6999>;
  <D.6998>:
  q.162 = (char *) q;
  if (q.162 < greatest_ha) goto <D.7000>; else goto <D.7001>;
  <D.7000>:
  q.163 = (void *) q;
  D.6994 = (long unsigned int) i;
  D.6995 = D.6994 * 8;
  D.6996 = p + D.6995;
  mark_stack_top = GC_mark_and_push (q.163, mark_stack_top, mark_stack_limit, D.6996);
  <D.7001>:
  <D.6999>:
  D.7003 = (sizetype) i;
  D.7004 = D.7003 + 1;
  D.7005 = D.7004 * 8;
  D.7006 = p + D.7005;
  q = *D.7006;
  q.162 = (char *) q;
  if (q.162 >= least_ha) goto <D.7007>; else goto <D.7008>;
  <D.7007>:
  q.162 = (char *) q;
  if (q.162 < greatest_ha) goto <D.7009>; else goto <D.7010>;
  <D.7009>:
  q.163 = (void *) q;
  D.7003 = (sizetype) i;
  D.7004 = D.7003 + 1;
  D.7005 = D.7004 * 8;
  D.7006 = p + D.7005;
  mark_stack_top = GC_mark_and_push (q.163, mark_stack_top, mark_stack_limit, D.7006);
  <D.7010>:
  <D.7008>:
  D.7003 = (sizetype) i;
  D.7011 = D.7003 + 2;
  D.7012 = D.7011 * 8;
  D.7013 = p + D.7012;
  q = *D.7013;
  q.162 = (char *) q;
  if (q.162 >= least_ha) goto <D.7014>; else goto <D.7015>;
  <D.7014>:
  q.162 = (char *) q;
  if (q.162 < greatest_ha) goto <D.7016>; else goto <D.7017>;
  <D.7016>:
  q.163 = (void *) q;
  D.7003 = (sizetype) i;
  D.7011 = D.7003 + 2;
  D.7012 = D.7011 * 8;
  D.7013 = p + D.7012;
  mark_stack_top = GC_mark_and_push (q.163, mark_stack_top, mark_stack_limit, D.7013);
  <D.7017>:
  <D.7015>:
  D.7003 = (sizetype) i;
  D.7018 = D.7003 + 3;
  D.7019 = D.7018 * 8;
  D.7020 = p + D.7019;
  q = *D.7020;
  q.162 = (char *) q;
  if (q.162 >= least_ha) goto <D.7021>; else goto <D.7022>;
  <D.7021>:
  q.162 = (char *) q;
  if (q.162 < greatest_ha) goto <D.7023>; else goto <D.7024>;
  <D.7023>:
  q.163 = (void *) q;
  D.7003 = (sizetype) i;
  D.7018 = D.7003 + 3;
  D.7019 = D.7018 * 8;
  D.7020 = p + D.7019;
  mark_stack_top = GC_mark_and_push (q.163, mark_stack_top, mark_stack_limit, D.7020);
  <D.7024>:
  <D.7022>:
  <D.6993>:
  i = i + 4;
  mark_word = mark_word >> 4;
  <D.6052>:
  if (mark_word != 0) goto <D.6051>; else goto <D.6053>;
  <D.6053>:
  p = p + 512;
  <D.6055>:
  if (p < plim) goto <D.6054>; else goto <D.6056>;
  <D.6056>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.7025;
  long unsigned int D.7026;
  int D.7029;
  long unsigned int GC_n_rescuing_pages.164;
  long unsigned int D.7033;
  unsigned int sz.165;
  struct hblk * D.7038;
  long unsigned int D.7039;
  long unsigned int D.7040;
  sizetype D.7041;
  int D.7042;
  long unsigned int D.7043;
  int D.7044;
  long unsigned int D.7045;
  long unsigned int D.7046;
  register int sz;
  register int descr;
  register word * p;
  register int word_no;
  register word * lim;
  register struct mse * GC_mark_stack_top_reg;
  register struct mse * mark_stack_limit;

  D.7025 = hhdr->hb_sz;
  sz = (int) D.7025;
  D.7026 = hhdr->hb_descr;
  descr = (int) D.7026;
  mark_stack_limit = GC_mark_stack_limit;
  if (descr == 0) goto <D.7027>; else goto <D.7028>;
  <D.7027>:
  return;
  <D.7028>:
  D.7029 = GC_block_empty (hhdr);
  if (D.7029 != 0) goto <D.7030>; else goto <D.7031>;
  <D.7030>:
  return;
  <D.7031>:
  GC_n_rescuing_pages.164 = GC_n_rescuing_pages;
  D.7033 = GC_n_rescuing_pages.164 + 1;
  GC_n_rescuing_pages = D.7033;
  GC_objects_are_marked = 1;
  sz.165 = (unsigned int) sz;
  if (sz.165 > 256) goto <D.7035>; else goto <D.7036>;
  <D.7035>:
  lim = h;
  goto <D.7037>;
  <D.7036>:
  D.7038 = h + 4096;
  D.7039 = (long unsigned int) sz;
  D.7040 = D.7039 * 8;
  D.7041 = -D.7040;
  lim = D.7038 + D.7041;
  <D.7037>:
  switch (sz) <default: <D.6072>, case 1: <D.6068>, case 2: <D.6070>, case 4: <D.6071>>
  <D.6068>:
  GC_push_marked1 (h, hhdr);
  goto <D.6069>;
  <D.6070>:
  GC_push_marked2 (h, hhdr);
  goto <D.6069>;
  <D.6071>:
  GC_push_marked4 (h, hhdr);
  goto <D.6069>;
  <D.6072>:
  GC_mark_stack_top_reg = GC_mark_stack_top;
  p = h;
  word_no = 0;
  goto <D.6075>;
  <D.6074>:
  D.7042 = word_no >> 6;
  D.7043 = hhdr->hb_marks[D.7042];
  D.7044 = word_no & 63;
  D.7045 = D.7043 >> D.7044;
  D.7046 = D.7045 & 1;
  if (D.7046 != 0) goto <D.7047>; else goto <D.7048>;
  <D.7047>:
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.7049>; else goto <D.7050>;
    <D.7049>:
    goto <D.7051>;
    <D.7050>:
    GC_mark_stack_top_reg = GC_mark_stack_top_reg + 16;
    if (GC_mark_stack_top_reg >= mark_stack_limit) goto <D.7052>; else goto <D.7053>;
    <D.7052>:
    GC_mark_stack_top_reg = GC_signal_mark_stack_overflow (GC_mark_stack_top_reg);
    <D.7053>:
    GC_mark_stack_top_reg->mse_start = p;
    GC_mark_stack_top_reg->mse_descr = _descr;
    <D.7051>:
  }
  <D.7048>:
  D.7039 = (long unsigned int) sz;
  D.7040 = D.7039 * 8;
  p = p + D.7040;
  word_no = word_no + sz;
  <D.6075>:
  if (p <= lim) goto <D.6074>; else goto <D.6076>;
  <D.6076>:
  GC_mark_stack_top = GC_mark_stack_top_reg;
  <D.6069>:
}


GC_block_was_dirty (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.7055;
  unsigned int sz.166;
  GC_bool D.7059;
  int D.7060;
  sizetype D.7063;
  char * D.7064;
  register int sz;

  D.7055 = hhdr->hb_sz;
  sz = (int) D.7055;
  sz.166 = (unsigned int) sz;
  if (sz.166 <= 256) goto <D.7057>; else goto <D.7058>;
  <D.7057>:
  D.7059 = GC_page_was_dirty (h);
  return D.7059;
  <D.7058>:
  {
    register char * p;

    p = h;
    sz = sz << 3;
    goto <D.6084>;
    <D.6083>:
    D.7060 = GC_page_was_dirty (p);
    if (D.7060 != 0) goto <D.7061>; else goto <D.7062>;
    <D.7061>:
    D.7059 = 1;
    return D.7059;
    <D.7062>:
    p = p + 4096;
    <D.6084>:
    D.7063 = (sizetype) sz;
    D.7064 = h + D.7063;
    if (D.7064 > p) goto <D.6083>; else goto <D.6085>;
    <D.6085>:
    D.7059 = 0;
    return D.7059;
  }
}


GC_push_next_marked (struct hblk * h)
{
  struct hblk * D.7068;
  long unsigned int D.7069;
  long unsigned int D.7070;
  long unsigned int D.7071;
  long unsigned int D.7072;
  long unsigned int D.7073;
  register struct hdr * hhdr;

  h = GC_next_used_block (h);
  if (h == 0B) goto <D.7066>; else goto <D.7067>;
  <D.7066>:
  D.7068 = 0B;
  return D.7068;
  <D.7067>:
  hhdr = GC_find_header (h);
  GC_push_marked (h, hhdr);
  D.7069 = hhdr->hb_sz;
  D.7070 = D.7069 << 3;
  D.7071 = D.7070 + 4095;
  D.7072 = D.7071 >> 12;
  D.7073 = D.7072 * 4096;
  D.7068 = h + D.7073;
  return D.7068;
}


GC_push_next_marked_dirty (struct hblk * h)
{
  int GC_dirty_maintained.167;
  struct hblk * D.7080;
  int D.7081;
  long unsigned int D.7083;
  long unsigned int D.7084;
  long unsigned int D.7085;
  long unsigned int D.7086;
  long unsigned int D.7087;
  register struct hdr * hhdr;

  GC_dirty_maintained.167 = GC_dirty_maintained;
  if (GC_dirty_maintained.167 == 0) goto <D.7076>; else goto <D.7077>;
  <D.7076>:
  GC_abort ("dirty bits not set up");
  <D.7077>:
  <D.6095>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.7078>; else goto <D.7079>;
  <D.7078>:
  D.7080 = 0B;
  return D.7080;
  <D.7079>:
  hhdr = GC_find_header (h);
  D.7081 = GC_block_was_dirty (h, hhdr);
  if (D.7081 != 0) goto <D.6094>; else goto <D.7082>;
  <D.7082>:
  D.7083 = hhdr->hb_sz;
  D.7084 = D.7083 << 3;
  D.7085 = D.7084 + 4095;
  D.7086 = D.7085 >> 12;
  D.7087 = D.7086 * 4096;
  h = h + D.7087;
  goto <D.6095>;
  <D.6094>:
  GC_push_marked (h, hhdr);
  D.7083 = hhdr->hb_sz;
  D.7084 = D.7083 << 3;
  D.7085 = D.7084 + 4095;
  D.7086 = D.7085 >> 12;
  D.7087 = D.7086 * 4096;
  D.7080 = h + D.7087;
  return D.7080;
}


GC_push_next_marked_uncollectable (struct hblk * h)
{
  struct hblk * D.7091;
  unsigned char D.7092;
  long unsigned int D.7094;
  long unsigned int D.7095;
  long unsigned int D.7096;
  long unsigned int D.7097;
  long unsigned int D.7098;
  register struct hdr * hhdr;

  hhdr = GC_find_header (h);
  <D.6101>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.7089>; else goto <D.7090>;
  <D.7089>:
  D.7091 = 0B;
  return D.7091;
  <D.7090>:
  hhdr = GC_find_header (h);
  D.7092 = hhdr->hb_obj_kind;
  if (D.7092 == 2) goto <D.6100>; else goto <D.7093>;
  <D.7093>:
  D.7094 = hhdr->hb_sz;
  D.7095 = D.7094 << 3;
  D.7096 = D.7095 + 4095;
  D.7097 = D.7096 >> 12;
  D.7098 = D.7097 * 4096;
  h = h + D.7098;
  goto <D.6101>;
  <D.6100>:
  GC_push_marked (h, hhdr);
  D.7094 = hhdr->hb_sz;
  D.7095 = D.7094 << 3;
  D.7096 = D.7095 + 4095;
  D.7097 = D.7096 >> 12;
  D.7098 = D.7097 * 4096;
  D.7091 = h + D.7098;
  return D.7091;
}