GC_default_oom_fn (size_t bytes_requested)
{
  void * D.6710;

  D.6710 = 0B;
  return D.6710;
}


GC_project2 (void * arg1, void * arg2)
{
  void * D.6712;

  D.6712 = arg2;
  return D.6712;
}


GC_init_size_map ()
{
  int GC_all_interior_pointers.0;
  unsigned int GC_all_interior_pointers.1;
  unsigned int D.6716;
  unsigned int D.6717;
  unsigned int D.6718;
  unsigned int D.6719;
  unsigned int D.6720;
  unsigned int D.6721;
  unsigned int D.6722;
  register unsigned int i;

  i = 0;
  goto <D.5602>;
  <D.5601>:
  GC_arrays._size_map[i] = 2;
  i = i + 1;
  <D.5602>:
  if (i <= 7) goto <D.5601>; else goto <D.5603>;
  <D.5603>:
  GC_arrays._size_map[8] = 2;
  i = 9;
  goto <D.5605>;
  <D.5604>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.6716 = GC_all_interior_pointers.1 + i;
  D.6717 = D.6716 + 7;
  D.6718 = D.6717 >> 3;
  GC_arrays._size_map[i] = D.6718;
  i = i + 1;
  <D.5605>:
  if (i <= 64) goto <D.5604>; else goto <D.5606>;
  <D.5606>:
  i = 65;
  goto <D.5608>;
  <D.5607>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.6716 = GC_all_interior_pointers.1 + i;
  D.6717 = D.6716 + 7;
  D.6718 = D.6717 >> 3;
  D.6719 = D.6718 + 1;
  D.6720 = D.6719 & 4294967294;
  GC_arrays._size_map[i] = D.6720;
  i = i + 1;
  <D.5608>:
  if (i <= 128) goto <D.5607>; else goto <D.5609>;
  <D.5609>:
  i = 129;
  goto <D.5611>;
  <D.5610>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.6716 = GC_all_interior_pointers.1 + i;
  D.6717 = D.6716 + 7;
  D.6718 = D.6717 >> 3;
  D.6721 = D.6718 + 3;
  D.6722 = D.6721 & 4294967292;
  GC_arrays._size_map[i] = D.6722;
  i = i + 1;
  <D.5611>:
  if (i <= 256) goto <D.5610>; else goto <D.5612>;
  <D.5612>:
}


GC_extend_size_map (word i)
{
  int GC_all_interior_pointers.2;
  int D.6724;
  long unsigned int D.6725;
  long unsigned int D.6726;
  long unsigned int D.6727;
  long unsigned int D.6728;
  unsigned int D.6729;
  unsigned int D.6732;
  long unsigned int D.6734;
  long unsigned int D.6735;
  long unsigned int D.6742;
  unsigned int D.6743;
  word orig_word_sz;
  word word_sz;
  register word byte_sz;
  word smaller_than_i;
  word much_smaller_than_i;
  register word low_limit;
  register word j;

  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  D.6724 = GC_all_interior_pointers.2 + 7;
  D.6725 = (long unsigned int) D.6724;
  D.6726 = D.6725 + i;
  orig_word_sz = D.6726 >> 3;
  word_sz = orig_word_sz;
  byte_sz = word_sz << 3;
  D.6727 = byte_sz >> 3;
  smaller_than_i = byte_sz - D.6727;
  D.6728 = byte_sz >> 2;
  much_smaller_than_i = byte_sz - D.6728;
  D.6729 = GC_arrays._size_map[smaller_than_i];
  if (D.6729 == 0) goto <D.6730>; else goto <D.6731>;
  <D.6730>:
  low_limit = much_smaller_than_i;
  goto <D.5624>;
  <D.5623>:
  low_limit = low_limit + 1;
  <D.5624>:
  D.6732 = GC_arrays._size_map[low_limit];
  if (D.6732 != 0) goto <D.5623>; else goto <D.5625>;
  <D.5625>:
  goto <D.6733>;
  <D.6731>:
  low_limit = smaller_than_i + 1;
  goto <D.5627>;
  <D.5626>:
  low_limit = low_limit + 1;
  <D.5627>:
  D.6732 = GC_arrays._size_map[low_limit];
  if (D.6732 != 0) goto <D.5626>; else goto <D.5628>;
  <D.5628>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  D.6724 = GC_all_interior_pointers.2 + 7;
  D.6725 = (long unsigned int) D.6724;
  D.6734 = D.6725 + low_limit;
  word_sz = D.6734 >> 3;
  D.6735 = word_sz >> 3;
  word_sz = D.6735 + word_sz;
  if (word_sz < orig_word_sz) goto <D.6736>; else goto <D.6737>;
  <D.6736>:
  word_sz = orig_word_sz;
  <D.6737>:
  <D.6733>:
  if (word_sz > 256) goto <D.6738>; else goto <D.6739>;
  <D.6738>:
  word_sz = 256;
  <D.6739>:
  {
    size_t number_of_objs;

    number_of_objs = 512 / word_sz;
    word_sz = 512 / number_of_objs;
  }
  byte_sz = word_sz << 3;
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.2 != 0) goto <D.6740>; else goto <D.6741>;
  <D.6740>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  D.6742 = (long unsigned int) GC_all_interior_pointers.2;
  byte_sz = byte_sz - D.6742;
  <D.6741>:
  j = low_limit;
  goto <D.5631>;
  <D.5630>:
  D.6743 = (unsigned int) word_sz;
  GC_arrays._size_map[j] = D.6743;
  j = j + 1;
  <D.5631>:
  if (j <= byte_sz) goto <D.5630>; else goto <D.5632>;
  <D.5632>:
}


