GC_print_static_roots ()
{
  char * D.5675;
  long int D.5676;
  char * D.5677;
  long int D.5678;
  int D.5679;
  long int D.5683;
  long int D.5684;
  long int D.5685;
  long unsigned int D.5686;
  int n_root_sets.0;
  long int total.1;
  long unsigned int GC_root_size.2;
  long int GC_root_size.3;
  register int i;
  size_t total;

  total = 0;
  i = 0;
  goto <D.5544>;
  <D.5543>:
  D.5675 = GC_arrays._static_roots[i].r_end;
  D.5676 = (long int) D.5675;
  D.5677 = GC_arrays._static_roots[i].r_start;
  D.5678 = (long int) D.5677;
  GC_printf ("From 0x%lx to 0x%lx ", D.5678, D.5676, 0, 0, 0, 0);
  D.5679 = GC_arrays._static_roots[i].r_tmp;
  if (D.5679 != 0) goto <D.5680>; else goto <D.5681>;
  <D.5680>:
  GC_printf (" (temporary)\n", 0, 0, 0, 0, 0, 0);
  goto <D.5682>;
  <D.5681>:
  GC_printf ("\n", 0, 0, 0, 0, 0, 0);
  <D.5682>:
  D.5675 = GC_arrays._static_roots[i].r_end;
  D.5683 = (long int) D.5675;
  D.5677 = GC_arrays._static_roots[i].r_start;
  D.5684 = (long int) D.5677;
  D.5685 = D.5683 - D.5684;
  D.5686 = (long unsigned int) D.5685;
  total = D.5686 + total;
  i = i + 1;
  <D.5544>:
  n_root_sets.0 = n_root_sets;
  if (i < n_root_sets.0) goto <D.5543>; else goto <D.5545>;
  <D.5545>:
  total.1 = (long int) total;
  GC_printf ("Total size: %ld\n", total.1, 0, 0, 0, 0, 0);
  GC_root_size.2 = GC_root_size;
  if (GC_root_size.2 != total) goto <D.5690>; else goto <D.5691>;
  <D.5690>:
  GC_root_size.2 = GC_root_size;
  GC_root_size.3 = (long int) GC_root_size.2;
  GC_printf ("GC_root_size incorrect: %ld!!\n", GC_root_size.3, 0, 0, 0, 0, 0);
  <D.5691>:
}


GC_is_static_root (char * p)
{
  int last_root_set.4;
  int n_root_sets.5;
  char * D.5697;
  char * D.5700;
  GC_bool D.5703;
  char * D.5704;
  char * D.5707;
  static int last_root_set = 1024;
  register int i;

  last_root_set.4 = last_root_set;
  n_root_sets.5 = n_root_sets;
  if (last_root_set.4 < n_root_sets.5) goto <D.5695>; else goto <D.5696>;
  <D.5695>:
  last_root_set.4 = last_root_set;
  D.5697 = GC_arrays._static_roots[last_root_set.4].r_start;
  if (D.5697 <= p) goto <D.5698>; else goto <D.5699>;
  <D.5698>:
  last_root_set.4 = last_root_set;
  D.5700 = GC_arrays._static_roots[last_root_set.4].r_end;
  if (D.5700 > p) goto <D.5701>; else goto <D.5702>;
  <D.5701>:
  D.5703 = 1;
  return D.5703;
  <D.5702>:
  <D.5699>:
  <D.5696>:
  i = 0;
  goto <D.5552>;
  <D.5551>:
  D.5704 = GC_arrays._static_roots[i].r_start;
  if (D.5704 <= p) goto <D.5705>; else goto <D.5706>;
  <D.5705>:
  D.5707 = GC_arrays._static_roots[i].r_end;
  if (D.5707 > p) goto <D.5708>; else goto <D.5709>;
  <D.5708>:
  last_root_set = i;
  D.5703 = 1;
  return D.5703;
  <D.5709>:
  <D.5706>:
  i = i + 1;
  <D.5552>:
  n_root_sets.5 = n_root_sets;
  if (i < n_root_sets.5) goto <D.5551>; else goto <D.5553>;
  <D.5553>:
  D.5703 = 0;
  return D.5703;
}


GC_roots_present (char * b)
{
  char * D.5711;
  struct roots * D.5714;
  register int h;
  register struct roots * p;

  h = rt_hash (b);
  p = GC_arrays._root_index[h];
  goto <D.5564>;
  <D.5563>:
  D.5711 = p->r_start;
  if (D.5711 == b) goto <D.5712>; else goto <D.5713>;
  <D.5712>:
  D.5714 = p;
  return D.5714;
  <D.5713>:
  p = p->r_next;
  <D.5564>:
  if (p != 0B) goto <D.5563>; else goto <D.5565>;
  <D.5565>:
  D.5714 = 0B;
  return D.5714;
}


