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

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


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

  D.6282 = arg2;
  return D.6282;
}


GC_init_size_map ()
{
  int GC_all_interior_pointers.0;
  unsigned int GC_all_interior_pointers.1;
  unsigned int D.6286;
  unsigned int D.6287;
  unsigned int D.6288;
  unsigned int D.6289;
  unsigned int D.6290;
  unsigned int D.6291;
  unsigned int D.6292;
  unsigned int D.6293;
  unsigned int D.6294;
  unsigned int D.6295;
  register unsigned int i;

  i = 0;
  goto <D.5182>;
  <D.5181>:
  GC_arrays._size_map[i] = 2;
  i = i + 1;
  <D.5182>:
  if (i <= 3) goto <D.5181>; else goto <D.5183>;
  <D.5183>:
  GC_arrays._size_map[4] = 2;
  i = 5;
  goto <D.5185>;
  <D.5184>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.6286 = i + GC_all_interior_pointers.1;
  D.6287 = D.6286 + 7;
  D.6288 = D.6287 >> 2;
  D.6289 = D.6288 & 4294967294;
  GC_arrays._size_map[i] = D.6289;
  i = i + 1;
  <D.5185>:
  if (i <= 32) goto <D.5184>; else goto <D.5186>;
  <D.5186>:
  i = 33;
  goto <D.5188>;
  <D.5187>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.6286 = GC_all_interior_pointers.1 + i;
  D.6290 = D.6286 + 3;
  D.6291 = D.6290 >> 2;
  D.6292 = D.6291 + 1;
  D.6293 = D.6292 & 4294967294;
  GC_arrays._size_map[i] = D.6293;
  i = i + 1;
  <D.5188>:
  if (i <= 64) goto <D.5187>; else goto <D.5189>;
  <D.5189>:
  i = 65;
  goto <D.5191>;
  <D.5190>:
  GC_all_interior_pointers.0 = GC_all_interior_pointers;
  GC_all_interior_pointers.1 = (unsigned int) GC_all_interior_pointers.0;
  D.6286 = GC_all_interior_pointers.1 + i;
  D.6290 = D.6286 + 3;
  D.6291 = D.6290 >> 2;
  D.6294 = D.6291 + 3;
  D.6295 = D.6294 & 4294967292;
  GC_arrays._size_map[i] = D.6295;
  i = i + 1;
  <D.5191>:
  if (i <= 128) goto <D.5190>; else goto <D.5192>;
  <D.5192>:
}