GC_clear_stack_inner (char * arg, word limit)
{
  long unsigned int dummy.3;
  char * D.6747;
  word dummy[213];

  try
    {
      memset (&dummy, 0, 1704);
      dummy.3 = (long unsigned int) &dummy;
      if (dummy.3 > limit) goto <D.6745>; else goto <D.6746>;
      <D.6745>:
      GC_clear_stack_inner (arg, limit);
      <D.6746>:
      dummy.3 = (long unsigned int) &dummy;
      GC_noop1 (dummy.3);
      D.6747 = arg;
      return D.6747;
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.6752;
  int D.6757;
  void * D.6759;
  long unsigned int D.6760;

  D.6752 = __builtin_constant_p (__len);
  if (D.6752 != 0) goto <D.6753>; else goto <D.6754>;
  <D.6753>:
  if (__len == 0) goto <D.6755>; else goto <D.6756>;
  <D.6755>:
  D.6757 = __builtin_constant_p (__ch);
  if (D.6757 == 0) goto <D.6750>; else goto <D.6758>;
  <D.6758>:
  if (__ch != 0) goto <D.6750>; else goto <D.6751>;
  <D.6750>:
  __warn_memset_zero_len ();
  D.6759 = __dest;
  return D.6759;
  <D.6751>:
  <D.6756>:
  <D.6754>:
  D.6760 = __builtin_object_size (__dest, 0);
  D.6759 = __builtin___memset_chk (__dest, __ch, __len, D.6760);
  return D.6759;
}


GC_clear_stack (char * arg)
{
  char * D.6762;
  unsigned int random_no.4;
  unsigned int random_no.5;
  unsigned int D.6765;
  char * D.6768;
  register word sp;
  word dummy[256];
  static unsigned int random_no = 0;
  register word limit;

  try
    {
      D.6762 = GC_approx_sp ();
      sp = (word) D.6762;
      random_no.4 = random_no;
      random_no.5 = random_no.4 + 1;
      random_no = random_no.5;
      random_no.4 = random_no;
      D.6765 = random_no.4 % 13;
      if (D.6765 == 0) goto <D.6766>; else goto <D.6767>;
      <D.6766>:
      limit = sp;
      limit = limit + 18446744073709535232;
      limit = limit & 18446744073709551600;
      D.6768 = GC_clear_stack_inner (arg, limit);
      return D.6768;
      <D.6767>:
      memset (&dummy, 0, 2048);
      D.6768 = arg;
      return D.6768;
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


GC_base (void * p)
{
  int GC_is_initialized.6;
  void * D.6774;
  long unsigned int D.6775;
  long unsigned int D.6776;
  long unsigned int D.6777;
  struct bottom_index * D.6779;
  long unsigned int D.6780;
  long unsigned int D.6781;
  long unsigned int candidate_hdr.7;
  long unsigned int D.6785;
  sizetype D.6786;
  map_entry_type * D.6787;
  map_entry_type * GC_invalid_map.8;
  int D.6791;
  long unsigned int D.6792;
  sizetype D.6793;
  map_entry_type * D.6794;
  unsigned char D.6795;
  int D.6798;
  long int D.6799;
  long int D.6800;
  long unsigned int D.6801;
  long int D.6802;
  long unsigned int D.6803;
  struct hblk * D.6804;
  long unsigned int D.6805;
  long unsigned int sz.9;
  long unsigned int p.10;
  register word r;
  register struct hblk * h;
  register struct bottom_index * bi;
  register struct hdr * candidate_hdr;
  register word limit;

  r = (word) p;
  GC_is_initialized.6 = GC_is_initialized;
  if (GC_is_initialized.6 == 0) goto <D.6772>; else goto <D.6773>;
  <D.6772>:
  D.6774 = 0B;
  return D.6774;
  <D.6773>:
  D.6775 = r & 18446744073709547520;
  h = (struct hblk *) D.6775;
  {
    register word hi;
    register struct bottom_index * _bi;

    hi = r >> 22;
    D.6776 = hi & 2047;
    _bi = GC_arrays._top_index[D.6776];
    goto <D.5660>;
    <D.5659>:
    _bi = _bi->hash_link;
    <D.5660>:
    D.6777 = _bi->key;
    if (D.6777 != hi) goto <D.6778>; else goto <D.5661>;
    <D.6778>:
    D.6779 = GC_arrays._all_nils;
    if (D.6779 != _bi) goto <D.5659>; else goto <D.5661>;
    <D.5661>:
    bi = _bi;
  }
  D.6780 = r >> 12;
  D.6781 = D.6780 & 1023;
  candidate_hdr = bi->index[D.6781];
  if (candidate_hdr == 0B) goto <D.6782>; else goto <D.6783>;
  <D.6782>:
  D.6774 = 0B;
  return D.6774;
  <D.6783>:
  goto <D.5663>;
  <D.5662>:
  candidate_hdr.7 = (long unsigned int) candidate_hdr;
  D.6785 = candidate_hdr.7 * 4096;
  D.6786 = -D.6785;
  h = h + D.6786;
  r = (word) h;
  candidate_hdr = GC_find_header (h);
  <D.5663>:
  candidate_hdr.7 = (long unsigned int) candidate_hdr;
  if (candidate_hdr.7 <= 4095) goto <D.5662>; else goto <D.5664>;
  <D.5664>:
  D.6787 = candidate_hdr->hb_map;
  GC_invalid_map.8 = GC_invalid_map;
  if (D.6787 == GC_invalid_map.8) goto <D.6789>; else goto <D.6790>;
  <D.6789>:
  D.6774 = 0B;
  return D.6774;
  <D.6790>:
  r = r & 18446744073709551608;
  {
    register int offset;
    register signed_word sz;
    register signed_word map_entry;

    D.6791 = (int) r;
    offset = D.6791 & 4095;
    D.6792 = candidate_hdr->hb_sz;
    sz = (signed_word) D.6792;
    D.6787 = candidate_hdr->hb_map;
    D.6793 = (sizetype) offset;
    D.6794 = D.6787 + D.6793;
    D.6795 = *D.6794;
    map_entry = (signed_word) D.6795;
    if (map_entry > 253) goto <D.6796>; else goto <D.6797>;
    <D.6796>:
    D.6798 = offset >> 3;
    D.6799 = (long int) D.6798;
    map_entry = D.6799 % sz;
    <D.6797>:
    D.6800 = map_entry << 3;
    D.6801 = (long unsigned int) D.6800;
    r = r - D.6801;
    D.6802 = sz << 3;
    D.6803 = (long unsigned int) D.6802;
    limit = D.6803 + r;
    D.6804 = h + 4096;
    D.6805 = (long unsigned int) D.6804;
    if (D.6805 < limit) goto <D.6806>; else goto <D.6807>;
    <D.6806>:
    sz.9 = (long unsigned int) sz;
    if (sz.9 <= 512) goto <D.6809>; else goto <D.6810>;
    <D.6809>:
    D.6774 = 0B;
    return D.6774;
    <D.6810>:
    <D.6807>:
    p.10 = (long unsigned int) p;
    if (p.10 >= limit) goto <D.6812>; else goto <D.6813>;
    <D.6812>:
    D.6774 = 0B;
    return D.6774;
    <D.6813>:
  }
  D.6774 = (void *) r;
  return D.6774;
}


GC_size (void * p)
{
  long unsigned int D.6815;
  long unsigned int D.6816;
  size_t D.6817;
  register int sz;
  register struct hdr * hhdr;

  hhdr = GC_find_header (p);
  D.6815 = hhdr->hb_sz;
  D.6816 = D.6815 << 3;
  sz = (int) D.6816;
  D.6817 = (size_t) sz;
  return D.6817;
}


GC_get_heap_size ()
{
  size_t D.6819;

  D.6819 = GC_arrays._heapsize;
  return D.6819;
}


GC_get_free_bytes ()
{
  size_t D.6821;

  D.6821 = GC_arrays._large_free_bytes;
  return D.6821;
}


GC_get_bytes_since_gc ()
{
  size_t D.6823;
  long unsigned int D.6824;

  D.6824 = GC_arrays._words_allocd;
  D.6823 = D.6824 << 3;
  return D.6823;
}


GC_get_total_bytes ()
{
  size_t D.6826;
  long unsigned int D.6827;
  long unsigned int D.6828;
  long unsigned int D.6829;

  D.6827 = GC_arrays._words_allocd;
  D.6828 = GC_arrays._words_allocd_before_gc;
  D.6829 = D.6827 + D.6828;
  D.6826 = D.6829 << 3;
  return D.6826;
}


GC_get_suspend_signal ()
{
  int D.6831;

  D.6831 = 30;
  return D.6831;
}


GC_init ()
{
  int D.6833;

  D.6833 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.6833 != 0) goto <D.6834>; else goto <D.6835>;
  <D.6834>:
  GC_lock ();
  <D.6835>:
  GC_init_inner ();
  pthread_mutex_unlock (&GC_allocate_ml);
  {
    extern void GC_init_parallel (void);

    GC_init_parallel ();
  }
}


GC_exit_check ()
{
  GC_gcollect ();
}


GC_init_inner ()
{
  int GC_is_initialized.11;
  char * D.6839;
  char * D.6842;
  char * D.6845;
  char * D.6848;
  char * D.6851;
  char * D.6854;
  char * D.6857;
  void (*<T8c2>) (char *, GC_word) GC_current_warn_proc.12;
  long unsigned int time_limit.13;
  int GC_all_interior_pointers.14;
  char * GC_stackbottom.15;
  char * GC_stackbottom.16;
  int D.6880;
  int D.6885;
  long unsigned int sz_str.17;
  long int D.6891;
  long unsigned int D.6892;
  long unsigned int sz_str.18;
  long unsigned int GC_max_retries.19;
  int D.6899;
  int D.6902;
  char * D.6905;
  int GC_dump_regularly.20;
  int GC_dont_precollect.21;
  int GC_incremental.22;
  word initial_heap_sz;

  initial_heap_sz = 16;
  GC_is_initialized.11 = GC_is_initialized;
  if (GC_is_initialized.11 != 0) goto <D.6837>; else goto <D.6838>;
  <D.6837>:
  return;
  <D.6838>:
  D.6839 = getenv ("GC_PRINT_STATS");
  if (D.6839 != 0B) goto <D.6840>; else goto <D.6841>;
  <D.6840>:
  GC_print_stats = 1;
  <D.6841>:
  D.6842 = getenv ("GC_DUMP_REGULARLY");
  if (D.6842 != 0B) goto <D.6843>; else goto <D.6844>;
  <D.6843>:
  GC_dump_regularly = 1;
  <D.6844>:
  D.6845 = getenv ("GC_FIND_LEAK");
  if (D.6845 != 0B) goto <D.6846>; else goto <D.6847>;
  <D.6846>:
  GC_find_leak = 1;
  atexit (GC_exit_check);
  <D.6847>:
  D.6848 = getenv ("GC_ALL_INTERIOR_POINTERS");
  if (D.6848 != 0B) goto <D.6849>; else goto <D.6850>;
  <D.6849>:
  GC_all_interior_pointers = 1;
  <D.6850>:
  D.6851 = getenv ("GC_DONT_GC");
  if (D.6851 != 0B) goto <D.6852>; else goto <D.6853>;
  <D.6852>:
  GC_dont_gc = 1;
  <D.6853>:
  D.6854 = getenv ("GC_PRINT_BACK_HEIGHT");
  if (D.6854 != 0B) goto <D.6855>; else goto <D.6856>;
  <D.6855>:
  GC_print_back_height = 1;
  <D.6856>:
  D.6857 = getenv ("GC_NO_BLACKLIST_WARNING");
  if (D.6857 != 0B) goto <D.6858>; else goto <D.6859>;
  <D.6858>:
  GC_large_alloc_warn_interval = 9223372036854775807;
  <D.6859>:
  {
    char * time_limit_string;

    time_limit_string = getenv ("GC_PAUSE_TIME_TARGET");
    if (time_limit_string != 0B) goto <D.6860>; else goto <D.6861>;
    <D.6860>:
    {
      long int time_limit;

      time_limit = atol (time_limit_string);
      if (time_limit <= 4) goto <D.6862>; else goto <D.6863>;
      <D.6862>:
      GC_current_warn_proc.12 = GC_current_warn_proc;
      GC_current_warn_proc.12 ("GC Warning: GC_PAUSE_TIME_TARGET environment variable value too small or bad syntax: Ignoring\n", 0);
      goto <D.6865>;
      <D.6863>:
      time_limit.13 = (long unsigned int) time_limit;
      GC_time_limit = time_limit.13;
      <D.6865>:
    }
    <D.6861>:
  }
  {
    char * interval_string;

    interval_string = getenv ("GC_LARGE_ALLOC_WARN_INTERVAL");
    if (interval_string != 0B) goto <D.6867>; else goto <D.6868>;
    <D.6867>:
    {
      long int interval;

      interval = atol (interval_string);
      if (interval <= 0) goto <D.6869>; else goto <D.6870>;
      <D.6869>:
      GC_current_warn_proc.12 = GC_current_warn_proc;
      GC_current_warn_proc.12 ("GC Warning: GC_LARGE_ALLOC_WARN_INTERVAL environment variable has bad value: Ignoring\n", 0);
      goto <D.6871>;
      <D.6870>:
      GC_large_alloc_warn_interval = interval;
      <D.6871>:
    }
    <D.6868>:
  }
  maybe_install_looping_handler ();
  GC_all_interior_pointers.14 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.14 != 0) goto <D.6873>; else goto <D.6874>;
  <D.6873>:
  GC_obj_kinds[1].ok_descriptor = 18446744073709551608;
  <D.6874>:
  GC_setpagesize ();
  GC_exclude_static_roots (&GC_arrays, &MEM[(void *)&GC_arrays + 83184B]);
  GC_exclude_static_roots (&GC_obj_kinds, &MEM[(void *)&GC_obj_kinds + 512B]);
  GC_init_linux_data_start ();
  GC_thr_init ();
  GC_stackbottom.15 = GC_stackbottom;
  if (GC_stackbottom.15 == 0B) goto <D.6876>; else goto <D.6877>;
  <D.6876>:
  GC_stackbottom.16 = GC_get_stack_base ();
  GC_stackbottom = GC_stackbottom.16;
  goto <D.6879>;
  <D.6877>:
  <D.6879>:
  D.6880 = GC_register_main_static_data ();
  if (D.6880 != 0) goto <D.6881>; else goto <D.6882>;
  <D.6881>:
  GC_register_data_segments ();
  <D.6882>:
  GC_init_headers ();
  GC_bl_init ();
  GC_mark_init ();
  {
    char * sz_str;

    sz_str = getenv ("GC_INITIAL_HEAP_SIZE");
    if (sz_str != 0B) goto <D.6883>; else goto <D.6884>;
    <D.6883>:
    D.6885 = atoi (sz_str);
    initial_heap_sz = (word) D.6885;
    if (initial_heap_sz <= 65536) goto <D.6886>; else goto <D.6887>;
    <D.6886>:
    GC_current_warn_proc.12 = GC_current_warn_proc;
    sz_str.17 = (long unsigned int) sz_str;
    GC_current_warn_proc.12 ("GC Warning: Bad initial heap size %s - ignoring it.\n", sz_str.17);
    <D.6887>:
    initial_heap_sz = initial_heap_sz >> 12;
    <D.6884>:
  }
  {
    char * sz_str;

    sz_str = getenv ("GC_MAXIMUM_HEAP_SIZE");
    if (sz_str != 0B) goto <D.6889>; else goto <D.6890>;
    <D.6889>:
    {
      word max_heap_sz;

      D.6891 = atol (sz_str);
      max_heap_sz = (word) D.6891;
      D.6892 = initial_heap_sz * 4096;
      if (D.6892 > max_heap_sz) goto <D.6893>; else goto <D.6894>;
      <D.6893>:
      GC_current_warn_proc.12 = GC_current_warn_proc;
      sz_str.18 = (long unsigned int) sz_str;
      GC_current_warn_proc.12 ("GC Warning: Bad maximum heap size %s - ignoring it.\n", sz_str.18);
      <D.6894>:
      GC_max_retries.19 = GC_max_retries;
      if (GC_max_retries.19 == 0) goto <D.6897>; else goto <D.6898>;
      <D.6897>:
      GC_max_retries = 2;
      <D.6898>:
      GC_set_max_heap_size (max_heap_sz);
    }
    <D.6890>:
  }
  D.6899 = GC_expand_hp_inner (initial_heap_sz);
  if (D.6899 == 0) goto <D.6900>; else goto <D.6901>;
  <D.6900>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.6901>:
  D.6902 = GC_add_map_entry (0);
  if (D.6902 == 0) goto <D.6903>; else goto <D.6904>;
  <D.6903>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.6904>:
  GC_register_displacement_inner (0);
  GC_init_size_map ();
  D.6905 = getenv ("GC_ENABLE_INCREMENTAL");
  if (D.6905 != 0B) goto <D.6906>; else goto <D.6907>;
  <D.6906>:
  GC_setpagesize ();
  GC_dirty_init ();
  GC_incremental = 1;
  <D.6907>:
  GC_dump_regularly.20 = GC_dump_regularly;
  if (GC_dump_regularly.20 != 0) goto <D.6909>; else goto <D.6910>;
  <D.6909>:
  GC_dump ();
  <D.6910>:
  GC_dont_precollect.21 = GC_dont_precollect;
  if (GC_dont_precollect.21 == 0) goto <D.6911>; else goto <D.6914>;
  <D.6914>:
  GC_incremental.22 = GC_incremental;
  if (GC_incremental.22 != 0) goto <D.6911>; else goto <D.6912>;
  <D.6911>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.6912>:
  GC_is_initialized = 1;
}


maybe_install_looping_handler ()
{
  int installed_looping_handler.23;
  char * D.6920;

  installed_looping_handler.23 = installed_looping_handler;
  if (installed_looping_handler.23 == 0) goto <D.6918>; else goto <D.6919>;
  <D.6918>:
  D.6920 = getenv ("GC_LOOP_ON_ABORT");
  if (D.6920 != 0B) goto <D.6921>; else goto <D.6922>;
  <D.6921>:
  GC_set_and_save_fault_handler (looping_handler);
  installed_looping_handler = 1;
  <D.6922>:
  <D.6919>:
}


looping_handler (int sig)
{
  long int D.6923;

  D.6923 = (long int) sig;
  GC_err_printf ("Caught signal %d: looping in handler\n", D.6923, 0, 0, 0, 0, 0);
  <D.5701>:
  goto <D.5701>;
}


atoi (const char * __nptr)
{
  int D.6924;
  long int D.6925;

  D.6925 = strtol (__nptr, 0B, 10);
  D.6924 = (int) D.6925;
  return D.6924;
}


atol (const char * __nptr)
{
  long int D.6927;

  D.6927 = strtol (__nptr, 0B, 10);
  return D.6927;
}


GC_enable_incremental ()
{
  int GC_find_leak.24;
  int D.6932;
  int GC_incremental.25;
  int GC_is_initialized.26;
  int GC_dont_gc.27;
  long unsigned int D.6945;
  void out = <<< error >>>;

  GC_find_leak.24 = GC_find_leak;
  if (GC_find_leak.24 == 0) goto <D.6930>; else goto <D.6931>;
  <D.6930>:
  D.6932 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.6932 != 0) goto <D.6933>; else goto <D.6934>;
  <D.6933>:
  GC_lock ();
  <D.6934>:
  GC_incremental.25 = GC_incremental;
  if (GC_incremental.25 != 0) goto out; else goto <D.6936>;
  <D.6936>:
  GC_setpagesize ();
  if (0 != 0) goto out; else goto <D.6937>;
  <D.6937>:
  maybe_install_looping_handler ();
  GC_dirty_init ();
  GC_is_initialized.26 = GC_is_initialized;
  if (GC_is_initialized.26 == 0) goto <D.6939>; else goto <D.6940>;
  <D.6939>:
  GC_init_inner ();
  <D.6940>:
  GC_incremental.25 = GC_incremental;
  if (GC_incremental.25 != 0) goto out; else goto <D.6941>;
  <D.6941>:
  GC_dont_gc.27 = GC_dont_gc;
  if (GC_dont_gc.27 != 0) goto <D.6943>; else goto <D.6944>;
  <D.6943>:
  pthread_mutex_unlock (&GC_allocate_ml);
  return;
  <D.6944>:
  D.6945 = GC_arrays._words_allocd;
  if (D.6945 != 0) goto <D.6946>; else goto <D.6947>;
  <D.6946>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.6947>:
  GC_read_dirty ();
  GC_incremental = 1;
  out:
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.6931>:
}


