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

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


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

  D.8864 = arg2;
  return D.8864;
}


GC_init_size_map ()
{
  int GC_all_interior_pointers.0;
  unsigned int GC_all_interior_pointers.1;
  unsigned int D.8868;
  unsigned int D.8869;
  unsigned int D.8870;
  unsigned int D.8871;
  unsigned int D.8872;
  unsigned int D.8873;
  unsigned int D.8874;
  unsigned int D.8875;
  unsigned int D.8876;
  unsigned int D.8877;
  register unsigned int i;

  i = 0;
  goto <D.7757>;
  <D.7756>:
  GC_arrays._size_map[i] = 2;
  i = i + 1;
  <D.7757>:
  if (i <= 3) goto <D.7756>; else goto <D.7758>;
  <D.7758>:
  GC_arrays._size_map[4] = 2;
  i = 5;
  goto <D.7760>;
  <D.7759>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.8868 = i + GC_all_interior_pointers.1;
  D.8869 = D.8868 + 7;
  D.8870 = D.8869 >> 2;
  D.8871 = D.8870 & 4294967294;
  GC_arrays._size_map[i] = D.8871;
  i = i + 1;
  <D.7760>:
  if (i <= 32) goto <D.7759>; else goto <D.7761>;
  <D.7761>:
  i = 33;
  goto <D.7763>;
  <D.7762>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.8868 = GC_all_interior_pointers.1 + i;
  D.8872 = D.8868 + 3;
  D.8873 = D.8872 >> 2;
  D.8874 = D.8873 + 1;
  D.8875 = D.8874 & 4294967294;
  GC_arrays._size_map[i] = D.8875;
  i = i + 1;
  <D.7763>:
  if (i <= 64) goto <D.7762>; else goto <D.7764>;
  <D.7764>:
  i = 65;
  goto <D.7766>;
  <D.7765>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.8868 = GC_all_interior_pointers.1 + i;
  D.8872 = D.8868 + 3;
  D.8873 = D.8872 >> 2;
  D.8876 = D.8873 + 3;
  D.8877 = D.8876 & 4294967292;
  GC_arrays._size_map[i] = D.8877;
  i = i + 1;
  <D.7766>:
  if (i <= 128) goto <D.7765>; else goto <D.7767>;
  <D.7767>:
}


