GC_noop (void * p)
{

}


GC_noop1 (word x)
{
  static volatile word sink;

  sink = x;
}


GC_collection_in_progress ()
{
  GC_bool D.6419;
  int GC_mark_state.0;
  _Bool D.6421;

  GC_mark_state.0 = GC_mark_state;
  D.6421 = GC_mark_state.0 != 0;
  D.6419 = (GC_bool) D.6421;
  return D.6419;
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.6426;
  int D.6431;
  void * D.6433;
  long unsigned int D.6434;

  D.6426 = __builtin_constant_p (__len);
  if (D.6426 != 0) goto <D.6427>; else goto <D.6428>;
  <D.6427>:
  if (__len == 0) goto <D.6429>; else goto <D.6430>;
  <D.6429>:
  D.6431 = __builtin_constant_p (__ch);
  if (D.6431 == 0) goto <D.6424>; else goto <D.6432>;
  <D.6432>:
  if (__ch != 0) goto <D.6424>; else goto <D.6425>;
  <D.6424>:
  __warn_memset_zero_len ();
  D.6433 = __dest;
  return D.6433;
  <D.6425>:
  <D.6430>:
  <D.6428>:
  D.6434 = __builtin_object_size (__dest, 0);
  D.6433 = __builtin___memset_chk (__dest, __ch, __len, D.6434);
  return D.6433;
}


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

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


GC_set_mark_bit (char * p)
{
  long unsigned int p.1;
  long unsigned int D.6437;
  long int p.2;
  long int h.3;
  long int D.6440;
  long int D.6441;
  int D.6442;
  sizetype D.6443;
  long unsigned int D.6444;
  int D.6445;
  long unsigned int D.6446;
  long unsigned int D.6447;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.1 = (long unsigned int) p;
  D.6437 = p.1 & 18446744073709547520;
  h = (struct hblk *) D.6437;
  hhdr = GC_find_header (h);
  p.2 = (long int) p;
  h.3 = (long int) h;
  D.6440 = p.2 - h.3;
  D.6441 = D.6440 /[ex] 8;
  word_no = (int) D.6441;
  D.6442 = word_no >> 6;
  D.6443 = (sizetype) D.6442;
  D.6442 = word_no >> 6;
  D.6443 = (sizetype) D.6442;
  D.6444 = hhdr->hb_marks[D.6443];
  D.6445 = word_no & 63;
  D.6446 = 1 << D.6445;
  D.6447 = D.6444 | D.6446;
  hhdr->hb_marks[D.6443] = D.6447;
}


GC_clear_mark_bit (char * p)
{
  long unsigned int p.4;
  long unsigned int D.6449;
  long int p.5;
  long int h.6;
  long int D.6452;
  long int D.6453;
  int D.6454;
  long unsigned int D.6455;
  int D.6456;
  long unsigned int D.6457;
  long unsigned int D.6458;
  long unsigned int D.6459;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.4 = (long unsigned int) p;
  D.6449 = p.4 & 18446744073709547520;
  h = (struct hblk *) D.6449;
  hhdr = GC_find_header (h);
  p.5 = (long int) p;
  h.6 = (long int) h;
  D.6452 = p.5 - h.6;
  D.6453 = D.6452 /[ex] 8;
  word_no = (int) D.6453;
  D.6454 = word_no >> 6;
  D.6454 = word_no >> 6;
  D.6455 = hhdr->hb_marks[D.6454];
  D.6456 = word_no & 63;
  D.6457 = 1 << D.6456;
  D.6458 = ~D.6457;
  D.6459 = D.6455 & D.6458;
  hhdr->hb_marks[D.6454] = D.6459;
}


GC_is_marked (char * p)
{
  long unsigned int p.7;
  long unsigned int D.6461;
  long int p.8;
  long int h.9;
  long int D.6464;
  long int D.6465;
  GC_bool D.6466;
  int D.6467;
  long unsigned int D.6468;
  int D.6469;
  long unsigned int D.6470;
  int D.6471;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.7 = (long unsigned int) p;
  D.6461 = p.7 & 18446744073709547520;
  h = (struct hblk *) D.6461;
  hhdr = GC_find_header (h);
  p.8 = (long int) p;
  h.9 = (long int) h;
  D.6464 = p.8 - h.9;
  D.6465 = D.6464 /[ex] 8;
  word_no = (int) D.6465;
  D.6467 = word_no >> 6;
  D.6468 = hhdr->hb_marks[D.6467];
  D.6469 = word_no & 63;
  D.6470 = D.6468 >> D.6469;
  D.6471 = (int) D.6470;
  D.6466 = D.6471 & 1;
  return D.6466;
}


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


clear_marks_for_block (struct hblk * h, word dummy)
{
  unsigned char D.6473;
  int D.6474;
  int D.6475;
  register struct hdr * hhdr;

  hhdr = GC_find_header (h);
  D.6473 = hhdr->hb_obj_kind;
  D.6474 = (int) D.6473;
  D.6475 = D.6474 & -2;
  if (D.6475 == 2) goto <D.6476>; else goto <D.6477>;
  <D.6476>:
  return;
  <D.6477>:
  GC_clear_hdr_marks (hhdr);
}


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

  GC_dirty_maintained.10 = GC_dirty_maintained;
  if (GC_dirty_maintained.10 != 0) goto <D.6480>; else goto <D.6481>;
  <D.6480>:
  GC_read_dirty ();
  <D.6481>:
  GC_n_rescuing_pages = 0;
  GC_mark_state.11 = GC_mark_state;
  if (GC_mark_state.11 == 0) goto <D.6483>; else goto <D.6484>;
  <D.6483>:
  GC_mark_state = 1;
  goto <D.6485>;
  <D.6484>:
  GC_mark_state.11 = GC_mark_state;
  if (GC_mark_state.11 != 5) goto <D.6486>; else goto <D.6487>;
  <D.6486>:
  GC_abort ("unexpected state");
  <D.6487>:
  <D.6485>:
  scan_ptr = 0B;
}


GC_mark_some (char * cold_gc_frame)
{
  int GC_mark_state.12;
  GC_bool D.6489;
  struct mse * GC_mark_stack_limit.13;
  struct mse * D.6491;
  struct mse * GC_mark_stack_top.14;
  struct mse * GC_mark_stack.15;
  long unsigned int GC_mark_stack_size.16;
  long unsigned int D.6497;
  struct mse * D.6498;
  struct mse * GC_mark_stack_top.17;
  struct hblk * scan_ptr.18;
  struct hblk * scan_ptr.19;
  int GC_print_stats.20;
  long unsigned int GC_n_rescuing_pages.21;
  long int GC_n_rescuing_pages.22;
  long unsigned int D.6511;
  long unsigned int D.6512;
  struct mse * D.6513;
  struct mse * GC_mark_stack_top.23;
  struct hblk * scan_ptr.24;
  struct mse * GC_mark_stack_top.25;
  int GC_mark_stack_too_small.26;
  long unsigned int D.6528;
  int GC_objects_are_marked.27;
  struct mse * GC_mark_stack_top.28;
  struct hblk * scan_ptr.29;

  GC_mark_state.12 = GC_mark_state;
  switch (GC_mark_state.12) <default: <D.6119>, case 0: <D.6113>, case 1: <D.6114>, case 2: <D.6115>, case 3: <D.6116>, case 4: <D.6118>, case 5: <D.6117>>
  <D.6113>:
  D.6489 = 0;
  return D.6489;
  <D.6114>:
  GC_mark_stack_limit.13 = GC_mark_stack_limit;
  D.6491 = GC_mark_stack_limit.13 + 18446744073709518848;
  GC_mark_stack_top.14 = GC_mark_stack_top;
  if (D.6491 <= GC_mark_stack_top.14) goto <D.6493>; else goto <D.6494>;
  <D.6493>:
  GC_mark_stack_too_small = 1;
  GC_mark_stack_top.14 = GC_mark_stack_top;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6497 = GC_mark_stack_size.16 * 16;
  D.6498 = GC_mark_stack.15 + D.6497;
  GC_mark_stack_top.17 = GC_mark_from (GC_mark_stack_top.14, GC_mark_stack.15, D.6498);
  GC_mark_stack_top = GC_mark_stack_top.17;
  D.6489 = 0;
  return D.6489;
  <D.6494>:
  scan_ptr.18 = scan_ptr;
  scan_ptr.19 = GC_push_next_marked_dirty (scan_ptr.18);
  scan_ptr = scan_ptr.19;
  scan_ptr.18 = scan_ptr;
  if (scan_ptr.18 == 0B) goto <D.6502>; else goto <D.6503>;
  <D.6502>:
  GC_print_stats.20 = GC_print_stats;
  if (GC_print_stats.20 != 0) goto <D.6505>; else goto <D.6506>;
  <D.6505>:
  GC_n_rescuing_pages.21 = GC_n_rescuing_pages;
  GC_n_rescuing_pages.22 = (long int) GC_n_rescuing_pages.21;
  GC_printf ("Marked from %lu dirty pages\n", GC_n_rescuing_pages.22, 0, 0, 0, 0, 0);
  <D.6506>:
  GC_push_roots (0, cold_gc_frame);
  GC_objects_are_marked = 1;
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 != 5) goto <D.6509>; else goto <D.6510>;
  <D.6509>:
  GC_mark_state = 3;
  <D.6510>:
  <D.6503>:
  D.6489 = 0;
  return D.6489;
  <D.6115>:
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6511 = GC_mark_stack_size.16 / 4;
  D.6512 = D.6511 * 16;
  D.6513 = GC_mark_stack.15 + D.6512;
  GC_mark_stack_top.14 = GC_mark_stack_top;
  if (D.6513 <= GC_mark_stack_top.14) goto <D.6514>; else goto <D.6515>;
  <D.6514>:
  GC_mark_stack_top.14 = GC_mark_stack_top;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6497 = GC_mark_stack_size.16 * 16;
  D.6498 = GC_mark_stack.15 + D.6497;
  GC_mark_stack_top.23 = GC_mark_from (GC_mark_stack_top.14, GC_mark_stack.15, D.6498);
  GC_mark_stack_top = GC_mark_stack_top.23;
  D.6489 = 0;
  return D.6489;
  <D.6515>:
  scan_ptr.18 = scan_ptr;
  scan_ptr.24 = GC_push_next_marked_uncollectable (scan_ptr.18);
  scan_ptr = scan_ptr.24;
  scan_ptr.18 = scan_ptr;
  if (scan_ptr.18 == 0B) goto <D.6518>; else goto <D.6519>;
  <D.6518>:
  GC_push_roots (1, cold_gc_frame);
  GC_objects_are_marked = 1;
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 != 5) goto <D.6520>; else goto <D.6521>;
  <D.6520>:
  GC_mark_state = 3;
  <D.6521>:
  <D.6519>:
  D.6489 = 0;
  return D.6489;
  <D.6116>:
  GC_mark_stack_top.14 = GC_mark_stack_top;
  GC_mark_stack.15 = GC_mark_stack;
  if (GC_mark_stack_top.14 >= GC_mark_stack.15) goto <D.6522>; else goto <D.6523>;
  <D.6522>:
  GC_mark_stack_top.14 = GC_mark_stack_top;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6497 = GC_mark_stack_size.16 * 16;
  D.6498 = GC_mark_stack.15 + D.6497;
  GC_mark_stack_top.25 = GC_mark_from (GC_mark_stack_top.14, GC_mark_stack.15, D.6498);
  GC_mark_stack_top = GC_mark_stack_top.25;
  D.6489 = 0;
  return D.6489;
  <D.6523>:
  GC_mark_state = 0;
  GC_mark_stack_too_small.26 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.26 != 0) goto <D.6526>; else goto <D.6527>;
  <D.6526>:
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6528 = GC_mark_stack_size.16 * 2;
  alloc_mark_stack (D.6528);
  <D.6527>:
  D.6489 = 1;
  return D.6489;
  <D.6117>:
  <D.6118>:
  GC_objects_are_marked.27 = GC_objects_are_marked;
  if (GC_objects_are_marked.27 == 0) goto <D.6530>; else goto <D.6531>;
  <D.6530>:
  GC_mark_state = 2;
  D.6489 = 0;
  return D.6489;
  <D.6531>:
  GC_mark_stack_top.14 = GC_mark_stack_top;
  GC_mark_stack.15 = GC_mark_stack;
  if (GC_mark_stack_top.14 >= GC_mark_stack.15) goto <D.6532>; else goto <D.6533>;
  <D.6532>:
  GC_mark_stack_top.14 = GC_mark_stack_top;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack.15 = GC_mark_stack;
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6497 = GC_mark_stack_size.16 * 16;
  D.6498 = GC_mark_stack.15 + D.6497;
  GC_mark_stack_top.28 = GC_mark_from (GC_mark_stack_top.14, GC_mark_stack.15, D.6498);
  GC_mark_stack_top = GC_mark_stack_top.28;
  D.6489 = 0;
  return D.6489;
  <D.6533>:
  scan_ptr.18 = scan_ptr;
  if (scan_ptr.18 == 0B) goto <D.6535>; else goto <D.6536>;
  <D.6535>:
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 == 5) goto <D.6537>; else goto <D.6538>;
  <D.6537>:
  GC_mark_stack_too_small.26 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.26 != 0) goto <D.6539>; else goto <D.6540>;
  <D.6539>:
  GC_mark_stack_size.16 = GC_mark_stack_size;
  D.6528 = GC_mark_stack_size.16 * 2;
  alloc_mark_stack (D.6528);
  <D.6540>:
  GC_mark_state = 4;
  <D.6538>:
  <D.6536>:
  scan_ptr.18 = scan_ptr;
  scan_ptr.29 = GC_push_next_marked (scan_ptr.18);
  scan_ptr = scan_ptr.29;
  scan_ptr.18 = scan_ptr;
  if (scan_ptr.18 == 0B) goto <D.6542>; else goto <D.6543>;
  <D.6542>:
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 == 4) goto <D.6544>; else goto <D.6545>;
  <D.6544>:
  GC_push_roots (1, cold_gc_frame);
  GC_objects_are_marked = 1;
  GC_mark_state.12 = GC_mark_state;
  if (GC_mark_state.12 != 5) goto <D.6546>; else goto <D.6547>;
  <D.6546>:
  GC_mark_state = 3;
  <D.6547>:
  <D.6545>:
  <D.6543>:
  D.6489 = 0;
  return D.6489;
  <D.6119>:
  GC_abort ("GC_mark_some: bad state");
  D.6489 = 0;
  return D.6489;
}


