GC_print_static_roots ()
{
  char * D.5757;
  long int D.5758;
  char * D.5759;
  long int D.5760;
  int D.5761;
  long int D.5765;
  long unsigned int D.5766;
  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.5626>;
  <D.5625>:
  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;
  GC_printf ("From 0x%lx to 0x%lx ", D.5758, D.5760, 0, 0, 0, 0);
  D.5761 = GC_arrays._static_roots[i].r_tmp;
  if (D.5761 != 0) goto <D.5762>; else goto <D.5763>;
  <D.5762>:
  GC_printf (" (temporary)\n", 0, 0, 0, 0, 0, 0);
  goto <D.5764>;
  <D.5763>:
  GC_printf ("\n", 0, 0, 0, 0, 0, 0);
  <D.5764>:
  D.5759 = GC_arrays._static_roots[i].r_end;
  D.5760 = (long int) D.5759;
  D.5757 = GC_arrays._static_roots[i].r_start;
  D.5758 = (long int) D.5757;
  D.5765 = D.5760 - D.5758;
  D.5766 = (long unsigned int) D.5765;
  total = D.5766 + total;
  i = i + 1;
  <D.5626>:
  n_root_sets.0 = n_root_sets;
  if (i < n_root_sets.0) goto <D.5625>; else goto <D.5627>;
  <D.5627>:
  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.5770>; else goto <D.5771>;
  <D.5770>:
  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.5771>:
}


GC_is_static_root (char * p)
{
  int last_root_set.4;
  int n_root_sets.5;
  char * D.5777;
  char * D.5780;
  GC_bool D.5783;
  char * D.5784;
  char * D.5787;
  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.5775>; else goto <D.5776>;
  <D.5775>:
  last_root_set.4 = last_root_set;
  D.5777 = GC_arrays._static_roots[last_root_set.4].r_start;
  if (D.5777 <= p) goto <D.5778>; else goto <D.5779>;
  <D.5778>:
  last_root_set.4 = last_root_set;
  D.5780 = GC_arrays._static_roots[last_root_set.4].r_end;
  if (D.5780 > p) goto <D.5781>; else goto <D.5782>;
  <D.5781>:
  D.5783 = 1;
  return D.5783;
  <D.5782>:
  <D.5779>:
  <D.5776>:
  i = 0;
  goto <D.5634>;
  <D.5633>:
  D.5784 = GC_arrays._static_roots[i].r_start;
  if (D.5784 <= p) goto <D.5785>; else goto <D.5786>;
  <D.5785>:
  D.5787 = GC_arrays._static_roots[i].r_end;
  if (D.5787 > p) goto <D.5788>; else goto <D.5789>;
  <D.5788>:
  last_root_set = i;
  D.5783 = 1;
  return D.5783;
  <D.5789>:
  <D.5786>:
  i = i + 1;
  <D.5634>:
  n_root_sets.5 = n_root_sets;
  if (i < n_root_sets.5) goto <D.5633>; else goto <D.5635>;
  <D.5635>:
  D.5783 = 0;
  return D.5783;
}


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

  h = rt_hash (b);
  p = GC_arrays._root_index[h];
  goto <D.5646>;
  <D.5645>:
  D.5791 = p->r_start;
  if (D.5791 == b) goto <D.5792>; else goto <D.5793>;
  <D.5792>:
  D.5794 = p;
  return D.5794;
  <D.5793>:
  p = p->r_next;
  <D.5646>:
  if (p != 0B) goto <D.5645>; else goto <D.5647>;
  <D.5647>:
  D.5794 = 0B;
  return D.5794;
}


