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

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


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

  D.6795 = arg2;
  return D.6795;
}


GC_init_size_map ()
{
  int GC_all_interior_pointers.0;
  unsigned int GC_all_interior_pointers.1;
  unsigned int D.6799;
  unsigned int D.6800;
  unsigned int D.6801;
  unsigned int D.6802;
  unsigned int D.6803;
  unsigned int D.6804;
  unsigned int D.6805;
  register unsigned int i;

  i = 0;
  goto <D.5684>;
  <D.5683>:
  GC_arrays._size_map[i] = 2;
  i = i + 1;
  <D.5684>:
  if (i <= 7) goto <D.5683>; else goto <D.5685>;
  <D.5685>:
  GC_arrays._size_map[8] = 2;
  i = 9;
  goto <D.5687>;
  <D.5686>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.6799 = GC_all_interior_pointers.1 + i;
  D.6800 = D.6799 + 7;
  D.6801 = D.6800 >> 3;
  GC_arrays._size_map[i] = D.6801;
  i = i + 1;
  <D.5687>:
  if (i <= 64) goto <D.5686>; else goto <D.5688>;
  <D.5688>:
  i = 65;
  goto <D.5690>;
  <D.5689>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.6799 = GC_all_interior_pointers.1 + i;
  D.6800 = D.6799 + 7;
  D.6801 = D.6800 >> 3;
  D.6802 = D.6801 + 1;
  D.6803 = D.6802 & 4294967294;
  GC_arrays._size_map[i] = D.6803;
  i = i + 1;
  <D.5690>:
  if (i <= 128) goto <D.5689>; else goto <D.5691>;
  <D.5691>:
  i = 129;
  goto <D.5693>;
  <D.5692>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.6799 = GC_all_interior_pointers.1 + i;
  D.6800 = D.6799 + 7;
  D.6801 = D.6800 >> 3;
  D.6804 = D.6801 + 3;
  D.6805 = D.6804 & 4294967292;
  GC_arrays._size_map[i] = D.6805;
  i = i + 1;
  <D.5693>:
  if (i <= 256) goto <D.5692>; else goto <D.5694>;
  <D.5694>:
}


