GC_noop (void * p)
{

}


GC_noop1 (word x)
{
  static volatile word sink;

  sink = x;
}


GC_collection_in_progress ()
{
  GC_bool D.6021;
  int GC_mark_state.0;
  _Bool D.6023;

  GC_mark_state.0 = GC_mark_state;
  D.6023 = GC_mark_state.0 != 0;
  D.6021 = (GC_bool) D.6023;
  return D.6021;
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.6028;
  int D.6033;
  void * D.6035;
  long unsigned int D.6036;

  D.6028 = __builtin_constant_p (__len);
  if (D.6028 != 0) goto <D.6029>; else goto <D.6030>;
  <D.6029>:
  if (__len == 0) goto <D.6031>; else goto <D.6032>;
  <D.6031>:
  D.6033 = __builtin_constant_p (__ch);
  if (D.6033 == 0) goto <D.6026>; else goto <D.6034>;
  <D.6034>:
  if (__ch != 0) goto <D.6026>; else goto <D.6027>;
  <D.6026>:
  __warn_memset_zero_len ();
  D.6035 = __dest;
  return D.6035;
  <D.6027>:
  <D.6032>:
  <D.6030>:
  D.6036 = __builtin_object_size (__dest, 0);
  D.6035 = __builtin___memset_chk (__dest, __ch, __len, D.6036);
  return D.6035;
}


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

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


GC_set_mark_bit (char * p)
{
  long unsigned int p.1;
  long unsigned int D.6039;
  long int p.2;
  long int h.3;
  long int D.6042;
  long int D.6043;
  int D.6044;
  sizetype D.6045;
  int D.6046;
  long unsigned int D.6047;
  long unsigned int D.6048;
  word * D.6049;
  int D.6050;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

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

    <D.5606>:
    D.6044 = word_no >> 6;
    D.6045 = (sizetype) D.6044;
    old = hhdr->hb_marks[D.6045];
    D.6046 = word_no & 63;
    D.6047 = 1 << D.6046;
    D.6048 = D.6047 | old;
    D.6044 = word_no >> 6;
    D.6045 = (sizetype) D.6044;
    D.6049 = &hhdr->hb_marks[D.6045];
    D.6050 = GC_compare_and_exchange (D.6049, old, D.6048);
    if (D.6050 == 0) goto <D.5606>; else goto <D.5607>;
    <D.5607>:
  }
}


GC_compare_and_exchange (volatile GC_word * addr, GC_word old, GC_word new_val)
{
  GC_bool D.6051;
  char result;

  __asm__ __volatile__("lock; cmpxchgq %2, %0; setz %1" : "=m" *addr, "=r" result : "r" new_val, "a" old, "m" *addr : "memory");
  D.6051 = (GC_bool) result;
  return D.6051;
}


GC_clear_mark_bit (char * p)
{
  long unsigned int p.4;
  long unsigned int D.6054;
  long int p.5;
  long int h.6;
  long int D.6057;
  long int D.6058;
  int D.6059;
  long unsigned int D.6060;
  int D.6061;
  long unsigned int D.6062;
  long unsigned int D.6063;
  long unsigned int D.6064;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.4 = (long unsigned int) p;
  D.6054 = p.4 & 18446744073709547520;
  h = (struct hblk *) D.6054;
  hhdr = GC_find_header (h);
  p.5 = (long int) p;
  h.6 = (long int) h;
  D.6057 = p.5 - h.6;
  D.6058 = D.6057 /[ex] 8;
  word_no = (int) D.6058;
  D.6059 = word_no >> 6;
  D.6059 = word_no >> 6;
  D.6060 = hhdr->hb_marks[D.6059];
  D.6061 = word_no & 63;
  D.6062 = 1 << D.6061;
  D.6063 = ~D.6062;
  D.6064 = D.6060 & D.6063;
  hhdr->hb_marks[D.6059] = D.6064;
}


GC_is_marked (char * p)
{
  long unsigned int p.7;
  long unsigned int D.6066;
  long int p.8;
  long int h.9;
  long int D.6069;
  long int D.6070;
  GC_bool D.6071;
  int D.6072;
  long unsigned int D.6073;
  int D.6074;
  long unsigned int D.6075;
  int D.6076;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.7 = (long unsigned int) p;
  D.6066 = p.7 & 18446744073709547520;
  h = (struct hblk *) D.6066;
  hhdr = GC_find_header (h);
  p.8 = (long int) p;
  h.9 = (long int) h;
  D.6069 = p.8 - h.9;
  D.6070 = D.6069 /[ex] 8;
  word_no = (int) D.6070;
  D.6072 = word_no >> 6;
  D.6073 = hhdr->hb_marks[D.6072];
  D.6074 = word_no & 63;
  D.6075 = D.6073 >> D.6074;
  D.6076 = (int) D.6075;
  D.6071 = D.6076 & 1;
  return D.6071;
}


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.6078;
  int D.6079;
  int D.6080;
  register struct hdr * hhdr;

  hhdr = GC_find_header (h);
  D.6078 = hhdr->hb_obj_kind;
  D.6079 = (int) D.6078;
  D.6080 = D.6079 & -2;
  if (D.6080 == 2) goto <D.6081>; else goto <D.6082>;
  <D.6081>:
  return;
  <D.6082>:
  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.6085>; else goto <D.6086>;
  <D.6085>:
  GC_read_dirty ();
  <D.6086>:
  GC_n_rescuing_pages = 0;
  GC_mark_state.11 = GC_mark_state;
  if (GC_mark_state.11 == 0) goto <D.6088>; else goto <D.6089>;
  <D.6088>:
  GC_mark_state = 1;
  goto <D.6090>;
  <D.6089>:
  GC_mark_state.11 = GC_mark_state;
  if (GC_mark_state.11 != 5) goto <D.6091>; else goto <D.6092>;
  <D.6091>:
  GC_abort ("unexpected state");
  <D.6092>:
  <D.6090>:
  scan_ptr = 0B;
}


GC_mark_some (char * cold_gc_frame)
{
  int GC_mark_state.12;
  GC_bool D.6094;
  struct mse * GC_mark_stack_limit.13;
  struct GC_ms_entry * D.6096;
  struct mse * GC_mark_stack_top.14;
  struct mse * GC_mark_stack.15;
  long unsigned int GC_mark_stack_size.16;
  long unsigned int D.6102;
  struct mse * D.6103;
  struct mse * GC_mark_stack_top.17;
  struct mse * GC_mark_stack_top.18;
  struct hblk * scan_ptr.19;
  struct hblk * scan_ptr.20;
  int GC_print_stats.21;
  long unsigned int GC_n_rescuing_pages.22;
  long int GC_n_rescuing_pages.23;
  long unsigned int D.6117;
  long unsigned int D.6118;
  struct GC_ms_entry * D.6119;
  struct mse * GC_mark_stack_top.24;
  int GC_parallel.25;
  struct mse * GC_mark_stack_top.26;
  struct mse * GC_mark_stack_top.27;
  struct hblk * scan_ptr.28;
  struct mse * GC_mark_stack_top.29;
  int GC_mark_stack_too_small.30;
  long unsigned int D.6139;
  struct mse * GC_mark_stack_top.31;
  struct mse * GC_mark_stack_top.32;
  struct mse * GC_mark_stack_top.33;
  int GC_objects_are_marked.34;
  struct mse * GC_mark_stack_top.35;
  struct mse * GC_mark_stack_top.36;
  struct mse * GC_mark_stack_top.37;
  struct hblk * scan_ptr.38;

  GC_mark_state.12 = GC_mark_state;
  switch (GC_mark_state.12) <default: <D.5634>, case 0: <D.5628>, case 1: <D.5629>, case 2: <D.5630>, case 3: <D.5631>, case 4: <D.5633>, case 5: <D.5632>>
  <D.5628>:
  D.6094 = 0;
  return D.6094;
  <D.5629>:
  GC_mark_stack_limit.13 = GC_mark_stack_limit;
  D.6096 = GC_mark_stack_limit.13 + 18446744073709518848;
  GC_mark_stack_top.14 = GC_mark_stack_top;
  if (D.6096 <= GC_mark_stack_top.14) goto <D.6098>; else goto <D.6099>;
  <D.6098>:
  GC_mark_stack_too_small = 1;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6102 = GC_mark_stack_size.16 * 16;
  D.6103 = GC_mark_stack.15 + D.6102;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_top.17 = GC_mark_stack_top;
  GC_mark_stack_top.18 = GC_mark_from (GC_mark_stack_top.17, GC_mark_stack.15, D.6103);
  GC_mark_stack_top = GC_mark_stack_top.18;
  D.6094 = 0;
  return D.6094;
  <D.6099>:
  scan_ptr.19 = scan_ptr;
  scan_ptr.20 = GC_push_next_marked_dirty (scan_ptr.19);
  scan_ptr = scan_ptr.20;
  scan_ptr.19 = scan_ptr;
  if (scan_ptr.19 == 0B) goto <D.6108>; else goto <D.6109>;
  <D.6108>:
  GC_print_stats.21 = GC_print_stats;
  if (GC_print_stats.21 != 0) goto <D.6111>; else goto <D.6112>;
  <D.6111>:
  GC_n_rescuing_pages.22 = GC_n_rescuing_pages;
  GC_n_rescuing_pages.23 = (long int) GC_n_rescuing_pages.22;
  GC_printf ("Marked from %lu dirty pages\n", GC_n_rescuing_pages.23, 0, 0, 0, 0, 0);
  <D.6112>:
  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.6115>; else goto <D.6116>;
  <D.6115>:
  GC_mark_state = 3;
  <D.6116>:
  <D.6109>:
  D.6094 = 0;
  return D.6094;
  <D.5630>:
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6117 = GC_mark_stack_size.16 / 4;
  D.6118 = D.6117 * 16;
  D.6119 = GC_mark_stack.15 + D.6118;
  GC_mark_stack_top.24 = GC_mark_stack_top;
  if (D.6119 <= GC_mark_stack_top.24) goto <D.6121>; else goto <D.6122>;
  <D.6121>:
  GC_parallel.25 = GC_parallel;
  if (GC_parallel.25 != 0) goto <D.6124>; else goto <D.6125>;
  <D.6124>:
  GC_mark_stack_too_small = 1;
  <D.6125>:
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6102 = GC_mark_stack_size.16 * 16;
  D.6103 = GC_mark_stack.15 + D.6102;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_top.26 = GC_mark_stack_top;
  GC_mark_stack_top.27 = GC_mark_from (GC_mark_stack_top.26, GC_mark_stack.15, D.6103);
  GC_mark_stack_top = GC_mark_stack_top.27;
  D.6094 = 0;
  return D.6094;
  <D.6122>:
  scan_ptr.19 = scan_ptr;
  scan_ptr.28 = GC_push_next_marked_uncollectable (scan_ptr.19);
  scan_ptr = scan_ptr.28;
  scan_ptr.19 = scan_ptr;
  if (scan_ptr.19 == 0B) goto <D.6129>; else goto <D.6130>;
  <D.6129>:
  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.6131>; else goto <D.6132>;
  <D.6131>:
  GC_mark_state = 3;
  <D.6132>:
  <D.6130>:
  D.6094 = 0;
  return D.6094;
  <D.5631>:
  GC_parallel.25 = GC_parallel;
  if (GC_parallel.25 != 0) goto <D.6133>; else goto <D.6134>;
  <D.6133>:
  GC_do_parallel_mark ();
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_top.29 = GC_mark_stack.15 + 18446744073709551600;
  GC_mark_stack_top = GC_mark_stack_top.29;
  GC_mark_stack_too_small.30 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.30 != 0) goto <D.6137>; else goto <D.6138>;
  <D.6137>:
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6139 = GC_mark_stack_size.16 * 2;
  alloc_mark_stack (D.6139);
  <D.6138>:
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 == 3) goto <D.6140>; else goto <D.6141>;
  <D.6140>:
  GC_mark_state = 0;
  D.6094 = 1;
  return D.6094;
  <D.6141>:
  D.6094 = 0;
  return D.6094;
  <D.6134>:
  GC_mark_stack_top.31 = GC_mark_stack_top;
  GC_mark_stack.15 = GC_mark_stack;
  if (GC_mark_stack_top.31 >= GC_mark_stack.15) goto <D.6143>; else goto <D.6144>;
  <D.6143>:
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6102 = GC_mark_stack_size.16 * 16;
  D.6103 = GC_mark_stack.15 + D.6102;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_top.32 = GC_mark_stack_top;
  GC_mark_stack_top.33 = GC_mark_from (GC_mark_stack_top.32, GC_mark_stack.15, D.6103);
  GC_mark_stack_top = GC_mark_stack_top.33;
  D.6094 = 0;
  return D.6094;
  <D.6144>:
  GC_mark_state = 0;
  GC_mark_stack_too_small.30 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.30 != 0) goto <D.6147>; else goto <D.6148>;
  <D.6147>:
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6139 = GC_mark_stack_size.16 * 2;
  alloc_mark_stack (D.6139);
  <D.6148>:
  D.6094 = 1;
  return D.6094;
  <D.5632>:
  <D.5633>:
  GC_objects_are_marked.34 = GC_objects_are_marked;
  if (GC_objects_are_marked.34 == 0) goto <D.6150>; else goto <D.6151>;
  <D.6150>:
  GC_mark_state = 2;
  D.6094 = 0;
  return D.6094;
  <D.6151>:
  GC_mark_stack_top.35 = GC_mark_stack_top;
  GC_mark_stack.15 = GC_mark_stack;
  if (GC_mark_stack_top.35 >= GC_mark_stack.15) goto <D.6153>; else goto <D.6154>;
  <D.6153>:
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6102 = GC_mark_stack_size.16 * 16;
  D.6103 = GC_mark_stack.15 + D.6102;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_top.36 = GC_mark_stack_top;
  GC_mark_stack_top.37 = GC_mark_from (GC_mark_stack_top.36, GC_mark_stack.15, D.6103);
  GC_mark_stack_top = GC_mark_stack_top.37;
  D.6094 = 0;
  return D.6094;
  <D.6154>:
  scan_ptr.19 = scan_ptr;
  if (scan_ptr.19 == 0B) goto <D.6157>; else goto <D.6158>;
  <D.6157>:
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 == 5) goto <D.6159>; else goto <D.6160>;
  <D.6159>:
  GC_mark_stack_too_small.30 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.30 != 0) goto <D.6161>; else goto <D.6162>;
  <D.6161>:
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6139 = GC_mark_stack_size.16 * 2;
  alloc_mark_stack (D.6139);
  <D.6162>:
  GC_mark_state = 4;
  <D.6160>:
  <D.6158>:
  scan_ptr.19 = scan_ptr;
  scan_ptr.38 = GC_push_next_marked (scan_ptr.19);
  scan_ptr = scan_ptr.38;
  scan_ptr.19 = scan_ptr;
  if (scan_ptr.19 == 0B) goto <D.6164>; else goto <D.6165>;
  <D.6164>:
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 == 4) goto <D.6166>; else goto <D.6167>;
  <D.6166>:
  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.6168>; else goto <D.6169>;
  <D.6168>:
  GC_mark_state = 3;
  <D.6169>:
  <D.6167>:
  <D.6165>:
  D.6094 = 0;
  return D.6094;
  <D.5634>:
  GC_abort ("GC_mark_some: bad state");
  D.6094 = 0;
  return D.6094;
}