rt_hash (char * addr)
{
  long unsigned int D.5796;
  long unsigned int D.5797;
  long unsigned int D.5798;
  long unsigned int D.5799;
  int D.5800;
  word result;

  result = (word) addr;
  D.5796 = result >> 48;
  result = D.5796 ^ result;
  D.5797 = result >> 24;
  result = D.5797 ^ result;
  D.5798 = result >> 12;
  result = D.5798 ^ result;
  D.5799 = result >> 6;
  result = D.5799 ^ result;
  result = result & 63;
  D.5800 = (int) result;
  return D.5800;
}


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

  D.5802 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.5802 != 0) goto <D.5803>; else goto <D.5804>;
  <D.5803>:
  GC_lock ();
  <D.5804>:
  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.5807;
  long int e.6;
  long int D.5811;
  long int D.5812;
  long unsigned int D.5813;
  long unsigned int GC_root_size.7;
  long unsigned int D.5815;
  int n_root_sets.8;
  long unsigned int D.5819;
  long unsigned int D.5820;
  struct roots * D.5821;
  long int b.9;
  long int D.5823;
  long unsigned int D.5824;
  long unsigned int D.5825;
  int D.5826;
  struct roots * old;

  old = GC_roots_present (b);
  if (old != 0B) goto <D.5805>; else goto <D.5806>;
  <D.5805>:
  D.5807 = old->r_end;
  if (D.5807 >= e) goto <D.5808>; else goto <D.5809>;
  <D.5808>:
  return;
  <D.5809>:
  e.6 = (long int) e;
  D.5807 = old->r_end;
  D.5811 = (long int) D.5807;
  D.5812 = e.6 - D.5811;
  D.5813 = (long unsigned int) D.5812;
  GC_root_size.7 = GC_root_size;
  D.5815 = D.5813 + GC_root_size.7;
  GC_root_size = D.5815;
  old->r_end = e;
  return;
  <D.5806>:
  n_root_sets.8 = n_root_sets;
  if (n_root_sets.8 == 1024) goto <D.5817>; else goto <D.5818>;
  <D.5817>:
  GC_abort ("Too many root sets\n");
  <D.5818>:
  n_root_sets.8 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.8].r_start = b;
  n_root_sets.8 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.8].r_end = e;
  n_root_sets.8 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.8].r_tmp = tmp;
  n_root_sets.8 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.8].r_next = 0B;
  n_root_sets.8 = n_root_sets;
  D.5819 = (long unsigned int) n_root_sets.8;
  D.5820 = D.5819 * 32;
  D.5821 = &GC_arrays._static_roots + D.5820;
  add_roots_to_index (D.5821);
  e.6 = (long int) e;
  b.9 = (long int) b;
  D.5823 = e.6 - b.9;
  D.5824 = (long unsigned int) D.5823;
  GC_root_size.7 = GC_root_size;
  D.5825 = D.5824 + GC_root_size.7;
  GC_root_size = D.5825;
  n_root_sets.8 = n_root_sets;
  D.5826 = n_root_sets.8 + 1;
  n_root_sets = D.5826;
}