GC_extend_size_map (word i)
{
  int GC_all_interior_pointers.2;
  int D.6807;
  long unsigned int D.6808;
  long unsigned int D.6809;
  long unsigned int D.6810;
  long unsigned int D.6811;
  unsigned int D.6812;
  unsigned int D.6815;
  long unsigned int D.6817;
  long unsigned int D.6818;
  long unsigned int D.6825;
  unsigned int D.6826;
  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.6807 = GC_all_interior_pointers.2 + 7;
  D.6808 = (long unsigned int) D.6807;
  D.6809 = D.6808 + i;
  orig_word_sz = D.6809 >> 3;
  word_sz = orig_word_sz;
  byte_sz = word_sz << 3;
  D.6810 = byte_sz >> 3;
  smaller_than_i = byte_sz - D.6810;
  D.6811 = byte_sz >> 2;
  much_smaller_than_i = byte_sz - D.6811;
  D.6812 = GC_arrays._size_map[smaller_than_i];
  if (D.6812 == 0) goto <D.6813>; else goto <D.6814>;
  <D.6813>:
  low_limit = much_smaller_than_i;
  goto <D.5706>;
  <D.5705>:
  low_limit = low_limit + 1;
  <D.5706>:
  D.6815 = GC_arrays._size_map[low_limit];
  if (D.6815 != 0) goto <D.5705>; else goto <D.5707>;
  <D.5707>:
  goto <D.6816>;
  <D.6814>:
  low_limit = smaller_than_i + 1;
  goto <D.5709>;
  <D.5708>:
  low_limit = low_limit + 1;
  <D.5709>:
  D.6815 = GC_arrays._size_map[low_limit];
  if (D.6815 != 0) goto <D.5708>; else goto <D.5710>;
  <D.5710>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  D.6807 = GC_all_interior_pointers.2 + 7;
  D.6808 = (long unsigned int) D.6807;
  D.6817 = D.6808 + low_limit;
  word_sz = D.6817 >> 3;
  D.6818 = word_sz >> 3;
  word_sz = D.6818 + word_sz;
  if (word_sz < orig_word_sz) goto <D.6819>; else goto <D.6820>;
  <D.6819>:
  word_sz = orig_word_sz;
  <D.6820>:
  <D.6816>:
  if (word_sz > 256) goto <D.6821>; else goto <D.6822>;
  <D.6821>:
  word_sz = 256;
  <D.6822>:
  {
    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.6823>; else goto <D.6824>;
  <D.6823>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  D.6825 = (long unsigned int) GC_all_interior_pointers.2;
  byte_sz = byte_sz - D.6825;
  <D.6824>:
  j = low_limit;
  goto <D.5713>;
  <D.5712>:
  D.6826 = (unsigned int) word_sz;
  GC_arrays._size_map[j] = D.6826;
  j = j + 1;
  <D.5713>:
  if (j <= byte_sz) goto <D.5712>; else goto <D.5714>;
  <D.5714>:
}


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

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.6833;
  long unsigned int D.6834;

  D.6834 = __builtin_object_size (__dest, 0);
  D.6833 = __builtin___memset_chk (__dest, __ch, __len, D.6834);
  return D.6833;
}


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

  try
    {
      D.6836 = GC_approx_sp ();
      sp = (word) D.6836;
      random_no.4 = random_no;
      random_no.5 = random_no.4 + 1;
      random_no = random_no.5;
      random_no.4 = random_no;
      D.6839 = random_no.4 % 13;
      if (D.6839 == 0) goto <D.6840>; else goto <D.6841>;
      <D.6840>:
      limit = sp;
      limit = limit + 18446744073709535232;
      limit = limit & 18446744073709551600;
      D.6842 = GC_clear_stack_inner (arg, limit);
      return D.6842;
      <D.6841>:
      memset (&dummy, 0, 2048);
      D.6842 = arg;
      return D.6842;
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


GC_base (void * p)
{
  int GC_is_initialized.6;
  void * D.6848;
  long unsigned int D.6849;
  long unsigned int D.6850;
  long unsigned int D.6851;
  struct bottom_index * D.6853;
  long unsigned int D.6854;
  long unsigned int D.6855;
  long unsigned int candidate_hdr.7;
  long unsigned int D.6859;
  sizetype D.6860;
  map_entry_type * D.6861;
  map_entry_type * GC_invalid_map.8;
  int D.6865;
  long unsigned int D.6866;
  sizetype D.6867;
  map_entry_type * D.6868;
  unsigned char D.6869;
  int D.6872;
  long int D.6873;
  long int D.6874;
  long unsigned int D.6875;
  long int D.6876;
  long unsigned int D.6877;
  struct hblk * D.6878;
  long unsigned int D.6879;
  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.6846>; else goto <D.6847>;
  <D.6846>:
  D.6848 = 0B;
  return D.6848;
  <D.6847>:
  D.6849 = r & 18446744073709547520;
  h = (struct hblk *) D.6849;
  {
    register word hi;
    register struct bottom_index * _bi;

    hi = r >> 22;
    D.6850 = hi & 2047;
    _bi = GC_arrays._top_index[D.6850];
    goto <D.5742>;
    <D.5741>:
    _bi = _bi->hash_link;
    <D.5742>:
    D.6851 = _bi->key;
    if (D.6851 != hi) goto <D.6852>; else goto <D.5743>;
    <D.6852>:
    D.6853 = GC_arrays._all_nils;
    if (D.6853 != _bi) goto <D.5741>; else goto <D.5743>;
    <D.5743>:
    bi = _bi;
  }
  D.6854 = r >> 12;
  D.6855 = D.6854 & 1023;
  candidate_hdr = bi->index[D.6855];
  if (candidate_hdr == 0B) goto <D.6856>; else goto <D.6857>;
  <D.6856>:
  D.6848 = 0B;
  return D.6848;
  <D.6857>:
  goto <D.5745>;
  <D.5744>:
  candidate_hdr.7 = (long unsigned int) candidate_hdr;
  D.6859 = candidate_hdr.7 * 4096;
  D.6860 = -D.6859;
  h = h + D.6860;
  r = (word) h;
  candidate_hdr = GC_find_header (h);
  <D.5745>:
  candidate_hdr.7 = (long unsigned int) candidate_hdr;
  if (candidate_hdr.7 <= 4095) goto <D.5744>; else goto <D.5746>;
  <D.5746>:
  D.6861 = candidate_hdr->hb_map;
  GC_invalid_map.8 = GC_invalid_map;
  if (D.6861 == GC_invalid_map.8) goto <D.6863>; else goto <D.6864>;
  <D.6863>:
  D.6848 = 0B;
  return D.6848;
  <D.6864>:
  r = r & 18446744073709551608;
  {
    register int offset;
    register signed_word sz;
    register signed_word map_entry;

    D.6865 = (int) r;
    offset = D.6865 & 4095;
    D.6866 = candidate_hdr->hb_sz;
    sz = (signed_word) D.6866;
    D.6861 = candidate_hdr->hb_map;
    D.6867 = (sizetype) offset;
    D.6868 = D.6861 + D.6867;
    D.6869 = *D.6868;
    map_entry = (signed_word) D.6869;
    if (map_entry > 253) goto <D.6870>; else goto <D.6871>;
    <D.6870>:
    D.6872 = offset >> 3;
    D.6873 = (long int) D.6872;
    map_entry = D.6873 % sz;
    <D.6871>:
    D.6874 = map_entry << 3;
    D.6875 = (long unsigned int) D.6874;
    r = r - D.6875;
    D.6876 = sz << 3;
    D.6877 = (long unsigned int) D.6876;
    limit = D.6877 + r;
    D.6878 = h + 4096;
    D.6879 = (long unsigned int) D.6878;
    if (D.6879 < limit) goto <D.6880>; else goto <D.6881>;
    <D.6880>:
    sz.9 = (long unsigned int) sz;
    if (sz.9 <= 512) goto <D.6883>; else goto <D.6884>;
    <D.6883>:
    D.6848 = 0B;
    return D.6848;
    <D.6884>:
    <D.6881>:
    p.10 = (long unsigned int) p;
    if (p.10 >= limit) goto <D.6886>; else goto <D.6887>;
    <D.6886>:
    D.6848 = 0B;
    return D.6848;
    <D.6887>:
  }
  D.6848 = (void *) r;
  return D.6848;
}


GC_size (void * p)
{
  long unsigned int D.6889;
  long unsigned int D.6890;
  size_t D.6891;
  register int sz;
  register struct hdr * hhdr;

  hhdr = GC_find_header (p);
  D.6889 = hhdr->hb_sz;
  D.6890 = D.6889 << 3;
  sz = (int) D.6890;
  D.6891 = (size_t) sz;
  return D.6891;
}


GC_get_heap_size ()
{
  size_t D.6893;

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


GC_get_free_bytes ()
{
  size_t D.6895;

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


GC_get_bytes_since_gc ()
{
  size_t D.6897;
  long unsigned int D.6898;

  D.6898 = GC_arrays._words_allocd;
  D.6897 = D.6898 << 3;
  return D.6897;
}


GC_get_total_bytes ()
{
  size_t D.6900;
  long unsigned int D.6901;
  long unsigned int D.6902;
  long unsigned int D.6903;

  D.6901 = GC_arrays._words_allocd;
  D.6902 = GC_arrays._words_allocd_before_gc;
  D.6903 = D.6901 + D.6902;
  D.6900 = D.6903 << 3;
  return D.6900;
}


GC_get_suspend_signal ()
{
  int D.6905;

  D.6905 = 30;
  return D.6905;
}


GC_init ()
{
  int D.6907;

  D.6907 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.6907 != 0) goto <D.6908>; else goto <D.6909>;
  <D.6908>:
  GC_lock ();
  <D.6909>:
  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.6913;
  char * D.6916;
  char * D.6919;
  char * D.6922;
  char * D.6925;
  char * D.6928;
  char * D.6931;
  void (*<T964>) (char *, GC_word) GC_current_warn_proc.12;
  long unsigned int time_limit.13;
  int GC_all_interior_pointers.14;
  void * D.6949;
  void * D.6950;
  char * GC_stackbottom.15;
  char * D.6954;
  int D.6956;
  int D.6961;
  long unsigned int sz_str.16;
  long int D.6967;
  long unsigned int D.6968;
  long unsigned int sz_str.17;
  long unsigned int GC_max_retries.18;
  int D.6975;
  int D.6978;
  char * D.6981;
  int GC_dump_regularly.19;
  int GC_dont_precollect.20;
  int GC_incremental.21;
  word initial_heap_sz;

  initial_heap_sz = 16;
  GC_is_initialized.11 = GC_is_initialized;
  if (GC_is_initialized.11 != 0) goto <D.6911>; else goto <D.6912>;
  <D.6911>:
  return;
  <D.6912>:
  D.6913 = getenv ("GC_PRINT_STATS");
  if (D.6913 != 0B) goto <D.6914>; else goto <D.6915>;
  <D.6914>:
  GC_print_stats = 1;
  <D.6915>:
  D.6916 = getenv ("GC_DUMP_REGULARLY");
  if (D.6916 != 0B) goto <D.6917>; else goto <D.6918>;
  <D.6917>:
  GC_dump_regularly = 1;
  <D.6918>:
  D.6919 = getenv ("GC_FIND_LEAK");
  if (D.6919 != 0B) goto <D.6920>; else goto <D.6921>;
  <D.6920>:
  GC_find_leak = 1;
  atexit (GC_exit_check);
  <D.6921>:
  D.6922 = getenv ("GC_ALL_INTERIOR_POINTERS");
  if (D.6922 != 0B) goto <D.6923>; else goto <D.6924>;
  <D.6923>:
  GC_all_interior_pointers = 1;
  <D.6924>:
  D.6925 = getenv ("GC_DONT_GC");
  if (D.6925 != 0B) goto <D.6926>; else goto <D.6927>;
  <D.6926>:
  GC_dont_gc = 1;
  <D.6927>:
  D.6928 = getenv ("GC_PRINT_BACK_HEIGHT");
  if (D.6928 != 0B) goto <D.6929>; else goto <D.6930>;
  <D.6929>:
  GC_print_back_height = 1;
  <D.6930>:
  D.6931 = getenv ("GC_NO_BLACKLIST_WARNING");
  if (D.6931 != 0B) goto <D.6932>; else goto <D.6933>;
  <D.6932>:
  GC_large_alloc_warn_interval = 9223372036854775807;
  <D.6933>:
  {
    char * time_limit_string;

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

      time_limit = atol (time_limit_string);
      if (time_limit <= 4) goto <D.6936>; else goto <D.6937>;
      <D.6936>:
      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.6939>;
      <D.6937>:
      time_limit.13 = (long unsigned int) time_limit;
      GC_time_limit = time_limit.13;
      <D.6939>:
    }
    <D.6935>:
  }
  {
    char * interval_string;

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

      interval = atol (interval_string);
      if (interval <= 0) goto <D.6943>; else goto <D.6944>;
      <D.6943>:
      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.6945>;
      <D.6944>:
      GC_large_alloc_warn_interval = interval;
      <D.6945>:
    }
    <D.6942>:
  }
  maybe_install_looping_handler ();
  GC_all_interior_pointers.14 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.14 != 0) goto <D.6947>; else goto <D.6948>;
  <D.6947>:
  GC_obj_kinds[1].ok_descriptor = 18446744073709551608;
  <D.6948>:
  GC_setpagesize ();
  D.6949 = &GC_arrays + 83184;
  GC_exclude_static_roots (&GC_arrays, D.6949);
  D.6950 = &GC_obj_kinds + 512;
  GC_exclude_static_roots (&GC_obj_kinds, D.6950);
  GC_thr_init ();
  GC_stackbottom.15 = GC_stackbottom;
  if (GC_stackbottom.15 == 0B) goto <D.6952>; else goto <D.6953>;
  <D.6952>:
  D.6954 = GC_get_stack_base ();
  GC_stackbottom = D.6954;
  goto <D.6955>;
  <D.6953>:
  <D.6955>:
  D.6956 = GC_register_main_static_data ();
  if (D.6956 != 0) goto <D.6957>; else goto <D.6958>;
  <D.6957>:
  GC_register_data_segments ();
  <D.6958>:
  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.6959>; else goto <D.6960>;
    <D.6959>:
    D.6961 = atoi (sz_str);
    initial_heap_sz = (word) D.6961;
    if (initial_heap_sz <= 65536) goto <D.6962>; else goto <D.6963>;
    <D.6962>:
    GC_current_warn_proc.12 = GC_current_warn_proc;
    sz_str.16 = (long unsigned int) sz_str;
    GC_current_warn_proc.12 ("GC Warning: Bad initial heap size %s - ignoring it.\n", sz_str.16);
    <D.6963>:
    initial_heap_sz = initial_heap_sz >> 12;
    <D.6960>:
  }
  {
    char * sz_str;

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

      D.6967 = atol (sz_str);
      max_heap_sz = (word) D.6967;
      D.6968 = initial_heap_sz * 4096;
      if (D.6968 > max_heap_sz) goto <D.6969>; else goto <D.6970>;
      <D.6969>:
      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 maximum heap size %s - ignoring it.\n", sz_str.17);
      <D.6970>:
      GC_max_retries.18 = GC_max_retries;
      if (GC_max_retries.18 == 0) goto <D.6973>; else goto <D.6974>;
      <D.6973>:
      GC_max_retries = 2;
      <D.6974>:
      GC_set_max_heap_size (max_heap_sz);
    }
    <D.6966>:
  }
  D.6975 = GC_expand_hp_inner (initial_heap_sz);
  if (D.6975 == 0) goto <D.6976>; else goto <D.6977>;
  <D.6976>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.6977>:
  D.6978 = GC_add_map_entry (0);
  if (D.6978 == 0) goto <D.6979>; else goto <D.6980>;
  <D.6979>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.6980>:
  GC_register_displacement_inner (0);
  GC_init_size_map ();
  D.6981 = getenv ("GC_ENABLE_INCREMENTAL");
  if (D.6981 != 0B) goto <D.6982>; else goto <D.6983>;
  <D.6982>:
  GC_setpagesize ();
  GC_dirty_init ();
  GC_incremental = 1;
  <D.6983>:
  GC_dump_regularly.19 = GC_dump_regularly;
  if (GC_dump_regularly.19 != 0) goto <D.6985>; else goto <D.6986>;
  <D.6985>:
  GC_dump ();
  <D.6986>:
  GC_dont_precollect.20 = GC_dont_precollect;
  if (GC_dont_precollect.20 == 0) goto <D.6987>; else goto <D.6990>;
  <D.6990>:
  GC_incremental.21 = GC_incremental;
  if (GC_incremental.21 != 0) goto <D.6987>; else goto <D.6988>;
  <D.6987>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.6988>:
  GC_is_initialized = 1;
}