alloc_mark_stack (word n)
{
  long unsigned int D.6171;
  long unsigned int GC_mark_stack_size.39;
  long unsigned int GC_page_size.40;
  long unsigned int D.6178;
  struct mse * GC_mark_stack.41;
  long unsigned int GC_mark_stack.42;
  long unsigned int D.6181;
  long unsigned int size.43;
  long unsigned int D.6185;
  long unsigned int D.6186;
  long unsigned int D.6187;
  long unsigned int D.6190;
  struct hblk * D.6191;
  long unsigned int D.6192;
  struct mse * GC_mark_stack_limit.44;
  int GC_print_stats.45;
  long int GC_mark_stack_size.46;
  long int n.47;
  struct mse * GC_mark_stack_top.48;
  struct mse * new_stack;

  D.6171 = n * 16;
  new_stack = GC_scratch_alloc (D.6171);
  GC_mark_stack_too_small = 0;
  GC_mark_stack_size.39 = GC_mark_stack_size;
  if (GC_mark_stack_size.39 != 0) goto <D.6173>; else goto <D.6174>;
  <D.6173>:
  if (new_stack != 0B) goto <D.6175>; else goto <D.6176>;
  <D.6175>:
  {
    word displ;
    signed_word size;

    GC_page_size.40 = GC_page_size;
    D.6178 = GC_page_size.40 + 18446744073709551615;
    GC_mark_stack.41 = GC_mark_stack;
    GC_mark_stack.42 = (long unsigned int) GC_mark_stack.41;
    displ = D.6178 & GC_mark_stack.42;
    GC_mark_stack_size.39 = GC_mark_stack_size;
    D.6181 = GC_mark_stack_size.39 * 16;
    size = (signed_word) D.6181;
    if (displ != 0) goto <D.6182>; else goto <D.6183>;
    <D.6182>:
    GC_page_size.40 = GC_page_size;
    displ = GC_page_size.40 - displ;
    <D.6183>:
    size.43 = (long unsigned int) size;
    D.6185 = size.43 - displ;
    GC_page_size.40 = GC_page_size;
    D.6186 = -GC_page_size.40;
    D.6187 = D.6185 & D.6186;
    size = (signed_word) D.6187;
    if (size > 0) goto <D.6188>; else goto <D.6189>;
    <D.6188>:
    size.43 = (long unsigned int) size;
    GC_mark_stack.41 = GC_mark_stack;
    GC_mark_stack.42 = (long unsigned int) GC_mark_stack.41;
    D.6190 = GC_mark_stack.42 + displ;
    D.6191 = (struct hblk *) D.6190;
    GC_add_to_heap (D.6191, size.43);
    <D.6189>:
    GC_mark_stack = new_stack;
    GC_mark_stack_size = n;
    D.6192 = n * 16;
    GC_mark_stack_limit.44 = new_stack + D.6192;
    GC_mark_stack_limit = GC_mark_stack_limit.44;
    GC_print_stats.45 = GC_print_stats;
    if (GC_print_stats.45 != 0) goto <D.6195>; else goto <D.6196>;
    <D.6195>:
    GC_mark_stack_size.39 = GC_mark_stack_size;
    GC_mark_stack_size.46 = (long int) GC_mark_stack_size.39;
    GC_printf ("Grew mark stack to %lu frames\n", GC_mark_stack_size.46, 0, 0, 0, 0, 0);
    <D.6196>:
  }
  goto <D.6198>;
  <D.6176>:
  GC_print_stats.45 = GC_print_stats;
  if (GC_print_stats.45 != 0) goto <D.6199>; else goto <D.6200>;
  <D.6199>:
  n.47 = (long int) n;
  GC_printf ("Failed to grow mark stack to %lu frames\n", n.47, 0, 0, 0, 0, 0);
  <D.6200>:
  <D.6198>:
  goto <D.6202>;
  <D.6174>:
  if (new_stack == 0B) goto <D.6203>; else goto <D.6204>;
  <D.6203>:
  GC_err_puts ("No space for mark stack\n");
  exit (1);
  <D.6204>:
  GC_mark_stack = new_stack;
  GC_mark_stack_size = n;
  D.6192 = n * 16;
  GC_mark_stack_limit.44 = new_stack + D.6192;
  GC_mark_stack_limit = GC_mark_stack_limit.44;
  <D.6202>:
  GC_mark_stack.41 = GC_mark_stack;
  GC_mark_stack_top.48 = GC_mark_stack.41 + 18446744073709551600;
  GC_mark_stack_top = GC_mark_stack_top.48;
}


GC_mark_stack_empty ()
{
  GC_bool D.6206;
  struct mse * GC_mark_stack_top.49;
  struct mse * GC_mark_stack.50;
  _Bool D.6209;

  GC_mark_stack_top.49 = GC_mark_stack_top;
  GC_mark_stack.50 = GC_mark_stack;
  D.6209 = GC_mark_stack_top.49 < GC_mark_stack.50;
  D.6206 = (GC_bool) D.6209;
  return D.6206;
}


GC_find_start (char * current, struct hdr * hhdr, struct hdr * * new_hdr_p)
{
  int GC_all_interior_pointers.51;
  long unsigned int current.52;
  long unsigned int D.6217;
  long unsigned int hhdr.53;
  long unsigned int D.6219;
  sizetype D.6220;
  unsigned char D.6221;
  int D.6222;
  int D.6223;
  char * D.6226;
  long int orig.54;
  long int current.55;
  long int D.6229;
  long int D.6230;
  long unsigned int D.6231;
  long int D.6232;

  GC_all_interior_pointers.51 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.51 != 0) goto <D.6212>; else goto <D.6213>;
  <D.6212>:
  if (hhdr != 0B) goto <D.6214>; else goto <D.6215>;
  <D.6214>:
  {
    register char * orig;

    orig = current;
    current.52 = (long unsigned int) current;
    D.6217 = current.52 & 18446744073709547520;
    current = (char *) D.6217;
    <D.5643>:
    hhdr.53 = (long unsigned int) hhdr;
    D.6219 = hhdr.53 * 4096;
    D.6220 = -D.6219;
    current = current + D.6220;
    hhdr = GC_find_header (current);
    hhdr.53 = (long unsigned int) hhdr;
    if (hhdr.53 <= 4095) goto <D.5643>; else goto <D.5644>;
    <D.5644>:
    D.6221 = hhdr->hb_flags;
    D.6222 = (int) D.6221;
    D.6223 = D.6222 & 1;
    if (D.6223 != 0) goto <D.6224>; else goto <D.6225>;
    <D.6224>:
    D.6226 = orig;
    return D.6226;
    <D.6225>:
    orig.54 = (long int) orig;
    current.55 = (long int) current;
    D.6229 = orig.54 - current.55;
    D.6230 = D.6229 /[ex] 8;
    D.6231 = hhdr->hb_sz;
    D.6232 = (long int) D.6231;
    if (D.6230 >= D.6232) goto <D.6233>; else goto <D.6234>;
    <D.6233>:
    D.6226 = orig;
    return D.6226;
    <D.6234>:
    *new_hdr_p = hhdr;
    D.6226 = current;
    return D.6226;
  }
  <D.6215>:
  D.6226 = current;
  return D.6226;
  <D.6213>:
  D.6226 = current;
  return D.6226;
}


GC_invalidate_mark_state ()
{
  struct mse * GC_mark_stack.56;
  struct mse * GC_mark_stack_top.57;

  GC_mark_state = 5;
  GC_mark_stack.56 = GC_mark_stack;
  GC_mark_stack_top.57 = GC_mark_stack.56 + 18446744073709551600;
  GC_mark_stack_top = GC_mark_stack_top.57;
}


GC_signal_mark_stack_overflow (struct mse * msp)
{
  int GC_print_stats.58;
  long unsigned int GC_mark_stack_size.59;
  long int GC_mark_stack_size.60;
  struct mse * D.6243;

  GC_mark_state = 5;
  GC_mark_stack_too_small = 1;
  GC_print_stats.58 = GC_print_stats;
  if (GC_print_stats.58 != 0) goto <D.6239>; else goto <D.6240>;
  <D.6239>:
  GC_mark_stack_size.59 = GC_mark_stack_size;
  GC_mark_stack_size.60 = (long int) GC_mark_stack_size.59;
  GC_printf ("Mark stack overflow; current size = %lu entries\n", GC_mark_stack_size.60, 0, 0, 0, 0, 0);
  <D.6240>:
  D.6243 = msp + 18446744073709543424;
  return D.6243;
}


