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

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


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

  D.7196 = arg2;
  return D.7196;
}


GC_init_size_map ()
{
  int GC_all_interior_pointers.0;
  unsigned int GC_all_interior_pointers.1;
  unsigned int D.7200;
  unsigned int D.7201;
  unsigned int D.7202;
  unsigned int D.7203;
  unsigned int D.7204;
  unsigned int D.7205;
  unsigned int D.7206;
  register unsigned int i;

  i = 0;
  goto <D.6089>;
  <D.6088>:
  GC_arrays._size_map[i] = 2;
  i = i + 1;
  <D.6089>:
  if (i <= 7) goto <D.6088>; else goto <D.6090>;
  <D.6090>:
  GC_arrays._size_map[8] = 2;
  i = 9;
  goto <D.6092>;
  <D.6091>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.7200 = GC_all_interior_pointers.1 + i;
  D.7201 = D.7200 + 7;
  D.7202 = D.7201 >> 3;
  GC_arrays._size_map[i] = D.7202;
  i = i + 1;
  <D.6092>:
  if (i <= 64) goto <D.6091>; else goto <D.6093>;
  <D.6093>:
  i = 65;
  goto <D.6095>;
  <D.6094>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.7200 = GC_all_interior_pointers.1 + i;
  D.7201 = D.7200 + 7;
  D.7202 = D.7201 >> 3;
  D.7203 = D.7202 + 1;
  D.7204 = D.7203 & 4294967294;
  GC_arrays._size_map[i] = D.7204;
  i = i + 1;
  <D.6095>:
  if (i <= 128) goto <D.6094>; else goto <D.6096>;
  <D.6096>:
  i = 129;
  goto <D.6098>;
  <D.6097>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.7200 = GC_all_interior_pointers.1 + i;
  D.7201 = D.7200 + 7;
  D.7202 = D.7201 >> 3;
  D.7205 = D.7202 + 3;
  D.7206 = D.7205 & 4294967292;
  GC_arrays._size_map[i] = D.7206;
  i = i + 1;
  <D.6098>:
  if (i <= 256) goto <D.6097>; else goto <D.6099>;
  <D.6099>:
}


