GC_noop (void * p)
{

}


GC_noop1 (word x)
{
  static volatile word sink;

  sink = x;
}


GC_collection_in_progress ()
{
  GC_bool D.5477;
  int GC_mark_state.0;
  _Bool D.5479;

  GC_mark_state.0 = GC_mark_state;
  D.5479 = GC_mark_state.0 != 0;
  D.5477 = (GC_bool) D.5479;
  return D.5477;
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.5484;
  int D.5489;
  void * D.5491;
  unsigned int D.5492;

  D.5484 = __builtin_constant_p (__len);
  if (D.5484 != 0) goto <D.5485>; else goto <D.5486>;
  <D.5485>:
  if (__len == 0) goto <D.5487>; else goto <D.5488>;
  <D.5487>:
  D.5489 = __builtin_constant_p (__ch);
  if (D.5489 == 0) goto <D.5482>; else goto <D.5490>;
  <D.5490>:
  if (__ch != 0) goto <D.5482>; else goto <D.5483>;
  <D.5482>:
  __warn_memset_zero_len ();
  D.5491 = __dest;
  return D.5491;
  <D.5483>:
  <D.5488>:
  <D.5486>:
  D.5492 = __builtin_object_size (__dest, 0);
  D.5491 = __builtin___memset_chk (__dest, __ch, __len, D.5492);
  return D.5491;
}


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

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


GC_set_mark_bit (char * p)
{
  long unsigned int p.1;
  long unsigned int D.5495;
  long unsigned int h.2;
  long unsigned int D.5497;
  struct bottom_index * D.5498;
  long unsigned int D.5499;
  long unsigned int D.5500;
  int p.3;
  int h.4;
  int D.5503;
  int D.5504;
  sizetype D.5505;
  long unsigned int D.5506;
  int D.5507;
  long unsigned int D.5508;
  long unsigned int D.5509;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.1 = (long unsigned int) p;
  D.5495 = p.1 & 4294963200;
  h = (struct hblk *) D.5495;
  h.2 = (long unsigned int) h;
  D.5497 = h.2 >> 22;
  D.5498 = GC_arrays._top_index[D.5497];
  h.2 = (long unsigned int) h;
  D.5499 = h.2 >> 12;
  D.5500 = D.5499 & 1023;
  hhdr = D.5498->index[D.5500];
  p.3 = (int) p;
  h.4 = (int) h;
  D.5503 = p.3 - h.4;
  word_no = D.5503 /[ex] 4;
  D.5504 = word_no >> 5;
  D.5505 = (sizetype) D.5504;
  D.5504 = word_no >> 5;
  D.5505 = (sizetype) D.5504;
  D.5506 = hhdr->hb_marks[D.5505];
  D.5507 = word_no & 31;
  D.5508 = 1 << D.5507;
  D.5509 = D.5506 | D.5508;
  hhdr->hb_marks[D.5505] = D.5509;
}


GC_clear_mark_bit (char * p)
{
  long unsigned int p.5;
  long unsigned int D.5511;
  long unsigned int h.6;
  long unsigned int D.5513;
  struct bottom_index * D.5514;
  long unsigned int D.5515;
  long unsigned int D.5516;
  int p.7;
  int h.8;
  int D.5519;
  int D.5520;
  long unsigned int D.5521;
  int D.5522;
  long unsigned int D.5523;
  long unsigned int D.5524;
  long unsigned int D.5525;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.5 = (long unsigned int) p;
  D.5511 = p.5 & 4294963200;
  h = (struct hblk *) D.5511;
  h.6 = (long unsigned int) h;
  D.5513 = h.6 >> 22;
  D.5514 = GC_arrays._top_index[D.5513];
  h.6 = (long unsigned int) h;
  D.5515 = h.6 >> 12;
  D.5516 = D.5515 & 1023;
  hhdr = D.5514->index[D.5516];
  p.7 = (int) p;
  h.8 = (int) h;
  D.5519 = p.7 - h.8;
  word_no = D.5519 /[ex] 4;
  D.5520 = word_no >> 5;
  D.5520 = word_no >> 5;
  D.5521 = hhdr->hb_marks[D.5520];
  D.5522 = word_no & 31;
  D.5523 = 1 << D.5522;
  D.5524 = ~D.5523;
  D.5525 = D.5521 & D.5524;
  hhdr->hb_marks[D.5520] = D.5525;
}


GC_is_marked (char * p)
{
  long unsigned int p.9;
  long unsigned int D.5527;
  long unsigned int h.10;
  long unsigned int D.5529;
  struct bottom_index * D.5530;
  long unsigned int D.5531;
  long unsigned int D.5532;
  int p.11;
  int h.12;
  int D.5535;
  GC_bool D.5536;
  int D.5537;
  long unsigned int D.5538;
  int D.5539;
  long unsigned int D.5540;
  int D.5541;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.9 = (long unsigned int) p;
  D.5527 = p.9 & 4294963200;
  h = (struct hblk *) D.5527;
  h.10 = (long unsigned int) h;
  D.5529 = h.10 >> 22;
  D.5530 = GC_arrays._top_index[D.5529];
  h.10 = (long unsigned int) h;
  D.5531 = h.10 >> 12;
  D.5532 = D.5531 & 1023;
  hhdr = D.5530->index[D.5532];
  p.11 = (int) p;
  h.12 = (int) h;
  D.5535 = p.11 - h.12;
  word_no = D.5535 /[ex] 4;
  D.5537 = word_no >> 5;
  D.5538 = hhdr->hb_marks[D.5537];
  D.5539 = word_no & 31;
  D.5540 = D.5538 >> D.5539;
  D.5541 = (int) D.5540;
  D.5536 = D.5541 & 1;
  return D.5536;
}


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.5544;
  struct bottom_index * D.5545;
  long unsigned int D.5546;
  long unsigned int D.5547;
  unsigned char D.5548;
  int D.5549;
  int D.5550;
  register struct hdr * hhdr;

  h.13 = (long unsigned int) h;
  D.5544 = h.13 >> 22;
  D.5545 = GC_arrays._top_index[D.5544];
  h.13 = (long unsigned int) h;
  D.5546 = h.13 >> 12;
  D.5547 = D.5546 & 1023;
  hhdr = D.5545->index[D.5547];
  D.5548 = hhdr->hb_obj_kind;
  D.5549 = (int) D.5548;
  D.5550 = D.5549 & -2;
  if (D.5550 == 2) goto <D.5551>; else goto <D.5552>;
  <D.5551>:
  return;
  <D.5552>:
  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.5555>; else goto <D.5556>;
  <D.5555>:
  GC_read_dirty ();
  <D.5556>:
  GC_n_rescuing_pages = 0;
  GC_mark_state.15 = GC_mark_state;
  if (GC_mark_state.15 == 0) goto <D.5558>; else goto <D.5559>;
  <D.5558>:
  GC_mark_state = 1;
  goto <D.5560>;
  <D.5559>:
  GC_mark_state.15 = GC_mark_state;
  if (GC_mark_state.15 != 5) goto <D.5561>; else goto <D.5562>;
  <D.5561>:
  GC_abort ("unexpected state");
  <D.5562>:
  <D.5560>:
  scan_ptr = 0B;
}