GC_mark_from (struct mse * mark_stack_top, struct mse * mark_stack, struct mse * mark_stack_limit)
{
  long unsigned int D.6245;
  int GC_parallel.61;
  struct mse * D.6253;
  long unsigned int D.6256;
  int D.6257;
  long unsigned int D.6258;
  long unsigned int D.6259;
  sizetype D.6260;
  long unsigned int D.6261;
  long unsigned int D.6262;
  unsigned int credit.62;
  unsigned int D.6264;
  long int descr.63;
  char * current.64;
  _Bool D.6269;
  _Bool D.6270;
  _Bool D.6271;
  long unsigned int my_current.65;
  long unsigned int D.6275;
  long unsigned int D.6276;
  long unsigned int D.6277;
  long unsigned int D.6278;
  long unsigned int D.6282;
  long unsigned int D.6283;
  struct bottom_index * D.6285;
  long unsigned int D.6286;
  long unsigned int my_hhdr.66;
  struct hdr * GC_invalid_header.67;
  long int my_current.68;
  int D.6293;
  map_entry_type * D.6294;
  sizetype D.6295;
  map_entry_type * D.6296;
  unsigned char D.6297;
  long unsigned int D.6302;
  long unsigned int D.6303;
  long unsigned int D.6304;
  long unsigned int D.6305;
  int GC_all_interior_pointers.69;
  int D.6317;
  sizetype D.6318;
  int D.6319;
  long unsigned int D.6320;
  long unsigned int D.6322;
  int D.6323;
  long unsigned int D.6329;
  long unsigned int D.6330;
  sizetype my_current.70;
  sizetype D.6332;
  sizetype D.6333;
  GC_word * D.6334;
  long unsigned int D.6335;
  long unsigned int D.6336;
  struct GC_ms_entry * (*<Tb64>) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word) D.6337;
  long unsigned int D.6338;
  sizetype D.6341;
  word * D.6342;
  sizetype D.6346;
  char * D.6347;
  long int current_p.71;
  long int limit.72;
  long int D.6354;
  unsigned int D.6355;
  unsigned int D.6356;
  char * deferred.73;
  _Bool D.6358;
  _Bool D.6359;
  _Bool D.6360;
  long unsigned int my_current.74;
  long unsigned int D.6368;
  long unsigned int D.6369;
  long unsigned int D.6370;
  long unsigned int D.6371;
  long unsigned int D.6375;
  long unsigned int D.6376;
  long unsigned int D.6378;
  long unsigned int my_hhdr.75;
  long int my_current.76;
  int D.6384;
  map_entry_type * D.6385;
  sizetype D.6386;
  map_entry_type * D.6387;
  unsigned char D.6388;
  long unsigned int D.6393;
  long unsigned int D.6394;
  long unsigned int D.6395;
  long unsigned int D.6396;
  int D.6407;
  sizetype D.6408;
  int D.6409;
  long unsigned int D.6410;
  long unsigned int D.6412;
  int D.6413;
  long unsigned int D.6419;
  long unsigned int D.6420;
  sizetype my_current.77;
  sizetype D.6422;
  sizetype D.6423;
  GC_word * D.6424;
  long unsigned int my_current.78;
  long unsigned int D.6426;
  long unsigned int D.6427;
  long unsigned int D.6428;
  long unsigned int D.6429;
  long unsigned int D.6433;
  long unsigned int D.6434;
  long unsigned int D.6436;
  long unsigned int my_hhdr.79;
  long int my_current.80;
  int D.6442;
  map_entry_type * D.6443;
  sizetype D.6444;
  map_entry_type * D.6445;
  unsigned char D.6446;
  long unsigned int D.6451;
  long unsigned int D.6452;
  long unsigned int D.6453;
  long unsigned int D.6454;
  int D.6465;
  sizetype D.6466;
  int D.6467;
  long unsigned int D.6468;
  long unsigned int D.6470;
  int D.6471;
  long unsigned int D.6477;
  long unsigned int D.6478;
  sizetype my_current.81;
  sizetype D.6480;
  sizetype D.6481;
  GC_word * D.6482;
  long int mark_stack_top.82;
  long int mark_stack.83;
  long int D.6485;
  long int D.6486;
  long int D.6487;
  struct mse * D.6488;
  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.5692>;
      <D.5743>:
      current_p = mark_stack_top->mse_start;
      descr = mark_stack_top->mse_descr;
      retry:
      D.6245 = descr & 18446744073709550595;
      if (D.6245 != 0) goto <D.6246>; else goto <D.6247>;
      <D.6246>:
      {
        word tag;

        tag = descr & 3;
        switch (tag) <default: <D.6350>, case 0: <D.5665>, case 1: <D.5668>, case 2: <D.5693>, case 3: <D.5694>>
        <D.5665>:
        if (descr > 2048) goto <D.6248>; else goto <D.6249>;
        <D.6248>:
        GC_parallel.61 = GC_parallel;
        if (GC_parallel.61 != 0) goto <D.6251>; else goto <D.6252>;
        <D.6251>:
        D.6253 = mark_stack_limit + 18446744073709551600;
        if (D.6253 > mark_stack_top) goto <D.6254>; else goto <D.6255>;
        <D.6254>:
        {
          int new_size;

          D.6256 = descr / 2;
          D.6257 = (int) D.6256;
          new_size = D.6257 & -8;
          mark_stack_top->mse_start = current_p;
          D.6258 = (long unsigned int) new_size;
          D.6259 = D.6258 + 8;
          mark_stack_top->mse_descr = D.6259;
          mark_stack_top = mark_stack_top + 16;
          D.6260 = (sizetype) new_size;
          current_p = current_p + D.6260;
          D.6261 = (long unsigned int) new_size;
          descr = descr - D.6261;
          goto retry;
        }
        <D.6255>:
        <D.6252>:
        <D.6249>:
        limit = current_p + 1016;
        mark_stack_top->mse_start = limit;
        D.6262 = descr + 18446744073709550600;
        mark_stack_top->mse_descr = D.6262;
        limit = limit;
        goto <D.5667>;
        <D.5668>:
        mark_stack_top = mark_stack_top + 18446744073709551600;
        descr = descr & 18446744073709551612;
        credit.62 = (unsigned int) credit;
        D.6264 = credit.62 + 4294967040;
        credit = (int) D.6264;
        goto <D.5690>;
        <D.5689>:
        descr.63 = (long int) descr;
        if (descr.63 < 0) goto <D.6266>; else goto <D.6267>;
        <D.6266>:
        current = *current_p;
        current.64 = (char *) current;
        D.6269 = current.64 >= least_ha;
        current.64 = (char *) current;
        D.6270 = current.64 < greatest_ha;
        D.6271 = D.6269 & D.6270;
        if (D.6271 != 0) goto <D.6272>; else goto <D.6273>;
        <D.6272>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.65 = (long unsigned int) my_current;
            D.6275 = my_current.65 >> 12;
            D.6276 = D.6275 & 7;
            D.6277 = D.6276 * 16;
            hce = &hdr_cache + D.6277;
            D.6278 = hce->block_addr;
            my_current.65 = (long unsigned int) my_current;
            D.6275 = my_current.65 >> 12;
            if (D.6278 == D.6275) goto <D.6279>; else goto <D.6280>;
            <D.6279>:
            my_hhdr = hce->hce_hdr;
            goto <D.6281>;
            <D.6280>:
            {
              register struct hdr * * _ha;

              {
                register struct bottom_index * bi;

                {
                  register word hi;
                  register struct bottom_index * _bi;

                  my_current.65 = (long unsigned int) my_current;
                  hi = my_current.65 >> 22;
                  D.6282 = hi & 2047;
                  _bi = GC_arrays._top_index[D.6282];
                  goto <D.5677>;
                  <D.5676>:
                  _bi = _bi->hash_link;
                  <D.5677>:
                  D.6283 = _bi->key;
                  if (D.6283 != hi) goto <D.6284>; else goto <D.5678>;
                  <D.6284>:
                  D.6285 = GC_arrays._all_nils;
                  if (D.6285 != _bi) goto <D.5676>; else goto <D.5678>;
                  <D.5678>:
                  bi = _bi;
                }
                my_current.65 = (long unsigned int) my_current;
                D.6275 = my_current.65 >> 12;
                D.6286 = D.6275 & 1023;
                _ha = &bi->index[D.6286];
              }
              my_hhdr = *_ha;
            }
            my_hhdr.66 = (long unsigned int) my_hhdr;
            if (my_hhdr.66 <= 4095) goto <D.6288>; else goto <D.6289>;
            <D.6288>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.67 = GC_invalid_header;
                  new_hdr = GC_invalid_header.67;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6291>;
            <D.6289>:
            my_current.65 = (long unsigned int) my_current;
            D.6275 = my_current.65 >> 12;
            hce->block_addr = D.6275;
            hce->hce_hdr = my_hhdr;
            <D.6291>:
            <D.6281>:
          }
          {
            int displ;
            int map_entry;

            my_current.68 = (long int) my_current;
            D.6293 = (int) my_current.68;
            displ = D.6293 & 4095;
            D.6294 = my_hhdr->hb_map;
            D.6295 = (sizetype) displ;
            D.6296 = D.6294 + D.6295;
            D.6297 = *D.6296;
            map_entry = (int) D.6297;
            displ = displ >> 3;
            if (map_entry > 253) goto <D.6298>; else goto <D.6299>;
            <D.6298>:
            if (map_entry == 254) goto <D.6300>; else goto <D.6301>;
            <D.6300>:
            D.6302 = (long unsigned int) displ;
            D.6303 = my_hhdr->hb_sz;
            D.6304 = D.6302 % D.6303;
            map_entry = (int) D.6304;
            displ = displ - map_entry;
            D.6302 = (long unsigned int) displ;
            D.6303 = my_hhdr->hb_sz;
            D.6305 = D.6302 + D.6303;
            if (D.6305 > 512) goto <D.6306>; else goto <D.6307>;
            <D.6306>:
            GC_all_interior_pointers.69 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.69 != 0) goto <D.6309>; else goto <D.6310>;
            <D.6309>:
            my_current.65 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.65);
            goto <D.6311>;
            <D.6310>:
            my_current.65 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.65);
            <D.6311>:
            goto exit1;
            <D.6307>:
            goto <D.6312>;
            <D.6301>:
            GC_all_interior_pointers.69 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.69 != 0) goto <D.6313>; else goto <D.6314>;
            <D.6313>:
            my_current.65 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.65);
            goto <D.6315>;
            <D.6314>:
            my_current.65 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.65);
            <D.6315>:
            goto exit1;
            <D.6312>:
            goto <D.6316>;
            <D.6299>:
            displ = displ - map_entry;
            <D.6316>:
            {
              register word * mark_word_addr;

              D.6317 = displ >> 6;
              D.6318 = (sizetype) D.6317;
              mark_word_addr = &my_hhdr->hb_marks[D.6318];
              {
                word old;
                word my_bits;

                D.6319 = displ & 63;
                my_bits = 1 << D.6319;
                <D.5686>:
                old = MEM[(volatile word *)mark_word_addr];
                D.6320 = old & my_bits;
                if (D.6320 != 0) goto exit1; else goto <D.6321>;
                <D.6321>:
                D.6322 = old | my_bits;
                D.6323 = GC_compare_and_exchange (mark_word_addr, old, D.6322);
                if (D.6323 == 0) goto <D.5686>; else goto <D.5687>;
                <D.5687>:
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6324>; else goto <D.6325>;
              <D.6324>:
              goto <D.6326>;
              <D.6325>:
              mark_stack_top = mark_stack_top + 16;
              if (mark_stack_top >= mark_stack_limit) goto <D.6327>; else goto <D.6328>;
              <D.6327>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6328>:
              D.6329 = (long unsigned int) displ;
              D.6330 = D.6329 * 8;
              my_current.70 = (sizetype) my_current;
              D.6332 = my_current.70 & 18446744073709547520;
              D.6333 = D.6330 + D.6332;
              D.6334 = (GC_word *) D.6333;
              mark_stack_top->mse_start = D.6334;
              mark_stack_top->mse_descr = _descr;
              <D.6326>:
            }
          }
          exit1:
        }
        <D.6273>:
        <D.6267>:
        descr = descr << 1;
        current_p = current_p + 8;
        <D.5690>:
        if (descr != 0) goto <D.5689>; else goto <D.5691>;
        <D.5691>:
        // predicted unlikely by continue predictor.
        goto <D.5692>;
        <D.5693>:
        mark_stack_top = mark_stack_top + 18446744073709551600;
        credit = credit + -100;
        D.6335 = descr >> 2;
        D.6336 = D.6335 & 63;
        D.6337 = GC_arrays._mark_procs[D.6336];
        D.6338 = descr >> 8;
        mark_stack_top = D.6337 (current_p, mark_stack_top, mark_stack_limit, D.6338);
        // predicted unlikely by continue predictor.
        goto <D.5692>;
        <D.5694>:
        descr.63 = (long int) descr;
        if (descr.63 >= 0) goto <D.6339>; else goto <D.6340>;
        <D.6339>:
        D.6341 = descr + 18446744073709551613;
        D.6342 = current_p + D.6341;
        descr = *D.6342;
        goto <D.6343>;
        <D.6340>:
        {
          char * type_descr;

          type_descr = MEM[(char * *)current_p];
          if (type_descr == 0B) goto <D.6344>; else goto <D.6345>;
          <D.6344>:
          mark_stack_top = mark_stack_top + 18446744073709551600;
          // predicted unlikely by continue predictor.
          goto <D.5692>;
          <D.6345>:
          D.6346 = 18446744073709551603 - descr;
          D.6347 = type_descr + D.6346;
          descr = MEM[(word *)D.6347];
        }
        <D.6343>:
        if (descr == 0) goto <D.6348>; else goto <D.6349>;
        <D.6348>:
        mark_stack_top = mark_stack_top + 18446744073709551600;
        // predicted unlikely by continue predictor.
        goto <D.5692>;
        <D.6349>:
        goto retry;
        <D.6350>:
        <D.5667>:
      }
      goto <D.6351>;
      <D.6247>:
      mark_stack_top = mark_stack_top + 18446744073709551600;
      limit = current_p + descr;
      <D.6351>:
      current_p.71 = (long int) current_p;
      limit.72 = (long int) limit;
      D.6354 = current_p.71 - limit.72;
      D.6355 = (unsigned int) D.6354;
      credit.62 = (unsigned int) credit;
      D.6356 = D.6355 + credit.62;
      credit = (int) D.6356;
      limit = limit + 18446744073709551608;
      {
        word deferred;

        <D.5699>:
        deferred = *limit;
        limit = limit + 18446744073709551608;
        deferred.73 = (char *) deferred;
        D.6358 = deferred.73 >= least_ha;
        deferred.73 = (char *) deferred;
        D.6359 = deferred.73 < greatest_ha;
        D.6360 = D.6358 & D.6359;
        if (D.6360 != 0) goto <D.5697>; else goto <D.6361>;
        <D.6361>:
        if (current_p > limit) goto next_object; else goto <D.6362>;
        <D.6362>:
        deferred = *limit;
        limit = limit + 18446744073709551608;
        deferred.73 = (char *) deferred;
        D.6358 = deferred.73 >= least_ha;
        deferred.73 = (char *) deferred;
        D.6359 = deferred.73 < greatest_ha;
        D.6360 = D.6358 & D.6359;
        if (D.6360 != 0) goto <D.5697>; else goto <D.6363>;
        <D.6363>:
        if (current_p > limit) goto next_object; else goto <D.6364>;
        <D.6364>:
        goto <D.5699>;
        <D.5697>:
        goto <D.5721>;
        <D.5720>:
        current = *current_p;
        current.64 = (char *) current;
        D.6269 = current.64 >= least_ha;
        current.64 = (char *) current;
        D.6270 = current.64 < greatest_ha;
        D.6271 = D.6269 & D.6270;
        if (D.6271 != 0) goto <D.6365>; else goto <D.6366>;
        <D.6365>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.74 = (long unsigned int) my_current;
            D.6368 = my_current.74 >> 12;
            D.6369 = D.6368 & 7;
            D.6370 = D.6369 * 16;
            hce = &hdr_cache + D.6370;
            D.6371 = hce->block_addr;
            my_current.74 = (long unsigned int) my_current;
            D.6368 = my_current.74 >> 12;
            if (D.6371 == D.6368) goto <D.6372>; else goto <D.6373>;
            <D.6372>:
            my_hhdr = hce->hce_hdr;
            goto <D.6374>;
            <D.6373>:
            {
              register struct hdr * * _ha;

              {
                register struct bottom_index * bi;

                {
                  register word hi;
                  register struct bottom_index * _bi;

                  my_current.74 = (long unsigned int) my_current;
                  hi = my_current.74 >> 22;
                  D.6375 = hi & 2047;
                  _bi = GC_arrays._top_index[D.6375];
                  goto <D.5708>;
                  <D.5707>:
                  _bi = _bi->hash_link;
                  <D.5708>:
                  D.6376 = _bi->key;
                  if (D.6376 != hi) goto <D.6377>; else goto <D.5709>;
                  <D.6377>:
                  D.6285 = GC_arrays._all_nils;
                  if (D.6285 != _bi) goto <D.5707>; else goto <D.5709>;
                  <D.5709>:
                  bi = _bi;
                }
                my_current.74 = (long unsigned int) my_current;
                D.6368 = my_current.74 >> 12;
                D.6378 = D.6368 & 1023;
                _ha = &bi->index[D.6378];
              }
              my_hhdr = *_ha;
            }
            my_hhdr.75 = (long unsigned int) my_hhdr;
            if (my_hhdr.75 <= 4095) goto <D.6380>; else goto <D.6381>;
            <D.6380>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.67 = GC_invalid_header;
                  new_hdr = GC_invalid_header.67;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6382>;
            <D.6381>:
            my_current.74 = (long unsigned int) my_current;
            D.6368 = my_current.74 >> 12;
            hce->block_addr = D.6368;
            hce->hce_hdr = my_hhdr;
            <D.6382>:
            <D.6374>:
          }
          {
            int displ;
            int map_entry;

            my_current.76 = (long int) my_current;
            D.6384 = (int) my_current.76;
            displ = D.6384 & 4095;
            D.6385 = my_hhdr->hb_map;
            D.6386 = (sizetype) displ;
            D.6387 = D.6385 + D.6386;
            D.6388 = *D.6387;
            map_entry = (int) D.6388;
            displ = displ >> 3;
            if (map_entry > 253) goto <D.6389>; else goto <D.6390>;
            <D.6389>:
            if (map_entry == 254) goto <D.6391>; else goto <D.6392>;
            <D.6391>:
            D.6393 = (long unsigned int) displ;
            D.6394 = my_hhdr->hb_sz;
            D.6395 = D.6393 % D.6394;
            map_entry = (int) D.6395;
            displ = displ - map_entry;
            D.6393 = (long unsigned int) displ;
            D.6394 = my_hhdr->hb_sz;
            D.6396 = D.6393 + D.6394;
            if (D.6396 > 512) goto <D.6397>; else goto <D.6398>;
            <D.6397>:
            GC_all_interior_pointers.69 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.69 != 0) goto <D.6399>; else goto <D.6400>;
            <D.6399>:
            my_current.74 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.74);
            goto <D.6401>;
            <D.6400>:
            my_current.74 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.74);
            <D.6401>:
            goto exit2;
            <D.6398>:
            goto <D.6402>;
            <D.6392>:
            GC_all_interior_pointers.69 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.69 != 0) goto <D.6403>; else goto <D.6404>;
            <D.6403>:
            my_current.74 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.74);
            goto <D.6405>;
            <D.6404>:
            my_current.74 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.74);
            <D.6405>:
            goto exit2;
            <D.6402>:
            goto <D.6406>;
            <D.6390>:
            displ = displ - map_entry;
            <D.6406>:
            {
              register word * mark_word_addr;

              D.6407 = displ >> 6;
              D.6408 = (sizetype) D.6407;
              mark_word_addr = &my_hhdr->hb_marks[D.6408];
              {
                word old;
                word my_bits;

                D.6409 = displ & 63;
                my_bits = 1 << D.6409;
                <D.5717>:
                old = MEM[(volatile word *)mark_word_addr];
                D.6410 = old & my_bits;
                if (D.6410 != 0) goto exit2; else goto <D.6411>;
                <D.6411>:
                D.6412 = old | my_bits;
                D.6413 = GC_compare_and_exchange (mark_word_addr, old, D.6412);
                if (D.6413 == 0) goto <D.5717>; else goto <D.5718>;
                <D.5718>:
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6414>; else goto <D.6415>;
              <D.6414>:
              goto <D.6416>;
              <D.6415>:
              mark_stack_top = mark_stack_top + 16;
              if (mark_stack_top >= mark_stack_limit) goto <D.6417>; else goto <D.6418>;
              <D.6417>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6418>:
              D.6419 = (long unsigned int) displ;
              D.6420 = D.6419 * 8;
              my_current.77 = (sizetype) my_current;
              D.6422 = my_current.77 & 18446744073709547520;
              D.6423 = D.6420 + D.6422;
              D.6424 = (GC_word *) D.6423;
              mark_stack_top->mse_start = D.6424;
              mark_stack_top->mse_descr = _descr;
              <D.6416>:
            }
          }
          exit2:
        }
        <D.6366>:
        current_p = current_p + 8;
        <D.5721>:
        if (current_p <= limit) goto <D.5720>; else goto <D.5722>;
        <D.5722>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.78 = (long unsigned int) my_current;
            D.6426 = my_current.78 >> 12;
            D.6427 = D.6426 & 7;
            D.6428 = D.6427 * 16;
            hce = &hdr_cache + D.6428;
            D.6429 = hce->block_addr;
            my_current.78 = (long unsigned int) my_current;
            D.6426 = my_current.78 >> 12;
            if (D.6429 == D.6426) goto <D.6430>; else goto <D.6431>;
            <D.6430>:
            my_hhdr = hce->hce_hdr;
            goto <D.6432>;
            <D.6431>:
            {
              register struct hdr * * _ha;

              {
                register struct bottom_index * bi;

                {
                  register word hi;
                  register struct bottom_index * _bi;

                  my_current.78 = (long unsigned int) my_current;
                  hi = my_current.78 >> 22;
                  D.6433 = hi & 2047;
                  _bi = GC_arrays._top_index[D.6433];
                  goto <D.5731>;
                  <D.5730>:
                  _bi = _bi->hash_link;
                  <D.5731>:
                  D.6434 = _bi->key;
                  if (D.6434 != hi) goto <D.6435>; else goto <D.5732>;
                  <D.6435>:
                  D.6285 = GC_arrays._all_nils;
                  if (D.6285 != _bi) goto <D.5730>; else goto <D.5732>;
                  <D.5732>:
                  bi = _bi;
                }
                my_current.78 = (long unsigned int) my_current;
                D.6426 = my_current.78 >> 12;
                D.6436 = D.6426 & 1023;
                _ha = &bi->index[D.6436];
              }
              my_hhdr = *_ha;
            }
            my_hhdr.79 = (long unsigned int) my_hhdr;
            if (my_hhdr.79 <= 4095) goto <D.6438>; else goto <D.6439>;
            <D.6438>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.67 = GC_invalid_header;
                  new_hdr = GC_invalid_header.67;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6440>;
            <D.6439>:
            my_current.78 = (long unsigned int) my_current;
            D.6426 = my_current.78 >> 12;
            hce->block_addr = D.6426;
            hce->hce_hdr = my_hhdr;
            <D.6440>:
            <D.6432>:
          }
          {
            int displ;
            int map_entry;

            my_current.80 = (long int) my_current;
            D.6442 = (int) my_current.80;
            displ = D.6442 & 4095;
            D.6443 = my_hhdr->hb_map;
            D.6444 = (sizetype) displ;
            D.6445 = D.6443 + D.6444;
            D.6446 = *D.6445;
            map_entry = (int) D.6446;
            displ = displ >> 3;
            if (map_entry > 253) goto <D.6447>; else goto <D.6448>;
            <D.6447>:
            if (map_entry == 254) goto <D.6449>; else goto <D.6450>;
            <D.6449>:
            D.6451 = (long unsigned int) displ;
            D.6452 = my_hhdr->hb_sz;
            D.6453 = D.6451 % D.6452;
            map_entry = (int) D.6453;
            displ = displ - map_entry;
            D.6451 = (long unsigned int) displ;
            D.6452 = my_hhdr->hb_sz;
            D.6454 = D.6451 + D.6452;
            if (D.6454 > 512) goto <D.6455>; else goto <D.6456>;
            <D.6455>:
            GC_all_interior_pointers.69 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.69 != 0) goto <D.6457>; else goto <D.6458>;
            <D.6457>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.78);
            goto <D.6459>;
            <D.6458>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.78);
            <D.6459>:
            goto exit4;
            <D.6456>:
            goto <D.6460>;
            <D.6450>:
            GC_all_interior_pointers.69 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.69 != 0) goto <D.6461>; else goto <D.6462>;
            <D.6461>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.78);
            goto <D.6463>;
            <D.6462>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.78);
            <D.6463>:
            goto exit4;
            <D.6460>:
            goto <D.6464>;
            <D.6448>:
            displ = displ - map_entry;
            <D.6464>:
            {
              register word * mark_word_addr;

              D.6465 = displ >> 6;
              D.6466 = (sizetype) D.6465;
              mark_word_addr = &my_hhdr->hb_marks[D.6466];
              {
                word old;
                word my_bits;

                D.6467 = displ & 63;
                my_bits = 1 << D.6467;
                <D.5740>:
                old = MEM[(volatile word *)mark_word_addr];
                D.6468 = old & my_bits;
                if (D.6468 != 0) goto exit4; else goto <D.6469>;
                <D.6469>:
                D.6470 = old | my_bits;
                D.6471 = GC_compare_and_exchange (mark_word_addr, old, D.6470);
                if (D.6471 == 0) goto <D.5740>; else goto <D.5741>;
                <D.5741>:
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6472>; else goto <D.6473>;
              <D.6472>:
              goto <D.6474>;
              <D.6473>:
              mark_stack_top = mark_stack_top + 16;
              if (mark_stack_top >= mark_stack_limit) goto <D.6475>; else goto <D.6476>;
              <D.6475>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6476>:
              D.6477 = (long unsigned int) displ;
              D.6478 = D.6477 * 8;
              my_current.81 = (sizetype) my_current;
              D.6480 = my_current.81 & 18446744073709547520;
              D.6481 = D.6478 + D.6480;
              D.6482 = (GC_word *) D.6481;
              mark_stack_top->mse_start = D.6482;
              mark_stack_top->mse_descr = _descr;
              <D.6474>:
            }
          }
          exit4:
        }
        next_object:
      }
      <D.5692>:
      mark_stack_top.82 = (long int) mark_stack_top;
      mark_stack.83 = (long int) mark_stack;
      D.6485 = mark_stack_top.82 - mark_stack.83;
      D.6486 = (long int) credit;
      D.6487 = D.6485 | D.6486;
      if (D.6487 >= 0) goto <D.5743>; else goto <D.5744>;
      <D.5744>:
      D.6488 = mark_stack_top;
      return D.6488;
    }
  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.6494;
  GC_word * D.6495;
  long unsigned int D.6496;
  long unsigned int D.6499;
  unsigned int D.6500;
  _Bool D.6501;
  _Bool D.6502;
  _Bool D.6503;
  struct mse * D.6504;
  struct mse * p;
  struct mse * top;
  unsigned int i;

  top = local + 18446744073709551600;
  i = 0;
  GC_memory_barrier ();
  p = low;
  goto <D.5762>;
  <D.5761>:
  {
    word descr;

    descr = p->mse_descr;
    GC_memory_barrier ();
    if (descr != 0) goto <D.6492>; else goto <D.6493>;
    <D.6492>:
    D.6494 = &p->mse_descr;
    MEM[(volatile word *)D.6494] = 0;
    top = top + 16;
    top->mse_descr = descr;
    D.6495 = p->mse_start;
    top->mse_start = D.6495;
    i = i + 1;
    D.6496 = descr & 3;
    if (D.6496 == 0) goto <D.6497>; else goto <D.6498>;
    <D.6497>:
    D.6499 = descr >> 8;
    D.6500 = (unsigned int) D.6499;
    i = D.6500 + i;
    <D.6498>:
    <D.6493>:
  }
  p = p + 16;
  <D.5762>:
  D.6501 = p <= high;
  D.6502 = i <= max;
  D.6503 = D.6501 & D.6502;
  if (D.6503 != 0) goto <D.5761>; else goto <D.5763>;
  <D.5763>:
  *next = p;
  D.6504 = top;
  return D.6504;
}