GC_extend_size_map (word i)
{
  int GC_all_interior_pointers.2;
  int D.7208;
  long unsigned int D.7209;
  long unsigned int D.7210;
  long unsigned int D.7211;
  long unsigned int D.7212;
  unsigned int D.7213;
  unsigned int D.7216;
  long unsigned int D.7218;
  long unsigned int D.7219;
  long unsigned int D.7226;
  unsigned int D.7227;
  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.7208 = GC_all_interior_pointers.2 + 7;
  D.7209 = (long unsigned int) D.7208;
  D.7210 = D.7209 + i;
  orig_word_sz = D.7210 >> 3;
  word_sz = orig_word_sz;
  byte_sz = word_sz << 3;
  D.7211 = byte_sz >> 3;
  smaller_than_i = byte_sz - D.7211;
  D.7212 = byte_sz >> 2;
  much_smaller_than_i = byte_sz - D.7212;
  D.7213 = GC_arrays._size_map[smaller_than_i];
  if (D.7213 == 0) goto <D.7214>; else goto <D.7215>;
  <D.7214>:
  low_limit = much_smaller_than_i;
  goto <D.6111>;
  <D.6110>:
  low_limit = low_limit + 1;
  <D.6111>:
  D.7216 = GC_arrays._size_map[low_limit];
  if (D.7216 != 0) goto <D.6110>; else goto <D.6112>;
  <D.6112>:
  goto <D.7217>;
  <D.7215>:
  low_limit = smaller_than_i + 1;
  goto <D.6114>;
  <D.6113>:
  low_limit = low_limit + 1;
  <D.6114>:
  D.7216 = GC_arrays._size_map[low_limit];
  if (D.7216 != 0) goto <D.6113>; else goto <D.6115>;
  <D.6115>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  D.7208 = GC_all_interior_pointers.2 + 7;
  D.7209 = (long unsigned int) D.7208;
  D.7218 = D.7209 + low_limit;
  word_sz = D.7218 >> 3;
  D.7219 = word_sz >> 3;
  word_sz = D.7219 + word_sz;
  if (word_sz < orig_word_sz) goto <D.7220>; else goto <D.7221>;
  <D.7220>:
  word_sz = orig_word_sz;
  <D.7221>:
  <D.7217>:
  if (word_sz > 256) goto <D.7222>; else goto <D.7223>;
  <D.7222>:
  word_sz = 256;
  <D.7223>:
  {
    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.7224>; else goto <D.7225>;
  <D.7224>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  D.7226 = (long unsigned int) GC_all_interior_pointers.2;
  byte_sz = byte_sz - D.7226;
  <D.7225>:
  j = low_limit;
  goto <D.6118>;
  <D.6117>:
  D.7227 = (unsigned int) word_sz;
  GC_arrays._size_map[j] = D.7227;
  j = j + 1;
  <D.6118>:
  if (j <= byte_sz) goto <D.6117>; else goto <D.6119>;
  <D.6119>:
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.7236;
  int D.7241;
  void * D.7243;
  long unsigned int D.7244;

  D.7236 = __builtin_constant_p (__len);
  if (D.7236 != 0) goto <D.7237>; else goto <D.7238>;
  <D.7237>:
  if (__len == 0) goto <D.7239>; else goto <D.7240>;
  <D.7239>:
  D.7241 = __builtin_constant_p (__ch);
  if (D.7241 == 0) goto <D.7234>; else goto <D.7242>;
  <D.7242>:
  if (__ch != 0) goto <D.7234>; else goto <D.7235>;
  <D.7234>:
  __warn_memset_zero_len ();
  D.7243 = __dest;
  return D.7243;
  <D.7235>:
  <D.7240>:
  <D.7238>:
  D.7244 = __builtin_object_size (__dest, 0);
  D.7243 = __builtin___memset_chk (__dest, __ch, __len, D.7244);
  return D.7243;
}


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

  try
    {
      D.7246 = GC_approx_sp ();
      sp = (word) D.7246;
      random_no.4 = random_no;
      random_no.5 = random_no.4 + 1;
      random_no = random_no.5;
      random_no.4 = random_no;
      D.7249 = random_no.4 % 13;
      if (D.7249 == 0) goto <D.7250>; else goto <D.7251>;
      <D.7250>:
      limit = sp;
      limit = limit + 18446744073709535232;
      limit = limit & 18446744073709551600;
      D.7252 = GC_clear_stack_inner (arg, limit);
      return D.7252;
      <D.7251>:
      memset (&dummy, 0, 2048);
      D.7252 = arg;
      return D.7252;
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


GC_base (void * p)
{
  int GC_is_initialized.6;
  void * D.7258;
  long unsigned int D.7259;
  long unsigned int D.7260;
  long unsigned int D.7261;
  struct bottom_index * D.7263;
  long unsigned int D.7264;
  long unsigned int D.7265;
  long unsigned int candidate_hdr.7;
  long unsigned int D.7269;
  sizetype D.7270;
  map_entry_type * D.7271;
  map_entry_type * GC_invalid_map.8;
  int D.7275;
  long unsigned int D.7276;
  sizetype D.7277;
  map_entry_type * D.7278;
  unsigned char D.7279;
  int D.7282;
  long int D.7283;
  long int D.7284;
  long unsigned int D.7285;
  long int D.7286;
  long unsigned int D.7287;
  struct hblk * D.7288;
  long unsigned int D.7289;
  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.7256>; else goto <D.7257>;
  <D.7256>:
  D.7258 = 0B;
  return D.7258;
  <D.7257>:
  D.7259 = r & 18446744073709547520;
  h = (struct hblk *) D.7259;
  {
    register word hi;
    register struct bottom_index * _bi;

    hi = r >> 22;
    D.7260 = hi & 2047;
    _bi = GC_arrays._top_index[D.7260];
    goto <D.6147>;
    <D.6146>:
    _bi = _bi->hash_link;
    <D.6147>:
    D.7261 = _bi->key;
    if (D.7261 != hi) goto <D.7262>; else goto <D.6148>;
    <D.7262>:
    D.7263 = GC_arrays._all_nils;
    if (D.7263 != _bi) goto <D.6146>; else goto <D.6148>;
    <D.6148>:
    bi = _bi;
  }
  D.7264 = r >> 12;
  D.7265 = D.7264 & 1023;
  candidate_hdr = bi->index[D.7265];
  if (candidate_hdr == 0B) goto <D.7266>; else goto <D.7267>;
  <D.7266>:
  D.7258 = 0B;
  return D.7258;
  <D.7267>:
  goto <D.6150>;
  <D.6149>:
  candidate_hdr.7 = (long unsigned int) candidate_hdr;
  D.7269 = candidate_hdr.7 * 4096;
  D.7270 = -D.7269;
  h = h + D.7270;
  r = (word) h;
  candidate_hdr = GC_find_header (h);
  <D.6150>:
  candidate_hdr.7 = (long unsigned int) candidate_hdr;
  if (candidate_hdr.7 <= 4095) goto <D.6149>; else goto <D.6151>;
  <D.6151>:
  D.7271 = candidate_hdr->hb_map;
  GC_invalid_map.8 = GC_invalid_map;
  if (D.7271 == GC_invalid_map.8) goto <D.7273>; else goto <D.7274>;
  <D.7273>:
  D.7258 = 0B;
  return D.7258;
  <D.7274>:
  r = r & 18446744073709551608;
  {
    register int offset;
    register signed_word sz;
    register signed_word map_entry;

    D.7275 = (int) r;
    offset = D.7275 & 4095;
    D.7276 = candidate_hdr->hb_sz;
    sz = (signed_word) D.7276;
    D.7271 = candidate_hdr->hb_map;
    D.7277 = (sizetype) offset;
    D.7278 = D.7271 + D.7277;
    D.7279 = *D.7278;
    map_entry = (signed_word) D.7279;
    if (map_entry > 253) goto <D.7280>; else goto <D.7281>;
    <D.7280>:
    D.7282 = offset >> 3;
    D.7283 = (long int) D.7282;
    map_entry = D.7283 % sz;
    <D.7281>:
    D.7284 = map_entry << 3;
    D.7285 = (long unsigned int) D.7284;
    r = r - D.7285;
    D.7286 = sz << 3;
    D.7287 = (long unsigned int) D.7286;
    limit = D.7287 + r;
    D.7288 = h + 4096;
    D.7289 = (long unsigned int) D.7288;
    if (D.7289 < limit) goto <D.7290>; else goto <D.7291>;
    <D.7290>:
    sz.9 = (long unsigned int) sz;
    if (sz.9 <= 512) goto <D.7293>; else goto <D.7294>;
    <D.7293>:
    D.7258 = 0B;
    return D.7258;
    <D.7294>:
    <D.7291>:
    p.10 = (long unsigned int) p;
    if (p.10 >= limit) goto <D.7296>; else goto <D.7297>;
    <D.7296>:
    D.7258 = 0B;
    return D.7258;
    <D.7297>:
  }
  D.7258 = (void *) r;
  return D.7258;
}


GC_size (void * p)
{
  long unsigned int D.7299;
  long unsigned int D.7300;
  size_t D.7301;
  register int sz;
  register struct hdr * hhdr;

  hhdr = GC_find_header (p);
  D.7299 = hhdr->hb_sz;
  D.7300 = D.7299 << 3;
  sz = (int) D.7300;
  D.7301 = (size_t) sz;
  return D.7301;
}


GC_get_heap_size ()
{
  size_t D.7303;

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


GC_get_free_bytes ()
{
  size_t D.7305;

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


GC_get_bytes_since_gc ()
{
  size_t D.7307;
  long unsigned int D.7308;

  D.7308 = GC_arrays._words_allocd;
  D.7307 = D.7308 << 3;
  return D.7307;
}


GC_get_total_bytes ()
{
  size_t D.7310;
  long unsigned int D.7311;
  long unsigned int D.7312;
  long unsigned int D.7313;

  D.7311 = GC_arrays._words_allocd;
  D.7312 = GC_arrays._words_allocd_before_gc;
  D.7313 = D.7311 + D.7312;
  D.7310 = D.7313 << 3;
  return D.7310;
}


GC_get_suspend_signal ()
{
  int D.7315;

  D.7315 = 30;
  return D.7315;
}


GC_init ()
{
  int D.7317;

  D.7317 = GC_test_and_set (&GC_allocate_lock);
  if (D.7317 != 0) goto <D.7318>; else goto <D.7319>;
  <D.7318>:
  GC_lock ();
  <D.7319>:
  GC_init_inner ();
  GC_clear (&GC_allocate_lock);
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.7320;
  int oldval;
  int temp;

  temp = 1;
  __asm__ __volatile__("1:	lwarx %0,0,%1
	cmpwi %0, 0
	bne 2f
	stwcx. %2,0,%1
	bne- 1b
	sync
2:	
" : "=&r" oldval : "r" addr, "r" temp : "memory", "cr0");
  D.7320 = oldval;
  return D.7320;
}


GC_clear (volatile unsigned int * addr)
{
  __asm__ __volatile__("lwsync" :  :  : "memory");
  *addr = 0;
}


GC_exit_check ()
{
  GC_gcollect ();
}


GC_init_inner ()
{
  int GC_is_initialized.11;
  char * D.7325;
  char * D.7328;
  char * D.7331;
  char * D.7334;
  char * D.7337;
  char * D.7340;
  char * D.7343;
  void (*<T916>) (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.7366;
  int D.7371;
  long unsigned int sz_str.17;
  long int D.7377;
  long unsigned int D.7378;
  long unsigned int sz_str.18;
  long unsigned int GC_max_retries.19;
  int D.7385;
  int D.7388;
  char * D.7391;
  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.7323>; else goto <D.7324>;
  <D.7323>:
  return;
  <D.7324>:
  D.7325 = getenv ("GC_PRINT_STATS");
  if (D.7325 != 0B) goto <D.7326>; else goto <D.7327>;
  <D.7326>:
  GC_print_stats = 1;
  <D.7327>:
  D.7328 = getenv ("GC_DUMP_REGULARLY");
  if (D.7328 != 0B) goto <D.7329>; else goto <D.7330>;
  <D.7329>:
  GC_dump_regularly = 1;
  <D.7330>:
  D.7331 = getenv ("GC_FIND_LEAK");
  if (D.7331 != 0B) goto <D.7332>; else goto <D.7333>;
  <D.7332>:
  GC_find_leak = 1;
  atexit (GC_exit_check);
  <D.7333>:
  D.7334 = getenv ("GC_ALL_INTERIOR_POINTERS");
  if (D.7334 != 0B) goto <D.7335>; else goto <D.7336>;
  <D.7335>:
  GC_all_interior_pointers = 1;
  <D.7336>:
  D.7337 = getenv ("GC_DONT_GC");
  if (D.7337 != 0B) goto <D.7338>; else goto <D.7339>;
  <D.7338>:
  GC_dont_gc = 1;
  <D.7339>:
  D.7340 = getenv ("GC_PRINT_BACK_HEIGHT");
  if (D.7340 != 0B) goto <D.7341>; else goto <D.7342>;
  <D.7341>:
  GC_print_back_height = 1;
  <D.7342>:
  D.7343 = getenv ("GC_NO_BLACKLIST_WARNING");
  if (D.7343 != 0B) goto <D.7344>; else goto <D.7345>;
  <D.7344>:
  GC_large_alloc_warn_interval = 9223372036854775807;
  <D.7345>:
  {
    char * time_limit_string;

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

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

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

      interval = atol (interval_string);
      if (interval <= 0) goto <D.7355>; else goto <D.7356>;
      <D.7355>:
      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.7357>;
      <D.7356>:
      GC_large_alloc_warn_interval = interval;
      <D.7357>:
    }
    <D.7354>:
  }
  maybe_install_looping_handler ();
  GC_all_interior_pointers.14 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.14 != 0) goto <D.7359>; else goto <D.7360>;
  <D.7359>:
  GC_obj_kinds[1].ok_descriptor = 18446744073709551608;
  <D.7360>:
  GC_setpagesize ();
  GC_exclude_static_roots (&GC_arrays, &MEM[(void *)&GC_arrays + 83176B]);
  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.7362>; else goto <D.7363>;
  <D.7362>:
  GC_stackbottom.16 = GC_get_stack_base ();
  GC_stackbottom = GC_stackbottom.16;
  goto <D.7365>;
  <D.7363>:
  <D.7365>:
  D.7366 = GC_register_main_static_data ();
  if (D.7366 != 0) goto <D.7367>; else goto <D.7368>;
  <D.7367>:
  GC_register_data_segments ();
  <D.7368>:
  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.7369>; else goto <D.7370>;
    <D.7369>:
    D.7371 = atoi (sz_str);
    initial_heap_sz = (word) D.7371;
    if (initial_heap_sz <= 65536) goto <D.7372>; else goto <D.7373>;
    <D.7372>:
    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.7373>:
    initial_heap_sz = initial_heap_sz >> 12;
    <D.7370>:
  }
  {
    char * sz_str;

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

      D.7377 = atol (sz_str);
      max_heap_sz = (word) D.7377;
      D.7378 = initial_heap_sz * 4096;
      if (D.7378 > max_heap_sz) goto <D.7379>; else goto <D.7380>;
      <D.7379>:
      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.7380>:
      GC_max_retries.19 = GC_max_retries;
      if (GC_max_retries.19 == 0) goto <D.7383>; else goto <D.7384>;
      <D.7383>:
      GC_max_retries = 2;
      <D.7384>:
      GC_set_max_heap_size (max_heap_sz);
    }
    <D.7376>:
  }
  D.7385 = GC_expand_hp_inner (initial_heap_sz);
  if (D.7385 == 0) goto <D.7386>; else goto <D.7387>;
  <D.7386>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.7387>:
  D.7388 = GC_add_map_entry (0);
  if (D.7388 == 0) goto <D.7389>; else goto <D.7390>;
  <D.7389>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.7390>:
  GC_register_displacement_inner (0);
  GC_init_size_map ();
  D.7391 = getenv ("GC_ENABLE_INCREMENTAL");
  if (D.7391 != 0B) goto <D.7392>; else goto <D.7393>;
  <D.7392>:
  GC_setpagesize ();
  GC_dirty_init ();
  GC_incremental = 1;
  <D.7393>:
  GC_dump_regularly.20 = GC_dump_regularly;
  if (GC_dump_regularly.20 != 0) goto <D.7395>; else goto <D.7396>;
  <D.7395>:
  GC_dump ();
  <D.7396>:
  GC_dont_precollect.21 = GC_dont_precollect;
  if (GC_dont_precollect.21 == 0) goto <D.7397>; else goto <D.7400>;
  <D.7400>:
  GC_incremental.22 = GC_incremental;
  if (GC_incremental.22 != 0) goto <D.7397>; else goto <D.7398>;
  <D.7397>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.7398>:
  GC_is_initialized = 1;
}


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

  installed_looping_handler.23 = installed_looping_handler;
  if (installed_looping_handler.23 == 0) goto <D.7404>; else goto <D.7405>;
  <D.7404>:
  D.7406 = getenv ("GC_LOOP_ON_ABORT");
  if (D.7406 != 0B) goto <D.7407>; else goto <D.7408>;
  <D.7407>:
  GC_set_and_save_fault_handler (looping_handler);
  installed_looping_handler = 1;
  <D.7408>:
  <D.7405>:
}


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

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


atoi (const char * __nptr)
{
  int D.7410;
  long int D.7411;

  D.7411 = strtol (__nptr, 0B, 10);
  D.7410 = (int) D.7411;
  return D.7410;
}


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

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


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

  GC_find_leak.24 = GC_find_leak;
  if (GC_find_leak.24 == 0) goto <D.7416>; else goto <D.7417>;
  <D.7416>:
  D.7418 = GC_test_and_set (&GC_allocate_lock);
  if (D.7418 != 0) goto <D.7419>; else goto <D.7420>;
  <D.7419>:
  GC_lock ();
  <D.7420>:
  GC_incremental.25 = GC_incremental;
  if (GC_incremental.25 != 0) goto out; else goto <D.7422>;
  <D.7422>:
  GC_setpagesize ();
  if (0 != 0) goto out; else goto <D.7423>;
  <D.7423>:
  maybe_install_looping_handler ();
  GC_dirty_init ();
  GC_is_initialized.26 = GC_is_initialized;
  if (GC_is_initialized.26 == 0) goto <D.7425>; else goto <D.7426>;
  <D.7425>:
  GC_init_inner ();
  <D.7426>:
  GC_incremental.25 = GC_incremental;
  if (GC_incremental.25 != 0) goto out; else goto <D.7427>;
  <D.7427>:
  GC_dont_gc.27 = GC_dont_gc;
  if (GC_dont_gc.27 != 0) goto <D.7429>; else goto <D.7430>;
  <D.7429>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.7430>:
  D.7431 = GC_arrays._words_allocd;
  if (D.7431 != 0) goto <D.7432>; else goto <D.7433>;
  <D.7432>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.7433>:
  GC_read_dirty ();
  GC_incremental = 1;
  out:
  GC_clear (&GC_allocate_lock);
  <D.7417>:
}