GC_mark_some (char * cold_gc_frame)
{
  int GC_mark_state.16;
  GC_bool D.5564;
  struct mse * GC_mark_stack_limit.17;
  struct mse * D.5566;
  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.5572;
  struct mse * D.5573;
  struct mse * GC_mark_stack_top.21;
  struct hblk * scan_ptr.22;
  struct hblk * scan_ptr.23;
  int GC_print_stats.24;
  long unsigned int GC_n_rescuing_pages.25;
  long int GC_n_rescuing_pages.26;
  long unsigned int D.5586;
  long unsigned int D.5587;
  struct mse * D.5588;
  struct mse * GC_mark_stack_top.27;
  struct hblk * scan_ptr.28;
  struct mse * GC_mark_stack_top.29;
  int GC_mark_stack_too_small.30;
  long unsigned int D.5603;
  int GC_objects_are_marked.31;
  struct mse * GC_mark_stack_top.32;
  struct hblk * scan_ptr.33;

  GC_mark_state.16 = GC_mark_state;
  switch (GC_mark_state.16) <default: <D.5212>, case 0: <D.5206>, case 1: <D.5207>, case 2: <D.5208>, case 3: <D.5209>, case 4: <D.5211>, case 5: <D.5210>>
  <D.5206>:
  D.5564 = 0;
  return D.5564;
  <D.5207>:
  GC_mark_stack_limit.17 = GC_mark_stack_limit;
  D.5566 = GC_mark_stack_limit.17 + 4294950912;
  GC_mark_stack_top.18 = GC_mark_stack_top;
  if (D.5566 <= GC_mark_stack_top.18) goto <D.5568>; else goto <D.5569>;
  <D.5568>:
  GC_mark_stack_too_small = 1;
  GC_mark_stack_top.18 = GC_mark_stack_top;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5572 = GC_mark_stack_size.20 * 8;
  D.5573 = GC_mark_stack.19 + D.5572;
  GC_mark_stack_top.21 = GC_mark_from (GC_mark_stack_top.18, GC_mark_stack.19, D.5573);
  GC_mark_stack_top = GC_mark_stack_top.21;
  D.5564 = 0;
  return D.5564;
  <D.5569>:
  scan_ptr.22 = scan_ptr;
  scan_ptr.23 = GC_push_next_marked_dirty (scan_ptr.22);
  scan_ptr = scan_ptr.23;
  scan_ptr.22 = scan_ptr;
  if (scan_ptr.22 == 0B) goto <D.5577>; else goto <D.5578>;
  <D.5577>:
  GC_print_stats.24 = GC_print_stats;
  if (GC_print_stats.24 != 0) goto <D.5580>; else goto <D.5581>;
  <D.5580>:
  GC_n_rescuing_pages.25 = GC_n_rescuing_pages;
  GC_n_rescuing_pages.26 = (long int) GC_n_rescuing_pages.25;
  GC_printf ("Marked from %lu dirty pages\n", GC_n_rescuing_pages.26, 0, 0, 0, 0, 0);
  <D.5581>:
  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.5584>; else goto <D.5585>;
  <D.5584>:
  GC_mark_state = 3;
  <D.5585>:
  <D.5578>:
  D.5564 = 0;
  return D.5564;
  <D.5208>:
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5586 = GC_mark_stack_size.20 / 4;
  D.5587 = D.5586 * 8;
  D.5588 = GC_mark_stack.19 + D.5587;
  GC_mark_stack_top.18 = GC_mark_stack_top;
  if (D.5588 <= GC_mark_stack_top.18) goto <D.5589>; else goto <D.5590>;
  <D.5589>:
  GC_mark_stack_top.18 = GC_mark_stack_top;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5572 = GC_mark_stack_size.20 * 8;
  D.5573 = GC_mark_stack.19 + D.5572;
  GC_mark_stack_top.27 = GC_mark_from (GC_mark_stack_top.18, GC_mark_stack.19, D.5573);
  GC_mark_stack_top = GC_mark_stack_top.27;
  D.5564 = 0;
  return D.5564;
  <D.5590>:
  scan_ptr.22 = scan_ptr;
  scan_ptr.28 = GC_push_next_marked_uncollectable (scan_ptr.22);
  scan_ptr = scan_ptr.28;
  scan_ptr.22 = scan_ptr;
  if (scan_ptr.22 == 0B) goto <D.5593>; else goto <D.5594>;
  <D.5593>:
  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.5595>; else goto <D.5596>;
  <D.5595>:
  GC_mark_state = 3;
  <D.5596>:
  <D.5594>:
  D.5564 = 0;
  return D.5564;
  <D.5209>:
  GC_mark_stack_top.18 = GC_mark_stack_top;
  GC_mark_stack.19 = GC_mark_stack;
  if (GC_mark_stack_top.18 >= GC_mark_stack.19) goto <D.5597>; else goto <D.5598>;
  <D.5597>:
  GC_mark_stack_top.18 = GC_mark_stack_top;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5572 = GC_mark_stack_size.20 * 8;
  D.5573 = GC_mark_stack.19 + D.5572;
  GC_mark_stack_top.29 = GC_mark_from (GC_mark_stack_top.18, GC_mark_stack.19, D.5573);
  GC_mark_stack_top = GC_mark_stack_top.29;
  D.5564 = 0;
  return D.5564;
  <D.5598>:
  GC_mark_state = 0;
  GC_mark_stack_too_small.30 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.30 != 0) goto <D.5601>; else goto <D.5602>;
  <D.5601>:
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5603 = GC_mark_stack_size.20 * 2;
  alloc_mark_stack (D.5603);
  <D.5602>:
  D.5564 = 1;
  return D.5564;
  <D.5210>:
  <D.5211>:
  GC_objects_are_marked.31 = GC_objects_are_marked;
  if (GC_objects_are_marked.31 == 0) goto <D.5605>; else goto <D.5606>;
  <D.5605>:
  GC_mark_state = 2;
  D.5564 = 0;
  return D.5564;
  <D.5606>:
  GC_mark_stack_top.18 = GC_mark_stack_top;
  GC_mark_stack.19 = GC_mark_stack;
  if (GC_mark_stack_top.18 >= GC_mark_stack.19) goto <D.5607>; else goto <D.5608>;
  <D.5607>:
  GC_mark_stack_top.18 = GC_mark_stack_top;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5572 = GC_mark_stack_size.20 * 8;
  D.5573 = GC_mark_stack.19 + D.5572;
  GC_mark_stack_top.32 = GC_mark_from (GC_mark_stack_top.18, GC_mark_stack.19, D.5573);
  GC_mark_stack_top = GC_mark_stack_top.32;
  D.5564 = 0;
  return D.5564;
  <D.5608>:
  scan_ptr.22 = scan_ptr;
  if (scan_ptr.22 == 0B) goto <D.5610>; else goto <D.5611>;
  <D.5610>:
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 == 5) goto <D.5612>; else goto <D.5613>;
  <D.5612>:
  GC_mark_stack_too_small.30 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.30 != 0) goto <D.5614>; else goto <D.5615>;
  <D.5614>:
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.5603 = GC_mark_stack_size.20 * 2;
  alloc_mark_stack (D.5603);
  <D.5615>:
  GC_mark_state = 4;
  <D.5613>:
  <D.5611>:
  scan_ptr.22 = scan_ptr;
  scan_ptr.33 = GC_push_next_marked (scan_ptr.22);
  scan_ptr = scan_ptr.33;
  scan_ptr.22 = scan_ptr;
  if (scan_ptr.22 == 0B) goto <D.5617>; else goto <D.5618>;
  <D.5617>:
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 == 4) goto <D.5619>; else goto <D.5620>;
  <D.5619>:
  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.5621>; else goto <D.5622>;
  <D.5621>:
  GC_mark_state = 3;
  <D.5622>:
  <D.5620>:
  <D.5618>:
  D.5564 = 0;
  return D.5564;
  <D.5212>:
  GC_abort ("GC_mark_some: bad state");
  D.5564 = 0;
  return D.5564;
}


alloc_mark_stack (word n)
{
  long unsigned int D.5624;
  long unsigned int GC_mark_stack_size.34;
  long unsigned int GC_page_size.35;
  long unsigned int D.5631;
  struct mse * GC_mark_stack.36;
  long unsigned int GC_mark_stack.37;
  long unsigned int D.5634;
  long unsigned int size.38;
  long unsigned int D.5638;
  long unsigned int D.5639;
  long unsigned int D.5640;
  long unsigned int D.5643;
  struct hblk * D.5644;
  long unsigned int D.5645;
  struct mse * GC_mark_stack_limit.39;
  int GC_print_stats.40;
  long int GC_mark_stack_size.41;
  long int n.42;
  struct mse * GC_mark_stack_top.43;
  struct mse * new_stack;

  D.5624 = n * 8;
  new_stack = GC_scratch_alloc (D.5624);
  GC_mark_stack_too_small = 0;
  GC_mark_stack_size.34 = GC_mark_stack_size;
  if (GC_mark_stack_size.34 != 0) goto <D.5626>; else goto <D.5627>;
  <D.5626>:
  if (new_stack != 0B) goto <D.5628>; else goto <D.5629>;
  <D.5628>:
  {
    word displ;
    signed_word size;

    GC_page_size.35 = GC_page_size;
    D.5631 = GC_page_size.35 + 4294967295;
    GC_mark_stack.36 = GC_mark_stack;
    GC_mark_stack.37 = (long unsigned int) GC_mark_stack.36;
    displ = D.5631 & GC_mark_stack.37;
    GC_mark_stack_size.34 = GC_mark_stack_size;
    D.5634 = GC_mark_stack_size.34 * 8;
    size = (signed_word) D.5634;
    if (displ != 0) goto <D.5635>; else goto <D.5636>;
    <D.5635>:
    GC_page_size.35 = GC_page_size;
    displ = GC_page_size.35 - displ;
    <D.5636>:
    size.38 = (long unsigned int) size;
    D.5638 = size.38 - displ;
    GC_page_size.35 = GC_page_size;
    D.5639 = -GC_page_size.35;
    D.5640 = D.5638 & D.5639;
    size = (signed_word) D.5640;
    if (size > 0) goto <D.5641>; else goto <D.5642>;
    <D.5641>:
    GC_mark_stack.36 = GC_mark_stack;
    GC_mark_stack.37 = (long unsigned int) GC_mark_stack.36;
    D.5643 = GC_mark_stack.37 + displ;
    D.5644 = (struct hblk *) D.5643;
    size.38 = (long unsigned int) size;
    GC_add_to_heap (D.5644, size.38);
    <D.5642>:
    GC_mark_stack = new_stack;
    GC_mark_stack_size = n;
    D.5645 = n * 8;
    GC_mark_stack_limit.39 = new_stack + D.5645;
    GC_mark_stack_limit = GC_mark_stack_limit.39;
    GC_print_stats.40 = GC_print_stats;
    if (GC_print_stats.40 != 0) goto <D.5648>; else goto <D.5649>;
    <D.5648>:
    GC_mark_stack_size.34 = GC_mark_stack_size;
    GC_mark_stack_size.41 = (long int) GC_mark_stack_size.34;
    GC_printf ("Grew mark stack to %lu frames\n", GC_mark_stack_size.41, 0, 0, 0, 0, 0);
    <D.5649>:
  }
  goto <D.5651>;
  <D.5629>:
  GC_print_stats.40 = GC_print_stats;
  if (GC_print_stats.40 != 0) goto <D.5652>; else goto <D.5653>;
  <D.5652>:
  n.42 = (long int) n;
  GC_printf ("Failed to grow mark stack to %lu frames\n", n.42, 0, 0, 0, 0, 0);
  <D.5653>:
  <D.5651>:
  goto <D.5655>;
  <D.5627>:
  if (new_stack == 0B) goto <D.5656>; else goto <D.5657>;
  <D.5656>:
  GC_err_puts ("No space for mark stack\n");
  exit (1);
  <D.5657>:
  GC_mark_stack = new_stack;
  GC_mark_stack_size = n;
  D.5645 = n * 8;
  GC_mark_stack_limit.39 = new_stack + D.5645;
  GC_mark_stack_limit = GC_mark_stack_limit.39;
  <D.5655>:
  GC_mark_stack.36 = GC_mark_stack;
  GC_mark_stack_top.43 = GC_mark_stack.36 + 4294967288;
  GC_mark_stack_top = GC_mark_stack_top.43;
}


GC_mark_stack_empty ()
{
  GC_bool D.5659;
  struct mse * GC_mark_stack_top.44;
  struct mse * GC_mark_stack.45;
  _Bool D.5662;

  GC_mark_stack_top.44 = GC_mark_stack_top;
  GC_mark_stack.45 = GC_mark_stack;
  D.5662 = GC_mark_stack_top.44 < GC_mark_stack.45;
  D.5659 = (GC_bool) D.5662;
  return D.5659;
}


