GC_noop (void * p)
{

}


GC_noop1 (word x)
{
  static volatile word sink;

  sink = x;
}


GC_collection_in_progress ()
{
  GC_bool D.5636;
  int GC_mark_state.0;
  _Bool D.5638;

  GC_mark_state.0 = GC_mark_state;
  D.5638 = GC_mark_state.0 != 0;
  D.5636 = (GC_bool) D.5638;
  return D.5636;
}


GC_clear_hdr_marks (struct hdr * hhdr)
{
  word[32] * D.5640;

  D.5640 = &hhdr->hb_marks;
  memset (D.5640, 0, 128);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5643;
  int D.5648;
  void * D.5650;
  unsigned int D.5651;

  D.5643 = __builtin_constant_p (__len);
  if (D.5643 != 0) goto <D.5644>; else goto <D.5645>;
  <D.5644>:
  if (__len == 0) goto <D.5646>; else goto <D.5647>;
  <D.5646>:
  D.5648 = __builtin_constant_p (__ch);
  if (D.5648 == 0) goto <D.5641>; else goto <D.5649>;
  <D.5649>:
  if (__ch != 0) goto <D.5641>; else goto <D.5642>;
  <D.5641>:
  __warn_memset_zero_len ();
  D.5650 = __dest;
  return D.5650;
  <D.5642>:
  <D.5647>:
  <D.5645>:
  D.5651 = __builtin_object_size (__dest, 0);
  D.5650 = __builtin___memset_chk (__dest, __ch, __len, D.5651);
  return D.5650;
}


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

  i = 0;
  goto <D.5242>;
  <D.5241>:
  hhdr->hb_marks[i] = 4294967295;
  i = i + 1;
  <D.5242>:
  if (i <= 31) goto <D.5241>; else goto <D.5243>;
  <D.5243>:
}


GC_set_mark_bit (char * p)
{
  long unsigned int p.1;
  long unsigned int D.5654;
  long unsigned int h.2;
  long unsigned int D.5656;
  struct bottom_index * D.5657;
  long unsigned int D.5658;
  long unsigned int D.5659;
  int p.3;
  int h.4;
  int D.5662;
  int D.5663;
  sizetype D.5664;
  int D.5665;
  long unsigned int D.5666;
  long unsigned int D.5667;
  word * D.5668;
  int D.5669;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.1 = (long unsigned int) p;
  D.5654 = p.1 & 4294963200;
  h = (struct hblk *) D.5654;
  h.2 = (long unsigned int) h;
  D.5656 = h.2 >> 22;
  D.5657 = GC_arrays._top_index[D.5656];
  h.2 = (long unsigned int) h;
  D.5658 = h.2 >> 12;
  D.5659 = D.5658 & 1023;
  hhdr = D.5657->index[D.5659];
  p.3 = (int) p;
  h.4 = (int) h;
  D.5662 = p.3 - h.4;
  word_no = D.5662 /[ex] 4;
  {
    word old;

    <D.5256>:
    D.5663 = word_no >> 5;
    D.5664 = (sizetype) D.5663;
    old = hhdr->hb_marks[D.5664];
    D.5665 = word_no & 31;
    D.5666 = 1 << D.5665;
    D.5667 = D.5666 | old;
    D.5663 = word_no >> 5;
    D.5664 = (sizetype) D.5663;
    D.5668 = &hhdr->hb_marks[D.5664];
    D.5669 = GC_compare_and_exchange (D.5668, old, D.5667);
    if (D.5669 == 0) goto <D.5256>; else goto <D.5257>;
    <D.5257>:
  }
}


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

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


GC_clear_mark_bit (char * p)
{
  long unsigned int p.5;
  long unsigned int D.5673;
  long unsigned int h.6;
  long unsigned int D.5675;
  struct bottom_index * D.5676;
  long unsigned int D.5677;
  long unsigned int D.5678;
  int p.7;
  int h.8;
  int D.5681;
  int D.5682;
  long unsigned int D.5683;
  int D.5684;
  long unsigned int D.5685;
  long unsigned int D.5686;
  long unsigned int D.5687;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.5 = (long unsigned int) p;
  D.5673 = p.5 & 4294963200;
  h = (struct hblk *) D.5673;
  h.6 = (long unsigned int) h;
  D.5675 = h.6 >> 22;
  D.5676 = GC_arrays._top_index[D.5675];
  h.6 = (long unsigned int) h;
  D.5677 = h.6 >> 12;
  D.5678 = D.5677 & 1023;
  hhdr = D.5676->index[D.5678];
  p.7 = (int) p;
  h.8 = (int) h;
  D.5681 = p.7 - h.8;
  word_no = D.5681 /[ex] 4;
  D.5682 = word_no >> 5;
  D.5682 = word_no >> 5;
  D.5683 = hhdr->hb_marks[D.5682];
  D.5684 = word_no & 31;
  D.5685 = 1 << D.5684;
  D.5686 = ~D.5685;
  D.5687 = D.5683 & D.5686;
  hhdr->hb_marks[D.5682] = D.5687;
}


GC_is_marked (char * p)
{
  long unsigned int p.9;
  long unsigned int D.5689;
  long unsigned int h.10;
  long unsigned int D.5691;
  struct bottom_index * D.5692;
  long unsigned int D.5693;
  long unsigned int D.5694;
  int p.11;
  int h.12;
  int D.5697;
  GC_bool D.5698;
  int D.5699;
  long unsigned int D.5700;
  int D.5701;
  long unsigned int D.5702;
  int D.5703;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.9 = (long unsigned int) p;
  D.5689 = p.9 & 4294963200;
  h = (struct hblk *) D.5689;
  h.10 = (long unsigned int) h;
  D.5691 = h.10 >> 22;
  D.5692 = GC_arrays._top_index[D.5691];
  h.10 = (long unsigned int) h;
  D.5693 = h.10 >> 12;
  D.5694 = D.5693 & 1023;
  hhdr = D.5692->index[D.5694];
  p.11 = (int) p;
  h.12 = (int) h;
  D.5697 = p.11 - h.12;
  word_no = D.5697 /[ex] 4;
  D.5699 = word_no >> 5;
  D.5700 = hhdr->hb_marks[D.5699];
  D.5701 = word_no & 31;
  D.5702 = D.5700 >> D.5701;
  D.5703 = (int) D.5702;
  D.5698 = D.5703 & 1;
  return D.5698;
}


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)
{
  long unsigned int h.13;
  long unsigned int D.5706;
  struct bottom_index * D.5707;
  long unsigned int D.5708;
  long unsigned int D.5709;
  unsigned char D.5710;
  int D.5711;
  int D.5712;
  register struct hdr * hhdr;

  h.13 = (long unsigned int) h;
  D.5706 = h.13 >> 22;
  D.5707 = GC_arrays._top_index[D.5706];
  h.13 = (long unsigned int) h;
  D.5708 = h.13 >> 12;
  D.5709 = D.5708 & 1023;
  hhdr = D.5707->index[D.5709];
  D.5710 = hhdr->hb_obj_kind;
  D.5711 = (int) D.5710;
  D.5712 = D.5711 & -2;
  if (D.5712 == 2) goto <D.5713>; else goto <D.5714>;
  <D.5713>:
  return;
  <D.5714>:
  GC_clear_hdr_marks (hhdr);
}


GC_initiate_gc ()
{
  int GC_dirty_maintained.14;
  int GC_mark_state.15;

  GC_dirty_maintained.14 = GC_dirty_maintained;
  if (GC_dirty_maintained.14 != 0) goto <D.5717>; else goto <D.5718>;
  <D.5717>:
  GC_read_dirty ();
  <D.5718>:
  GC_n_rescuing_pages = 0;
  GC_mark_state.15 = GC_mark_state;
  if (GC_mark_state.15 == 0) goto <D.5720>; else goto <D.5721>;
  <D.5720>:
  GC_mark_state = 1;
  goto <D.5722>;
  <D.5721>:
  GC_mark_state.15 = GC_mark_state;
  if (GC_mark_state.15 != 5) goto <D.5723>; else goto <D.5724>;
  <D.5723>:
  GC_abort ("unexpected state");
  <D.5724>:
  <D.5722>:
  scan_ptr = 0B;
}


GC_mark_some (char * cold_gc_frame)
{
  int GC_mark_state.16;
  GC_bool D.5726;
  struct mse * GC_mark_stack_limit.17;
  struct GC_ms_entry * D.5728;
  struct mse * GC_mark_stack_top.18;
  struct mse * GC_mark_stack.19;
  long unsigned int GC_mark_stack_size.20;
  long unsigned int D.5734;
  struct mse * D.5735;
  struct mse * GC_mark_stack_top.21;
  struct mse * GC_mark_stack_top.22;
  struct hblk * scan_ptr.23;
  struct hblk * scan_ptr.24;
  int GC_print_stats.25;
  long unsigned int GC_n_rescuing_pages.26;
  long int GC_n_rescuing_pages.27;
  long unsigned int D.5749;
  long unsigned int D.5750;
  struct GC_ms_entry * D.5751;
  struct mse * GC_mark_stack_top.28;
  int GC_parallel.29;
  struct mse * GC_mark_stack_top.30;
  struct mse * GC_mark_stack_top.31;
  struct hblk * scan_ptr.32;
  struct mse * GC_mark_stack_top.33;
  int GC_mark_stack_too_small.34;
  long unsigned int D.5771;
  struct mse * GC_mark_stack_top.35;
  struct mse * GC_mark_stack_top.36;
  struct mse * GC_mark_stack_top.37;
  int GC_objects_are_marked.38;
  struct mse * GC_mark_stack_top.39;
  struct mse * GC_mark_stack_top.40;
  struct mse * GC_mark_stack_top.41;
  struct hblk * scan_ptr.42;

  GC_mark_state.16 = GC_mark_state;
  switch (GC_mark_state.16) <default: <D.5284>, case 0: <D.5278>, case 1: <D.5279>, case 2: <D.5280>, case 3: <D.5281>, case 4: <D.5283>, case 5: <D.5282>>
  <D.5278>:
  D.5726 = 0;
  return D.5726;
  <D.5279>:
  GC_mark_stack_limit.17 = GC_mark_stack_limit;
  D.5728 = GC_mark_stack_limit.17 + 4294950912;
  GC_mark_stack_top.18 = GC_mark_stack_top;
  if (D.5728 <= GC_mark_stack_top.18) goto <D.5730>; else goto <D.5731>;
  <D.5730>:
  GC_mark_stack_too_small = 1;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5734 = GC_mark_stack_size.20 * 8;
  D.5735 = GC_mark_stack.19 + D.5734;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_top.21 = GC_mark_stack_top;
  GC_mark_stack_top.22 = GC_mark_from (GC_mark_stack_top.21, GC_mark_stack.19, D.5735);
  GC_mark_stack_top = GC_mark_stack_top.22;
  D.5726 = 0;
  return D.5726;
  <D.5731>:
  scan_ptr.23 = scan_ptr;
  scan_ptr.24 = GC_push_next_marked_dirty (scan_ptr.23);
  scan_ptr = scan_ptr.24;
  scan_ptr.23 = scan_ptr;
  if (scan_ptr.23 == 0B) goto <D.5740>; else goto <D.5741>;
  <D.5740>:
  GC_print_stats.25 = GC_print_stats;
  if (GC_print_stats.25 != 0) goto <D.5743>; else goto <D.5744>;
  <D.5743>:
  GC_n_rescuing_pages.26 = GC_n_rescuing_pages;
  GC_n_rescuing_pages.27 = (long int) GC_n_rescuing_pages.26;
  GC_printf ("Marked from %lu dirty pages\n", GC_n_rescuing_pages.27, 0, 0, 0, 0, 0);
  <D.5744>:
  GC_push_roots (0, cold_gc_frame);
  GC_objects_are_marked = 1;
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 != 5) goto <D.5747>; else goto <D.5748>;
  <D.5747>:
  GC_mark_state = 3;
  <D.5748>:
  <D.5741>:
  D.5726 = 0;
  return D.5726;
  <D.5280>:
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5749 = GC_mark_stack_size.20 / 4;
  D.5750 = D.5749 * 8;
  D.5751 = GC_mark_stack.19 + D.5750;
  GC_mark_stack_top.28 = GC_mark_stack_top;
  if (D.5751 <= GC_mark_stack_top.28) goto <D.5753>; else goto <D.5754>;
  <D.5753>:
  GC_parallel.29 = GC_parallel;
  if (GC_parallel.29 != 0) goto <D.5756>; else goto <D.5757>;
  <D.5756>:
  GC_mark_stack_too_small = 1;
  <D.5757>:
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5734 = GC_mark_stack_size.20 * 8;
  D.5735 = GC_mark_stack.19 + D.5734;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_top.30 = GC_mark_stack_top;
  GC_mark_stack_top.31 = GC_mark_from (GC_mark_stack_top.30, GC_mark_stack.19, D.5735);
  GC_mark_stack_top = GC_mark_stack_top.31;
  D.5726 = 0;
  return D.5726;
  <D.5754>:
  scan_ptr.23 = scan_ptr;
  scan_ptr.32 = GC_push_next_marked_uncollectable (scan_ptr.23);
  scan_ptr = scan_ptr.32;
  scan_ptr.23 = scan_ptr;
  if (scan_ptr.23 == 0B) goto <D.5761>; else goto <D.5762>;
  <D.5761>:
  GC_push_roots (1, cold_gc_frame);
  GC_objects_are_marked = 1;
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 != 5) goto <D.5763>; else goto <D.5764>;
  <D.5763>:
  GC_mark_state = 3;
  <D.5764>:
  <D.5762>:
  D.5726 = 0;
  return D.5726;
  <D.5281>:
  GC_parallel.29 = GC_parallel;
  if (GC_parallel.29 != 0) goto <D.5765>; else goto <D.5766>;
  <D.5765>:
  GC_do_parallel_mark ();
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_top.33 = GC_mark_stack.19 + 4294967288;
  GC_mark_stack_top = GC_mark_stack_top.33;
  GC_mark_stack_too_small.34 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.34 != 0) goto <D.5769>; else goto <D.5770>;
  <D.5769>:
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5771 = GC_mark_stack_size.20 * 2;
  alloc_mark_stack (D.5771);
  <D.5770>:
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 == 3) goto <D.5772>; else goto <D.5773>;
  <D.5772>:
  GC_mark_state = 0;
  D.5726 = 1;
  return D.5726;
  <D.5773>:
  D.5726 = 0;
  return D.5726;
  <D.5766>:
  GC_mark_stack_top.35 = GC_mark_stack_top;
  GC_mark_stack.19 = GC_mark_stack;
  if (GC_mark_stack_top.35 >= GC_mark_stack.19) goto <D.5775>; else goto <D.5776>;
  <D.5775>:
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5734 = GC_mark_stack_size.20 * 8;
  D.5735 = GC_mark_stack.19 + D.5734;
  GC_mark_stack.19 = 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.19, D.5735);
  GC_mark_stack_top = GC_mark_stack_top.37;
  D.5726 = 0;
  return D.5726;
  <D.5776>:
  GC_mark_state = 0;
  GC_mark_stack_too_small.34 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.34 != 0) goto <D.5779>; else goto <D.5780>;
  <D.5779>:
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5771 = GC_mark_stack_size.20 * 2;
  alloc_mark_stack (D.5771);
  <D.5780>:
  D.5726 = 1;
  return D.5726;
  <D.5282>:
  <D.5283>:
  GC_objects_are_marked.38 = GC_objects_are_marked;
  if (GC_objects_are_marked.38 == 0) goto <D.5782>; else goto <D.5783>;
  <D.5782>:
  GC_mark_state = 2;
  D.5726 = 0;
  return D.5726;
  <D.5783>:
  GC_mark_stack_top.39 = GC_mark_stack_top;
  GC_mark_stack.19 = GC_mark_stack;
  if (GC_mark_stack_top.39 >= GC_mark_stack.19) goto <D.5785>; else goto <D.5786>;
  <D.5785>:
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5734 = GC_mark_stack_size.20 * 8;
  D.5735 = GC_mark_stack.19 + D.5734;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_top.40 = GC_mark_stack_top;
  GC_mark_stack_top.41 = GC_mark_from (GC_mark_stack_top.40, GC_mark_stack.19, D.5735);
  GC_mark_stack_top = GC_mark_stack_top.41;
  D.5726 = 0;
  return D.5726;
  <D.5786>:
  scan_ptr.23 = scan_ptr;
  if (scan_ptr.23 == 0B) goto <D.5789>; else goto <D.5790>;
  <D.5789>:
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 == 5) goto <D.5791>; else goto <D.5792>;
  <D.5791>:
  GC_mark_stack_too_small.34 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.34 != 0) goto <D.5793>; else goto <D.5794>;
  <D.5793>:
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5771 = GC_mark_stack_size.20 * 2;
  alloc_mark_stack (D.5771);
  <D.5794>:
  GC_mark_state = 4;
  <D.5792>:
  <D.5790>:
  scan_ptr.23 = scan_ptr;
  scan_ptr.42 = GC_push_next_marked (scan_ptr.23);
  scan_ptr = scan_ptr.42;
  scan_ptr.23 = scan_ptr;
  if (scan_ptr.23 == 0B) goto <D.5796>; else goto <D.5797>;
  <D.5796>:
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 == 4) goto <D.5798>; else goto <D.5799>;
  <D.5798>:
  GC_push_roots (1, cold_gc_frame);
  GC_objects_are_marked = 1;
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 != 5) goto <D.5800>; else goto <D.5801>;
  <D.5800>:
  GC_mark_state = 3;
  <D.5801>:
  <D.5799>:
  <D.5797>:
  D.5726 = 0;
  return D.5726;
  <D.5284>:
  GC_abort ("GC_mark_some: bad state");
  D.5726 = 0;
  return D.5726;
}


