GC_noop (void * p)
{

}


GC_noop1 (word x)
{
  static volatile word sink;

  sink = x;
}


GC_collection_in_progress ()
{
  GC_bool D.8054;
  int GC_mark_state.0;
  _Bool D.8056;

  GC_mark_state.0 = GC_mark_state;
  D.8056 = GC_mark_state.0 != 0;
  D.8054 = (GC_bool) D.8056;
  return D.8054;
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.8061;
  int D.8066;
  void * D.8068;
  unsigned int D.8069;

  D.8061 = __builtin_constant_p (__len);
  if (D.8061 != 0) goto <D.8062>; else goto <D.8063>;
  <D.8062>:
  if (__len == 0) goto <D.8064>; else goto <D.8065>;
  <D.8064>:
  D.8066 = __builtin_constant_p (__ch);
  if (D.8066 == 0) goto <D.8059>; else goto <D.8067>;
  <D.8067>:
  if (__ch != 0) goto <D.8059>; else goto <D.8060>;
  <D.8059>:
  __warn_memset_zero_len ();
  D.8068 = __dest;
  return D.8068;
  <D.8060>:
  <D.8065>:
  <D.8063>:
  D.8069 = __builtin_object_size (__dest, 0);
  D.8068 = __builtin___memset_chk (__dest, __ch, __len, D.8069);
  return D.8068;
}


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

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


GC_set_mark_bit (char * p)
{
  long unsigned int p.1;
  long unsigned int D.8072;
  long unsigned int h.2;
  long unsigned int D.8074;
  struct bottom_index * D.8075;
  long unsigned int D.8076;
  long unsigned int D.8077;
  int p.3;
  int h.4;
  int D.8080;
  int D.8081;
  sizetype D.8082;
  long unsigned int D.8083;
  int D.8084;
  long unsigned int D.8085;
  long unsigned int D.8086;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.1 = (long unsigned int) p;
  D.8072 = p.1 & 4294963200;
  h = (struct hblk *) D.8072;
  h.2 = (long unsigned int) h;
  D.8074 = h.2 >> 22;
  D.8075 = GC_arrays._top_index[D.8074];
  h.2 = (long unsigned int) h;
  D.8076 = h.2 >> 12;
  D.8077 = D.8076 & 1023;
  hhdr = D.8075->index[D.8077];
  p.3 = (int) p;
  h.4 = (int) h;
  D.8080 = p.3 - h.4;
  word_no = D.8080 /[ex] 4;
  D.8081 = word_no >> 5;
  D.8082 = (sizetype) D.8081;
  D.8081 = word_no >> 5;
  D.8082 = (sizetype) D.8081;
  D.8083 = hhdr->hb_marks[D.8082];
  D.8084 = word_no & 31;
  D.8085 = 1 << D.8084;
  D.8086 = D.8083 | D.8085;
  hhdr->hb_marks[D.8082] = D.8086;
}


GC_clear_mark_bit (char * p)
{
  long unsigned int p.5;
  long unsigned int D.8088;
  long unsigned int h.6;
  long unsigned int D.8090;
  struct bottom_index * D.8091;
  long unsigned int D.8092;
  long unsigned int D.8093;
  int p.7;
  int h.8;
  int D.8096;
  int D.8097;
  long unsigned int D.8098;
  int D.8099;
  long unsigned int D.8100;
  long unsigned int D.8101;
  long unsigned int D.8102;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.5 = (long unsigned int) p;
  D.8088 = p.5 & 4294963200;
  h = (struct hblk *) D.8088;
  h.6 = (long unsigned int) h;
  D.8090 = h.6 >> 22;
  D.8091 = GC_arrays._top_index[D.8090];
  h.6 = (long unsigned int) h;
  D.8092 = h.6 >> 12;
  D.8093 = D.8092 & 1023;
  hhdr = D.8091->index[D.8093];
  p.7 = (int) p;
  h.8 = (int) h;
  D.8096 = p.7 - h.8;
  word_no = D.8096 /[ex] 4;
  D.8097 = word_no >> 5;
  D.8097 = word_no >> 5;
  D.8098 = hhdr->hb_marks[D.8097];
  D.8099 = word_no & 31;
  D.8100 = 1 << D.8099;
  D.8101 = ~D.8100;
  D.8102 = D.8098 & D.8101;
  hhdr->hb_marks[D.8097] = D.8102;
}


GC_is_marked (char * p)
{
  long unsigned int p.9;
  long unsigned int D.8104;
  long unsigned int h.10;
  long unsigned int D.8106;
  struct bottom_index * D.8107;
  long unsigned int D.8108;
  long unsigned int D.8109;
  int p.11;
  int h.12;
  int D.8112;
  GC_bool D.8113;
  int D.8114;
  long unsigned int D.8115;
  int D.8116;
  long unsigned int D.8117;
  int D.8118;
  register struct hblk * h;
  register struct hdr * hhdr;
  register int word_no;

  p.9 = (long unsigned int) p;
  D.8104 = p.9 & 4294963200;
  h = (struct hblk *) D.8104;
  h.10 = (long unsigned int) h;
  D.8106 = h.10 >> 22;
  D.8107 = GC_arrays._top_index[D.8106];
  h.10 = (long unsigned int) h;
  D.8108 = h.10 >> 12;
  D.8109 = D.8108 & 1023;
  hhdr = D.8107->index[D.8109];
  p.11 = (int) p;
  h.12 = (int) h;
  D.8112 = p.11 - h.12;
  word_no = D.8112 /[ex] 4;
  D.8114 = word_no >> 5;
  D.8115 = hhdr->hb_marks[D.8114];
  D.8116 = word_no & 31;
  D.8117 = D.8115 >> D.8116;
  D.8118 = (int) D.8117;
  D.8113 = D.8118 & 1;
  return D.8113;
}


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.8121;
  struct bottom_index * D.8122;
  long unsigned int D.8123;
  long unsigned int D.8124;
  unsigned char D.8125;
  int D.8126;
  int D.8127;
  register struct hdr * hhdr;

  h.13 = (long unsigned int) h;
  D.8121 = h.13 >> 22;
  D.8122 = GC_arrays._top_index[D.8121];
  h.13 = (long unsigned int) h;
  D.8123 = h.13 >> 12;
  D.8124 = D.8123 & 1023;
  hhdr = D.8122->index[D.8124];
  D.8125 = hhdr->hb_obj_kind;
  D.8126 = (int) D.8125;
  D.8127 = D.8126 & -2;
  if (D.8127 == 2) goto <D.8128>; else goto <D.8129>;
  <D.8128>:
  return;
  <D.8129>:
  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.8132>; else goto <D.8133>;
  <D.8132>:
  GC_read_dirty ();
  <D.8133>:
  GC_n_rescuing_pages = 0;
  GC_mark_state.15 = GC_mark_state;
  if (GC_mark_state.15 == 0) goto <D.8135>; else goto <D.8136>;
  <D.8135>:
  GC_mark_state = 1;
  goto <D.8137>;
  <D.8136>:
  GC_mark_state.15 = GC_mark_state;
  if (GC_mark_state.15 != 5) goto <D.8138>; else goto <D.8139>;
  <D.8138>:
  GC_abort ("unexpected state");
  <D.8139>:
  <D.8137>:
  scan_ptr = 0B;
}


