sgen_init_pinning ()
{
  memset (&pin_hash_filter, 0, 4096);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.17342;
  int D.17347;
  void * D.17349;
  unsigned int D.17350;

  D.17342 = __builtin_constant_p (__len);
  if (D.17342 != 0) goto <D.17343>; else goto <D.17344>;
  <D.17343>:
  if (__len == 0) goto <D.17345>; else goto <D.17346>;
  <D.17345>:
  D.17347 = __builtin_constant_p (__ch);
  if (D.17347 == 0) goto <D.17340>; else goto <D.17348>;
  <D.17348>:
  if (__ch != 0) goto <D.17340>; else goto <D.17341>;
  <D.17340>:
  __warn_memset_zero_len ();
  D.17349 = __dest;
  return D.17349;
  <D.17341>:
  <D.17346>:
  <D.17344>:
  D.17350 = __builtin_object_size (__dest, 0);
  D.17349 = __builtin___memset_chk (__dest, __ch, __len, D.17350);
  return D.17349;
}


sgen_finish_pinning ()
{
  int next_pin_slot.0;

  next_pin_slot.0 = next_pin_slot;
  last_num_pinned = next_pin_slot.0;
  next_pin_slot = 0;
}


sgen_pin_stage_ptr (void * ptr)
{
  unsigned int ptr.1;
  unsigned int D.17354;
  int D.17355;
  void * D.17356;
  int next_pin_slot.2;
  int pin_queue_size.3;
  void * * pin_queue.4;
  int next_pin_slot.5;
  int next_pin_slot.6;
  unsigned int next_pin_slot.7;
  unsigned int D.17367;
  void * * D.17368;
  int hash_idx;

  ptr.1 = (unsigned int) ptr;
  D.17354 = ptr.1 * 1737350767;
  D.17355 = (int) D.17354;
  hash_idx = D.17355 & 1023;
  D.17356 = pin_hash_filter[hash_idx];
  if (D.17356 == ptr) goto <D.17357>; else goto <D.17358>;
  <D.17357>:
  return;
  <D.17358>:
  pin_hash_filter[hash_idx] = ptr;
  next_pin_slot.2 = next_pin_slot;
  pin_queue_size.3 = pin_queue_size;
  if (next_pin_slot.2 >= pin_queue_size.3) goto <D.17361>; else goto <D.17362>;
  <D.17361>:
  realloc_pin_queue ();
  <D.17362>:
  pin_queue.4 = pin_queue;
  next_pin_slot.2 = next_pin_slot;
  next_pin_slot.5 = next_pin_slot.2;
  next_pin_slot.6 = next_pin_slot.5 + 1;
  next_pin_slot = next_pin_slot.6;
  next_pin_slot.7 = (unsigned int) next_pin_slot.5;
  D.17367 = next_pin_slot.7 * 4;
  D.17368 = pin_queue.4 + D.17367;
  *D.17368 = ptr;
}