alloc_mark_stack (word n)
{
  long unsigned int D.5803;
  long unsigned int GC_mark_stack_size.43;
  long unsigned int GC_page_size.44;
  long unsigned int D.5810;
  struct mse * GC_mark_stack.45;
  long unsigned int GC_mark_stack.46;
  long unsigned int D.5813;
  long unsigned int size.47;
  long unsigned int D.5817;
  long unsigned int D.5818;
  long unsigned int D.5819;
  long unsigned int D.5822;
  struct hblk * D.5823;
  long unsigned int D.5824;
  struct mse * GC_mark_stack_limit.48;
  int GC_print_stats.49;
  long int GC_mark_stack_size.50;
  long int n.51;
  struct mse * GC_mark_stack_top.52;
  struct mse * new_stack;

  D.5803 = n * 8;
  new_stack = GC_scratch_alloc (D.5803);
  GC_mark_stack_too_small = 0;
  GC_mark_stack_size.43 = GC_mark_stack_size;
  if (GC_mark_stack_size.43 != 0) goto <D.5805>; else goto <D.5806>;
  <D.5805>:
  if (new_stack != 0B) goto <D.5807>; else goto <D.5808>;
  <D.5807>:
  {
    word displ;
    signed_word size;

    GC_page_size.44 = GC_page_size;
    D.5810 = GC_page_size.44 + 4294967295;
    GC_mark_stack.45 = GC_mark_stack;
    GC_mark_stack.46 = (long unsigned int) GC_mark_stack.45;
    displ = D.5810 & GC_mark_stack.46;
    GC_mark_stack_size.43 = GC_mark_stack_size;
    D.5813 = GC_mark_stack_size.43 * 8;
    size = (signed_word) D.5813;
    if (displ != 0) goto <D.5814>; else goto <D.5815>;
    <D.5814>:
    GC_page_size.44 = GC_page_size;
    displ = GC_page_size.44 - displ;
    <D.5815>:
    size.47 = (long unsigned int) size;
    D.5817 = size.47 - displ;
    GC_page_size.44 = GC_page_size;
    D.5818 = -GC_page_size.44;
    D.5819 = D.5817 & D.5818;
    size = (signed_word) D.5819;
    if (size > 0) goto <D.5820>; else goto <D.5821>;
    <D.5820>:
    size.47 = (long unsigned int) size;
    GC_mark_stack.45 = GC_mark_stack;
    GC_mark_stack.46 = (long unsigned int) GC_mark_stack.45;
    D.5822 = GC_mark_stack.46 + displ;
    D.5823 = (struct hblk *) D.5822;
    GC_add_to_heap (D.5823, size.47);
    <D.5821>:
    GC_mark_stack = new_stack;
    GC_mark_stack_size = n;
    D.5824 = n * 8;
    GC_mark_stack_limit.48 = new_stack + D.5824;
    GC_mark_stack_limit = GC_mark_stack_limit.48;
    GC_print_stats.49 = GC_print_stats;
    if (GC_print_stats.49 != 0) goto <D.5827>; else goto <D.5828>;
    <D.5827>:
    GC_mark_stack_size.43 = GC_mark_stack_size;
    GC_mark_stack_size.50 = (long int) GC_mark_stack_size.43;
    GC_printf ("Grew mark stack to %lu frames\n", GC_mark_stack_size.50, 0, 0, 0, 0, 0);
    <D.5828>:
  }
  goto <D.5830>;
  <D.5808>:
  GC_print_stats.49 = GC_print_stats;
  if (GC_print_stats.49 != 0) goto <D.5831>; else goto <D.5832>;
  <D.5831>:
  n.51 = (long int) n;
  GC_printf ("Failed to grow mark stack to %lu frames\n", n.51, 0, 0, 0, 0, 0);
  <D.5832>:
  <D.5830>:
  goto <D.5834>;
  <D.5806>:
  if (new_stack == 0B) goto <D.5835>; else goto <D.5836>;
  <D.5835>:
  GC_err_puts ("No space for mark stack\n");
  exit (1);
  <D.5836>:
  GC_mark_stack = new_stack;
  GC_mark_stack_size = n;
  D.5824 = n * 8;
  GC_mark_stack_limit.48 = new_stack + D.5824;
  GC_mark_stack_limit = GC_mark_stack_limit.48;
  <D.5834>:
  GC_mark_stack.45 = GC_mark_stack;
  GC_mark_stack_top.52 = GC_mark_stack.45 + 4294967288;
  GC_mark_stack_top = GC_mark_stack_top.52;
}


GC_mark_stack_empty ()
{
  GC_bool D.5838;
  struct mse * GC_mark_stack_top.53;
  struct mse * GC_mark_stack.54;
  _Bool D.5841;

  GC_mark_stack_top.53 = GC_mark_stack_top;
  GC_mark_stack.54 = GC_mark_stack;
  D.5841 = GC_mark_stack_top.53 < GC_mark_stack.54;
  D.5838 = (GC_bool) D.5841;
  return D.5838;
}


GC_find_start (char * current, struct hdr * hhdr, struct hdr * * new_hdr_p)
{
  int GC_all_interior_pointers.55;
  long unsigned int current.56;
  long unsigned int D.5849;
  long unsigned int hhdr.57;
  long unsigned int D.5851;
  sizetype D.5852;
  long unsigned int D.5853;
  struct bottom_index * D.5854;
  long unsigned int D.5855;
  long unsigned int D.5856;
  unsigned char D.5857;
  int D.5858;
  int D.5859;
  char * D.5862;
  int orig.58;
  int current.59;
  int D.5865;
  int D.5866;
  long unsigned int D.5867;
  int D.5868;

  GC_all_interior_pointers.55 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.55 != 0) goto <D.5844>; else goto <D.5845>;
  <D.5844>:
  if (hhdr != 0B) goto <D.5846>; else goto <D.5847>;
  <D.5846>:
  {
    register char * orig;

    orig = current;
    current.56 = (long unsigned int) current;
    D.5849 = current.56 & 4294963200;
    current = (char *) D.5849;
    <D.5293>:
    hhdr.57 = (long unsigned int) hhdr;
    D.5851 = hhdr.57 * 4096;
    D.5852 = -D.5851;
    current = current + D.5852;
    current.56 = (long unsigned int) current;
    D.5853 = current.56 >> 22;
    D.5854 = GC_arrays._top_index[D.5853];
    current.56 = (long unsigned int) current;
    D.5855 = current.56 >> 12;
    D.5856 = D.5855 & 1023;
    hhdr = D.5854->index[D.5856];
    hhdr.57 = (long unsigned int) hhdr;
    if (hhdr.57 <= 4095) goto <D.5293>; else goto <D.5294>;
    <D.5294>:
    D.5857 = hhdr->hb_flags;
    D.5858 = (int) D.5857;
    D.5859 = D.5858 & 1;
    if (D.5859 != 0) goto <D.5860>; else goto <D.5861>;
    <D.5860>:
    D.5862 = orig;
    return D.5862;
    <D.5861>:
    orig.58 = (int) orig;
    current.59 = (int) current;
    D.5865 = orig.58 - current.59;
    D.5866 = D.5865 /[ex] 4;
    D.5867 = hhdr->hb_sz;
    D.5868 = (int) D.5867;
    if (D.5866 >= D.5868) goto <D.5869>; else goto <D.5870>;
    <D.5869>:
    D.5862 = orig;
    return D.5862;
    <D.5870>:
    *new_hdr_p = hhdr;
    D.5862 = current;
    return D.5862;
  }
  <D.5847>:
  D.5862 = current;
  return D.5862;
  <D.5845>:
  D.5862 = current;
  return D.5862;
}


GC_invalidate_mark_state ()
{
  struct mse * GC_mark_stack.60;
  struct mse * GC_mark_stack_top.61;

  GC_mark_state = 5;
  GC_mark_stack.60 = GC_mark_stack;
  GC_mark_stack_top.61 = GC_mark_stack.60 + 4294967288;
  GC_mark_stack_top = GC_mark_stack_top.61;
}


GC_signal_mark_stack_overflow (struct mse * msp)
{
  int GC_print_stats.62;
  long unsigned int GC_mark_stack_size.63;
  long int GC_mark_stack_size.64;
  struct mse * D.5879;

  GC_mark_state = 5;
  GC_mark_stack_too_small = 1;
  GC_print_stats.62 = GC_print_stats;
  if (GC_print_stats.62 != 0) goto <D.5875>; else goto <D.5876>;
  <D.5875>:
  GC_mark_stack_size.63 = GC_mark_stack_size;
  GC_mark_stack_size.64 = (long int) GC_mark_stack_size.63;
  GC_printf ("Mark stack overflow; current size = %lu entries\n", GC_mark_stack_size.64, 0, 0, 0, 0, 0);
  <D.5876>:
  D.5879 = msp + 4294963200;
  return D.5879;
}