GC_mark_some (char * cold_gc_frame)
{
  int GC_mark_state.16;
  GC_bool D.8141;
  struct mse * GC_mark_stack_limit.17;
  struct mse * D.8143;
  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.8149;
  struct mse * D.8150;
  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.8163;
  long unsigned int D.8164;
  struct mse * D.8165;
  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.8180;
  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.7787>, case 0: <D.7781>, case 1: <D.7782>, case 2: <D.7783>, case 3: <D.7784>, case 4: <D.7786>, case 5: <D.7785>>
  <D.7781>:
  D.8141 = 0;
  return D.8141;
  <D.7782>:
  GC_mark_stack_limit.17 = GC_mark_stack_limit;
  D.8143 = GC_mark_stack_limit.17 + 4294950912;
  GC_mark_stack_top.18 = GC_mark_stack_top;
  if (D.8143 <= GC_mark_stack_top.18) goto <D.8145>; else goto <D.8146>;
  <D.8145>:
  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.8149 = GC_mark_stack_size.20 * 8;
  D.8150 = GC_mark_stack.19 + D.8149;
  GC_mark_stack_top.21 = GC_mark_from (GC_mark_stack_top.18, GC_mark_stack.19, D.8150);
  GC_mark_stack_top = GC_mark_stack_top.21;
  D.8141 = 0;
  return D.8141;
  <D.8146>:
  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.8154>; else goto <D.8155>;
  <D.8154>:
  GC_print_stats.24 = GC_print_stats;
  if (GC_print_stats.24 != 0) goto <D.8157>; else goto <D.8158>;
  <D.8157>:
  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.8158>:
  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.8161>; else goto <D.8162>;
  <D.8161>:
  GC_mark_state = 3;
  <D.8162>:
  <D.8155>:
  D.8141 = 0;
  return D.8141;
  <D.7783>:
  GC_mark_stack.19 = GC_mark_stack;
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.8163 = GC_mark_stack_size.20 / 4;
  D.8164 = D.8163 * 8;
  D.8165 = GC_mark_stack.19 + D.8164;
  GC_mark_stack_top.18 = GC_mark_stack_top;
  if (D.8165 <= GC_mark_stack_top.18) goto <D.8166>; else goto <D.8167>;
  <D.8166>:
  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.8149 = GC_mark_stack_size.20 * 8;
  D.8150 = GC_mark_stack.19 + D.8149;
  GC_mark_stack_top.27 = GC_mark_from (GC_mark_stack_top.18, GC_mark_stack.19, D.8150);
  GC_mark_stack_top = GC_mark_stack_top.27;
  D.8141 = 0;
  return D.8141;
  <D.8167>:
  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.8170>; else goto <D.8171>;
  <D.8170>:
  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.8172>; else goto <D.8173>;
  <D.8172>:
  GC_mark_state = 3;
  <D.8173>:
  <D.8171>:
  D.8141 = 0;
  return D.8141;
  <D.7784>:
  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.8174>; else goto <D.8175>;
  <D.8174>:
  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.8149 = GC_mark_stack_size.20 * 8;
  D.8150 = GC_mark_stack.19 + D.8149;
  GC_mark_stack_top.29 = GC_mark_from (GC_mark_stack_top.18, GC_mark_stack.19, D.8150);
  GC_mark_stack_top = GC_mark_stack_top.29;
  D.8141 = 0;
  return D.8141;
  <D.8175>:
  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.8178>; else goto <D.8179>;
  <D.8178>:
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.8180 = GC_mark_stack_size.20 * 2;
  alloc_mark_stack (D.8180);
  <D.8179>:
  D.8141 = 1;
  return D.8141;
  <D.7785>:
  <D.7786>:
  GC_objects_are_marked.31 = GC_objects_are_marked;
  if (GC_objects_are_marked.31 == 0) goto <D.8182>; else goto <D.8183>;
  <D.8182>:
  GC_mark_state = 2;
  D.8141 = 0;
  return D.8141;
  <D.8183>:
  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.8184>; else goto <D.8185>;
  <D.8184>:
  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.8149 = GC_mark_stack_size.20 * 8;
  D.8150 = GC_mark_stack.19 + D.8149;
  GC_mark_stack_top.32 = GC_mark_from (GC_mark_stack_top.18, GC_mark_stack.19, D.8150);
  GC_mark_stack_top = GC_mark_stack_top.32;
  D.8141 = 0;
  return D.8141;
  <D.8185>:
  scan_ptr.22 = scan_ptr;
  if (scan_ptr.22 == 0B) goto <D.8187>; else goto <D.8188>;
  <D.8187>:
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 == 5) goto <D.8189>; else goto <D.8190>;
  <D.8189>:
  GC_mark_stack_too_small.30 = GC_mark_stack_too_small;
  if (GC_mark_stack_too_small.30 != 0) goto <D.8191>; else goto <D.8192>;
  <D.8191>:
  GC_mark_stack_size.20 = GC_mark_stack_size;
  D.8180 = GC_mark_stack_size.20 * 2;
  alloc_mark_stack (D.8180);
  <D.8192>:
  GC_mark_state = 4;
  <D.8190>:
  <D.8188>:
  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.8194>; else goto <D.8195>;
  <D.8194>:
  GC_mark_state.16 = GC_mark_state;
  if (GC_mark_state.16 == 4) goto <D.8196>; else goto <D.8197>;
  <D.8196>:
  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.8198>; else goto <D.8199>;
  <D.8198>:
  GC_mark_state = 3;
  <D.8199>:
  <D.8197>:
  <D.8195>:
  D.8141 = 0;
  return D.8141;
  <D.7787>:
  GC_abort ("GC_mark_some: bad state");
  D.8141 = 0;
  return D.8141;
}


alloc_mark_stack (word n)
{
  long unsigned int D.8201;
  long unsigned int GC_mark_stack_size.34;
  long unsigned int GC_page_size.35;
  long unsigned int D.8208;
  struct mse * GC_mark_stack.36;
  long unsigned int GC_mark_stack.37;
  long unsigned int D.8211;
  long unsigned int size.38;
  long unsigned int D.8215;
  long unsigned int D.8216;
  long unsigned int D.8217;
  long unsigned int D.8220;
  struct hblk * D.8221;
  long unsigned int D.8222;
  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.8201 = n * 8;
  new_stack = GC_scratch_alloc (D.8201);
  GC_mark_stack_too_small = 0;
  GC_mark_stack_size.34 = GC_mark_stack_size;
  if (GC_mark_stack_size.34 != 0) goto <D.8203>; else goto <D.8204>;
  <D.8203>:
  if (new_stack != 0B) goto <D.8205>; else goto <D.8206>;
  <D.8205>:
  {
    word displ;
    signed_word size;

    GC_page_size.35 = GC_page_size;
    D.8208 = 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.8208 & GC_mark_stack.37;
    GC_mark_stack_size.34 = GC_mark_stack_size;
    D.8211 = GC_mark_stack_size.34 * 8;
    size = (signed_word) D.8211;
    if (displ != 0) goto <D.8212>; else goto <D.8213>;
    <D.8212>:
    GC_page_size.35 = GC_page_size;
    displ = GC_page_size.35 - displ;
    <D.8213>:
    size.38 = (long unsigned int) size;
    D.8215 = size.38 - displ;
    GC_page_size.35 = GC_page_size;
    D.8216 = -GC_page_size.35;
    D.8217 = D.8215 & D.8216;
    size = (signed_word) D.8217;
    if (size > 0) goto <D.8218>; else goto <D.8219>;
    <D.8218>:
    GC_mark_stack.36 = GC_mark_stack;
    GC_mark_stack.37 = (long unsigned int) GC_mark_stack.36;
    D.8220 = GC_mark_stack.37 + displ;
    D.8221 = (struct hblk *) D.8220;
    size.38 = (long unsigned int) size;
    GC_add_to_heap (D.8221, size.38);
    <D.8219>:
    GC_mark_stack = new_stack;
    GC_mark_stack_size = n;
    D.8222 = n * 8;
    GC_mark_stack_limit.39 = new_stack + D.8222;
    GC_mark_stack_limit = GC_mark_stack_limit.39;
    GC_print_stats.40 = GC_print_stats;
    if (GC_print_stats.40 != 0) goto <D.8225>; else goto <D.8226>;
    <D.8225>:
    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.8226>:
  }
  goto <D.8228>;
  <D.8206>:
  GC_print_stats.40 = GC_print_stats;
  if (GC_print_stats.40 != 0) goto <D.8229>; else goto <D.8230>;
  <D.8229>:
  n.42 = (long int) n;
  GC_printf ("Failed to grow mark stack to %lu frames\n", n.42, 0, 0, 0, 0, 0);
  <D.8230>:
  <D.8228>:
  goto <D.8232>;
  <D.8204>:
  if (new_stack == 0B) goto <D.8233>; else goto <D.8234>;
  <D.8233>:
  GC_err_puts ("No space for mark stack\n");
  exit (1);
  <D.8234>:
  GC_mark_stack = new_stack;
  GC_mark_stack_size = n;
  D.8222 = n * 8;
  GC_mark_stack_limit.39 = new_stack + D.8222;
  GC_mark_stack_limit = GC_mark_stack_limit.39;
  <D.8232>:
  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.8236;
  struct mse * GC_mark_stack_top.44;
  struct mse * GC_mark_stack.45;
  _Bool D.8239;

  GC_mark_stack_top.44 = GC_mark_stack_top;
  GC_mark_stack.45 = GC_mark_stack;
  D.8239 = GC_mark_stack_top.44 < GC_mark_stack.45;
  D.8236 = (GC_bool) D.8239;
  return D.8236;
}


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.8247;
  long unsigned int hhdr.48;
  long unsigned int D.8249;
  sizetype D.8250;
  long unsigned int D.8251;
  struct bottom_index * D.8252;
  long unsigned int D.8253;
  long unsigned int D.8254;
  unsigned char D.8255;
  int D.8256;
  int D.8257;
  char * D.8260;
  int orig.49;
  int current.50;
  int D.8263;
  int D.8264;
  long unsigned int D.8265;
  int D.8266;

  GC_all_interior_pointers.46 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.46 != 0) goto <D.8242>; else goto <D.8243>;
  <D.8242>:
  if (hhdr != 0B) goto <D.8244>; else goto <D.8245>;
  <D.8244>:
  {
    register char * orig;

    orig = current;
    current.47 = (long unsigned int) current;
    D.8247 = current.47 & 4294963200;
    current = (char *) D.8247;
    <D.7796>:
    hhdr.48 = (long unsigned int) hhdr;
    D.8249 = hhdr.48 * 4096;
    D.8250 = -D.8249;
    current = current + D.8250;
    current.47 = (long unsigned int) current;
    D.8251 = current.47 >> 22;
    D.8252 = GC_arrays._top_index[D.8251];
    current.47 = (long unsigned int) current;
    D.8253 = current.47 >> 12;
    D.8254 = D.8253 & 1023;
    hhdr = D.8252->index[D.8254];
    hhdr.48 = (long unsigned int) hhdr;
    if (hhdr.48 <= 4095) goto <D.7796>; else goto <D.7797>;
    <D.7797>:
    D.8255 = hhdr->hb_flags;
    D.8256 = (int) D.8255;
    D.8257 = D.8256 & 1;
    if (D.8257 != 0) goto <D.8258>; else goto <D.8259>;
    <D.8258>:
    D.8260 = orig;
    return D.8260;
    <D.8259>:
    orig.49 = (int) orig;
    current.50 = (int) current;
    D.8263 = orig.49 - current.50;
    D.8264 = D.8263 /[ex] 4;
    D.8265 = hhdr->hb_sz;
    D.8266 = (int) D.8265;
    if (D.8264 >= D.8266) goto <D.8267>; else goto <D.8268>;
    <D.8267>:
    D.8260 = orig;
    return D.8260;
    <D.8268>:
    *new_hdr_p = hhdr;
    D.8260 = current;
    return D.8260;
  }
  <D.8245>:
  D.8260 = current;
  return D.8260;
  <D.8243>:
  D.8260 = current;
  return D.8260;
}


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.8277;

  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.8273>; else goto <D.8274>;
  <D.8273>:
  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.8274>:
  D.8277 = msp + 4294963200;
  return D.8277;
}


