GC_print_static_roots ()
{
  char * D.7837;
  long int D.7838;
  char * D.7839;
  long int D.7840;
  int D.7841;
  int D.7845;
  int D.7846;
  int D.7847;
  unsigned int D.7848;
  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.7705>;
  <D.7704>:
  D.7837 = GC_arrays._static_roots[i].r_start;
  D.7838 = (long int) D.7837;
  D.7839 = GC_arrays._static_roots[i].r_end;
  D.7840 = (long int) D.7839;
  GC_printf ("From 0x%lx to 0x%lx ", D.7838, D.7840, 0, 0, 0, 0);
  D.7841 = GC_arrays._static_roots[i].r_tmp;
  if (D.7841 != 0) goto <D.7842>; else goto <D.7843>;
  <D.7842>:
  GC_printf (" (temporary)\n", 0, 0, 0, 0, 0, 0);
  goto <D.7844>;
  <D.7843>:
  GC_printf ("\n", 0, 0, 0, 0, 0, 0);
  <D.7844>:
  D.7839 = GC_arrays._static_roots[i].r_end;
  D.7845 = (int) D.7839;
  D.7837 = GC_arrays._static_roots[i].r_start;
  D.7846 = (int) D.7837;
  D.7847 = D.7845 - D.7846;
  D.7848 = (unsigned int) D.7847;
  total = D.7848 + total;
  i = i + 1;
  <D.7705>:
  n_root_sets.0 = n_root_sets;
  if (i < n_root_sets.0) goto <D.7704>; else goto <D.7706>;
  <D.7706>:
  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.7852>; else goto <D.7853>;
  <D.7852>:
  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.7853>:
}


GC_is_static_root (char * p)
{
  int last_root_set.4;
  int n_root_sets.5;
  char * D.7859;
  char * D.7862;
  GC_bool D.7865;
  char * D.7866;
  char * D.7869;
  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.7857>; else goto <D.7858>;
  <D.7857>:
  last_root_set.4 = last_root_set;
  D.7859 = GC_arrays._static_roots[last_root_set.4].r_start;
  if (D.7859 <= p) goto <D.7860>; else goto <D.7861>;
  <D.7860>:
  last_root_set.4 = last_root_set;
  D.7862 = GC_arrays._static_roots[last_root_set.4].r_end;
  if (D.7862 > p) goto <D.7863>; else goto <D.7864>;
  <D.7863>:
  D.7865 = 1;
  return D.7865;
  <D.7864>:
  <D.7861>:
  <D.7858>:
  i = 0;
  goto <D.7713>;
  <D.7712>:
  D.7866 = GC_arrays._static_roots[i].r_start;
  if (D.7866 <= p) goto <D.7867>; else goto <D.7868>;
  <D.7867>:
  D.7869 = GC_arrays._static_roots[i].r_end;
  if (D.7869 > p) goto <D.7870>; else goto <D.7871>;
  <D.7870>:
  last_root_set = i;
  D.7865 = 1;
  return D.7865;
  <D.7871>:
  <D.7868>:
  i = i + 1;
  <D.7713>:
  n_root_sets.5 = n_root_sets;
  if (i < n_root_sets.5) goto <D.7712>; else goto <D.7714>;
  <D.7714>:
  D.7865 = 0;
  return D.7865;
}


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

  h = rt_hash (b);
  p = GC_arrays._root_index[h];
  goto <D.7725>;
  <D.7724>:
  D.7873 = p->r_start;
  if (D.7873 == b) goto <D.7874>; else goto <D.7875>;
  <D.7874>:
  D.7876 = p;
  return D.7876;
  <D.7875>:
  p = p->r_next;
  <D.7725>:
  if (p != 0B) goto <D.7724>; else goto <D.7726>;
  <D.7726>:
  D.7876 = 0B;
  return D.7876;
}