rt_hash (char * addr)
{
  long unsigned int D.5716;
  long unsigned int D.5717;
  long unsigned int D.5718;
  long unsigned int D.5719;
  int D.5720;
  word result;

  result = (word) addr;
  D.5716 = result >> 48;
  result = D.5716 ^ result;
  D.5717 = result >> 24;
  result = D.5717 ^ result;
  D.5718 = result >> 12;
  result = D.5718 ^ result;
  D.5719 = result >> 6;
  result = D.5719 ^ result;
  result = result & 63;
  D.5720 = (int) result;
  return D.5720;
}


GC_add_roots (char * b, char * e)
{
  int D.5722;

  D.5722 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5722 != 0) goto <D.5723>; else goto <D.5724>;
  <D.5723>:
  GC_lock ();
  <D.5724>:
  GC_add_roots_inner (b, e, 0);
  pthread_mutex_unlock (&GC_allocate_ml);
}


GC_add_roots_inner (char * b, char * e, GC_bool tmp)
{
  char * D.5727;
  long int e.6;
  long int D.5731;
  long int D.5732;
  long unsigned int D.5733;
  long unsigned int GC_root_size.7;
  long unsigned int GC_root_size.8;
  int n_root_sets.9;
  sizetype D.5739;
  struct roots * D.5740;
  long int b.10;
  long int D.5742;
  long unsigned int D.5743;
  long unsigned int GC_root_size.11;
  int n_root_sets.12;
  struct roots * old;

  old = GC_roots_present (b);
  if (old != 0B) goto <D.5725>; else goto <D.5726>;
  <D.5725>:
  D.5727 = old->r_end;
  if (D.5727 >= e) goto <D.5728>; else goto <D.5729>;
  <D.5728>:
  return;
  <D.5729>:
  e.6 = (long int) e;
  D.5727 = old->r_end;
  D.5731 = (long int) D.5727;
  D.5732 = e.6 - D.5731;
  D.5733 = (long unsigned int) D.5732;
  GC_root_size.7 = GC_root_size;
  GC_root_size.8 = D.5733 + GC_root_size.7;
  GC_root_size = GC_root_size.8;
  old->r_end = e;
  return;
  <D.5726>:
  n_root_sets.9 = n_root_sets;
  if (n_root_sets.9 == 1024) goto <D.5737>; else goto <D.5738>;
  <D.5737>:
  GC_abort ("Too many root sets\n");
  <D.5738>:
  n_root_sets.9 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.9].r_start = b;
  n_root_sets.9 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.9].r_end = e;
  n_root_sets.9 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.9].r_tmp = tmp;
  n_root_sets.9 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.9].r_next = 0B;
  n_root_sets.9 = n_root_sets;
  D.5739 = (sizetype) n_root_sets.9;
  D.5740 = &GC_arrays._static_roots[D.5739];
  add_roots_to_index (D.5740);
  e.6 = (long int) e;
  b.10 = (long int) b;
  D.5742 = e.6 - b.10;
  D.5743 = (long unsigned int) D.5742;
  GC_root_size.7 = GC_root_size;
  GC_root_size.11 = D.5743 + GC_root_size.7;
  GC_root_size = GC_root_size.11;
  n_root_sets.9 = n_root_sets;
  n_root_sets.12 = n_root_sets.9 + 1;
  n_root_sets = n_root_sets.12;
}


add_roots_to_index (struct roots * p)
{
  char * D.5747;
  struct roots * D.5748;
  register int h;

  D.5747 = p->r_start;
  h = rt_hash (D.5747);
  D.5748 = GC_arrays._root_index[h];
  p->r_next = D.5748;
  GC_arrays._root_index[h] = p;
}


GC_clear_roots ()
{
  int D.5749;

  D.5749 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5749 != 0) goto <D.5750>; else goto <D.5751>;
  <D.5750>:
  GC_lock ();
  <D.5751>:
  roots_were_cleared = 1;
  n_root_sets = 0;
  GC_root_size = 0;
  {
    register int i;

    i = 0;
    goto <D.5587>;
    <D.5586>:
    GC_arrays._root_index[i] = 0B;
    i = i + 1;
    <D.5587>:
    if (i <= 63) goto <D.5586>; else goto <D.5588>;
    <D.5588>:
  }
  pthread_mutex_unlock (&GC_allocate_ml);
}