GC_mark_from (struct mse * mark_stack_top, struct mse * mark_stack, struct mse * mark_stack_limit)
{
  long unsigned int D.5881;
  int GC_parallel.65;
  struct mse * D.5889;
  long unsigned int D.5892;
  int D.5893;
  unsigned int new_size.66;
  unsigned int D.5895;
  sizetype new_size.67;
  long unsigned int new_size.68;
  long unsigned int D.5898;
  long unsigned int credit.69;
  long unsigned int D.5900;
  long int descr.70;
  char * current.71;
  _Bool D.5905;
  _Bool D.5906;
  _Bool D.5907;
  long unsigned int my_current.72;
  long unsigned int D.5911;
  long unsigned int D.5912;
  long unsigned int D.5913;
  long unsigned int D.5914;
  long unsigned int D.5918;
  struct bottom_index * D.5919;
  long unsigned int D.5920;
  long unsigned int my_hhdr.73;
  struct hdr * GC_invalid_header.74;
  int my_current.75;
  map_entry_type * D.5927;
  sizetype displ.76;
  map_entry_type * D.5929;
  unsigned char D.5930;
  long unsigned int displ.77;
  long unsigned int D.5936;
  long unsigned int D.5937;
  long unsigned int D.5938;
  int GC_all_interior_pointers.78;
  int D.5950;
  sizetype D.5951;
  int D.5952;
  long unsigned int D.5953;
  long unsigned int D.5955;
  int D.5956;
  unsigned int displ.79;
  unsigned int D.5963;
  sizetype my_current.80;
  sizetype D.5965;
  sizetype D.5966;
  GC_word * D.5967;
  long unsigned int D.5968;
  long unsigned int D.5969;
  struct GC_ms_entry * (*<Taa8>) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word) D.5970;
  long unsigned int D.5971;
  sizetype D.5974;
  word * D.5975;
  sizetype D.5979;
  char * D.5980;
  int current_p.81;
  int limit.82;
  int D.5987;
  char * deferred.83;
  _Bool D.5989;
  _Bool D.5990;
  _Bool D.5991;
  long unsigned int my_current.84;
  long unsigned int D.5999;
  long unsigned int D.6000;
  long unsigned int D.6001;
  long unsigned int D.6002;
  long unsigned int D.6006;
  struct bottom_index * D.6007;
  long unsigned int D.6008;
  long unsigned int my_hhdr.85;
  int my_current.86;
  map_entry_type * D.6014;
  sizetype displ.87;
  map_entry_type * D.6016;
  unsigned char D.6017;
  long unsigned int displ.88;
  long unsigned int D.6023;
  long unsigned int D.6024;
  long unsigned int D.6025;
  int D.6036;
  sizetype D.6037;
  int D.6038;
  long unsigned int D.6039;
  long unsigned int D.6041;
  int D.6042;
  unsigned int displ.89;
  unsigned int D.6049;
  sizetype my_current.90;
  sizetype D.6051;
  sizetype D.6052;
  GC_word * D.6053;
  long unsigned int my_current.91;
  long unsigned int D.6055;
  long unsigned int D.6056;
  long unsigned int D.6057;
  long unsigned int D.6058;
  long unsigned int D.6062;
  struct bottom_index * D.6063;
  long unsigned int D.6064;
  long unsigned int my_hhdr.92;
  int my_current.93;
  map_entry_type * D.6070;
  sizetype displ.94;
  map_entry_type * D.6072;
  unsigned char D.6073;
  long unsigned int displ.95;
  long unsigned int D.6079;
  long unsigned int D.6080;
  long unsigned int D.6081;
  int D.6092;
  sizetype D.6093;
  int D.6094;
  long unsigned int D.6095;
  long unsigned int D.6097;
  int D.6098;
  unsigned int displ.96;
  unsigned int D.6105;
  sizetype my_current.97;
  sizetype D.6107;
  sizetype D.6108;
  GC_word * D.6109;
  int mark_stack_top.98;
  int mark_stack.99;
  int D.6112;
  int D.6113;
  struct mse * D.6114;
  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, 64);
      goto <D.5335>;
      <D.5372>:
      current_p = mark_stack_top->mse_start;
      descr = mark_stack_top->mse_descr;
      retry:
      D.5881 = descr & 4294966787;
      if (D.5881 != 0) goto <D.5882>; else goto <D.5883>;
      <D.5882>:
      {
        word tag;

        tag = descr & 3;
        switch (tag) <default: <D.5983>, case 0: <D.5315>, case 1: <D.5318>, case 2: <D.5336>, case 3: <D.5337>>
        <D.5315>:
        if (descr > 2048) goto <D.5884>; else goto <D.5885>;
        <D.5884>:
        GC_parallel.65 = GC_parallel;
        if (GC_parallel.65 != 0) goto <D.5887>; else goto <D.5888>;
        <D.5887>:
        D.5889 = mark_stack_limit + 4294967288;
        if (D.5889 > mark_stack_top) goto <D.5890>; else goto <D.5891>;
        <D.5890>:
        {
          int new_size;

          D.5892 = descr / 2;
          D.5893 = (int) D.5892;
          new_size = D.5893 & -4;
          mark_stack_top->mse_start = current_p;
          new_size.66 = (unsigned int) new_size;
          D.5895 = new_size.66 + 4;
          mark_stack_top->mse_descr = D.5895;
          mark_stack_top = mark_stack_top + 8;
          new_size.67 = (sizetype) new_size;
          current_p = current_p + new_size.67;
          new_size.68 = (long unsigned int) new_size;
          descr = descr - new_size.68;
          goto retry;
        }
        <D.5891>:
        <D.5888>:
        <D.5885>:
        limit = current_p + 508;
        mark_stack_top->mse_start = limit;
        D.5898 = descr + 4294966788;
        mark_stack_top->mse_descr = D.5898;
        limit = limit;
        goto <D.5317>;
        <D.5318>:
        mark_stack_top = mark_stack_top + 4294967288;
        descr = descr & 4294967292;
        credit.69 = (long unsigned int) credit;
        D.5900 = credit.69 + 4294967232;
        credit = (int) D.5900;
        goto <D.5333>;
        <D.5332>:
        descr.70 = (long int) descr;
        if (descr.70 < 0) goto <D.5902>; else goto <D.5903>;
        <D.5902>:
        current = *current_p;
        current.71 = (char *) current;
        D.5905 = current.71 >= least_ha;
        current.71 = (char *) current;
        D.5906 = current.71 < greatest_ha;
        D.5907 = D.5905 & D.5906;
        if (D.5907 != 0) goto <D.5908>; else goto <D.5909>;
        <D.5908>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.72 = (long unsigned int) my_current;
            D.5911 = my_current.72 >> 12;
            D.5912 = D.5911 & 7;
            D.5913 = D.5912 * 8;
            hce = &hdr_cache + D.5913;
            D.5914 = hce->block_addr;
            my_current.72 = (long unsigned int) my_current;
            D.5911 = my_current.72 >> 12;
            if (D.5914 == D.5911) goto <D.5915>; else goto <D.5916>;
            <D.5915>:
            my_hhdr = hce->hce_hdr;
            goto <D.5917>;
            <D.5916>:
            my_current.72 = (long unsigned int) my_current;
            D.5918 = my_current.72 >> 22;
            D.5919 = GC_arrays._top_index[D.5918];
            my_current.72 = (long unsigned int) my_current;
            D.5911 = my_current.72 >> 12;
            D.5920 = D.5911 & 1023;
            my_hhdr = D.5919->index[D.5920];
            my_hhdr.73 = (long unsigned int) my_hhdr;
            if (my_hhdr.73 <= 4095) goto <D.5922>; else goto <D.5923>;
            <D.5922>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.74 = GC_invalid_header;
                  new_hdr = GC_invalid_header.74;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.5925>;
            <D.5923>:
            my_current.72 = (long unsigned int) my_current;
            D.5911 = my_current.72 >> 12;
            hce->block_addr = D.5911;
            hce->hce_hdr = my_hhdr;
            <D.5925>:
            <D.5917>:
          }
          {
            int displ;
            int map_entry;

            my_current.75 = (int) my_current;
            displ = my_current.75 & 4095;
            D.5927 = my_hhdr->hb_map;
            displ.76 = (sizetype) displ;
            D.5929 = D.5927 + displ.76;
            D.5930 = *D.5929;
            map_entry = (int) D.5930;
            displ = displ >> 2;
            if (map_entry > 253) goto <D.5931>; else goto <D.5932>;
            <D.5931>:
            if (map_entry == 254) goto <D.5933>; else goto <D.5934>;
            <D.5933>:
            displ.77 = (long unsigned int) displ;
            D.5936 = my_hhdr->hb_sz;
            D.5937 = displ.77 % D.5936;
            map_entry = (int) D.5937;
            displ = displ - map_entry;
            D.5936 = my_hhdr->hb_sz;
            displ.77 = (long unsigned int) displ;
            D.5938 = D.5936 + displ.77;
            if (D.5938 > 1024) goto <D.5939>; else goto <D.5940>;
            <D.5939>:
            GC_all_interior_pointers.78 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.78 != 0) goto <D.5942>; else goto <D.5943>;
            <D.5942>:
            my_current.72 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.72);
            goto <D.5944>;
            <D.5943>:
            my_current.72 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.72);
            <D.5944>:
            goto exit1;
            <D.5940>:
            goto <D.5945>;
            <D.5934>:
            GC_all_interior_pointers.78 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.78 != 0) goto <D.5946>; else goto <D.5947>;
            <D.5946>:
            my_current.72 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.72);
            goto <D.5948>;
            <D.5947>:
            my_current.72 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.72);
            <D.5948>:
            goto exit1;
            <D.5945>:
            goto <D.5949>;
            <D.5932>:
            displ = displ - map_entry;
            <D.5949>:
            {
              register word * mark_word_addr;

              D.5950 = displ >> 5;
              D.5951 = (sizetype) D.5950;
              mark_word_addr = &my_hhdr->hb_marks[D.5951];
              {
                word old;
                word my_bits;

                D.5952 = displ & 31;
                my_bits = 1 << D.5952;
                <D.5329>:
                old = MEM[(volatile word *)mark_word_addr];
                D.5953 = old & my_bits;
                if (D.5953 != 0) goto exit1; else goto <D.5954>;
                <D.5954>:
                D.5955 = old | my_bits;
                D.5956 = GC_compare_and_exchange (mark_word_addr, old, D.5955);
                if (D.5956 == 0) goto <D.5329>; else goto <D.5330>;
                <D.5330>:
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.5957>; else goto <D.5958>;
              <D.5957>:
              goto <D.5959>;
              <D.5958>:
              mark_stack_top = mark_stack_top + 8;
              if (mark_stack_top >= mark_stack_limit) goto <D.5960>; else goto <D.5961>;
              <D.5960>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.5961>:
              displ.79 = (unsigned int) displ;
              D.5963 = displ.79 * 4;
              my_current.80 = (sizetype) my_current;
              D.5965 = my_current.80 & 4294963200;
              D.5966 = D.5963 + D.5965;
              D.5967 = (GC_word *) D.5966;
              mark_stack_top->mse_start = D.5967;
              mark_stack_top->mse_descr = _descr;
              <D.5959>:
            }
          }
          exit1:
        }
        <D.5909>:
        <D.5903>:
        descr = descr << 1;
        current_p = current_p + 4;
        <D.5333>:
        if (descr != 0) goto <D.5332>; else goto <D.5334>;
        <D.5334>:
        // predicted unlikely by continue predictor.
        goto <D.5335>;
        <D.5336>:
        mark_stack_top = mark_stack_top + 4294967288;
        credit = credit + -100;
        D.5968 = descr >> 2;
        D.5969 = D.5968 & 63;
        D.5970 = GC_arrays._mark_procs[D.5969];
        D.5971 = descr >> 8;
        mark_stack_top = D.5970 (current_p, mark_stack_top, mark_stack_limit, D.5971);
        // predicted unlikely by continue predictor.
        goto <D.5335>;
        <D.5337>:
        descr.70 = (long int) descr;
        if (descr.70 >= 0) goto <D.5972>; else goto <D.5973>;
        <D.5972>:
        D.5974 = descr + 4294967293;
        D.5975 = current_p + D.5974;
        descr = *D.5975;
        goto <D.5976>;
        <D.5973>:
        {
          char * type_descr;

          type_descr = MEM[(char * *)current_p];
          if (type_descr == 0B) goto <D.5977>; else goto <D.5978>;
          <D.5977>:
          mark_stack_top = mark_stack_top + 4294967288;
          // predicted unlikely by continue predictor.
          goto <D.5335>;
          <D.5978>:
          D.5979 = 4294967283 - descr;
          D.5980 = type_descr + D.5979;
          descr = MEM[(word *)D.5980];
        }
        <D.5976>:
        if (descr == 0) goto <D.5981>; else goto <D.5982>;
        <D.5981>:
        mark_stack_top = mark_stack_top + 4294967288;
        // predicted unlikely by continue predictor.
        goto <D.5335>;
        <D.5982>:
        goto retry;
        <D.5983>:
        <D.5317>:
      }
      goto <D.5984>;
      <D.5883>:
      mark_stack_top = mark_stack_top + 4294967288;
      limit = current_p + descr;
      <D.5984>:
      current_p.81 = (int) current_p;
      limit.82 = (int) limit;
      D.5987 = current_p.81 - limit.82;
      credit = D.5987 + credit;
      limit = limit + 4294967292;
      {
        word deferred;

        <D.5342>:
        deferred = *limit;
        limit = limit + 4294967292;
        deferred.83 = (char *) deferred;
        D.5989 = deferred.83 >= least_ha;
        deferred.83 = (char *) deferred;
        D.5990 = deferred.83 < greatest_ha;
        D.5991 = D.5989 & D.5990;
        if (D.5991 != 0) goto <D.5340>; else goto <D.5992>;
        <D.5992>:
        if (current_p > limit) goto next_object; else goto <D.5993>;
        <D.5993>:
        deferred = *limit;
        limit = limit + 4294967292;
        deferred.83 = (char *) deferred;
        D.5989 = deferred.83 >= least_ha;
        deferred.83 = (char *) deferred;
        D.5990 = deferred.83 < greatest_ha;
        D.5991 = D.5989 & D.5990;
        if (D.5991 != 0) goto <D.5340>; else goto <D.5994>;
        <D.5994>:
        if (current_p > limit) goto next_object; else goto <D.5995>;
        <D.5995>:
        goto <D.5342>;
        <D.5340>:
        goto <D.5357>;
        <D.5356>:
        current = *current_p;
        current.71 = (char *) current;
        D.5905 = current.71 >= least_ha;
        current.71 = (char *) current;
        D.5906 = current.71 < greatest_ha;
        D.5907 = D.5905 & D.5906;
        if (D.5907 != 0) goto <D.5996>; else goto <D.5997>;
        <D.5996>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.84 = (long unsigned int) my_current;
            D.5999 = my_current.84 >> 12;
            D.6000 = D.5999 & 7;
            D.6001 = D.6000 * 8;
            hce = &hdr_cache + D.6001;
            D.6002 = hce->block_addr;
            my_current.84 = (long unsigned int) my_current;
            D.5999 = my_current.84 >> 12;
            if (D.6002 == D.5999) goto <D.6003>; else goto <D.6004>;
            <D.6003>:
            my_hhdr = hce->hce_hdr;
            goto <D.6005>;
            <D.6004>:
            my_current.84 = (long unsigned int) my_current;
            D.6006 = my_current.84 >> 22;
            D.6007 = GC_arrays._top_index[D.6006];
            my_current.84 = (long unsigned int) my_current;
            D.5999 = my_current.84 >> 12;
            D.6008 = D.5999 & 1023;
            my_hhdr = D.6007->index[D.6008];
            my_hhdr.85 = (long unsigned int) my_hhdr;
            if (my_hhdr.85 <= 4095) goto <D.6010>; else goto <D.6011>;
            <D.6010>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.74 = GC_invalid_header;
                  new_hdr = GC_invalid_header.74;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6012>;
            <D.6011>:
            my_current.84 = (long unsigned int) my_current;
            D.5999 = my_current.84 >> 12;
            hce->block_addr = D.5999;
            hce->hce_hdr = my_hhdr;
            <D.6012>:
            <D.6005>:
          }
          {
            int displ;
            int map_entry;

            my_current.86 = (int) my_current;
            displ = my_current.86 & 4095;
            D.6014 = my_hhdr->hb_map;
            displ.87 = (sizetype) displ;
            D.6016 = D.6014 + displ.87;
            D.6017 = *D.6016;
            map_entry = (int) D.6017;
            displ = displ >> 2;
            if (map_entry > 253) goto <D.6018>; else goto <D.6019>;
            <D.6018>:
            if (map_entry == 254) goto <D.6020>; else goto <D.6021>;
            <D.6020>:
            displ.88 = (long unsigned int) displ;
            D.6023 = my_hhdr->hb_sz;
            D.6024 = displ.88 % D.6023;
            map_entry = (int) D.6024;
            displ = displ - map_entry;
            D.6023 = my_hhdr->hb_sz;
            displ.88 = (long unsigned int) displ;
            D.6025 = D.6023 + displ.88;
            if (D.6025 > 1024) goto <D.6026>; else goto <D.6027>;
            <D.6026>:
            GC_all_interior_pointers.78 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.78 != 0) goto <D.6028>; else goto <D.6029>;
            <D.6028>:
            my_current.84 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.84);
            goto <D.6030>;
            <D.6029>:
            my_current.84 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.84);
            <D.6030>:
            goto exit2;
            <D.6027>:
            goto <D.6031>;
            <D.6021>:
            GC_all_interior_pointers.78 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.78 != 0) goto <D.6032>; else goto <D.6033>;
            <D.6032>:
            my_current.84 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.84);
            goto <D.6034>;
            <D.6033>:
            my_current.84 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.84);
            <D.6034>:
            goto exit2;
            <D.6031>:
            goto <D.6035>;
            <D.6019>:
            displ = displ - map_entry;
            <D.6035>:
            {
              register word * mark_word_addr;

              D.6036 = displ >> 5;
              D.6037 = (sizetype) D.6036;
              mark_word_addr = &my_hhdr->hb_marks[D.6037];
              {
                word old;
                word my_bits;

                D.6038 = displ & 31;
                my_bits = 1 << D.6038;
                <D.5353>:
                old = MEM[(volatile word *)mark_word_addr];
                D.6039 = old & my_bits;
                if (D.6039 != 0) goto exit2; else goto <D.6040>;
                <D.6040>:
                D.6041 = old | my_bits;
                D.6042 = GC_compare_and_exchange (mark_word_addr, old, D.6041);
                if (D.6042 == 0) goto <D.5353>; else goto <D.5354>;
                <D.5354>:
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6043>; else goto <D.6044>;
              <D.6043>:
              goto <D.6045>;
              <D.6044>:
              mark_stack_top = mark_stack_top + 8;
              if (mark_stack_top >= mark_stack_limit) goto <D.6046>; else goto <D.6047>;
              <D.6046>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6047>:
              displ.89 = (unsigned int) displ;
              D.6049 = displ.89 * 4;
              my_current.90 = (sizetype) my_current;
              D.6051 = my_current.90 & 4294963200;
              D.6052 = D.6049 + D.6051;
              D.6053 = (GC_word *) D.6052;
              mark_stack_top->mse_start = D.6053;
              mark_stack_top->mse_descr = _descr;
              <D.6045>:
            }
          }
          exit2:
        }
        <D.5997>:
        current_p = current_p + 4;
        <D.5357>:
        if (current_p <= limit) goto <D.5356>; else goto <D.5358>;
        <D.5358>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.91 = (long unsigned int) my_current;
            D.6055 = my_current.91 >> 12;
            D.6056 = D.6055 & 7;
            D.6057 = D.6056 * 8;
            hce = &hdr_cache + D.6057;
            D.6058 = hce->block_addr;
            my_current.91 = (long unsigned int) my_current;
            D.6055 = my_current.91 >> 12;
            if (D.6058 == D.6055) goto <D.6059>; else goto <D.6060>;
            <D.6059>:
            my_hhdr = hce->hce_hdr;
            goto <D.6061>;
            <D.6060>:
            my_current.91 = (long unsigned int) my_current;
            D.6062 = my_current.91 >> 22;
            D.6063 = GC_arrays._top_index[D.6062];
            my_current.91 = (long unsigned int) my_current;
            D.6055 = my_current.91 >> 12;
            D.6064 = D.6055 & 1023;
            my_hhdr = D.6063->index[D.6064];
            my_hhdr.92 = (long unsigned int) my_hhdr;
            if (my_hhdr.92 <= 4095) goto <D.6066>; else goto <D.6067>;
            <D.6066>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.74 = GC_invalid_header;
                  new_hdr = GC_invalid_header.74;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6068>;
            <D.6067>:
            my_current.91 = (long unsigned int) my_current;
            D.6055 = my_current.91 >> 12;
            hce->block_addr = D.6055;
            hce->hce_hdr = my_hhdr;
            <D.6068>:
            <D.6061>:
          }
          {
            int displ;
            int map_entry;

            my_current.93 = (int) my_current;
            displ = my_current.93 & 4095;
            D.6070 = my_hhdr->hb_map;
            displ.94 = (sizetype) displ;
            D.6072 = D.6070 + displ.94;
            D.6073 = *D.6072;
            map_entry = (int) D.6073;
            displ = displ >> 2;
            if (map_entry > 253) goto <D.6074>; else goto <D.6075>;
            <D.6074>:
            if (map_entry == 254) goto <D.6076>; else goto <D.6077>;
            <D.6076>:
            displ.95 = (long unsigned int) displ;
            D.6079 = my_hhdr->hb_sz;
            D.6080 = displ.95 % D.6079;
            map_entry = (int) D.6080;
            displ = displ - map_entry;
            D.6079 = my_hhdr->hb_sz;
            displ.95 = (long unsigned int) displ;
            D.6081 = D.6079 + displ.95;
            if (D.6081 > 1024) goto <D.6082>; else goto <D.6083>;
            <D.6082>:
            GC_all_interior_pointers.78 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.78 != 0) goto <D.6084>; else goto <D.6085>;
            <D.6084>:
            my_current.91 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.91);
            goto <D.6086>;
            <D.6085>:
            my_current.91 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.91);
            <D.6086>:
            goto exit4;
            <D.6083>:
            goto <D.6087>;
            <D.6077>:
            GC_all_interior_pointers.78 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.78 != 0) goto <D.6088>; else goto <D.6089>;
            <D.6088>:
            my_current.91 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.91);
            goto <D.6090>;
            <D.6089>:
            my_current.91 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.91);
            <D.6090>:
            goto exit4;
            <D.6087>:
            goto <D.6091>;
            <D.6075>:
            displ = displ - map_entry;
            <D.6091>:
            {
              register word * mark_word_addr;

              D.6092 = displ >> 5;
              D.6093 = (sizetype) D.6092;
              mark_word_addr = &my_hhdr->hb_marks[D.6093];
              {
                word old;
                word my_bits;

                D.6094 = displ & 31;
                my_bits = 1 << D.6094;
                <D.5369>:
                old = MEM[(volatile word *)mark_word_addr];
                D.6095 = old & my_bits;
                if (D.6095 != 0) goto exit4; else goto <D.6096>;
                <D.6096>:
                D.6097 = old | my_bits;
                D.6098 = GC_compare_and_exchange (mark_word_addr, old, D.6097);
                if (D.6098 == 0) goto <D.5369>; else goto <D.5370>;
                <D.5370>:
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6099>; else goto <D.6100>;
              <D.6099>:
              goto <D.6101>;
              <D.6100>:
              mark_stack_top = mark_stack_top + 8;
              if (mark_stack_top >= mark_stack_limit) goto <D.6102>; else goto <D.6103>;
              <D.6102>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6103>:
              displ.96 = (unsigned int) displ;
              D.6105 = displ.96 * 4;
              my_current.97 = (sizetype) my_current;
              D.6107 = my_current.97 & 4294963200;
              D.6108 = D.6105 + D.6107;
              D.6109 = (GC_word *) D.6108;
              mark_stack_top->mse_start = D.6109;
              mark_stack_top->mse_descr = _descr;
              <D.6101>:
            }
          }
          exit4:
        }
        next_object:
      }
      <D.5335>:
      mark_stack_top.98 = (int) mark_stack_top;
      mark_stack.99 = (int) mark_stack;
      D.6112 = mark_stack_top.98 - mark_stack.99;
      D.6113 = D.6112 | credit;
      if (D.6113 >= 0) goto <D.5372>; else goto <D.5373>;
      <D.5373>:
      D.6114 = mark_stack_top;
      return D.6114;
    }
  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.6120;
  GC_word * D.6121;
  long unsigned int D.6122;
  long unsigned int D.6125;
  _Bool D.6126;
  _Bool D.6127;
  _Bool D.6128;
  struct mse * D.6129;
  struct mse * p;
  struct mse * top;
  unsigned int i;

  top = local + 4294967288;
  i = 0;
  p = low;
  goto <D.5391>;
  <D.5390>:
  {
    word descr;

    descr = p->mse_descr;
    if (descr != 0) goto <D.6118>; else goto <D.6119>;
    <D.6118>:
    D.6120 = &p->mse_descr;
    MEM[(volatile word *)D.6120] = 0;
    top = top + 8;
    top->mse_descr = descr;
    D.6121 = p->mse_start;
    top->mse_start = D.6121;
    i = i + 1;
    D.6122 = descr & 3;
    if (D.6122 == 0) goto <D.6123>; else goto <D.6124>;
    <D.6123>:
    D.6125 = descr >> 8;
    i = D.6125 + i;
    <D.6124>:
    <D.6119>:
  }
  p = p + 8;
  <D.5391>:
  D.6126 = p <= high;
  D.6127 = i <= max;
  D.6128 = D.6126 & D.6127;
  if (D.6128 != 0) goto <D.5390>; else goto <D.5392>;
  <D.5392>:
  *next = p;
  D.6129 = top;
  return D.6129;
}