rt_hash (char * addr)
{
  long unsigned int D.7878;
  long unsigned int D.7879;
  long unsigned int D.7880;
  int D.7881;
  word result;

  result = (word) addr;
  D.7878 = result >> 24;
  result = D.7878 ^ result;
  D.7879 = result >> 12;
  result = D.7879 ^ result;
  D.7880 = result >> 6;
  result = D.7880 ^ result;
  result = result & 63;
  D.7881 = (int) result;
  return D.7881;
}


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

  D.7883 = GC_test_and_set (&GC_allocate_lock);
  if (D.7883 != 0) goto <D.7884>; else goto <D.7885>;
  <D.7884>:
  GC_lock ();
  <D.7885>:
  GC_add_roots_inner (b, e, 0);
  GC_clear (&GC_allocate_lock);
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.7886;
  unsigned int D.7887;

  D.7887 = __sync_lock_test_and_set_4 (addr, 1);
  D.7886 = (int) D.7887;
  return D.7886;
}


GC_clear (volatile unsigned int * addr)
{
  __sync_synchronize ();
  *addr = 0;
}


GC_add_roots_inner (char * b, char * e, GC_bool tmp)
{
  char * D.7891;
  int e.6;
  int D.7895;
  int D.7896;
  long unsigned int D.7897;
  long unsigned int GC_root_size.7;
  long unsigned int GC_root_size.8;
  int n_root_sets.9;
  sizetype n_root_sets.10;
  struct roots * D.7904;
  int b.11;
  int D.7906;
  long unsigned int D.7907;
  long unsigned int GC_root_size.12;
  int n_root_sets.13;
  struct roots * old;

  old = GC_roots_present (b);
  if (old != 0B) goto <D.7889>; else goto <D.7890>;
  <D.7889>:
  D.7891 = old->r_end;
  if (D.7891 >= e) goto <D.7892>; else goto <D.7893>;
  <D.7892>:
  return;
  <D.7893>:
  e.6 = (int) e;
  D.7891 = old->r_end;
  D.7895 = (int) D.7891;
  D.7896 = e.6 - D.7895;
  D.7897 = (long unsigned int) D.7896;
  GC_root_size.7 = GC_root_size;
  GC_root_size.8 = D.7897 + GC_root_size.7;
  GC_root_size = GC_root_size.8;
  old->r_end = e;
  return;
  <D.7890>:
  n_root_sets.9 = n_root_sets;
  if (n_root_sets.9 == 1024) goto <D.7901>; else goto <D.7902>;
  <D.7901>:
  GC_abort ("Too many root sets\n");
  <D.7902>:
  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;
  n_root_sets.10 = (sizetype) n_root_sets.9;
  D.7904 = &GC_arrays._static_roots[n_root_sets.10];
  add_roots_to_index (D.7904);
  e.6 = (int) e;
  b.11 = (int) b;
  D.7906 = e.6 - b.11;
  D.7907 = (long unsigned int) D.7906;
  GC_root_size.7 = GC_root_size;
  GC_root_size.12 = D.7907 + GC_root_size.7;
  GC_root_size = GC_root_size.12;
  n_root_sets.9 = n_root_sets;
  n_root_sets.13 = n_root_sets.9 + 1;
  n_root_sets = n_root_sets.13;
}