add_roots_to_index (struct roots * p)
{
  char * D.5828;
  struct roots * D.5829;
  register int h;

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


GC_clear_roots ()
{
  int D.5830;

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

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


GC_remove_tmp_roots ()
{
  int D.5833;
  int n_root_sets.10;
  register int i;

  i = 0;
  goto <D.5687>;
  <D.5686>:
  D.5833 = GC_arrays._static_roots[i].r_tmp;
  if (D.5833 != 0) goto <D.5834>; else goto <D.5835>;
  <D.5834>:
  GC_remove_root_at_pos (i);
  goto <D.5836>;
  <D.5835>:
  i = i + 1;
  <D.5836>:
  <D.5687>:
  n_root_sets.10 = n_root_sets;
  if (i < n_root_sets.10) goto <D.5686>; else goto <D.5688>;
  <D.5688>:
  GC_rebuild_root_index ();
}


GC_remove_root_at_pos (int i)
{
  long unsigned int GC_root_size.11;
  char * D.5839;
  long int D.5840;
  char * D.5841;
  long int D.5842;
  long int D.5843;
  long unsigned int D.5844;
  long unsigned int D.5845;
  int n_root_sets.12;
  int D.5847;
  char * D.5848;
  char * D.5849;
  int D.5850;

  GC_root_size.11 = GC_root_size;
  D.5839 = GC_arrays._static_roots[i].r_end;
  D.5840 = (long int) D.5839;
  D.5841 = GC_arrays._static_roots[i].r_start;
  D.5842 = (long int) D.5841;
  D.5843 = D.5840 - D.5842;
  D.5844 = (long unsigned int) D.5843;
  D.5845 = GC_root_size.11 - D.5844;
  GC_root_size = D.5845;
  n_root_sets.12 = n_root_sets;
  D.5847 = n_root_sets.12 + -1;
  D.5848 = GC_arrays._static_roots[D.5847].r_start;
  GC_arrays._static_roots[i].r_start = D.5848;
  n_root_sets.12 = n_root_sets;
  D.5847 = n_root_sets.12 + -1;
  D.5849 = GC_arrays._static_roots[D.5847].r_end;
  GC_arrays._static_roots[i].r_end = D.5849;
  n_root_sets.12 = n_root_sets;
  D.5847 = n_root_sets.12 + -1;
  D.5850 = GC_arrays._static_roots[D.5847].r_tmp;
  GC_arrays._static_roots[i].r_tmp = D.5850;
  n_root_sets.12 = n_root_sets;
  D.5847 = n_root_sets.12 + -1;
  n_root_sets = D.5847;
}


GC_rebuild_root_index ()
{
  long unsigned int D.5851;
  long unsigned int D.5852;
  struct roots * D.5853;
  int n_root_sets.13;
  register int i;

  i = 0;
  goto <D.5678>;
  <D.5677>:
  GC_arrays._root_index[i] = 0B;
  i = i + 1;
  <D.5678>:
  if (i <= 63) goto <D.5677>; else goto <D.5679>;
  <D.5679>:
  i = 0;
  goto <D.5681>;
  <D.5680>:
  D.5851 = (long unsigned int) i;
  D.5852 = D.5851 * 32;
  D.5853 = &GC_arrays._static_roots + D.5852;
  add_roots_to_index (D.5853);
  i = i + 1;
  <D.5681>:
  n_root_sets.13 = n_root_sets;
  if (i < n_root_sets.13) goto <D.5680>; else goto <D.5682>;
  <D.5682>:
}


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

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


GC_remove_roots_inner (char * b, char * e)
{
  char * D.5860;
  char * D.5862;
  int n_root_sets.14;
  int i;

  i = 0;
  goto <D.5699>;
  <D.5698>:
  D.5860 = GC_arrays._static_roots[i].r_start;
  if (D.5860 >= b) goto <D.5861>; else goto <D.5858>;
  <D.5861>:
  D.5862 = GC_arrays._static_roots[i].r_end;
  if (D.5862 <= e) goto <D.5863>; else goto <D.5858>;
  <D.5863>:
  GC_remove_root_at_pos (i);
  goto <D.5859>;
  <D.5858>:
  i = i + 1;
  <D.5859>:
  <D.5699>:
  n_root_sets.14 = n_root_sets;
  if (i < n_root_sets.14) goto <D.5698>; else goto <D.5700>;
  <D.5700>:
  GC_rebuild_root_index ();
}


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

  dummy = 42;
  D.5865 = 0B;
  return D.5865;
}


GC_next_exclusion (char * start_addr)
{
  long unsigned int GC_excl_table_entries.15;
  long unsigned int D.5868;
  char * D.5869;
  long unsigned int D.5870;
  long unsigned int start_addr.16;
  char * D.5875;
  long unsigned int D.5876;
  struct exclusion * D.5879;
  long unsigned int D.5880;
  size_t low;
  size_t high;
  size_t mid;

  low = 0;
  GC_excl_table_entries.15 = GC_excl_table_entries;
  high = GC_excl_table_entries.15 + 18446744073709551615;
  goto <D.5712>;
  <D.5711>:
  D.5868 = low + high;
  mid = D.5868 >> 1;
  D.5869 = GC_arrays._excl_table[mid].e_end;
  D.5870 = (long unsigned int) D.5869;
  start_addr.16 = (long unsigned int) start_addr;
  if (D.5870 <= start_addr.16) goto <D.5872>; else goto <D.5873>;
  <D.5872>:
  low = mid + 1;
  goto <D.5874>;
  <D.5873>:
  high = mid;
  <D.5874>:
  <D.5712>:
  if (high > low) goto <D.5711>; else goto <D.5713>;
  <D.5713>:
  D.5875 = GC_arrays._excl_table[low].e_end;
  D.5876 = (long unsigned int) D.5875;
  start_addr.16 = (long unsigned int) start_addr;
  if (D.5876 <= start_addr.16) goto <D.5877>; else goto <D.5878>;
  <D.5877>:
  D.5879 = 0B;
  return D.5879;
  <D.5878>:
  D.5880 = low * 16;
  D.5879 = &GC_arrays._excl_table + D.5880;
  return D.5879;
}


GC_exclude_static_roots (void * start, void * finish)
{
  long unsigned int GC_excl_table_entries.17;
  char * D.5888;
  long unsigned int D.5889;
  long unsigned int finish.18;
  long int next.19;
  long int D.5896;
  long int D.5897;
  long int D.5898;
  long unsigned int D.5899;
  long unsigned int D.5903;
  struct exclusion * next;
  size_t next_index;
  size_t i;

  GC_excl_table_entries.17 = GC_excl_table_entries;
  if (GC_excl_table_entries.17 == 0) goto <D.5883>; else goto <D.5884>;
  <D.5883>:
  next = 0B;
  goto <D.5885>;
  <D.5884>:
  next = GC_next_exclusion (start);
  <D.5885>:
  if (next != 0B) goto <D.5886>; else goto <D.5887>;
  <D.5886>:
  D.5888 = next->e_start;
  D.5889 = (long unsigned int) D.5888;
  finish.18 = (long unsigned int) finish;
  if (D.5889 < finish.18) goto <D.5891>; else goto <D.5892>;
  <D.5891>:
  GC_abort ("exclusion ranges overlap");
  <D.5892>:
  D.5888 = next->e_start;
  D.5889 = (long unsigned int) D.5888;
  finish.18 = (long unsigned int) finish;
  if (D.5889 == finish.18) goto <D.5893>; else goto <D.5894>;
  <D.5893>:
  next->e_start = start;
  return;
  <D.5894>:
  next.19 = (long int) next;
  D.5896 = (long int) &GC_arrays._excl_table;
  D.5897 = next.19 - D.5896;
  D.5898 = D.5897 /[ex] 16;
  next_index = (size_t) D.5898;
  i = GC_excl_table_entries;
  goto <D.5722>;
  <D.5721>:
  D.5899 = i + 18446744073709551615;
  GC_arrays._excl_table[i] = GC_arrays._excl_table[D.5899];
  i = i + 18446744073709551615;
  <D.5722>:
  if (i > next_index) goto <D.5721>; else goto <D.5723>;
  <D.5723>:
  goto <D.5900>;
  <D.5887>:
  next_index = GC_excl_table_entries;
  <D.5900>:
  GC_excl_table_entries.17 = GC_excl_table_entries;
  if (GC_excl_table_entries.17 == 256) goto <D.5901>; else goto <D.5902>;
  <D.5901>:
  GC_abort ("Too many exclusions");
  <D.5902>:
  GC_arrays._excl_table[next_index].e_start = start;
  GC_arrays._excl_table[next_index].e_end = finish;
  GC_excl_table_entries.17 = GC_excl_table_entries;
  D.5903 = GC_excl_table_entries.17 + 1;
  GC_excl_table_entries = D.5903;
}


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

  goto <D.5732>;
  <D.5731>:
  next = GC_next_exclusion (bottom);
  if (next == 0B) goto <D.5905>; else goto <D.5907>;
  <D.5907>:
  excl_start = next->e_start;
  if (excl_start >= top) goto <D.5905>; else goto <D.5906>;
  <D.5905>:
  GC_push_conditional (bottom, top, all);
  return;
  <D.5906>:
  if (excl_start > bottom) goto <D.5908>; else goto <D.5909>;
  <D.5908>:
  GC_push_conditional (bottom, excl_start, all);
  <D.5909>:
  bottom = next->e_end;
  <D.5732>:
  if (bottom < top) goto <D.5731>; else goto <D.5733>;
  <D.5733>:
}


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

  if (cold_gc_frame == 0B) goto <D.5911>; else goto <D.5912>;
  <D.5911>:
  return;
  <D.5912>:
  D.5913 = GC_approx_sp ();
  GC_push_all_eager (D.5913, 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.20;

  GC_remove_tmp_roots ();
  GC_no_dls.20 = GC_no_dls;
  if (GC_no_dls.20 == 0) goto <D.5916>; else goto <D.5917>;
  <D.5916>:
  GC_register_dynamic_libraries ();
  <D.5917>:
}