alloc_mark_stack (word n)
{
  long unsigned int D.6549;
  long unsigned int GC_mark_stack_size.30;
  long unsigned int GC_page_size.31;
  long unsigned int D.6556;
  struct mse * GC_mark_stack.32;
  long unsigned int GC_mark_stack.33;
  long unsigned int D.6559;
  long unsigned int size.34;
  long unsigned int D.6563;
  long unsigned int D.6564;
  long unsigned int D.6565;
  long unsigned int D.6568;
  struct hblk * D.6569;
  long unsigned int D.6570;
  struct mse * GC_mark_stack_limit.35;
  int GC_print_stats.36;
  long int GC_mark_stack_size.37;
  long int n.38;
  struct mse * GC_mark_stack_top.39;
  struct mse * new_stack;

  D.6549 = n * 16;
  new_stack = GC_scratch_alloc (D.6549);
  GC_mark_stack_too_small = 0;
  GC_mark_stack_size.30 = GC_mark_stack_size;
  if (GC_mark_stack_size.30 != 0) goto <D.6551>; else goto <D.6552>;
  <D.6551>:
  if (new_stack != 0B) goto <D.6553>; else goto <D.6554>;
  <D.6553>:
  {
    word displ;
    signed_word size;

    GC_page_size.31 = GC_page_size;
    D.6556 = GC_page_size.31 + 18446744073709551615;
    GC_mark_stack.32 = GC_mark_stack;
    GC_mark_stack.33 = (long unsigned int) GC_mark_stack.32;
    displ = D.6556 & GC_mark_stack.33;
    GC_mark_stack_size.30 = GC_mark_stack_size;
    D.6559 = GC_mark_stack_size.30 * 16;
    size = (signed_word) D.6559;
    if (displ != 0) goto <D.6560>; else goto <D.6561>;
    <D.6560>:
    GC_page_size.31 = GC_page_size;
    displ = GC_page_size.31 - displ;
    <D.6561>:
    size.34 = (long unsigned int) size;
    D.6563 = size.34 - displ;
    GC_page_size.31 = GC_page_size;
    D.6564 = -GC_page_size.31;
    D.6565 = D.6563 & D.6564;
    size = (signed_word) D.6565;
    if (size > 0) goto <D.6566>; else goto <D.6567>;
    <D.6566>:
    GC_mark_stack.32 = GC_mark_stack;
    GC_mark_stack.33 = (long unsigned int) GC_mark_stack.32;
    D.6568 = GC_mark_stack.33 + displ;
    D.6569 = (struct hblk *) D.6568;
    size.34 = (long unsigned int) size;
    GC_add_to_heap (D.6569, size.34);
    <D.6567>:
    GC_mark_stack = new_stack;
    GC_mark_stack_size = n;
    D.6570 = n * 16;
    GC_mark_stack_limit.35 = new_stack + D.6570;
    GC_mark_stack_limit = GC_mark_stack_limit.35;
    GC_print_stats.36 = GC_print_stats;
    if (GC_print_stats.36 != 0) goto <D.6573>; else goto <D.6574>;
    <D.6573>:
    GC_mark_stack_size.30 = GC_mark_stack_size;
    GC_mark_stack_size.37 = (long int) GC_mark_stack_size.30;
    GC_printf ("Grew mark stack to %lu frames\n", GC_mark_stack_size.37, 0, 0, 0, 0, 0);
    <D.6574>:
  }
  goto <D.6576>;
  <D.6554>:
  GC_print_stats.36 = GC_print_stats;
  if (GC_print_stats.36 != 0) goto <D.6577>; else goto <D.6578>;
  <D.6577>:
  n.38 = (long int) n;
  GC_printf ("Failed to grow mark stack to %lu frames\n", n.38, 0, 0, 0, 0, 0);
  <D.6578>:
  <D.6576>:
  goto <D.6580>;
  <D.6552>:
  if (new_stack == 0B) goto <D.6581>; else goto <D.6582>;
  <D.6581>:
  GC_err_puts ("No space for mark stack\n");
  exit (1);
  <D.6582>:
  GC_mark_stack = new_stack;
  GC_mark_stack_size = n;
  D.6570 = n * 16;
  GC_mark_stack_limit.35 = new_stack + D.6570;
  GC_mark_stack_limit = GC_mark_stack_limit.35;
  <D.6580>:
  GC_mark_stack.32 = GC_mark_stack;
  GC_mark_stack_top.39 = GC_mark_stack.32 + 18446744073709551600;
  GC_mark_stack_top = GC_mark_stack_top.39;
}


GC_mark_stack_empty ()
{
  GC_bool D.6584;
  struct mse * GC_mark_stack_top.40;
  struct mse * GC_mark_stack.41;
  _Bool D.6587;

  GC_mark_stack_top.40 = GC_mark_stack_top;
  GC_mark_stack.41 = GC_mark_stack;
  D.6587 = GC_mark_stack_top.40 < GC_mark_stack.41;
  D.6584 = (GC_bool) D.6587;
  return D.6584;
}


GC_find_start (char * current, struct hdr * hhdr, struct hdr * * new_hdr_p)
{
  int GC_all_interior_pointers.42;
  long unsigned int current.43;
  long unsigned int D.6595;
  long unsigned int hhdr.44;
  long unsigned int D.6597;
  sizetype D.6598;
  unsigned char D.6599;
  int D.6600;
  int D.6601;
  char * D.6604;
  long int orig.45;
  long int current.46;
  long int D.6607;
  long int D.6608;
  long unsigned int D.6609;
  long int D.6610;

  GC_all_interior_pointers.42 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.42 != 0) goto <D.6590>; else goto <D.6591>;
  <D.6590>:
  if (hhdr != 0B) goto <D.6592>; else goto <D.6593>;
  <D.6592>:
  {
    register char * orig;

    orig = current;
    current.43 = (long unsigned int) current;
    D.6595 = current.43 & 18446744073709547520;
    current = (char *) D.6595;
    <D.6128>:
    hhdr.44 = (long unsigned int) hhdr;
    D.6597 = hhdr.44 * 4096;
    D.6598 = -D.6597;
    current = current + D.6598;
    hhdr = GC_find_header (current);
    hhdr.44 = (long unsigned int) hhdr;
    if (hhdr.44 <= 4095) goto <D.6128>; else goto <D.6129>;
    <D.6129>:
    D.6599 = hhdr->hb_flags;
    D.6600 = (int) D.6599;
    D.6601 = D.6600 & 1;
    if (D.6601 != 0) goto <D.6602>; else goto <D.6603>;
    <D.6602>:
    D.6604 = orig;
    return D.6604;
    <D.6603>:
    orig.45 = (long int) orig;
    current.46 = (long int) current;
    D.6607 = orig.45 - current.46;
    D.6608 = D.6607 /[ex] 8;
    D.6609 = hhdr->hb_sz;
    D.6610 = (long int) D.6609;
    if (D.6608 >= D.6610) goto <D.6611>; else goto <D.6612>;
    <D.6611>:
    D.6604 = orig;
    return D.6604;
    <D.6612>:
    *new_hdr_p = hhdr;
    D.6604 = current;
    return D.6604;
  }
  <D.6593>:
  D.6604 = current;
  return D.6604;
  <D.6591>:
  D.6604 = current;
  return D.6604;
}