GC_return_mark_stack (struct mse * low, struct mse * high)
{
  int high.100;
  int low.101;
  int D.6135;
  int D.6136;
  int D.6137;
  int my_start.102;
  struct mse * GC_mark_stack.103;
  int GC_mark_stack.104;
  int D.6141;
  int D.6142;
  unsigned int D.6143;
  unsigned int D.6144;
  long unsigned int GC_mark_stack_size.105;
  int GC_print_stats.106;
  unsigned int D.6152;
  struct mse * GC_mark_stack_top.107;
  struct mse * my_top;
  struct mse * my_start;
  size_t stack_size;

  if (high < low) goto <D.6131>; else goto <D.6132>;
  <D.6131>:
  return;
  <D.6132>:
  high.100 = (int) high;
  low.101 = (int) low;
  D.6135 = high.100 - low.101;
  D.6136 = D.6135 /[ex] 8;
  D.6137 = D.6136 + 1;
  stack_size = (size_t) D.6137;
  GC_acquire_mark_lock ();
  my_top = GC_mark_stack_top;
  my_start = my_top + 8;
  my_start.102 = (int) my_start;
  GC_mark_stack.103 = GC_mark_stack;
  GC_mark_stack.104 = (int) GC_mark_stack.103;
  D.6141 = my_start.102 - GC_mark_stack.104;
  D.6142 = D.6141 /[ex] 8;
  D.6143 = (unsigned int) D.6142;
  D.6144 = D.6143 + stack_size;
  GC_mark_stack_size.105 = GC_mark_stack_size;
  if (D.6144 > GC_mark_stack_size.105) goto <D.6146>; else goto <D.6147>;
  <D.6146>:
  GC_print_stats.106 = GC_print_stats;
  if (GC_print_stats.106 != 0) goto <D.6149>; else goto <D.6150>;
  <D.6149>:
  GC_printf ("No room to copy back mark stack.", 0, 0, 0, 0, 0, 0);
  <D.6150>:
  GC_mark_state = 5;
  GC_mark_stack_too_small = 1;
  goto <D.6151>;
  <D.6147>:
  D.6152 = stack_size * 8;
  memcpy (my_start, low, D.6152);
  GC_memory_barrier ();
  D.6152 = stack_size * 8;
  GC_mark_stack_top.107 = my_top + D.6152;
  GC_mark_stack_top = GC_mark_stack_top.107;
  <D.6151>:
  GC_release_mark_lock ();
  GC_notify_all_marker ();
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.6155;
  unsigned int D.6156;

  D.6156 = __builtin_object_size (__dest, 0);
  D.6155 = __builtin___memcpy_chk (__dest, __src, __len, D.6156);
  return D.6155;
}


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