GC_extend_size_map (word i)
{
  int GC_all_interior_pointers.2;
  long unsigned int GC_all_interior_pointers.3;
  long unsigned int D.8880;
  long unsigned int D.8881;
  long unsigned int D.8882;
  long unsigned int D.8883;
  unsigned int D.8884;
  unsigned int D.8887;
  long unsigned int D.8889;
  long unsigned int D.8890;
  long unsigned int D.8891;
  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;
  GC_all_interior_pointers.3 = (long unsigned int) GC_all_interior_pointers.2;
  D.8880 = GC_all_interior_pointers.3 + i;
  D.8881 = D.8880 + 3;
  orig_word_sz = D.8881 >> 2;
  word_sz = orig_word_sz;
  byte_sz = word_sz << 2;
  D.8882 = byte_sz >> 3;
  smaller_than_i = byte_sz - D.8882;
  D.8883 = byte_sz >> 2;
  much_smaller_than_i = byte_sz - D.8883;
  D.8884 = GC_arrays._size_map[smaller_than_i];
  if (D.8884 == 0) goto <D.8885>; else goto <D.8886>;
  <D.8885>:
  low_limit = much_smaller_than_i;
  goto <D.7779>;
  <D.7778>:
  low_limit = low_limit + 1;
  <D.7779>:
  D.8887 = GC_arrays._size_map[low_limit];
  if (D.8887 != 0) goto <D.7778>; else goto <D.7780>;
  <D.7780>:
  goto <D.8888>;
  <D.8886>:
  low_limit = smaller_than_i + 1;
  goto <D.7782>;
  <D.7781>:
  low_limit = low_limit + 1;
  <D.7782>:
  D.8887 = GC_arrays._size_map[low_limit];
  if (D.8887 != 0) goto <D.7781>; else goto <D.7783>;
  <D.7783>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  GC_all_interior_pointers.3 = (long unsigned int) GC_all_interior_pointers.2;
  D.8889 = GC_all_interior_pointers.3 + low_limit;
  D.8890 = D.8889 + 3;
  word_sz = D.8890 >> 2;
  D.8891 = word_sz >> 3;
  word_sz = D.8891 + word_sz;
  if (word_sz < orig_word_sz) goto <D.8892>; else goto <D.8893>;
  <D.8892>:
  word_sz = orig_word_sz;
  <D.8893>:
  <D.8888>:
  word_sz = word_sz + 1;
  word_sz = word_sz & 4294967294;
  if (word_sz > 512) goto <D.8894>; else goto <D.8895>;
  <D.8894>:
  word_sz = 512;
  <D.8895>:
  {
    size_t number_of_objs;

    number_of_objs = 1024 / word_sz;
    word_sz = 1024 / number_of_objs;
    word_sz = word_sz & 4294967294;
  }
  byte_sz = word_sz << 2;
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.2 != 0) goto <D.8896>; else goto <D.8897>;
  <D.8896>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  GC_all_interior_pointers.3 = (long unsigned int) GC_all_interior_pointers.2;
  byte_sz = byte_sz - GC_all_interior_pointers.3;
  <D.8897>:
  j = low_limit;
  goto <D.7786>;
  <D.7785>:
  GC_arrays._size_map[j] = word_sz;
  j = j + 1;
  <D.7786>:
  if (j <= byte_sz) goto <D.7785>; else goto <D.7787>;
  <D.7787>:
}


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

  try
    {
      memset (&dummy, 0, 852);
      dummy.4 = (long unsigned int) &dummy;
      if (dummy.4 > limit) goto <D.8899>; else goto <D.8900>;
      <D.8899>:
      GC_clear_stack_inner (arg, limit);
      <D.8900>:
      dummy.4 = (long unsigned int) &dummy;
      GC_noop1 (dummy.4);
      D.8901 = arg;
      return D.8901;
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.8906;
  int D.8911;
  void * D.8913;
  unsigned int D.8914;

  D.8906 = __builtin_constant_p (__len);
  if (D.8906 != 0) goto <D.8907>; else goto <D.8908>;
  <D.8907>:
  if (__len == 0) goto <D.8909>; else goto <D.8910>;
  <D.8909>:
  D.8911 = __builtin_constant_p (__ch);
  if (D.8911 == 0) goto <D.8904>; else goto <D.8912>;
  <D.8912>:
  if (__ch != 0) goto <D.8904>; else goto <D.8905>;
  <D.8904>:
  __warn_memset_zero_len ();
  D.8913 = __dest;
  return D.8913;
  <D.8905>:
  <D.8910>:
  <D.8908>:
  D.8914 = __builtin_object_size (__dest, 0);
  D.8913 = __builtin___memset_chk (__dest, __ch, __len, D.8914);
  return D.8913;
}