GC_write (int fd, const char * buf, size_t len)
{
  long unsigned int D.6949;
  long unsigned int D.6950;
  sizetype D.6951;
  const void * D.6952;
  long int D.6953;
  int D.6956;
  register int bytes_written;
  register int result;

  bytes_written = 0;
  goto <D.6629>;
  <D.6628>:
  D.6949 = (long unsigned int) bytes_written;
  D.6950 = len - D.6949;
  D.6951 = (sizetype) bytes_written;
  D.6952 = buf + D.6951;
  D.6953 = write (fd, D.6952, D.6950);
  result = (int) D.6953;
  if (result == -1) goto <D.6954>; else goto <D.6955>;
  <D.6954>:
  D.6956 = result;
  return D.6956;
  <D.6955>:
  bytes_written = bytes_written + result;
  <D.6629>:
  D.6949 = (long unsigned int) bytes_written;
  if (D.6949 < len) goto <D.6628>; else goto <D.6630>;
  <D.6630>:
  D.6956 = bytes_written;
  return D.6956;
}


GC_printf (const char * format, long int a, long int b, long int c, long int d, long int e, long int f)
{
  int GC_quiet.28;
  char D.6961;
  long unsigned int D.6964;
  int GC_stdout.29;
  int D.6966;
  char buf[1025];

  try
    {
      GC_quiet.28 = GC_quiet;
      if (GC_quiet.28 != 0) goto <D.6959>; else goto <D.6960>;
      <D.6959>:
      return;
      <D.6960>:
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.6961 = buf[1024];
      if (D.6961 != 21) goto <D.6962>; else goto <D.6963>;
      <D.6962>:
      GC_abort ("GC_printf clobbered stack");
      <D.6963>:
      D.6964 = strlen (&buf);
      GC_stdout.29 = GC_stdout;
      D.6966 = GC_write (GC_stdout.29, &buf, D.6964);
      if (D.6966 < 0) goto <D.6967>; else goto <D.6968>;
      <D.6967>:
      GC_abort ("write to stdout failed");
      <D.6968>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.6972;
  long unsigned int D.6973;

  D.6973 = __builtin_object_size (__s, 1);
  D.6972 = __builtin___sprintf_chk (__s, 1, D.6973, __fmt, __builtin_va_arg_pack ());
  return D.6972;
}


GC_err_printf (const char * format, long int a, long int b, long int c, long int d, long int e, long int f)
{
  char D.6975;
  long unsigned int D.6978;
  int GC_stderr.30;
  int D.6980;
  char buf[1025];

  try
    {
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.6975 = buf[1024];
      if (D.6975 != 21) goto <D.6976>; else goto <D.6977>;
      <D.6976>:
      GC_abort ("GC_err_printf clobbered stack");
      <D.6977>:
      D.6978 = strlen (&buf);
      GC_stderr.30 = GC_stderr;
      D.6980 = GC_write (GC_stderr.30, &buf, D.6978);
      if (D.6980 < 0) goto <D.6981>; else goto <D.6982>;
      <D.6981>:
      GC_abort ("write to stderr failed");
      <D.6982>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


GC_err_puts (const char * s)
{
  long unsigned int D.6983;
  int GC_stderr.31;
  int D.6985;

  D.6983 = strlen (s);
  GC_stderr.31 = GC_stderr;
  D.6985 = GC_write (GC_stderr.31, s, D.6983);
  if (D.6985 < 0) goto <D.6986>; else goto <D.6987>;
  <D.6986>:
  GC_abort ("write to stderr failed");
  <D.6987>:
}


GC_err_write (const char * buf, size_t len)
{
  int GC_stderr.32;
  int D.6989;

  GC_stderr.32 = GC_stderr;
  D.6989 = GC_write (GC_stderr.32, buf, len);
  if (D.6989 < 0) goto <D.6990>; else goto <D.6991>;
  <D.6990>:
  GC_abort ("write to stderr failed");
  <D.6991>:
}


GC_default_warn_proc (char * msg, GC_word arg)
{
  long int arg.33;

  arg.33 = (long int) arg;
  GC_err_printf (msg, arg.33, 0, 0, 0, 0, 0);
}


GC_set_warn_proc (void (*GC_warn_proc) (char *, GC_word) p)
{
  int D.6993;
  void (*GC_warn_proc) (char *, GC_word) D.6996;
  void (*GC_warn_proc) (char *, GC_word) result;

  D.6993 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.6993 != 0) goto <D.6994>; else goto <D.6995>;
  <D.6994>:
  GC_lock ();
  <D.6995>:
  result = GC_current_warn_proc;
  GC_current_warn_proc = p;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.6996 = result;
  return D.6996;
}


GC_set_free_space_divisor (GC_word value)
{
  GC_word D.6998;
  GC_word old;

  old = GC_free_space_divisor;
  GC_free_space_divisor = value;
  D.6998 = old;
  return D.6998;
}


GC_abort (const char * msg)
{
  long int msg.34;
  char * D.7001;

  msg.34 = (long int) msg;
  GC_err_printf ("%s\n", msg.34, 0, 0, 0, 0, 0);
  D.7001 = getenv ("GC_LOOP_ON_ABORT");
  if (D.7001 != 0B) goto <D.7002>; else goto <D.7003>;
  <D.7002>:
  <D.6674>:
  goto <D.6674>;
  <D.7003>:
  abort ();
}


GC_enable ()
{
  int D.7004;
  int GC_dont_gc.35;
  int GC_dont_gc.36;

  D.7004 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7004 != 0) goto <D.7005>; else goto <D.7006>;
  <D.7005>:
  GC_lock ();
  <D.7006>:
  GC_dont_gc.35 = GC_dont_gc;
  GC_dont_gc.36 = GC_dont_gc.35 + -1;
  GC_dont_gc = GC_dont_gc.36;
  pthread_mutex_unlock (&GC_allocate_ml);
}


GC_disable ()
{
  int D.7009;
  int GC_dont_gc.37;
  int GC_dont_gc.38;

  D.7009 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7009 != 0) goto <D.7010>; else goto <D.7011>;
  <D.7010>:
  GC_lock ();
  <D.7011>:
  GC_dont_gc.37 = GC_dont_gc;
  GC_dont_gc.38 = GC_dont_gc.37 + 1;
  GC_dont_gc = GC_dont_gc.38;
  pthread_mutex_unlock (&GC_allocate_ml);
}