realloc_pin_queue ()
{
  int iftmp.8;
  int pin_queue_size.9;
  int D.17374;
  unsigned int new_size.10;
  unsigned int D.17377;
  int next_pin_slot.11;
  unsigned int next_pin_slot.12;
  unsigned int D.17380;
  void * * pin_queue.13;
  unsigned int pin_queue_size.14;
  unsigned int D.17383;
  struct FILE * gc_debug_file.15;
  int new_size;
  void * * new_pin;

  pin_queue_size.9 = pin_queue_size;
  if (pin_queue_size.9 != 0) goto <D.17372>; else goto <D.17373>;
  <D.17372>:
  pin_queue_size.9 = pin_queue_size;
  D.17374 = pin_queue_size.9 / 2;
  pin_queue_size.9 = pin_queue_size;
  iftmp.8 = D.17374 + pin_queue_size.9;
  goto <D.17375>;
  <D.17373>:
  iftmp.8 = 1024;
  <D.17375>:
  new_size = iftmp.8;
  new_size.10 = (unsigned int) new_size;
  D.17377 = new_size.10 * 4;
  new_pin = sgen_alloc_internal_dynamic (D.17377, 0, 1);
  next_pin_slot.11 = next_pin_slot;
  next_pin_slot.12 = (unsigned int) next_pin_slot.11;
  D.17380 = next_pin_slot.12 * 4;
  pin_queue.13 = pin_queue;
  memcpy (new_pin, pin_queue.13, D.17380);
  pin_queue_size.9 = pin_queue_size;
  pin_queue_size.14 = (unsigned int) pin_queue_size.9;
  D.17383 = pin_queue_size.14 * 4;
  pin_queue.13 = pin_queue;
  sgen_free_internal_dynamic (pin_queue.13, D.17383, 0);
  pin_queue = new_pin;
  pin_queue_size = new_size;
  if (0 != 0) goto <D.17384>; else goto <D.17385>;
  <D.17384>:
  gc_debug_file.15 = gc_debug_file;
  fprintf (gc_debug_file.15, "Reallocated pin queue to size: %d\n", new_size);
  gc_debug_file.15 = gc_debug_file;
  fflush (gc_debug_file.15);
  <D.17385>:
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.17387;
  unsigned int D.17388;

  D.17388 = __builtin_object_size (__dest, 0);
  D.17387 = __builtin___memcpy_chk (__dest, __src, __len, D.17388);
  return D.17387;
}


sgen_find_optimized_pin_queue_area (void * start, void * end, int * num)
{
  int D.17390;
  void * * D.17393;
  void * * pin_queue.16;
  unsigned int first.17;
  unsigned int D.17396;
  int first;
  int last;

  first = optimized_pin_queue_search (start);
  last = optimized_pin_queue_search (end);
  D.17390 = last - first;
  *num = D.17390;
  if (first == last) goto <D.17391>; else goto <D.17392>;
  <D.17391>:
  D.17393 = 0B;
  return D.17393;
  <D.17392>:
  pin_queue.16 = pin_queue;
  first.17 = (unsigned int) first;
  D.17396 = first.17 * 4;
  D.17393 = pin_queue.16 + D.17396;
  return D.17393;
}


optimized_pin_queue_search (void * addr)
{
  int D.17398;
  int D.17399;
  void * * pin_queue.18;
  unsigned int middle.19;
  unsigned int D.17402;
  void * * D.17403;
  void * D.17404;
  _Bool D.17408;
  long int D.17409;
  long int D.17410;
  int D.17413;
  int first;
  int last;

  first = 0;
  last = next_pin_slot;
  goto <D.17234>;
  <D.17233>:
  {
    int middle;

    D.17398 = last - first;
    D.17399 = D.17398 >> 1;
    middle = D.17399 + first;
    pin_queue.18 = pin_queue;
    middle.19 = (unsigned int) middle;
    D.17402 = middle.19 * 4;
    D.17403 = pin_queue.18 + D.17402;
    D.17404 = *D.17403;
    if (D.17404 >= addr) goto <D.17405>; else goto <D.17406>;
    <D.17405>:
    last = middle;
    goto <D.17407>;
    <D.17406>:
    first = middle + 1;
    <D.17407>:
  }
  <D.17234>:
  if (first < last) goto <D.17233>; else goto <D.17235>;
  <D.17235>:
  D.17408 = first != last;
  D.17409 = (long int) D.17408;
  D.17410 = __builtin_expect (D.17409, 0);
  if (D.17410 != 0) goto <D.17411>; else goto <D.17412>;
  <D.17411>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-pinning.c", 89, "first == last");
  <D.17412>:
  D.17413 = first;
  return D.17413;
}