GC_memory_barrier ()
{
  __asm__ __volatile__("" :  :  : "memory");
}


GC_return_mark_stack (struct mse * low, struct mse * high)
{
  long int high.84;
  long int low.85;
  long int D.6510;
  long int D.6511;
  long int D.6512;
  long int my_start.86;
  struct mse * GC_mark_stack.87;
  long int GC_mark_stack.88;
  long int D.6516;
  long int D.6517;
  long unsigned int D.6518;
  long unsigned int D.6519;
  long unsigned int GC_mark_stack_size.89;
  int GC_print_stats.90;
  long unsigned int D.6527;
  long unsigned int D.6528;
  struct mse * GC_mark_stack_top.91;
  struct mse * my_top;
  struct mse * my_start;
  size_t stack_size;

  if (high < low) goto <D.6506>; else goto <D.6507>;
  <D.6506>:
  return;
  <D.6507>:
  high.84 = (long int) high;
  low.85 = (long int) low;
  D.6510 = high.84 - low.85;
  D.6511 = D.6510 /[ex] 16;
  D.6512 = D.6511 + 1;
  stack_size = (size_t) D.6512;
  GC_acquire_mark_lock ();
  my_top = GC_mark_stack_top;
  my_start = my_top + 16;
  my_start.86 = (long int) my_start;
  GC_mark_stack.87 = GC_mark_stack;
  GC_mark_stack.88 = (long int) GC_mark_stack.87;
  D.6516 = my_start.86 - GC_mark_stack.88;
  D.6517 = D.6516 /[ex] 16;
  D.6518 = (long unsigned int) D.6517;
  D.6519 = D.6518 + stack_size;
  GC_mark_stack_size.89 = GC_mark_stack_size;
  if (D.6519 > GC_mark_stack_size.89) goto <D.6521>; else goto <D.6522>;
  <D.6521>:
  GC_print_stats.90 = GC_print_stats;
  if (GC_print_stats.90 != 0) goto <D.6524>; else goto <D.6525>;
  <D.6524>:
  GC_printf ("No room to copy back mark stack.", 0, 0, 0, 0, 0, 0);
  <D.6525>:
  GC_mark_state = 5;
  GC_mark_stack_too_small = 1;
  goto <D.6526>;
  <D.6522>:
  D.6527 = stack_size * 16;
  memcpy (my_start, low, D.6527);
  GC_memory_barrier ();
  D.6528 = stack_size * 16;
  GC_mark_stack_top.91 = my_top + D.6528;
  GC_mark_stack_top = GC_mark_stack_top.91;
  <D.6526>:
  GC_release_mark_lock ();
  GC_notify_all_marker ();
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.6531;
  long unsigned int D.6532;

  D.6532 = __builtin_object_size (__dest, 0);
  D.6531 = __builtin___memcpy_chk (__dest, __src, __len, D.6532);
  return D.6531;
}