GC_new_free_list_inner ()
{
  void * * D.7016;
  void * result;

  result = GC_generic_malloc_inner (2056, 0);
  if (result == 0B) goto <D.7014>; else goto <D.7015>;
  <D.7014>:
  GC_abort ("Failed to allocate freelist for new kind");
  <D.7015>:
  memset (result, 0, 2056);
  D.7016 = result;
  return D.7016;
}


GC_new_free_list ()
{
  int D.7018;
  void * * D.7021;
  void * result;

  D.7018 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7018 != 0) goto <D.7019>; else goto <D.7020>;
  <D.7019>:
  GC_lock ();
  <D.7020>:
  result = GC_new_free_list_inner ();
  pthread_mutex_unlock (&GC_allocate_ml);
  D.7021 = result;
  return D.7021;
}


GC_new_kind_inner (void * * fl, GC_word descr, int adjust, int clear)
{
  int GC_n_kinds.39;
  int GC_n_kinds.40;
  int GC_n_kinds.41;
  int D.7028;
  int result;

  GC_n_kinds.39 = GC_n_kinds;
  GC_n_kinds.40 = GC_n_kinds.39;
  GC_n_kinds.41 = GC_n_kinds.40 + 1;
  GC_n_kinds = GC_n_kinds.41;
  result = GC_n_kinds.40;
  GC_n_kinds.39 = GC_n_kinds;
  if (GC_n_kinds.39 > 16) goto <D.7026>; else goto <D.7027>;
  <D.7026>:
  GC_abort ("Too many kinds");
  <D.7027>:
  GC_obj_kinds[result].ok_freelist = fl;
  GC_obj_kinds[result].ok_reclaim_list = 0B;
  GC_obj_kinds[result].ok_descriptor = descr;
  GC_obj_kinds[result].ok_relocate_descr = adjust;
  GC_obj_kinds[result].ok_init = clear;
  D.7028 = result;
  return D.7028;
}