maybe_install_looping_handler ()
{
  int installed_looping_handler.22;
  char * D.6996;

  installed_looping_handler.22 = installed_looping_handler;
  if (installed_looping_handler.22 == 0) goto <D.6994>; else goto <D.6995>;
  <D.6994>:
  D.6996 = getenv ("GC_LOOP_ON_ABORT");
  if (D.6996 != 0B) goto <D.6997>; else goto <D.6998>;
  <D.6997>:
  GC_set_and_save_fault_handler (looping_handler);
  installed_looping_handler = 1;
  <D.6998>:
  <D.6995>:
}


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

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


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atoi (const char * __nptr)
{
  int D.7000;
  long int D.7001;

  D.7001 = strtol (__nptr, 0B, 10);
  D.7000 = (int) D.7001;
  return D.7000;
}


__attribute__((__gnu_inline__, __pure__, __leaf__, __nothrow__))
atol (const char * __nptr)
{
  long int D.7003;

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


GC_enable_incremental ()
{
  int GC_find_leak.23;
  int D.7008;
  int GC_incremental.24;
  int GC_is_initialized.25;
  int GC_dont_gc.26;
  long unsigned int D.7021;
  void out = <<< error >>>;

  GC_find_leak.23 = GC_find_leak;
  if (GC_find_leak.23 == 0) goto <D.7006>; else goto <D.7007>;
  <D.7006>:
  D.7008 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7008 != 0) goto <D.7009>; else goto <D.7010>;
  <D.7009>:
  GC_lock ();
  <D.7010>:
  GC_incremental.24 = GC_incremental;
  if (GC_incremental.24 != 0) goto out; else goto <D.7012>;
  <D.7012>:
  GC_setpagesize ();
  if (0 != 0) goto out; else goto <D.7013>;
  <D.7013>:
  maybe_install_looping_handler ();
  GC_dirty_init ();
  GC_is_initialized.25 = GC_is_initialized;
  if (GC_is_initialized.25 == 0) goto <D.7015>; else goto <D.7016>;
  <D.7015>:
  GC_init_inner ();
  <D.7016>:
  GC_incremental.24 = GC_incremental;
  if (GC_incremental.24 != 0) goto out; else goto <D.7017>;
  <D.7017>:
  GC_dont_gc.26 = GC_dont_gc;
  if (GC_dont_gc.26 != 0) goto <D.7019>; else goto <D.7020>;
  <D.7019>:
  pthread_mutex_unlock (&GC_allocate_ml);
  return;
  <D.7020>:
  D.7021 = GC_arrays._words_allocd;
  if (D.7021 != 0) goto <D.7022>; else goto <D.7023>;
  <D.7022>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.7023>:
  GC_read_dirty ();
  GC_incremental = 1;
  out:
  pthread_mutex_unlock (&GC_allocate_ml);
  <D.7007>:
}