GC_invalidate_mark_state ()
{
  struct mse * GC_mark_stack.47;
  struct mse * GC_mark_stack_top.48;

  GC_mark_state = 5;
  GC_mark_stack.47 = GC_mark_stack;
  GC_mark_stack_top.48 = GC_mark_stack.47 + 18446744073709551600;
  GC_mark_stack_top = GC_mark_stack_top.48;
}


GC_signal_mark_stack_overflow (struct mse * msp)
{
  int GC_print_stats.49;
  long unsigned int GC_mark_stack_size.50;
  long int GC_mark_stack_size.51;
  struct mse * D.6621;

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


GC_mark_from (struct mse * mark_stack_top, struct mse * mark_stack, struct mse * mark_stack_limit)
{
  long unsigned int D.6623;
  long unsigned int D.6626;
  unsigned int credit.52;
  unsigned int D.6628;
  long int descr.53;
  char * current.54;
  long unsigned int my_current.55;
  long unsigned int D.6638;
  long unsigned int D.6639;
  long unsigned int D.6640;
  long unsigned int D.6641;
  long unsigned int D.6645;
  long unsigned int D.6646;
  struct bottom_index * D.6648;
  long unsigned int D.6649;
  long unsigned int my_hhdr.56;
  struct hdr * GC_invalid_header.57;
  long int my_current.58;
  int D.6656;
  map_entry_type * D.6657;
  sizetype D.6658;
  map_entry_type * D.6659;
  unsigned char D.6660;
  long unsigned int D.6665;
  long unsigned int D.6666;
  long unsigned int D.6667;
  long unsigned int D.6668;
  int GC_all_interior_pointers.59;
  int D.6680;
  sizetype D.6681;
  int D.6682;
  long unsigned int D.6683;
  long unsigned int D.6685;
  long unsigned int D.6691;
  long unsigned int D.6692;
  sizetype my_current.60;
  sizetype D.6694;
  sizetype D.6695;
  GC_word * D.6696;
  long unsigned int D.6697;
  long unsigned int D.6698;
  struct GC_ms_entry * (*<Tbb8>) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word) D.6699;
  long unsigned int D.6700;
  sizetype D.6703;
  word * D.6704;
  sizetype D.6708;
  char * D.6709;
  long int current_p.61;
  long int limit.62;
  long int D.6716;
  unsigned int D.6717;
  unsigned int D.6718;
  char * deferred.63;
  long unsigned int my_current.64;
  long unsigned int D.6733;
  long unsigned int D.6734;
  long unsigned int D.6735;
  long unsigned int D.6736;
  long unsigned int D.6740;
  long unsigned int D.6741;
  long unsigned int D.6743;
  long unsigned int my_hhdr.65;
  long int my_current.66;
  int D.6749;
  map_entry_type * D.6750;
  sizetype D.6751;
  map_entry_type * D.6752;
  unsigned char D.6753;
  long unsigned int D.6758;
  long unsigned int D.6759;
  long unsigned int D.6760;
  long unsigned int D.6761;
  int D.6772;
  sizetype D.6773;
  int D.6774;
  long unsigned int D.6775;
  long unsigned int D.6777;
  long unsigned int D.6783;
  long unsigned int D.6784;
  sizetype my_current.67;
  sizetype D.6786;
  sizetype D.6787;
  GC_word * D.6788;
  long unsigned int my_current.68;
  long unsigned int D.6790;
  long unsigned int D.6791;
  long unsigned int D.6792;
  long unsigned int D.6793;
  long unsigned int D.6797;
  long unsigned int D.6798;
  long unsigned int D.6800;
  long unsigned int my_hhdr.69;
  long int my_current.70;
  int D.6806;
  map_entry_type * D.6807;
  sizetype D.6808;
  map_entry_type * D.6809;
  unsigned char D.6810;
  long unsigned int D.6815;
  long unsigned int D.6816;
  long unsigned int D.6817;
  long unsigned int D.6818;
  int D.6829;
  sizetype D.6830;
  int D.6831;
  long unsigned int D.6832;
  long unsigned int D.6834;
  long unsigned int D.6840;
  long unsigned int D.6841;
  sizetype my_current.71;
  sizetype D.6843;
  sizetype D.6844;
  GC_word * D.6845;
  long int mark_stack_top.72;
  long int mark_stack.73;
  long int D.6848;
  long int D.6849;
  long int D.6850;
  struct mse * D.6851;
  int credit;
  register word * current_p;
  register word current;
  register word * limit;
  register word descr;
  register char * greatest_ha;
  register char * least_ha;
  struct hdr_cache_entry hdr_cache[8];
  void retry = <<< error >>>;
  void exit1 = <<< error >>>;
  void next_object = <<< error >>>;
  void exit2 = <<< error >>>;
  void exit4 = <<< error >>>;

  try
    {
      credit = 4096;
      greatest_ha = GC_greatest_plausible_heap_addr;
      least_ha = GC_least_plausible_heap_addr;
      GC_objects_are_marked = 1;
      memset (&hdr_cache, 0, 128);
      goto <D.6174>;
      <D.6221>:
      current_p = mark_stack_top->mse_start;
      descr = mark_stack_top->mse_descr;
      retry:
      D.6623 = descr & 18446744073709550595;
      if (D.6623 != 0) goto <D.6624>; else goto <D.6625>;
      <D.6624>:
      {
        word tag;

        tag = descr & 3;
        switch (tag) <default: <D.6712>, case 0: <D.6150>, case 1: <D.6152>, case 2: <D.6175>, case 3: <D.6176>>
        <D.6150>:
        limit = current_p + 1016;
        mark_stack_top->mse_start = limit;
        D.6626 = descr + 18446744073709550600;
        mark_stack_top->mse_descr = D.6626;
        limit = limit;
        goto <D.6151>;
        <D.6152>:
        mark_stack_top = mark_stack_top + 18446744073709551600;
        descr = descr & 18446744073709551612;
        credit.52 = (unsigned int) credit;
        D.6628 = credit.52 + 4294967040;
        credit = (int) D.6628;
        goto <D.6172>;
        <D.6171>:
        descr.53 = (long int) descr;
        if (descr.53 < 0) goto <D.6630>; else goto <D.6631>;
        <D.6630>:
        current = *current_p;
        current.54 = (char *) current;
        if (current.54 >= least_ha) goto <D.6633>; else goto <D.6634>;
        <D.6633>:
        current.54 = (char *) current;
        if (current.54 < greatest_ha) goto <D.6635>; else goto <D.6636>;
        <D.6635>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.55 = (long unsigned int) my_current;
            D.6638 = my_current.55 >> 12;
            D.6639 = D.6638 & 7;
            D.6640 = D.6639 * 16;
            hce = &hdr_cache + D.6640;
            D.6641 = hce->block_addr;
            my_current.55 = (long unsigned int) my_current;
            D.6638 = my_current.55 >> 12;
            if (D.6641 == D.6638) goto <D.6642>; else goto <D.6643>;
            <D.6642>:
            my_hhdr = hce->hce_hdr;
            goto <D.6644>;
            <D.6643>:
            {
              register struct hdr * * _ha;

              {
                register struct bottom_index * bi;

                {
                  register word hi;
                  register struct bottom_index * _bi;

                  my_current.55 = (long unsigned int) my_current;
                  hi = my_current.55 >> 22;
                  D.6645 = hi & 2047;
                  _bi = GC_arrays._top_index[D.6645];
                  goto <D.6161>;
                  <D.6160>:
                  _bi = _bi->hash_link;
                  <D.6161>:
                  D.6646 = _bi->key;
                  if (D.6646 != hi) goto <D.6647>; else goto <D.6162>;
                  <D.6647>:
                  D.6648 = GC_arrays._all_nils;
                  if (D.6648 != _bi) goto <D.6160>; else goto <D.6162>;
                  <D.6162>:
                  bi = _bi;
                }
                my_current.55 = (long unsigned int) my_current;
                D.6638 = my_current.55 >> 12;
                D.6649 = D.6638 & 1023;
                _ha = &bi->index[D.6649];
              }
              my_hhdr = *_ha;
            }
            my_hhdr.56 = (long unsigned int) my_hhdr;
            if (my_hhdr.56 <= 4095) goto <D.6651>; else goto <D.6652>;
            <D.6651>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.57 = GC_invalid_header;
                  new_hdr = GC_invalid_header.57;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6654>;
            <D.6652>:
            my_current.55 = (long unsigned int) my_current;
            D.6638 = my_current.55 >> 12;
            hce->block_addr = D.6638;
            hce->hce_hdr = my_hhdr;
            <D.6654>:
            <D.6644>:
          }
          {
            int displ;
            int map_entry;

            my_current.58 = (long int) my_current;
            D.6656 = (int) my_current.58;
            displ = D.6656 & 4095;
            D.6657 = my_hhdr->hb_map;
            D.6658 = (sizetype) displ;
            D.6659 = D.6657 + D.6658;
            D.6660 = *D.6659;
            map_entry = (int) D.6660;
            displ = displ >> 3;
            if (map_entry > 253) goto <D.6661>; else goto <D.6662>;
            <D.6661>:
            if (map_entry == 254) goto <D.6663>; else goto <D.6664>;
            <D.6663>:
            D.6665 = (long unsigned int) displ;
            D.6666 = my_hhdr->hb_sz;
            D.6667 = D.6665 % D.6666;
            map_entry = (int) D.6667;
            displ = displ - map_entry;
            D.6665 = (long unsigned int) displ;
            D.6666 = my_hhdr->hb_sz;
            D.6668 = D.6665 + D.6666;
            if (D.6668 > 512) goto <D.6669>; else goto <D.6670>;
            <D.6669>:
            GC_all_interior_pointers.59 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.59 != 0) goto <D.6672>; else goto <D.6673>;
            <D.6672>:
            my_current.55 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.55);
            goto <D.6674>;
            <D.6673>:
            my_current.55 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.55);
            <D.6674>:
            goto exit1;
            <D.6670>:
            goto <D.6675>;
            <D.6664>:
            GC_all_interior_pointers.59 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.59 != 0) goto <D.6676>; else goto <D.6677>;
            <D.6676>:
            my_current.55 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.55);
            goto <D.6678>;
            <D.6677>:
            my_current.55 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.55);
            <D.6678>:
            goto exit1;
            <D.6675>:
            goto <D.6679>;
            <D.6662>:
            displ = displ - map_entry;
            <D.6679>:
            {
              register word * mark_word_addr;

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

                old = *mark_word_addr;
                D.6682 = displ & 63;
                my_bits = 1 << D.6682;
                D.6683 = old & my_bits;
                if (D.6683 != 0) goto exit1; else goto <D.6684>;
                <D.6684>:
                D.6685 = old | my_bits;
                *mark_word_addr = D.6685;
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6686>; else goto <D.6687>;
              <D.6686>:
              goto <D.6688>;
              <D.6687>:
              mark_stack_top = mark_stack_top + 16;
              if (mark_stack_top >= mark_stack_limit) goto <D.6689>; else goto <D.6690>;
              <D.6689>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6690>:
              D.6691 = (long unsigned int) displ;
              D.6692 = D.6691 * 8;
              my_current.60 = (sizetype) my_current;
              D.6694 = my_current.60 & 18446744073709547520;
              D.6695 = D.6692 + D.6694;
              D.6696 = (GC_word *) D.6695;
              mark_stack_top->mse_start = D.6696;
              mark_stack_top->mse_descr = _descr;
              <D.6688>:
            }
          }
          exit1:
        }
        <D.6636>:
        <D.6634>:
        <D.6631>:
        descr = descr << 1;
        current_p = current_p + 8;
        <D.6172>:
        if (descr != 0) goto <D.6171>; else goto <D.6173>;
        <D.6173>:
        // predicted unlikely by continue predictor.
        goto <D.6174>;
        <D.6175>:
        mark_stack_top = mark_stack_top + 18446744073709551600;
        credit = credit + -100;
        D.6697 = descr >> 2;
        D.6698 = D.6697 & 63;
        D.6699 = GC_arrays._mark_procs[D.6698];
        D.6700 = descr >> 8;
        mark_stack_top = D.6699 (current_p, mark_stack_top, mark_stack_limit, D.6700);
        // predicted unlikely by continue predictor.
        goto <D.6174>;
        <D.6176>:
        descr.53 = (long int) descr;
        if (descr.53 >= 0) goto <D.6701>; else goto <D.6702>;
        <D.6701>:
        D.6703 = descr + 18446744073709551613;
        D.6704 = current_p + D.6703;
        descr = *D.6704;
        goto <D.6705>;
        <D.6702>:
        {
          char * type_descr;

          type_descr = MEM[(char * *)current_p];
          if (type_descr == 0B) goto <D.6706>; else goto <D.6707>;
          <D.6706>:
          mark_stack_top = mark_stack_top + 18446744073709551600;
          // predicted unlikely by continue predictor.
          goto <D.6174>;
          <D.6707>:
          D.6708 = 18446744073709551603 - descr;
          D.6709 = type_descr + D.6708;
          descr = MEM[(word *)D.6709];
        }
        <D.6705>:
        if (descr == 0) goto <D.6710>; else goto <D.6711>;
        <D.6710>:
        mark_stack_top = mark_stack_top + 18446744073709551600;
        // predicted unlikely by continue predictor.
        goto <D.6174>;
        <D.6711>:
        goto retry;
        <D.6712>:
        <D.6151>:
      }
      goto <D.6713>;
      <D.6625>:
      mark_stack_top = mark_stack_top + 18446744073709551600;
      limit = current_p + descr;
      <D.6713>:
      current_p.61 = (long int) current_p;
      limit.62 = (long int) limit;
      D.6716 = current_p.61 - limit.62;
      D.6717 = (unsigned int) D.6716;
      credit.52 = (unsigned int) credit;
      D.6718 = D.6717 + credit.52;
      credit = (int) D.6718;
      limit = limit + 18446744073709551608;
      {
        word deferred;

        <D.6181>:
        deferred = *limit;
        limit = limit + 18446744073709551608;
        deferred.63 = (char *) deferred;
        if (deferred.63 >= least_ha) goto <D.6720>; else goto <D.6721>;
        <D.6720>:
        deferred.63 = (char *) deferred;
        if (deferred.63 < greatest_ha) goto <D.6179>; else goto <D.6722>;
        <D.6722>:
        <D.6721>:
        if (current_p > limit) goto next_object; else goto <D.6723>;
        <D.6723>:
        deferred = *limit;
        limit = limit + 18446744073709551608;
        deferred.63 = (char *) deferred;
        if (deferred.63 >= least_ha) goto <D.6724>; else goto <D.6725>;
        <D.6724>:
        deferred.63 = (char *) deferred;
        if (deferred.63 < greatest_ha) goto <D.6179>; else goto <D.6726>;
        <D.6726>:
        <D.6725>:
        if (current_p > limit) goto next_object; else goto <D.6727>;
        <D.6727>:
        goto <D.6181>;
        <D.6179>:
        goto <D.6201>;
        <D.6200>:
        current = *current_p;
        current.54 = (char *) current;
        if (current.54 >= least_ha) goto <D.6728>; else goto <D.6729>;
        <D.6728>:
        current.54 = (char *) current;
        if (current.54 < greatest_ha) goto <D.6730>; else goto <D.6731>;
        <D.6730>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.64 = (long unsigned int) my_current;
            D.6733 = my_current.64 >> 12;
            D.6734 = D.6733 & 7;
            D.6735 = D.6734 * 16;
            hce = &hdr_cache + D.6735;
            D.6736 = hce->block_addr;
            my_current.64 = (long unsigned int) my_current;
            D.6733 = my_current.64 >> 12;
            if (D.6736 == D.6733) goto <D.6737>; else goto <D.6738>;
            <D.6737>:
            my_hhdr = hce->hce_hdr;
            goto <D.6739>;
            <D.6738>:
            {
              register struct hdr * * _ha;

              {
                register struct bottom_index * bi;

                {
                  register word hi;
                  register struct bottom_index * _bi;

                  my_current.64 = (long unsigned int) my_current;
                  hi = my_current.64 >> 22;
                  D.6740 = hi & 2047;
                  _bi = GC_arrays._top_index[D.6740];
                  goto <D.6190>;
                  <D.6189>:
                  _bi = _bi->hash_link;
                  <D.6190>:
                  D.6741 = _bi->key;
                  if (D.6741 != hi) goto <D.6742>; else goto <D.6191>;
                  <D.6742>:
                  D.6648 = GC_arrays._all_nils;
                  if (D.6648 != _bi) goto <D.6189>; else goto <D.6191>;
                  <D.6191>:
                  bi = _bi;
                }
                my_current.64 = (long unsigned int) my_current;
                D.6733 = my_current.64 >> 12;
                D.6743 = D.6733 & 1023;
                _ha = &bi->index[D.6743];
              }
              my_hhdr = *_ha;
            }
            my_hhdr.65 = (long unsigned int) my_hhdr;
            if (my_hhdr.65 <= 4095) goto <D.6745>; else goto <D.6746>;
            <D.6745>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.57 = GC_invalid_header;
                  new_hdr = GC_invalid_header.57;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6747>;
            <D.6746>:
            my_current.64 = (long unsigned int) my_current;
            D.6733 = my_current.64 >> 12;
            hce->block_addr = D.6733;
            hce->hce_hdr = my_hhdr;
            <D.6747>:
            <D.6739>:
          }
          {
            int displ;
            int map_entry;

            my_current.66 = (long int) my_current;
            D.6749 = (int) my_current.66;
            displ = D.6749 & 4095;
            D.6750 = my_hhdr->hb_map;
            D.6751 = (sizetype) displ;
            D.6752 = D.6750 + D.6751;
            D.6753 = *D.6752;
            map_entry = (int) D.6753;
            displ = displ >> 3;
            if (map_entry > 253) goto <D.6754>; else goto <D.6755>;
            <D.6754>:
            if (map_entry == 254) goto <D.6756>; else goto <D.6757>;
            <D.6756>:
            D.6758 = (long unsigned int) displ;
            D.6759 = my_hhdr->hb_sz;
            D.6760 = D.6758 % D.6759;
            map_entry = (int) D.6760;
            displ = displ - map_entry;
            D.6758 = (long unsigned int) displ;
            D.6759 = my_hhdr->hb_sz;
            D.6761 = D.6758 + D.6759;
            if (D.6761 > 512) goto <D.6762>; else goto <D.6763>;
            <D.6762>:
            GC_all_interior_pointers.59 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.59 != 0) goto <D.6764>; else goto <D.6765>;
            <D.6764>:
            my_current.64 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.64);
            goto <D.6766>;
            <D.6765>:
            my_current.64 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.64);
            <D.6766>:
            goto exit2;
            <D.6763>:
            goto <D.6767>;
            <D.6757>:
            GC_all_interior_pointers.59 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.59 != 0) goto <D.6768>; else goto <D.6769>;
            <D.6768>:
            my_current.64 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.64);
            goto <D.6770>;
            <D.6769>:
            my_current.64 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.64);
            <D.6770>:
            goto exit2;
            <D.6767>:
            goto <D.6771>;
            <D.6755>:
            displ = displ - map_entry;
            <D.6771>:
            {
              register word * mark_word_addr;

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

                old = *mark_word_addr;
                D.6774 = displ & 63;
                my_bits = 1 << D.6774;
                D.6775 = old & my_bits;
                if (D.6775 != 0) goto exit2; else goto <D.6776>;
                <D.6776>:
                D.6777 = old | my_bits;
                *mark_word_addr = D.6777;
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6778>; else goto <D.6779>;
              <D.6778>:
              goto <D.6780>;
              <D.6779>:
              mark_stack_top = mark_stack_top + 16;
              if (mark_stack_top >= mark_stack_limit) goto <D.6781>; else goto <D.6782>;
              <D.6781>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6782>:
              D.6783 = (long unsigned int) displ;
              D.6784 = D.6783 * 8;
              my_current.67 = (sizetype) my_current;
              D.6786 = my_current.67 & 18446744073709547520;
              D.6787 = D.6784 + D.6786;
              D.6788 = (GC_word *) D.6787;
              mark_stack_top->mse_start = D.6788;
              mark_stack_top->mse_descr = _descr;
              <D.6780>:
            }
          }
          exit2:
        }
        <D.6731>:
        <D.6729>:
        current_p = current_p + 8;
        <D.6201>:
        if (current_p <= limit) goto <D.6200>; else goto <D.6202>;
        <D.6202>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.68 = (long unsigned int) my_current;
            D.6790 = my_current.68 >> 12;
            D.6791 = D.6790 & 7;
            D.6792 = D.6791 * 16;
            hce = &hdr_cache + D.6792;
            D.6793 = hce->block_addr;
            my_current.68 = (long unsigned int) my_current;
            D.6790 = my_current.68 >> 12;
            if (D.6793 == D.6790) goto <D.6794>; else goto <D.6795>;
            <D.6794>:
            my_hhdr = hce->hce_hdr;
            goto <D.6796>;
            <D.6795>:
            {
              register struct hdr * * _ha;

              {
                register struct bottom_index * bi;

                {
                  register word hi;
                  register struct bottom_index * _bi;

                  my_current.68 = (long unsigned int) my_current;
                  hi = my_current.68 >> 22;
                  D.6797 = hi & 2047;
                  _bi = GC_arrays._top_index[D.6797];
                  goto <D.6211>;
                  <D.6210>:
                  _bi = _bi->hash_link;
                  <D.6211>:
                  D.6798 = _bi->key;
                  if (D.6798 != hi) goto <D.6799>; else goto <D.6212>;
                  <D.6799>:
                  D.6648 = GC_arrays._all_nils;
                  if (D.6648 != _bi) goto <D.6210>; else goto <D.6212>;
                  <D.6212>:
                  bi = _bi;
                }
                my_current.68 = (long unsigned int) my_current;
                D.6790 = my_current.68 >> 12;
                D.6800 = D.6790 & 1023;
                _ha = &bi->index[D.6800];
              }
              my_hhdr = *_ha;
            }
            my_hhdr.69 = (long unsigned int) my_hhdr;
            if (my_hhdr.69 <= 4095) goto <D.6802>; else goto <D.6803>;
            <D.6802>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.57 = GC_invalid_header;
                  new_hdr = GC_invalid_header.57;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.6804>;
            <D.6803>:
            my_current.68 = (long unsigned int) my_current;
            D.6790 = my_current.68 >> 12;
            hce->block_addr = D.6790;
            hce->hce_hdr = my_hhdr;
            <D.6804>:
            <D.6796>:
          }
          {
            int displ;
            int map_entry;

            my_current.70 = (long int) my_current;
            D.6806 = (int) my_current.70;
            displ = D.6806 & 4095;
            D.6807 = my_hhdr->hb_map;
            D.6808 = (sizetype) displ;
            D.6809 = D.6807 + D.6808;
            D.6810 = *D.6809;
            map_entry = (int) D.6810;
            displ = displ >> 3;
            if (map_entry > 253) goto <D.6811>; else goto <D.6812>;
            <D.6811>:
            if (map_entry == 254) goto <D.6813>; else goto <D.6814>;
            <D.6813>:
            D.6815 = (long unsigned int) displ;
            D.6816 = my_hhdr->hb_sz;
            D.6817 = D.6815 % D.6816;
            map_entry = (int) D.6817;
            displ = displ - map_entry;
            D.6815 = (long unsigned int) displ;
            D.6816 = my_hhdr->hb_sz;
            D.6818 = D.6815 + D.6816;
            if (D.6818 > 512) goto <D.6819>; else goto <D.6820>;
            <D.6819>:
            GC_all_interior_pointers.59 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.59 != 0) goto <D.6821>; else goto <D.6822>;
            <D.6821>:
            my_current.68 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.68);
            goto <D.6823>;
            <D.6822>:
            my_current.68 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.68);
            <D.6823>:
            goto exit4;
            <D.6820>:
            goto <D.6824>;
            <D.6814>:
            GC_all_interior_pointers.59 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.59 != 0) goto <D.6825>; else goto <D.6826>;
            <D.6825>:
            my_current.68 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.68);
            goto <D.6827>;
            <D.6826>:
            my_current.68 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.68);
            <D.6827>:
            goto exit4;
            <D.6824>:
            goto <D.6828>;
            <D.6812>:
            displ = displ - map_entry;
            <D.6828>:
            {
              register word * mark_word_addr;

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

                old = *mark_word_addr;
                D.6831 = displ & 63;
                my_bits = 1 << D.6831;
                D.6832 = old & my_bits;
                if (D.6832 != 0) goto exit4; else goto <D.6833>;
                <D.6833>:
                D.6834 = old | my_bits;
                *mark_word_addr = D.6834;
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.6835>; else goto <D.6836>;
              <D.6835>:
              goto <D.6837>;
              <D.6836>:
              mark_stack_top = mark_stack_top + 16;
              if (mark_stack_top >= mark_stack_limit) goto <D.6838>; else goto <D.6839>;
              <D.6838>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.6839>:
              D.6840 = (long unsigned int) displ;
              D.6841 = D.6840 * 8;
              my_current.71 = (sizetype) my_current;
              D.6843 = my_current.71 & 18446744073709547520;
              D.6844 = D.6841 + D.6843;
              D.6845 = (GC_word *) D.6844;
              mark_stack_top->mse_start = D.6845;
              mark_stack_top->mse_descr = _descr;
              <D.6837>:
            }
          }
          exit4:
        }
        next_object:
      }
      <D.6174>:
      mark_stack_top.72 = (long int) mark_stack_top;
      mark_stack.73 = (long int) mark_stack;
      D.6848 = mark_stack_top.72 - mark_stack.73;
      D.6849 = (long int) credit;
      D.6850 = D.6848 | D.6849;
      if (D.6850 >= 0) goto <D.6221>; else goto <D.6222>;
      <D.6222>:
      D.6851 = mark_stack_top;
      return D.6851;
    }
  finally
    {
      hdr_cache = {CLOBBER};
    }
}