GC_remove_tmp_roots ()
{
  int D.5752;
  int n_root_sets.13;
  register int i;

  i = 0;
  goto <D.5605>;
  <D.5604>:
  D.5752 = GC_arrays._static_roots[i].r_tmp;
  if (D.5752 != 0) goto <D.5753>; else goto <D.5754>;
  <D.5753>:
  GC_remove_root_at_pos (i);
  goto <D.5755>;
  <D.5754>:
  i = i + 1;
  <D.5755>:
  <D.5605>:
  n_root_sets.13 = n_root_sets;
  if (i < n_root_sets.13) goto <D.5604>; else goto <D.5606>;
  <D.5606>:
  GC_rebuild_root_index ();
}


GC_remove_root_at_pos (int i)
{
  char * D.5757;
  long int D.5758;
  char * D.5759;
  long int D.5760;
  long int D.5761;
  long unsigned int D.5762;
  long unsigned int GC_root_size.14;
  long unsigned int GC_root_size.15;
  int n_root_sets.16;
  int n_root_sets.17;
  char * D.5767;
  char * D.5768;
  int D.5769;

  D.5757 = GC_arrays._static_roots[i].r_start;
  D.5758 = (long int) D.5757;
  D.5759 = GC_arrays._static_roots[i].r_end;
  D.5760 = (long int) D.5759;
  D.5761 = D.5758 - D.5760;
  D.5762 = (long unsigned int) D.5761;
  GC_root_size.14 = GC_root_size;
  GC_root_size.15 = D.5762 + GC_root_size.14;
  GC_root_size = GC_root_size.15;
  n_root_sets.16 = n_root_sets;
  n_root_sets.17 = n_root_sets.16 + -1;
  D.5767 = GC_arrays._static_roots[n_root_sets.17].r_start;
  GC_arrays._static_roots[i].r_start = D.5767;
  n_root_sets.16 = n_root_sets;
  n_root_sets.17 = n_root_sets.16 + -1;
  D.5768 = GC_arrays._static_roots[n_root_sets.17].r_end;
  GC_arrays._static_roots[i].r_end = D.5768;
  n_root_sets.16 = n_root_sets;
  n_root_sets.17 = n_root_sets.16 + -1;
  D.5769 = GC_arrays._static_roots[n_root_sets.17].r_tmp;
  GC_arrays._static_roots[i].r_tmp = D.5769;
  n_root_sets.16 = n_root_sets;
  n_root_sets.17 = n_root_sets.16 + -1;
  n_root_sets = n_root_sets.17;
}


GC_rebuild_root_index ()
{
  sizetype D.5770;
  struct roots * D.5771;
  int n_root_sets.18;
  register int i;

  i = 0;
  goto <D.5596>;
  <D.5595>:
  GC_arrays._root_index[i] = 0B;
  i = i + 1;
  <D.5596>:
  if (i <= 63) goto <D.5595>; else goto <D.5597>;
  <D.5597>:
  i = 0;
  goto <D.5599>;
  <D.5598>:
  D.5770 = (sizetype) i;
  D.5771 = &GC_arrays._static_roots[D.5770];
  add_roots_to_index (D.5771);
  i = i + 1;
  <D.5599>:
  n_root_sets.18 = n_root_sets;
  if (i < n_root_sets.18) goto <D.5598>; else goto <D.5600>;
  <D.5600>:
}


GC_remove_roots (char * b, char * e)
{
  int D.5773;

  D.5773 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5773 != 0) goto <D.5774>; else goto <D.5775>;
  <D.5774>:
  GC_lock ();
  <D.5775>:
  GC_remove_roots_inner (b, e);
  pthread_mutex_unlock (&GC_allocate_ml);
}


GC_remove_roots_inner (char * b, char * e)
{
  char * D.5778;
  char * D.5780;
  int n_root_sets.19;
  int i;

  i = 0;
  goto <D.5617>;
  <D.5616>:
  D.5778 = GC_arrays._static_roots[i].r_start;
  if (D.5778 >= b) goto <D.5779>; else goto <D.5776>;
  <D.5779>:
  D.5780 = GC_arrays._static_roots[i].r_end;
  if (D.5780 <= e) goto <D.5781>; else goto <D.5776>;
  <D.5781>:
  GC_remove_root_at_pos (i);
  goto <D.5777>;
  <D.5776>:
  i = i + 1;
  <D.5777>:
  <D.5617>:
  n_root_sets.19 = n_root_sets;
  if (i < n_root_sets.19) goto <D.5616>; else goto <D.5618>;
  <D.5618>:
  GC_rebuild_root_index ();
}