GC_do_local_mark (struct mse * local_mark_stack, struct mse * local_top)
{
  struct mse * D.6534;
  long int local_top.92;
  long int local_mark_stack.93;
  long int D.6539;
  long int D.6540;
  long unsigned int D.6541;
  struct mse * GC_mark_stack_top.94;
  struct mse * GC_first_nonempty.95;
  unsigned int GC_active_count.96;
  unsigned int GC_helper_count.97;
  struct mse * D.6552;
  long int D.6555;
  long unsigned int D.6556;
  long unsigned int D.6557;
  struct mse * D.6558;
  long int new_bottom.98;
  long int D.6560;
  long int D.6561;
  long int D.6562;
  long unsigned int D.6563;
  long unsigned int D.6564;
  long int D.6565;
  sizetype D.6566;
  sizetype D.6567;
  unsigned int n;

  <D.5781>:
  n = 0;
  goto <D.5777>;
  <D.5776>:
  D.6534 = local_mark_stack + 65536;
  local_top = GC_mark_from (local_top, local_mark_stack, D.6534);
  if (local_top < local_mark_stack) goto <D.6535>; else goto <D.6536>;
  <D.6535>:
  return;
  <D.6536>:
  local_top.92 = (long int) local_top;
  local_mark_stack.93 = (long int) local_mark_stack;
  D.6539 = local_top.92 - local_mark_stack.93;
  D.6540 = D.6539 /[ex] 16;
  D.6541 = (long unsigned int) D.6540;
  if (D.6541 > 2047) goto <D.6542>; else goto <D.6543>;
  <D.6542>:
  GC_return_mark_stack (local_mark_stack, local_top);
  return;
  <D.6543>:
  n = n + 1;
  <D.5777>:
  if (n == 0) goto <D.5776>; else goto <D.5778>;
  <D.5778>:
  GC_mark_stack_top.94 = GC_mark_stack_top;
  GC_first_nonempty.95 = GC_first_nonempty;
  if (GC_mark_stack_top.94 < GC_first_nonempty.95) goto <D.6546>; else goto <D.6547>;
  <D.6546>:
  GC_active_count.96 = GC_active_count;
  GC_helper_count.97 = GC_helper_count;
  if (GC_active_count.96 < GC_helper_count.97) goto <D.6550>; else goto <D.6551>;
  <D.6550>:
  D.6552 = local_mark_stack + 16;
  if (D.6552 < local_top) goto <D.6553>; else goto <D.6554>;
  <D.6553>:
  {
    struct mse * p;
    struct mse * new_bottom;

    local_top.92 = (long int) local_top;
    local_mark_stack.93 = (long int) local_mark_stack;
    D.6539 = local_top.92 - local_mark_stack.93;
    D.6540 = D.6539 /[ex] 16;
    D.6555 = D.6540 / 2;
    D.6556 = (long unsigned int) D.6555;
    D.6557 = D.6556 * 16;
    new_bottom = local_mark_stack + D.6557;
    D.6558 = new_bottom + 18446744073709551600;
    GC_return_mark_stack (local_mark_stack, D.6558);
    local_top.92 = (long int) local_top;
    new_bottom.98 = (long int) new_bottom;
    D.6560 = local_top.92 - new_bottom.98;
    D.6561 = D.6560 /[ex] 16;
    D.6562 = D.6561 + 1;
    D.6563 = (long unsigned int) D.6562;
    D.6564 = D.6563 * 16;
    memmove (local_mark_stack, new_bottom, D.6564);
    new_bottom.98 = (long int) new_bottom;
    local_mark_stack.93 = (long int) local_mark_stack;
    D.6565 = new_bottom.98 - local_mark_stack.93;
    D.6566 = (sizetype) D.6565;
    D.6567 = -D.6566;
    local_top = local_top + D.6567;
  }
  <D.6554>:
  <D.6551>:
  <D.6547>:
  goto <D.5781>;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.6569;
  long unsigned int D.6570;

  D.6570 = __builtin_object_size (__dest, 0);
  D.6569 = __builtin___memmove_chk (__dest, __src, __len, D.6570);
  return D.6569;
}


GC_mark_local (struct mse * local_mark_stack, int id)
{
  unsigned int GC_active_count.99;
  unsigned int GC_active_count.100;
  struct mse * GC_first_nonempty.101;
  struct mse * my_first_nonempty.102;
  long unsigned int my_first_nonempty.103;
  long unsigned int global_first_nonempty.104;
  long int my_top.105;
  long int my_first_nonempty.106;
  long int D.6585;
  long int D.6586;
  long int D.6587;
  unsigned int GC_active_count.107;
  struct mse * GC_first_nonempty.108;
  struct mse * GC_mark_stack_top.109;
  struct mse * GC_first_nonempty.110;
  struct mse * GC_mark_stack_top.111;
  unsigned int GC_helper_count.112;
  unsigned int GC_helper_count.113;
  unsigned int D.6612;
  struct mse * my_first_nonempty;

  try
    {
      GC_acquire_mark_lock ();
      GC_active_count.99 = GC_active_count;
      GC_active_count.100 = GC_active_count.99 + 1;
      GC_active_count = GC_active_count.100;
      GC_first_nonempty.101 = GC_first_nonempty;
      my_first_nonempty = GC_first_nonempty.101;
      GC_release_mark_lock ();
      <D.5799>:
      {
        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.102 = my_first_nonempty;
        if (my_first_nonempty.102 < global_first_nonempty) goto <D.6576>; else goto <D.6577>;
        <D.6576>:
        my_first_nonempty = global_first_nonempty;
        goto <D.6578>;
        <D.6577>:
        my_first_nonempty.102 = my_first_nonempty;
        if (global_first_nonempty < my_first_nonempty.102) goto <D.6579>; else goto <D.6580>;
        <D.6579>:
        my_first_nonempty.102 = my_first_nonempty;
        my_first_nonempty.103 = (long unsigned int) my_first_nonempty.102;
        global_first_nonempty.104 = (long unsigned int) global_first_nonempty;
        GC_compare_and_exchange (&GC_first_nonempty, global_first_nonempty.104, my_first_nonempty.103);
        <D.6580>:
        <D.6578>:
        my_top = GC_mark_stack_top;
        my_top.105 = (long int) my_top;
        my_first_nonempty.102 = my_first_nonempty;
        my_first_nonempty.106 = (long int) my_first_nonempty.102;
        D.6585 = my_top.105 - my_first_nonempty.106;
        D.6586 = D.6585 /[ex] 16;
        D.6587 = D.6586 + 1;
        n_on_stack = (size_t) D.6587;
        if (n_on_stack == 0) goto <D.6588>; else goto <D.6589>;
        <D.6588>:
        GC_acquire_mark_lock ();
        my_top = GC_mark_stack_top;
        my_top.105 = (long int) my_top;
        my_first_nonempty.102 = my_first_nonempty;
        my_first_nonempty.106 = (long int) my_first_nonempty.102;
        D.6585 = my_top.105 - my_first_nonempty.106;
        D.6586 = D.6585 /[ex] 16;
        D.6587 = D.6586 + 1;
        n_on_stack = (size_t) D.6587;
        if (n_on_stack == 0) goto <D.6590>; else goto <D.6591>;
        <D.6590>:
        GC_active_count.99 = GC_active_count;
        GC_active_count.107 = GC_active_count.99 + 4294967295;
        GC_active_count = GC_active_count.107;
        GC_active_count.99 = GC_active_count;
        if (GC_active_count.99 == 0) goto <D.6593>; else goto <D.6594>;
        <D.6593>:
        GC_notify_all_marker ();
        <D.6594>:
        goto <D.5795>;
        <D.5794>:
        GC_wait_marker ();
        <D.5795>:
        GC_active_count.99 = GC_active_count;
        if (GC_active_count.99 != 0) goto <D.6595>; else goto <D.5796>;
        <D.6595>:
        GC_first_nonempty.108 = GC_first_nonempty;
        GC_mark_stack_top.109 = GC_mark_stack_top;
        if (GC_first_nonempty.108 > GC_mark_stack_top.109) goto <D.5794>; else goto <D.5796>;
        <D.5796>:
        GC_active_count.99 = GC_active_count;
        if (GC_active_count.99 == 0) goto <D.6598>; else goto <D.6599>;
        <D.6598>:
        GC_first_nonempty.110 = GC_first_nonempty;
        GC_mark_stack_top.111 = GC_mark_stack_top;
        if (GC_first_nonempty.110 > GC_mark_stack_top.111) goto <D.6602>; else goto <D.6603>;
        <D.6602>:
        {
          GC_bool need_to_notify;

          need_to_notify = 0;
          GC_helper_count.112 = GC_helper_count;
          GC_helper_count.113 = GC_helper_count.112 + 4294967295;
          GC_helper_count = GC_helper_count.113;
          GC_helper_count.112 = GC_helper_count;
          if (GC_helper_count.112 == 0) goto <D.6606>; else goto <D.6607>;
          <D.6606>:
          need_to_notify = 1;
          <D.6607>:
          GC_release_mark_lock ();
          if (need_to_notify != 0) goto <D.6608>; else goto <D.6609>;
          <D.6608>:
          GC_notify_all_marker ();
          <D.6609>:
          return;
        }
        <D.6603>:
        <D.6599>:
        GC_active_count.99 = GC_active_count;
        GC_active_count.100 = GC_active_count.99 + 1;
        GC_active_count = GC_active_count.100;
        GC_release_mark_lock ();
        // predicted unlikely by continue predictor.
        goto <D.5798>;
        <D.6591>:
        GC_release_mark_lock ();
        <D.6589>:
        n_to_get = 5;
        if (n_on_stack <= 9) goto <D.6610>; else goto <D.6611>;
        <D.6610>:
        n_to_get = 1;
        <D.6611>:
        D.6612 = (unsigned int) n_to_get;
        my_first_nonempty.102 = my_first_nonempty;
        local_top = GC_steal_mark_stack (my_first_nonempty.102, my_top, local_mark_stack, D.6612, &my_first_nonempty);
        GC_do_local_mark (local_mark_stack, local_top);
      }
      <D.5798>:
      goto <D.5799>;
    }
  finally
    {
      my_first_nonempty = {CLOBBER};
    }
}


GC_do_parallel_mark ()
{
  int GC_help_wanted.114;
  unsigned int GC_active_count.115;
  unsigned int GC_helper_count.116;
  struct mse * GC_mark_stack.117;
  long unsigned int GC_mark_no.118;
  long unsigned int GC_mark_no.119;
  struct mse local_mark_stack[4096];
  struct mse * local_top;
  struct mse * my_top;

  try
    {
      GC_acquire_mark_lock ();
      GC_help_wanted.114 = GC_help_wanted;
      if (GC_help_wanted.114 != 0) goto <D.6615>; else goto <D.6618>;
      <D.6618>:
      GC_active_count.115 = GC_active_count;
      if (GC_active_count.115 != 0) goto <D.6615>; else goto <D.6620>;
      <D.6620>:
      GC_helper_count.116 = GC_helper_count;
      if (GC_helper_count.116 != 0) goto <D.6615>; else goto <D.6616>;
      <D.6615>:
      GC_abort ("Tried to start parallel mark in bad state");
      <D.6616>:
      GC_mark_stack.117 = GC_mark_stack;
      GC_first_nonempty = GC_mark_stack.117;
      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.5806>;
      <D.5805>:
      GC_wait_marker ();
      <D.5806>:
      GC_helper_count.116 = GC_helper_count;
      if (GC_helper_count.116 != 0) goto <D.5805>; else goto <D.5807>;
      <D.5807>:
      GC_mark_no.118 = GC_mark_no;
      GC_mark_no.119 = GC_mark_no.118 + 1;
      GC_mark_no = GC_mark_no.119;
      GC_release_mark_lock ();
      GC_notify_all_marker ();
    }
  finally
    {
      local_mark_stack = {CLOBBER};
    }
}