GC_mark_init ()
{
  alloc_mark_stack (4096);
}


GC_push_all (char * bottom, char * top)
{
  long unsigned int bottom.74;
  long unsigned int D.6856;
  long unsigned int D.6857;
  long unsigned int top.75;
  long unsigned int D.6859;
  struct mse * GC_mark_stack_top.76;
  struct mse * GC_mark_stack_top.77;
  struct mse * GC_mark_stack_limit.78;
  long int top.79;
  long int bottom.80;
  long int D.6870;
  register word length;

  bottom.74 = (long unsigned int) bottom;
  D.6856 = bottom.74 + 7;
  D.6857 = D.6856 & 18446744073709551608;
  bottom = (char *) D.6857;
  top.75 = (long unsigned int) top;
  D.6859 = top.75 & 18446744073709551608;
  top = (char *) D.6859;
  if (top == 0B) goto <D.6860>; else goto <D.6862>;
  <D.6862>:
  if (bottom == top) goto <D.6860>; else goto <D.6861>;
  <D.6860>:
  return;
  <D.6861>:
  GC_mark_stack_top.76 = GC_mark_stack_top;
  GC_mark_stack_top.77 = GC_mark_stack_top.76 + 16;
  GC_mark_stack_top = GC_mark_stack_top.77;
  GC_mark_stack_top.76 = GC_mark_stack_top;
  GC_mark_stack_limit.78 = GC_mark_stack_limit;
  if (GC_mark_stack_top.76 >= GC_mark_stack_limit.78) goto <D.6866>; else goto <D.6867>;
  <D.6866>:
  GC_abort ("unexpected mark stack overflow");
  <D.6867>:
  top.79 = (long int) top;
  bottom.80 = (long int) bottom;
  D.6870 = top.79 - bottom.80;
  length = (word) D.6870;
  GC_mark_stack_top.76 = GC_mark_stack_top;
  GC_mark_stack_top.76->mse_start = bottom;
  GC_mark_stack_top.76 = GC_mark_stack_top;
  GC_mark_stack_top.76->mse_descr = length;
}