sgen_find_section_pin_queue_start_end (struct GCMemSection * section)
{
  char * D.17417;
  char * D.17418;
  struct FILE * gc_debug_file.20;
  int * D.17420;
  void * * D.17421;
  int D.17424;

  if (0 != 0) goto <D.17415>; else goto <D.17416>;
  <D.17415>:
  D.17417 = section->end_data;
  D.17418 = section->data;
  gc_debug_file.20 = gc_debug_file;
  fprintf (gc_debug_file.20, "Pinning from section %p (%p-%p)\n", section, D.17418, D.17417);
  gc_debug_file.20 = gc_debug_file;
  fflush (gc_debug_file.20);
  <D.17416>:
  D.17420 = &section->pin_queue_num_entries;
  D.17417 = section->end_data;
  D.17418 = section->data;
  D.17421 = sgen_find_optimized_pin_queue_area (D.17418, D.17417, D.17420);
  section->pin_queue_start = D.17421;
  if (0 != 0) goto <D.17422>; else goto <D.17423>;
  <D.17422>:
  D.17424 = section->pin_queue_num_entries;
  gc_debug_file.20 = gc_debug_file;
  fprintf (gc_debug_file.20, "Found %d pinning addresses in section %p\n", D.17424, section);
  gc_debug_file.20 = gc_debug_file;
  fflush (gc_debug_file.20);
  <D.17423>:
}


sgen_pinning_setup_section (struct GCMemSection * section)
{
  void * * pin_queue.21;
  int next_pin_slot.22;

  pin_queue.21 = pin_queue;
  section->pin_queue_start = pin_queue.21;
  next_pin_slot.22 = next_pin_slot;
  section->pin_queue_num_entries = next_pin_slot.22;
}


sgen_pinning_trim_queue_to_section (struct GCMemSection * section)
{
  int next_pin_slot.23;

  next_pin_slot.23 = section->pin_queue_num_entries;
  next_pin_slot = next_pin_slot.23;
}


sgen_pin_queue_clear_discarded_entries (struct GCMemSection * section, int max_pin_slot)
{
  void * * D.17428;
  int D.17429;
  unsigned int D.17430;
  unsigned int D.17431;
  void * * pin_queue.24;
  unsigned int max_pin_slot.25;
  unsigned int D.17434;
  char * D.17437;
  char * D.17439;
  void * * start;
  void * * end;
  void * addr;

  D.17428 = section->pin_queue_start;
  D.17429 = section->pin_queue_num_entries;
  D.17430 = (unsigned int) D.17429;
  D.17431 = D.17430 * 4;
  start = D.17428 + D.17431;
  pin_queue.24 = pin_queue;
  max_pin_slot.25 = (unsigned int) max_pin_slot;
  D.17434 = max_pin_slot.25 * 4;
  end = pin_queue.24 + D.17434;
  if (start == 0B) goto <D.17435>; else goto <D.17436>;
  <D.17435>:
  return;
  <D.17436>:
  goto <D.17261>;
  <D.17260>:
  addr = *start;
  D.17437 = section->data;
  if (D.17437 > addr) goto <D.17259>; else goto <D.17438>;
  <D.17438>:
  D.17439 = section->end_data;
  if (D.17439 < addr) goto <D.17259>; else goto <D.17440>;
  <D.17440>:
  *start = 0B;
  start = start + 4;
  <D.17261>:
  if (start < end) goto <D.17260>; else goto <D.17259>;
  <D.17259>:
}