GC_clear_stack (char * arg)
{
  char * D.8916;
  unsigned int random_no.5;
  unsigned int random_no.6;
  unsigned int D.8919;
  char * D.8922;
  register word sp;
  word dummy[256];
  static unsigned int random_no = 0;
  register word limit;

  try
    {
      D.8916 = GC_approx_sp ();
      sp = (word) D.8916;
      random_no.5 = random_no;
      random_no.6 = random_no.5 + 1;
      random_no = random_no.6;
      random_no.5 = random_no;
      D.8919 = random_no.5 % 13;
      if (D.8919 == 0) goto <D.8920>; else goto <D.8921>;
      <D.8920>:
      limit = sp;
      limit = limit + 4294959104;
      limit = limit & 4294967280;
      D.8922 = GC_clear_stack_inner (arg, limit);
      return D.8922;
      <D.8921>:
      memset (&dummy, 0, 1024);
      D.8922 = arg;
      return D.8922;
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


GC_base (void * p)
{
  int GC_is_initialized.7;
  void * D.8928;
  long unsigned int D.8929;
  long unsigned int D.8930;
  long unsigned int D.8931;
  long unsigned int D.8932;
  long unsigned int candidate_hdr.8;
  long unsigned int D.8936;
  sizetype D.8937;
  long unsigned int h.9;
  long unsigned int D.8939;
  struct bottom_index * D.8940;
  long unsigned int D.8941;
  long unsigned int D.8942;
  map_entry_type * D.8943;
  map_entry_type * GC_invalid_map.10;
  int r.11;
  long unsigned int D.8948;
  sizetype offset.12;
  map_entry_type * D.8950;
  unsigned char D.8951;
  int D.8954;
  long int D.8955;
  long unsigned int D.8956;
  long int D.8957;
  long unsigned int D.8958;
  struct hblk * D.8959;
  long unsigned int D.8960;
  long unsigned int sz.13;
  long unsigned int p.14;
  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.7 = GC_is_initialized;
  if (GC_is_initialized.7 == 0) goto <D.8926>; else goto <D.8927>;
  <D.8926>:
  D.8928 = 0B;
  return D.8928;
  <D.8927>:
  D.8929 = r & 4294963200;
  h = (struct hblk *) D.8929;
  D.8930 = r >> 22;
  bi = GC_arrays._top_index[D.8930];
  D.8931 = r >> 12;
  D.8932 = D.8931 & 1023;
  candidate_hdr = bi->index[D.8932];
  if (candidate_hdr == 0B) goto <D.8933>; else goto <D.8934>;
  <D.8933>:
  D.8928 = 0B;
  return D.8928;
  <D.8934>:
  goto <D.7813>;
  <D.7812>:
  candidate_hdr.8 = (long unsigned int) candidate_hdr;
  D.8936 = candidate_hdr.8 * 4096;
  D.8937 = -D.8936;
  h = h + D.8937;
  r = (word) h;
  h.9 = (long unsigned int) h;
  D.8939 = h.9 >> 22;
  D.8940 = GC_arrays._top_index[D.8939];
  h.9 = (long unsigned int) h;
  D.8941 = h.9 >> 12;
  D.8942 = D.8941 & 1023;
  candidate_hdr = D.8940->index[D.8942];
  <D.7813>:
  candidate_hdr.8 = (long unsigned int) candidate_hdr;
  if (candidate_hdr.8 <= 4095) goto <D.7812>; else goto <D.7814>;
  <D.7814>:
  D.8943 = candidate_hdr->hb_map;
  GC_invalid_map.10 = GC_invalid_map;
  if (D.8943 == GC_invalid_map.10) goto <D.8945>; else goto <D.8946>;
  <D.8945>:
  D.8928 = 0B;
  return D.8928;
  <D.8946>:
  r = r & 4294967292;
  {
    register int offset;
    register signed_word sz;
    register signed_word map_entry;

    r.11 = (int) r;
    offset = r.11 & 4095;
    D.8948 = candidate_hdr->hb_sz;
    sz = (signed_word) D.8948;
    D.8943 = candidate_hdr->hb_map;
    offset.12 = (sizetype) offset;
    D.8950 = D.8943 + offset.12;
    D.8951 = *D.8950;
    map_entry = (signed_word) D.8951;
    if (map_entry > 253) goto <D.8952>; else goto <D.8953>;
    <D.8952>:
    D.8954 = offset >> 2;
    map_entry = D.8954 % sz;
    <D.8953>:
    D.8955 = map_entry << 2;
    D.8956 = (long unsigned int) D.8955;
    r = r - D.8956;
    D.8957 = sz << 2;
    D.8958 = (long unsigned int) D.8957;
    limit = D.8958 + r;
    D.8959 = h + 4096;
    D.8960 = (long unsigned int) D.8959;
    if (D.8960 < limit) goto <D.8961>; else goto <D.8962>;
    <D.8961>:
    sz.13 = (long unsigned int) sz;
    if (sz.13 <= 1024) goto <D.8964>; else goto <D.8965>;
    <D.8964>:
    D.8928 = 0B;
    return D.8928;
    <D.8965>:
    <D.8962>:
    p.14 = (long unsigned int) p;
    if (p.14 >= limit) goto <D.8967>; else goto <D.8968>;
    <D.8967>:
    D.8928 = 0B;
    return D.8928;
    <D.8968>:
  }
  D.8928 = (void *) r;
  return D.8928;
}


GC_size (void * p)
{
  long unsigned int p.15;
  long unsigned int D.8971;
  struct bottom_index * D.8972;
  long unsigned int D.8973;
  long unsigned int D.8974;
  long unsigned int D.8975;
  long unsigned int D.8976;
  size_t D.8977;
  register int sz;
  register struct hdr * hhdr;

  p.15 = (long unsigned int) p;
  D.8971 = p.15 >> 22;
  D.8972 = GC_arrays._top_index[D.8971];
  p.15 = (long unsigned int) p;
  D.8973 = p.15 >> 12;
  D.8974 = D.8973 & 1023;
  hhdr = D.8972->index[D.8974];
  D.8975 = hhdr->hb_sz;
  D.8976 = D.8975 << 2;
  sz = (int) D.8976;
  D.8977 = (size_t) sz;
  return D.8977;
}


GC_get_heap_size ()
{
  size_t D.8979;

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


GC_get_free_bytes ()
{
  size_t D.8981;

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


GC_get_bytes_since_gc ()
{
  size_t D.8983;
  long unsigned int D.8984;

  D.8984 = GC_arrays._words_allocd;
  D.8983 = D.8984 << 2;
  return D.8983;
}


GC_get_total_bytes ()
{
  size_t D.8986;
  long unsigned int D.8987;
  long unsigned int D.8988;
  long unsigned int D.8989;

  D.8987 = GC_arrays._words_allocd;
  D.8988 = GC_arrays._words_allocd_before_gc;
  D.8989 = D.8987 + D.8988;
  D.8986 = D.8989 << 2;
  return D.8986;
}


GC_get_suspend_signal ()
{
  int D.8991;

  D.8991 = 30;
  return D.8991;
}


GC_init ()
{
  int D.8993;

  D.8993 = GC_test_and_set (&GC_allocate_lock);
  if (D.8993 != 0) goto <D.8994>; else goto <D.8995>;
  <D.8994>:
  GC_lock ();
  <D.8995>:
  GC_init_inner ();
  GC_clear (&GC_allocate_lock);
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.8996;
  unsigned int D.8997;

  D.8997 = __sync_lock_test_and_set_4 (addr, 1);
  D.8996 = (int) D.8997;
  return D.8996;
}


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


GC_exit_check ()
{
  GC_gcollect ();
}


GC_init_inner ()
{
  int GC_is_initialized.16;
  char * D.9002;
  char * D.9005;
  char * D.9008;
  char * D.9011;
  char * D.9014;
  char * D.9017;
  char * D.9020;
  void (*<T1282>) (char *, GC_word) GC_current_warn_proc.17;
  long unsigned int time_limit.18;
  int GC_all_interior_pointers.19;
  char * GC_stackbottom.20;
  char * GC_stackbottom.21;
  int D.9043;
  int D.9048;
  long unsigned int sz_str.22;
  long int D.9054;
  long unsigned int D.9055;
  long unsigned int sz_str.23;
  long unsigned int GC_max_retries.24;
  int D.9062;
  int D.9065;
  char * D.9068;
  int GC_dump_regularly.25;
  int GC_dont_precollect.26;
  int GC_incremental.27;
  word initial_heap_sz;

  initial_heap_sz = 16;
  GC_is_initialized.16 = GC_is_initialized;
  if (GC_is_initialized.16 != 0) goto <D.9000>; else goto <D.9001>;
  <D.9000>:
  return;
  <D.9001>:
  D.9002 = getenv ("GC_PRINT_STATS");
  if (D.9002 != 0B) goto <D.9003>; else goto <D.9004>;
  <D.9003>:
  GC_print_stats = 1;
  <D.9004>:
  D.9005 = getenv ("GC_DUMP_REGULARLY");
  if (D.9005 != 0B) goto <D.9006>; else goto <D.9007>;
  <D.9006>:
  GC_dump_regularly = 1;
  <D.9007>:
  D.9008 = getenv ("GC_FIND_LEAK");
  if (D.9008 != 0B) goto <D.9009>; else goto <D.9010>;
  <D.9009>:
  GC_find_leak = 1;
  atexit (GC_exit_check);
  <D.9010>:
  D.9011 = getenv ("GC_ALL_INTERIOR_POINTERS");
  if (D.9011 != 0B) goto <D.9012>; else goto <D.9013>;
  <D.9012>:
  GC_all_interior_pointers = 1;
  <D.9013>:
  D.9014 = getenv ("GC_DONT_GC");
  if (D.9014 != 0B) goto <D.9015>; else goto <D.9016>;
  <D.9015>:
  GC_dont_gc = 1;
  <D.9016>:
  D.9017 = getenv ("GC_PRINT_BACK_HEIGHT");
  if (D.9017 != 0B) goto <D.9018>; else goto <D.9019>;
  <D.9018>:
  GC_print_back_height = 1;
  <D.9019>:
  D.9020 = getenv ("GC_NO_BLACKLIST_WARNING");
  if (D.9020 != 0B) goto <D.9021>; else goto <D.9022>;
  <D.9021>:
  GC_large_alloc_warn_interval = 2147483647;
  <D.9022>:
  {
    char * time_limit_string;

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

      time_limit = atol (time_limit_string);
      if (time_limit <= 4) goto <D.9025>; else goto <D.9026>;
      <D.9025>:
      GC_current_warn_proc.17 = GC_current_warn_proc;
      GC_current_warn_proc.17 ("GC Warning: GC_PAUSE_TIME_TARGET environment variable value too small or bad syntax: Ignoring\n", 0);
      goto <D.9028>;
      <D.9026>:
      time_limit.18 = (long unsigned int) time_limit;
      GC_time_limit = time_limit.18;
      <D.9028>:
    }
    <D.9024>:
  }
  {
    char * interval_string;

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

      interval = atol (interval_string);
      if (interval <= 0) goto <D.9032>; else goto <D.9033>;
      <D.9032>:
      GC_current_warn_proc.17 = GC_current_warn_proc;
      GC_current_warn_proc.17 ("GC Warning: GC_LARGE_ALLOC_WARN_INTERVAL environment variable has bad value: Ignoring\n", 0);
      goto <D.9034>;
      <D.9033>:
      GC_large_alloc_warn_interval = interval;
      <D.9034>:
    }
    <D.9031>:
  }
  maybe_install_looping_handler ();
  GC_all_interior_pointers.19 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.19 != 0) goto <D.9036>; else goto <D.9037>;
  <D.9036>:
  GC_obj_kinds[1].ok_descriptor = 4294967292;
  <D.9037>:
  GC_setpagesize ();
  GC_exclude_static_roots (&GC_arrays, &MEM[(void *)&GC_arrays + 47736B]);
  GC_exclude_static_roots (&GC_obj_kinds, &MEM[(void *)&GC_obj_kinds + 320B]);
  GC_init_linux_data_start ();
  GC_thr_init ();
  GC_stackbottom.20 = GC_stackbottom;
  if (GC_stackbottom.20 == 0B) goto <D.9039>; else goto <D.9040>;
  <D.9039>:
  GC_stackbottom.21 = GC_get_stack_base ();
  GC_stackbottom = GC_stackbottom.21;
  goto <D.9042>;
  <D.9040>:
  <D.9042>:
  D.9043 = GC_register_main_static_data ();
  if (D.9043 != 0) goto <D.9044>; else goto <D.9045>;
  <D.9044>:
  GC_register_data_segments ();
  <D.9045>:
  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.9046>; else goto <D.9047>;
    <D.9046>:
    D.9048 = atoi (sz_str);
    initial_heap_sz = (word) D.9048;
    if (initial_heap_sz <= 65536) goto <D.9049>; else goto <D.9050>;
    <D.9049>:
    GC_current_warn_proc.17 = GC_current_warn_proc;
    sz_str.22 = (long unsigned int) sz_str;
    GC_current_warn_proc.17 ("GC Warning: Bad initial heap size %s - ignoring it.\n", sz_str.22);
    <D.9050>:
    initial_heap_sz = initial_heap_sz >> 12;
    <D.9047>:
  }
  {
    char * sz_str;

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

      D.9054 = atol (sz_str);
      max_heap_sz = (word) D.9054;
      D.9055 = initial_heap_sz * 4096;
      if (D.9055 > max_heap_sz) goto <D.9056>; else goto <D.9057>;
      <D.9056>:
      GC_current_warn_proc.17 = GC_current_warn_proc;
      sz_str.23 = (long unsigned int) sz_str;
      GC_current_warn_proc.17 ("GC Warning: Bad maximum heap size %s - ignoring it.\n", sz_str.23);
      <D.9057>:
      GC_max_retries.24 = GC_max_retries;
      if (GC_max_retries.24 == 0) goto <D.9060>; else goto <D.9061>;
      <D.9060>:
      GC_max_retries = 2;
      <D.9061>:
      GC_set_max_heap_size (max_heap_sz);
    }
    <D.9053>:
  }
  D.9062 = GC_expand_hp_inner (initial_heap_sz);
  if (D.9062 == 0) goto <D.9063>; else goto <D.9064>;
  <D.9063>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.9064>:
  D.9065 = GC_add_map_entry (0);
  if (D.9065 == 0) goto <D.9066>; else goto <D.9067>;
  <D.9066>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.9067>:
  GC_register_displacement_inner (0);
  GC_init_size_map ();
  D.9068 = getenv ("GC_ENABLE_INCREMENTAL");
  if (D.9068 != 0B) goto <D.9069>; else goto <D.9070>;
  <D.9069>:
  GC_setpagesize ();
  GC_dirty_init ();
  GC_incremental = 1;
  <D.9070>:
  GC_dump_regularly.25 = GC_dump_regularly;
  if (GC_dump_regularly.25 != 0) goto <D.9072>; else goto <D.9073>;
  <D.9072>:
  GC_dump ();
  <D.9073>:
  GC_dont_precollect.26 = GC_dont_precollect;
  if (GC_dont_precollect.26 == 0) goto <D.9074>; else goto <D.9077>;
  <D.9077>:
  GC_incremental.27 = GC_incremental;
  if (GC_incremental.27 != 0) goto <D.9074>; else goto <D.9075>;
  <D.9074>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.9075>:
  GC_is_initialized = 1;
}