GC_do_local_mark (struct mse * local_mark_stack, struct mse * local_top)
{
  struct mse * D.6158;
  int local_top.108;
  int local_mark_stack.109;
  int D.6163;
  int D.6164;
  long unsigned int D.6165;
  struct mse * GC_mark_stack_top.110;
  struct mse * GC_first_nonempty.111;
  unsigned int GC_active_count.112;
  unsigned int GC_helper_count.113;
  struct mse * D.6176;
  int D.6179;
  unsigned int D.6180;
  unsigned int D.6181;
  struct mse * D.6182;
  int new_bottom.114;
  int D.6184;
  int D.6185;
  int D.6186;
  unsigned int D.6187;
  unsigned int D.6188;
  int D.6189;
  sizetype D.6190;
  sizetype D.6191;
  unsigned int n;

  <D.5410>:
  n = 0;
  goto <D.5406>;
  <D.5405>:
  D.6158 = local_mark_stack + 32768;
  local_top = GC_mark_from (local_top, local_mark_stack, D.6158);
  if (local_top < local_mark_stack) goto <D.6159>; else goto <D.6160>;
  <D.6159>:
  return;
  <D.6160>:
  local_top.108 = (int) local_top;
  local_mark_stack.109 = (int) local_mark_stack;
  D.6163 = local_top.108 - local_mark_stack.109;
  D.6164 = D.6163 /[ex] 8;
  D.6165 = (long unsigned int) D.6164;
  if (D.6165 > 2047) goto <D.6166>; else goto <D.6167>;
  <D.6166>:
  GC_return_mark_stack (local_mark_stack, local_top);
  return;
  <D.6167>:
  n = n + 1;
  <D.5406>:
  if (n == 0) goto <D.5405>; else goto <D.5407>;
  <D.5407>:
  GC_mark_stack_top.110 = GC_mark_stack_top;
  GC_first_nonempty.111 = GC_first_nonempty;
  if (GC_mark_stack_top.110 < GC_first_nonempty.111) goto <D.6170>; else goto <D.6171>;
  <D.6170>:
  GC_active_count.112 = GC_active_count;
  GC_helper_count.113 = GC_helper_count;
  if (GC_active_count.112 < GC_helper_count.113) goto <D.6174>; else goto <D.6175>;
  <D.6174>:
  D.6176 = local_mark_stack + 8;
  if (D.6176 < local_top) goto <D.6177>; else goto <D.6178>;
  <D.6177>:
  {
    struct mse * p;
    struct mse * new_bottom;

    local_top.108 = (int) local_top;
    local_mark_stack.109 = (int) local_mark_stack;
    D.6163 = local_top.108 - local_mark_stack.109;
    D.6164 = D.6163 /[ex] 8;
    D.6179 = D.6164 / 2;
    D.6180 = (unsigned int) D.6179;
    D.6181 = D.6180 * 8;
    new_bottom = local_mark_stack + D.6181;
    D.6182 = new_bottom + 4294967288;
    GC_return_mark_stack (local_mark_stack, D.6182);
    local_top.108 = (int) local_top;
    new_bottom.114 = (int) new_bottom;
    D.6184 = local_top.108 - new_bottom.114;
    D.6185 = D.6184 /[ex] 8;
    D.6186 = D.6185 + 1;
    D.6187 = (unsigned int) D.6186;
    D.6188 = D.6187 * 8;
    memmove (local_mark_stack, new_bottom, D.6188);
    new_bottom.114 = (int) new_bottom;
    local_mark_stack.109 = (int) local_mark_stack;
    D.6189 = new_bottom.114 - local_mark_stack.109;
    D.6190 = (sizetype) D.6189;
    D.6191 = -D.6190;
    local_top = local_top + D.6191;
  }
  <D.6178>:
  <D.6175>:
  <D.6171>:
  goto <D.5410>;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.6193;
  unsigned int D.6194;

  D.6194 = __builtin_object_size (__dest, 0);
  D.6193 = __builtin___memmove_chk (__dest, __src, __len, D.6194);
  return D.6193;
}


GC_mark_local (struct mse * local_mark_stack, int id)
{
  unsigned int GC_active_count.115;
  unsigned int GC_active_count.116;
  struct mse * GC_first_nonempty.117;
  struct mse * my_first_nonempty.118;
  long unsigned int my_first_nonempty.119;
  long unsigned int global_first_nonempty.120;
  int my_top.121;
  int my_first_nonempty.122;
  int D.6209;
  int D.6210;
  int D.6211;
  unsigned int GC_active_count.123;
  struct mse * GC_first_nonempty.124;
  struct mse * GC_mark_stack_top.125;
  struct mse * GC_first_nonempty.126;
  struct mse * GC_mark_stack_top.127;
  unsigned int GC_helper_count.128;
  unsigned int GC_helper_count.129;
  struct mse * my_first_nonempty;

  try
    {
      GC_acquire_mark_lock ();
      GC_active_count.115 = GC_active_count;
      GC_active_count.116 = GC_active_count.115 + 1;
      GC_active_count = GC_active_count.116;
      GC_first_nonempty.117 = GC_first_nonempty;
      my_first_nonempty = GC_first_nonempty.117;
      GC_release_mark_lock ();
      <D.5428>:
      {
        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.118 = my_first_nonempty;
        if (my_first_nonempty.118 < global_first_nonempty) goto <D.6200>; else goto <D.6201>;
        <D.6200>:
        my_first_nonempty = global_first_nonempty;
        goto <D.6202>;
        <D.6201>:
        my_first_nonempty.118 = my_first_nonempty;
        if (global_first_nonempty < my_first_nonempty.118) goto <D.6203>; else goto <D.6204>;
        <D.6203>:
        my_first_nonempty.118 = my_first_nonempty;
        my_first_nonempty.119 = (long unsigned int) my_first_nonempty.118;
        global_first_nonempty.120 = (long unsigned int) global_first_nonempty;
        GC_compare_and_exchange (&GC_first_nonempty, global_first_nonempty.120, my_first_nonempty.119);
        <D.6204>:
        <D.6202>:
        my_top = GC_mark_stack_top;
        my_top.121 = (int) my_top;
        my_first_nonempty.118 = my_first_nonempty;
        my_first_nonempty.122 = (int) my_first_nonempty.118;
        D.6209 = my_top.121 - my_first_nonempty.122;
        D.6210 = D.6209 /[ex] 8;
        D.6211 = D.6210 + 1;
        n_on_stack = (size_t) D.6211;
        if (n_on_stack == 0) goto <D.6212>; else goto <D.6213>;
        <D.6212>:
        GC_acquire_mark_lock ();
        my_top = GC_mark_stack_top;
        my_top.121 = (int) my_top;
        my_first_nonempty.118 = my_first_nonempty;
        my_first_nonempty.122 = (int) my_first_nonempty.118;
        D.6209 = my_top.121 - my_first_nonempty.122;
        D.6210 = D.6209 /[ex] 8;
        D.6211 = D.6210 + 1;
        n_on_stack = (size_t) D.6211;
        if (n_on_stack == 0) goto <D.6214>; else goto <D.6215>;
        <D.6214>:
        GC_active_count.115 = GC_active_count;
        GC_active_count.123 = GC_active_count.115 + 4294967295;
        GC_active_count = GC_active_count.123;
        GC_active_count.115 = GC_active_count;
        if (GC_active_count.115 == 0) goto <D.6217>; else goto <D.6218>;
        <D.6217>:
        GC_notify_all_marker ();
        <D.6218>:
        goto <D.5424>;
        <D.5423>:
        GC_wait_marker ();
        <D.5424>:
        GC_active_count.115 = GC_active_count;
        if (GC_active_count.115 != 0) goto <D.6219>; else goto <D.5425>;
        <D.6219>:
        GC_first_nonempty.124 = GC_first_nonempty;
        GC_mark_stack_top.125 = GC_mark_stack_top;
        if (GC_first_nonempty.124 > GC_mark_stack_top.125) goto <D.5423>; else goto <D.5425>;
        <D.5425>:
        GC_active_count.115 = GC_active_count;
        if (GC_active_count.115 == 0) goto <D.6222>; else goto <D.6223>;
        <D.6222>:
        GC_first_nonempty.126 = GC_first_nonempty;
        GC_mark_stack_top.127 = GC_mark_stack_top;
        if (GC_first_nonempty.126 > GC_mark_stack_top.127) goto <D.6226>; else goto <D.6227>;
        <D.6226>:
        {
          GC_bool need_to_notify;

          need_to_notify = 0;
          GC_helper_count.128 = GC_helper_count;
          GC_helper_count.129 = GC_helper_count.128 + 4294967295;
          GC_helper_count = GC_helper_count.129;
          GC_helper_count.128 = GC_helper_count;
          if (GC_helper_count.128 == 0) goto <D.6230>; else goto <D.6231>;
          <D.6230>:
          need_to_notify = 1;
          <D.6231>:
          GC_release_mark_lock ();
          if (need_to_notify != 0) goto <D.6232>; else goto <D.6233>;
          <D.6232>:
          GC_notify_all_marker ();
          <D.6233>:
          return;
        }
        <D.6227>:
        <D.6223>:
        GC_active_count.115 = GC_active_count;
        GC_active_count.116 = GC_active_count.115 + 1;
        GC_active_count = GC_active_count.116;
        GC_release_mark_lock ();
        // predicted unlikely by continue predictor.
        goto <D.5427>;
        <D.6215>:
        GC_release_mark_lock ();
        <D.6213>:
        n_to_get = 5;
        if (n_on_stack <= 9) goto <D.6234>; else goto <D.6235>;
        <D.6234>:
        n_to_get = 1;
        <D.6235>:
        my_first_nonempty.118 = my_first_nonempty;
        local_top = GC_steal_mark_stack (my_first_nonempty.118, my_top, local_mark_stack, n_to_get, &my_first_nonempty);
        GC_do_local_mark (local_mark_stack, local_top);
      }
      <D.5427>:
      goto <D.5428>;
    }
  finally
    {
      my_first_nonempty = {CLOBBER};
    }
}


GC_do_parallel_mark ()
{
  int GC_help_wanted.130;
  unsigned int GC_active_count.131;
  unsigned int GC_helper_count.132;
  struct mse * GC_mark_stack.133;
  long unsigned int GC_mark_no.134;
  long unsigned int GC_mark_no.135;
  struct mse local_mark_stack[4096];
  struct mse * local_top;
  struct mse * my_top;

  try
    {
      GC_acquire_mark_lock ();
      GC_help_wanted.130 = GC_help_wanted;
      if (GC_help_wanted.130 != 0) goto <D.6238>; else goto <D.6241>;
      <D.6241>:
      GC_active_count.131 = GC_active_count;
      if (GC_active_count.131 != 0) goto <D.6238>; else goto <D.6243>;
      <D.6243>:
      GC_helper_count.132 = GC_helper_count;
      if (GC_helper_count.132 != 0) goto <D.6238>; else goto <D.6239>;
      <D.6238>:
      GC_abort ("Tried to start parallel mark in bad state");
      <D.6239>:
      GC_mark_stack.133 = GC_mark_stack;
      GC_first_nonempty = GC_mark_stack.133;
      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.5435>;
      <D.5434>:
      GC_wait_marker ();
      <D.5435>:
      GC_helper_count.132 = GC_helper_count;
      if (GC_helper_count.132 != 0) goto <D.5434>; else goto <D.5436>;
      <D.5436>:
      GC_mark_no.134 = GC_mark_no;
      GC_mark_no.135 = GC_mark_no.134 + 1;
      GC_mark_no = GC_mark_no.135;
      GC_release_mark_lock ();
      GC_notify_all_marker ();
    }
  finally
    {
      local_mark_stack = {CLOBBER};
    }
}


GC_help_marker (word my_mark_no)
{
  int GC_parallel.136;
  long unsigned int GC_mark_no.137;
  int GC_help_wanted.138;
  long int GC_markers.139;
  long unsigned int GC_markers.140;
  unsigned int GC_helper_count.141;
  int my_id.142;
  struct mse local_mark_stack[4096];
  unsigned int my_id;
  struct mse * my_first_nonempty;

  try
    {
      GC_parallel.136 = GC_parallel;
      if (GC_parallel.136 == 0) goto <D.6249>; else goto <D.6250>;
      <D.6249>:
      return;
      <D.6250>:
      GC_acquire_mark_lock ();
      goto <D.5444>;
      <D.5443>:
      GC_wait_marker ();
      <D.5444>:
      GC_mark_no.137 = GC_mark_no;
      if (GC_mark_no.137 < my_mark_no) goto <D.5443>; else goto <D.6252>;
      <D.6252>:
      GC_help_wanted.138 = GC_help_wanted;
      if (GC_help_wanted.138 == 0) goto <D.6254>; else goto <D.5445>;
      <D.6254>:
      GC_mark_no.137 = GC_mark_no;
      if (GC_mark_no.137 == my_mark_no) goto <D.5443>; else goto <D.5445>;
      <D.5445>:
      my_id = GC_helper_count;
      GC_mark_no.137 = GC_mark_no;
      if (GC_mark_no.137 != my_mark_no) goto <D.6255>; else goto <D.6257>;
      <D.6257>:
      GC_markers.139 = GC_markers;
      GC_markers.140 = (long unsigned int) GC_markers.139;
      if (GC_markers.140 <= my_id) goto <D.6255>; else goto <D.6256>;
      <D.6255>:
      GC_release_mark_lock ();
      return;
      <D.6256>:
      GC_helper_count.141 = my_id + 1;
      GC_helper_count = GC_helper_count.141;
      GC_release_mark_lock ();
      my_id.142 = (int) my_id;
      GC_mark_local (&local_mark_stack, my_id.142);
    }
  finally
    {
      local_mark_stack = {CLOBBER};
    }
}