GC_mark_from (struct mse * mark_stack_top, struct mse * mark_stack, struct mse * mark_stack_limit)
{
  long unsigned int D.8279;
  long unsigned int D.8282;
  long unsigned int credit.56;
  long unsigned int D.8284;
  long int descr.57;
  char * current.58;
  _Bool D.8289;
  _Bool D.8290;
  _Bool D.8291;
  long unsigned int my_current.59;
  long unsigned int D.8295;
  long unsigned int D.8296;
  long unsigned int D.8297;
  long unsigned int D.8298;
  long unsigned int D.8302;
  struct bottom_index * D.8303;
  long unsigned int D.8304;
  long unsigned int my_hhdr.60;
  struct hdr * GC_invalid_header.61;
  int my_current.62;
  map_entry_type * D.8311;
  sizetype displ.63;
  map_entry_type * D.8313;
  unsigned char D.8314;
  long unsigned int displ.64;
  long unsigned int D.8320;
  long unsigned int D.8321;
  long unsigned int D.8322;
  int GC_all_interior_pointers.65;
  int D.8334;
  sizetype D.8335;
  int D.8336;
  long unsigned int D.8337;
  long unsigned int D.8339;
  unsigned int displ.66;
  unsigned int D.8346;
  sizetype my_current.67;
  sizetype D.8348;
  sizetype D.8349;
  GC_word * D.8350;
  long unsigned int D.8351;
  long unsigned int D.8352;
  struct GC_ms_entry * (*<T151e>) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word) D.8353;
  long unsigned int D.8354;
  sizetype D.8357;
  word * D.8358;
  sizetype D.8362;
  char * D.8363;
  int current_p.68;
  int limit.69;
  int D.8370;
  char * deferred.70;
  _Bool D.8372;
  _Bool D.8373;
  _Bool D.8374;
  long unsigned int my_current.71;
  long unsigned int D.8382;
  long unsigned int D.8383;
  long unsigned int D.8384;
  long unsigned int D.8385;
  long unsigned int D.8389;
  struct bottom_index * D.8390;
  long unsigned int D.8391;
  long unsigned int my_hhdr.72;
  int my_current.73;
  map_entry_type * D.8397;
  sizetype displ.74;
  map_entry_type * D.8399;
  unsigned char D.8400;
  long unsigned int displ.75;
  long unsigned int D.8406;
  long unsigned int D.8407;
  long unsigned int D.8408;
  int D.8419;
  sizetype D.8420;
  int D.8421;
  long unsigned int D.8422;
  long unsigned int D.8424;
  unsigned int displ.76;
  unsigned int D.8431;
  sizetype my_current.77;
  sizetype D.8433;
  sizetype D.8434;
  GC_word * D.8435;
  long unsigned int my_current.78;
  long unsigned int D.8437;
  long unsigned int D.8438;
  long unsigned int D.8439;
  long unsigned int D.8440;
  long unsigned int D.8444;
  struct bottom_index * D.8445;
  long unsigned int D.8446;
  long unsigned int my_hhdr.79;
  int my_current.80;
  map_entry_type * D.8452;
  sizetype displ.81;
  map_entry_type * D.8454;
  unsigned char D.8455;
  long unsigned int displ.82;
  long unsigned int D.8461;
  long unsigned int D.8462;
  long unsigned int D.8463;
  int D.8474;
  sizetype D.8475;
  int D.8476;
  long unsigned int D.8477;
  long unsigned int D.8479;
  unsigned int displ.83;
  unsigned int D.8486;
  sizetype my_current.84;
  sizetype D.8488;
  sizetype D.8489;
  GC_word * D.8490;
  int mark_stack_top.85;
  int mark_stack.86;
  int D.8493;
  int D.8494;
  struct mse * D.8495;
  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.7835>;
      <D.7868>:
      current_p = mark_stack_top->mse_start;
      descr = mark_stack_top->mse_descr;
      retry:
      D.8279 = descr & 4294966787;
      if (D.8279 != 0) goto <D.8280>; else goto <D.8281>;
      <D.8280>:
      {
        word tag;

        tag = descr & 3;
        switch (tag) <default: <D.8366>, case 0: <D.7818>, case 1: <D.7820>, case 2: <D.7836>, case 3: <D.7837>>
        <D.7818>:
        limit = current_p + 508;
        mark_stack_top->mse_start = limit;
        D.8282 = descr + 4294966788;
        mark_stack_top->mse_descr = D.8282;
        limit = limit;
        goto <D.7819>;
        <D.7820>:
        mark_stack_top = mark_stack_top + 4294967288;
        descr = descr & 4294967292;
        credit.56 = (long unsigned int) credit;
        D.8284 = credit.56 + 4294967232;
        credit = (int) D.8284;
        goto <D.7833>;
        <D.7832>:
        descr.57 = (long int) descr;
        if (descr.57 < 0) goto <D.8286>; else goto <D.8287>;
        <D.8286>:
        current = *current_p;
        current.58 = (char *) current;
        D.8289 = current.58 >= least_ha;
        current.58 = (char *) current;
        D.8290 = current.58 < greatest_ha;
        D.8291 = D.8289 & D.8290;
        if (D.8291 != 0) goto <D.8292>; else goto <D.8293>;
        <D.8292>:
        {
          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.8295 = my_current.59 >> 12;
            D.8296 = D.8295 & 7;
            D.8297 = D.8296 * 8;
            hce = &hdr_cache + D.8297;
            D.8298 = hce->block_addr;
            my_current.59 = (long unsigned int) my_current;
            D.8295 = my_current.59 >> 12;
            if (D.8298 == D.8295) goto <D.8299>; else goto <D.8300>;
            <D.8299>:
            my_hhdr = hce->hce_hdr;
            goto <D.8301>;
            <D.8300>:
            my_current.59 = (long unsigned int) my_current;
            D.8302 = my_current.59 >> 22;
            D.8303 = GC_arrays._top_index[D.8302];
            my_current.59 = (long unsigned int) my_current;
            D.8295 = my_current.59 >> 12;
            D.8304 = D.8295 & 1023;
            my_hhdr = D.8303->index[D.8304];
            my_hhdr.60 = (long unsigned int) my_hhdr;
            if (my_hhdr.60 <= 4095) goto <D.8306>; else goto <D.8307>;
            <D.8306>:
            {
              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.8309>;
            <D.8307>:
            my_current.59 = (long unsigned int) my_current;
            D.8295 = my_current.59 >> 12;
            hce->block_addr = D.8295;
            hce->hce_hdr = my_hhdr;
            <D.8309>:
            <D.8301>:
          }
          {
            int displ;
            int map_entry;

            my_current.62 = (int) my_current;
            displ = my_current.62 & 4095;
            D.8311 = my_hhdr->hb_map;
            displ.63 = (sizetype) displ;
            D.8313 = D.8311 + displ.63;
            D.8314 = *D.8313;
            map_entry = (int) D.8314;
            displ = displ >> 2;
            if (map_entry > 253) goto <D.8315>; else goto <D.8316>;
            <D.8315>:
            if (map_entry == 254) goto <D.8317>; else goto <D.8318>;
            <D.8317>:
            displ.64 = (long unsigned int) displ;
            D.8320 = my_hhdr->hb_sz;
            D.8321 = displ.64 % D.8320;
            map_entry = (int) D.8321;
            displ = displ - map_entry;
            D.8320 = my_hhdr->hb_sz;
            displ.64 = (long unsigned int) displ;
            D.8322 = D.8320 + displ.64;
            if (D.8322 > 1024) goto <D.8323>; else goto <D.8324>;
            <D.8323>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.8326>; else goto <D.8327>;
            <D.8326>:
            my_current.59 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.59);
            goto <D.8328>;
            <D.8327>:
            my_current.59 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.59);
            <D.8328>:
            goto exit1;
            <D.8324>:
            goto <D.8329>;
            <D.8318>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.8330>; else goto <D.8331>;
            <D.8330>:
            my_current.59 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.59);
            goto <D.8332>;
            <D.8331>:
            my_current.59 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.59);
            <D.8332>:
            goto exit1;
            <D.8329>:
            goto <D.8333>;
            <D.8316>:
            displ = displ - map_entry;
            <D.8333>:
            {
              register word * mark_word_addr;

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

                old = *mark_word_addr;
                D.8336 = displ & 31;
                my_bits = 1 << D.8336;
                D.8337 = old & my_bits;
                if (D.8337 != 0) goto exit1; else goto <D.8338>;
                <D.8338>:
                D.8339 = old | my_bits;
                *mark_word_addr = D.8339;
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.8340>; else goto <D.8341>;
              <D.8340>:
              goto <D.8342>;
              <D.8341>:
              mark_stack_top = mark_stack_top + 8;
              if (mark_stack_top >= mark_stack_limit) goto <D.8343>; else goto <D.8344>;
              <D.8343>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.8344>:
              displ.66 = (unsigned int) displ;
              D.8346 = displ.66 * 4;
              my_current.67 = (sizetype) my_current;
              D.8348 = my_current.67 & 4294963200;
              D.8349 = D.8346 + D.8348;
              D.8350 = (GC_word *) D.8349;
              mark_stack_top->mse_start = D.8350;
              mark_stack_top->mse_descr = _descr;
              <D.8342>:
            }
          }
          exit1:
        }
        <D.8293>:
        <D.8287>:
        descr = descr << 1;
        current_p = current_p + 4;
        <D.7833>:
        if (descr != 0) goto <D.7832>; else goto <D.7834>;
        <D.7834>:
        // predicted unlikely by continue predictor.
        goto <D.7835>;
        <D.7836>:
        mark_stack_top = mark_stack_top + 4294967288;
        credit = credit + -100;
        D.8351 = descr >> 2;
        D.8352 = D.8351 & 63;
        D.8353 = GC_arrays._mark_procs[D.8352];
        D.8354 = descr >> 8;
        mark_stack_top = D.8353 (current_p, mark_stack_top, mark_stack_limit, D.8354);
        // predicted unlikely by continue predictor.
        goto <D.7835>;
        <D.7837>:
        descr.57 = (long int) descr;
        if (descr.57 >= 0) goto <D.8355>; else goto <D.8356>;
        <D.8355>:
        D.8357 = descr + 4294967293;
        D.8358 = current_p + D.8357;
        descr = *D.8358;
        goto <D.8359>;
        <D.8356>:
        {
          char * type_descr;

          type_descr = MEM[(char * *)current_p];
          if (type_descr == 0B) goto <D.8360>; else goto <D.8361>;
          <D.8360>:
          mark_stack_top = mark_stack_top + 4294967288;
          // predicted unlikely by continue predictor.
          goto <D.7835>;
          <D.8361>:
          D.8362 = 4294967283 - descr;
          D.8363 = type_descr + D.8362;
          descr = MEM[(word *)D.8363];
        }
        <D.8359>:
        if (descr == 0) goto <D.8364>; else goto <D.8365>;
        <D.8364>:
        mark_stack_top = mark_stack_top + 4294967288;
        // predicted unlikely by continue predictor.
        goto <D.7835>;
        <D.8365>:
        goto retry;
        <D.8366>:
        <D.7819>:
      }
      goto <D.8367>;
      <D.8281>:
      mark_stack_top = mark_stack_top + 4294967288;
      limit = current_p + descr;
      <D.8367>:
      current_p.68 = (int) current_p;
      limit.69 = (int) limit;
      D.8370 = current_p.68 - limit.69;
      credit = D.8370 + credit;
      limit = limit + 4294967292;
      {
        word deferred;

        <D.7842>:
        deferred = *limit;
        limit = limit + 4294967292;
        deferred.70 = (char *) deferred;
        D.8372 = deferred.70 >= least_ha;
        deferred.70 = (char *) deferred;
        D.8373 = deferred.70 < greatest_ha;
        D.8374 = D.8372 & D.8373;
        if (D.8374 != 0) goto <D.7840>; else goto <D.8375>;
        <D.8375>:
        if (current_p > limit) goto next_object; else goto <D.8376>;
        <D.8376>:
        deferred = *limit;
        limit = limit + 4294967292;
        deferred.70 = (char *) deferred;
        D.8372 = deferred.70 >= least_ha;
        deferred.70 = (char *) deferred;
        D.8373 = deferred.70 < greatest_ha;
        D.8374 = D.8372 & D.8373;
        if (D.8374 != 0) goto <D.7840>; else goto <D.8377>;
        <D.8377>:
        if (current_p > limit) goto next_object; else goto <D.8378>;
        <D.8378>:
        goto <D.7842>;
        <D.7840>:
        goto <D.7855>;
        <D.7854>:
        current = *current_p;
        current.58 = (char *) current;
        D.8289 = current.58 >= least_ha;
        current.58 = (char *) current;
        D.8290 = current.58 < greatest_ha;
        D.8291 = D.8289 & D.8290;
        if (D.8291 != 0) goto <D.8379>; else goto <D.8380>;
        <D.8379>:
        {
          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.8382 = my_current.71 >> 12;
            D.8383 = D.8382 & 7;
            D.8384 = D.8383 * 8;
            hce = &hdr_cache + D.8384;
            D.8385 = hce->block_addr;
            my_current.71 = (long unsigned int) my_current;
            D.8382 = my_current.71 >> 12;
            if (D.8385 == D.8382) goto <D.8386>; else goto <D.8387>;
            <D.8386>:
            my_hhdr = hce->hce_hdr;
            goto <D.8388>;
            <D.8387>:
            my_current.71 = (long unsigned int) my_current;
            D.8389 = my_current.71 >> 22;
            D.8390 = GC_arrays._top_index[D.8389];
            my_current.71 = (long unsigned int) my_current;
            D.8382 = my_current.71 >> 12;
            D.8391 = D.8382 & 1023;
            my_hhdr = D.8390->index[D.8391];
            my_hhdr.72 = (long unsigned int) my_hhdr;
            if (my_hhdr.72 <= 4095) goto <D.8393>; else goto <D.8394>;
            <D.8393>:
            {
              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.8395>;
            <D.8394>:
            my_current.71 = (long unsigned int) my_current;
            D.8382 = my_current.71 >> 12;
            hce->block_addr = D.8382;
            hce->hce_hdr = my_hhdr;
            <D.8395>:
            <D.8388>:
          }
          {
            int displ;
            int map_entry;

            my_current.73 = (int) my_current;
            displ = my_current.73 & 4095;
            D.8397 = my_hhdr->hb_map;
            displ.74 = (sizetype) displ;
            D.8399 = D.8397 + displ.74;
            D.8400 = *D.8399;
            map_entry = (int) D.8400;
            displ = displ >> 2;
            if (map_entry > 253) goto <D.8401>; else goto <D.8402>;
            <D.8401>:
            if (map_entry == 254) goto <D.8403>; else goto <D.8404>;
            <D.8403>:
            displ.75 = (long unsigned int) displ;
            D.8406 = my_hhdr->hb_sz;
            D.8407 = displ.75 % D.8406;
            map_entry = (int) D.8407;
            displ = displ - map_entry;
            D.8406 = my_hhdr->hb_sz;
            displ.75 = (long unsigned int) displ;
            D.8408 = D.8406 + displ.75;
            if (D.8408 > 1024) goto <D.8409>; else goto <D.8410>;
            <D.8409>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.8411>; else goto <D.8412>;
            <D.8411>:
            my_current.71 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.71);
            goto <D.8413>;
            <D.8412>:
            my_current.71 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.71);
            <D.8413>:
            goto exit2;
            <D.8410>:
            goto <D.8414>;
            <D.8404>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.8415>; else goto <D.8416>;
            <D.8415>:
            my_current.71 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.71);
            goto <D.8417>;
            <D.8416>:
            my_current.71 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.71);
            <D.8417>:
            goto exit2;
            <D.8414>:
            goto <D.8418>;
            <D.8402>:
            displ = displ - map_entry;
            <D.8418>:
            {
              register word * mark_word_addr;

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

                old = *mark_word_addr;
                D.8421 = displ & 31;
                my_bits = 1 << D.8421;
                D.8422 = old & my_bits;
                if (D.8422 != 0) goto exit2; else goto <D.8423>;
                <D.8423>:
                D.8424 = old | my_bits;
                *mark_word_addr = D.8424;
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.8425>; else goto <D.8426>;
              <D.8425>:
              goto <D.8427>;
              <D.8426>:
              mark_stack_top = mark_stack_top + 8;
              if (mark_stack_top >= mark_stack_limit) goto <D.8428>; else goto <D.8429>;
              <D.8428>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.8429>:
              displ.76 = (unsigned int) displ;
              D.8431 = displ.76 * 4;
              my_current.77 = (sizetype) my_current;
              D.8433 = my_current.77 & 4294963200;
              D.8434 = D.8431 + D.8433;
              D.8435 = (GC_word *) D.8434;
              mark_stack_top->mse_start = D.8435;
              mark_stack_top->mse_descr = _descr;
              <D.8427>:
            }
          }
          exit2:
        }
        <D.8380>:
        current_p = current_p + 4;
        <D.7855>:
        if (current_p <= limit) goto <D.7854>; else goto <D.7856>;
        <D.7856>:
        {
          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.8437 = my_current.78 >> 12;
            D.8438 = D.8437 & 7;
            D.8439 = D.8438 * 8;
            hce = &hdr_cache + D.8439;
            D.8440 = hce->block_addr;
            my_current.78 = (long unsigned int) my_current;
            D.8437 = my_current.78 >> 12;
            if (D.8440 == D.8437) goto <D.8441>; else goto <D.8442>;
            <D.8441>:
            my_hhdr = hce->hce_hdr;
            goto <D.8443>;
            <D.8442>:
            my_current.78 = (long unsigned int) my_current;
            D.8444 = my_current.78 >> 22;
            D.8445 = GC_arrays._top_index[D.8444];
            my_current.78 = (long unsigned int) my_current;
            D.8437 = my_current.78 >> 12;
            D.8446 = D.8437 & 1023;
            my_hhdr = D.8445->index[D.8446];
            my_hhdr.79 = (long unsigned int) my_hhdr;
            if (my_hhdr.79 <= 4095) goto <D.8448>; else goto <D.8449>;
            <D.8448>:
            {
              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.8450>;
            <D.8449>:
            my_current.78 = (long unsigned int) my_current;
            D.8437 = my_current.78 >> 12;
            hce->block_addr = D.8437;
            hce->hce_hdr = my_hhdr;
            <D.8450>:
            <D.8443>:
          }
          {
            int displ;
            int map_entry;

            my_current.80 = (int) my_current;
            displ = my_current.80 & 4095;
            D.8452 = my_hhdr->hb_map;
            displ.81 = (sizetype) displ;
            D.8454 = D.8452 + displ.81;
            D.8455 = *D.8454;
            map_entry = (int) D.8455;
            displ = displ >> 2;
            if (map_entry > 253) goto <D.8456>; else goto <D.8457>;
            <D.8456>:
            if (map_entry == 254) goto <D.8458>; else goto <D.8459>;
            <D.8458>:
            displ.82 = (long unsigned int) displ;
            D.8461 = my_hhdr->hb_sz;
            D.8462 = displ.82 % D.8461;
            map_entry = (int) D.8462;
            displ = displ - map_entry;
            D.8461 = my_hhdr->hb_sz;
            displ.82 = (long unsigned int) displ;
            D.8463 = D.8461 + displ.82;
            if (D.8463 > 1024) goto <D.8464>; else goto <D.8465>;
            <D.8464>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.8466>; else goto <D.8467>;
            <D.8466>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.78);
            goto <D.8468>;
            <D.8467>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.78);
            <D.8468>:
            goto exit4;
            <D.8465>:
            goto <D.8469>;
            <D.8459>:
            GC_all_interior_pointers.65 = GC_all_interior_pointers;
            if (GC_all_interior_pointers.65 != 0) goto <D.8470>; else goto <D.8471>;
            <D.8470>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_stack (my_current.78);
            goto <D.8472>;
            <D.8471>:
            my_current.78 = (long unsigned int) my_current;
            GC_add_to_black_list_normal (my_current.78);
            <D.8472>:
            goto exit4;
            <D.8469>:
            goto <D.8473>;
            <D.8457>:
            displ = displ - map_entry;
            <D.8473>:
            {
              register word * mark_word_addr;

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

                old = *mark_word_addr;
                D.8476 = displ & 31;
                my_bits = 1 << D.8476;
                D.8477 = old & my_bits;
                if (D.8477 != 0) goto exit4; else goto <D.8478>;
                <D.8478>:
                D.8479 = old | my_bits;
                *mark_word_addr = D.8479;
              }
            }
            {
              register word _descr;

              _descr = my_hhdr->hb_descr;
              if (_descr == 0) goto <D.8480>; else goto <D.8481>;
              <D.8480>:
              goto <D.8482>;
              <D.8481>:
              mark_stack_top = mark_stack_top + 8;
              if (mark_stack_top >= mark_stack_limit) goto <D.8483>; else goto <D.8484>;
              <D.8483>:
              mark_stack_top = GC_signal_mark_stack_overflow (mark_stack_top);
              <D.8484>:
              displ.83 = (unsigned int) displ;
              D.8486 = displ.83 * 4;
              my_current.84 = (sizetype) my_current;
              D.8488 = my_current.84 & 4294963200;
              D.8489 = D.8486 + D.8488;
              D.8490 = (GC_word *) D.8489;
              mark_stack_top->mse_start = D.8490;
              mark_stack_top->mse_descr = _descr;
              <D.8482>:
            }
          }
          exit4:
        }
        next_object:
      }
      <D.7835>:
      mark_stack_top.85 = (int) mark_stack_top;
      mark_stack.86 = (int) mark_stack;
      D.8493 = mark_stack_top.85 - mark_stack.86;
      D.8494 = D.8493 | credit;
      if (D.8494 >= 0) goto <D.7868>; else goto <D.7869>;
      <D.7869>:
      D.8495 = mark_stack_top;
      return D.8495;
    }
  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.8500;
  long unsigned int D.8501;
  long unsigned int top.88;
  long unsigned int D.8503;
  _Bool D.8504;
  _Bool D.8505;
  _Bool D.8506;
  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.8516;
  register word length;

  bottom.87 = (long unsigned int) bottom;
  D.8500 = bottom.87 + 3;
  D.8501 = D.8500 & 4294967292;
  bottom = (char *) D.8501;
  top.88 = (long unsigned int) top;
  D.8503 = top.88 & 4294967292;
  top = (char *) D.8503;
  D.8504 = top == 0B;
  D.8505 = bottom == top;
  D.8506 = D.8504 | D.8505;
  if (D.8506 != 0) goto <D.8507>; else goto <D.8508>;
  <D.8507>:
  return;
  <D.8508>:
  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.8512>; else goto <D.8513>;
  <D.8512>:
  GC_abort ("unexpected mark stack overflow");
  <D.8513>:
  top.92 = (int) top;
  bottom.93 = (int) bottom;
  D.8516 = top.92 - bottom.93;
  length = (word) D.8516;
  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 (*<T1989>) (struct hblk *) dirty_fn, void (*<T198c>) (char *, char *) push_fn)
{
  long int bottom.94;
  long int D.8519;
  long int D.8520;
  long int top.95;
  long int D.8522;
  _Bool D.8523;
  _Bool D.8524;
  _Bool D.8525;
  char * D.8528;
  long unsigned int D.8529;
  long unsigned int D.8530;
  struct hblk * D.8533;
  int D.8534;
  int D.8537;
  int D.8540;
  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.8547;
  int D.8548;
  long unsigned int D.8549;
  long unsigned int GC_mark_stack_size.100;
  long unsigned int D.8551;
  long unsigned int D.8552;
  char * D.8555;
  int D.8558;
  struct mse * GC_mark_stack_limit.101;
  register struct hblk * h;

  bottom.94 = (long int) bottom;
  D.8519 = bottom.94 + 3;
  D.8520 = D.8519 & -4;
  bottom = (char *) D.8520;
  top.95 = (long int) top;
  D.8522 = top.95 & -4;
  top = (char *) D.8522;
  D.8523 = top == 0B;
  D.8524 = bottom == top;
  D.8525 = D.8523 | D.8524;
  if (D.8525 != 0) goto <D.8526>; else goto <D.8527>;
  <D.8526>:
  return;
  <D.8527>:
  D.8528 = bottom + 4096;
  D.8529 = (long unsigned int) D.8528;
  D.8530 = D.8529 & 4294963200;
  h = (struct hblk *) D.8530;
  if (top <= h) goto <D.8531>; else goto <D.8532>;
  <D.8531>:
  D.8533 = h + 4294963200;
  D.8534 = dirty_fn (D.8533);
  if (D.8534 != 0) goto <D.8535>; else goto <D.8536>;
  <D.8535>:
  push_fn (bottom, top);
  <D.8536>:
  return;
  <D.8532>:
  D.8533 = h + 4294963200;
  D.8537 = dirty_fn (D.8533);
  if (D.8537 != 0) goto <D.8538>; else goto <D.8539>;
  <D.8538>:
  push_fn (bottom, h);
  <D.8539>:
  goto <D.7894>;
  <D.7893>:
  D.8540 = dirty_fn (h);
  if (D.8540 != 0) goto <D.8541>; else goto <D.8542>;
  <D.8541>:
  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.8547 = GC_mark_stack_top.97 - GC_mark_stack.99;
  D.8548 = D.8547 /[ex] 8;
  D.8549 = (long unsigned int) D.8548;
  GC_mark_stack_size.100 = GC_mark_stack_size;
  D.8551 = GC_mark_stack_size.100 * 3;
  D.8552 = D.8551 / 4;
  if (D.8549 > D.8552) goto <D.8553>; else goto <D.8554>;
  <D.8553>:
  push_fn (h, top);
  return;
  <D.8554>:
  D.8555 = h + 4096;
  push_fn (h, D.8555);
  <D.8542>:
  h = h + 4096;
  <D.7894>:
  D.8555 = h + 4096;
  if (D.8555 <= top) goto <D.7893>; else goto <D.7895>;
  <D.7895>:
  if (h != top) goto <D.8556>; else goto <D.8557>;
  <D.8556>:
  D.8558 = dirty_fn (h);
  if (D.8558 != 0) goto <D.8559>; else goto <D.8560>;
  <D.8559>:
  push_fn (h, top);
  <D.8560>:
  <D.8557>:
  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.8562>; else goto <D.8563>;
  <D.8562>:
  GC_abort ("unexpected mark stack overflow");
  <D.8563>:
}


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

  if (all != 0) goto <D.8565>; else goto <D.8566>;
  <D.8565>:
  GC_dirty_maintained.102 = GC_dirty_maintained;
  if (GC_dirty_maintained.102 != 0) goto <D.8568>; else goto <D.8569>;
  <D.8568>:
  GC_push_all (bottom, top);
  goto <D.8570>;
  <D.8569>:
  GC_push_all (bottom, top);
  <D.8570>:
  goto <D.8571>;
  <D.8566>:
  GC_push_selected (bottom, top, GC_page_was_dirty, GC_push_all);
  <D.8571>:
}


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.8574>; else goto <D.8575>;
  <D.8574>:
  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.8577>; else goto <D.8578>;
  <D.8577>:
  GC_mark_and_push_stack (p);
  <D.8578>:
  <D.8575>:
}


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.8580;
  struct bottom_index * D.8581;
  long unsigned int D.8582;
  long unsigned int D.8583;
  long unsigned int my_hhdr.107;
  struct hdr * GC_invalid_header.108;
  int my_current.109;
  map_entry_type * D.8589;
  sizetype displ.110;
  map_entry_type * D.8591;
  unsigned char D.8592;
  long unsigned int displ.111;
  long unsigned int D.8598;
  long unsigned int D.8599;
  long unsigned int D.8600;
  int GC_all_interior_pointers.112;
  int D.8612;
  sizetype D.8613;
  int D.8614;
  long unsigned int D.8615;
  long unsigned int D.8617;
  unsigned int displ.113;
  unsigned int D.8624;
  sizetype my_current.114;
  sizetype D.8626;
  sizetype D.8627;
  GC_word * D.8628;
  struct GC_ms_entry * D.8629;
  void was_marked = <<< error >>>;

  {
    struct hdr * my_hhdr;
    char * my_current;

    my_current = obj;
    my_current.106 = (long unsigned int) my_current;
    D.8580 = my_current.106 >> 22;
    D.8581 = GC_arrays._top_index[D.8580];
    my_current.106 = (long unsigned int) my_current;
    D.8582 = my_current.106 >> 12;
    D.8583 = D.8582 & 1023;
    my_hhdr = D.8581->index[D.8583];
    my_hhdr.107 = (long unsigned int) my_hhdr;
    if (my_hhdr.107 <= 4095) goto <D.8585>; else goto <D.8586>;
    <D.8585>:
    {
      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.8586>:
    {
      int displ;
      int map_entry;

      my_current.109 = (int) my_current;
      displ = my_current.109 & 4095;
      D.8589 = my_hhdr->hb_map;
      displ.110 = (sizetype) displ;
      D.8591 = D.8589 + displ.110;
      D.8592 = *D.8591;
      map_entry = (int) D.8592;
      displ = displ >> 2;
      if (map_entry > 253) goto <D.8593>; else goto <D.8594>;
      <D.8593>:
      if (map_entry == 254) goto <D.8595>; else goto <D.8596>;
      <D.8595>:
      displ.111 = (long unsigned int) displ;
      D.8598 = my_hhdr->hb_sz;
      D.8599 = displ.111 % D.8598;
      map_entry = (int) D.8599;
      displ = displ - map_entry;
      D.8598 = my_hhdr->hb_sz;
      displ.111 = (long unsigned int) displ;
      D.8600 = D.8598 + displ.111;
      if (D.8600 > 1024) goto <D.8601>; else goto <D.8602>;
      <D.8601>:
      GC_all_interior_pointers.112 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.112 != 0) goto <D.8604>; else goto <D.8605>;
      <D.8604>:
      my_current.106 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.106);
      goto <D.8606>;
      <D.8605>:
      my_current.106 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.106);
      <D.8606>:
      goto was_marked;
      <D.8602>:
      goto <D.8607>;
      <D.8596>:
      GC_all_interior_pointers.112 = GC_all_interior_pointers;
      if (GC_all_interior_pointers.112 != 0) goto <D.8608>; else goto <D.8609>;
      <D.8608>:
      my_current.106 = (long unsigned int) my_current;
      GC_add_to_black_list_stack (my_current.106);
      goto <D.8610>;
      <D.8609>:
      my_current.106 = (long unsigned int) my_current;
      GC_add_to_black_list_normal (my_current.106);
      <D.8610>:
      goto was_marked;
      <D.8607>:
      goto <D.8611>;
      <D.8594>:
      displ = displ - map_entry;
      <D.8611>:
      {
        register word * mark_word_addr;

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

          old = *mark_word_addr;
          D.8614 = displ & 31;
          my_bits = 1 << D.8614;
          D.8615 = old & my_bits;
          if (D.8615 != 0) goto was_marked; else goto <D.8616>;
          <D.8616>:
          D.8617 = old | my_bits;
          *mark_word_addr = D.8617;
        }
      }
      {
        register word _descr;

        _descr = my_hhdr->hb_descr;
        if (_descr == 0) goto <D.8618>; else goto <D.8619>;
        <D.8618>:
        goto <D.8620>;
        <D.8619>:
        mark_stack_ptr = mark_stack_ptr + 8;
        if (mark_stack_ptr >= mark_stack_limit) goto <D.8621>; else goto <D.8622>;
        <D.8621>:
        mark_stack_ptr = GC_signal_mark_stack_overflow (mark_stack_ptr);
        <D.8622>:
        displ.113 = (unsigned int) displ;
        D.8624 = displ.113 * 4;
        my_current.114 = (sizetype) my_current;
        D.8626 = my_current.114 & 4294963200;
        D.8627 = D.8624 + D.8626;
        D.8628 = (GC_word *) D.8627;
        mark_stack_ptr->mse_start = D.8628;
        mark_stack_ptr->mse_descr = _descr;
        <D.8620>:
      }
    }
    was_marked:
  }
  D.8629 = mark_stack_ptr;
  return D.8629;
}