sgen_optimize_pin_queue (int start_slot)
{
  int next_pin_slot.26;
  struct FILE * gc_debug_file.27;
  int D.17446;
  void * * pin_queue.28;
  unsigned int start_slot.29;
  unsigned int D.17451;
  void * * D.17452;
  unsigned int next_pin_slot.30;
  unsigned int D.17454;
  void * * cur.31;
  void * D.17456;
  void * D.17457;
  void * D.17458;
  int start.32;
  int pin_queue.33;
  int D.17462;
  int next_pin_slot.34;
  void * * start;
  void * * cur;
  void * * end;

  if (0 != 0) goto <D.17442>; else goto <D.17443>;
  <D.17442>:
  next_pin_slot.26 = next_pin_slot;
  gc_debug_file.27 = gc_debug_file;
  fprintf (gc_debug_file.27, "Sorting pin queue, size: %d\n", next_pin_slot.26);
  gc_debug_file.27 = gc_debug_file;
  fflush (gc_debug_file.27);
  <D.17443>:
  next_pin_slot.26 = next_pin_slot;
  D.17446 = next_pin_slot.26 - start_slot;
  if (D.17446 > 1) goto <D.17447>; else goto <D.17448>;
  <D.17447>:
  next_pin_slot.26 = next_pin_slot;
  D.17446 = next_pin_slot.26 - start_slot;
  pin_queue.28 = pin_queue;
  start_slot.29 = (unsigned int) start_slot;
  D.17451 = start_slot.29 * 4;
  D.17452 = pin_queue.28 + D.17451;
  sgen_sort_addresses (D.17452, D.17446);
  <D.17448>:
  pin_queue.28 = pin_queue;
  start_slot.29 = (unsigned int) start_slot;
  D.17451 = start_slot.29 * 4;
  cur = pin_queue.28 + D.17451;
  start = cur;
  pin_queue.28 = pin_queue;
  next_pin_slot.26 = next_pin_slot;
  next_pin_slot.30 = (unsigned int) next_pin_slot.26;
  D.17454 = next_pin_slot.30 * 4;
  end = pin_queue.28 + D.17454;
  goto <D.17272>;
  <D.17271>:
  cur.31 = cur;
  cur = cur.31 + 4;
  D.17456 = *cur.31;
  *start = D.17456;
  goto <D.17269>;
  <D.17268>:
  cur = cur + 4;
  <D.17269>:
  D.17457 = *start;
  D.17458 = *cur;
  if (D.17457 == D.17458) goto <D.17459>; else goto <D.17270>;
  <D.17459>:
  if (cur < end) goto <D.17268>; else goto <D.17270>;
  <D.17270>:
  start = start + 4;
  <D.17272>:
  if (cur < end) goto <D.17271>; else goto <D.17273>;
  <D.17273>:
  start.32 = (int) start;
  pin_queue.28 = pin_queue;
  pin_queue.33 = (int) pin_queue.28;
  D.17462 = start.32 - pin_queue.33;
  next_pin_slot.34 = D.17462 /[ex] 4;
  next_pin_slot = next_pin_slot.34;
  if (0 != 0) goto <D.17464>; else goto <D.17465>;
  <D.17464>:
  next_pin_slot.26 = next_pin_slot;
  gc_debug_file.27 = gc_debug_file;
  fprintf (gc_debug_file.27, "Pin queue reduced to size: %d\n", next_pin_slot.26);
  gc_debug_file.27 = gc_debug_file;
  fflush (gc_debug_file.27);
  <D.17465>:
}


sgen_get_pinned_count ()
{
  int D.17466;

  D.17466 = next_pin_slot;
  return D.17466;
}


sgen_dump_pin_queue ()
{
  void * * pin_queue.35;
  unsigned int i.36;
  unsigned int D.17472;
  void * * D.17473;
  void * D.17474;
  unsigned int D.17475;
  const char * D.17476;
  struct FILE * gc_debug_file.37;
  int last_num_pinned.38;
  int i;

  i = 0;
  goto <D.17282>;
  <D.17281>:
  if (0 != 0) goto <D.17468>; else goto <D.17469>;
  <D.17468>:
  pin_queue.35 = pin_queue;
  i.36 = (unsigned int) i;
  D.17472 = i.36 * 4;
  D.17473 = pin_queue.35 + D.17472;
  D.17474 = *D.17473;
  D.17475 = sgen_safe_object_get_size (D.17474);
  pin_queue.35 = pin_queue;
  i.36 = (unsigned int) i;
  D.17472 = i.36 * 4;
  D.17473 = pin_queue.35 + D.17472;
  D.17474 = *D.17473;
  D.17476 = sgen_safe_name (D.17474);
  pin_queue.35 = pin_queue;
  i.36 = (unsigned int) i;
  D.17472 = i.36 * 4;
  D.17473 = pin_queue.35 + D.17472;
  D.17474 = *D.17473;
  gc_debug_file.37 = gc_debug_file;
  fprintf (gc_debug_file.37, "Bastard pinning obj %p (%s), size: %d\n", D.17474, D.17476, D.17475);
  gc_debug_file.37 = gc_debug_file;
  fflush (gc_debug_file.37);
  <D.17469>:
  i = i + 1;
  <D.17282>:
  last_num_pinned.38 = last_num_pinned;
  if (i < last_num_pinned.38) goto <D.17281>; else goto <D.17283>;
  <D.17283>:
}