add_roots_to_index (struct roots * p)
{
  char * D.7911;
  struct roots * D.7912;
  register int h;

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


GC_clear_roots ()
{
  int D.7913;

  D.7913 = GC_test_and_set (&GC_allocate_lock);
  if (D.7913 != 0) goto <D.7914>; else goto <D.7915>;
  <D.7914>:
  GC_lock ();
  <D.7915>:
  roots_were_cleared = 1;
  n_root_sets = 0;
  GC_root_size = 0;
  {
    register int i;

    i = 0;
    goto <D.7748>;
    <D.7747>:
    GC_arrays._root_index[i] = 0B;
    i = i + 1;
    <D.7748>:
    if (i <= 63) goto <D.7747>; else goto <D.7749>;
    <D.7749>:
  }
  GC_clear (&GC_allocate_lock);
}


GC_remove_tmp_roots ()
{
  int D.7916;
  int n_root_sets.14;
  register int i;

  i = 0;
  goto <D.7766>;
  <D.7765>:
  D.7916 = GC_arrays._static_roots[i].r_tmp;
  if (D.7916 != 0) goto <D.7917>; else goto <D.7918>;
  <D.7917>:
  GC_remove_root_at_pos (i);
  goto <D.7919>;
  <D.7918>:
  i = i + 1;
  <D.7919>:
  <D.7766>:
  n_root_sets.14 = n_root_sets;
  if (i < n_root_sets.14) goto <D.7765>; else goto <D.7767>;
  <D.7767>:
  GC_rebuild_root_index ();
}


GC_remove_root_at_pos (int i)
{
  char * D.7921;
  int D.7922;
  char * D.7923;
  int D.7924;
  int D.7925;
  long unsigned int D.7926;
  long unsigned int GC_root_size.15;
  long unsigned int GC_root_size.16;
  int n_root_sets.17;
  int n_root_sets.18;
  char * D.7931;
  char * D.7932;
  int D.7933;

  D.7921 = GC_arrays._static_roots[i].r_start;
  D.7922 = (int) D.7921;
  D.7923 = GC_arrays._static_roots[i].r_end;
  D.7924 = (int) D.7923;
  D.7925 = D.7922 - D.7924;
  D.7926 = (long unsigned int) D.7925;
  GC_root_size.15 = GC_root_size;
  GC_root_size.16 = D.7926 + GC_root_size.15;
  GC_root_size = GC_root_size.16;
  n_root_sets.17 = n_root_sets;
  n_root_sets.18 = n_root_sets.17 + -1;
  D.7931 = GC_arrays._static_roots[n_root_sets.18].r_start;
  GC_arrays._static_roots[i].r_start = D.7931;
  n_root_sets.17 = n_root_sets;
  n_root_sets.18 = n_root_sets.17 + -1;
  D.7932 = GC_arrays._static_roots[n_root_sets.18].r_end;
  GC_arrays._static_roots[i].r_end = D.7932;
  n_root_sets.17 = n_root_sets;
  n_root_sets.18 = n_root_sets.17 + -1;
  D.7933 = GC_arrays._static_roots[n_root_sets.18].r_tmp;
  GC_arrays._static_roots[i].r_tmp = D.7933;
  n_root_sets.17 = n_root_sets;
  n_root_sets.18 = n_root_sets.17 + -1;
  n_root_sets = n_root_sets.18;
}


GC_rebuild_root_index ()
{
  sizetype i.19;
  struct roots * D.7935;
  int n_root_sets.20;
  register int i;

  i = 0;
  goto <D.7757>;
  <D.7756>:
  GC_arrays._root_index[i] = 0B;
  i = i + 1;
  <D.7757>:
  if (i <= 63) goto <D.7756>; else goto <D.7758>;
  <D.7758>:
  i = 0;
  goto <D.7760>;
  <D.7759>:
  i.19 = (sizetype) i;
  D.7935 = &GC_arrays._static_roots[i.19];
  add_roots_to_index (D.7935);
  i = i + 1;
  <D.7760>:
  n_root_sets.20 = n_root_sets;
  if (i < n_root_sets.20) goto <D.7759>; else goto <D.7761>;
  <D.7761>:
}


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

  D.7937 = GC_test_and_set (&GC_allocate_lock);
  if (D.7937 != 0) goto <D.7938>; else goto <D.7939>;
  <D.7938>:
  GC_lock ();
  <D.7939>:
  GC_remove_roots_inner (b, e);
  GC_clear (&GC_allocate_lock);
}


GC_remove_roots_inner (char * b, char * e)
{
  char * D.7942;
  char * D.7944;
  int n_root_sets.21;
  int i;

  i = 0;
  goto <D.7778>;
  <D.7777>:
  D.7942 = GC_arrays._static_roots[i].r_start;
  if (D.7942 >= b) goto <D.7943>; else goto <D.7940>;
  <D.7943>:
  D.7944 = GC_arrays._static_roots[i].r_end;
  if (D.7944 <= e) goto <D.7945>; else goto <D.7940>;
  <D.7945>:
  GC_remove_root_at_pos (i);
  goto <D.7941>;
  <D.7940>:
  i = i + 1;
  <D.7941>:
  <D.7778>:
  n_root_sets.21 = n_root_sets;
  if (i < n_root_sets.21) goto <D.7777>; else goto <D.7779>;
  <D.7779>:
  GC_rebuild_root_index ();
}


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

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