GC_mark_and_push_stack (word p)
{
  long unsigned int D.8631;
  struct bottom_index * D.8632;
  long unsigned int D.8633;
  long unsigned int D.8634;
  long unsigned int hhdr.115;
  void * p.116;
  void * D.8641;
  long unsigned int D.8642;
  struct bottom_index * D.8643;
  long unsigned int D.8644;
  long unsigned int D.8645;
  long unsigned int D.8646;
  long unsigned int D.8647;
  int p.117;
  map_entry_type * D.8650;
  sizetype displ.118;
  map_entry_type * D.8652;
  int GC_all_interior_pointers.119;
  void * D.8660;
  int D.8664;
  unsigned int displ.120;
  unsigned int D.8666;
  sizetype D.8667;
  int D.8671;
  long unsigned int D.8672;
  int D.8673;
  long unsigned int D.8674;
  long unsigned int D.8675;
  sizetype D.8678;
  long unsigned int D.8679;
  long unsigned int D.8680;
  long unsigned int D.8681;
  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.8631 = p >> 22;
  D.8632 = GC_arrays._top_index[D.8631];
  D.8633 = p >> 12;
  D.8634 = D.8633 & 1023;
  hhdr = D.8632->index[D.8634];
  hhdr.115 = (long unsigned int) hhdr;
  if (hhdr.115 <= 4095) goto <D.8636>; else goto <D.8637>;
  <D.8636>:
  if (hhdr != 0B) goto <D.8638>; else goto <D.8639>;
  <D.8638>:
  p.116 = (void *) p;
  D.8641 = GC_base (p.116);
  r = (word) D.8641;
  D.8642 = r >> 22;
  D.8643 = GC_arrays._top_index[D.8642];
  D.8644 = r >> 12;
  D.8645 = D.8644 & 1023;
  hhdr = D.8643->index[D.8645];
  D.8646 = r & 4095;
  D.8647 = D.8646 >> 2;
  displ = (int) D.8647;
  <D.8639>:
  goto <D.8648>;
  <D.8637>:
  {
    register map_entry_type map_entry;

    p.117 = (int) p;
    displ = p.117 & 4095;
    D.8650 = hhdr->hb_map;
    displ.118 = (sizetype) displ;
    D.8652 = D.8650 + displ.118;
    map_entry = *D.8652;
    if (map_entry > 252) goto <D.8653>; else goto <D.8654>;
    <D.8653>:
    if (map_entry == 254) goto <D.8655>; else goto <D.8658>;
    <D.8658>:
    GC_all_interior_pointers.119 = GC_all_interior_pointers;
    if (GC_all_interior_pointers.119 == 0) goto <D.8655>; else goto <D.8656>;
    <D.8655>:
    p.116 = (void *) p;
    D.8660 = GC_base (p.116);
    r = (word) D.8660;
    D.8646 = r & 4095;
    D.8647 = D.8646 >> 2;
    displ = (int) D.8647;
    if (r == 0) goto <D.8661>; else goto <D.8662>;
    <D.8661>:
    hhdr = 0B;
    <D.8662>:
    goto <D.8657>;
    <D.8656>:
    hhdr = 0B;
    <D.8657>:
    goto <D.8663>;
    <D.8654>:
    displ = displ >> 2;
    D.8664 = (int) map_entry;
    displ = displ - D.8664;
    displ.120 = (unsigned int) displ;
    D.8666 = displ.120 * 4;
    D.8667 = p & 4294963200;
    r = D.8666 + D.8667;
    <D.8663>:
  }
  <D.8648>:
  if (hhdr == 0B) goto <D.8668>; else goto <D.8669>;
  <D.8668>:
  GC_add_to_black_list_stack (p);
  goto <D.8670>;
  <D.8669>:
  D.8671 = displ >> 5;
  D.8672 = hhdr->hb_marks[D.8671];
  D.8673 = displ & 31;
  D.8674 = D.8672 >> D.8673;
  D.8675 = D.8674 & 1;
  if (D.8675 == 0) goto <D.8676>; else goto <D.8677>;
  <D.8676>:
  D.8671 = displ >> 5;
  D.8678 = (sizetype) D.8671;
  D.8671 = displ >> 5;
  D.8678 = (sizetype) D.8671;
  D.8679 = hhdr->hb_marks[D.8678];
  D.8673 = displ & 31;
  D.8680 = 1 << D.8673;
  D.8681 = D.8679 | D.8680;
  hhdr->hb_marks[D.8678] = D.8681;
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.8682>; else goto <D.8683>;
    <D.8682>:
    goto <D.8684>;
    <D.8683>:
    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.8688>; else goto <D.8689>;
    <D.8688>:
    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.8689>:
    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.8684>:
  }
  <D.8677>:
  <D.8670>:
}