GC_find_start (char * current, struct hdr * hhdr, struct hdr * * new_hdr_p)
{
  int GC_all_interior_pointers.46;
  long unsigned int current.47;
  long unsigned int D.5670;
  long unsigned int hhdr.48;
  long unsigned int D.5672;
  sizetype D.5673;
  long unsigned int D.5674;
  struct bottom_index * D.5675;
  long unsigned int D.5676;
  long unsigned int D.5677;
  unsigned char D.5678;
  int D.5679;
  int D.5680;
  char * D.5683;
  int orig.49;
  int current.50;
  int D.5686;
  int D.5687;
  long unsigned int D.5688;
  int D.5689;

  GC_all_interior_pointers.46 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.46 != 0) goto <D.5665>; else goto <D.5666>;
  <D.5665>:
  if (hhdr != 0B) goto <D.5667>; else goto <D.5668>;
  <D.5667>:
  {
    register char * orig;

    orig = current;
    current.47 = (long unsigned int) current;
    D.5670 = current.47 & 4294963200;
    current = (char *) D.5670;
    <D.5221>:
    hhdr.48 = (long unsigned int) hhdr;
    D.5672 = hhdr.48 * 4096;
    D.5673 = -D.5672;
    current = current + D.5673;
    current.47 = (long unsigned int) current;
    D.5674 = current.47 >> 22;
    D.5675 = GC_arrays._top_index[D.5674];
    current.47 = (long unsigned int) current;
    D.5676 = current.47 >> 12;
    D.5677 = D.5676 & 1023;
    hhdr = D.5675->index[D.5677];
    hhdr.48 = (long unsigned int) hhdr;
    if (hhdr.48 <= 4095) goto <D.5221>; else goto <D.5222>;
    <D.5222>:
    D.5678 = hhdr->hb_flags;
    D.5679 = (int) D.5678;
    D.5680 = D.5679 & 1;
    if (D.5680 != 0) goto <D.5681>; else goto <D.5682>;
    <D.5681>:
    D.5683 = orig;
    return D.5683;
    <D.5682>:
    orig.49 = (int) orig;
    current.50 = (int) current;
    D.5686 = orig.49 - current.50;
    D.5687 = D.5686 /[ex] 4;
    D.5688 = hhdr->hb_sz;
    D.5689 = (int) D.5688;
    if (D.5687 >= D.5689) goto <D.5690>; else goto <D.5691>;
    <D.5690>:
    D.5683 = orig;
    return D.5683;
    <D.5691>:
    *new_hdr_p = hhdr;
    D.5683 = current;
    return D.5683;
  }
  <D.5668>:
  D.5683 = current;
  return D.5683;
  <D.5666>:
  D.5683 = current;
  return D.5683;
}


GC_invalidate_mark_state ()
{
  struct mse * GC_mark_stack.51;
  struct mse * GC_mark_stack_top.52;

  GC_mark_state = 5;
  GC_mark_stack.51 = GC_mark_stack;
  GC_mark_stack_top.52 = GC_mark_stack.51 + 4294967288;
  GC_mark_stack_top = GC_mark_stack_top.52;
}


GC_signal_mark_stack_overflow (struct mse * msp)
{
  int GC_print_stats.53;
  long unsigned int GC_mark_stack_size.54;
  long int GC_mark_stack_size.55;
  struct mse * D.5700;

  GC_mark_state = 5;
  GC_mark_stack_too_small = 1;
  GC_print_stats.53 = GC_print_stats;
  if (GC_print_stats.53 != 0) goto <D.5696>; else goto <D.5697>;
  <D.5696>:
  GC_mark_stack_size.54 = GC_mark_stack_size;
  GC_mark_stack_size.55 = (long int) GC_mark_stack_size.54;
  GC_printf ("Mark stack overflow; current size = %lu entries\n", GC_mark_stack_size.55, 0, 0, 0, 0, 0);
  <D.5697>:
  D.5700 = msp + 4294963200;
  return D.5700;
}