GC_help_marker (word my_mark_no)
{
  int GC_parallel.120;
  long unsigned int GC_mark_no.121;
  int GC_help_wanted.122;
  long int D.6635;
  long int GC_markers.123;
  unsigned int GC_helper_count.124;
  int my_id.125;
  struct mse local_mark_stack[4096];
  unsigned int my_id;
  struct mse * my_first_nonempty;

  try
    {
      GC_parallel.120 = GC_parallel;
      if (GC_parallel.120 == 0) goto <D.6626>; else goto <D.6627>;
      <D.6626>:
      return;
      <D.6627>:
      GC_acquire_mark_lock ();
      goto <D.5815>;
      <D.5814>:
      GC_wait_marker ();
      <D.5815>:
      GC_mark_no.121 = GC_mark_no;
      if (GC_mark_no.121 < my_mark_no) goto <D.5814>; else goto <D.6629>;
      <D.6629>:
      GC_help_wanted.122 = GC_help_wanted;
      if (GC_help_wanted.122 == 0) goto <D.6631>; else goto <D.5816>;
      <D.6631>:
      GC_mark_no.121 = GC_mark_no;
      if (GC_mark_no.121 == my_mark_no) goto <D.5814>; else goto <D.5816>;
      <D.5816>:
      my_id = GC_helper_count;
      GC_mark_no.121 = GC_mark_no;
      if (GC_mark_no.121 != my_mark_no) goto <D.6632>; else goto <D.6634>;
      <D.6634>:
      D.6635 = (long int) my_id;
      GC_markers.123 = GC_markers;
      if (D.6635 >= GC_markers.123) goto <D.6632>; else goto <D.6633>;
      <D.6632>:
      GC_release_mark_lock ();
      return;
      <D.6633>:
      GC_helper_count.124 = my_id + 1;
      GC_helper_count = GC_helper_count.124;
      GC_release_mark_lock ();
      my_id.125 = (int) my_id;
      GC_mark_local (&local_mark_stack, my_id.125);
    }
  finally
    {
      local_mark_stack = {CLOBBER};
    }
}


GC_mark_init ()
{
  alloc_mark_stack (4096);
}


GC_push_all (char * bottom, char * top)
{
  long unsigned int bottom.126;
  long unsigned int D.6643;
  long unsigned int D.6644;
  long unsigned int top.127;
  long unsigned int D.6646;
  _Bool D.6647;
  _Bool D.6648;
  _Bool D.6649;
  struct mse * GC_mark_stack_top.128;
  struct mse * GC_mark_stack_top.129;
  struct mse * GC_mark_stack_top.130;
  struct mse * GC_mark_stack_limit.131;
  long int top.132;
  long int bottom.133;
  long int D.6660;
  struct mse * GC_mark_stack_top.134;
  struct mse * GC_mark_stack_top.135;
  register word length;

  bottom.126 = (long unsigned int) bottom;
  D.6643 = bottom.126 + 7;
  D.6644 = D.6643 & 18446744073709551608;
  bottom = (char *) D.6644;
  top.127 = (long unsigned int) top;
  D.6646 = top.127 & 18446744073709551608;
  top = (char *) D.6646;
  D.6647 = top == 0B;
  D.6648 = bottom == top;
  D.6649 = D.6647 | D.6648;
  if (D.6649 != 0) goto <D.6650>; else goto <D.6651>;
  <D.6650>:
  return;
  <D.6651>:
  GC_mark_stack_top.128 = GC_mark_stack_top;
  GC_mark_stack_top.129 = GC_mark_stack_top.128 + 16;
  GC_mark_stack_top = GC_mark_stack_top.129;
  GC_mark_stack_top.130 = GC_mark_stack_top;
  GC_mark_stack_limit.131 = GC_mark_stack_limit;
  if (GC_mark_stack_top.130 >= GC_mark_stack_limit.131) goto <D.6656>; else goto <D.6657>;
  <D.6656>:
  GC_abort ("unexpected mark stack overflow");
  <D.6657>:
  top.132 = (long int) top;
  bottom.133 = (long int) bottom;
  D.6660 = top.132 - bottom.133;
  length = (word) D.6660;
  GC_mark_stack_top.134 = GC_mark_stack_top;
  GC_mark_stack_top.134->mse_start = bottom;
  GC_mark_stack_top.135 = GC_mark_stack_top;
  GC_mark_stack_top.135->mse_descr = length;
}


GC_push_selected (char * bottom, char * top, int (*<Tfeb>) (struct hblk *) dirty_fn, void (*<Tfee>) (char *, char *) push_fn)
{
  long int bottom.136;
  long int D.6665;
  long int D.6666;
  long int top.137;
  long int D.6668;
  _Bool D.6669;
  _Bool D.6670;
  _Bool D.6671;
  char * D.6674;
  long unsigned int D.6675;
  long unsigned int D.6676;
  struct hblk * D.6679;
  int D.6680;
  int D.6683;
  int D.6686;
  struct mse * GC_mark_stack_top.138;
  long int GC_mark_stack_top.139;
  struct mse * GC_mark_stack.140;
  long int GC_mark_stack.141;
  long int D.6693;
  long int D.6694;
  long unsigned int D.6695;
  long unsigned int GC_mark_stack_size.142;
  long unsigned int D.6697;
  long unsigned int D.6698;
  char * D.6701;
  int D.6704;
  struct mse * GC_mark_stack_top.143;
  struct mse * GC_mark_stack_limit.144;
  register struct hblk * h;

  bottom.136 = (long int) bottom;
  D.6665 = bottom.136 + 7;
  D.6666 = D.6665 & -8;
  bottom = (char *) D.6666;
  top.137 = (long int) top;
  D.6668 = top.137 & -8;
  top = (char *) D.6668;
  D.6669 = top == 0B;
  D.6670 = bottom == top;
  D.6671 = D.6669 | D.6670;
  if (D.6671 != 0) goto <D.6672>; else goto <D.6673>;
  <D.6672>:
  return;
  <D.6673>:
  D.6674 = bottom + 4096;
  D.6675 = (long unsigned int) D.6674;
  D.6676 = D.6675 & 18446744073709547520;
  h = (struct hblk *) D.6676;
  if (top <= h) goto <D.6677>; else goto <D.6678>;
  <D.6677>:
  D.6679 = h + 18446744073709547520;
  D.6680 = dirty_fn (D.6679);
  if (D.6680 != 0) goto <D.6681>; else goto <D.6682>;
  <D.6681>:
  push_fn (bottom, top);
  <D.6682>:
  return;
  <D.6678>:
  D.6679 = h + 18446744073709547520;
  D.6683 = dirty_fn (D.6679);
  if (D.6683 != 0) goto <D.6684>; else goto <D.6685>;
  <D.6684>:
  push_fn (bottom, h);
  <D.6685>:
  goto <D.5841>;
  <D.5840>:
  D.6686 = dirty_fn (h);
  if (D.6686 != 0) goto <D.6687>; else goto <D.6688>;
  <D.6687>:
  GC_mark_stack_top.138 = GC_mark_stack_top;
  GC_mark_stack_top.139 = (long int) GC_mark_stack_top.138;
  GC_mark_stack.140 = GC_mark_stack;
  GC_mark_stack.141 = (long int) GC_mark_stack.140;
  D.6693 = GC_mark_stack_top.139 - GC_mark_stack.141;
  D.6694 = D.6693 /[ex] 16;
  D.6695 = (long unsigned int) D.6694;
  GC_mark_stack_size.142 = GC_mark_stack_size;
  D.6697 = GC_mark_stack_size.142 * 3;
  D.6698 = D.6697 / 4;
  if (D.6695 > D.6698) goto <D.6699>; else goto <D.6700>;
  <D.6699>:
  push_fn (h, top);
  return;
  <D.6700>:
  D.6701 = h + 4096;
  push_fn (h, D.6701);
  <D.6688>:
  h = h + 4096;
  <D.5841>:
  D.6701 = h + 4096;
  if (D.6701 <= top) goto <D.5840>; else goto <D.5842>;
  <D.5842>:
  if (h != top) goto <D.6702>; else goto <D.6703>;
  <D.6702>:
  D.6704 = dirty_fn (h);
  if (D.6704 != 0) goto <D.6705>; else goto <D.6706>;
  <D.6705>:
  push_fn (h, top);
  <D.6706>:
  <D.6703>:
  GC_mark_stack_top.143 = GC_mark_stack_top;
  GC_mark_stack_limit.144 = GC_mark_stack_limit;
  if (GC_mark_stack_top.143 >= GC_mark_stack_limit.144) goto <D.6709>; else goto <D.6710>;
  <D.6709>:
  GC_abort ("unexpected mark stack overflow");
  <D.6710>:
}


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

  D.6712 = 1;
  return D.6712;
}


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

  if (all != 0) goto <D.6714>; else goto <D.6715>;
  <D.6714>:
  GC_dirty_maintained.145 = GC_dirty_maintained;
  if (GC_dirty_maintained.145 != 0) goto <D.6717>; else goto <D.6718>;
  <D.6717>:
  GC_push_all (bottom, top);
  goto <D.6719>;
  <D.6718>:
  GC_push_all (bottom, top);
  <D.6719>:
  goto <D.6720>;
  <D.6715>:
  GC_push_selected (bottom, top, GC_page_was_dirty, GC_push_all);
  <D.6720>:
}


GC_push_one (word p)
{
  char * p.146;
  void * GC_least_plausible_heap_addr.147;
  void * GC_greatest_plausible_heap_addr.148;

  p.146 = (char *) p;
  GC_least_plausible_heap_addr.147 = GC_least_plausible_heap_addr;
  if (p.146 >= GC_least_plausible_heap_addr.147) goto <D.6723>; else goto <D.6724>;
  <D.6723>:
  p.146 = (char *) p;
  GC_greatest_plausible_heap_addr.148 = GC_greatest_plausible_heap_addr;
  if (p.146 < GC_greatest_plausible_heap_addr.148) goto <D.6726>; else goto <D.6727>;
  <D.6726>:
  GC_mark_and_push_stack (p);
  <D.6727>:
  <D.6724>:
}


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.149;
  long unsigned int D.6729;
  long unsigned int D.6730;
  struct bottom_index * D.6732;
  long unsigned int D.6733;
  long unsigned int D.6734;
  long unsigned int my_hhdr.150;
  struct hdr * GC_invalid_header.151;
  long int my_current.152;
  int D.6740;
  map_entry_type * D.6741;
  sizetype D.6742;
  map_entry_type * D.6743;
  unsigned char D.6744;
  long unsigned int D.6749;
  long unsigned int D.6750;
  long unsigned int D.6751;
  long unsigned int D.6752;
  int GC_all_interior_pointers.153;
  int D.6764;
  sizetype D.6765;
  int D.6766;
  long unsigned int D.6767;
  long unsigned int D.6769;
  int D.6770;
  long unsigned int D.6776;
  long unsigned int D.6777;
  sizetype my_current.154;
  sizetype D.6779;
  sizetype D.6780;
  GC_word * D.6781;
  struct GC_ms_entry * D.6782;
  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.149 = (long unsigned int) my_current;
          hi = my_current.149 >> 22;
          D.6729 = hi & 2047;
          _bi = GC_arrays._top_index[D.6729];
          goto <D.5867>;
          <D.5866>:
          _bi = _bi->hash_link;
          <D.5867>:
          D.6730 = _bi->key;
          if (D.6730 != hi) goto <D.6731>; else goto <D.5868>;
          <D.6731>:
          D.6732 = GC_arrays._all_nils;
          if (D.6732 != _bi) goto <D.5866>; else goto <D.5868>;
          <D.5868>:
          bi = _bi;
        }
        my_current.149 = (long unsigned int) my_current;
        D.6733 = my_current.149 >> 12;
        D.6734 = D.6733 & 1023;
        _ha = &bi->index[D.6734];
      }
      my_hhdr = *_ha;
    }
    my_hhdr.150 = (long unsigned int) my_hhdr;
    if (my_hhdr.150 <= 4095) goto <D.6736>; else goto <D.6737>;
    <D.6736>:
    {
      struct hdr * new_hdr;

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

      my_current.152 = (long int) my_current;
      D.6740 = (int) my_current.152;
      displ = D.6740 & 4095;
      D.6741 = my_hhdr->hb_map;
      D.6742 = (sizetype) displ;
      D.6743 = D.6741 + D.6742;
      D.6744 = *D.6743;
      map_entry = (int) D.6744;
      displ = displ >> 3;
      if (map_entry > 253) goto <D.6745>; else goto <D.6746>;
      <D.6745>:
      if (map_entry == 254) goto <D.6747>; else goto <D.6748>;
      <D.6747>:
      D.6749 = (long unsigned int) displ;
      D.6750 = my_hhdr->hb_sz;
      D.6751 = D.6749 % D.6750;
      map_entry = (int) D.6751;
      displ = displ - map_entry;
      D.6749 = (long unsigned int) displ;
      D.6750 = my_hhdr->hb_sz;
      D.6752 = D.6749 + D.6750;
      if (D.6752 > 512) goto <D.6753>; else goto <D.6754>;
      <D.6753>:
      GC_all_interior_pointers.153 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.153 != 0) goto <D.6756>; else goto <D.6757>;
      <D.6756>:
      my_current.149 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.149);
      goto <D.6758>;
      <D.6757>:
      my_current.149 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.149);
      <D.6758>:
      goto was_marked;
      <D.6754>:
      goto <D.6759>;
      <D.6748>:
      GC_all_interior_pointers.153 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.153 != 0) goto <D.6760>; else goto <D.6761>;
      <D.6760>:
      my_current.149 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.149);
      goto <D.6762>;
      <D.6761>:
      my_current.149 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.149);
      <D.6762>:
      goto was_marked;
      <D.6759>:
      goto <D.6763>;
      <D.6746>:
      displ = displ - map_entry;
      <D.6763>:
      {
        register word * mark_word_addr;

        D.6764 = displ >> 6;
        D.6765 = (sizetype) D.6764;
        mark_word_addr = &my_hhdr->hb_marks[D.6765];
        {
          word old;
          word my_bits;

          D.6766 = displ & 63;
          my_bits = 1 << D.6766;
          <D.5876>:
          old = MEM[(volatile word *)mark_word_addr];
          D.6767 = old & my_bits;
          if (D.6767 != 0) goto was_marked; else goto <D.6768>;
          <D.6768>:
          D.6769 = old | my_bits;
          D.6770 = GC_compare_and_exchange (mark_word_addr, old, D.6769);
          if (D.6770 == 0) goto <D.5876>; else goto <D.5877>;
          <D.5877>:
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.6771>; else goto <D.6772>;
        <D.6771>:
        goto <D.6773>;
        <D.6772>:
        mark_stack_ptr = mark_stack_ptr + 16;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.6774>; else goto <D.6775>;
        <D.6774>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.6775>:
        D.6776 = (long unsigned int) displ;
        D.6777 = D.6776 * 8;
        my_current.154 = (sizetype) my_current;
        D.6779 = my_current.154 & 18446744073709547520;
        D.6780 = D.6777 + D.6779;
        D.6781 = (GC_word *) D.6780;
        mark_stack_ptr->mse_start = D.6781;
        mark_stack_ptr->mse_descr = _descr;
        <D.6773>:
      }
    }
    was_marked:
  }
  D.6782 = mark_stack_ptr;
  return D.6782;
}