GC_approx_sp ()
{
  char * D.5783;
  volatile word dummy;

  dummy = 42;
  D.5783 = &dummy;
  return D.5783;
}


GC_next_exclusion (char * start_addr)
{
  long unsigned int GC_excl_table_entries.20;
  long unsigned int D.5786;
  char * D.5787;
  long unsigned int D.5788;
  long unsigned int start_addr.21;
  char * D.5793;
  long unsigned int D.5794;
  struct exclusion * D.5797;
  size_t low;
  size_t high;
  size_t mid;

  low = 0;
  GC_excl_table_entries.20 = GC_excl_table_entries;
  high = GC_excl_table_entries.20 + 18446744073709551615;
  goto <D.5630>;
  <D.5629>:
  D.5786 = low + high;
  mid = D.5786 >> 1;
  D.5787 = GC_arrays._excl_table[mid].e_end;
  D.5788 = (long unsigned int) D.5787;
  start_addr.21 = (long unsigned int) start_addr;
  if (D.5788 <= start_addr.21) goto <D.5790>; else goto <D.5791>;
  <D.5790>:
  low = mid + 1;
  goto <D.5792>;
  <D.5791>:
  high = mid;
  <D.5792>:
  <D.5630>:
  if (high > low) goto <D.5629>; else goto <D.5631>;
  <D.5631>:
  D.5793 = GC_arrays._excl_table[low].e_end;
  D.5794 = (long unsigned int) D.5793;
  start_addr.21 = (long unsigned int) start_addr;
  if (D.5794 <= start_addr.21) goto <D.5795>; else goto <D.5796>;
  <D.5795>:
  D.5797 = 0B;
  return D.5797;
  <D.5796>:
  D.5797 = &GC_arrays._excl_table[low];
  return D.5797;
}


GC_exclude_static_roots (void * start, void * finish)
{
  long unsigned int GC_excl_table_entries.22;
  char * D.5805;
  long unsigned int D.5806;
  long unsigned int finish.23;
  long int next.24;
  long int D.5813;
  long int D.5814;
  long int D.5815;
  long unsigned int D.5816;
  long unsigned int GC_excl_table_entries.25;
  struct exclusion * next;
  size_t next_index;
  size_t i;

  GC_excl_table_entries.22 = GC_excl_table_entries;
  if (GC_excl_table_entries.22 == 0) goto <D.5800>; else goto <D.5801>;
  <D.5800>:
  next = 0B;
  goto <D.5802>;
  <D.5801>:
  next = GC_next_exclusion (start);
  <D.5802>:
  if (next != 0B) goto <D.5803>; else goto <D.5804>;
  <D.5803>:
  D.5805 = next->e_start;
  D.5806 = (long unsigned int) D.5805;
  finish.23 = (long unsigned int) finish;
  if (D.5806 < finish.23) goto <D.5808>; else goto <D.5809>;
  <D.5808>:
  GC_abort ("exclusion ranges overlap");
  <D.5809>:
  D.5805 = next->e_start;
  D.5806 = (long unsigned int) D.5805;
  finish.23 = (long unsigned int) finish;
  if (D.5806 == finish.23) goto <D.5810>; else goto <D.5811>;
  <D.5810>:
  next->e_start = start;
  return;
  <D.5811>:
  next.24 = (long int) next;
  D.5813 = (long int) &GC_arrays._excl_table;
  D.5814 = next.24 - D.5813;
  D.5815 = D.5814 /[ex] 16;
  next_index = (size_t) D.5815;
  i = GC_excl_table_entries;
  goto <D.5640>;
  <D.5639>:
  D.5816 = i + 18446744073709551615;
  GC_arrays._excl_table[i] = GC_arrays._excl_table[D.5816];
  i = i + 18446744073709551615;
  <D.5640>:
  if (i > next_index) goto <D.5639>; else goto <D.5641>;
  <D.5641>:
  goto <D.5817>;
  <D.5804>:
  next_index = GC_excl_table_entries;
  <D.5817>:
  GC_excl_table_entries.22 = GC_excl_table_entries;
  if (GC_excl_table_entries.22 == 256) goto <D.5818>; else goto <D.5819>;
  <D.5818>:
  GC_abort ("Too many exclusions");
  <D.5819>:
  GC_arrays._excl_table[next_index].e_start = start;
  GC_arrays._excl_table[next_index].e_end = finish;
  GC_excl_table_entries.22 = GC_excl_table_entries;
  GC_excl_table_entries.25 = GC_excl_table_entries.22 + 1;
  GC_excl_table_entries = GC_excl_table_entries.25;
}