GC_push_selected (char * bottom, char * top, int (*<T1054>) (struct hblk *) dirty_fn, void (*<T1057>) (char *, char *) push_fn)
{
  long int bottom.81;
  long int D.6873;
  long int D.6874;
  long int top.82;
  long int D.6876;
  char * D.6880;
  long unsigned int D.6881;
  long unsigned int D.6882;
  struct hblk * D.6885;
  int D.6886;
  int D.6889;
  int D.6892;
  struct mse * GC_mark_stack_top.83;
  long int GC_mark_stack_top.84;
  struct mse * GC_mark_stack.85;
  long int GC_mark_stack.86;
  long int D.6899;
  long int D.6900;
  long unsigned int D.6901;
  long unsigned int GC_mark_stack_size.87;
  long unsigned int D.6903;
  long unsigned int D.6904;
  char * D.6907;
  int D.6910;
  struct mse * GC_mark_stack_limit.88;
  register struct hblk * h;

  bottom.81 = (long int) bottom;
  D.6873 = bottom.81 + 7;
  D.6874 = D.6873 & -8;
  bottom = (char *) D.6874;
  top.82 = (long int) top;
  D.6876 = top.82 & -8;
  top = (char *) D.6876;
  if (top == 0B) goto <D.6877>; else goto <D.6879>;
  <D.6879>:
  if (bottom == top) goto <D.6877>; else goto <D.6878>;
  <D.6877>:
  return;
  <D.6878>:
  D.6880 = bottom + 4096;
  D.6881 = (long unsigned int) D.6880;
  D.6882 = D.6881 & 18446744073709547520;
  h = (struct hblk *) D.6882;
  if (top <= h) goto <D.6883>; else goto <D.6884>;
  <D.6883>:
  D.6885 = h + 18446744073709547520;
  D.6886 = dirty_fn (D.6885);
  if (D.6886 != 0) goto <D.6887>; else goto <D.6888>;
  <D.6887>:
  push_fn (bottom, top);
  <D.6888>:
  return;
  <D.6884>:
  D.6885 = h + 18446744073709547520;
  D.6889 = dirty_fn (D.6885);
  if (D.6889 != 0) goto <D.6890>; else goto <D.6891>;
  <D.6890>:
  push_fn (bottom, h);
  <D.6891>:
  goto <D.6247>;
  <D.6246>:
  D.6892 = dirty_fn (h);
  if (D.6892 != 0) goto <D.6893>; else goto <D.6894>;
  <D.6893>:
  GC_mark_stack_top.83 = GC_mark_stack_top;
  GC_mark_stack_top.84 = (long int) GC_mark_stack_top.83;
  GC_mark_stack.85 = GC_mark_stack;
  GC_mark_stack.86 = (long int) GC_mark_stack.85;
  D.6899 = GC_mark_stack_top.84 - GC_mark_stack.86;
  D.6900 = D.6899 /[ex] 16;
  D.6901 = (long unsigned int) D.6900;
  GC_mark_stack_size.87 = GC_mark_stack_size;
  D.6903 = GC_mark_stack_size.87 * 3;
  D.6904 = D.6903 / 4;
  if (D.6901 > D.6904) goto <D.6905>; else goto <D.6906>;
  <D.6905>:
  push_fn (h, top);
  return;
  <D.6906>:
  D.6907 = h + 4096;
  push_fn (h, D.6907);
  <D.6894>:
  h = h + 4096;
  <D.6247>:
  D.6907 = h + 4096;
  if (D.6907 <= top) goto <D.6246>; else goto <D.6248>;
  <D.6248>:
  if (h != top) goto <D.6908>; else goto <D.6909>;
  <D.6908>:
  D.6910 = dirty_fn (h);
  if (D.6910 != 0) goto <D.6911>; else goto <D.6912>;
  <D.6911>:
  push_fn (h, top);
  <D.6912>:
  <D.6909>:
  GC_mark_stack_top.83 = GC_mark_stack_top;
  GC_mark_stack_limit.88 = GC_mark_stack_limit;
  if (GC_mark_stack_top.83 >= GC_mark_stack_limit.88) goto <D.6914>; else goto <D.6915>;
  <D.6914>:
  GC_abort ("unexpected mark stack overflow");
  <D.6915>:
}


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

  if (all != 0) goto <D.6917>; else goto <D.6918>;
  <D.6917>:
  GC_dirty_maintained.89 = GC_dirty_maintained;
  if (GC_dirty_maintained.89 != 0) goto <D.6920>; else goto <D.6921>;
  <D.6920>:
  GC_push_all (bottom, top);
  goto <D.6922>;
  <D.6921>:
  GC_push_all (bottom, top);
  <D.6922>:
  goto <D.6923>;
  <D.6918>:
  GC_push_selected (bottom, top, GC_page_was_dirty, GC_push_all);
  <D.6923>:
}