GC_mark_from (struct mse * mark_stack_top, struct mse * mark_stack, struct mse * mark_stack_limit)
{
  long unsigned int D.5702;
  long unsigned int D.5705;
  long unsigned int credit.56;
  long unsigned int D.5707;
  long int descr.57;
  char * current.58;
  long unsigned int my_current.59;
  long unsigned int D.5717;
  long unsigned int D.5718;
  long unsigned int D.5719;
  long unsigned int D.5720;
  long unsigned int D.5724;
  struct bottom_index * D.5725;
  long unsigned int D.5726;
  long unsigned int my_hhdr.60;
  struct hdr * GC_invalid_header.61;
  int my_current.62;
  map_entry_type * D.5733;
  sizetype displ.63;
  map_entry_type * D.5735;
  unsigned char D.5736;
  long unsigned int displ.64;
  long unsigned int D.5742;
  long unsigned int D.5743;
  long unsigned int D.5744;
  int GC_all_interior_pointers.65;
  int D.5756;
  sizetype D.5757;
  int D.5758;
  long unsigned int D.5759;
  long unsigned int D.5761;
  unsigned int displ.66;
  unsigned int D.5768;
  sizetype my_current.67;
  sizetype D.5770;
  sizetype D.5771;
  GC_word * D.5772;
  long unsigned int D.5773;
  long unsigned int D.5774;
  struct GC_ms_entry * (*<Ta6f>) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word) D.5775;
  long unsigned int D.5776;
  sizetype D.5779;
  word * D.5780;
  sizetype D.5784;
  char * D.5785;
  int current_p.68;
  int limit.69;
  int D.5792;
  char * deferred.70;
  long unsigned int my_current.71;
  long unsigned int D.5807;
  long unsigned int D.5808;
  long unsigned int D.5809;
  long unsigned int D.5810;
  long unsigned int D.5814;
  struct bottom_index * D.5815;
  long unsigned int D.5816;
  long unsigned int my_hhdr.72;
  int my_current.73;
  map_entry_type * D.5822;
  sizetype displ.74;
  map_entry_type * D.5824;
  unsigned char D.5825;
  long unsigned int displ.75;
  long unsigned int D.5831;
  long unsigned int D.5832;
  long unsigned int D.5833;
  int D.5844;
  sizetype D.5845;
  int D.5846;
  long unsigned int D.5847;
  long unsigned int D.5849;
  unsigned int displ.76;
  unsigned int D.5856;
  sizetype my_current.77;
  sizetype D.5858;
  sizetype D.5859;
  GC_word * D.5860;
  long unsigned int my_current.78;
  long unsigned int D.5862;
  long unsigned int D.5863;
  long unsigned int D.5864;
  long unsigned int D.5865;
  long unsigned int D.5869;
  struct bottom_index * D.5870;
  long unsigned int D.5871;
  long unsigned int my_hhdr.79;
  int my_current.80;
  map_entry_type * D.5877;
  sizetype displ.81;
  map_entry_type * D.5879;
  unsigned char D.5880;
  long unsigned int displ.82;
  long unsigned int D.5886;
  long unsigned int D.5887;
  long unsigned int D.5888;
  int D.5899;
  sizetype D.5900;
  int D.5901;
  long unsigned int D.5902;
  long unsigned int D.5904;
  unsigned int displ.83;
  unsigned int D.5911;
  sizetype my_current.84;
  sizetype D.5913;
  sizetype D.5914;
  GC_word * D.5915;
  int mark_stack_top.85;
  int mark_stack.86;
  int D.5918;
  int D.5919;
  struct mse * D.5920;
  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.5260>;
      <D.5293>:
      current_p = mark_stack_top->mse_start;
      descr = mark_stack_top->mse_descr;
      retry:
      D.5702 = descr & 4294966787;
      if (D.5702 != 0) goto <D.5703>; else goto <D.5704>;
      <D.5703>:
      {
        word tag;

        tag = descr & 3;
        switch (tag) <default: <D.5788>, case 0: <D.5243>, case 1: <D.5245>, case 2: <D.5261>, case 3: <D.5262>>
        <D.5243>:
        limit = current_p + 508;
        mark_stack_top->mse_start = limit;
        D.5705 = descr + 4294966788;
        mark_stack_top->mse_descr = D.5705;
        limit = limit;
        goto <D.5244>;
        <D.5245>:
        mark_stack_top = mark_stack_top + 4294967288;
        descr = descr & 4294967292;
        credit.56 = (long unsigned int) credit;
        D.5707 = credit.56 + 4294967232;
        credit = (int) D.5707;
        goto <D.5258>;
        <D.5257>:
        descr.57 = (long int) descr;
        if (descr.57 < 0) goto <D.5709>; else goto <D.5710>;
        <D.5709>:
        current = *current_p;
        current.58 = (char *) current;
        if (current.58 >= least_ha) goto <D.5712>; else goto <D.5713>;
        <D.5712>:
        current.58 = (char *) current;
        if (current.58 < greatest_ha) goto <D.5714>; else goto <D.5715>;
        <D.5714>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.59 = (long unsigned int) my_current;
            D.5717 = my_current.59 >> 12;
            D.5718 = D.5717 & 7;
            D.5719 = D.5718 * 8;
            hce = &hdr_cache + D.5719;
            D.5720 = hce->block_addr;
            my_current.59 = (long unsigned int) my_current;
            D.5717 = my_current.59 >> 12;
            if (D.5720 == D.5717) goto <D.5721>; else goto <D.5722>;
            <D.5721>:
            my_hhdr = hce->hce_hdr;
            goto <D.5723>;
            <D.5722>:
            my_current.59 = (long unsigned int) my_current;
            D.5724 = my_current.59 >> 22;
            D.5725 = GC_arrays._top_index[D.5724];
            my_current.59 = (long unsigned int) my_current;
            D.5717 = my_current.59 >> 12;
            D.5726 = D.5717 & 1023;
            my_hhdr = D.5725->index[D.5726];
            my_hhdr.60 = (long unsigned int) my_hhdr;
            if (my_hhdr.60 <= 4095) goto <D.5728>; else goto <D.5729>;
            <D.5728>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.61 = GC_invalid_header;
                  new_hdr = GC_invalid_header.61;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.5731>;
            <D.5729>:
            my_current.59 = (long unsigned int) my_current;
            D.5717 = my_current.59 >> 12;
            hce->block_addr = D.5717;
            hce->hce_hdr = my_hhdr;
            <D.5731>:
            <D.5723>:
          }
          {
            int displ;
            int map_entry;

            my_current.62 = (int) my_current;
            displ = my_current.62 & 4095;
            D.5733 = my_hhdr->hb_map;
            displ.63 = (sizetype) displ;
            D.5735 = D.5733 + displ.63;
            D.5736 = *D.5735;
            map_entry = (int) D.5736;
            displ = displ >> 2;
            if (map_entry > 253) goto <D.5737>; else goto <D.5738>;
            <D.5737>:
            if (map_entry == 254) goto <D.5739>; else goto <D.5740>;
            <D.5739>:
            displ.64 = (long unsigned int) displ;
            D.5742 = my_hhdr->hb_sz;
            D.5743 = displ.64 % D.5742;
            map_entry = (int) D.5743;
            displ = displ - map_entry;
            D.5742 = my_hhdr->hb_sz;
            displ.64 = (long unsigned int) displ;
            D.5744 = D.5742 + displ.64;
            if (D.5744 > 1024) goto <D.5745>; else goto <D.5746>;
            <D.5745>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.5748>; else goto <D.5749>;
            <D.5748>:
            my_current.59 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.59);
            goto <D.5750>;
            <D.5749>:
            my_current.59 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.59);
            <D.5750>:
            goto exit1;
            <D.5746>:
            goto <D.5751>;
            <D.5740>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.5752>; else goto <D.5753>;
            <D.5752>:
            my_current.59 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.59);
            goto <D.5754>;
            <D.5753>:
            my_current.59 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.59);
            <D.5754>:
            goto exit1;
            <D.5751>:
            goto <D.5755>;
            <D.5738>:
            displ = displ - map_entry;
            <D.5755>:
            {
              register word * mark_word_addr;

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

                old = *mark_word_addr;
                D.5758 = displ & 31;
                my_bits = 1 << D.5758;
                D.5759 = old & my_bits;
                if (D.5759 != 0) goto exit1; else goto <D.5760>;
                <D.5760>:
                D.5761 = old | my_bits;
                *mark_word_addr = D.5761;
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.5762>; else goto <D.5763>;
              <D.5762>:
              goto <D.5764>;
              <D.5763>:
              mark_stack_top = mark_stack_top + 8;
              if (mark_stack_top >= mark_stack_limit) goto <D.5765>; else goto <D.5766>;
              <D.5765>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.5766>:
              displ.66 = (unsigned int) displ;
              D.5768 = displ.66 * 4;
              my_current.67 = (sizetype) my_current;
              D.5770 = my_current.67 & 4294963200;
              D.5771 = D.5768 + D.5770;
              D.5772 = (GC_word *) D.5771;
              mark_stack_top->mse_start = D.5772;
              mark_stack_top->mse_descr = _descr;
              <D.5764>:
            }
          }
          exit1:
        }
        <D.5715>:
        <D.5713>:
        <D.5710>:
        descr = descr << 1;
        current_p = current_p + 4;
        <D.5258>:
        if (descr != 0) goto <D.5257>; else goto <D.5259>;
        <D.5259>:
        // predicted unlikely by continue predictor.
        goto <D.5260>;
        <D.5261>:
        mark_stack_top = mark_stack_top + 4294967288;
        credit = credit + -100;
        D.5773 = descr >> 2;
        D.5774 = D.5773 & 63;
        D.5775 = GC_arrays._mark_procs[D.5774];
        D.5776 = descr >> 8;
        mark_stack_top = D.5775 (current_p, mark_stack_top, mark_stack_limit, D.5776);
        // predicted unlikely by continue predictor.
        goto <D.5260>;
        <D.5262>:
        descr.57 = (long int) descr;
        if (descr.57 >= 0) goto <D.5777>; else goto <D.5778>;
        <D.5777>:
        D.5779 = descr + 4294967293;
        D.5780 = current_p + D.5779;
        descr = *D.5780;
        goto <D.5781>;
        <D.5778>:
        {
          char * type_descr;

          type_descr = MEM[(char * *)current_p];
          if (type_descr == 0B) goto <D.5782>; else goto <D.5783>;
          <D.5782>:
          mark_stack_top = mark_stack_top + 4294967288;
          // predicted unlikely by continue predictor.
          goto <D.5260>;
          <D.5783>:
          D.5784 = 4294967283 - descr;
          D.5785 = type_descr + D.5784;
          descr = MEM[(word *)D.5785];
        }
        <D.5781>:
        if (descr == 0) goto <D.5786>; else goto <D.5787>;
        <D.5786>:
        mark_stack_top = mark_stack_top + 4294967288;
        // predicted unlikely by continue predictor.
        goto <D.5260>;
        <D.5787>:
        goto retry;
        <D.5788>:
        <D.5244>:
      }
      goto <D.5789>;
      <D.5704>:
      mark_stack_top = mark_stack_top + 4294967288;
      limit = current_p + descr;
      <D.5789>:
      current_p.68 = (int) current_p;
      limit.69 = (int) limit;
      D.5792 = current_p.68 - limit.69;
      credit = D.5792 + credit;
      limit = limit + 4294967292;
      {
        word deferred;

        <D.5267>:
        deferred = *limit;
        limit = limit + 4294967292;
        deferred.70 = (char *) deferred;
        if (deferred.70 >= least_ha) goto <D.5794>; else goto <D.5795>;
        <D.5794>:
        deferred.70 = (char *) deferred;
        if (deferred.70 < greatest_ha) goto <D.5265>; else goto <D.5796>;
        <D.5796>:
        <D.5795>:
        if (current_p > limit) goto next_object; else goto <D.5797>;
        <D.5797>:
        deferred = *limit;
        limit = limit + 4294967292;
        deferred.70 = (char *) deferred;
        if (deferred.70 >= least_ha) goto <D.5798>; else goto <D.5799>;
        <D.5798>:
        deferred.70 = (char *) deferred;
        if (deferred.70 < greatest_ha) goto <D.5265>; else goto <D.5800>;
        <D.5800>:
        <D.5799>:
        if (current_p > limit) goto next_object; else goto <D.5801>;
        <D.5801>:
        goto <D.5267>;
        <D.5265>:
        goto <D.5280>;
        <D.5279>:
        current = *current_p;
        current.58 = (char *) current;
        if (current.58 >= least_ha) goto <D.5802>; else goto <D.5803>;
        <D.5802>:
        current.58 = (char *) current;
        if (current.58 < greatest_ha) goto <D.5804>; else goto <D.5805>;
        <D.5804>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.71 = (long unsigned int) my_current;
            D.5807 = my_current.71 >> 12;
            D.5808 = D.5807 & 7;
            D.5809 = D.5808 * 8;
            hce = &hdr_cache + D.5809;
            D.5810 = hce->block_addr;
            my_current.71 = (long unsigned int) my_current;
            D.5807 = my_current.71 >> 12;
            if (D.5810 == D.5807) goto <D.5811>; else goto <D.5812>;
            <D.5811>:
            my_hhdr = hce->hce_hdr;
            goto <D.5813>;
            <D.5812>:
            my_current.71 = (long unsigned int) my_current;
            D.5814 = my_current.71 >> 22;
            D.5815 = GC_arrays._top_index[D.5814];
            my_current.71 = (long unsigned int) my_current;
            D.5807 = my_current.71 >> 12;
            D.5816 = D.5807 & 1023;
            my_hhdr = D.5815->index[D.5816];
            my_hhdr.72 = (long unsigned int) my_hhdr;
            if (my_hhdr.72 <= 4095) goto <D.5818>; else goto <D.5819>;
            <D.5818>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.61 = GC_invalid_header;
                  new_hdr = GC_invalid_header.61;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.5820>;
            <D.5819>:
            my_current.71 = (long unsigned int) my_current;
            D.5807 = my_current.71 >> 12;
            hce->block_addr = D.5807;
            hce->hce_hdr = my_hhdr;
            <D.5820>:
            <D.5813>:
          }
          {
            int displ;
            int map_entry;

            my_current.73 = (int) my_current;
            displ = my_current.73 & 4095;
            D.5822 = my_hhdr->hb_map;
            displ.74 = (sizetype) displ;
            D.5824 = D.5822 + displ.74;
            D.5825 = *D.5824;
            map_entry = (int) D.5825;
            displ = displ >> 2;
            if (map_entry > 253) goto <D.5826>; else goto <D.5827>;
            <D.5826>:
            if (map_entry == 254) goto <D.5828>; else goto <D.5829>;
            <D.5828>:
            displ.75 = (long unsigned int) displ;
            D.5831 = my_hhdr->hb_sz;
            D.5832 = displ.75 % D.5831;
            map_entry = (int) D.5832;
            displ = displ - map_entry;
            D.5831 = my_hhdr->hb_sz;
            displ.75 = (long unsigned int) displ;
            D.5833 = D.5831 + displ.75;
            if (D.5833 > 1024) goto <D.5834>; else goto <D.5835>;
            <D.5834>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.5836>; else goto <D.5837>;
            <D.5836>:
            my_current.71 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.71);
            goto <D.5838>;
            <D.5837>:
            my_current.71 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.71);
            <D.5838>:
            goto exit2;
            <D.5835>:
            goto <D.5839>;
            <D.5829>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.5840>; else goto <D.5841>;
            <D.5840>:
            my_current.71 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.71);
            goto <D.5842>;
            <D.5841>:
            my_current.71 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.71);
            <D.5842>:
            goto exit2;
            <D.5839>:
            goto <D.5843>;
            <D.5827>:
            displ = displ - map_entry;
            <D.5843>:
            {
              register word * mark_word_addr;

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

                old = *mark_word_addr;
                D.5846 = displ & 31;
                my_bits = 1 << D.5846;
                D.5847 = old & my_bits;
                if (D.5847 != 0) goto exit2; else goto <D.5848>;
                <D.5848>:
                D.5849 = old | my_bits;
                *mark_word_addr = D.5849;
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.5850>; else goto <D.5851>;
              <D.5850>:
              goto <D.5852>;
              <D.5851>:
              mark_stack_top = mark_stack_top + 8;
              if (mark_stack_top >= mark_stack_limit) goto <D.5853>; else goto <D.5854>;
              <D.5853>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.5854>:
              displ.76 = (unsigned int) displ;
              D.5856 = displ.76 * 4;
              my_current.77 = (sizetype) my_current;
              D.5858 = my_current.77 & 4294963200;
              D.5859 = D.5856 + D.5858;
              D.5860 = (GC_word *) D.5859;
              mark_stack_top->mse_start = D.5860;
              mark_stack_top->mse_descr = _descr;
              <D.5852>:
            }
          }
          exit2:
        }
        <D.5805>:
        <D.5803>:
        current_p = current_p + 4;
        <D.5280>:
        if (current_p <= limit) goto <D.5279>; else goto <D.5281>;
        <D.5281>:
        {
          struct hdr * my_hhdr;
          char * my_current;

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

            my_current.78 = (long unsigned int) my_current;
            D.5862 = my_current.78 >> 12;
            D.5863 = D.5862 & 7;
            D.5864 = D.5863 * 8;
            hce = &hdr_cache + D.5864;
            D.5865 = hce->block_addr;
            my_current.78 = (long unsigned int) my_current;
            D.5862 = my_current.78 >> 12;
            if (D.5865 == D.5862) goto <D.5866>; else goto <D.5867>;
            <D.5866>:
            my_hhdr = hce->hce_hdr;
            goto <D.5868>;
            <D.5867>:
            my_current.78 = (long unsigned int) my_current;
            D.5869 = my_current.78 >> 22;
            D.5870 = GC_arrays._top_index[D.5869];
            my_current.78 = (long unsigned int) my_current;
            D.5862 = my_current.78 >> 12;
            D.5871 = D.5862 & 1023;
            my_hhdr = D.5870->index[D.5871];
            my_hhdr.79 = (long unsigned int) my_hhdr;
            if (my_hhdr.79 <= 4095) goto <D.5873>; else goto <D.5874>;
            <D.5873>:
            {
              struct hdr * new_hdr;

              try
                {
                  GC_invalid_header.61 = GC_invalid_header;
                  new_hdr = GC_invalid_header.61;
                  my_current = GC_find_start (my_current, my_hhdr, &new_hdr);
                  my_hhdr = new_hdr;
                }
              finally
                {
                  new_hdr = {CLOBBER};
                }
            }
            goto <D.5875>;
            <D.5874>:
            my_current.78 = (long unsigned int) my_current;
            D.5862 = my_current.78 >> 12;
            hce->block_addr = D.5862;
            hce->hce_hdr = my_hhdr;
            <D.5875>:
            <D.5868>:
          }
          {
            int displ;
            int map_entry;

            my_current.80 = (int) my_current;
            displ = my_current.80 & 4095;
            D.5877 = my_hhdr->hb_map;
            displ.81 = (sizetype) displ;
            D.5879 = D.5877 + displ.81;
            D.5880 = *D.5879;
            map_entry = (int) D.5880;
            displ = displ >> 2;
            if (map_entry > 253) goto <D.5881>; else goto <D.5882>;
            <D.5881>:
            if (map_entry == 254) goto <D.5883>; else goto <D.5884>;
            <D.5883>:
            displ.82 = (long unsigned int) displ;
            D.5886 = my_hhdr->hb_sz;
            D.5887 = displ.82 % D.5886;
            map_entry = (int) D.5887;
            displ = displ - map_entry;
            D.5886 = my_hhdr->hb_sz;
            displ.82 = (long unsigned int) displ;
            D.5888 = D.5886 + displ.82;
            if (D.5888 > 1024) goto <D.5889>; else goto <D.5890>;
            <D.5889>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.5891>; else goto <D.5892>;
            <D.5891>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.78);
            goto <D.5893>;
            <D.5892>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.78);
            <D.5893>:
            goto exit4;
            <D.5890>:
            goto <D.5894>;
            <D.5884>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.5895>; else goto <D.5896>;
            <D.5895>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.78);
            goto <D.5897>;
            <D.5896>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.78);
            <D.5897>:
            goto exit4;
            <D.5894>:
            goto <D.5898>;
            <D.5882>:
            displ = displ - map_entry;
            <D.5898>:
            {
              register word * mark_word_addr;

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

                old = *mark_word_addr;
                D.5901 = displ & 31;
                my_bits = 1 << D.5901;
                D.5902 = old & my_bits;
                if (D.5902 != 0) goto exit4; else goto <D.5903>;
                <D.5903>:
                D.5904 = old | my_bits;
                *mark_word_addr = D.5904;
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.5905>; else goto <D.5906>;
              <D.5905>:
              goto <D.5907>;
              <D.5906>:
              mark_stack_top = mark_stack_top + 8;
              if (mark_stack_top >= mark_stack_limit) goto <D.5908>; else goto <D.5909>;
              <D.5908>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.5909>:
              displ.83 = (unsigned int) displ;
              D.5911 = displ.83 * 4;
              my_current.84 = (sizetype) my_current;
              D.5913 = my_current.84 & 4294963200;
              D.5914 = D.5911 + D.5913;
              D.5915 = (GC_word *) D.5914;
              mark_stack_top->mse_start = D.5915;
              mark_stack_top->mse_descr = _descr;
              <D.5907>:
            }
          }
          exit4:
        }
        next_object:
      }
      <D.5260>:
      mark_stack_top.85 = (int) mark_stack_top;
      mark_stack.86 = (int) mark_stack;
      D.5918 = mark_stack_top.85 - mark_stack.86;
      D.5919 = D.5918 | credit;
      if (D.5919 >= 0) goto <D.5293>; else goto <D.5294>;
      <D.5294>:
      D.5920 = mark_stack_top;
      return D.5920;
    }
  finally
    {
      hdr_cache = {CLOBBER};
    }
}