GC_push_conditional_with_exclusions (char * bottom, char * top, int all)
{
  struct exclusion * next;
  char * excl_start;

  goto <D.5650>;
  <D.5649>:
  next = GC_next_exclusion (bottom);
  if (next == 0B) goto <D.5822>; else goto <D.5824>;
  <D.5824>:
  excl_start = next->e_start;
  if (excl_start >= top) goto <D.5822>; else goto <D.5823>;
  <D.5822>:
  GC_push_conditional (bottom, top, all);
  return;
  <D.5823>:
  if (excl_start > bottom) goto <D.5825>; else goto <D.5826>;
  <D.5825>:
  GC_push_conditional (bottom, excl_start, all);
  <D.5826>:
  bottom = next->e_end;
  <D.5650>:
  if (bottom < top) goto <D.5649>; else goto <D.5651>;
  <D.5651>:
}


GC_push_current_stack (char * cold_gc_frame)
{
  char * D.5830;

  if (cold_gc_frame == 0B) goto <D.5828>; else goto <D.5829>;
  <D.5828>:
  return;
  <D.5829>:
  D.5830 = GC_approx_sp ();
  GC_push_all_eager (D.5830, cold_gc_frame);
}


GC_push_gc_structures ()
{
  GC_push_finalizer_structures ();
  GC_push_stubborn_structures ();
  GC_push_thread_structures ();
}


GC_cond_register_dynamic_libraries ()
{
  int GC_no_dls.26;

  GC_remove_tmp_roots ();
  GC_no_dls.26 = GC_no_dls;
  if (GC_no_dls.26 == 0) goto <D.5833>; else goto <D.5834>;
  <D.5833>:
  GC_register_dynamic_libraries ();
  <D.5834>:
}


GC_push_roots (GC_bool all, char * cold_gc_frame)
{
  char * D.5835;
  char * D.5836;
  int n_root_sets.27;
  char * * D.5838;
  int GC_n_kinds.28;
  int GC_no_dls.29;
  int roots_were_cleared.30;
  int GC_world_stopped.31;
  void (*<T6fb>) (void) GC_push_other_roots.32;
  int i;
  int kind;

  i = 0;
  goto <D.5668>;
  <D.5667>:
  D.5835 = GC_arrays._static_roots[i].r_end;
  D.5836 = GC_arrays._static_roots[i].r_start;
  GC_push_conditional_with_exclusions (D.5836, D.5835, all);
  i = i + 1;
  <D.5668>:
  n_root_sets.27 = n_root_sets;
  if (i < n_root_sets.27) goto <D.5667>; else goto <D.5669>;
  <D.5669>:
  kind = 0;
  goto <D.5672>;
  <D.5671>:
  {
    void * base;

    D.5838 = GC_obj_kinds[kind].ok_freelist;
    base = GC_base (D.5838);
    if (base != 0B) goto <D.5839>; else goto <D.5840>;
    <D.5839>:
    GC_set_mark_bit (base);
    <D.5840>:
  }
  kind = kind + 1;
  <D.5672>:
  GC_n_kinds.28 = GC_n_kinds;
  if (kind < GC_n_kinds.28) goto <D.5671>; else goto <D.5673>;
  <D.5673>:
  GC_no_dls.29 = GC_no_dls;
  if (GC_no_dls.29 != 0) goto <D.5842>; else goto <D.5845>;
  <D.5845>:
  roots_were_cleared.30 = roots_were_cleared;
  if (roots_were_cleared.30 != 0) goto <D.5842>; else goto <D.5843>;
  <D.5842>:
  GC_push_gc_structures ();
  <D.5843>:
  GC_world_stopped.31 = GC_world_stopped;
  if (GC_world_stopped.31 != 0) goto <D.5848>; else goto <D.5849>;
  <D.5848>:
  GC_mark_thread_local_free_lists ();
  <D.5849>:
  GC_generic_push_regs (cold_gc_frame);
  GC_push_other_roots.32 = GC_push_other_roots;
  if (GC_push_other_roots.32 != 0B) goto <D.5851>; else goto <D.5852>;
  <D.5851>:
  GC_push_other_roots.32 = GC_push_other_roots;
  GC_push_other_roots.32 ();
  <D.5852>:
}