GC_push_one (word p)
{
  char * p.90;
  void * GC_least_plausible_heap_addr.91;
  void * GC_greatest_plausible_heap_addr.92;

  p.90 = (char *) p;
  GC_least_plausible_heap_addr.91 = GC_least_plausible_heap_addr;
  if (p.90 >= GC_least_plausible_heap_addr.91) goto <D.6926>; else goto <D.6927>;
  <D.6926>:
  p.90 = (char *) p;
  GC_greatest_plausible_heap_addr.92 = GC_greatest_plausible_heap_addr;
  if (p.90 < GC_greatest_plausible_heap_addr.92) goto <D.6929>; else goto <D.6930>;
  <D.6929>:
  GC_mark_and_push_stack (p);
  <D.6930>:
  <D.6927>:
}


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.93;
  long unsigned int D.6932;
  long unsigned int D.6933;
  struct bottom_index * D.6935;
  long unsigned int D.6936;
  long unsigned int D.6937;
  long unsigned int my_hhdr.94;
  struct hdr * GC_invalid_header.95;
  long int my_current.96;
  int D.6943;
  map_entry_type * D.6944;
  sizetype D.6945;
  map_entry_type * D.6946;
  unsigned char D.6947;
  long unsigned int D.6952;
  long unsigned int D.6953;
  long unsigned int D.6954;
  long unsigned int D.6955;
  int GC_all_interior_pointers.97;
  int D.6967;
  sizetype D.6968;
  int D.6969;
  long unsigned int D.6970;
  long unsigned int D.6972;
  long unsigned int D.6978;
  long unsigned int D.6979;
  sizetype my_current.98;
  sizetype D.6981;
  sizetype D.6982;
  GC_word * D.6983;
  struct GC_ms_entry * D.6984;
  void was_marked = <<< error >>>;

  {
    struct hdr * my_hhdr;
    char * my_current;

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

      {
        register struct bottom_index * bi;

        {
          register word hi;
          register struct bottom_index * _bi;

          my_current.93 = (long unsigned int) my_current;
          hi = my_current.93 >> 22;
          D.6932 = hi & 2047;
          _bi = GC_arrays._top_index[D.6932];
          goto <D.6270>;
          <D.6269>:
          _bi = _bi->hash_link;
          <D.6270>:
          D.6933 = _bi->key;
          if (D.6933 != hi) goto <D.6934>; else goto <D.6271>;
          <D.6934>:
          D.6935 = GC_arrays._all_nils;
          if (D.6935 != _bi) goto <D.6269>; else goto <D.6271>;
          <D.6271>:
          bi = _bi;
        }
        my_current.93 = (long unsigned int) my_current;
        D.6936 = my_current.93 >> 12;
        D.6937 = D.6936 & 1023;
        _ha = &bi->index[D.6937];
      }
      my_hhdr = *_ha;
    }
    my_hhdr.94 = (long unsigned int) my_hhdr;
    if (my_hhdr.94 <= 4095) goto <D.6939>; else goto <D.6940>;
    <D.6939>:
    {
      struct hdr * new_hdr;

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

      my_current.96 = (long int) my_current;
      D.6943 = (int) my_current.96;
      displ = D.6943 & 4095;
      D.6944 = my_hhdr->hb_map;
      D.6945 = (sizetype) displ;
      D.6946 = D.6944 + D.6945;
      D.6947 = *D.6946;
      map_entry = (int) D.6947;
      displ = displ >> 3;
      if (map_entry > 253) goto <D.6948>; else goto <D.6949>;
      <D.6948>:
      if (map_entry == 254) goto <D.6950>; else goto <D.6951>;
      <D.6950>:
      D.6952 = (long unsigned int) displ;
      D.6953 = my_hhdr->hb_sz;
      D.6954 = D.6952 % D.6953;
      map_entry = (int) D.6954;
      displ = displ - map_entry;
      D.6952 = (long unsigned int) displ;
      D.6953 = my_hhdr->hb_sz;
      D.6955 = D.6952 + D.6953;
      if (D.6955 > 512) goto <D.6956>; else goto <D.6957>;
      <D.6956>:
      GC_all_interior_pointers.97 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.97 != 0) goto <D.6959>; else goto <D.6960>;
      <D.6959>:
      my_current.93 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.93);
      goto <D.6961>;
      <D.6960>:
      my_current.93 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.93);
      <D.6961>:
      goto was_marked;
      <D.6957>:
      goto <D.6962>;
      <D.6951>:
      GC_all_interior_pointers.97 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.97 != 0) goto <D.6963>; else goto <D.6964>;
      <D.6963>:
      my_current.93 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.93);
      goto <D.6965>;
      <D.6964>:
      my_current.93 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.93);
      <D.6965>:
      goto was_marked;
      <D.6962>:
      goto <D.6966>;
      <D.6949>:
      displ = displ - map_entry;
      <D.6966>:
      {
        register word * mark_word_addr;

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

          old = *mark_word_addr;
          D.6969 = displ & 63;
          my_bits = 1 << D.6969;
          D.6970 = old & my_bits;
          if (D.6970 != 0) goto was_marked; else goto <D.6971>;
          <D.6971>:
          D.6972 = old | my_bits;
          *mark_word_addr = D.6972;
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.6973>; else goto <D.6974>;
        <D.6973>:
        goto <D.6975>;
        <D.6974>:
        mark_stack_ptr = mark_stack_ptr + 16;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.6976>; else goto <D.6977>;
        <D.6976>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.6977>:
        D.6978 = (long unsigned int) displ;
        D.6979 = D.6978 * 8;
        my_current.98 = (sizetype) my_current;
        D.6981 = my_current.98 & 18446744073709547520;
        D.6982 = D.6979 + D.6981;
        D.6983 = (GC_word *) D.6982;
        mark_stack_ptr->mse_start = D.6983;
        mark_stack_ptr->mse_descr = _descr;
        <D.6975>:
      }
    }
    was_marked:
  }
  D.6984 = mark_stack_ptr;
  return D.6984;
}


GC_mark_and_push_stack (word p)
{
  long unsigned int D.6986;
  long unsigned int D.6987;
  struct bottom_index * D.6989;
  long unsigned int D.6990;
  long unsigned int D.6991;
  long unsigned int hhdr.99;
  void * p.100;
  void * D.6998;
  char * r.101;
  long unsigned int D.7000;
  long unsigned int D.7001;
  int D.7003;
  map_entry_type * D.7004;
  sizetype D.7005;
  map_entry_type * D.7006;
  int GC_all_interior_pointers.102;
  void * D.7014;
  int D.7018;
  long unsigned int D.7019;
  long unsigned int D.7020;
  sizetype D.7021;
  int D.7025;
  long unsigned int D.7026;
  int D.7027;
  long unsigned int D.7028;
  long unsigned int D.7029;
  sizetype D.7032;
  long unsigned int D.7033;
  long unsigned int D.7034;
  long unsigned int D.7035;
  struct mse * GC_mark_stack_top.103;
  struct mse * GC_mark_stack_top.104;
  struct mse * GC_mark_stack_limit.105;
  struct mse * GC_mark_stack_top.106;
  GC_word * r.107;
  register word r;
  register struct hdr * hhdr;
  register int displ;

  {
    register struct hdr * * _ha;

    {
      register struct bottom_index * bi;

      {
        register word hi;
        register struct bottom_index * _bi;

        hi = p >> 22;
        D.6986 = hi & 2047;
        _bi = GC_arrays._top_index[D.6986];
        goto <D.6291>;
        <D.6290>:
        _bi = _bi->hash_link;
        <D.6291>:
        D.6987 = _bi->key;
        if (D.6987 != hi) goto <D.6988>; else goto <D.6292>;
        <D.6988>:
        D.6989 = GC_arrays._all_nils;
        if (D.6989 != _bi) goto <D.6290>; else goto <D.6292>;
        <D.6292>:
        bi = _bi;
      }
      D.6990 = p >> 12;
      D.6991 = D.6990 & 1023;
      _ha = &bi->index[D.6991];
    }
    hhdr = *_ha;
  }
  hhdr.99 = (long unsigned int) hhdr;
  if (hhdr.99 <= 4095) goto <D.6993>; else goto <D.6994>;
  <D.6993>:
  if (hhdr != 0B) goto <D.6995>; else goto <D.6996>;
  <D.6995>:
  p.100 = (void *) p;
  D.6998 = GC_base (p.100);
  r = (word) D.6998;
  r.101 = (char *) r;
  hhdr = GC_find_header (r.101);
  D.7000 = r & 4095;
  D.7001 = D.7000 >> 3;
  displ = (int) D.7001;
  <D.6996>:
  goto <D.7002>;
  <D.6994>:
  {
    register map_entry_type map_entry;

    D.7003 = (int) p;
    displ = D.7003 & 4095;
    D.7004 = hhdr->hb_map;
    D.7005 = (sizetype) displ;
    D.7006 = D.7004 + D.7005;
    map_entry = *D.7006;
    if (map_entry > 252) goto <D.7007>; else goto <D.7008>;
    <D.7007>:
    if (map_entry == 254) goto <D.7009>; else goto <D.7012>;
    <D.7012>:
    GC_all_interior_pointers.102 = GC_all_interior_pointers;
    if (GC_all_interior_pointers.102 == 0) goto <D.7009>; else goto <D.7010>;
    <D.7009>:
    p.100 = (void *) p;
    D.7014 = GC_base (p.100);
    r = (word) D.7014;
    D.7000 = r & 4095;
    D.7001 = D.7000 >> 3;
    displ = (int) D.7001;
    if (r == 0) goto <D.7015>; else goto <D.7016>;
    <D.7015>:
    hhdr = 0B;
    <D.7016>:
    goto <D.7011>;
    <D.7010>:
    hhdr = 0B;
    <D.7011>:
    goto <D.7017>;
    <D.7008>:
    displ = displ >> 3;
    D.7018 = (int) map_entry;
    displ = displ - D.7018;
    D.7019 = (long unsigned int) displ;
    D.7020 = D.7019 * 8;
    D.7021 = p & 18446744073709547520;
    r = D.7020 + D.7021;
    <D.7017>:
  }
  <D.7002>:
  if (hhdr == 0B) goto <D.7022>; else goto <D.7023>;
  <D.7022>:
  GC_add_to_black_list_stack (p);
  goto <D.7024>;
  <D.7023>:
  D.7025 = displ >> 6;
  D.7026 = hhdr->hb_marks[D.7025];
  D.7027 = displ & 63;
  D.7028 = D.7026 >> D.7027;
  D.7029 = D.7028 & 1;
  if (D.7029 == 0) goto <D.7030>; else goto <D.7031>;
  <D.7030>:
  D.7025 = displ >> 6;
  D.7032 = (sizetype) D.7025;
  D.7025 = displ >> 6;
  D.7032 = (sizetype) D.7025;
  D.7033 = hhdr->hb_marks[D.7032];
  D.7027 = displ & 63;
  D.7034 = 1 << D.7027;
  D.7035 = D.7033 | D.7034;
  hhdr->hb_marks[D.7032] = D.7035;
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.7036>; else goto <D.7037>;
    <D.7036>:
    goto <D.7038>;
    <D.7037>:
    GC_mark_stack_top.103 = GC_mark_stack_top;
    GC_mark_stack_top.104 = GC_mark_stack_top.103 + 16;
    GC_mark_stack_top = GC_mark_stack_top.104;
    GC_mark_stack_top.103 = GC_mark_stack_top;
    GC_mark_stack_limit.105 = GC_mark_stack_limit;
    if (GC_mark_stack_top.103 >= GC_mark_stack_limit.105) goto <D.7042>; else goto <D.7043>;
    <D.7042>:
    GC_mark_stack_top.103 = GC_mark_stack_top;
    GC_mark_stack_top.106 = GC_signal_mark_stack_overflow (GC_mark_stack_top.103);
    GC_mark_stack_top = GC_mark_stack_top.106;
    <D.7043>:
    GC_mark_stack_top.103 = GC_mark_stack_top;
    r.107 = (GC_word *) r;
    GC_mark_stack_top.103->mse_start = r.107;
    GC_mark_stack_top.103 = GC_mark_stack_top;
    GC_mark_stack_top.103->mse_descr = _descr;
    <D.7038>:
  }
  <D.7031>:
  <D.7024>:
}