GC_mark_init ()
{
  alloc_mark_stack (4096);
}


GC_push_all (char * bottom, char * top)
{
  long unsigned int bottom.87;
  long unsigned int D.5925;
  long unsigned int D.5926;
  long unsigned int top.88;
  long unsigned int D.5928;
  struct mse * GC_mark_stack_top.89;
  struct mse * GC_mark_stack_top.90;
  struct mse * GC_mark_stack_limit.91;
  int top.92;
  int bottom.93;
  int D.5939;
  register word length;

  bottom.87 = (long unsigned int) bottom;
  D.5925 = bottom.87 + 3;
  D.5926 = D.5925 & 4294967292;
  bottom = (char *) D.5926;
  top.88 = (long unsigned int) top;
  D.5928 = top.88 & 4294967292;
  top = (char *) D.5928;
  if (top == 0B) goto <D.5929>; else goto <D.5931>;
  <D.5931>:
  if (bottom == top) goto <D.5929>; else goto <D.5930>;
  <D.5929>:
  return;
  <D.5930>:
  GC_mark_stack_top.89 = GC_mark_stack_top;
  GC_mark_stack_top.90 = GC_mark_stack_top.89 + 8;
  GC_mark_stack_top = GC_mark_stack_top.90;
  GC_mark_stack_top.89 = GC_mark_stack_top;
  GC_mark_stack_limit.91 = GC_mark_stack_limit;
  if (GC_mark_stack_top.89 >= GC_mark_stack_limit.91) goto <D.5935>; else goto <D.5936>;
  <D.5935>:
  GC_abort ("unexpected mark stack overflow");
  <D.5936>:
  top.92 = (int) top;
  bottom.93 = (int) bottom;
  D.5939 = top.92 - bottom.93;
  length = (word) D.5939;
  GC_mark_stack_top.89 = GC_mark_stack_top;
  GC_mark_stack_top.89->mse_start = bottom;
  GC_mark_stack_top.89 = GC_mark_stack_top;
  GC_mark_stack_top.89->mse_descr = length;
}


GC_push_selected (char * bottom, char * top, int (*<Tf17>) (struct hblk *) dirty_fn, void (*<Tf1a>) (char *, char *) push_fn)
{
  long int bottom.94;
  long int D.5942;
  long int D.5943;
  long int top.95;
  long int D.5945;
  char * D.5949;
  long unsigned int D.5950;
  long unsigned int D.5951;
  struct hblk * D.5954;
  int D.5955;
  int D.5958;
  int D.5961;
  struct mse * GC_mark_stack_top.96;
  int GC_mark_stack_top.97;
  struct mse * GC_mark_stack.98;
  int GC_mark_stack.99;
  int D.5968;
  int D.5969;
  long unsigned int D.5970;
  long unsigned int GC_mark_stack_size.100;
  long unsigned int D.5972;
  long unsigned int D.5973;
  char * D.5976;
  int D.5979;
  struct mse * GC_mark_stack_limit.101;
  register struct hblk * h;

  bottom.94 = (long int) bottom;
  D.5942 = bottom.94 + 3;
  D.5943 = D.5942 & -4;
  bottom = (char *) D.5943;
  top.95 = (long int) top;
  D.5945 = top.95 & -4;
  top = (char *) D.5945;
  if (top == 0B) goto <D.5946>; else goto <D.5948>;
  <D.5948>:
  if (bottom == top) goto <D.5946>; else goto <D.5947>;
  <D.5946>:
  return;
  <D.5947>:
  D.5949 = bottom + 4096;
  D.5950 = (long unsigned int) D.5949;
  D.5951 = D.5950 & 4294963200;
  h = (struct hblk *) D.5951;
  if (top <= h) goto <D.5952>; else goto <D.5953>;
  <D.5952>:
  D.5954 = h + 4294963200;
  D.5955 = dirty_fn (D.5954);
  if (D.5955 != 0) goto <D.5956>; else goto <D.5957>;
  <D.5956>:
  push_fn (bottom, top);
  <D.5957>:
  return;
  <D.5953>:
  D.5954 = h + 4294963200;
  D.5958 = dirty_fn (D.5954);
  if (D.5958 != 0) goto <D.5959>; else goto <D.5960>;
  <D.5959>:
  push_fn (bottom, h);
  <D.5960>:
  goto <D.5319>;
  <D.5318>:
  D.5961 = dirty_fn (h);
  if (D.5961 != 0) goto <D.5962>; else goto <D.5963>;
  <D.5962>:
  GC_mark_stack_top.96 = GC_mark_stack_top;
  GC_mark_stack_top.97 = (int) GC_mark_stack_top.96;
  GC_mark_stack.98 = GC_mark_stack;
  GC_mark_stack.99 = (int) GC_mark_stack.98;
  D.5968 = GC_mark_stack_top.97 - GC_mark_stack.99;
  D.5969 = D.5968 /[ex] 8;
  D.5970 = (long unsigned int) D.5969;
  GC_mark_stack_size.100 = GC_mark_stack_size;
  D.5972 = GC_mark_stack_size.100 * 3;
  D.5973 = D.5972 / 4;
  if (D.5970 > D.5973) goto <D.5974>; else goto <D.5975>;
  <D.5974>:
  push_fn (h, top);
  return;
  <D.5975>:
  D.5976 = h + 4096;
  push_fn (h, D.5976);
  <D.5963>:
  h = h + 4096;
  <D.5319>:
  D.5976 = h + 4096;
  if (D.5976 <= top) goto <D.5318>; else goto <D.5320>;
  <D.5320>:
  if (h != top) goto <D.5977>; else goto <D.5978>;
  <D.5977>:
  D.5979 = dirty_fn (h);
  if (D.5979 != 0) goto <D.5980>; else goto <D.5981>;
  <D.5980>:
  push_fn (h, top);
  <D.5981>:
  <D.5978>:
  GC_mark_stack_top.96 = GC_mark_stack_top;
  GC_mark_stack_limit.101 = GC_mark_stack_limit;
  if (GC_mark_stack_top.96 >= GC_mark_stack_limit.101) goto <D.5983>; else goto <D.5984>;
  <D.5983>:
  GC_abort ("unexpected mark stack overflow");
  <D.5984>:
}


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

  if (all != 0) goto <D.5986>; else goto <D.5987>;
  <D.5986>:
  GC_dirty_maintained.102 = GC_dirty_maintained;
  if (GC_dirty_maintained.102 != 0) goto <D.5989>; else goto <D.5990>;
  <D.5989>:
  GC_push_all (bottom, top);
  goto <D.5991>;
  <D.5990>:
  GC_push_all (bottom, top);
  <D.5991>:
  goto <D.5992>;
  <D.5987>:
  GC_push_selected (bottom, top, GC_page_was_dirty, GC_push_all);
  <D.5992>:
}