GC_write (int fd, const char * buf, size_t len)
{
  sizetype D.7435;
  const void * D.7436;
  long unsigned int D.7437;
  long unsigned int D.7438;
  long int D.7439;
  int D.7442;
  register int bytes_written;
  register int result;

  bytes_written = 0;
  goto <D.7113>;
  <D.7112>:
  D.7435 = (sizetype) bytes_written;
  D.7436 = buf + D.7435;
  D.7437 = (long unsigned int) bytes_written;
  D.7438 = len - D.7437;
  D.7439 = write (fd, D.7436, D.7438);
  result = (int) D.7439;
  if (result == -1) goto <D.7440>; else goto <D.7441>;
  <D.7440>:
  D.7442 = result;
  return D.7442;
  <D.7441>:
  bytes_written = bytes_written + result;
  <D.7113>:
  D.7437 = (long unsigned int) bytes_written;
  if (D.7437 < len) goto <D.7112>; else goto <D.7114>;
  <D.7114>:
  D.7442 = bytes_written;
  return D.7442;
}


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.7447;
  int GC_stdout.29;
  long unsigned int D.7451;
  int D.7452;
  char buf[1025];

  try
    {
      GC_quiet.28 = GC_quiet;
      if (GC_quiet.28 != 0) goto <D.7445>; else goto <D.7446>;
      <D.7445>:
      return;
      <D.7446>:
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.7447 = buf[1024];
      if (D.7447 != 21) goto <D.7448>; else goto <D.7449>;
      <D.7448>:
      GC_abort ("GC_printf clobbered stack");
      <D.7449>:
      GC_stdout.29 = GC_stdout;
      D.7451 = strlen (&buf);
      D.7452 = GC_write (GC_stdout.29, &buf, D.7451);
      if (D.7452 < 0) goto <D.7453>; else goto <D.7454>;
      <D.7453>:
      GC_abort ("write to stdout failed");
      <D.7454>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

  D.7459 = __builtin_object_size (__s, 1);
  D.7458 = __builtin___sprintf_chk (__s, 1, D.7459, __fmt, __builtin_va_arg_pack ());
  return D.7458;
}


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.7461;
  int GC_stderr.30;
  long unsigned int D.7465;
  int D.7466;
  char buf[1025];

  try
    {
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.7461 = buf[1024];
      if (D.7461 != 21) goto <D.7462>; else goto <D.7463>;
      <D.7462>:
      GC_abort ("GC_err_printf clobbered stack");
      <D.7463>:
      GC_stderr.30 = GC_stderr;
      D.7465 = strlen (&buf);
      D.7466 = GC_write (GC_stderr.30, &buf, D.7465);
      if (D.7466 < 0) goto <D.7467>; else goto <D.7468>;
      <D.7467>:
      GC_abort ("write to stderr failed");
      <D.7468>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

  GC_stderr.31 = GC_stderr;
  D.7470 = strlen (s);
  D.7471 = GC_write (GC_stderr.31, s, D.7470);
  if (D.7471 < 0) goto <D.7472>; else goto <D.7473>;
  <D.7472>:
  GC_abort ("write to stderr failed");
  <D.7473>:
}


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

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


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.7479;
  void (*GC_warn_proc) (char *, GC_word) D.7482;
  void (*GC_warn_proc) (char *, GC_word) result;

  D.7479 = GC_test_and_set (&GC_allocate_lock);
  if (D.7479 != 0) goto <D.7480>; else goto <D.7481>;
  <D.7480>:
  GC_lock ();
  <D.7481>:
  result = GC_current_warn_proc;
  GC_current_warn_proc = p;
  GC_clear (&GC_allocate_lock);
  D.7482 = result;
  return D.7482;
}


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

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


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

  msg.34 = (long int) msg;
  GC_err_printf ("%s\n", msg.34, 0, 0, 0, 0, 0);
  D.7487 = getenv ("GC_LOOP_ON_ABORT");
  if (D.7487 != 0B) goto <D.7488>; else goto <D.7489>;
  <D.7488>:
  <D.7158>:
  goto <D.7158>;
  <D.7489>:
  abort ();
}


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

  D.7490 = GC_test_and_set (&GC_allocate_lock);
  if (D.7490 != 0) goto <D.7491>; else goto <D.7492>;
  <D.7491>:
  GC_lock ();
  <D.7492>:
  GC_dont_gc.35 = GC_dont_gc;
  GC_dont_gc.36 = GC_dont_gc.35 + -1;
  GC_dont_gc = GC_dont_gc.36;
  GC_clear (&GC_allocate_lock);
}


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

  D.7495 = GC_test_and_set (&GC_allocate_lock);
  if (D.7495 != 0) goto <D.7496>; else goto <D.7497>;
  <D.7496>:
  GC_lock ();
  <D.7497>:
  GC_dont_gc.37 = GC_dont_gc;
  GC_dont_gc.38 = GC_dont_gc.37 + 1;
  GC_dont_gc = GC_dont_gc.38;
  GC_clear (&GC_allocate_lock);
}


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

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