GC_push_all_eager (char * bottom, char * top)
{
  long unsigned int bottom.108;
  long unsigned int D.7047;
  long unsigned int D.7048;
  long unsigned int top.109;
  long unsigned int D.7050;
  char * q.110;
  word * b;
  word * t;
  register word * p;
  register word q;
  register word * lim;
  register char * greatest_ha;
  register char * least_ha;

  bottom.108 = (long unsigned int) bottom;
  D.7047 = bottom.108 + 7;
  D.7048 = D.7047 & 18446744073709551608;
  b = (word *) D.7048;
  top.109 = (long unsigned int) top;
  D.7050 = top.109 & 18446744073709551608;
  t = (word *) D.7050;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  if (top == 0B) goto <D.7051>; else goto <D.7052>;
  <D.7051>:
  return;
  <D.7052>:
  lim = t + 18446744073709551608;
  p = b;
  goto <D.6307>;
  <D.6306>:
  q = *p;
  q.110 = (char *) q;
  if (q.110 >= least_ha) goto <D.7054>; else goto <D.7055>;
  <D.7054>:
  q.110 = (char *) q;
  if (q.110 < greatest_ha) goto <D.7056>; else goto <D.7057>;
  <D.7056>:
  GC_mark_and_push_stack (q);
  <D.7057>:
  <D.7055>:
  p = p + 8;
  <D.6307>:
  if (p <= lim) goto <D.6306>; else goto <D.6308>;
  <D.6308>:
}


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

  GC_all_interior_pointers.111 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.111 != 0) goto <D.7060>; else goto <D.7061>;
  <D.7060>:
  GC_push_all (bottom, top);
  goto <D.7062>;
  <D.7061>:
  GC_push_all_eager (bottom, top);
  <D.7062>:
}


GC_push_marked1 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.112;
  long unsigned int D.7064;
  word * mark_word_addr.113;
  long unsigned int D.7066;
  long unsigned int D.7069;
  long unsigned int D.7070;
  word * D.7071;
  char * q.114;
  void * q.115;
  void * * D.7078;
  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.112 = (long unsigned int) h;
  D.7064 = h.112 + 4096;
  plim = (word *) D.7064;
  goto <D.6331>;
  <D.6330>:
  mark_word_addr.113 = mark_word_addr;
  mark_word_addr = mark_word_addr.113 + 8;
  mark_word = *mark_word_addr.113;
  i = 0;
  goto <D.6328>;
  <D.6327>:
  D.7066 = mark_word & 1;
  if (D.7066 != 0) goto <D.7067>; else goto <D.7068>;
  <D.7067>:
  D.7069 = (long unsigned int) i;
  D.7070 = D.7069 * 8;
  D.7071 = p + D.7070;
  q = *D.7071;
  q.114 = (char *) q;
  if (q.114 >= least_ha) goto <D.7073>; else goto <D.7074>;
  <D.7073>:
  q.114 = (char *) q;
  if (q.114 < greatest_ha) goto <D.7075>; else goto <D.7076>;
  <D.7075>:
  q.115 = (void *) q;
  D.7069 = (long unsigned int) i;
  D.7070 = D.7069 * 8;
  D.7078 = p + D.7070;
  mark_stack_top = GC_mark_and_push (q.115, mark_stack_top, mark_stack_limit, D.7078);
  <D.7076>:
  <D.7074>:
  <D.7068>:
  i = i + 1;
  mark_word = mark_word >> 1;
  <D.6328>:
  if (mark_word != 0) goto <D.6327>; else goto <D.6329>;
  <D.6329>:
  p = p + 512;
  <D.6331>:
  if (p < plim) goto <D.6330>; else goto <D.6332>;
  <D.6332>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked2 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.116;
  long unsigned int D.7080;
  word * mark_word_addr.117;
  long unsigned int D.7082;
  long unsigned int D.7085;
  long unsigned int D.7086;
  word * D.7087;
  char * q.118;
  void * q.119;
  void * * D.7094;
  sizetype D.7095;
  sizetype D.7096;
  sizetype D.7097;
  word * D.7098;
  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.116 = (long unsigned int) h;
  D.7080 = h.116 + 4096;
  plim = (word *) D.7080;
  goto <D.6351>;
  <D.6350>:
  mark_word_addr.117 = mark_word_addr;
  mark_word_addr = mark_word_addr.117 + 8;
  mark_word = *mark_word_addr.117;
  i = 0;
  goto <D.6348>;
  <D.6347>:
  D.7082 = mark_word & 1;
  if (D.7082 != 0) goto <D.7083>; else goto <D.7084>;
  <D.7083>:
  D.7085 = (long unsigned int) i;
  D.7086 = D.7085 * 8;
  D.7087 = p + D.7086;
  q = *D.7087;
  q.118 = (char *) q;
  if (q.118 >= least_ha) goto <D.7089>; else goto <D.7090>;
  <D.7089>:
  q.118 = (char *) q;
  if (q.118 < greatest_ha) goto <D.7091>; else goto <D.7092>;
  <D.7091>:
  q.119 = (void *) q;
  D.7085 = (long unsigned int) i;
  D.7086 = D.7085 * 8;
  D.7094 = p + D.7086;
  mark_stack_top = GC_mark_and_push (q.119, mark_stack_top, mark_stack_limit, D.7094);
  <D.7092>:
  <D.7090>:
  D.7095 = (sizetype) i;
  D.7096 = D.7095 + 1;
  D.7097 = D.7096 * 8;
  D.7098 = p + D.7097;
  q = *D.7098;
  q.118 = (char *) q;
  if (q.118 >= least_ha) goto <D.7099>; else goto <D.7100>;
  <D.7099>:
  q.118 = (char *) q;
  if (q.118 < greatest_ha) goto <D.7101>; else goto <D.7102>;
  <D.7101>:
  q.119 = (void *) q;
  D.7085 = (long unsigned int) i;
  D.7086 = D.7085 * 8;
  D.7094 = p + D.7086;
  mark_stack_top = GC_mark_and_push (q.119, mark_stack_top, mark_stack_limit, D.7094);
  <D.7102>:
  <D.7100>:
  <D.7084>:
  i = i + 2;
  mark_word = mark_word >> 2;
  <D.6348>:
  if (mark_word != 0) goto <D.6347>; else goto <D.6349>;
  <D.6349>:
  p = p + 512;
  <D.6351>:
  if (p < plim) goto <D.6350>; else goto <D.6352>;
  <D.6352>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked4 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.120;
  long unsigned int D.7104;
  word * mark_word_addr.121;
  long unsigned int D.7106;
  long unsigned int D.7109;
  long unsigned int D.7110;
  word * D.7111;
  char * q.122;
  void * q.123;
  void * * D.7118;
  sizetype D.7119;
  sizetype D.7120;
  sizetype D.7121;
  word * D.7122;
  sizetype D.7127;
  sizetype D.7128;
  word * D.7129;
  sizetype D.7134;
  sizetype D.7135;
  word * D.7136;
  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.120 = (long unsigned int) h;
  D.7104 = h.120 + 4096;
  plim = (word *) D.7104;
  goto <D.6371>;
  <D.6370>:
  mark_word_addr.121 = mark_word_addr;
  mark_word_addr = mark_word_addr.121 + 8;
  mark_word = *mark_word_addr.121;
  i = 0;
  goto <D.6368>;
  <D.6367>:
  D.7106 = mark_word & 1;
  if (D.7106 != 0) goto <D.7107>; else goto <D.7108>;
  <D.7107>:
  D.7109 = (long unsigned int) i;
  D.7110 = D.7109 * 8;
  D.7111 = p + D.7110;
  q = *D.7111;
  q.122 = (char *) q;
  if (q.122 >= least_ha) goto <D.7113>; else goto <D.7114>;
  <D.7113>:
  q.122 = (char *) q;
  if (q.122 < greatest_ha) goto <D.7115>; else goto <D.7116>;
  <D.7115>:
  q.123 = (void *) q;
  D.7109 = (long unsigned int) i;
  D.7110 = D.7109 * 8;
  D.7118 = p + D.7110;
  mark_stack_top = GC_mark_and_push (q.123, mark_stack_top, mark_stack_limit, D.7118);
  <D.7116>:
  <D.7114>:
  D.7119 = (sizetype) i;
  D.7120 = D.7119 + 1;
  D.7121 = D.7120 * 8;
  D.7122 = p + D.7121;
  q = *D.7122;
  q.122 = (char *) q;
  if (q.122 >= least_ha) goto <D.7123>; else goto <D.7124>;
  <D.7123>:
  q.122 = (char *) q;
  if (q.122 < greatest_ha) goto <D.7125>; else goto <D.7126>;
  <D.7125>:
  q.123 = (void *) q;
  D.7119 = (sizetype) i;
  D.7120 = D.7119 + 1;
  D.7121 = D.7120 * 8;
  D.7122 = p + D.7121;
  mark_stack_top = GC_mark_and_push (q.123, mark_stack_top, mark_stack_limit, D.7122);
  <D.7126>:
  <D.7124>:
  D.7119 = (sizetype) i;
  D.7127 = D.7119 + 2;
  D.7128 = D.7127 * 8;
  D.7129 = p + D.7128;
  q = *D.7129;
  q.122 = (char *) q;
  if (q.122 >= least_ha) goto <D.7130>; else goto <D.7131>;
  <D.7130>:
  q.122 = (char *) q;
  if (q.122 < greatest_ha) goto <D.7132>; else goto <D.7133>;
  <D.7132>:
  q.123 = (void *) q;
  D.7119 = (sizetype) i;
  D.7127 = D.7119 + 2;
  D.7128 = D.7127 * 8;
  D.7129 = p + D.7128;
  mark_stack_top = GC_mark_and_push (q.123, mark_stack_top, mark_stack_limit, D.7129);
  <D.7133>:
  <D.7131>:
  D.7119 = (sizetype) i;
  D.7134 = D.7119 + 3;
  D.7135 = D.7134 * 8;
  D.7136 = p + D.7135;
  q = *D.7136;
  q.122 = (char *) q;
  if (q.122 >= least_ha) goto <D.7137>; else goto <D.7138>;
  <D.7137>:
  q.122 = (char *) q;
  if (q.122 < greatest_ha) goto <D.7139>; else goto <D.7140>;
  <D.7139>:
  q.123 = (void *) q;
  D.7119 = (sizetype) i;
  D.7134 = D.7119 + 3;
  D.7135 = D.7134 * 8;
  D.7136 = p + D.7135;
  mark_stack_top = GC_mark_and_push (q.123, mark_stack_top, mark_stack_limit, D.7136);
  <D.7140>:
  <D.7138>:
  <D.7108>:
  i = i + 4;
  mark_word = mark_word >> 4;
  <D.6368>:
  if (mark_word != 0) goto <D.6367>; else goto <D.6369>;
  <D.6369>:
  p = p + 512;
  <D.6371>:
  if (p < plim) goto <D.6370>; else goto <D.6372>;
  <D.6372>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.7141;
  long unsigned int D.7142;
  int D.7145;
  long unsigned int GC_n_rescuing_pages.124;
  long unsigned int GC_n_rescuing_pages.125;
  unsigned int sz.126;
  sizetype D.7154;
  sizetype D.7155;
  sizetype D.7156;
  int D.7157;
  long unsigned int D.7158;
  int D.7159;
  long unsigned int D.7160;
  long unsigned int D.7161;
  long unsigned int D.7169;
  long unsigned int D.7170;
  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.7141 = hhdr->hb_sz;
  sz = (int) D.7141;
  D.7142 = hhdr->hb_descr;
  descr = (int) D.7142;
  mark_stack_limit = GC_mark_stack_limit;
  if (descr == 0) goto <D.7143>; else goto <D.7144>;
  <D.7143>:
  return;
  <D.7144>:
  D.7145 = GC_block_empty (hhdr);
  if (D.7145 != 0) goto <D.7146>; else goto <D.7147>;
  <D.7146>:
  return;
  <D.7147>:
  GC_n_rescuing_pages.124 = GC_n_rescuing_pages;
  GC_n_rescuing_pages.125 = GC_n_rescuing_pages.124 + 1;
  GC_n_rescuing_pages = GC_n_rescuing_pages.125;
  GC_objects_are_marked = 1;
  sz.126 = (unsigned int) sz;
  if (sz.126 > 256) goto <D.7151>; else goto <D.7152>;
  <D.7151>:
  lim = h;
  goto <D.7153>;
  <D.7152>:
  D.7154 = (sizetype) sz;
  D.7155 = D.7154 * 18446744073709551608;
  D.7156 = D.7155 + 4096;
  lim = h + D.7156;
  <D.7153>:
  switch (sz) <default: <D.6388>, case 1: <D.6384>, case 2: <D.6386>, case 4: <D.6387>>
  <D.6384>:
  GC_push_marked1 (h, hhdr);
  goto <D.6385>;
  <D.6386>:
  GC_push_marked2 (h, hhdr);
  goto <D.6385>;
  <D.6387>:
  GC_push_marked4 (h, hhdr);
  goto <D.6385>;
  <D.6388>:
  GC_mark_stack_top_reg = GC_mark_stack_top;
  p = h;
  word_no = 0;
  goto <D.6391>;
  <D.6390>:
  D.7157 = word_no >> 6;
  D.7158 = hhdr->hb_marks[D.7157];
  D.7159 = word_no & 63;
  D.7160 = D.7158 >> D.7159;
  D.7161 = D.7160 & 1;
  if (D.7161 != 0) goto <D.7162>; else goto <D.7163>;
  <D.7162>:
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.7164>; else goto <D.7165>;
    <D.7164>:
    goto <D.7166>;
    <D.7165>:
    GC_mark_stack_top_reg = GC_mark_stack_top_reg + 16;
    if (GC_mark_stack_top_reg >= mark_stack_limit) goto <D.7167>; else goto <D.7168>;
    <D.7167>:
    GC_mark_stack_top_reg = GC_signal_mark_stack_overflow (GC_mark_stack_top_reg);
    <D.7168>:
    GC_mark_stack_top_reg->mse_start = p;
    GC_mark_stack_top_reg->mse_descr = _descr;
    <D.7166>:
  }
  <D.7163>:
  D.7169 = (long unsigned int) sz;
  D.7170 = D.7169 * 8;
  p = p + D.7170;
  word_no = word_no + sz;
  <D.6391>:
  if (p <= lim) goto <D.6390>; else goto <D.6392>;
  <D.6392>:
  GC_mark_stack_top = GC_mark_stack_top_reg;
  <D.6385>:
}