GC_push_all_eager (char * bottom, char * top)
{
  long unsigned int bottom.126;
  long unsigned int D.8693;
  long unsigned int D.8694;
  long unsigned int top.127;
  long unsigned int D.8696;
  char * q.128;
  _Bool D.8700;
  _Bool D.8701;
  _Bool D.8702;
  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.8693 = bottom.126 + 3;
  D.8694 = D.8693 & 4294967292;
  b = (word *) D.8694;
  top.127 = (long unsigned int) top;
  D.8696 = top.127 & 4294967292;
  t = (word *) D.8696;
  greatest_ha = GC_greatest_plausible_heap_addr;
  least_ha = GC_least_plausible_heap_addr;
  if (top == 0B) goto <D.8697>; else goto <D.8698>;
  <D.8697>:
  return;
  <D.8698>:
  lim = t + 4294967292;
  p = b;
  goto <D.7940>;
  <D.7939>:
  q = *p;
  q.128 = (char *) q;
  D.8700 = q.128 >= least_ha;
  q.128 = (char *) q;
  D.8701 = q.128 < greatest_ha;
  D.8702 = D.8700 & D.8701;
  if (D.8702 != 0) goto <D.8703>; else goto <D.8704>;
  <D.8703>:
  GC_mark_and_push_stack (q);
  <D.8704>:
  p = p + 4;
  <D.7940>:
  if (p <= lim) goto <D.7939>; else goto <D.7941>;
  <D.7941>:
}


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.8707>; else goto <D.8708>;
  <D.8707>:
  GC_push_all (bottom, top);
  goto <D.8709>;
  <D.8708>:
  GC_push_all_eager (bottom, top);
  <D.8709>:
}