GC_next_exclusion (char * start_addr)
{
  unsigned int GC_excl_table_entries.22;
  unsigned int D.7950;
  char * D.7951;
  long unsigned int D.7952;
  long unsigned int start_addr.23;
  char * D.7957;
  long unsigned int D.7958;
  struct exclusion * D.7961;
  size_t low;
  size_t high;
  size_t mid;

  low = 0;
  GC_excl_table_entries.22 = GC_excl_table_entries;
  high = GC_excl_table_entries.22 + 4294967295;
  goto <D.7791>;
  <D.7790>:
  D.7950 = low + high;
  mid = D.7950 >> 1;
  D.7951 = GC_arrays._excl_table[mid].e_end;
  D.7952 = (long unsigned int) D.7951;
  start_addr.23 = (long unsigned int) start_addr;
  if (D.7952 <= start_addr.23) goto <D.7954>; else goto <D.7955>;
  <D.7954>:
  low = mid + 1;
  goto <D.7956>;
  <D.7955>:
  high = mid;
  <D.7956>:
  <D.7791>:
  if (high > low) goto <D.7790>; else goto <D.7792>;
  <D.7792>:
  D.7957 = GC_arrays._excl_table[low].e_end;
  D.7958 = (long unsigned int) D.7957;
  start_addr.23 = (long unsigned int) start_addr;
  if (D.7958 <= start_addr.23) goto <D.7959>; else goto <D.7960>;
  <D.7959>:
  D.7961 = 0B;
  return D.7961;
  <D.7960>:
  D.7961 = &GC_arrays._excl_table[low];
  return D.7961;
}


GC_exclude_static_roots (void * start, void * finish)
{
  unsigned int GC_excl_table_entries.24;
  char * D.7969;
  long unsigned int D.7970;
  long unsigned int finish.25;
  int next.26;
  int D.7977;
  int D.7978;
  int D.7979;
  unsigned int D.7980;
  unsigned int GC_excl_table_entries.27;
  struct exclusion * next;
  size_t next_index;
  size_t i;

  GC_excl_table_entries.24 = GC_excl_table_entries;
  if (GC_excl_table_entries.24 == 0) goto <D.7964>; else goto <D.7965>;
  <D.7964>:
  next = 0B;
  goto <D.7966>;
  <D.7965>:
  next = GC_next_exclusion (start);
  <D.7966>:
  if (next != 0B) goto <D.7967>; else goto <D.7968>;
  <D.7967>:
  D.7969 = next->e_start;
  D.7970 = (long unsigned int) D.7969;
  finish.25 = (long unsigned int) finish;
  if (D.7970 < finish.25) goto <D.7972>; else goto <D.7973>;
  <D.7972>:
  GC_abort ("exclusion ranges overlap");
  <D.7973>:
  D.7969 = next->e_start;
  D.7970 = (long unsigned int) D.7969;
  finish.25 = (long unsigned int) finish;
  if (D.7970 == finish.25) goto <D.7974>; else goto <D.7975>;
  <D.7974>:
  next->e_start = start;
  return;
  <D.7975>:
  next.26 = (int) next;
  D.7977 = (int) &GC_arrays._excl_table;
  D.7978 = next.26 - D.7977;
  D.7979 = D.7978 /[ex] 8;
  next_index = (size_t) D.7979;
  i = GC_excl_table_entries;
  goto <D.7801>;
  <D.7800>:
  D.7980 = i + 4294967295;
  GC_arrays._excl_table[i] = GC_arrays._excl_table[D.7980];
  i = i + 4294967295;
  <D.7801>:
  if (i > next_index) goto <D.7800>; else goto <D.7802>;
  <D.7802>:
  goto <D.7981>;
  <D.7968>:
  next_index = GC_excl_table_entries;
  <D.7981>:
  GC_excl_table_entries.24 = GC_excl_table_entries;
  if (GC_excl_table_entries.24 == 256) goto <D.7982>; else goto <D.7983>;
  <D.7982>:
  GC_abort ("Too many exclusions");
  <D.7983>:
  GC_arrays._excl_table[next_index].e_start = start;
  GC_arrays._excl_table[next_index].e_end = finish;
  GC_excl_table_entries.24 = GC_excl_table_entries;
  GC_excl_table_entries.27 = GC_excl_table_entries.24 + 1;
  GC_excl_table_entries = GC_excl_table_entries.27;
}


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

  goto <D.7811>;
  <D.7810>:
  next = GC_next_exclusion (bottom);
  if (next == 0B) goto <D.7986>; else goto <D.7988>;
  <D.7988>:
  excl_start = next->e_start;
  if (excl_start >= top) goto <D.7986>; else goto <D.7987>;
  <D.7986>:
  GC_push_conditional (bottom, top, all);
  return;
  <D.7987>:
  if (excl_start > bottom) goto <D.7989>; else goto <D.7990>;
  <D.7989>:
  GC_push_conditional (bottom, excl_start, all);
  <D.7990>:
  bottom = next->e_end;
  <D.7811>:
  if (bottom < top) goto <D.7810>; else goto <D.7812>;
  <D.7812>:
}


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

  if (cold_gc_frame == 0B) goto <D.7992>; else goto <D.7993>;
  <D.7992>:
  return;
  <D.7993>:
  D.7994 = GC_approx_sp ();
  GC_push_all_eager (D.7994, 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.28;

  GC_remove_tmp_roots ();
  GC_no_dls.28 = GC_no_dls;
  if (GC_no_dls.28 == 0) goto <D.7997>; else goto <D.7998>;
  <D.7997>:
  GC_register_dynamic_libraries ();
  <D.7998>:
}