GC_write (int fd, const char * buf, size_t len)
{
  sizetype D.7025;
  const char * D.7026;
  long unsigned int D.7027;
  long unsigned int D.7028;
  long int D.7029;
  int D.7032;
  register int bytes_written;
  register int result;

  bytes_written = 0;
  goto <D.6712>;
  <D.6711>:
  D.7025 = (sizetype) bytes_written;
  D.7026 = buf + D.7025;
  D.7027 = (long unsigned int) bytes_written;
  D.7028 = len - D.7027;
  D.7029 = write (fd, D.7026, D.7028);
  result = (int) D.7029;
  if (result == -1) goto <D.7030>; else goto <D.7031>;
  <D.7030>:
  D.7032 = result;
  return D.7032;
  <D.7031>:
  bytes_written = bytes_written + result;
  <D.6712>:
  D.7027 = (long unsigned int) bytes_written;
  if (D.7027 < len) goto <D.6711>; else goto <D.6713>;
  <D.6713>:
  D.7032 = bytes_written;
  return D.7032;
}


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.27;
  char D.7037;
  int GC_stdout.28;
  long unsigned int D.7041;
  int D.7042;
  char buf[1025];

  try
    {
      GC_quiet.27 = GC_quiet;
      if (GC_quiet.27 != 0) goto <D.7035>; else goto <D.7036>;
      <D.7035>:
      return;
      <D.7036>:
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.7037 = buf[1024];
      if (D.7037 != 21) goto <D.7038>; else goto <D.7039>;
      <D.7038>:
      GC_abort ("GC_printf clobbered stack");
      <D.7039>:
      GC_stdout.28 = GC_stdout;
      D.7041 = strlen (&buf);
      D.7042 = GC_write (GC_stdout.28, &buf, D.7041);
      if (D.7042 < 0) goto <D.7043>; else goto <D.7044>;
      <D.7043>:
      GC_abort ("write to stdout failed");
      <D.7044>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.7048;
  long unsigned int D.7049;

  D.7049 = __builtin_object_size (__s, 1);
  D.7048 = __builtin___sprintf_chk (__s, 1, D.7049, __fmt, __builtin_va_arg_pack ());
  return D.7048;
}


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.7051;
  int GC_stderr.29;
  long unsigned int D.7055;
  int D.7056;
  char buf[1025];

  try
    {
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.7051 = buf[1024];
      if (D.7051 != 21) goto <D.7052>; else goto <D.7053>;
      <D.7052>:
      GC_abort ("GC_err_printf clobbered stack");
      <D.7053>:
      GC_stderr.29 = GC_stderr;
      D.7055 = strlen (&buf);
      D.7056 = GC_write (GC_stderr.29, &buf, D.7055);
      if (D.7056 < 0) goto <D.7057>; else goto <D.7058>;
      <D.7057>:
      GC_abort ("write to stderr failed");
      <D.7058>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


GC_err_puts (const char * s)
{
  int GC_stderr.30;
  long unsigned int D.7060;
  int D.7061;

  GC_stderr.30 = GC_stderr;
  D.7060 = strlen (s);
  D.7061 = GC_write (GC_stderr.30, s, D.7060);
  if (D.7061 < 0) goto <D.7062>; else goto <D.7063>;
  <D.7062>:
  GC_abort ("write to stderr failed");
  <D.7063>:
}


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

  GC_stderr.31 = GC_stderr;
  D.7065 = GC_write (GC_stderr.31, buf, len);
  if (D.7065 < 0) goto <D.7066>; else goto <D.7067>;
  <D.7066>:
  GC_abort ("write to stderr failed");
  <D.7067>:
}


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

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


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

  D.7069 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7069 != 0) goto <D.7070>; else goto <D.7071>;
  <D.7070>:
  GC_lock ();
  <D.7071>:
  result = GC_current_warn_proc;
  GC_current_warn_proc = p;
  pthread_mutex_unlock (&GC_allocate_ml);
  D.7072 = result;
  return D.7072;
}


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

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