sgen_cement_init (gboolean enabled)
{
  cement_enabled = enabled;
}


sgen_cement_reset ()
{
  int cement_concurrent.39;
  _Bool D.17480;
  long int D.17481;
  long int D.17482;

  cement_concurrent.39 = cement_concurrent;
  D.17480 = cement_concurrent.39 != 0;
  D.17481 = (long int) D.17480;
  D.17482 = __builtin_expect (D.17481, 0);
  if (D.17482 != 0) goto <D.17483>; else goto <D.17484>;
  <D.17483>:
  monoeg_g_log (0B, 4, "Concurrent cementing cannot simply be reset");
  <D.17298>:
  goto <D.17298>;
  <D.17484>:
  memset (&cement_hash, 0, 488);
}


sgen_cement_concurrent_start ()
{
  int cement_concurrent.40;
  _Bool D.17486;
  long int D.17487;
  long int D.17488;

  cement_concurrent.40 = cement_concurrent;
  D.17486 = cement_concurrent.40 != 0;
  D.17487 = (long int) D.17486;
  D.17488 = __builtin_expect (D.17487, 0);
  if (D.17488 != 0) goto <D.17489>; else goto <D.17490>;
  <D.17489>:
  monoeg_g_log (0B, 4, "Concurrent cementing has already been started");
  <D.17302>:
  goto <D.17302>;
  <D.17490>:
  cement_concurrent = 1;
  memset (&cement_hash_concurrent, 0, 488);
}


sgen_cement_concurrent_finish ()
{
  int cement_concurrent.41;
  _Bool D.17492;
  long int D.17493;
  long int D.17494;

  cement_concurrent.41 = cement_concurrent;
  D.17492 = cement_concurrent.41 == 0;
  D.17493 = (long int) D.17492;
  D.17494 = __builtin_expect (D.17493, 0);
  if (D.17494 != 0) goto <D.17495>; else goto <D.17496>;
  <D.17495>:
  monoeg_g_log (0B, 4, "Concurrent cementing hasn\'t been started");
  <D.17306>:
  goto <D.17306>;
  <D.17496>:
  cement_concurrent = 0;
  memcpy (&cement_hash, &cement_hash_concurrent, 488);
}


sgen_cement_lookup (char * obj)
{
  unsigned int D.17497;
  unsigned int D.17498;
  int D.17499;
  _Bool D.17500;
  long int D.17501;
  long int D.17502;
  int cement_enabled.42;
  gboolean D.17508;
  char * D.17509;
  unsigned int D.17514;
  _Bool D.17515;
  int i;

  D.17497 = mono_aligned_addr_hash (obj);
  D.17498 = D.17497 % 61;
  i = (int) D.17498;
  D.17499 = sgen_ptr_in_nursery (obj);
  D.17500 = D.17499 == 0;
  D.17501 = (long int) D.17500;
  D.17502 = __builtin_expect (D.17501, 0);
  if (D.17502 != 0) goto <D.17503>; else goto <D.17504>;
  <D.17503>:
  monoeg_g_log (0B, 4, "Looking up cementing for non-nursery objects makes no sense");
  <D.17311>:
  goto <D.17311>;
  <D.17504>:
  cement_enabled.42 = cement_enabled;
  if (cement_enabled.42 == 0) goto <D.17506>; else goto <D.17507>;
  <D.17506>:
  D.17508 = 0;
  return D.17508;
  <D.17507>:
  D.17509 = cement_hash[i].obj;
  if (D.17509 == 0B) goto <D.17510>; else goto <D.17511>;
  <D.17510>:
  D.17508 = 0;
  return D.17508;
  <D.17511>:
  D.17509 = cement_hash[i].obj;
  if (D.17509 != obj) goto <D.17512>; else goto <D.17513>;
  <D.17512>:
  D.17508 = 0;
  return D.17508;
  <D.17513>:
  D.17514 = cement_hash[i].count;
  D.17515 = D.17514 > 999;
  D.17508 = (gboolean) D.17515;
  return D.17508;
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.17517;
  int sgen_nursery_bits.43;
  int D.17519;
  int D.17520;
  unsigned int D.17521;
  unsigned int p.44;
  unsigned int D.17523;
  char * sgen_nursery_start.45;
  unsigned int sgen_nursery_start.46;
  _Bool D.17526;

  sgen_nursery_bits.43 = sgen_nursery_bits;
  D.17519 = 1 << sgen_nursery_bits.43;
  D.17520 = -D.17519;
  D.17521 = (unsigned int) D.17520;
  p.44 = (unsigned int) p;
  D.17523 = D.17521 & p.44;
  sgen_nursery_start.45 = sgen_nursery_start;
  sgen_nursery_start.46 = (unsigned int) sgen_nursery_start.45;
  D.17526 = D.17523 == sgen_nursery_start.46;
  D.17517 = (gboolean) D.17526;
  return D.17517;
}