GC_push_roots (GC_bool all, char * cold_gc_frame)
{
  char * D.7999;
  char * D.8000;
  int n_root_sets.29;
  char * * D.8002;
  int GC_n_kinds.30;
  int GC_no_dls.31;
  int roots_were_cleared.32;
  void (*<T10dc>) (void) GC_push_other_roots.33;
  int i;
  int kind;

  i = 0;
  goto <D.7828>;
  <D.7827>:
  D.7999 = GC_arrays._static_roots[i].r_start;
  D.8000 = GC_arrays._static_roots[i].r_end;
  GC_push_conditional_with_exclusions (D.7999, D.8000, all);
  i = i + 1;
  <D.7828>:
  n_root_sets.29 = n_root_sets;
  if (i < n_root_sets.29) goto <D.7827>; else goto <D.7829>;
  <D.7829>:
  kind = 0;
  goto <D.7832>;
  <D.7831>:
  {
    void * base;

    D.8002 = GC_obj_kinds[kind].ok_freelist;
    base = GC_base (D.8002);
    if (base != 0B) goto <D.8003>; else goto <D.8004>;
    <D.8003>:
    GC_set_mark_bit (base);
    <D.8004>:
  }
  kind = kind + 1;
  <D.7832>:
  GC_n_kinds.30 = GC_n_kinds;
  if (kind < GC_n_kinds.30) goto <D.7831>; else goto <D.7833>;
  <D.7833>:
  GC_no_dls.31 = GC_no_dls;
  if (GC_no_dls.31 != 0) goto <D.8006>; else goto <D.8009>;
  <D.8009>:
  roots_were_cleared.32 = roots_were_cleared;
  if (roots_were_cleared.32 != 0) goto <D.8006>; else goto <D.8007>;
  <D.8006>:
  GC_push_gc_structures ();
  <D.8007>:
  GC_generic_push_regs (cold_gc_frame);
  GC_push_other_roots.33 = GC_push_other_roots;
  if (GC_push_other_roots.33 != 0B) goto <D.8012>; else goto <D.8013>;
  <D.8012>:
  GC_push_other_roots.33 = GC_push_other_roots;
  GC_push_other_roots.33 ();
  <D.8013>:
}