GC_mark_init ()
{
  alloc_mark_stack (4096);
}


GC_push_all (char * bottom, char * top)
{
  long unsigned int bottom.143;
  long unsigned int D.6266;
  long unsigned int D.6267;
  long unsigned int top.144;
  long unsigned int D.6269;
  _Bool D.6270;
  _Bool D.6271;
  _Bool D.6272;
  struct mse * GC_mark_stack_top.145;
  struct mse * GC_mark_stack_top.146;
  struct mse * GC_mark_stack_top.147;
  struct mse * GC_mark_stack_limit.148;
  int top.149;
  int bottom.150;
  int D.6283;
  struct mse * GC_mark_stack_top.151;
  struct mse * GC_mark_stack_top.152;
  register word length;

  bottom.143 = (long unsigned int) bottom;
  D.6266 = bottom.143 + 3;
  D.6267 = D.6266 & 4294967292;
  bottom = (char *) D.6267;
  top.144 = (long unsigned int) top;
  D.6269 = top.144 & 4294967292;
  top = (char *) D.6269;
  D.6270 = top == 0B;
  D.6271 = bottom == top;
  D.6272 = D.6270 | D.6271;
  if (D.6272 != 0) goto <D.6273>; else goto <D.6274>;
  <D.6273>:
  return;
  <D.6274>:
  GC_mark_stack_top.145 = GC_mark_stack_top;
  GC_mark_stack_top.146 = GC_mark_stack_top.145 + 8;
  GC_mark_stack_top = GC_mark_stack_top.146;
  GC_mark_stack_top.147 = GC_mark_stack_top;
  GC_mark_stack_limit.148 = GC_mark_stack_limit;
  if (GC_mark_stack_top.147 >= GC_mark_stack_limit.148) goto <D.6279>; else goto <D.6280>;
  <D.6279>:
  GC_abort ("unexpected mark stack overflow");
  <D.6280>:
  top.149 = (int) top;
  bottom.150 = (int) bottom;
  D.6283 = top.149 - bottom.150;
  length = (word) D.6283;
  GC_mark_stack_top.151 = GC_mark_stack_top;
  GC_mark_stack_top.151->mse_start = bottom;
  GC_mark_stack_top.152 = GC_mark_stack_top;
  GC_mark_stack_top.152->mse_descr = length;
}


GC_push_selected (char * bottom, char * top, int (*<Tf4a>) (struct hblk *) dirty_fn, void (*<Tf4d>) (char *, char *) push_fn)
{
  long int bottom.153;
  long int D.6288;
  long int D.6289;
  long int top.154;
  long int D.6291;
  _Bool D.6292;
  _Bool D.6293;
  _Bool D.6294;
  char * D.6297;
  long unsigned int D.6298;
  long unsigned int D.6299;
  struct hblk * D.6302;
  int D.6303;
  int D.6306;
  int D.6309;
  struct mse * GC_mark_stack_top.155;
  int GC_mark_stack_top.156;
  struct mse * GC_mark_stack.157;
  int GC_mark_stack.158;
  int D.6316;
  int D.6317;
  long unsigned int D.6318;
  long unsigned int GC_mark_stack_size.159;
  long unsigned int D.6320;
  long unsigned int D.6321;
  char * D.6324;
  int D.6327;
  struct mse * GC_mark_stack_top.160;
  struct mse * GC_mark_stack_limit.161;
  register struct hblk * h;

  bottom.153 = (long int) bottom;
  D.6288 = bottom.153 + 3;
  D.6289 = D.6288 & -4;
  bottom = (char *) D.6289;
  top.154 = (long int) top;
  D.6291 = top.154 & -4;
  top = (char *) D.6291;
  D.6292 = top == 0B;
  D.6293 = bottom == top;
  D.6294 = D.6292 | D.6293;
  if (D.6294 != 0) goto <D.6295>; else goto <D.6296>;
  <D.6295>:
  return;
  <D.6296>:
  D.6297 = bottom + 4096;
  D.6298 = (long unsigned int) D.6297;
  D.6299 = D.6298 & 4294963200;
  h = (struct hblk *) D.6299;
  if (top <= h) goto <D.6300>; else goto <D.6301>;
  <D.6300>:
  D.6302 = h + 4294963200;
  D.6303 = dirty_fn (D.6302);
  if (D.6303 != 0) goto <D.6304>; else goto <D.6305>;
  <D.6304>:
  push_fn (bottom, top);
  <D.6305>:
  return;
  <D.6301>:
  D.6302 = h + 4294963200;
  D.6306 = dirty_fn (D.6302);
  if (D.6306 != 0) goto <D.6307>; else goto <D.6308>;
  <D.6307>:
  push_fn (bottom, h);
  <D.6308>:
  goto <D.5470>;
  <D.5469>:
  D.6309 = dirty_fn (h);
  if (D.6309 != 0) goto <D.6310>; else goto <D.6311>;
  <D.6310>:
  GC_mark_stack_top.155 = GC_mark_stack_top;
  GC_mark_stack_top.156 = (int) GC_mark_stack_top.155;
  GC_mark_stack.157 = GC_mark_stack;
  GC_mark_stack.158 = (int) GC_mark_stack.157;
  D.6316 = GC_mark_stack_top.156 - GC_mark_stack.158;
  D.6317 = D.6316 /[ex] 8;
  D.6318 = (long unsigned int) D.6317;
  GC_mark_stack_size.159 = GC_mark_stack_size;
  D.6320 = GC_mark_stack_size.159 * 3;
  D.6321 = D.6320 / 4;
  if (D.6318 > D.6321) goto <D.6322>; else goto <D.6323>;
  <D.6322>:
  push_fn (h, top);
  return;
  <D.6323>:
  D.6324 = h + 4096;
  push_fn (h, D.6324);
  <D.6311>:
  h = h + 4096;
  <D.5470>:
  D.6324 = h + 4096;
  if (D.6324 <= top) goto <D.5469>; else goto <D.5471>;
  <D.5471>:
  if (h != top) goto <D.6325>; else goto <D.6326>;
  <D.6325>:
  D.6327 = dirty_fn (h);
  if (D.6327 != 0) goto <D.6328>; else goto <D.6329>;
  <D.6328>:
  push_fn (h, top);
  <D.6329>:
  <D.6326>:
  GC_mark_stack_top.160 = GC_mark_stack_top;
  GC_mark_stack_limit.161 = GC_mark_stack_limit;
  if (GC_mark_stack_top.160 >= GC_mark_stack_limit.161) goto <D.6332>; else goto <D.6333>;
  <D.6332>:
  GC_abort ("unexpected mark stack overflow");
  <D.6333>:
}


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

  D.6335 = 1;
  return D.6335;
}


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

  if (all != 0) goto <D.6337>; else goto <D.6338>;
  <D.6337>:
  GC_dirty_maintained.162 = GC_dirty_maintained;
  if (GC_dirty_maintained.162 != 0) goto <D.6340>; else goto <D.6341>;
  <D.6340>:
  GC_push_all (bottom, top);
  goto <D.6342>;
  <D.6341>:
  GC_push_all (bottom, top);
  <D.6342>:
  goto <D.6343>;
  <D.6338>:
  GC_push_selected (bottom, top, GC_page_was_dirty, GC_push_all);
  <D.6343>:
}


GC_push_one (word p)
{
  char * p.163;
  void * GC_least_plausible_heap_addr.164;
  void * GC_greatest_plausible_heap_addr.165;

  p.163 = (char *) p;
  GC_least_plausible_heap_addr.164 = GC_least_plausible_heap_addr;
  if (p.163 >= GC_least_plausible_heap_addr.164) goto <D.6346>; else goto <D.6347>;
  <D.6346>:
  p.163 = (char *) p;
  GC_greatest_plausible_heap_addr.165 = GC_greatest_plausible_heap_addr;
  if (p.163 < GC_greatest_plausible_heap_addr.165) goto <D.6349>; else goto <D.6350>;
  <D.6349>:
  GC_mark_and_push_stack (p);
  <D.6350>:
  <D.6347>:
}


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.166;
  long unsigned int D.6352;
  struct bottom_index * D.6353;
  long unsigned int D.6354;
  long unsigned int D.6355;
  long unsigned int my_hhdr.167;
  struct hdr * GC_invalid_header.168;
  int my_current.169;
  map_entry_type * D.6361;
  sizetype displ.170;
  map_entry_type * D.6363;
  unsigned char D.6364;
  long unsigned int displ.171;
  long unsigned int D.6370;
  long unsigned int D.6371;
  long unsigned int D.6372;
  int GC_all_interior_pointers.172;
  int D.6384;
  sizetype D.6385;
  int D.6386;
  long unsigned int D.6387;
  long unsigned int D.6389;
  int D.6390;
  unsigned int displ.173;
  unsigned int D.6397;
  sizetype my_current.174;
  sizetype D.6399;
  sizetype D.6400;
  GC_word * D.6401;
  struct GC_ms_entry * D.6402;
  void was_marked = <<< error >>>;

  {
    struct hdr * my_hhdr;
    char * my_current;

    my_current = obj;
    my_current.166 = (long unsigned int) my_current;
    D.6352 = my_current.166 >> 22;
    D.6353 = GC_arrays._top_index[D.6352];
    my_current.166 = (long unsigned int) my_current;
    D.6354 = my_current.166 >> 12;
    D.6355 = D.6354 & 1023;
    my_hhdr = D.6353->index[D.6355];
    my_hhdr.167 = (long unsigned int) my_hhdr;
    if (my_hhdr.167 <= 4095) goto <D.6357>; else goto <D.6358>;
    <D.6357>:
    {
      struct hdr * new_hdr;

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

      my_current.169 = (int) my_current;
      displ = my_current.169 & 4095;
      D.6361 = my_hhdr->hb_map;
      displ.170 = (sizetype) displ;
      D.6363 = D.6361 + displ.170;
      D.6364 = *D.6363;
      map_entry = (int) D.6364;
      displ = displ >> 2;
      if (map_entry > 253) goto <D.6365>; else goto <D.6366>;
      <D.6365>:
      if (map_entry == 254) goto <D.6367>; else goto <D.6368>;
      <D.6367>:
      displ.171 = (long unsigned int) displ;
      D.6370 = my_hhdr->hb_sz;
      D.6371 = displ.171 % D.6370;
      map_entry = (int) D.6371;
      displ = displ - map_entry;
      D.6370 = my_hhdr->hb_sz;
      displ.171 = (long unsigned int) displ;
      D.6372 = D.6370 + displ.171;
      if (D.6372 > 1024) goto <D.6373>; else goto <D.6374>;
      <D.6373>:
      GC_all_interior_pointers.172 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.172 != 0) goto <D.6376>; else goto <D.6377>;
      <D.6376>:
      my_current.166 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.166);
      goto <D.6378>;
      <D.6377>:
      my_current.166 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.166);
      <D.6378>:
      goto was_marked;
      <D.6374>:
      goto <D.6379>;
      <D.6368>:
      GC_all_interior_pointers.172 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.172 != 0) goto <D.6380>; else goto <D.6381>;
      <D.6380>:
      my_current.166 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.166);
      goto <D.6382>;
      <D.6381>:
      my_current.166 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.166);
      <D.6382>:
      goto was_marked;
      <D.6379>:
      goto <D.6383>;
      <D.6366>:
      displ = displ - map_entry;
      <D.6383>:
      {
        register word * mark_word_addr;

        D.6384 = displ >> 5;
        D.6385 = (sizetype) D.6384;
        mark_word_addr = &my_hhdr->hb_marks[D.6385];
        {
          word old;
          word my_bits;

          D.6386 = displ & 31;
          my_bits = 1 << D.6386;
          <D.5498>:
          old = MEM[(volatile word *)mark_word_addr];
          D.6387 = old & my_bits;
          if (D.6387 != 0) goto was_marked; else goto <D.6388>;
          <D.6388>:
          D.6389 = old | my_bits;
          D.6390 = GC_compare_and_exchange (mark_word_addr, old, D.6389);
          if (D.6390 == 0) goto <D.5498>; else goto <D.5499>;
          <D.5499>:
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.6391>; else goto <D.6392>;
        <D.6391>:
        goto <D.6393>;
        <D.6392>:
        mark_stack_ptr = mark_stack_ptr + 8;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.6394>; else goto <D.6395>;
        <D.6394>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.6395>:
        displ.173 = (unsigned int) displ;
        D.6397 = displ.173 * 4;
        my_current.174 = (sizetype) my_current;
        D.6399 = my_current.174 & 4294963200;
        D.6400 = D.6397 + D.6399;
        D.6401 = (GC_word *) D.6400;
        mark_stack_ptr->mse_start = D.6401;
        mark_stack_ptr->mse_descr = _descr;
        <D.6393>:
      }
    }
    was_marked:
  }
  D.6402 = mark_stack_ptr;
  return D.6402;
}