GC_mark_and_push_stack (word p)
{
  long unsigned int D.6784;
  long unsigned int D.6785;
  struct bottom_index * D.6787;
  long unsigned int D.6788;
  long unsigned int D.6789;
  long unsigned int hhdr.155;
  void * p.156;
  void * D.6796;
  char * r.157;
  long unsigned int D.6798;
  long unsigned int D.6799;
  int D.6801;
  map_entry_type * D.6802;
  sizetype D.6803;
  map_entry_type * D.6804;
  int GC_all_interior_pointers.158;
  void * D.6812;
  int D.6816;
  long unsigned int D.6817;
  long unsigned int D.6818;
  sizetype D.6819;
  int D.6823;
  long unsigned int D.6824;
  int D.6825;
  long unsigned int D.6826;
  long unsigned int D.6827;
  sizetype D.6830;
  long unsigned int D.6831;
  long unsigned int D.6832;
  word * D.6833;
  int D.6834;
  struct mse * GC_mark_stack_top.159;
  struct mse * GC_mark_stack_top.160;
  struct mse * GC_mark_stack_top.161;
  struct mse * GC_mark_stack_limit.162;
  struct mse * GC_mark_stack_top.163;
  struct mse * GC_mark_stack_top.164;
  struct mse * GC_mark_stack_top.165;
  GC_word * r.166;
  struct mse * GC_mark_stack_top.167;
  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.6784 = hi & 2047;
        _bi = GC_arrays._top_index[D.6784];
        goto <D.5890>;
        <D.5889>:
        _bi = _bi->hash_link;
        <D.5890>:
        D.6785 = _bi->key;
        if (D.6785 != hi) goto <D.6786>; else goto <D.5891>;
        <D.6786>:
        D.6787 = GC_arrays._all_nils;
        if (D.6787 != _bi) goto <D.5889>; else goto <D.5891>;
        <D.5891>:
        bi = _bi;
      }
      D.6788 = p >> 12;
      D.6789 = D.6788 & 1023;
      _ha = &bi->index[D.6789];
    }
    hhdr = *_ha;
  }
  hhdr.155 = (long unsigned int) hhdr;
  if (hhdr.155 <= 4095) goto <D.6791>; else goto <D.6792>;
  <D.6791>:
  if (hhdr != 0B) goto <D.6793>; else goto <D.6794>;
  <D.6793>:
  p.156 = (void *) p;
  D.6796 = GC_base (p.156);
  r = (word) D.6796;
  r.157 = (char *) r;
  hhdr = GC_find_header (r.157);
  D.6798 = r & 4095;
  D.6799 = D.6798 >> 3;
  displ = (int) D.6799;
  <D.6794>:
  goto <D.6800>;
  <D.6792>:
  {
    register map_entry_type map_entry;

    D.6801 = (int) p;
    displ = D.6801 & 4095;
    D.6802 = hhdr->hb_map;
    D.6803 = (sizetype) displ;
    D.6804 = D.6802 + D.6803;
    map_entry = *D.6804;
    if (map_entry > 252) goto <D.6805>; else goto <D.6806>;
    <D.6805>:
    if (map_entry == 254) goto <D.6807>; else goto <D.6810>;
    <D.6810>:
    GC_all_interior_pointers.158 = GC_all_interior_pointers;
    if (GC_all_interior_pointers.158 == 0) goto <D.6807>; else goto <D.6808>;
    <D.6807>:
    p.156 = (void *) p;
    D.6812 = GC_base (p.156);
    r = (word) D.6812;
    D.6798 = r & 4095;
    D.6799 = D.6798 >> 3;
    displ = (int) D.6799;
    if (r == 0) goto <D.6813>; else goto <D.6814>;
    <D.6813>:
    hhdr = 0B;
    <D.6814>:
    goto <D.6809>;
    <D.6808>:
    hhdr = 0B;
    <D.6809>:
    goto <D.6815>;
    <D.6806>:
    displ = displ >> 3;
    D.6816 = (int) map_entry;
    displ = displ - D.6816;
    D.6817 = (long unsigned int) displ;
    D.6818 = D.6817 * 8;
    D.6819 = p & 18446744073709547520;
    r = D.6818 + D.6819;
    <D.6815>:
  }
  <D.6800>:
  if (hhdr == 0B) goto <D.6820>; else goto <D.6821>;
  <D.6820>:
  GC_add_to_black_list_stack (p);
  goto <D.6822>;
  <D.6821>:
  D.6823 = displ >> 6;
  D.6824 = hhdr->hb_marks[D.6823];
  D.6825 = displ & 63;
  D.6826 = D.6824 >> D.6825;
  D.6827 = D.6826 & 1;
  if (D.6827 == 0) goto <D.6828>; else goto <D.6829>;
  <D.6828>:
  {
    word old;

    <D.5894>:
    D.6823 = displ >> 6;
    D.6830 = (sizetype) D.6823;
    old = hhdr->hb_marks[D.6830];
    D.6825 = displ & 63;
    D.6831 = 1 << D.6825;
    D.6832 = D.6831 | old;
    D.6823 = displ >> 6;
    D.6830 = (sizetype) D.6823;
    D.6833 = &hhdr->hb_marks[D.6830];
    D.6834 = GC_compare_and_exchange (D.6833, old, D.6832);
    if (D.6834 == 0) goto <D.5894>; else goto <D.5895>;
    <D.5895>:
  }
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.6835>; else goto <D.6836>;
    <D.6835>:
    goto <D.6837>;
    <D.6836>:
    GC_mark_stack_top.159 = GC_mark_stack_top;
    GC_mark_stack_top.160 = GC_mark_stack_top.159 + 16;
    GC_mark_stack_top = GC_mark_stack_top.160;
    GC_mark_stack_top.161 = GC_mark_stack_top;
    GC_mark_stack_limit.162 = GC_mark_stack_limit;
    if (GC_mark_stack_top.161 >= GC_mark_stack_limit.162) goto <D.6842>; else goto <D.6843>;
    <D.6842>:
    GC_mark_stack_top.163 = GC_mark_stack_top;
    GC_mark_stack_top.164 = GC_signal_mark_stack_overflow (GC_mark_stack_top.163);
    GC_mark_stack_top = GC_mark_stack_top.164;
    <D.6843>:
    GC_mark_stack_top.165 = GC_mark_stack_top;
    r.166 = (GC_word *) r;
    GC_mark_stack_top.165->mse_start = r.166;
    GC_mark_stack_top.167 = GC_mark_stack_top;
    GC_mark_stack_top.167->mse_descr = _descr;
    <D.6837>:
  }
  <D.6829>:
  <D.6822>:
}


GC_push_all_eager (char * bottom, char * top)
{
  long unsigned int bottom.168;
  long unsigned int D.6850;
  long unsigned int D.6851;
  long unsigned int top.169;
  long unsigned int D.6853;
  char * q.170;
  _Bool D.6857;
  _Bool D.6858;
  _Bool D.6859;
  word * b;
  word * t;
  register word * p;
  register word q;
  register word * lim;
  register char * greatest_ha;
  register char * least_ha;

  bottom.168 = (long unsigned int) bottom;
  D.6850 = bottom.168 + 7;
  D.6851 = D.6850 & 18446744073709551608;
  b = (word *) D.6851;
  top.169 = (long unsigned int) top;
  D.6853 = top.169 & 18446744073709551608;
  t = (word *) D.6853;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  if (top == 0B) goto <D.6854>; else goto <D.6855>;
  <D.6854>:
  return;
  <D.6855>:
  lim = t + 18446744073709551608;
  p = b;
  goto <D.5909>;
  <D.5908>:
  q = *p;
  q.170 = (char *) q;
  D.6857 = q.170 >= least_ha;
  q.170 = (char *) q;
  D.6858 = q.170 < greatest_ha;
  D.6859 = D.6857 & D.6858;
  if (D.6859 != 0) goto <D.6860>; else goto <D.6861>;
  <D.6860>:
  GC_mark_and_push_stack (q);
  <D.6861>:
  p = p + 8;
  <D.5909>:
  if (p <= lim) goto <D.5908>; else goto <D.5910>;
  <D.5910>:
}


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

  GC_all_interior_pointers.171 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.171 != 0) goto <D.6864>; else goto <D.6865>;
  <D.6864>:
  GC_push_all (bottom, top);
  goto <D.6866>;
  <D.6865>:
  GC_push_all_eager (bottom, top);
  <D.6866>:
}