GC_push_roots (GC_bool all, char * cold_gc_frame)
{
  char * D.5918;
  char * D.5919;
  int n_root_sets.21;
  char * * D.5921;
  int GC_n_kinds.22;
  int GC_no_dls.23;
  int roots_were_cleared.24;
  int GC_world_stopped.25;
  void (*<T771>) (void) GC_push_other_roots.26;
  int i;
  int kind;

  i = 0;
  goto <D.5750>;
  <D.5749>:
  D.5918 = GC_arrays._static_roots[i].r_start;
  D.5919 = GC_arrays._static_roots[i].r_end;
  GC_push_conditional_with_exclusions (D.5918, D.5919, all);
  i = i + 1;
  <D.5750>:
  n_root_sets.21 = n_root_sets;
  if (i < n_root_sets.21) goto <D.5749>; else goto <D.5751>;
  <D.5751>:
  kind = 0;
  goto <D.5754>;
  <D.5753>:
  {
    void * base;

    D.5921 = GC_obj_kinds[kind].ok_freelist;
    base = GC_base (D.5921);
    if (base != 0B) goto <D.5922>; else goto <D.5923>;
    <D.5922>:
    GC_set_mark_bit (base);
    <D.5923>:
  }
  kind = kind + 1;
  <D.5754>:
  GC_n_kinds.22 = GC_n_kinds;
  if (kind < GC_n_kinds.22) goto <D.5753>; else goto <D.5755>;
  <D.5755>:
  GC_no_dls.23 = GC_no_dls;
  if (GC_no_dls.23 != 0) goto <D.5925>; else goto <D.5928>;
  <D.5928>:
  roots_were_cleared.24 = roots_were_cleared;
  if (roots_were_cleared.24 != 0) goto <D.5925>; else goto <D.5926>;
  <D.5925>:
  GC_push_gc_structures ();
  <D.5926>:
  GC_world_stopped.25 = GC_world_stopped;
  if (GC_world_stopped.25 != 0) goto <D.5931>; else goto <D.5932>;
  <D.5931>:
  GC_mark_thread_local_free_lists ();
  <D.5932>:
  GC_generic_push_regs (cold_gc_frame);
  GC_push_other_roots.26 = GC_push_other_roots;
  if (GC_push_other_roots.26 != 0B) goto <D.5934>; else goto <D.5935>;
  <D.5934>:
  GC_push_other_roots.26 = GC_push_other_roots;
  GC_push_other_roots.26 ();
  <D.5935>:
}