sgen_cement_lookup_or_register (char * obj)
{
  int cement_enabled.47;
  gboolean D.17531;
  int cement_concurrent.48;
  _Bool D.17535;
  long int D.17536;
  long int D.17537;
  unsigned int D.17543;
  unsigned int D.17544;
  int D.17545;
  _Bool D.17546;
  long int D.17547;
  long int D.17548;
  unsigned int i.49;
  unsigned int D.17552;
  struct CementHashEntry * D.17553;
  char * D.17554;
  unsigned int D.17557;
  _Bool D.17558;
  long int D.17559;
  long int D.17560;
  unsigned int D.17568;
  unsigned int D.17573;
  unsigned int D.17574;
  int i;
  struct CementHashEntry * hash;
  gboolean concurrent_cementing;

  concurrent_cementing = sgen_concurrent_collection_in_progress ();
  cement_enabled.47 = cement_enabled;
  if (cement_enabled.47 == 0) goto <D.17529>; else goto <D.17530>;
  <D.17529>:
  D.17531 = 0;
  return D.17531;
  <D.17530>:
  if (concurrent_cementing != 0) goto <D.17532>; else goto <D.17533>;
  <D.17532>:
  cement_concurrent.48 = cement_concurrent;
  D.17535 = cement_concurrent.48 == 0;
  D.17536 = (long int) D.17535;
  D.17537 = __builtin_expect (D.17536, 0);
  if (D.17537 != 0) goto <D.17538>; else goto <D.17539>;
  <D.17538>:
  monoeg_g_log (0B, 4, "Cementing wasn\'t inited with concurrent flag");
  <D.17318>:
  goto <D.17318>;
  <D.17539>:
  <D.17533>:
  if (concurrent_cementing != 0) goto <D.17540>; else goto <D.17541>;
  <D.17540>:
  hash = &cement_hash_concurrent;
  goto <D.17542>;
  <D.17541>:
  hash = &cement_hash;
  <D.17542>:
  D.17543 = mono_aligned_addr_hash (obj);
  D.17544 = D.17543 % 61;
  i = (int) D.17544;
  D.17545 = sgen_ptr_in_nursery (obj);
  D.17546 = D.17545 == 0;
  D.17547 = (long int) D.17546;
  D.17548 = __builtin_expect (D.17547, 0);
  if (D.17548 != 0) goto <D.17549>; else goto <D.17550>;
  <D.17549>:
  monoeg_g_log (0B, 4, "Can only cement pointers to nursery objects");
  <D.17319>:
  goto <D.17319>;
  <D.17550>:
  i.49 = (unsigned int) i;
  D.17552 = i.49 * 8;
  D.17553 = hash + D.17552;
  D.17554 = D.17553->obj;
  if (D.17554 == 0B) goto <D.17555>; else goto <D.17556>;
  <D.17555>:
  i.49 = (unsigned int) i;
  D.17552 = i.49 * 8;
  D.17553 = hash + D.17552;
  D.17557 = D.17553->count;
  D.17558 = D.17557 != 0;
  D.17559 = (long int) D.17558;
  D.17560 = __builtin_expect (D.17559, 0);
  if (D.17560 != 0) goto <D.17561>; else goto <D.17562>;
  <D.17561>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.17320>:
  goto <D.17320>;
  <D.17562>:
  i.49 = (unsigned int) i;
  D.17552 = i.49 * 8;
  D.17553 = hash + D.17552;
  D.17553->obj = obj;
  goto <D.17563>;
  <D.17556>:
  i.49 = (unsigned int) i;
  D.17552 = i.49 * 8;
  D.17553 = hash + D.17552;
  D.17554 = D.17553->obj;
  if (D.17554 != obj) goto <D.17564>; else goto <D.17565>;
  <D.17564>:
  D.17531 = 0;
  return D.17531;
  <D.17565>:
  <D.17563>:
  i.49 = (unsigned int) i;
  D.17552 = i.49 * 8;
  D.17553 = hash + D.17552;
  D.17557 = D.17553->count;
  if (D.17557 > 999) goto <D.17566>; else goto <D.17567>;
  <D.17566>:
  D.17531 = 1;
  return D.17531;
  <D.17567>:
  i.49 = (unsigned int) i;
  D.17552 = i.49 * 8;
  D.17553 = hash + D.17552;
  D.17557 = D.17553->count;
  D.17568 = D.17557 + 1;
  D.17553->count = D.17568;
  i.49 = (unsigned int) i;
  D.17552 = i.49 * 8;
  D.17553 = hash + D.17552;
  D.17557 = D.17553->count;
  if (D.17557 == 1000) goto <D.17569>; else goto <D.17570>;
  <D.17569>:
  if (0 != 0) goto <D.17571>; else goto <D.17572>;
  <D.17571>:
  {
    struct MonoVTable * vt;

    D.17573 = MEM[(mword *)obj];
    D.17574 = D.17573 & 4294967292;
    vt = (struct MonoVTable *) D.17574;
  }
  <D.17572>:
  <D.17570>:
  D.17531 = 0;
  return D.17531;
}