GC_new_kind (void * * fl, GC_word descr, int adjust, int clear)
{
  int D.7030;
  int D.7033;
  int result;

  D.7030 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7030 != 0) goto <D.7031>; else goto <D.7032>;
  <D.7031>:
  GC_lock ();
  <D.7032>:
  result = GC_new_kind_inner (fl, descr, adjust, clear);
  pthread_mutex_unlock (&GC_allocate_ml);
  D.7033 = result;
  return D.7033;
}


GC_new_proc_inner (struct GC_ms_entry * (*GC_mark_proc) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word) proc)
{
  long unsigned int GC_n_mark_procs.42;
  long unsigned int GC_n_mark_procs.43;
  long unsigned int GC_n_mark_procs.44;
  int D.7040;
  int result;

  GC_n_mark_procs.42 = GC_n_mark_procs;
  GC_n_mark_procs.43 = GC_n_mark_procs.42;
  GC_n_mark_procs.44 = GC_n_mark_procs.43 + 1;
  GC_n_mark_procs = GC_n_mark_procs.44;
  result = (int) GC_n_mark_procs.43;
  GC_n_mark_procs.42 = GC_n_mark_procs;
  if (GC_n_mark_procs.42 > 64) goto <D.7038>; else goto <D.7039>;
  <D.7038>:
  GC_abort ("Too many mark procedures");
  <D.7039>:
  GC_arrays._mark_procs[result] = proc;
  D.7040 = result;
  return D.7040;
}


GC_new_proc (struct GC_ms_entry * (*GC_mark_proc) (GC_word *, struct GC_ms_entry *, struct GC_ms_entry *, GC_word) proc)
{
  int D.7042;
  int D.7045;
  int result;

  D.7042 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7042 != 0) goto <D.7043>; else goto <D.7044>;
  <D.7043>:
  GC_lock ();
  <D.7044>:
  result = GC_new_proc_inner (proc);
  pthread_mutex_unlock (&GC_allocate_ml);
  D.7045 = result;
  return D.7045;
}


GC_dump ()
{
  GC_printf ("***Static roots:\n", 0, 0, 0, 0, 0, 0);
  GC_print_static_roots ();
  GC_printf ("\n***Heap sections:\n", 0, 0, 0, 0, 0, 0);
  GC_print_heap_sects ();
  GC_printf ("\n***Free blocks:\n", 0, 0, 0, 0, 0, 0);
  GC_print_hblkfreelist ();
  GC_printf ("\n***Blocks in use:\n", 0, 0, 0, 0, 0, 0);
  GC_print_block_list ();
  GC_printf ("\n***Finalization statistics:\n", 0, 0, 0, 0, 0, 0);
  GC_print_finalization_stats ();
}