GC_extend_size_map (word i)
{
  int GC_all_interior_pointers.2;
  long unsigned int GC_all_interior_pointers.3;
  long unsigned int D.6298;
  long unsigned int D.6299;
  long unsigned int D.6300;
  long unsigned int D.6301;
  unsigned int D.6302;
  unsigned int D.6305;
  long unsigned int D.6307;
  long unsigned int D.6308;
  long unsigned int D.6309;
  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.6298 = GC_all_interior_pointers.3 + i;
  D.6299 = D.6298 + 3;
  orig_word_sz = D.6299 >> 2;
  word_sz = orig_word_sz;
  byte_sz = word_sz << 2;
  D.6300 = byte_sz >> 3;
  smaller_than_i = byte_sz - D.6300;
  D.6301 = byte_sz >> 2;
  much_smaller_than_i = byte_sz - D.6301;
  D.6302 = GC_arrays._size_map[smaller_than_i];
  if (D.6302 == 0) goto <D.6303>; else goto <D.6304>;
  <D.6303>:
  low_limit = much_smaller_than_i;
  goto <D.5204>;
  <D.5203>:
  low_limit = low_limit + 1;
  <D.5204>:
  D.6305 = GC_arrays._size_map[low_limit];
  if (D.6305 != 0) goto <D.5203>; else goto <D.5205>;
  <D.5205>:
  goto <D.6306>;
  <D.6304>:
  low_limit = smaller_than_i + 1;
  goto <D.5207>;
  <D.5206>:
  low_limit = low_limit + 1;
  <D.5207>:
  D.6305 = GC_arrays._size_map[low_limit];
  if (D.6305 != 0) goto <D.5206>; else goto <D.5208>;
  <D.5208>:
  GC_all_interior_pointers.2 = GC_all_interior_pointers;
  GC_all_interior_pointers.3 = (long unsigned int) GC_all_interior_pointers.2;
  D.6307 = GC_all_interior_pointers.3 + low_limit;
  D.6308 = D.6307 + 3;
  word_sz = D.6308 >> 2;
  D.6309 = word_sz >> 3;
  word_sz = D.6309 + word_sz;
  if (word_sz < orig_word_sz) goto <D.6310>; else goto <D.6311>;
  <D.6310>:
  word_sz = orig_word_sz;
  <D.6311>:
  <D.6306>:
  word_sz = word_sz + 1;
  word_sz = word_sz & 4294967294;
  if (word_sz > 512) goto <D.6312>; else goto <D.6313>;
  <D.6312>:
  word_sz = 512;
  <D.6313>:
  {
    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.6314>; else goto <D.6315>;
  <D.6314>:
  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.6315>:
  j = low_limit;
  goto <D.5211>;
  <D.5210>:
  GC_arrays._size_map[j] = word_sz;
  j = j + 1;
  <D.5211>:
  if (j <= byte_sz) goto <D.5210>; else goto <D.5212>;
  <D.5212>:
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.6324;
  int D.6329;
  void * D.6331;
  unsigned int D.6332;

  D.6324 = __builtin_constant_p (__len);
  if (D.6324 != 0) goto <D.6325>; else goto <D.6326>;
  <D.6325>:
  if (__len == 0) goto <D.6327>; else goto <D.6328>;
  <D.6327>:
  D.6329 = __builtin_constant_p (__ch);
  if (D.6329 == 0) goto <D.6322>; else goto <D.6330>;
  <D.6330>:
  if (__ch != 0) goto <D.6322>; else goto <D.6323>;
  <D.6322>:
  __warn_memset_zero_len ();
  D.6331 = __dest;
  return D.6331;
  <D.6323>:
  <D.6328>:
  <D.6326>:
  D.6332 = __builtin_object_size (__dest, 0);
  D.6331 = __builtin___memset_chk (__dest, __ch, __len, D.6332);
  return D.6331;
}


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

  try
    {
      D.6334 = GC_approx_sp ();
      sp = (word) D.6334;
      random_no.5 = random_no;
      random_no.6 = random_no.5 + 1;
      random_no = random_no.6;
      random_no.5 = random_no;
      D.6337 = random_no.5 % 13;
      if (D.6337 == 0) goto <D.6338>; else goto <D.6339>;
      <D.6338>:
      limit = sp;
      limit = limit + 4294959104;
      limit = limit & 4294967280;
      D.6340 = GC_clear_stack_inner (arg, limit);
      return D.6340;
      <D.6339>:
      memset (&dummy, 0, 1024);
      D.6340 = arg;
      return D.6340;
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


GC_base (void * p)
{
  int GC_is_initialized.7;
  void * D.6346;
  long unsigned int D.6347;
  long unsigned int D.6348;
  long unsigned int D.6349;
  long unsigned int D.6350;
  long unsigned int candidate_hdr.8;
  long unsigned int D.6354;
  sizetype D.6355;
  long unsigned int h.9;
  long unsigned int D.6357;
  struct bottom_index * D.6358;
  long unsigned int D.6359;
  long unsigned int D.6360;
  map_entry_type * D.6361;
  map_entry_type * GC_invalid_map.10;
  int r.11;
  long unsigned int D.6366;
  sizetype offset.12;
  map_entry_type * D.6368;
  unsigned char D.6369;
  int D.6372;
  long int D.6373;
  long unsigned int D.6374;
  long int D.6375;
  long unsigned int D.6376;
  struct hblk * D.6377;
  long unsigned int D.6378;
  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.6344>; else goto <D.6345>;
  <D.6344>:
  D.6346 = 0B;
  return D.6346;
  <D.6345>:
  D.6347 = r & 4294963200;
  h = (struct hblk *) D.6347;
  D.6348 = r >> 22;
  bi = GC_arrays._top_index[D.6348];
  D.6349 = r >> 12;
  D.6350 = D.6349 & 1023;
  candidate_hdr = bi->index[D.6350];
  if (candidate_hdr == 0B) goto <D.6351>; else goto <D.6352>;
  <D.6351>:
  D.6346 = 0B;
  return D.6346;
  <D.6352>:
  goto <D.5238>;
  <D.5237>:
  candidate_hdr.8 = (long unsigned int) candidate_hdr;
  D.6354 = candidate_hdr.8 * 4096;
  D.6355 = -D.6354;
  h = h + D.6355;
  r = (word) h;
  h.9 = (long unsigned int) h;
  D.6357 = h.9 >> 22;
  D.6358 = GC_arrays._top_index[D.6357];
  h.9 = (long unsigned int) h;
  D.6359 = h.9 >> 12;
  D.6360 = D.6359 & 1023;
  candidate_hdr = D.6358->index[D.6360];
  <D.5238>:
  candidate_hdr.8 = (long unsigned int) candidate_hdr;
  if (candidate_hdr.8 <= 4095) goto <D.5237>; else goto <D.5239>;
  <D.5239>:
  D.6361 = candidate_hdr->hb_map;
  GC_invalid_map.10 = GC_invalid_map;
  if (D.6361 == GC_invalid_map.10) goto <D.6363>; else goto <D.6364>;
  <D.6363>:
  D.6346 = 0B;
  return D.6346;
  <D.6364>:
  r = r & 4294967292;
  {
    register int offset;
    register signed_word sz;
    register signed_word map_entry;

    r.11 = (int) r;
    offset = r.11 & 4095;
    D.6366 = candidate_hdr->hb_sz;
    sz = (signed_word) D.6366;
    D.6361 = candidate_hdr->hb_map;
    offset.12 = (sizetype) offset;
    D.6368 = D.6361 + offset.12;
    D.6369 = *D.6368;
    map_entry = (signed_word) D.6369;
    if (map_entry > 253) goto <D.6370>; else goto <D.6371>;
    <D.6370>:
    D.6372 = offset >> 2;
    map_entry = D.6372 % sz;
    <D.6371>:
    D.6373 = map_entry << 2;
    D.6374 = (long unsigned int) D.6373;
    r = r - D.6374;
    D.6375 = sz << 2;
    D.6376 = (long unsigned int) D.6375;
    limit = D.6376 + r;
    D.6377 = h + 4096;
    D.6378 = (long unsigned int) D.6377;
    if (D.6378 < limit) goto <D.6379>; else goto <D.6380>;
    <D.6379>:
    sz.13 = (long unsigned int) sz;
    if (sz.13 <= 1024) goto <D.6382>; else goto <D.6383>;
    <D.6382>:
    D.6346 = 0B;
    return D.6346;
    <D.6383>:
    <D.6380>:
    p.14 = (long unsigned int) p;
    if (p.14 >= limit) goto <D.6385>; else goto <D.6386>;
    <D.6385>:
    D.6346 = 0B;
    return D.6346;
    <D.6386>:
  }
  D.6346 = (void *) r;
  return D.6346;
}


GC_size (void * p)
{
  long unsigned int p.15;
  long unsigned int D.6389;
  struct bottom_index * D.6390;
  long unsigned int D.6391;
  long unsigned int D.6392;
  long unsigned int D.6393;
  long unsigned int D.6394;
  size_t D.6395;
  register int sz;
  register struct hdr * hhdr;

  p.15 = (long unsigned int) p;
  D.6389 = p.15 >> 22;
  D.6390 = GC_arrays._top_index[D.6389];
  p.15 = (long unsigned int) p;
  D.6391 = p.15 >> 12;
  D.6392 = D.6391 & 1023;
  hhdr = D.6390->index[D.6392];
  D.6393 = hhdr->hb_sz;
  D.6394 = D.6393 << 2;
  sz = (int) D.6394;
  D.6395 = (size_t) sz;
  return D.6395;
}


GC_get_heap_size ()
{
  size_t D.6397;

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


GC_get_free_bytes ()
{
  size_t D.6399;

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


GC_get_bytes_since_gc ()
{
  size_t D.6401;
  long unsigned int D.6402;

  D.6402 = GC_arrays._words_allocd;
  D.6401 = D.6402 << 2;
  return D.6401;
}


GC_get_total_bytes ()
{
  size_t D.6404;
  long unsigned int D.6405;
  long unsigned int D.6406;
  long unsigned int D.6407;

  D.6405 = GC_arrays._words_allocd;
  D.6406 = GC_arrays._words_allocd_before_gc;
  D.6407 = D.6405 + D.6406;
  D.6404 = D.6407 << 2;
  return D.6404;
}


GC_get_suspend_signal ()
{
  int D.6409;

  D.6409 = 19;
  return D.6409;
}


GC_init ()
{
  int D.6411;

  D.6411 = _test_and_set (&GC_allocate_lock, 1);
  if (D.6411 != 0) goto <D.6412>; else goto <D.6413>;
  <D.6412>:
  GC_lock ();
  <D.6413>:
  GC_init_inner ();
  GC_clear (&GC_allocate_lock);
}


_test_and_set (int * __p, int __v)
{
  int D.6414;
  int __r;
  int __t;

  __asm__ __volatile__("/* Inline test and set */
.set	push
	.set	mips2
	sync
	1:
	ll	%0,%3
	move	%1,%4
	beq	%0,%4,2f
	sc	%1,%2
	beqz	%1,1b
sync
	.set	pop
	2:
	/* End test and set */" : "=&r" __r, "=&r" __t, "=m" *__p : "m" *__p, "r" __v : "memory");
  D.6414 = __r;
  return D.6414;
}


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


GC_exit_check ()
{
  GC_gcollect ();
}


GC_init_inner ()
{
  int GC_is_initialized.16;
  char * D.6419;
  char * D.6422;
  char * D.6425;
  char * D.6428;
  char * D.6431;
  char * D.6434;
  char * D.6437;
  void (*<T7cd>) (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.6460;
  int D.6465;
  long unsigned int sz_str.22;
  long int D.6471;
  long unsigned int D.6472;
  long unsigned int sz_str.23;
  long unsigned int GC_max_retries.24;
  int D.6479;
  int D.6482;
  char * D.6485;
  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.6417>; else goto <D.6418>;
  <D.6417>:
  return;
  <D.6418>:
  D.6419 = getenv ("GC_PRINT_STATS");
  if (D.6419 != 0B) goto <D.6420>; else goto <D.6421>;
  <D.6420>:
  GC_print_stats = 1;
  <D.6421>:
  D.6422 = getenv ("GC_DUMP_REGULARLY");
  if (D.6422 != 0B) goto <D.6423>; else goto <D.6424>;
  <D.6423>:
  GC_dump_regularly = 1;
  <D.6424>:
  D.6425 = getenv ("GC_FIND_LEAK");
  if (D.6425 != 0B) goto <D.6426>; else goto <D.6427>;
  <D.6426>:
  GC_find_leak = 1;
  atexit (GC_exit_check);
  <D.6427>:
  D.6428 = getenv ("GC_ALL_INTERIOR_POINTERS");
  if (D.6428 != 0B) goto <D.6429>; else goto <D.6430>;
  <D.6429>:
  GC_all_interior_pointers = 1;
  <D.6430>:
  D.6431 = getenv ("GC_DONT_GC");
  if (D.6431 != 0B) goto <D.6432>; else goto <D.6433>;
  <D.6432>:
  GC_dont_gc = 1;
  <D.6433>:
  D.6434 = getenv ("GC_PRINT_BACK_HEIGHT");
  if (D.6434 != 0B) goto <D.6435>; else goto <D.6436>;
  <D.6435>:
  GC_print_back_height = 1;
  <D.6436>:
  D.6437 = getenv ("GC_NO_BLACKLIST_WARNING");
  if (D.6437 != 0B) goto <D.6438>; else goto <D.6439>;
  <D.6438>:
  GC_large_alloc_warn_interval = 2147483647;
  <D.6439>:
  {
    char * time_limit_string;

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

      time_limit = atol (time_limit_string);
      if (time_limit <= 4) goto <D.6442>; else goto <D.6443>;
      <D.6442>:
      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.6445>;
      <D.6443>:
      time_limit.18 = (long unsigned int) time_limit;
      GC_time_limit = time_limit.18;
      <D.6445>:
    }
    <D.6441>:
  }
  {
    char * interval_string;

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

      interval = atol (interval_string);
      if (interval <= 0) goto <D.6449>; else goto <D.6450>;
      <D.6449>:
      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.6451>;
      <D.6450>:
      GC_large_alloc_warn_interval = interval;
      <D.6451>:
    }
    <D.6448>:
  }
  maybe_install_looping_handler ();
  GC_all_interior_pointers.19 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.19 != 0) goto <D.6453>; else goto <D.6454>;
  <D.6453>:
  GC_obj_kinds[1].ok_descriptor = 4294967292;
  <D.6454>:
  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_thr_init ();
  GC_stackbottom.20 = GC_stackbottom;
  if (GC_stackbottom.20 == 0B) goto <D.6456>; else goto <D.6457>;
  <D.6456>:
  GC_stackbottom.21 = GC_get_stack_base ();
  GC_stackbottom = GC_stackbottom.21;
  goto <D.6459>;
  <D.6457>:
  <D.6459>:
  D.6460 = GC_register_main_static_data ();
  if (D.6460 != 0) goto <D.6461>; else goto <D.6462>;
  <D.6461>:
  GC_register_data_segments ();
  <D.6462>:
  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.6463>; else goto <D.6464>;
    <D.6463>:
    D.6465 = atoi (sz_str);
    initial_heap_sz = (word) D.6465;
    if (initial_heap_sz <= 65536) goto <D.6466>; else goto <D.6467>;
    <D.6466>:
    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.6467>:
    initial_heap_sz = initial_heap_sz >> 12;
    <D.6464>:
  }
  {
    char * sz_str;

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

      D.6471 = atol (sz_str);
      max_heap_sz = (word) D.6471;
      D.6472 = initial_heap_sz * 4096;
      if (D.6472 > max_heap_sz) goto <D.6473>; else goto <D.6474>;
      <D.6473>:
      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.6474>:
      GC_max_retries.24 = GC_max_retries;
      if (GC_max_retries.24 == 0) goto <D.6477>; else goto <D.6478>;
      <D.6477>:
      GC_max_retries = 2;
      <D.6478>:
      GC_set_max_heap_size (max_heap_sz);
    }
    <D.6470>:
  }
  D.6479 = GC_expand_hp_inner (initial_heap_sz);
  if (D.6479 == 0) goto <D.6480>; else goto <D.6481>;
  <D.6480>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.6481>:
  D.6482 = GC_add_map_entry (0);
  if (D.6482 == 0) goto <D.6483>; else goto <D.6484>;
  <D.6483>:
  GC_err_puts ("Can\'t start up: not enough memory\n");
  exit (1);
  <D.6484>:
  GC_register_displacement_inner (0);
  GC_init_size_map ();
  D.6485 = getenv ("GC_ENABLE_INCREMENTAL");
  if (D.6485 != 0B) goto <D.6486>; else goto <D.6487>;
  <D.6486>:
  GC_setpagesize ();
  GC_dirty_init ();
  GC_incremental = 1;
  <D.6487>:
  GC_dump_regularly.25 = GC_dump_regularly;
  if (GC_dump_regularly.25 != 0) goto <D.6489>; else goto <D.6490>;
  <D.6489>:
  GC_dump ();
  <D.6490>:
  GC_dont_precollect.26 = GC_dont_precollect;
  if (GC_dont_precollect.26 == 0) goto <D.6491>; else goto <D.6494>;
  <D.6494>:
  GC_incremental.27 = GC_incremental;
  if (GC_incremental.27 != 0) goto <D.6491>; else goto <D.6492>;
  <D.6491>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.6492>:
  GC_is_initialized = 1;
}


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

  installed_looping_handler.28 = installed_looping_handler;
  if (installed_looping_handler.28 == 0) goto <D.6498>; else goto <D.6499>;
  <D.6498>:
  D.6500 = getenv ("GC_LOOP_ON_ABORT");
  if (D.6500 != 0B) goto <D.6501>; else goto <D.6502>;
  <D.6501>:
  GC_set_and_save_fault_handler (looping_handler);
  installed_looping_handler = 1;
  <D.6502>:
  <D.6499>:
}


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


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

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


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

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


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

  GC_find_leak.29 = GC_find_leak;
  if (GC_find_leak.29 == 0) goto <D.6508>; else goto <D.6509>;
  <D.6508>:
  D.6510 = _test_and_set (&GC_allocate_lock, 1);
  if (D.6510 != 0) goto <D.6511>; else goto <D.6512>;
  <D.6511>:
  GC_lock ();
  <D.6512>:
  GC_incremental.30 = GC_incremental;
  if (GC_incremental.30 != 0) goto out; else goto <D.6514>;
  <D.6514>:
  GC_setpagesize ();
  if (0 != 0) goto out; else goto <D.6515>;
  <D.6515>:
  maybe_install_looping_handler ();
  GC_dirty_init ();
  GC_is_initialized.31 = GC_is_initialized;
  if (GC_is_initialized.31 == 0) goto <D.6517>; else goto <D.6518>;
  <D.6517>:
  GC_init_inner ();
  <D.6518>:
  GC_incremental.30 = GC_incremental;
  if (GC_incremental.30 != 0) goto out; else goto <D.6519>;
  <D.6519>:
  GC_dont_gc.32 = GC_dont_gc;
  if (GC_dont_gc.32 != 0) goto <D.6521>; else goto <D.6522>;
  <D.6521>:
  GC_clear (&GC_allocate_lock);
  return;
  <D.6522>:
  D.6523 = GC_arrays._words_allocd;
  if (D.6523 != 0) goto <D.6524>; else goto <D.6525>;
  <D.6524>:
  GC_try_to_collect_inner (GC_never_stop_func);
  <D.6525>:
  GC_read_dirty ();
  GC_incremental = 1;
  out:
  GC_clear (&GC_allocate_lock);
  <D.6509>:
}


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

  bytes_written = 0;
  goto <D.6199>;
  <D.6198>:
  bytes_written.33 = (sizetype) bytes_written;
  D.6528 = buf + bytes_written.33;
  bytes_written.34 = (unsigned int) bytes_written;
  D.6530 = len - bytes_written.34;
  result = write (fd, D.6528, D.6530);
  if (result == -1) goto <D.6531>; else goto <D.6532>;
  <D.6531>:
  D.6533 = result;
  return D.6533;
  <D.6532>:
  bytes_written = bytes_written + result;
  <D.6199>:
  bytes_written.34 = (unsigned int) bytes_written;
  if (bytes_written.34 < len) goto <D.6198>; else goto <D.6200>;
  <D.6200>:
  D.6533 = bytes_written;
  return D.6533;
}


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.6538;
  int GC_stdout.36;
  unsigned int D.6542;
  int D.6543;
  char buf[1025];

  try
    {
      GC_quiet.35 = GC_quiet;
      if (GC_quiet.35 != 0) goto <D.6536>; else goto <D.6537>;
      <D.6536>:
      return;
      <D.6537>:
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.6538 = buf[1024];
      if (D.6538 != 21) goto <D.6539>; else goto <D.6540>;
      <D.6539>:
      GC_abort ("GC_printf clobbered stack");
      <D.6540>:
      GC_stdout.36 = GC_stdout;
      D.6542 = strlen (&buf);
      D.6543 = GC_write (GC_stdout.36, &buf, D.6542);
      if (D.6543 < 0) goto <D.6544>; else goto <D.6545>;
      <D.6544>:
      GC_abort ("write to stdout failed");
      <D.6545>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

  D.6550 = __builtin_object_size (__s, 1);
  D.6549 = __builtin___sprintf_chk (__s, 1, D.6550, __fmt, __builtin_va_arg_pack ());
  return D.6549;
}


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.6552;
  int GC_stderr.37;
  unsigned int D.6556;
  int D.6557;
  char buf[1025];

  try
    {
      buf[1024] = 21;
      sprintf (&buf, format, a, b, c, d, e, f);
      D.6552 = buf[1024];
      if (D.6552 != 21) goto <D.6553>; else goto <D.6554>;
      <D.6553>:
      GC_abort ("GC_err_printf clobbered stack");
      <D.6554>:
      GC_stderr.37 = GC_stderr;
      D.6556 = strlen (&buf);
      D.6557 = GC_write (GC_stderr.37, &buf, D.6556);
      if (D.6557 < 0) goto <D.6558>; else goto <D.6559>;
      <D.6558>:
      GC_abort ("write to stderr failed");
      <D.6559>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


GC_err_puts (const char * s)
{
  int GC_stderr.38;
  unsigned int D.6561;
  int D.6562;

  GC_stderr.38 = GC_stderr;
  D.6561 = strlen (s);
  D.6562 = GC_write (GC_stderr.38, s, D.6561);
  if (D.6562 < 0) goto <D.6563>; else goto <D.6564>;
  <D.6563>:
  GC_abort ("write to stderr failed");
  <D.6564>:
}


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

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


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

  D.6570 = _test_and_set (&GC_allocate_lock, 1);
  if (D.6570 != 0) goto <D.6571>; else goto <D.6572>;
  <D.6571>:
  GC_lock ();
  <D.6572>:
  result = GC_current_warn_proc;
  GC_current_warn_proc = p;
  GC_clear (&GC_allocate_lock);
  D.6573 = result;
  return D.6573;
}


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

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


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

  msg.41 = (long int) msg;
  GC_err_printf ("%s\n", msg.41, 0, 0, 0, 0, 0);
  D.6578 = getenv ("GC_LOOP_ON_ABORT");
  if (D.6578 != 0B) goto <D.6579>; else goto <D.6580>;
  <D.6579>:
  <D.6244>:
  goto <D.6244>;
  <D.6580>:
  abort ();
}


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

  D.6581 = _test_and_set (&GC_allocate_lock, 1);
  if (D.6581 != 0) goto <D.6582>; else goto <D.6583>;
  <D.6582>:
  GC_lock ();
  <D.6583>:
  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.6586;
  int GC_dont_gc.44;
  int GC_dont_gc.45;

  D.6586 = _test_and_set (&GC_allocate_lock, 1);
  if (D.6586 != 0) goto <D.6587>; else goto <D.6588>;
  <D.6587>:
  GC_lock ();
  <D.6588>:
  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.6593;
  void * result;

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


GC_new_free_list ()
{
  int D.6595;
  void * * D.6598;
  void * result;

  D.6595 = _test_and_set (&GC_allocate_lock, 1);
  if (D.6595 != 0) goto <D.6596>; else goto <D.6597>;
  <D.6596>:
  GC_lock ();
  <D.6597>:
  result = GC_new_free_list_inner ();
  GC_clear (&GC_allocate_lock);
  D.6598 = result;
  return D.6598;
}


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


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

  D.6607 = _test_and_set (&GC_allocate_lock, 1);
  if (D.6607 != 0) goto <D.6608>; else goto <D.6609>;
  <D.6608>:
  GC_lock ();
  <D.6609>:
  result = GC_new_kind_inner (fl, descr, adjust, clear);
  GC_clear (&GC_allocate_lock);
  D.6610 = result;
  return D.6610;
}


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


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.6619;
  int D.6622;
  int result;

  D.6619 = _test_and_set (&GC_allocate_lock, 1);
  if (D.6619 != 0) goto <D.6620>; else goto <D.6621>;
  <D.6620>:
  GC_lock ();
  <D.6621>:
  result = GC_new_proc_inner (proc);
  GC_clear (&GC_allocate_lock);
  D.6622 = result;
  return D.6622;
}


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