GC_push_one (word p)
{
  char * p.103;
  void * GC_least_plausible_heap_addr.104;
  void * GC_greatest_plausible_heap_addr.105;

  p.103 = (char *) p;
  GC_least_plausible_heap_addr.104 = GC_least_plausible_heap_addr;
  if (p.103 >= GC_least_plausible_heap_addr.104) goto <D.5995>; else goto <D.5996>;
  <D.5995>:
  p.103 = (char *) p;
  GC_greatest_plausible_heap_addr.105 = GC_greatest_plausible_heap_addr;
  if (p.103 < GC_greatest_plausible_heap_addr.105) goto <D.5998>; else goto <D.5999>;
  <D.5998>:
  GC_mark_and_push_stack (p);
  <D.5999>:
  <D.5996>:
}


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.106;
  long unsigned int D.6001;
  struct bottom_index * D.6002;
  long unsigned int D.6003;
  long unsigned int D.6004;
  long unsigned int my_hhdr.107;
  struct hdr * GC_invalid_header.108;
  int my_current.109;
  map_entry_type * D.6010;
  sizetype displ.110;
  map_entry_type * D.6012;
  unsigned char D.6013;
  long unsigned int displ.111;
  long unsigned int D.6019;
  long unsigned int D.6020;
  long unsigned int D.6021;
  int GC_all_interior_pointers.112;
  int D.6033;
  sizetype D.6034;
  int D.6035;
  long unsigned int D.6036;
  long unsigned int D.6038;
  unsigned int displ.113;
  unsigned int D.6045;
  sizetype my_current.114;
  sizetype D.6047;
  sizetype D.6048;
  GC_word * D.6049;
  struct GC_ms_entry * D.6050;
  void was_marked = <<< error >>>;

  {
    struct hdr * my_hhdr;
    char * my_current;

    my_current = obj;
    my_current.106 = (long unsigned int) my_current;
    D.6001 = my_current.106 >> 22;
    D.6002 = GC_arrays._top_index[D.6001];
    my_current.106 = (long unsigned int) my_current;
    D.6003 = my_current.106 >> 12;
    D.6004 = D.6003 & 1023;
    my_hhdr = D.6002->index[D.6004];
    my_hhdr.107 = (long unsigned int) my_hhdr;
    if (my_hhdr.107 <= 4095) goto <D.6006>; else goto <D.6007>;
    <D.6006>:
    {
      struct hdr * new_hdr;

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

      my_current.109 = (int) my_current;
      displ = my_current.109 & 4095;
      D.6010 = my_hhdr->hb_map;
      displ.110 = (sizetype) displ;
      D.6012 = D.6010 + displ.110;
      D.6013 = *D.6012;
      map_entry = (int) D.6013;
      displ = displ >> 2;
      if (map_entry > 253) goto <D.6014>; else goto <D.6015>;
      <D.6014>:
      if (map_entry == 254) goto <D.6016>; else goto <D.6017>;
      <D.6016>:
      displ.111 = (long unsigned int) displ;
      D.6019 = my_hhdr->hb_sz;
      D.6020 = displ.111 % D.6019;
      map_entry = (int) D.6020;
      displ = displ - map_entry;
      D.6019 = my_hhdr->hb_sz;
      displ.111 = (long unsigned int) displ;
      D.6021 = D.6019 + displ.111;
      if (D.6021 > 1024) goto <D.6022>; else goto <D.6023>;
      <D.6022>:
      GC_all_interior_pointers.112 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.112 != 0) goto <D.6025>; else goto <D.6026>;
      <D.6025>:
      my_current.106 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.106);
      goto <D.6027>;
      <D.6026>:
      my_current.106 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.106);
      <D.6027>:
      goto was_marked;
      <D.6023>:
      goto <D.6028>;
      <D.6017>:
      GC_all_interior_pointers.112 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.112 != 0) goto <D.6029>; else goto <D.6030>;
      <D.6029>:
      my_current.106 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.106);
      goto <D.6031>;
      <D.6030>:
      my_current.106 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.106);
      <D.6031>:
      goto was_marked;
      <D.6028>:
      goto <D.6032>;
      <D.6015>:
      displ = displ - map_entry;
      <D.6032>:
      {
        register word * mark_word_addr;

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

          old = *mark_word_addr;
          D.6035 = displ & 31;
          my_bits = 1 << D.6035;
          D.6036 = old & my_bits;
          if (D.6036 != 0) goto was_marked; else goto <D.6037>;
          <D.6037>:
          D.6038 = old | my_bits;
          *mark_word_addr = D.6038;
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.6039>; else goto <D.6040>;
        <D.6039>:
        goto <D.6041>;
        <D.6040>:
        mark_stack_ptr = mark_stack_ptr + 8;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.6042>; else goto <D.6043>;
        <D.6042>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.6043>:
        displ.113 = (unsigned int) displ;
        D.6045 = displ.113 * 4;
        my_current.114 = (sizetype) my_current;
        D.6047 = my_current.114 & 4294963200;
        D.6048 = D.6045 + D.6047;
        D.6049 = (GC_word *) D.6048;
        mark_stack_ptr->mse_start = D.6049;
        mark_stack_ptr->mse_descr = _descr;
        <D.6041>:
      }
    }
    was_marked:
  }
  D.6050 = mark_stack_ptr;
  return D.6050;
}


GC_mark_and_push_stack (word p)
{
  long unsigned int D.6052;
  struct bottom_index * D.6053;
  long unsigned int D.6054;
  long unsigned int D.6055;
  long unsigned int hhdr.115;
  void * p.116;
  void * D.6062;
  long unsigned int D.6063;
  struct bottom_index * D.6064;
  long unsigned int D.6065;
  long unsigned int D.6066;
  long unsigned int D.6067;
  long unsigned int D.6068;
  int p.117;
  map_entry_type * D.6071;
  sizetype displ.118;
  map_entry_type * D.6073;
  int GC_all_interior_pointers.119;
  void * D.6081;
  int D.6085;
  unsigned int displ.120;
  unsigned int D.6087;
  sizetype D.6088;
  int D.6092;
  long unsigned int D.6093;
  int D.6094;
  long unsigned int D.6095;
  long unsigned int D.6096;
  sizetype D.6099;
  long unsigned int D.6100;
  long unsigned int D.6101;
  long unsigned int D.6102;
  struct mse * GC_mark_stack_top.121;
  struct mse * GC_mark_stack_top.122;
  struct mse * GC_mark_stack_limit.123;
  struct mse * GC_mark_stack_top.124;
  GC_word * r.125;
  register word r;
  register struct hdr * hhdr;
  register int displ;

  D.6052 = p >> 22;
  D.6053 = GC_arrays._top_index[D.6052];
  D.6054 = p >> 12;
  D.6055 = D.6054 & 1023;
  hhdr = D.6053->index[D.6055];
  hhdr.115 = (long unsigned int) hhdr;
  if (hhdr.115 <= 4095) goto <D.6057>; else goto <D.6058>;
  <D.6057>:
  if (hhdr != 0B) goto <D.6059>; else goto <D.6060>;
  <D.6059>:
  p.116 = (void *) p;
  D.6062 = GC_base (p.116);
  r = (word) D.6062;
  D.6063 = r >> 22;
  D.6064 = GC_arrays._top_index[D.6063];
  D.6065 = r >> 12;
  D.6066 = D.6065 & 1023;
  hhdr = D.6064->index[D.6066];
  D.6067 = r & 4095;
  D.6068 = D.6067 >> 2;
  displ = (int) D.6068;
  <D.6060>:
  goto <D.6069>;
  <D.6058>:
  {
    register map_entry_type map_entry;

    p.117 = (int) p;
    displ = p.117 & 4095;
    D.6071 = hhdr->hb_map;
    displ.118 = (sizetype) displ;
    D.6073 = D.6071 + displ.118;
    map_entry = *D.6073;
    if (map_entry > 252) goto <D.6074>; else goto <D.6075>;
    <D.6074>:
    if (map_entry == 254) goto <D.6076>; else goto <D.6079>;
    <D.6079>:
    GC_all_interior_pointers.119 = GC_all_interior_pointers;
    if (GC_all_interior_pointers.119 == 0) goto <D.6076>; else goto <D.6077>;
    <D.6076>:
    p.116 = (void *) p;
    D.6081 = GC_base (p.116);
    r = (word) D.6081;
    D.6067 = r & 4095;
    D.6068 = D.6067 >> 2;
    displ = (int) D.6068;
    if (r == 0) goto <D.6082>; else goto <D.6083>;
    <D.6082>:
    hhdr = 0B;
    <D.6083>:
    goto <D.6078>;
    <D.6077>:
    hhdr = 0B;
    <D.6078>:
    goto <D.6084>;
    <D.6075>:
    displ = displ >> 2;
    D.6085 = (int) map_entry;
    displ = displ - D.6085;
    displ.120 = (unsigned int) displ;
    D.6087 = displ.120 * 4;
    D.6088 = p & 4294963200;
    r = D.6087 + D.6088;
    <D.6084>:
  }
  <D.6069>:
  if (hhdr == 0B) goto <D.6089>; else goto <D.6090>;
  <D.6089>:
  GC_add_to_black_list_stack (p);
  goto <D.6091>;
  <D.6090>:
  D.6092 = displ >> 5;
  D.6093 = hhdr->hb_marks[D.6092];
  D.6094 = displ & 31;
  D.6095 = D.6093 >> D.6094;
  D.6096 = D.6095 & 1;
  if (D.6096 == 0) goto <D.6097>; else goto <D.6098>;
  <D.6097>:
  D.6092 = displ >> 5;
  D.6099 = (sizetype) D.6092;
  D.6092 = displ >> 5;
  D.6099 = (sizetype) D.6092;
  D.6100 = hhdr->hb_marks[D.6099];
  D.6094 = displ & 31;
  D.6101 = 1 << D.6094;
  D.6102 = D.6100 | D.6101;
  hhdr->hb_marks[D.6099] = D.6102;
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.6103>; else goto <D.6104>;
    <D.6103>:
    goto <D.6105>;
    <D.6104>:
    GC_mark_stack_top.121 = GC_mark_stack_top;
    GC_mark_stack_top.122 = GC_mark_stack_top.121 + 8;
    GC_mark_stack_top = GC_mark_stack_top.122;
    GC_mark_stack_top.121 = GC_mark_stack_top;
    GC_mark_stack_limit.123 = GC_mark_stack_limit;
    if (GC_mark_stack_top.121 >= GC_mark_stack_limit.123) goto <D.6109>; else goto <D.6110>;
    <D.6109>:
    GC_mark_stack_top.121 = GC_mark_stack_top;
    GC_mark_stack_top.124 = GC_signal_mark_stack_overflow (GC_mark_stack_top.121);
    GC_mark_stack_top = GC_mark_stack_top.124;
    <D.6110>:
    GC_mark_stack_top.121 = GC_mark_stack_top;
    r.125 = (GC_word *) r;
    GC_mark_stack_top.121->mse_start = r.125;
    GC_mark_stack_top.121 = GC_mark_stack_top;
    GC_mark_stack_top.121->mse_descr = _descr;
    <D.6105>:
  }
  <D.6098>:
  <D.6091>:
}