GC_push_marked1 (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int h.130;
  long unsigned int D.8711;
  word * mark_word_addr.131;
  long unsigned int D.8713;
  unsigned int i.132;
  unsigned int D.8717;
  word * D.8718;
  char * q.133;
  _Bool D.8720;
  _Bool D.8721;
  _Bool D.8722;
  void * q.134;
  void * * D.8726;
  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.8711 = h.130 + 4096;
  plim = (word *) D.8711;
  goto <D.7964>;
  <D.7963>:
  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.7961>;
  <D.7960>:
  D.8713 = mark_word & 1;
  if (D.8713 != 0) goto <D.8714>; else goto <D.8715>;
  <D.8714>:
  i.132 = (unsigned int) i;
  D.8717 = i.132 * 4;
  D.8718 = p + D.8717;
  q = *D.8718;
  q.133 = (char *) q;
  D.8720 = q.133 >= least_ha;
  q.133 = (char *) q;
  D.8721 = q.133 < greatest_ha;
  D.8722 = D.8720 & D.8721;
  if (D.8722 != 0) goto <D.8723>; else goto <D.8724>;
  <D.8723>:
  q.134 = (void *) q;
  i.132 = (unsigned int) i;
  D.8717 = i.132 * 4;
  D.8726 = p + D.8717;
  mark_stack_top = GC_mark_and_push (q.134, mark_stack_top, mark_stack_limit, D.8726);
  <D.8724>:
  <D.8715>:
  i = i + 1;
  mark_word = mark_word >> 1;
  <D.7961>:
  if (mark_word != 0) goto <D.7960>; else goto <D.7962>;
  <D.7962>:
  p = p + 128;
  <D.7964>:
  if (p < plim) goto <D.7963>; else goto <D.7965>;
  <D.7965>:
  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.8728;
  word * mark_word_addr.136;
  long unsigned int D.8730;
  unsigned int i.137;
  unsigned int D.8734;
  word * D.8735;
  char * q.138;
  _Bool D.8737;
  _Bool D.8738;
  _Bool D.8739;
  void * q.139;
  void * * D.8743;
  sizetype i.140;
  sizetype D.8745;
  sizetype D.8746;
  word * D.8747;
  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.8728 = h.135 + 4096;
  plim = (word *) D.8728;
  goto <D.7984>;
  <D.7983>:
  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.7981>;
  <D.7980>:
  D.8730 = mark_word & 1;
  if (D.8730 != 0) goto <D.8731>; else goto <D.8732>;
  <D.8731>:
  i.137 = (unsigned int) i;
  D.8734 = i.137 * 4;
  D.8735 = p + D.8734;
  q = *D.8735;
  q.138 = (char *) q;
  D.8737 = q.138 >= least_ha;
  q.138 = (char *) q;
  D.8738 = q.138 < greatest_ha;
  D.8739 = D.8737 & D.8738;
  if (D.8739 != 0) goto <D.8740>; else goto <D.8741>;
  <D.8740>:
  q.139 = (void *) q;
  i.137 = (unsigned int) i;
  D.8734 = i.137 * 4;
  D.8743 = p + D.8734;
  mark_stack_top = GC_mark_and_push (q.139, mark_stack_top, mark_stack_limit, D.8743);
  <D.8741>:
  i.140 = (sizetype) i;
  D.8745 = i.140 + 1;
  D.8746 = D.8745 * 4;
  D.8747 = p + D.8746;
  q = *D.8747;
  q.138 = (char *) q;
  D.8737 = q.138 >= least_ha;
  q.138 = (char *) q;
  D.8738 = q.138 < greatest_ha;
  D.8739 = D.8737 & D.8738;
  if (D.8739 != 0) goto <D.8748>; else goto <D.8749>;
  <D.8748>:
  q.139 = (void *) q;
  i.137 = (unsigned int) i;
  D.8734 = i.137 * 4;
  D.8743 = p + D.8734;
  mark_stack_top = GC_mark_and_push (q.139, mark_stack_top, mark_stack_limit, D.8743);
  <D.8749>:
  <D.8732>:
  i = i + 2;
  mark_word = mark_word >> 2;
  <D.7981>:
  if (mark_word != 0) goto <D.7980>; else goto <D.7982>;
  <D.7982>:
  p = p + 128;
  <D.7984>:
  if (p < plim) goto <D.7983>; else goto <D.7985>;
  <D.7985>:
  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.8751;
  word * mark_word_addr.142;
  long unsigned int D.8753;
  unsigned int i.143;
  unsigned int D.8757;
  word * D.8758;
  char * q.144;
  _Bool D.8760;
  _Bool D.8761;
  _Bool D.8762;
  void * q.145;
  void * * D.8766;
  sizetype i.146;
  sizetype D.8768;
  sizetype D.8769;
  word * D.8770;
  sizetype D.8773;
  sizetype D.8774;
  word * D.8775;
  sizetype D.8778;
  sizetype D.8779;
  word * D.8780;
  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.8751 = h.141 + 4096;
  plim = (word *) D.8751;
  goto <D.8004>;
  <D.8003>:
  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.8001>;
  <D.8000>:
  D.8753 = mark_word & 1;
  if (D.8753 != 0) goto <D.8754>; else goto <D.8755>;
  <D.8754>:
  i.143 = (unsigned int) i;
  D.8757 = i.143 * 4;
  D.8758 = p + D.8757;
  q = *D.8758;
  q.144 = (char *) q;
  D.8760 = q.144 >= least_ha;
  q.144 = (char *) q;
  D.8761 = q.144 < greatest_ha;
  D.8762 = D.8760 & D.8761;
  if (D.8762 != 0) goto <D.8763>; else goto <D.8764>;
  <D.8763>:
  q.145 = (void *) q;
  i.143 = (unsigned int) i;
  D.8757 = i.143 * 4;
  D.8766 = p + D.8757;
  mark_stack_top = GC_mark_and_push (q.145, mark_stack_top, mark_stack_limit, D.8766);
  <D.8764>:
  i.146 = (sizetype) i;
  D.8768 = i.146 + 1;
  D.8769 = D.8768 * 4;
  D.8770 = p + D.8769;
  q = *D.8770;
  q.144 = (char *) q;
  D.8760 = q.144 >= least_ha;
  q.144 = (char *) q;
  D.8761 = q.144 < greatest_ha;
  D.8762 = D.8760 & D.8761;
  if (D.8762 != 0) goto <D.8771>; else goto <D.8772>;
  <D.8771>:
  q.145 = (void *) q;
  i.146 = (sizetype) i;
  D.8768 = i.146 + 1;
  D.8769 = D.8768 * 4;
  D.8770 = p + D.8769;
  mark_stack_top = GC_mark_and_push (q.145, mark_stack_top, mark_stack_limit, D.8770);
  <D.8772>:
  i.146 = (sizetype) i;
  D.8773 = i.146 + 2;
  D.8774 = D.8773 * 4;
  D.8775 = p + D.8774;
  q = *D.8775;
  q.144 = (char *) q;
  D.8760 = q.144 >= least_ha;
  q.144 = (char *) q;
  D.8761 = q.144 < greatest_ha;
  D.8762 = D.8760 & D.8761;
  if (D.8762 != 0) goto <D.8776>; else goto <D.8777>;
  <D.8776>:
  q.145 = (void *) q;
  i.146 = (sizetype) i;
  D.8773 = i.146 + 2;
  D.8774 = D.8773 * 4;
  D.8775 = p + D.8774;
  mark_stack_top = GC_mark_and_push (q.145, mark_stack_top, mark_stack_limit, D.8775);
  <D.8777>:
  i.146 = (sizetype) i;
  D.8778 = i.146 + 3;
  D.8779 = D.8778 * 4;
  D.8780 = p + D.8779;
  q = *D.8780;
  q.144 = (char *) q;
  D.8760 = q.144 >= least_ha;
  q.144 = (char *) q;
  D.8761 = q.144 < greatest_ha;
  D.8762 = D.8760 & D.8761;
  if (D.8762 != 0) goto <D.8781>; else goto <D.8782>;
  <D.8781>:
  q.145 = (void *) q;
  i.146 = (sizetype) i;
  D.8778 = i.146 + 3;
  D.8779 = D.8778 * 4;
  D.8780 = p + D.8779;
  mark_stack_top = GC_mark_and_push (q.145, mark_stack_top, mark_stack_limit, D.8780);
  <D.8782>:
  <D.8755>:
  i = i + 4;
  mark_word = mark_word >> 4;
  <D.8001>:
  if (mark_word != 0) goto <D.8000>; else goto <D.8002>;
  <D.8002>:
  p = p + 128;
  <D.8004>:
  if (p < plim) goto <D.8003>; else goto <D.8005>;
  <D.8005>:
  GC_mark_stack_top = mark_stack_top;
}