sgen_cement_iterate (void (*IterateObjectCallbackFunc) (char *, size_t, void *) callback, void * callback_data)
{
  unsigned int D.17576;
  _Bool D.17579;
  long int D.17580;
  long int D.17581;
  char * D.17584;
  int i;

  i = 0;
  goto <D.17330>;
  <D.17329>:
  D.17576 = cement_hash[i].count;
  if (D.17576 == 0) goto <D.17577>; else goto <D.17578>;
  <D.17577>:
  // predicted unlikely by continue predictor.
  goto <D.17327>;
  <D.17578>:
  D.17576 = cement_hash[i].count;
  D.17579 = D.17576 <= 999;
  D.17580 = (long int) D.17579;
  D.17581 = __builtin_expect (D.17580, 0);
  if (D.17581 != 0) goto <D.17582>; else goto <D.17583>;
  <D.17582>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.17328>:
  goto <D.17328>;
  <D.17583>:
  D.17584 = cement_hash[i].obj;
  callback (D.17584, 0, callback_data);
  <D.17327>:
  i = i + 1;
  <D.17330>:
  if (i <= 60) goto <D.17329>; else goto <D.17331>;
  <D.17331>:
}


sgen_cement_clear_below_threshold ()
{
  unsigned int D.17585;
  int i;

  i = 0;
  goto <D.17337>;
  <D.17336>:
  D.17585 = cement_hash[i].count;
  if (D.17585 <= 999) goto <D.17586>; else goto <D.17587>;
  <D.17586>:
  cement_hash[i].obj = 0B;
  cement_hash[i].count = 0;
  <D.17587>:
  i = i + 1;
  <D.17337>:
  if (i <= 60) goto <D.17336>; else goto <D.17338>;
  <D.17338>:
}