GC_mark_and_push_stack (word p)
{
  long unsigned int D.6404;
  struct bottom_index * D.6405;
  long unsigned int D.6406;
  long unsigned int D.6407;
  long unsigned int hhdr.175;
  void * p.176;
  void * D.6414;
  long unsigned int D.6415;
  struct bottom_index * D.6416;
  long unsigned int D.6417;
  long unsigned int D.6418;
  long unsigned int D.6419;
  long unsigned int D.6420;
  int p.177;
  map_entry_type * D.6423;
  sizetype displ.178;
  map_entry_type * D.6425;
  int GC_all_interior_pointers.179;
  void * D.6433;
  int D.6437;
  unsigned int displ.180;
  unsigned int D.6439;
  sizetype D.6440;
  int D.6444;
  long unsigned int D.6445;
  int D.6446;
  long unsigned int D.6447;
  long unsigned int D.6448;
  sizetype D.6451;
  long unsigned int D.6452;
  long unsigned int D.6453;
  word * D.6454;
  int D.6455;
  struct mse * GC_mark_stack_top.181;
  struct mse * GC_mark_stack_top.182;
  struct mse * GC_mark_stack_top.183;
  struct mse * GC_mark_stack_limit.184;
  struct mse * GC_mark_stack_top.185;
  struct mse * GC_mark_stack_top.186;
  struct mse * GC_mark_stack_top.187;
  GC_word * r.188;
  struct mse * GC_mark_stack_top.189;
  register word r;
  register struct hdr * hhdr;
  register int displ;

  D.6404 = p >> 22;
  D.6405 = GC_arrays._top_index[D.6404];
  D.6406 = p >> 12;
  D.6407 = D.6406 & 1023;
  hhdr = D.6405->index[D.6407];
  hhdr.175 = (long unsigned int) hhdr;
  if (hhdr.175 <= 4095) goto <D.6409>; else goto <D.6410>;
  <D.6409>:
  if (hhdr != 0B) goto <D.6411>; else goto <D.6412>;
  <D.6411>:
  p.176 = (void *) p;
  D.6414 = GC_base (p.176);
  r = (word) D.6414;
  D.6415 = r >> 22;
  D.6416 = GC_arrays._top_index[D.6415];
  D.6417 = r >> 12;
  D.6418 = D.6417 & 1023;
  hhdr = D.6416->index[D.6418];
  D.6419 = r & 4095;
  D.6420 = D.6419 >> 2;
  displ = (int) D.6420;
  <D.6412>:
  goto <D.6421>;
  <D.6410>:
  {
    register map_entry_type map_entry;

    p.177 = (int) p;
    displ = p.177 & 4095;
    D.6423 = hhdr->hb_map;
    displ.178 = (sizetype) displ;
    D.6425 = D.6423 + displ.178;
    map_entry = *D.6425;
    if (map_entry > 252) goto <D.6426>; else goto <D.6427>;
    <D.6426>:
    if (map_entry == 254) goto <D.6428>; else goto <D.6431>;
    <D.6431>:
    GC_all_interior_pointers.179 = GC_all_interior_pointers;
    if (GC_all_interior_pointers.179 == 0) goto <D.6428>; else goto <D.6429>;
    <D.6428>:
    p.176 = (void *) p;
    D.6433 = GC_base (p.176);
    r = (word) D.6433;
    D.6419 = r & 4095;
    D.6420 = D.6419 >> 2;
    displ = (int) D.6420;
    if (r == 0) goto <D.6434>; else goto <D.6435>;
    <D.6434>:
    hhdr = 0B;
    <D.6435>:
    goto <D.6430>;
    <D.6429>:
    hhdr = 0B;
    <D.6430>:
    goto <D.6436>;
    <D.6427>:
    displ = displ >> 2;
    D.6437 = (int) map_entry;
    displ = displ - D.6437;
    displ.180 = (unsigned int) displ;
    D.6439 = displ.180 * 4;
    D.6440 = p & 4294963200;
    r = D.6439 + D.6440;
    <D.6436>:
  }
  <D.6421>:
  if (hhdr == 0B) goto <D.6441>; else goto <D.6442>;
  <D.6441>:
  GC_add_to_black_list_stack (p);
  goto <D.6443>;
  <D.6442>:
  D.6444 = displ >> 5;
  D.6445 = hhdr->hb_marks[D.6444];
  D.6446 = displ & 31;
  D.6447 = D.6445 >> D.6446;
  D.6448 = D.6447 & 1;
  if (D.6448 == 0) goto <D.6449>; else goto <D.6450>;
  <D.6449>:
  {
    word old;

    <D.5509>:
    D.6444 = displ >> 5;
    D.6451 = (sizetype) D.6444;
    old = hhdr->hb_marks[D.6451];
    D.6446 = displ & 31;
    D.6452 = 1 << D.6446;
    D.6453 = D.6452 | old;
    D.6444 = displ >> 5;
    D.6451 = (sizetype) D.6444;
    D.6454 = &hhdr->hb_marks[D.6451];
    D.6455 = GC_compare_and_exchange (D.6454, old, D.6453);
    if (D.6455 == 0) goto <D.5509>; else goto <D.5510>;
    <D.5510>:
  }
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.6456>; else goto <D.6457>;
    <D.6456>:
    goto <D.6458>;
    <D.6457>:
    GC_mark_stack_top.181 = GC_mark_stack_top;
    GC_mark_stack_top.182 = GC_mark_stack_top.181 + 8;
    GC_mark_stack_top = GC_mark_stack_top.182;
    GC_mark_stack_top.183 = GC_mark_stack_top;
    GC_mark_stack_limit.184 = GC_mark_stack_limit;
    if (GC_mark_stack_top.183 >= GC_mark_stack_limit.184) goto <D.6463>; else goto <D.6464>;
    <D.6463>:
    GC_mark_stack_top.185 = GC_mark_stack_top;
    GC_mark_stack_top.186 = GC_signal_mark_stack_overflow (GC_mark_stack_top.185);
    GC_mark_stack_top = GC_mark_stack_top.186;
    <D.6464>:
    GC_mark_stack_top.187 = GC_mark_stack_top;
    r.188 = (GC_word *) r;
    GC_mark_stack_top.187->mse_start = r.188;
    GC_mark_stack_top.189 = GC_mark_stack_top;
    GC_mark_stack_top.189->mse_descr = _descr;
    <D.6458>:
  }
  <D.6450>:
  <D.6443>:
}


GC_push_all_eager (char * bottom, char * top)
{
  long unsigned int bottom.190;
  long unsigned int D.6471;
  long unsigned int D.6472;
  long unsigned int top.191;
  long unsigned int D.6474;
  char * q.192;
  _Bool D.6478;
  _Bool D.6479;
  _Bool D.6480;
  word * b;
  word * t;
  register word * p;
  register word q;
  register word * lim;
  register char * greatest_ha;
  register char * least_ha;

  bottom.190 = (long unsigned int) bottom;
  D.6471 = bottom.190 + 3;
  D.6472 = D.6471 & 4294967292;
  b = (word *) D.6472;
  top.191 = (long unsigned int) top;
  D.6474 = top.191 & 4294967292;
  t = (word *) D.6474;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  if (top == 0B) goto <D.6475>; else goto <D.6476>;
  <D.6475>:
  return;
  <D.6476>:
  lim = t + 4294967292;
  p = b;
  goto <D.5524>;
  <D.5523>:
  q = *p;
  q.192 = (char *) q;
  D.6478 = q.192 >= least_ha;
  q.192 = (char *) q;
  D.6479 = q.192 < greatest_ha;
  D.6480 = D.6478 & D.6479;
  if (D.6480 != 0) goto <D.6481>; else goto <D.6482>;
  <D.6481>:
  GC_mark_and_push_stack (q);
  <D.6482>:
  p = p + 4;
  <D.5524>:
  if (p <= lim) goto <D.5523>; else goto <D.5525>;
  <D.5525>:
}


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

  GC_all_interior_pointers.193 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.193 != 0) goto <D.6485>; else goto <D.6486>;
  <D.6485>:
  GC_push_all (bottom, top);
  goto <D.6487>;
  <D.6486>:
  GC_push_all_eager (bottom, top);
  <D.6487>:
}