GC_push_marked (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.8783;
  long unsigned int D.8784;
  int D.8787;
  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.8797;
  sizetype D.8798;
  int D.8799;
  long unsigned int D.8800;
  int D.8801;
  long unsigned int D.8802;
  long unsigned int D.8803;
  unsigned int sz.151;
  unsigned int D.8812;
  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.8783 = hhdr->hb_sz;
  sz = (int) D.8783;
  D.8784 = hhdr->hb_descr;
  descr = (int) D.8784;
  mark_stack_limit = GC_mark_stack_limit;
  if (descr == 0) goto <D.8785>; else goto <D.8786>;
  <D.8785>:
  return;
  <D.8786>:
  D.8787 = GC_block_empty (hhdr);
  if (D.8787 != 0) goto <D.8788>; else goto <D.8789>;
  <D.8788>:
  return;
  <D.8789>:
  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.8793>; else goto <D.8794>;
  <D.8793>:
  lim = h;
  goto <D.8795>;
  <D.8794>:
  sz.150 = (sizetype) sz;
  D.8797 = sz.150 * 4294967292;
  D.8798 = D.8797 + 4096;
  lim = h + D.8798;
  <D.8795>:
  switch (sz) <default: <D.8021>, case 1: <D.8017>, case 2: <D.8019>, case 4: <D.8020>>
  <D.8017>:
  GC_push_marked1 (h, hhdr);
  goto <D.8018>;
  <D.8019>:
  GC_push_marked2 (h, hhdr);
  goto <D.8018>;
  <D.8020>:
  GC_push_marked4 (h, hhdr);
  goto <D.8018>;
  <D.8021>:
  GC_mark_stack_top_reg = GC_mark_stack_top;
  p = h;
  word_no = 0;
  goto <D.8024>;
  <D.8023>:
  D.8799 = word_no >> 5;
  D.8800 = hhdr->hb_marks[D.8799];
  D.8801 = word_no & 31;
  D.8802 = D.8800 >> D.8801;
  D.8803 = D.8802 & 1;
  if (D.8803 != 0) goto <D.8804>; else goto <D.8805>;
  <D.8804>:
  {
    register word _descr;

    _descr = hhdr->hb_descr;
    if (_descr == 0) goto <D.8806>; else goto <D.8807>;
    <D.8806>:
    goto <D.8808>;
    <D.8807>:
    GC_mark_stack_top_reg = GC_mark_stack_top_reg + 8;
    if (GC_mark_stack_top_reg >= mark_stack_limit) goto <D.8809>; else goto <D.8810>;
    <D.8809>:
    GC_mark_stack_top_reg = GC_signal_mark_stack_overflow (GC_mark_stack_top_reg);
    <D.8810>:
    GC_mark_stack_top_reg->mse_start = p;
    GC_mark_stack_top_reg->mse_descr = _descr;
    <D.8808>:
  }
  <D.8805>:
  sz.151 = (unsigned int) sz;
  D.8812 = sz.151 * 4;
  p = p + D.8812;
  word_no = word_no + sz;
  <D.8024>:
  if (p <= lim) goto <D.8023>; else goto <D.8025>;
  <D.8025>:
  GC_mark_stack_top = GC_mark_stack_top_reg;
  <D.8018>:
}