GC_block_was_dirty (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.7172;
  unsigned int sz.127;
  GC_bool D.7176;
  int D.7177;
  sizetype D.7180;
  char * D.7181;
  register int sz;

  D.7172 = hhdr->hb_sz;
  sz = (int) D.7172;
  sz.127 = (unsigned int) sz;
  if (sz.127 <= 256) goto <D.7174>; else goto <D.7175>;
  <D.7174>:
  D.7176 = GC_page_was_dirty (h);
  return D.7176;
  <D.7175>:
  {
    register char * p;

    p = h;
    sz = sz << 3;
    goto <D.6400>;
    <D.6399>:
    D.7177 = GC_page_was_dirty (p);
    if (D.7177 != 0) goto <D.7178>; else goto <D.7179>;
    <D.7178>:
    D.7176 = 1;
    return D.7176;
    <D.7179>:
    p = p + 4096;
    <D.6400>:
    D.7180 = (sizetype) sz;
    D.7181 = h + D.7180;
    if (D.7181 > p) goto <D.6399>; else goto <D.6401>;
    <D.6401>:
    D.7176 = 0;
    return D.7176;
  }
}


GC_push_next_marked (struct hblk * h)
{
  struct hblk * D.7185;
  long unsigned int D.7186;
  long unsigned int D.7187;
  long unsigned int D.7188;
  long unsigned int D.7189;
  long unsigned int D.7190;
  register struct hdr * hhdr;

  h = GC_next_used_block (h);
  if (h == 0B) goto <D.7183>; else goto <D.7184>;
  <D.7183>:
  D.7185 = 0B;
  return D.7185;
  <D.7184>:
  hhdr = GC_find_header (h);
  GC_push_marked (h, hhdr);
  D.7186 = hhdr->hb_sz;
  D.7187 = D.7186 << 3;
  D.7188 = D.7187 + 4095;
  D.7189 = D.7188 >> 12;
  D.7190 = D.7189 * 4096;
  D.7185 = h + D.7190;
  return D.7185;
}


GC_push_next_marked_dirty (struct hblk * h)
{
  int GC_dirty_maintained.128;
  struct hblk * D.7197;
  int D.7198;
  long unsigned int D.7200;
  long unsigned int D.7201;
  long unsigned int D.7202;
  long unsigned int D.7203;
  long unsigned int D.7204;
  register struct hdr * hhdr;

  GC_dirty_maintained.128 = GC_dirty_maintained;
  if (GC_dirty_maintained.128 == 0) goto <D.7193>; else goto <D.7194>;
  <D.7193>:
  GC_abort ("dirty bits not set up");
  <D.7194>:
  <D.6411>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.7195>; else goto <D.7196>;
  <D.7195>:
  D.7197 = 0B;
  return D.7197;
  <D.7196>:
  hhdr = GC_find_header (h);
  D.7198 = GC_block_was_dirty (h, hhdr);
  if (D.7198 != 0) goto <D.6410>; else goto <D.7199>;
  <D.7199>:
  D.7200 = hhdr->hb_sz;
  D.7201 = D.7200 << 3;
  D.7202 = D.7201 + 4095;
  D.7203 = D.7202 >> 12;
  D.7204 = D.7203 * 4096;
  h = h + D.7204;
  goto <D.6411>;
  <D.6410>:
  GC_push_marked (h, hhdr);
  D.7200 = hhdr->hb_sz;
  D.7201 = D.7200 << 3;
  D.7202 = D.7201 + 4095;
  D.7203 = D.7202 >> 12;
  D.7204 = D.7203 * 4096;
  D.7197 = h + D.7204;
  return D.7197;
}


GC_push_next_marked_uncollectable (struct hblk * h)
{
  struct hblk * D.7208;
  unsigned char D.7209;
  long unsigned int D.7211;
  long unsigned int D.7212;
  long unsigned int D.7213;
  long unsigned int D.7214;
  long unsigned int D.7215;
  register struct hdr * hhdr;

  hhdr = GC_find_header (h);
  <D.6417>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.7206>; else goto <D.7207>;
  <D.7206>:
  D.7208 = 0B;
  return D.7208;
  <D.7207>:
  hhdr = GC_find_header (h);
  D.7209 = hhdr->hb_obj_kind;
  if (D.7209 == 2) goto <D.6416>; else goto <D.7210>;
  <D.7210>:
  D.7211 = hhdr->hb_sz;
  D.7212 = D.7211 << 3;
  D.7213 = D.7212 + 4095;
  D.7214 = D.7213 >> 12;
  D.7215 = D.7214 * 4096;
  h = h + D.7215;
  goto <D.6417>;
  <D.6416>:
  GC_push_marked (h, hhdr);
  D.7211 = hhdr->hb_sz;
  D.7212 = D.7211 << 3;
  D.7213 = D.7212 + 4095;
  D.7214 = D.7213 >> 12;
  D.7215 = D.7214 * 4096;
  D.7208 = h + D.7215;
  return D.7208;
}