GC_abort (const char * msg)
{
  long int msg.33;
  char * D.7077;

  msg.33 = (long int) msg;
  GC_err_printf ("%s\n", msg.33, 0, 0, 0, 0, 0);
  D.7077 = getenv ("GC_LOOP_ON_ABORT");
  if (D.7077 != 0B) goto <D.7078>; else goto <D.7079>;
  <D.7078>:
  <D.6757>:
  goto <D.6757>;
  <D.7079>:
  abort ();
}


GC_enable ()
{
  int D.7080;
  int GC_dont_gc.34;
  int D.7084;

  D.7080 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7080 != 0) goto <D.7081>; else goto <D.7082>;
  <D.7081>:
  GC_lock ();
  <D.7082>:
  GC_dont_gc.34 = GC_dont_gc;
  D.7084 = GC_dont_gc.34 + -1;
  GC_dont_gc = D.7084;
  pthread_mutex_unlock (&GC_allocate_ml);
}


GC_disable ()
{
  int D.7085;
  int GC_dont_gc.35;
  int D.7089;

  D.7085 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7085 != 0) goto <D.7086>; else goto <D.7087>;
  <D.7086>:
  GC_lock ();
  <D.7087>:
  GC_dont_gc.35 = GC_dont_gc;
  D.7089 = GC_dont_gc.35 + 1;
  GC_dont_gc = D.7089;
  pthread_mutex_unlock (&GC_allocate_ml);
}


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

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