GC_push_all_eager (char * bottom, char * top)
{
  long unsigned int bottom.126;
  long unsigned int D.6114;
  long unsigned int D.6115;
  long unsigned int top.127;
  long unsigned int D.6117;
  char * q.128;
  word * b;
  word * t;
  register word * p;
  register word q;
  register word * lim;
  register char * greatest_ha;
  register char * least_ha;

  bottom.126 = (long unsigned int) bottom;
  D.6114 = bottom.126 + 3;
  D.6115 = D.6114 & 4294967292;
  b = (word *) D.6115;
  top.127 = (long unsigned int) top;
  D.6117 = top.127 & 4294967292;
  t = (word *) D.6117;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  if (top == 0B) goto <D.6118>; else goto <D.6119>;
  <D.6118>:
  return;
  <D.6119>:
  lim = t + 4294967292;
  p = b;
  goto <D.5365>;
  <D.5364>:
  q = *p;
  q.128 = (char *) q;
  if (q.128 >= least_ha) goto <D.6121>; else goto <D.6122>;
  <D.6121>:
  q.128 = (char *) q;
  if (q.128 < greatest_ha) goto <D.6123>; else goto <D.6124>;
  <D.6123>:
  GC_mark_and_push_stack (q);
  <D.6124>:
  <D.6122>:
  p = p + 4;
  <D.5365>:
  if (p <= lim) goto <D.5364>; else goto <D.5366>;
  <D.5366>:
}


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

  GC_all_interior_pointers.129 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.129 != 0) goto <D.6127>; else goto <D.6128>;
  <D.6127>:
  GC_push_all (bottom, top);
  goto <D.6129>;
  <D.6128>:
  GC_push_all_eager (bottom, top);
  <D.6129>:
}


GC_push_marked1 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.130;
  long unsigned int D.6131;
  word * mark_word_addr.131;
  long unsigned int D.6133;
  unsigned int i.132;
  unsigned int D.6137;
  word * D.6138;
  char * q.133;
  void * q.134;
  void * * D.6145;
  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.130 = (long unsigned int) h;
  D.6131 = h.130 + 4096;
  plim = (word *) D.6131;
  goto <D.5389>;
  <D.5388>:
  mark_word_addr.131 = mark_word_addr;
  mark_word_addr = mark_word_addr.131 + 4;
  mark_word = *mark_word_addr.131;
  i = 0;
  goto <D.5386>;
  <D.5385>:
  D.6133 = mark_word & 1;
  if (D.6133 != 0) goto <D.6134>; else goto <D.6135>;
  <D.6134>:
  i.132 = (unsigned int) i;
  D.6137 = i.132 * 4;
  D.6138 = p + D.6137;
  q = *D.6138;
  q.133 = (char *) q;
  if (q.133 >= least_ha) goto <D.6140>; else goto <D.6141>;
  <D.6140>:
  q.133 = (char *) q;
  if (q.133 < greatest_ha) goto <D.6142>; else goto <D.6143>;
  <D.6142>:
  q.134 = (void *) q;
  i.132 = (unsigned int) i;
  D.6137 = i.132 * 4;
  D.6145 = p + D.6137;
  mark_stack_top = GC_mark_and_push (q.134, mark_stack_top, mark_stack_limit, D.6145);
  <D.6143>:
  <D.6141>:
  <D.6135>:
  i = i + 1;
  mark_word = mark_word >> 1;
  <D.5386>:
  if (mark_word != 0) goto <D.5385>; else goto <D.5387>;
  <D.5387>:
  p = p + 128;
  <D.5389>:
  if (p < plim) goto <D.5388>; else goto <D.5390>;
  <D.5390>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked2 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.135;
  long unsigned int D.6147;
  word * mark_word_addr.136;
  long unsigned int D.6149;
  unsigned int i.137;
  unsigned int D.6153;
  word * D.6154;
  char * q.138;
  void * q.139;
  void * * D.6161;
  sizetype i.140;
  sizetype D.6163;
  sizetype D.6164;
  word * D.6165;
  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.135 = (long unsigned int) h;
  D.6147 = h.135 + 4096;
  plim = (word *) D.6147;
  goto <D.5409>;
  <D.5408>:
  mark_word_addr.136 = mark_word_addr;
  mark_word_addr = mark_word_addr.136 + 4;
  mark_word = *mark_word_addr.136;
  i = 0;
  goto <D.5406>;
  <D.5405>:
  D.6149 = mark_word & 1;
  if (D.6149 != 0) goto <D.6150>; else goto <D.6151>;
  <D.6150>:
  i.137 = (unsigned int) i;
  D.6153 = i.137 * 4;
  D.6154 = p + D.6153;
  q = *D.6154;
  q.138 = (char *) q;
  if (q.138 >= least_ha) goto <D.6156>; else goto <D.6157>;
  <D.6156>:
  q.138 = (char *) q;
  if (q.138 < greatest_ha) goto <D.6158>; else goto <D.6159>;
  <D.6158>:
  q.139 = (void *) q;
  i.137 = (unsigned int) i;
  D.6153 = i.137 * 4;
  D.6161 = p + D.6153;
  mark_stack_top = GC_mark_and_push (q.139, mark_stack_top, mark_stack_limit, D.6161);
  <D.6159>:
  <D.6157>:
  i.140 = (sizetype) i;
  D.6163 = i.140 + 1;
  D.6164 = D.6163 * 4;
  D.6165 = p + D.6164;
  q = *D.6165;
  q.138 = (char *) q;
  if (q.138 >= least_ha) goto <D.6166>; else goto <D.6167>;
  <D.6166>:
  q.138 = (char *) q;
  if (q.138 < greatest_ha) goto <D.6168>; else goto <D.6169>;
  <D.6168>:
  q.139 = (void *) q;
  i.137 = (unsigned int) i;
  D.6153 = i.137 * 4;
  D.6161 = p + D.6153;
  mark_stack_top = GC_mark_and_push (q.139, mark_stack_top, mark_stack_limit, D.6161);
  <D.6169>:
  <D.6167>:
  <D.6151>:
  i = i + 2;
  mark_word = mark_word >> 2;
  <D.5406>:
  if (mark_word != 0) goto <D.5405>; else goto <D.5407>;
  <D.5407>:
  p = p + 128;
  <D.5409>:
  if (p < plim) goto <D.5408>; else goto <D.5410>;
  <D.5410>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked4 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.141;
  long unsigned int D.6171;
  word * mark_word_addr.142;
  long unsigned int D.6173;
  unsigned int i.143;
  unsigned int D.6177;
  word * D.6178;
  char * q.144;
  void * q.145;
  void * * D.6185;
  sizetype i.146;
  sizetype D.6187;
  sizetype D.6188;
  word * D.6189;
  sizetype D.6194;
  sizetype D.6195;
  word * D.6196;
  sizetype D.6201;
  sizetype D.6202;
  word * D.6203;
  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.141 = (long unsigned int) h;
  D.6171 = h.141 + 4096;
  plim = (word *) D.6171;
  goto <D.5429>;
  <D.5428>:
  mark_word_addr.142 = mark_word_addr;
  mark_word_addr = mark_word_addr.142 + 4;
  mark_word = *mark_word_addr.142;
  i = 0;
  goto <D.5426>;
  <D.5425>:
  D.6173 = mark_word & 1;
  if (D.6173 != 0) goto <D.6174>; else goto <D.6175>;
  <D.6174>:
  i.143 = (unsigned int) i;
  D.6177 = i.143 * 4;
  D.6178 = p + D.6177;
  q = *D.6178;
  q.144 = (char *) q;
  if (q.144 >= least_ha) goto <D.6180>; else goto <D.6181>;
  <D.6180>:
  q.144 = (char *) q;
  if (q.144 < greatest_ha) goto <D.6182>; else goto <D.6183>;
  <D.6182>:
  q.145 = (void *) q;
  i.143 = (unsigned int) i;
  D.6177 = i.143 * 4;
  D.6185 = p + D.6177;
  mark_stack_top = GC_mark_and_push (q.145, mark_stack_top, mark_stack_limit, D.6185);
  <D.6183>:
  <D.6181>:
  i.146 = (sizetype) i;
  D.6187 = i.146 + 1;
  D.6188 = D.6187 * 4;
  D.6189 = p + D.6188;
  q = *D.6189;
  q.144 = (char *) q;
  if (q.144 >= least_ha) goto <D.6190>; else goto <D.6191>;
  <D.6190>:
  q.144 = (char *) q;
  if (q.144 < greatest_ha) goto <D.6192>; else goto <D.6193>;
  <D.6192>:
  q.145 = (void *) q;
  i.146 = (sizetype) i;
  D.6187 = i.146 + 1;
  D.6188 = D.6187 * 4;
  D.6189 = p + D.6188;
  mark_stack_top = GC_mark_and_push (q.145, mark_stack_top, mark_stack_limit, D.6189);
  <D.6193>:
  <D.6191>:
  i.146 = (sizetype) i;
  D.6194 = i.146 + 2;
  D.6195 = D.6194 * 4;
  D.6196 = p + D.6195;
  q = *D.6196;
  q.144 = (char *) q;
  if (q.144 >= least_ha) goto <D.6197>; else goto <D.6198>;
  <D.6197>:
  q.144 = (char *) q;
  if (q.144 < greatest_ha) goto <D.6199>; else goto <D.6200>;
  <D.6199>:
  q.145 = (void *) q;
  i.146 = (sizetype) i;
  D.6194 = i.146 + 2;
  D.6195 = D.6194 * 4;
  D.6196 = p + D.6195;
  mark_stack_top = GC_mark_and_push (q.145, mark_stack_top, mark_stack_limit, D.6196);
  <D.6200>:
  <D.6198>:
  i.146 = (sizetype) i;
  D.6201 = i.146 + 3;
  D.6202 = D.6201 * 4;
  D.6203 = p + D.6202;
  q = *D.6203;
  q.144 = (char *) q;
  if (q.144 >= least_ha) goto <D.6204>; else goto <D.6205>;
  <D.6204>:
  q.144 = (char *) q;
  if (q.144 < greatest_ha) goto <D.6206>; else goto <D.6207>;
  <D.6206>:
  q.145 = (void *) q;
  i.146 = (sizetype) i;
  D.6201 = i.146 + 3;
  D.6202 = D.6201 * 4;
  D.6203 = p + D.6202;
  mark_stack_top = GC_mark_and_push (q.145, mark_stack_top, mark_stack_limit, D.6203);
  <D.6207>:
  <D.6205>:
  <D.6175>:
  i = i + 4;
  mark_word = mark_word >> 4;
  <D.5426>:
  if (mark_word != 0) goto <D.5425>; else goto <D.5427>;
  <D.5427>:
  p = p + 128;
  <D.5429>:
  if (p < plim) goto <D.5428>; else goto <D.5430>;
  <D.5430>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.6208;
  long unsigned int D.6209;
  int D.6212;
  long unsigned int GC_n_rescuing_pages.147;
  long unsigned int GC_n_rescuing_pages.148;
  long unsigned int sz.149;
  sizetype sz.150;
  sizetype D.6222;
  sizetype D.6223;
  int D.6224;
  long unsigned int D.6225;
  int D.6226;
  long unsigned int D.6227;
  long unsigned int D.6228;
  unsigned int sz.151;
  unsigned int D.6237;
  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.6208 = hhdr->hb_sz;
  sz = (int) D.6208;
  D.6209 = hhdr->hb_descr;
  descr = (int) D.6209;
  mark_stack_limit = GC_mark_stack_limit;
  if (descr == 0) goto <D.6210>; else goto <D.6211>;
  <D.6210>:
  return;
  <D.6211>:
  D.6212 = GC_block_empty (hhdr);
  if (D.6212 != 0) goto <D.6213>; else goto <D.6214>;
  <D.6213>:
  return;
  <D.6214>:
  GC_n_rescuing_pages.147 = GC_n_rescuing_pages;
  GC_n_rescuing_pages.148 = GC_n_rescuing_pages.147 + 1;
  GC_n_rescuing_pages = GC_n_rescuing_pages.148;
  GC_objects_are_marked = 1;
  sz.149 = (long unsigned int) sz;
  if (sz.149 > 512) goto <D.6218>; else goto <D.6219>;
  <D.6218>:
  lim = h;
  goto <D.6220>;
  <D.6219>:
  sz.150 = (sizetype) sz;
  D.6222 = sz.150 * 4294967292;
  D.6223 = D.6222 + 4096;
  lim = h + D.6223;
  <D.6220>:
  switch (sz) <default: <D.5446>, case 1: <D.5442>, case 2: <D.5444>, case 4: <D.5445>>
  <D.5442>:
  GC_push_marked1 (h, hhdr);
  goto <D.5443>;
  <D.5444>:
  GC_push_marked2 (h, hhdr);
  goto <D.5443>;
  <D.5445>:
  GC_push_marked4 (h, hhdr);
  goto <D.5443>;
  <D.5446>:
  GC_mark_stack_top_reg = GC_mark_stack_top;
  p = h;
  word_no = 0;
  goto <D.5449>;
  <D.5448>:
  D.6224 = word_no >> 5;
  D.6225 = hhdr->hb_marks[D.6224];
  D.6226 = word_no & 31;
  D.6227 = D.6225 >> D.6226;
  D.6228 = D.6227 & 1;
  if (D.6228 != 0) goto <D.6229>; else goto <D.6230>;
  <D.6229>:
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.6231>; else goto <D.6232>;
    <D.6231>:
    goto <D.6233>;
    <D.6232>:
    GC_mark_stack_top_reg = GC_mark_stack_top_reg + 8;
    if (GC_mark_stack_top_reg >= mark_stack_limit) goto <D.6234>; else goto <D.6235>;
    <D.6234>:
    GC_mark_stack_top_reg = GC_signal_mark_stack_overflow (GC_mark_stack_top_reg);
    <D.6235>:
    GC_mark_stack_top_reg->mse_start = p;
    GC_mark_stack_top_reg->mse_descr = _descr;
    <D.6233>:
  }
  <D.6230>:
  sz.151 = (unsigned int) sz;
  D.6237 = sz.151 * 4;
  p = p + D.6237;
  word_no = word_no + sz;
  <D.5449>:
  if (p <= lim) goto <D.5448>; else goto <D.5450>;
  <D.5450>:
  GC_mark_stack_top = GC_mark_stack_top_reg;
  <D.5443>:
}