GC_new_free_list ()
{
  int D.7504;
  void * * D.7507;
  void * result;

  D.7504 = GC_test_and_set (&GC_allocate_lock);
  if (D.7504 != 0) goto <D.7505>; else goto <D.7506>;
  <D.7505>:
  GC_lock ();
  <D.7506>:
  result = GC_new_free_list_inner ();
  GC_clear (&GC_allocate_lock);
  D.7507 = result;
  return D.7507;
}


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.7514;
  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.7512>; else goto <D.7513>;
  <D.7512>:
  GC_abort ("Too many kinds");
  <D.7513>:
  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.7514 = result;
  return D.7514;
}


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

  D.7516 = GC_test_and_set (&GC_allocate_lock);
  if (D.7516 != 0) goto <D.7517>; else goto <D.7518>;
  <D.7517>:
  GC_lock ();
  <D.7518>:
  result = GC_new_kind_inner (fl, descr, adjust, clear);
  GC_clear (&GC_allocate_lock);
  D.7519 = result;
  return D.7519;
}


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.7526;
  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.7524>; else goto <D.7525>;
  <D.7524>:
  GC_abort ("Too many mark procedures");
  <D.7525>:
  GC_arrays._mark_procs[result] = proc;
  D.7526 = result;
  return D.7526;
}


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.7528;
  int D.7531;
  int result;

  D.7528 = GC_test_and_set (&GC_allocate_lock);
  if (D.7528 != 0) goto <D.7529>; else goto <D.7530>;
  <D.7529>:
  GC_lock ();
  <D.7530>:
  result = GC_new_proc_inner (proc);
  GC_clear (&GC_allocate_lock);
  D.7531 = result;
  return D.7531;
}


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