GC_new_free_list ()
{
  int D.7094;
  void * * D.7097;
  void * result;

  D.7094 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7094 != 0) goto <D.7095>; else goto <D.7096>;
  <D.7095>:
  GC_lock ();
  <D.7096>:
  result = GC_new_free_list_inner ();
  pthread_mutex_unlock (&GC_allocate_ml);
  D.7097 = result;
  return D.7097;
}


GC_new_kind_inner (void * * fl, GC_word descr, int adjust, int clear)
{
  int GC_n_kinds.36;
  int GC_n_kinds.37;
  int D.7101;
  int D.7104;
  int result;

  GC_n_kinds.36 = GC_n_kinds;
  GC_n_kinds.37 = GC_n_kinds.36;
  D.7101 = GC_n_kinds.37 + 1;
  GC_n_kinds = D.7101;
  result = GC_n_kinds.37;
  GC_n_kinds.36 = GC_n_kinds;
  if (GC_n_kinds.36 > 16) goto <D.7102>; else goto <D.7103>;
  <D.7102>:
  GC_abort ("Too many kinds");
  <D.7103>:
  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.7104 = result;
  return D.7104;
}


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

  D.7106 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7106 != 0) goto <D.7107>; else goto <D.7108>;
  <D.7107>:
  GC_lock ();
  <D.7108>:
  result = GC_new_kind_inner (fl, descr, adjust, clear);
  pthread_mutex_unlock (&GC_allocate_ml);
  D.7109 = result;
  return D.7109;
}


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.38;
  long unsigned int GC_n_mark_procs.39;
  long unsigned int D.7113;
  int D.7116;
  int result;

  GC_n_mark_procs.38 = GC_n_mark_procs;
  GC_n_mark_procs.39 = GC_n_mark_procs.38;
  D.7113 = GC_n_mark_procs.39 + 1;
  GC_n_mark_procs = D.7113;
  result = (int) GC_n_mark_procs.39;
  GC_n_mark_procs.38 = GC_n_mark_procs;
  if (GC_n_mark_procs.38 > 64) goto <D.7114>; else goto <D.7115>;
  <D.7114>:
  GC_abort ("Too many mark procedures");
  <D.7115>:
  GC_arrays._mark_procs[result] = proc;
  D.7116 = result;
  return D.7116;
}


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.7118;
  int D.7121;
  int result;

  D.7118 = pthread_mutex_trylock (&GC_allocate_ml);
  if (D.7118 != 0) goto <D.7119>; else goto <D.7120>;
  <D.7119>:
  GC_lock ();
  <D.7120>:
  result = GC_new_proc_inner (proc);
  pthread_mutex_unlock (&GC_allocate_ml);
  D.7121 = result;
  return D.7121;
}


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 ();
}