maybe_install_looping_handler ()
{
  int installed_looping_handler.28;
  char * D.9083;

  installed_looping_handler.28 = installed_looping_handler;
  if (installed_looping_handler.28 == 0) goto <D.9081>; else goto <D.9082>;
  <D.9081>:
  D.9083 = getenv ("GC_LOOP_ON_ABORT");
  if (D.9083 != 0B) goto <D.9084>; else goto <D.9085>;
  <D.9084>:
  GC_set_and_save_fault_handler (looping_handler);
  installed_looping_handler = 1;
  <D.9085>:
  <D.9082>:
}


looping_handler (int sig)
{
  GC_err_printf ("Caught signal %d: looping in handler\n", sig, 0, 0, 0, 0, 0);
  <D.7848>:
  goto <D.7848>;
}


atoi (const char * __nptr)
{
  int D.9086;

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


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

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


GC_enable_incremental ()
{
  int GC_find_leak.29;
  int D.9093;
  int GC_incremental.30;
  int GC_is_initialized.31;
  int GC_dont_gc.32;
  long unsigned int D.9106;
  void out = <<< error >>>;

  GC_find_leak.29 = GC_find_leak;
  if (GC_find_leak.29 == 0) goto <D.9091>; else goto <D.9092>;
  <D.9091>:
  D.9093 = GC_test_and_set (&GC_allocate_lock);
  if (D.9093 != 0) goto <D.9094>; else goto <D.9095>;
  <D.9094>:
  GC_lock ();
  <D.9095>:
  GC_incremental.30 = GC_incremental;
  if (GC_incremental.30 != 0) goto out; else goto <D.9097>;
  <D.9097>:
  GC_setpagesize ();
  if (0 != 0) goto out; else goto <D.9098>;
  <D.9098>:
  maybe_install_looping_handler ();
  GC_dirty_init ();
  GC_is_initialized.31 = GC_is_initialized;
  if (GC_is_initialized.31 == 0) goto <D.9100>; else goto <D.9101>;
  <D.9100>:
  GC_init_inner ();
  <D.9101>:
  GC_incremental.30 = GC_incremental;
  if (GC_incremental.30 != 0) goto out; else goto <D.9102>;
  <D.9102>:
  GC_dont_gc.32 = GC_dont_gc;
  if (GC_dont_gc.32 != 0) goto <D.9104>; else goto <D.9105>;
  <D.9104>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.9105>:
  D.9106 = GC_arrays._words_allocd;
  if (D.9106 != 0) goto <D.9107>; else goto <D.9108>;
  <D.9107>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.9108>:
  GC_read_dirty ();
  GC_incremental = 1;
  out:
  GC_clear (&GC_allocate_lock);
  <D.9092>:
}


GC_write (int fd, const char * buf, size_t len)
{
  sizetype bytes_written.33;
  const void * D.9111;
  unsigned int bytes_written.34;
  unsigned int D.9113;
  int D.9116;
  register int bytes_written;
  register int result;

  bytes_written = 0;
  goto <D.8779>;
  <D.8778>:
  bytes_written.33 = (sizetype) bytes_written;
  D.9111 = buf + bytes_written.33;
  bytes_written.34 = (unsigned int) bytes_written;
  D.9113 = len - bytes_written.34;
  result = write (fd, D.9111, D.9113);
  if (result == -1) goto <D.9114>; else goto <D.9115>;
  <D.9114>:
  D.9116 = result;
  return D.9116;
  <D.9115>:
  bytes_written = bytes_written + result;
  <D.8779>:
  bytes_written.34 = (unsigned int) bytes_written;
  if (bytes_written.34 < len) goto <D.8778>; else goto <D.8780>;
  <D.8780>:
  D.9116 = bytes_written;
  return D.9116;
}


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.35;
  char D.9121;
  int GC_stdout.36;
  unsigned int D.9125;
  int D.9126;
  char buf[1025];

  try
    {
      GC_quiet.35 = GC_quiet;
      if (GC_quiet.35 != 0) goto <D.9119>; else goto <D.9120>;
      <D.9119>:
      return;
      <D.9120>:
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.9121 = buf[1024];
      if (D.9121 != 21) goto <D.9122>; else goto <D.9123>;
      <D.9122>:
      GC_abort ("GC_printf clobbered stack");
      <D.9123>:
      GC_stdout.36 = GC_stdout;
      D.9125 = strlen (&buf);
      D.9126 = GC_write (GC_stdout.36, &buf, D.9125);
      if (D.9126 < 0) goto <D.9127>; else goto <D.9128>;
      <D.9127>:
      GC_abort ("write to stdout failed");
      <D.9128>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.9132;
  unsigned int D.9133;

  D.9133 = __builtin_object_size (__s, 1);
  D.9132 = __builtin___sprintf_chk (__s, 1, D.9133, __fmt, __builtin_va_arg_pack ());
  return D.9132;
}


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.9135;
  int GC_stderr.37;
  unsigned int D.9139;
  int D.9140;
  char buf[1025];

  try
    {
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.9135 = buf[1024];
      if (D.9135 != 21) goto <D.9136>; else goto <D.9137>;
      <D.9136>:
      GC_abort ("GC_err_printf clobbered stack");
      <D.9137>:
      GC_stderr.37 = GC_stderr;
      D.9139 = strlen (&buf);
      D.9140 = GC_write (GC_stderr.37, &buf, D.9139);
      if (D.9140 < 0) goto <D.9141>; else goto <D.9142>;
      <D.9141>:
      GC_abort ("write to stderr failed");
      <D.9142>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


GC_err_puts (const char * s)
{
  int GC_stderr.38;
  unsigned int D.9144;
  int D.9145;

  GC_stderr.38 = GC_stderr;
  D.9144 = strlen (s);
  D.9145 = GC_write (GC_stderr.38, s, D.9144);
  if (D.9145 < 0) goto <D.9146>; else goto <D.9147>;
  <D.9146>:
  GC_abort ("write to stderr failed");
  <D.9147>:
}


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

  GC_stderr.39 = GC_stderr;
  D.9149 = GC_write (GC_stderr.39, buf, len);
  if (D.9149 < 0) goto <D.9150>; else goto <D.9151>;
  <D.9150>:
  GC_abort ("write to stderr failed");
  <D.9151>:
}


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

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


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

  D.9153 = GC_test_and_set (&GC_allocate_lock);
  if (D.9153 != 0) goto <D.9154>; else goto <D.9155>;
  <D.9154>:
  GC_lock ();
  <D.9155>:
  result = GC_current_warn_proc;
  GC_current_warn_proc = p;
  GC_clear (&GC_allocate_lock);
  D.9156 = result;
  return D.9156;
}


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

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