GC_block_was_dirty (struct hblk * h, struct hdr * hhdr)
{
  long unsigned int D.8814;
  long unsigned int sz.152;
  GC_bool D.8818;
  int D.8819;
  sizetype sz.153;
  char * D.8823;
  register int sz;

  D.8814 = hhdr->hb_sz;
  sz = (int) D.8814;
  sz.152 = (long unsigned int) sz;
  if (sz.152 <= 512) goto <D.8816>; else goto <D.8817>;
  <D.8816>:
  D.8818 = GC_page_was_dirty (h);
  return D.8818;
  <D.8817>:
  {
    register char * p;

    p = h;
    sz = sz << 2;
    goto <D.8033>;
    <D.8032>:
    D.8819 = GC_page_was_dirty (p);
    if (D.8819 != 0) goto <D.8820>; else goto <D.8821>;
    <D.8820>:
    D.8818 = 1;
    return D.8818;
    <D.8821>:
    p = p + 4096;
    <D.8033>:
    sz.153 = (sizetype) sz;
    D.8823 = h + sz.153;
    if (D.8823 > p) goto <D.8032>; else goto <D.8034>;
    <D.8034>:
    D.8818 = 0;
    return D.8818;
  }
}


GC_push_next_marked (struct hblk * h)
{
  struct hblk * D.8827;
  long unsigned int h.154;
  long unsigned int D.8829;
  struct bottom_index * D.8830;
  long unsigned int D.8831;
  long unsigned int D.8832;
  long unsigned int D.8833;
  long unsigned int D.8834;
  long unsigned int D.8835;
  long unsigned int D.8836;
  long unsigned int D.8837;
  register struct hdr * hhdr;

  h = GC_next_used_block (h);
  if (h == 0B) goto <D.8825>; else goto <D.8826>;
  <D.8825>:
  D.8827 = 0B;
  return D.8827;
  <D.8826>:
  h.154 = (long unsigned int) h;
  D.8829 = h.154 >> 22;
  D.8830 = GC_arrays._top_index[D.8829];
  h.154 = (long unsigned int) h;
  D.8831 = h.154 >> 12;
  D.8832 = D.8831 & 1023;
  hhdr = D.8830->index[D.8832];
  GC_push_marked (h, hhdr);
  D.8833 = hhdr->hb_sz;
  D.8834 = D.8833 << 2;
  D.8835 = D.8834 + 4095;
  D.8836 = D.8835 >> 12;
  D.8837 = D.8836 * 4096;
  D.8827 = h + D.8837;
  return D.8827;
}


GC_push_next_marked_dirty (struct hblk * h)
{
  int GC_dirty_maintained.155;
  struct hblk * D.8844;
  long unsigned int h.156;
  long unsigned int D.8846;
  struct bottom_index * D.8847;
  long unsigned int D.8848;
  long unsigned int D.8849;
  int D.8850;
  long unsigned int D.8852;
  long unsigned int D.8853;
  long unsigned int D.8854;
  long unsigned int D.8855;
  long unsigned int D.8856;
  register struct hdr * hhdr;

  GC_dirty_maintained.155 = GC_dirty_maintained;
  if (GC_dirty_maintained.155 == 0) goto <D.8840>; else goto <D.8841>;
  <D.8840>:
  GC_abort ("dirty bits not set up");
  <D.8841>:
  <D.8044>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.8842>; else goto <D.8843>;
  <D.8842>:
  D.8844 = 0B;
  return D.8844;
  <D.8843>:
  h.156 = (long unsigned int) h;
  D.8846 = h.156 >> 22;
  D.8847 = GC_arrays._top_index[D.8846];
  h.156 = (long unsigned int) h;
  D.8848 = h.156 >> 12;
  D.8849 = D.8848 & 1023;
  hhdr = D.8847->index[D.8849];
  D.8850 = GC_block_was_dirty (h, hhdr);
  if (D.8850 != 0) goto <D.8043>; else goto <D.8851>;
  <D.8851>:
  D.8852 = hhdr->hb_sz;
  D.8853 = D.8852 << 2;
  D.8854 = D.8853 + 4095;
  D.8855 = D.8854 >> 12;
  D.8856 = D.8855 * 4096;
  h = h + D.8856;
  goto <D.8044>;
  <D.8043>:
  GC_push_marked (h, hhdr);
  D.8852 = hhdr->hb_sz;
  D.8853 = D.8852 << 2;
  D.8854 = D.8853 + 4095;
  D.8855 = D.8854 >> 12;
  D.8856 = D.8855 * 4096;
  D.8844 = h + D.8856;
  return D.8844;
}


GC_push_next_marked_uncollectable (struct hblk * h)
{
  long unsigned int h.157;
  long unsigned int D.8859;
  struct bottom_index * D.8860;
  long unsigned int D.8861;
  long unsigned int D.8862;
  struct hblk * D.8865;
  unsigned char D.8866;
  long unsigned int D.8868;
  long unsigned int D.8869;
  long unsigned int D.8870;
  long unsigned int D.8871;
  long unsigned int D.8872;
  register struct hdr * hhdr;

  h.157 = (long unsigned int) h;
  D.8859 = h.157 >> 22;
  D.8860 = GC_arrays._top_index[D.8859];
  h.157 = (long unsigned int) h;
  D.8861 = h.157 >> 12;
  D.8862 = D.8861 & 1023;
  hhdr = D.8860->index[D.8862];
  <D.8050>:
  h = GC_next_used_block (h);
  if (h == 0B) goto <D.8863>; else goto <D.8864>;
  <D.8863>:
  D.8865 = 0B;
  return D.8865;
  <D.8864>:
  h.157 = (long unsigned int) h;
  D.8859 = h.157 >> 22;
  D.8860 = GC_arrays._top_index[D.8859];
  h.157 = (long unsigned int) h;
  D.8861 = h.157 >> 12;
  D.8862 = D.8861 & 1023;
  hhdr = D.8860->index[D.8862];
  D.8866 = hhdr->hb_obj_kind;
  if (D.8866 == 2) goto <D.8049>; else goto <D.8867>;
  <D.8867>:
  D.8868 = hhdr->hb_sz;
  D.8869 = D.8868 << 2;
  D.8870 = D.8869 + 4095;
  D.8871 = D.8870 >> 12;
  D.8872 = D.8871 * 4096;
  h = h + D.8872;
  goto <D.8050>;
  <D.8049>:
  GC_push_marked (h, hhdr);
  D.8868 = hhdr->hb_sz;
  D.8869 = D.8868 << 2;
  D.8870 = D.8869 + 4095;
  D.8871 = D.8870 >> 12;
  D.8872 = D.8871 * 4096;
  D.8865 = h + D.8872;
  return D.8865;
}