GC_push_marked1 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.172;
  long unsigned int D.6868;
  word * mark_word_addr.173;
  long unsigned int D.6870;
  long unsigned int D.6873;
  long unsigned int D.6874;
  word * D.6875;
  char * q.174;
  _Bool D.6877;
  _Bool D.6878;
  _Bool D.6879;
  void * * D.6882;
  void * q.175;
  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.172 = (long unsigned int) h;
  D.6868 = h.172 + 4096;
  plim = (word *) D.6868;
  goto <D.5933>;
  <D.5932>:
  mark_word_addr.173 = mark_word_addr;
  mark_word_addr = mark_word_addr.173 + 8;
  mark_word = *mark_word_addr.173;
  i = 0;
  goto <D.5930>;
  <D.5929>:
  D.6870 = mark_word & 1;
  if (D.6870 != 0) goto <D.6871>; else goto <D.6872>;
  <D.6871>:
  D.6873 = (long unsigned int) i;
  D.6874 = D.6873 * 8;
  D.6875 = p + D.6874;
  q = *D.6875;
  q.174 = (char *) q;
  D.6877 = q.174 >= least_ha;
  q.174 = (char *) q;
  D.6878 = q.174 < greatest_ha;
  D.6879 = D.6877 & D.6878;
  if (D.6879 != 0) goto <D.6880>; else goto <D.6881>;
  <D.6880>:
  D.6873 = (long unsigned int) i;
  D.6874 = D.6873 * 8;
  D.6882 = p + D.6874;
  q.175 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.175, mark_stack_top, mark_stack_limit, D.6882);
  <D.6881>:
  <D.6872>:
  i = i + 1;
  mark_word = mark_word >> 1;
  <D.5930>:
  if (mark_word != 0) goto <D.5929>; else goto <D.5931>;
  <D.5931>:
  p = p + 512;
  <D.5933>:
  if (p < plim) goto <D.5932>; else goto <D.5934>;
  <D.5934>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked2 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.176;
  long unsigned int D.6885;
  word * mark_word_addr.177;
  long unsigned int D.6887;
  long unsigned int D.6890;
  long unsigned int D.6891;
  word * D.6892;
  char * q.178;
  _Bool D.6894;
  _Bool D.6895;
  _Bool D.6896;
  void * * D.6899;
  void * q.179;
  sizetype D.6901;
  sizetype D.6902;
  sizetype D.6903;
  word * D.6904;
  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.176 = (long unsigned int) h;
  D.6885 = h.176 + 4096;
  plim = (word *) D.6885;
  goto <D.5953>;
  <D.5952>:
  mark_word_addr.177 = mark_word_addr;
  mark_word_addr = mark_word_addr.177 + 8;
  mark_word = *mark_word_addr.177;
  i = 0;
  goto <D.5950>;
  <D.5949>:
  D.6887 = mark_word & 1;
  if (D.6887 != 0) goto <D.6888>; else goto <D.6889>;
  <D.6888>:
  D.6890 = (long unsigned int) i;
  D.6891 = D.6890 * 8;
  D.6892 = p + D.6891;
  q = *D.6892;
  q.178 = (char *) q;
  D.6894 = q.178 >= least_ha;
  q.178 = (char *) q;
  D.6895 = q.178 < greatest_ha;
  D.6896 = D.6894 & D.6895;
  if (D.6896 != 0) goto <D.6897>; else goto <D.6898>;
  <D.6897>:
  D.6890 = (long unsigned int) i;
  D.6891 = D.6890 * 8;
  D.6899 = p + D.6891;
  q.179 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.179, mark_stack_top, mark_stack_limit, D.6899);
  <D.6898>:
  D.6901 = (sizetype) i;
  D.6902 = D.6901 + 1;
  D.6903 = D.6902 * 8;
  D.6904 = p + D.6903;
  q = *D.6904;
  q.178 = (char *) q;
  D.6894 = q.178 >= least_ha;
  q.178 = (char *) q;
  D.6895 = q.178 < greatest_ha;
  D.6896 = D.6894 & D.6895;
  if (D.6896 != 0) goto <D.6905>; else goto <D.6906>;
  <D.6905>:
  D.6890 = (long unsigned int) i;
  D.6891 = D.6890 * 8;
  D.6899 = p + D.6891;
  q.179 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.179, mark_stack_top, mark_stack_limit, D.6899);
  <D.6906>:
  <D.6889>:
  i = i + 2;
  mark_word = mark_word >> 2;
  <D.5950>:
  if (mark_word != 0) goto <D.5949>; else goto <D.5951>;
  <D.5951>:
  p = p + 512;
  <D.5953>:
  if (p < plim) goto <D.5952>; else goto <D.5954>;
  <D.5954>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked4 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.180;
  long unsigned int D.6908;
  word * mark_word_addr.181;
  long unsigned int D.6910;
  long unsigned int D.6913;
  long unsigned int D.6914;
  word * D.6915;
  char * q.182;
  _Bool D.6917;
  _Bool D.6918;
  _Bool D.6919;
  void * * D.6922;
  void * q.183;
  sizetype D.6924;
  sizetype D.6925;
  sizetype D.6926;
  word * D.6927;
  sizetype D.6930;
  sizetype D.6931;
  word * D.6932;
  sizetype D.6935;
  sizetype D.6936;
  word * D.6937;
  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.180 = (long unsigned int) h;
  D.6908 = h.180 + 4096;
  plim = (word *) D.6908;
  goto <D.5973>;
  <D.5972>:
  mark_word_addr.181 = mark_word_addr;
  mark_word_addr = mark_word_addr.181 + 8;
  mark_word = *mark_word_addr.181;
  i = 0;
  goto <D.5970>;
  <D.5969>:
  D.6910 = mark_word & 1;
  if (D.6910 != 0) goto <D.6911>; else goto <D.6912>;
  <D.6911>:
  D.6913 = (long unsigned int) i;
  D.6914 = D.6913 * 8;
  D.6915 = p + D.6914;
  q = *D.6915;
  q.182 = (char *) q;
  D.6917 = q.182 >= least_ha;
  q.182 = (char *) q;
  D.6918 = q.182 < greatest_ha;
  D.6919 = D.6917 & D.6918;
  if (D.6919 != 0) goto <D.6920>; else goto <D.6921>;
  <D.6920>:
  D.6913 = (long unsigned int) i;
  D.6914 = D.6913 * 8;
  D.6922 = p + D.6914;
  q.183 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.183, mark_stack_top, mark_stack_limit, D.6922);
  <D.6921>:
  D.6924 = (sizetype) i;
  D.6925 = D.6924 + 1;
  D.6926 = D.6925 * 8;
  D.6927 = p + D.6926;
  q = *D.6927;
  q.182 = (char *) q;
  D.6917 = q.182 >= least_ha;
  q.182 = (char *) q;
  D.6918 = q.182 < greatest_ha;
  D.6919 = D.6917 & D.6918;
  if (D.6919 != 0) goto <D.6928>; else goto <D.6929>;
  <D.6928>:
  D.6924 = (sizetype) i;
  D.6925 = D.6924 + 1;
  D.6926 = D.6925 * 8;
  D.6927 = p + D.6926;
  q.183 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.183, mark_stack_top, mark_stack_limit, D.6927);
  <D.6929>:
  D.6924 = (sizetype) i;
  D.6930 = D.6924 + 2;
  D.6931 = D.6930 * 8;
  D.6932 = p + D.6931;
  q = *D.6932;
  q.182 = (char *) q;
  D.6917 = q.182 >= least_ha;
  q.182 = (char *) q;
  D.6918 = q.182 < greatest_ha;
  D.6919 = D.6917 & D.6918;
  if (D.6919 != 0) goto <D.6933>; else goto <D.6934>;
  <D.6933>:
  D.6924 = (sizetype) i;
  D.6930 = D.6924 + 2;
  D.6931 = D.6930 * 8;
  D.6932 = p + D.6931;
  q.183 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.183, mark_stack_top, mark_stack_limit, D.6932);
  <D.6934>:
  D.6924 = (sizetype) i;
  D.6935 = D.6924 + 3;
  D.6936 = D.6935 * 8;
  D.6937 = p + D.6936;
  q = *D.6937;
  q.182 = (char *) q;
  D.6917 = q.182 >= least_ha;
  q.182 = (char *) q;
  D.6918 = q.182 < greatest_ha;
  D.6919 = D.6917 & D.6918;
  if (D.6919 != 0) goto <D.6938>; else goto <D.6939>;
  <D.6938>:
  D.6924 = (sizetype) i;
  D.6935 = D.6924 + 3;
  D.6936 = D.6935 * 8;
  D.6937 = p + D.6936;
  q.183 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.183, mark_stack_top, mark_stack_limit, D.6937);
  <D.6939>:
  <D.6912>:
  i = i + 4;
  mark_word = mark_word >> 4;
  <D.5970>:
  if (mark_word != 0) goto <D.5969>; else goto <D.5971>;
  <D.5971>:
  p = p + 512;
  <D.5973>:
  if (p < plim) goto <D.5972>; else goto <D.5974>;
  <D.5974>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.6940;
  long unsigned int D.6941;
  int D.6944;
  long unsigned int GC_n_rescuing_pages.184;
  long unsigned int GC_n_rescuing_pages.185;
  unsigned int sz.186;
  sizetype D.6953;
  sizetype D.6954;
  sizetype D.6955;
  int D.6956;
  long unsigned int D.6957;
  int D.6958;
  long unsigned int D.6959;
  long unsigned int D.6960;
  long unsigned int D.6968;
  long unsigned int D.6969;
  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.6940 = hhdr->hb_sz;
  sz = (int) D.6940;
  D.6941 = hhdr->hb_descr;
  descr = (int) D.6941;
  mark_stack_limit = GC_mark_stack_limit;
  if (descr == 0) goto <D.6942>; else goto <D.6943>;
  <D.6942>:
  return;
  <D.6943>:
  D.6944 = GC_block_empty (hhdr);
  if (D.6944 != 0) goto <D.6945>; else goto <D.6946>;
  <D.6945>:
  return;
  <D.6946>:
  GC_n_rescuing_pages.184 = GC_n_rescuing_pages;
  GC_n_rescuing_pages.185 = GC_n_rescuing_pages.184 + 1;
  GC_n_rescuing_pages = GC_n_rescuing_pages.185;
  GC_objects_are_marked = 1;
  sz.186 = (unsigned int) sz;
  if (sz.186 > 256) goto <D.6950>; else goto <D.6951>;
  <D.6950>:
  lim = h;
  goto <D.6952>;
  <D.6951>:
  D.6953 = (sizetype) sz;
  D.6954 = D.6953 * 18446744073709551608;
  D.6955 = D.6954 + 4096;
  lim = h + D.6955;
  <D.6952>:
  switch (sz) <default: <D.5990>, case 1: <D.5986>, case 2: <D.5988>, case 4: <D.5989>>
  <D.5986>:
  GC_push_marked1 (h, hhdr);
  goto <D.5987>;
  <D.5988>:
  GC_push_marked2 (h, hhdr);
  goto <D.5987>;
  <D.5989>:
  GC_push_marked4 (h, hhdr);
  goto <D.5987>;
  <D.5990>:
  GC_mark_stack_top_reg = GC_mark_stack_top;
  p = h;
  word_no = 0;
  goto <D.5993>;
  <D.5992>:
  D.6956 = word_no >> 6;
  D.6957 = hhdr->hb_marks[D.6956];
  D.6958 = word_no & 63;
  D.6959 = D.6957 >> D.6958;
  D.6960 = D.6959 & 1;
  if (D.6960 != 0) goto <D.6961>; else goto <D.6962>;
  <D.6961>:
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.6963>; else goto <D.6964>;
    <D.6963>:
    goto <D.6965>;
    <D.6964>:
    GC_mark_stack_top_reg = GC_mark_stack_top_reg + 16;
    if (GC_mark_stack_top_reg >= mark_stack_limit) goto <D.6966>; else goto <D.6967>;
    <D.6966>:
    GC_mark_stack_top_reg = GC_signal_mark_stack_overflow (GC_mark_stack_top_reg);
    <D.6967>:
    GC_mark_stack_top_reg->mse_start = p;
    GC_mark_stack_top_reg->mse_descr = _descr;
    <D.6965>:
  }
  <D.6962>:
  D.6968 = (long unsigned int) sz;
  D.6969 = D.6968 * 8;
  p = p + D.6969;
  word_no = word_no + sz;
  <D.5993>:
  if (p <= lim) goto <D.5992>; else goto <D.5994>;
  <D.5994>:
  GC_mark_stack_top = GC_mark_stack_top_reg;
  <D.5987>:
}


GC_block_was_dirty (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.6971;
  unsigned int sz.187;
  GC_bool D.6975;
  int D.6976;
  sizetype D.6979;
  char * D.6980;
  register int sz;

  D.6971 = hhdr->hb_sz;
  sz = (int) D.6971;
  sz.187 = (unsigned int) sz;
  if (sz.187 <= 256) goto <D.6973>; else goto <D.6974>;
  <D.6973>:
  D.6975 = GC_page_was_dirty (h);
  return D.6975;
  <D.6974>:
  {
    register char * p;

    p = h;
    sz = sz << 3;
    goto <D.6002>;
    <D.6001>:
    D.6976 = GC_page_was_dirty (p);
    if (D.6976 != 0) goto <D.6977>; else goto <D.6978>;
    <D.6977>:
    D.6975 = 1;
    return D.6975;
    <D.6978>:
    p = p + 4096;
    <D.6002>:
    D.6979 = (sizetype) sz;
    D.6980 = h + D.6979;
    if (D.6980 > p) goto <D.6001>; else goto <D.6003>;
    <D.6003>:
    D.6975 = 0;
    return D.6975;
  }
}


GC_push_next_marked (struct hblk * h)
{
  struct hblk * D.6984;
  long unsigned int D.6985;
  long unsigned int D.6986;
  long unsigned int D.6987;
  long unsigned int D.6988;
  long unsigned int D.6989;
  register struct hdr * hhdr;

  h = GC_next_used_block (h);
  if (h == 0B) goto <D.6982>; else goto <D.6983>;
  <D.6982>:
  D.6984 = 0B;
  return D.6984;
  <D.6983>:
  hhdr = GC_find_header (h);
  GC_push_marked (h, hhdr);
  D.6985 = hhdr->hb_sz;
  D.6986 = D.6985 << 3;
  D.6987 = D.6986 + 4095;
  D.6988 = D.6987 >> 12;
  D.6989 = D.6988 * 4096;
  D.6984 = h + D.6989;
  return D.6984;
}


GC_push_next_marked_dirty (struct hblk * h)
{
  int GC_dirty_maintained.188;
  struct hblk * D.6996;
  int D.6997;
  long unsigned int D.6999;
  long unsigned int D.7000;
  long unsigned int D.7001;
  long unsigned int D.7002;
  long unsigned int D.7003;
  register struct hdr * hhdr;

  GC_dirty_maintained.188 = GC_dirty_maintained;
  if (GC_dirty_maintained.188 == 0) goto <D.6992>; else goto <D.6993>;
  <D.6992>:
  GC_abort ("dirty bits not set up");
  <D.6993>:
  <D.6013>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.6994>; else goto <D.6995>;
  <D.6994>:
  D.6996 = 0B;
  return D.6996;
  <D.6995>:
  hhdr = GC_find_header (h);
  D.6997 = GC_block_was_dirty (h, hhdr);
  if (D.6997 != 0) goto <D.6012>; else goto <D.6998>;
  <D.6998>:
  D.6999 = hhdr->hb_sz;
  D.7000 = D.6999 << 3;
  D.7001 = D.7000 + 4095;
  D.7002 = D.7001 >> 12;
  D.7003 = D.7002 * 4096;
  h = h + D.7003;
  goto <D.6013>;
  <D.6012>:
  GC_push_marked (h, hhdr);
  D.6999 = hhdr->hb_sz;
  D.7000 = D.6999 << 3;
  D.7001 = D.7000 + 4095;
  D.7002 = D.7001 >> 12;
  D.7003 = D.7002 * 4096;
  D.6996 = h + D.7003;
  return D.6996;
}


GC_push_next_marked_uncollectable (struct hblk * h)
{
  struct hblk * D.7007;
  unsigned char D.7008;
  long unsigned int D.7010;
  long unsigned int D.7011;
  long unsigned int D.7012;
  long unsigned int D.7013;
  long unsigned int D.7014;
  register struct hdr * hhdr;

  hhdr = GC_find_header (h);
  <D.6019>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.7005>; else goto <D.7006>;
  <D.7005>:
  D.7007 = 0B;
  return D.7007;
  <D.7006>:
  hhdr = GC_find_header (h);
  D.7008 = hhdr->hb_obj_kind;
  if (D.7008 == 2) goto <D.6018>; else goto <D.7009>;
  <D.7009>:
  D.7010 = hhdr->hb_sz;
  D.7011 = D.7010 << 3;
  D.7012 = D.7011 + 4095;
  D.7013 = D.7012 >> 12;
  D.7014 = D.7013 * 4096;
  h = h + D.7014;
  goto <D.6019>;
  <D.6018>:
  GC_push_marked (h, hhdr);
  D.7010 = hhdr->hb_sz;
  D.7011 = D.7010 << 3;
  D.7012 = D.7011 + 4095;
  D.7013 = D.7012 >> 12;
  D.7014 = D.7013 * 4096;
  D.7007 = h + D.7014;
  return D.7007;
}