GC_abort (const char * msg)
{
  long int msg.41;
  char * D.9161;

  msg.41 = (long int) msg;
  GC_err_printf ("%s\n", msg.41, 0, 0, 0, 0, 0);
  D.9161 = getenv ("GC_LOOP_ON_ABORT");
  if (D.9161 != 0B) goto <D.9162>; else goto <D.9163>;
  <D.9162>:
  <D.8824>:
  goto <D.8824>;
  <D.9163>:
  abort ();
}


GC_enable ()
{
  int D.9164;
  int GC_dont_gc.42;
  int GC_dont_gc.43;

  D.9164 = GC_test_and_set (&GC_allocate_lock);
  if (D.9164 != 0) goto <D.9165>; else goto <D.9166>;
  <D.9165>:
  GC_lock ();
  <D.9166>:
  GC_dont_gc.42 = GC_dont_gc;
  GC_dont_gc.43 = GC_dont_gc.42 + -1;
  GC_dont_gc = GC_dont_gc.43;
  GC_clear (&GC_allocate_lock);
}


GC_disable ()
{
  int D.9169;
  int GC_dont_gc.44;
  int GC_dont_gc.45;

  D.9169 = GC_test_and_set (&GC_allocate_lock);
  if (D.9169 != 0) goto <D.9170>; else goto <D.9171>;
  <D.9170>:
  GC_lock ();
  <D.9171>:
  GC_dont_gc.44 = GC_dont_gc;
  GC_dont_gc.45 = GC_dont_gc.44 + 1;
  GC_dont_gc = GC_dont_gc.45;
  GC_clear (&GC_allocate_lock);
}


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

  result = GC_generic_malloc_inner (2052, 0);
  if (result == 0B) goto <D.9174>; else goto <D.9175>;
  <D.9174>:
  GC_abort ("Failed to allocate freelist for new kind");
  <D.9175>:
  memset (result, 0, 2052);
  D.9176 = result;
  return D.9176;
}