GC_push_marked1 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.194;
  long unsigned int D.6489;
  word * mark_word_addr.195;
  long unsigned int D.6491;
  unsigned int i.196;
  unsigned int D.6495;
  word * D.6496;
  char * q.197;
  _Bool D.6498;
  _Bool D.6499;
  _Bool D.6500;
  void * * D.6503;
  void * q.198;
  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.194 = (long unsigned int) h;
  D.6489 = h.194 + 4096;
  plim = (word *) D.6489;
  goto <D.5548>;
  <D.5547>:
  mark_word_addr.195 = mark_word_addr;
  mark_word_addr = mark_word_addr.195 + 4;
  mark_word = *mark_word_addr.195;
  i = 0;
  goto <D.5545>;
  <D.5544>:
  D.6491 = mark_word & 1;
  if (D.6491 != 0) goto <D.6492>; else goto <D.6493>;
  <D.6492>:
  i.196 = (unsigned int) i;
  D.6495 = i.196 * 4;
  D.6496 = p + D.6495;
  q = *D.6496;
  q.197 = (char *) q;
  D.6498 = q.197 >= least_ha;
  q.197 = (char *) q;
  D.6499 = q.197 < greatest_ha;
  D.6500 = D.6498 & D.6499;
  if (D.6500 != 0) goto <D.6501>; else goto <D.6502>;
  <D.6501>:
  i.196 = (unsigned int) i;
  D.6495 = i.196 * 4;
  D.6503 = p + D.6495;
  q.198 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.198, mark_stack_top, mark_stack_limit, D.6503);
  <D.6502>:
  <D.6493>:
  i = i + 1;
  mark_word = mark_word >> 1;
  <D.5545>:
  if (mark_word != 0) goto <D.5544>; else goto <D.5546>;
  <D.5546>:
  p = p + 128;
  <D.5548>:
  if (p < plim) goto <D.5547>; else goto <D.5549>;
  <D.5549>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked2 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.199;
  long unsigned int D.6506;
  word * mark_word_addr.200;
  long unsigned int D.6508;
  unsigned int i.201;
  unsigned int D.6512;
  word * D.6513;
  char * q.202;
  _Bool D.6515;
  _Bool D.6516;
  _Bool D.6517;
  void * * D.6520;
  void * q.203;
  sizetype i.204;
  sizetype D.6523;
  sizetype D.6524;
  word * D.6525;
  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.199 = (long unsigned int) h;
  D.6506 = h.199 + 4096;
  plim = (word *) D.6506;
  goto <D.5568>;
  <D.5567>:
  mark_word_addr.200 = mark_word_addr;
  mark_word_addr = mark_word_addr.200 + 4;
  mark_word = *mark_word_addr.200;
  i = 0;
  goto <D.5565>;
  <D.5564>:
  D.6508 = mark_word & 1;
  if (D.6508 != 0) goto <D.6509>; else goto <D.6510>;
  <D.6509>:
  i.201 = (unsigned int) i;
  D.6512 = i.201 * 4;
  D.6513 = p + D.6512;
  q = *D.6513;
  q.202 = (char *) q;
  D.6515 = q.202 >= least_ha;
  q.202 = (char *) q;
  D.6516 = q.202 < greatest_ha;
  D.6517 = D.6515 & D.6516;
  if (D.6517 != 0) goto <D.6518>; else goto <D.6519>;
  <D.6518>:
  i.201 = (unsigned int) i;
  D.6512 = i.201 * 4;
  D.6520 = p + D.6512;
  q.203 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.203, mark_stack_top, mark_stack_limit, D.6520);
  <D.6519>:
  i.204 = (sizetype) i;
  D.6523 = i.204 + 1;
  D.6524 = D.6523 * 4;
  D.6525 = p + D.6524;
  q = *D.6525;
  q.202 = (char *) q;
  D.6515 = q.202 >= least_ha;
  q.202 = (char *) q;
  D.6516 = q.202 < greatest_ha;
  D.6517 = D.6515 & D.6516;
  if (D.6517 != 0) goto <D.6526>; else goto <D.6527>;
  <D.6526>:
  i.201 = (unsigned int) i;
  D.6512 = i.201 * 4;
  D.6520 = p + D.6512;
  q.203 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.203, mark_stack_top, mark_stack_limit, D.6520);
  <D.6527>:
  <D.6510>:
  i = i + 2;
  mark_word = mark_word >> 2;
  <D.5565>:
  if (mark_word != 0) goto <D.5564>; else goto <D.5566>;
  <D.5566>:
  p = p + 128;
  <D.5568>:
  if (p < plim) goto <D.5567>; else goto <D.5569>;
  <D.5569>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked4 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.205;
  long unsigned int D.6529;
  word * mark_word_addr.206;
  long unsigned int D.6531;
  unsigned int i.207;
  unsigned int D.6535;
  word * D.6536;
  char * q.208;
  _Bool D.6538;
  _Bool D.6539;
  _Bool D.6540;
  void * * D.6543;
  void * q.209;
  sizetype i.210;
  sizetype D.6546;
  sizetype D.6547;
  word * D.6548;
  sizetype D.6551;
  sizetype D.6552;
  word * D.6553;
  sizetype D.6556;
  sizetype D.6557;
  word * D.6558;
  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.205 = (long unsigned int) h;
  D.6529 = h.205 + 4096;
  plim = (word *) D.6529;
  goto <D.5588>;
  <D.5587>:
  mark_word_addr.206 = mark_word_addr;
  mark_word_addr = mark_word_addr.206 + 4;
  mark_word = *mark_word_addr.206;
  i = 0;
  goto <D.5585>;
  <D.5584>:
  D.6531 = mark_word & 1;
  if (D.6531 != 0) goto <D.6532>; else goto <D.6533>;
  <D.6532>:
  i.207 = (unsigned int) i;
  D.6535 = i.207 * 4;
  D.6536 = p + D.6535;
  q = *D.6536;
  q.208 = (char *) q;
  D.6538 = q.208 >= least_ha;
  q.208 = (char *) q;
  D.6539 = q.208 < greatest_ha;
  D.6540 = D.6538 & D.6539;
  if (D.6540 != 0) goto <D.6541>; else goto <D.6542>;
  <D.6541>:
  i.207 = (unsigned int) i;
  D.6535 = i.207 * 4;
  D.6543 = p + D.6535;
  q.209 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.209, mark_stack_top, mark_stack_limit, D.6543);
  <D.6542>:
  i.210 = (sizetype) i;
  D.6546 = i.210 + 1;
  D.6547 = D.6546 * 4;
  D.6548 = p + D.6547;
  q = *D.6548;
  q.208 = (char *) q;
  D.6538 = q.208 >= least_ha;
  q.208 = (char *) q;
  D.6539 = q.208 < greatest_ha;
  D.6540 = D.6538 & D.6539;
  if (D.6540 != 0) goto <D.6549>; else goto <D.6550>;
  <D.6549>:
  i.210 = (sizetype) i;
  D.6546 = i.210 + 1;
  D.6547 = D.6546 * 4;
  D.6548 = p + D.6547;
  q.209 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.209, mark_stack_top, mark_stack_limit, D.6548);
  <D.6550>:
  i.210 = (sizetype) i;
  D.6551 = i.210 + 2;
  D.6552 = D.6551 * 4;
  D.6553 = p + D.6552;
  q = *D.6553;
  q.208 = (char *) q;
  D.6538 = q.208 >= least_ha;
  q.208 = (char *) q;
  D.6539 = q.208 < greatest_ha;
  D.6540 = D.6538 & D.6539;
  if (D.6540 != 0) goto <D.6554>; else goto <D.6555>;
  <D.6554>:
  i.210 = (sizetype) i;
  D.6551 = i.210 + 2;
  D.6552 = D.6551 * 4;
  D.6553 = p + D.6552;
  q.209 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.209, mark_stack_top, mark_stack_limit, D.6553);
  <D.6555>:
  i.210 = (sizetype) i;
  D.6556 = i.210 + 3;
  D.6557 = D.6556 * 4;
  D.6558 = p + D.6557;
  q = *D.6558;
  q.208 = (char *) q;
  D.6538 = q.208 >= least_ha;
  q.208 = (char *) q;
  D.6539 = q.208 < greatest_ha;
  D.6540 = D.6538 & D.6539;
  if (D.6540 != 0) goto <D.6559>; else goto <D.6560>;
  <D.6559>:
  i.210 = (sizetype) i;
  D.6556 = i.210 + 3;
  D.6557 = D.6556 * 4;
  D.6558 = p + D.6557;
  q.209 = (void *) q;
  mark_stack_top = GC_mark_and_push (q.209, mark_stack_top, mark_stack_limit, D.6558);
  <D.6560>:
  <D.6533>:
  i = i + 4;
  mark_word = mark_word >> 4;
  <D.5585>:
  if (mark_word != 0) goto <D.5584>; else goto <D.5586>;
  <D.5586>:
  p = p + 128;
  <D.5588>:
  if (p < plim) goto <D.5587>; else goto <D.5589>;
  <D.5589>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.6561;
  long unsigned int D.6562;
  int D.6565;
  long unsigned int GC_n_rescuing_pages.211;
  long unsigned int GC_n_rescuing_pages.212;
  long unsigned int sz.213;
  sizetype sz.214;
  sizetype D.6575;
  sizetype D.6576;
  int D.6577;
  long unsigned int D.6578;
  int D.6579;
  long unsigned int D.6580;
  long unsigned int D.6581;
  unsigned int sz.215;
  unsigned int D.6590;
  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.6561 = hhdr->hb_sz;
  sz = (int) D.6561;
  D.6562 = hhdr->hb_descr;
  descr = (int) D.6562;
  mark_stack_limit = GC_mark_stack_limit;
  if (descr == 0) goto <D.6563>; else goto <D.6564>;
  <D.6563>:
  return;
  <D.6564>:
  D.6565 = GC_block_empty (hhdr);
  if (D.6565 != 0) goto <D.6566>; else goto <D.6567>;
  <D.6566>:
  return;
  <D.6567>:
  GC_n_rescuing_pages.211 = GC_n_rescuing_pages;
  GC_n_rescuing_pages.212 = GC_n_rescuing_pages.211 + 1;
  GC_n_rescuing_pages = GC_n_rescuing_pages.212;
  GC_objects_are_marked = 1;
  sz.213 = (long unsigned int) sz;
  if (sz.213 > 512) goto <D.6571>; else goto <D.6572>;
  <D.6571>:
  lim = h;
  goto <D.6573>;
  <D.6572>:
  sz.214 = (sizetype) sz;
  D.6575 = sz.214 * 4294967292;
  D.6576 = D.6575 + 4096;
  lim = h + D.6576;
  <D.6573>:
  switch (sz) <default: <D.5605>, case 1: <D.5601>, case 2: <D.5603>, case 4: <D.5604>>
  <D.5601>:
  GC_push_marked1 (h, hhdr);
  goto <D.5602>;
  <D.5603>:
  GC_push_marked2 (h, hhdr);
  goto <D.5602>;
  <D.5604>:
  GC_push_marked4 (h, hhdr);
  goto <D.5602>;
  <D.5605>:
  GC_mark_stack_top_reg = GC_mark_stack_top;
  p = h;
  word_no = 0;
  goto <D.5608>;
  <D.5607>:
  D.6577 = word_no >> 5;
  D.6578 = hhdr->hb_marks[D.6577];
  D.6579 = word_no & 31;
  D.6580 = D.6578 >> D.6579;
  D.6581 = D.6580 & 1;
  if (D.6581 != 0) goto <D.6582>; else goto <D.6583>;
  <D.6582>:
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.6584>; else goto <D.6585>;
    <D.6584>:
    goto <D.6586>;
    <D.6585>:
    GC_mark_stack_top_reg = GC_mark_stack_top_reg + 8;
    if (GC_mark_stack_top_reg >= mark_stack_limit) goto <D.6587>; else goto <D.6588>;
    <D.6587>:
    GC_mark_stack_top_reg = GC_signal_mark_stack_overflow (GC_mark_stack_top_reg);
    <D.6588>:
    GC_mark_stack_top_reg->mse_start = p;
    GC_mark_stack_top_reg->mse_descr = _descr;
    <D.6586>:
  }
  <D.6583>:
  sz.215 = (unsigned int) sz;
  D.6590 = sz.215 * 4;
  p = p + D.6590;
  word_no = word_no + sz;
  <D.5608>:
  if (p <= lim) goto <D.5607>; else goto <D.5609>;
  <D.5609>:
  GC_mark_stack_top = GC_mark_stack_top_reg;
  <D.5602>:
}


GC_block_was_dirty (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.6592;
  long unsigned int sz.216;
  GC_bool D.6596;
  int D.6597;
  sizetype sz.217;
  char * D.6601;
  register int sz;

  D.6592 = hhdr->hb_sz;
  sz = (int) D.6592;
  sz.216 = (long unsigned int) sz;
  if (sz.216 <= 512) goto <D.6594>; else goto <D.6595>;
  <D.6594>:
  D.6596 = GC_page_was_dirty (h);
  return D.6596;
  <D.6595>:
  {
    register char * p;

    p = h;
    sz = sz << 2;
    goto <D.5617>;
    <D.5616>:
    D.6597 = GC_page_was_dirty (p);
    if (D.6597 != 0) goto <D.6598>; else goto <D.6599>;
    <D.6598>:
    D.6596 = 1;
    return D.6596;
    <D.6599>:
    p = p + 4096;
    <D.5617>:
    sz.217 = (sizetype) sz;
    D.6601 = h + sz.217;
    if (D.6601 > p) goto <D.5616>; else goto <D.5618>;
    <D.5618>:
    D.6596 = 0;
    return D.6596;
  }
}


GC_push_next_marked (struct hblk * h)
{
  struct hblk * D.6605;
  long unsigned int h.218;
  long unsigned int D.6607;
  struct bottom_index * D.6608;
  long unsigned int D.6609;
  long unsigned int D.6610;
  long unsigned int D.6611;
  long unsigned int D.6612;
  long unsigned int D.6613;
  long unsigned int D.6614;
  long unsigned int D.6615;
  register struct hdr * hhdr;

  h = GC_next_used_block (h);
  if (h == 0B) goto <D.6603>; else goto <D.6604>;
  <D.6603>:
  D.6605 = 0B;
  return D.6605;
  <D.6604>:
  h.218 = (long unsigned int) h;
  D.6607 = h.218 >> 22;
  D.6608 = GC_arrays._top_index[D.6607];
  h.218 = (long unsigned int) h;
  D.6609 = h.218 >> 12;
  D.6610 = D.6609 & 1023;
  hhdr = D.6608->index[D.6610];
  GC_push_marked (h, hhdr);
  D.6611 = hhdr->hb_sz;
  D.6612 = D.6611 << 2;
  D.6613 = D.6612 + 4095;
  D.6614 = D.6613 >> 12;
  D.6615 = D.6614 * 4096;
  D.6605 = h + D.6615;
  return D.6605;
}


GC_push_next_marked_dirty (struct hblk * h)
{
  int GC_dirty_maintained.219;
  struct hblk * D.6622;
  long unsigned int h.220;
  long unsigned int D.6624;
  struct bottom_index * D.6625;
  long unsigned int D.6626;
  long unsigned int D.6627;
  int D.6628;
  long unsigned int D.6630;
  long unsigned int D.6631;
  long unsigned int D.6632;
  long unsigned int D.6633;
  long unsigned int D.6634;
  register struct hdr * hhdr;

  GC_dirty_maintained.219 = GC_dirty_maintained;
  if (GC_dirty_maintained.219 == 0) goto <D.6618>; else goto <D.6619>;
  <D.6618>:
  GC_abort ("dirty bits not set up");
  <D.6619>:
  <D.5628>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.6620>; else goto <D.6621>;
  <D.6620>:
  D.6622 = 0B;
  return D.6622;
  <D.6621>:
  h.220 = (long unsigned int) h;
  D.6624 = h.220 >> 22;
  D.6625 = GC_arrays._top_index[D.6624];
  h.220 = (long unsigned int) h;
  D.6626 = h.220 >> 12;
  D.6627 = D.6626 & 1023;
  hhdr = D.6625->index[D.6627];
  D.6628 = GC_block_was_dirty (h, hhdr);
  if (D.6628 != 0) goto <D.5627>; else goto <D.6629>;
  <D.6629>:
  D.6630 = hhdr->hb_sz;
  D.6631 = D.6630 << 2;
  D.6632 = D.6631 + 4095;
  D.6633 = D.6632 >> 12;
  D.6634 = D.6633 * 4096;
  h = h + D.6634;
  goto <D.5628>;
  <D.5627>:
  GC_push_marked (h, hhdr);
  D.6630 = hhdr->hb_sz;
  D.6631 = D.6630 << 2;
  D.6632 = D.6631 + 4095;
  D.6633 = D.6632 >> 12;
  D.6634 = D.6633 * 4096;
  D.6622 = h + D.6634;
  return D.6622;
}


GC_push_next_marked_uncollectable (struct hblk * h)
{
  long unsigned int h.221;
  long unsigned int D.6637;
  struct bottom_index * D.6638;
  long unsigned int D.6639;
  long unsigned int D.6640;
  struct hblk * D.6643;
  unsigned char D.6644;
  long unsigned int D.6646;
  long unsigned int D.6647;
  long unsigned int D.6648;
  long unsigned int D.6649;
  long unsigned int D.6650;
  register struct hdr * hhdr;

  h.221 = (long unsigned int) h;
  D.6637 = h.221 >> 22;
  D.6638 = GC_arrays._top_index[D.6637];
  h.221 = (long unsigned int) h;
  D.6639 = h.221 >> 12;
  D.6640 = D.6639 & 1023;
  hhdr = D.6638->index[D.6640];
  <D.5634>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.6641>; else goto <D.6642>;
  <D.6641>:
  D.6643 = 0B;
  return D.6643;
  <D.6642>:
  h.221 = (long unsigned int) h;
  D.6637 = h.221 >> 22;
  D.6638 = GC_arrays._top_index[D.6637];
  h.221 = (long unsigned int) h;
  D.6639 = h.221 >> 12;
  D.6640 = D.6639 & 1023;
  hhdr = D.6638->index[D.6640];
  D.6644 = hhdr->hb_obj_kind;
  if (D.6644 == 2) goto <D.5633>; else goto <D.6645>;
  <D.6645>:
  D.6646 = hhdr->hb_sz;
  D.6647 = D.6646 << 2;
  D.6648 = D.6647 + 4095;
  D.6649 = D.6648 >> 12;
  D.6650 = D.6649 * 4096;
  h = h + D.6650;
  goto <D.5634>;
  <D.5633>:
  GC_push_marked (h, hhdr);
  D.6646 = hhdr->hb_sz;
  D.6647 = D.6646 << 2;
  D.6648 = D.6647 + 4095;
  D.6649 = D.6648 >> 12;
  D.6650 = D.6649 * 4096;
  D.6643 = h + D.6650;
  return D.6643;
}