GC_block_was_dirty (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.6239;
  long unsigned int sz.152;
  GC_bool D.6243;
  int D.6244;
  sizetype sz.153;
  char * D.6248;
  register int sz;

  D.6239 = hhdr->hb_sz;
  sz = (int) D.6239;
  sz.152 = (long unsigned int) sz;
  if (sz.152 <= 512) goto <D.6241>; else goto <D.6242>;
  <D.6241>:
  D.6243 = GC_page_was_dirty (h);
  return D.6243;
  <D.6242>:
  {
    register char * p;

    p = h;
    sz = sz << 2;
    goto <D.5458>;
    <D.5457>:
    D.6244 = GC_page_was_dirty (p);
    if (D.6244 != 0) goto <D.6245>; else goto <D.6246>;
    <D.6245>:
    D.6243 = 1;
    return D.6243;
    <D.6246>:
    p = p + 4096;
    <D.5458>:
    sz.153 = (sizetype) sz;
    D.6248 = h + sz.153;
    if (D.6248 > p) goto <D.5457>; else goto <D.5459>;
    <D.5459>:
    D.6243 = 0;
    return D.6243;
  }
}


GC_push_next_marked (struct hblk * h)
{
  struct hblk * D.6252;
  long unsigned int h.154;
  long unsigned int D.6254;
  struct bottom_index * D.6255;
  long unsigned int D.6256;
  long unsigned int D.6257;
  long unsigned int D.6258;
  long unsigned int D.6259;
  long unsigned int D.6260;
  long unsigned int D.6261;
  long unsigned int D.6262;
  register struct hdr * hhdr;

  h = GC_next_used_block (h);
  if (h == 0B) goto <D.6250>; else goto <D.6251>;
  <D.6250>:
  D.6252 = 0B;
  return D.6252;
  <D.6251>:
  h.154 = (long unsigned int) h;
  D.6254 = h.154 >> 22;
  D.6255 = GC_arrays._top_index[D.6254];
  h.154 = (long unsigned int) h;
  D.6256 = h.154 >> 12;
  D.6257 = D.6256 & 1023;
  hhdr = D.6255->index[D.6257];
  GC_push_marked (h, hhdr);
  D.6258 = hhdr->hb_sz;
  D.6259 = D.6258 << 2;
  D.6260 = D.6259 + 4095;
  D.6261 = D.6260 >> 12;
  D.6262 = D.6261 * 4096;
  D.6252 = h + D.6262;
  return D.6252;
}


GC_push_next_marked_dirty (struct hblk * h)
{
  int GC_dirty_maintained.155;
  struct hblk * D.6269;
  long unsigned int h.156;
  long unsigned int D.6271;
  struct bottom_index * D.6272;
  long unsigned int D.6273;
  long unsigned int D.6274;
  int D.6275;
  long unsigned int D.6277;
  long unsigned int D.6278;
  long unsigned int D.6279;
  long unsigned int D.6280;
  long unsigned int D.6281;
  register struct hdr * hhdr;

  GC_dirty_maintained.155 = GC_dirty_maintained;
  if (GC_dirty_maintained.155 == 0) goto <D.6265>; else goto <D.6266>;
  <D.6265>:
  GC_abort ("dirty bits not set up");
  <D.6266>:
  <D.5469>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.6267>; else goto <D.6268>;
  <D.6267>:
  D.6269 = 0B;
  return D.6269;
  <D.6268>:
  h.156 = (long unsigned int) h;
  D.6271 = h.156 >> 22;
  D.6272 = GC_arrays._top_index[D.6271];
  h.156 = (long unsigned int) h;
  D.6273 = h.156 >> 12;
  D.6274 = D.6273 & 1023;
  hhdr = D.6272->index[D.6274];
  D.6275 = GC_block_was_dirty (h, hhdr);
  if (D.6275 != 0) goto <D.5468>; else goto <D.6276>;
  <D.6276>:
  D.6277 = hhdr->hb_sz;
  D.6278 = D.6277 << 2;
  D.6279 = D.6278 + 4095;
  D.6280 = D.6279 >> 12;
  D.6281 = D.6280 * 4096;
  h = h + D.6281;
  goto <D.5469>;
  <D.5468>:
  GC_push_marked (h, hhdr);
  D.6277 = hhdr->hb_sz;
  D.6278 = D.6277 << 2;
  D.6279 = D.6278 + 4095;
  D.6280 = D.6279 >> 12;
  D.6281 = D.6280 * 4096;
  D.6269 = h + D.6281;
  return D.6269;
}


GC_push_next_marked_uncollectable (struct hblk * h)
{
  long unsigned int h.157;
  long unsigned int D.6284;
  struct bottom_index * D.6285;
  long unsigned int D.6286;
  long unsigned int D.6287;
  struct hblk * D.6290;
  unsigned char D.6291;
  long unsigned int D.6293;
  long unsigned int D.6294;
  long unsigned int D.6295;
  long unsigned int D.6296;
  long unsigned int D.6297;
  register struct hdr * hhdr;

  h.157 = (long unsigned int) h;
  D.6284 = h.157 >> 22;
  D.6285 = GC_arrays._top_index[D.6284];
  h.157 = (long unsigned int) h;
  D.6286 = h.157 >> 12;
  D.6287 = D.6286 & 1023;
  hhdr = D.6285->index[D.6287];
  <D.5475>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.6288>; else goto <D.6289>;
  <D.6288>:
  D.6290 = 0B;
  return D.6290;
  <D.6289>:
  h.157 = (long unsigned int) h;
  D.6284 = h.157 >> 22;
  D.6285 = GC_arrays._top_index[D.6284];
  h.157 = (long unsigned int) h;
  D.6286 = h.157 >> 12;
  D.6287 = D.6286 & 1023;
  hhdr = D.6285->index[D.6287];
  D.6291 = hhdr->hb_obj_kind;
  if (D.6291 == 2) goto <D.5474>; else goto <D.6292>;
  <D.6292>:
  D.6293 = hhdr->hb_sz;
  D.6294 = D.6293 << 2;
  D.6295 = D.6294 + 4095;
  D.6296 = D.6295 >> 12;
  D.6297 = D.6296 * 4096;
  h = h + D.6297;
  goto <D.5475>;
  <D.5474>:
  GC_push_marked (h, hhdr);
  D.6293 = hhdr->hb_sz;
  D.6294 = D.6293 << 2;
  D.6295 = D.6294 + 4095;
  D.6296 = D.6295 >> 12;
  D.6297 = D.6296 * 4096;
  D.6290 = h + D.6297;
  return D.6290;
}