GC_new_free_list ()
{
  int D.9178;
  void * * D.9181;
  void * result;

  D.9178 = GC_test_and_set (&GC_allocate_lock);
  if (D.9178 != 0) goto <D.9179>; else goto <D.9180>;
  <D.9179>:
  GC_lock ();
  <D.9180>:
  result = GC_new_free_list_inner ();
  GC_clear (&GC_allocate_lock);
  D.9181 = result;
  return D.9181;
}


GC_new_kind_inner (void * * fl, GC_word descr, int adjust, int clear)
{
  int GC_n_kinds.46;
  int GC_n_kinds.47;
  int GC_n_kinds.48;
  int D.9188;
  int result;

  GC_n_kinds.46 = GC_n_kinds;
  GC_n_kinds.47 = GC_n_kinds.46;
  GC_n_kinds.48 = GC_n_kinds.47 + 1;
  GC_n_kinds = GC_n_kinds.48;
  result = GC_n_kinds.47;
  GC_n_kinds.46 = GC_n_kinds;
  if (GC_n_kinds.46 > 16) goto <D.9186>; else goto <D.9187>;
  <D.9186>:
  GC_abort ("Too many kinds");
  <D.9187>:
  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.9188 = result;
  return D.9188;
}


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

  D.9190 = GC_test_and_set (&GC_allocate_lock);
  if (D.9190 != 0) goto <D.9191>; else goto <D.9192>;
  <D.9191>:
  GC_lock ();
  <D.9192>:
  result = GC_new_kind_inner (fl, descr, adjust, clear);
  GC_clear (&GC_allocate_lock);
  D.9193 = result;
  return D.9193;
}


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.49;
  long unsigned int GC_n_mark_procs.50;
  long unsigned int GC_n_mark_procs.51;
  int D.9200;
  int result;

  GC_n_mark_procs.49 = GC_n_mark_procs;
  GC_n_mark_procs.50 = GC_n_mark_procs.49;
  GC_n_mark_procs.51 = GC_n_mark_procs.50 + 1;
  GC_n_mark_procs = GC_n_mark_procs.51;
  result = (int) GC_n_mark_procs.50;
  GC_n_mark_procs.49 = GC_n_mark_procs;
  if (GC_n_mark_procs.49 > 64) goto <D.9198>; else goto <D.9199>;
  <D.9198>:
  GC_abort ("Too many mark procedures");
  <D.9199>:
  GC_arrays._mark_procs[result] = proc;
  D.9200 = result;
  return D.9200;
}


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.9202;
  int D.9205;
  int result;

  D.9202 = GC_test_and_set (&GC_allocate_lock);
  if (D.9202 != 0) goto <D.9203>; else goto <D.9204>;
  <D.9203>:
  GC_lock ();
  <D.9204>:
  result = GC_new_proc_inner (proc);
  GC_clear (&GC_allocate_lock);
  D.9205 = result;
  return D.9205;
}


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