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


memset (void * __dest, int __ch, size_t __len)
{
  int D.18235;
  int D.18240;
  void * D.18242;
  long unsigned int D.18243;

  D.18235 = __builtin_constant_p (__len);
  if (D.18235 != 0) goto <D.18236>; else goto <D.18237>;
  <D.18236>:
  if (__len == 0) goto <D.18238>; else goto <D.18239>;
  <D.18238>:
  D.18240 = __builtin_constant_p (__ch);
  if (D.18240 == 0) goto <D.18233>; else goto <D.18241>;
  <D.18241>:
  if (__ch != 0) goto <D.18233>; else goto <D.18234>;
  <D.18233>:
  __warn_memset_zero_len ();
  D.18242 = __dest;
  return D.18242;
  <D.18234>:
  <D.18239>:
  <D.18237>:
  D.18243 = __builtin_object_size (__dest, 0);
  D.18242 = __builtin___memset_chk (__dest, __ch, __len, D.18243);
  return D.18242;
}


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)
{
  long unsigned int ptr.1;
  unsigned int D.18247;
  unsigned int D.18248;
  int D.18249;
  void * D.18250;
  int next_pin_slot.2;
  int pin_queue_size.3;
  void * * pin_queue.4;
  int next_pin_slot.5;
  int next_pin_slot.6;
  long unsigned int D.18260;
  long unsigned int D.18261;
  void * * D.18262;
  int hash_idx;

  ptr.1 = (long unsigned int) ptr;
  D.18247 = (unsigned int) ptr.1;
  D.18248 = D.18247 * 1737350767;
  D.18249 = (int) D.18248;
  hash_idx = D.18249 & 1023;
  D.18250 = pin_hash_filter[hash_idx];
  if (D.18250 == ptr) goto <D.18251>; else goto <D.18252>;
  <D.18251>:
  return;
  <D.18252>:
  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.18255>; else goto <D.18256>;
  <D.18255>:
  realloc_pin_queue ();
  <D.18256>:
  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;
  D.18260 = (long unsigned int) next_pin_slot.5;
  D.18261 = D.18260 * 8;
  D.18262 = pin_queue.4 + D.18261;
  *D.18262 = ptr;
}


realloc_pin_queue ()
{
  int iftmp.7;
  int pin_queue_size.8;
  int D.18268;
  long unsigned int D.18270;
  long unsigned int D.18271;
  void * * pin_queue.9;
  int next_pin_slot.10;
  long unsigned int D.18274;
  long unsigned int D.18275;
  long unsigned int D.18276;
  long unsigned int D.18277;
  struct FILE * gc_debug_file.11;
  int new_size;
  void * * new_pin;

  pin_queue_size.8 = pin_queue_size;
  if (pin_queue_size.8 != 0) goto <D.18266>; else goto <D.18267>;
  <D.18266>:
  pin_queue_size.8 = pin_queue_size;
  D.18268 = pin_queue_size.8 / 2;
  pin_queue_size.8 = pin_queue_size;
  iftmp.7 = D.18268 + pin_queue_size.8;
  goto <D.18269>;
  <D.18267>:
  iftmp.7 = 1024;
  <D.18269>:
  new_size = iftmp.7;
  D.18270 = (long unsigned int) new_size;
  D.18271 = D.18270 * 8;
  new_pin = sgen_alloc_internal_dynamic (D.18271, 0, 1);
  pin_queue.9 = pin_queue;
  next_pin_slot.10 = next_pin_slot;
  D.18274 = (long unsigned int) next_pin_slot.10;
  D.18275 = D.18274 * 8;
  memcpy (new_pin, pin_queue.9, D.18275);
  pin_queue.9 = pin_queue;
  pin_queue_size.8 = pin_queue_size;
  D.18276 = (long unsigned int) pin_queue_size.8;
  D.18277 = D.18276 * 8;
  sgen_free_internal_dynamic (pin_queue.9, D.18277, 0);
  pin_queue = new_pin;
  pin_queue_size = new_size;
  if (0 != 0) goto <D.18278>; else goto <D.18279>;
  <D.18278>:
  gc_debug_file.11 = gc_debug_file;
  fprintf (gc_debug_file.11, "Reallocated pin queue to size: %d\n", new_size);
  gc_debug_file.11 = gc_debug_file;
  fflush (gc_debug_file.11);
  <D.18279>:
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.18281;
  long unsigned int D.18282;

  D.18282 = __builtin_object_size (__dest, 0);
  D.18281 = __builtin___memcpy_chk (__dest, __src, __len, D.18282);
  return D.18281;
}


sgen_find_optimized_pin_queue_area (void * start, void * end, int * num)
{
  int D.18284;
  void * * D.18287;
  void * * pin_queue.12;
  long unsigned int D.18289;
  long unsigned int D.18290;
  int first;
  int last;

  first = optimized_pin_queue_search (start);
  last = optimized_pin_queue_search (end);
  D.18284 = last - first;
  *num = D.18284;
  if (first == last) goto <D.18285>; else goto <D.18286>;
  <D.18285>:
  D.18287 = 0B;
  return D.18287;
  <D.18286>:
  pin_queue.12 = pin_queue;
  D.18289 = (long unsigned int) first;
  D.18290 = D.18289 * 8;
  D.18287 = pin_queue.12 + D.18290;
  return D.18287;
}


optimized_pin_queue_search (void * addr)
{
  int D.18292;
  int D.18293;
  void * * pin_queue.13;
  long unsigned int D.18295;
  long unsigned int D.18296;
  void * * D.18297;
  void * D.18298;
  _Bool D.18302;
  long int D.18303;
  long int D.18304;
  int D.18307;
  int first;
  int last;

  first = 0;
  last = next_pin_slot;
  goto <D.18127>;
  <D.18126>:
  {
    int middle;

    D.18292 = last - first;
    D.18293 = D.18292 >> 1;
    middle = D.18293 + first;
    pin_queue.13 = pin_queue;
    D.18295 = (long unsigned int) middle;
    D.18296 = D.18295 * 8;
    D.18297 = pin_queue.13 + D.18296;
    D.18298 = *D.18297;
    if (D.18298 >= addr) goto <D.18299>; else goto <D.18300>;
    <D.18299>:
    last = middle;
    goto <D.18301>;
    <D.18300>:
    first = middle + 1;
    <D.18301>:
  }
  <D.18127>:
  if (first < last) goto <D.18126>; else goto <D.18128>;
  <D.18128>:
  D.18302 = first != last;
  D.18303 = (long int) D.18302;
  D.18304 = __builtin_expect (D.18303, 0);
  if (D.18304 != 0) goto <D.18305>; else goto <D.18306>;
  <D.18305>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-pinning.c", 89, "first == last");
  <D.18306>:
  D.18307 = first;
  return D.18307;
}


sgen_find_section_pin_queue_start_end (struct GCMemSection * section)
{
  struct FILE * gc_debug_file.14;
  char * D.18312;
  char * D.18313;
  int * D.18314;
  void * * D.18315;
  int D.18318;

  if (0 != 0) goto <D.18309>; else goto <D.18310>;
  <D.18309>:
  gc_debug_file.14 = gc_debug_file;
  D.18312 = section->data;
  D.18313 = section->end_data;
  fprintf (gc_debug_file.14, "Pinning from section %p (%p-%p)\n", section, D.18312, D.18313);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.18310>:
  D.18312 = section->data;
  D.18313 = section->end_data;
  D.18314 = &section->pin_queue_num_entries;
  D.18315 = sgen_find_optimized_pin_queue_area (D.18312, D.18313, D.18314);
  section->pin_queue_start = D.18315;
  if (0 != 0) goto <D.18316>; else goto <D.18317>;
  <D.18316>:
  gc_debug_file.14 = gc_debug_file;
  D.18318 = section->pin_queue_num_entries;
  fprintf (gc_debug_file.14, "Found %d pinning addresses in section %p\n", D.18318, section);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.18317>:
}


sgen_pinning_setup_section (struct GCMemSection * section)
{
  void * * pin_queue.15;
  int next_pin_slot.16;

  pin_queue.15 = pin_queue;
  section->pin_queue_start = pin_queue.15;
  next_pin_slot.16 = next_pin_slot;
  section->pin_queue_num_entries = next_pin_slot.16;
}


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

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


sgen_pin_queue_clear_discarded_entries (struct GCMemSection * section, int max_pin_slot)
{
  void * * D.18322;
  int D.18323;
  long unsigned int D.18324;
  long unsigned int D.18325;
  void * * pin_queue.18;
  long unsigned int D.18327;
  long unsigned int D.18328;
  char * D.18331;
  char * D.18333;
  void * * start;
  void * * end;
  void * addr;

  D.18322 = section->pin_queue_start;
  D.18323 = section->pin_queue_num_entries;
  D.18324 = (long unsigned int) D.18323;
  D.18325 = D.18324 * 8;
  start = D.18322 + D.18325;
  pin_queue.18 = pin_queue;
  D.18327 = (long unsigned int) max_pin_slot;
  D.18328 = D.18327 * 8;
  end = pin_queue.18 + D.18328;
  if (start == 0B) goto <D.18329>; else goto <D.18330>;
  <D.18329>:
  return;
  <D.18330>:
  goto <D.18154>;
  <D.18153>:
  addr = *start;
  D.18331 = section->data;
  if (D.18331 > addr) goto <D.18152>; else goto <D.18332>;
  <D.18332>:
  D.18333 = section->end_data;
  if (D.18333 < addr) goto <D.18152>; else goto <D.18334>;
  <D.18334>:
  *start = 0B;
  start = start + 8;
  <D.18154>:
  if (start < end) goto <D.18153>; else goto <D.18152>;
  <D.18152>:
}


sgen_optimize_pin_queue (int start_slot)
{
  struct FILE * gc_debug_file.19;
  int next_pin_slot.20;
  int D.18340;
  void * * pin_queue.21;
  long unsigned int D.18344;
  long unsigned int D.18345;
  void * * D.18346;
  long unsigned int D.18347;
  long unsigned int D.18348;
  void * * cur.22;
  void * D.18350;
  void * D.18351;
  void * D.18352;
  long int start.23;
  long int pin_queue.24;
  long int D.18356;
  long int D.18357;
  int next_pin_slot.25;
  void * * start;
  void * * cur;
  void * * end;

  if (0 != 0) goto <D.18336>; else goto <D.18337>;
  <D.18336>:
  gc_debug_file.19 = gc_debug_file;
  next_pin_slot.20 = next_pin_slot;
  fprintf (gc_debug_file.19, "Sorting pin queue, size: %d\n", next_pin_slot.20);
  gc_debug_file.19 = gc_debug_file;
  fflush (gc_debug_file.19);
  <D.18337>:
  next_pin_slot.20 = next_pin_slot;
  D.18340 = next_pin_slot.20 - start_slot;
  if (D.18340 > 1) goto <D.18341>; else goto <D.18342>;
  <D.18341>:
  pin_queue.21 = pin_queue;
  D.18344 = (long unsigned int) start_slot;
  D.18345 = D.18344 * 8;
  D.18346 = pin_queue.21 + D.18345;
  next_pin_slot.20 = next_pin_slot;
  D.18340 = next_pin_slot.20 - start_slot;
  sgen_sort_addresses (D.18346, D.18340);
  <D.18342>:
  pin_queue.21 = pin_queue;
  D.18344 = (long unsigned int) start_slot;
  D.18345 = D.18344 * 8;
  cur = pin_queue.21 + D.18345;
  start = cur;
  pin_queue.21 = pin_queue;
  next_pin_slot.20 = next_pin_slot;
  D.18347 = (long unsigned int) next_pin_slot.20;
  D.18348 = D.18347 * 8;
  end = pin_queue.21 + D.18348;
  goto <D.18165>;
  <D.18164>:
  cur.22 = cur;
  cur = cur.22 + 8;
  D.18350 = *cur.22;
  *start = D.18350;
  goto <D.18162>;
  <D.18161>:
  cur = cur + 8;
  <D.18162>:
  D.18351 = *start;
  D.18352 = *cur;
  if (D.18351 == D.18352) goto <D.18353>; else goto <D.18163>;
  <D.18353>:
  if (cur < end) goto <D.18161>; else goto <D.18163>;
  <D.18163>:
  start = start + 8;
  <D.18165>:
  if (cur < end) goto <D.18164>; else goto <D.18166>;
  <D.18166>:
  start.23 = (long int) start;
  pin_queue.21 = pin_queue;
  pin_queue.24 = (long int) pin_queue.21;
  D.18356 = start.23 - pin_queue.24;
  D.18357 = D.18356 /[ex] 8;
  next_pin_slot.25 = (int) D.18357;
  next_pin_slot = next_pin_slot.25;
  if (0 != 0) goto <D.18359>; else goto <D.18360>;
  <D.18359>:
  gc_debug_file.19 = gc_debug_file;
  next_pin_slot.20 = next_pin_slot;
  fprintf (gc_debug_file.19, "Pin queue reduced to size: %d\n", next_pin_slot.20);
  gc_debug_file.19 = gc_debug_file;
  fflush (gc_debug_file.19);
  <D.18360>:
}


sgen_get_pinned_count ()
{
  int D.18361;

  D.18361 = next_pin_slot;
  return D.18361;
}


sgen_dump_pin_queue ()
{
  struct FILE * gc_debug_file.26;
  void * * pin_queue.27;
  long unsigned int D.18367;
  long unsigned int D.18368;
  void * * D.18369;
  void * D.18370;
  const char * D.18371;
  unsigned int D.18372;
  int last_num_pinned.28;
  int i;

  i = 0;
  goto <D.18175>;
  <D.18174>:
  if (0 != 0) goto <D.18363>; else goto <D.18364>;
  <D.18363>:
  gc_debug_file.26 = gc_debug_file;
  pin_queue.27 = pin_queue;
  D.18367 = (long unsigned int) i;
  D.18368 = D.18367 * 8;
  D.18369 = pin_queue.27 + D.18368;
  D.18370 = *D.18369;
  pin_queue.27 = pin_queue;
  D.18367 = (long unsigned int) i;
  D.18368 = D.18367 * 8;
  D.18369 = pin_queue.27 + D.18368;
  D.18370 = *D.18369;
  D.18371 = sgen_safe_name (D.18370);
  pin_queue.27 = pin_queue;
  D.18367 = (long unsigned int) i;
  D.18368 = D.18367 * 8;
  D.18369 = pin_queue.27 + D.18368;
  D.18370 = *D.18369;
  D.18372 = sgen_safe_object_get_size (D.18370);
  fprintf (gc_debug_file.26, "Bastard pinning obj %p (%s), size: %d\n", D.18370, D.18371, D.18372);
  gc_debug_file.26 = gc_debug_file;
  fflush (gc_debug_file.26);
  <D.18364>:
  i = i + 1;
  <D.18175>:
  last_num_pinned.28 = last_num_pinned;
  if (i < last_num_pinned.28) goto <D.18174>; else goto <D.18176>;
  <D.18176>:
}


sgen_cement_init (gboolean enabled)
{
  cement_enabled = enabled;
}


sgen_cement_reset ()
{
  int cement_concurrent.29;
  _Bool D.18375;
  long int D.18376;
  long int D.18377;

  cement_concurrent.29 = cement_concurrent;
  D.18375 = cement_concurrent.29 != 0;
  D.18376 = (long int) D.18375;
  D.18377 = __builtin_expect (D.18376, 0);
  if (D.18377 != 0) goto <D.18378>; else goto <D.18379>;
  <D.18378>:
  monoeg_g_log (0B, 4, "Concurrent cementing cannot simply be reset");
  <D.18191>:
  goto <D.18191>;
  <D.18379>:
  memset (&cement_hash, 0, 976);
}


sgen_cement_concurrent_start ()
{
  int cement_concurrent.30;
  _Bool D.18381;
  long int D.18382;
  long int D.18383;

  cement_concurrent.30 = cement_concurrent;
  D.18381 = cement_concurrent.30 != 0;
  D.18382 = (long int) D.18381;
  D.18383 = __builtin_expect (D.18382, 0);
  if (D.18383 != 0) goto <D.18384>; else goto <D.18385>;
  <D.18384>:
  monoeg_g_log (0B, 4, "Concurrent cementing has already been started");
  <D.18195>:
  goto <D.18195>;
  <D.18385>:
  cement_concurrent = 1;
  memset (&cement_hash_concurrent, 0, 976);
}


sgen_cement_concurrent_finish ()
{
  int cement_concurrent.31;
  _Bool D.18387;
  long int D.18388;
  long int D.18389;

  cement_concurrent.31 = cement_concurrent;
  D.18387 = cement_concurrent.31 == 0;
  D.18388 = (long int) D.18387;
  D.18389 = __builtin_expect (D.18388, 0);
  if (D.18389 != 0) goto <D.18390>; else goto <D.18391>;
  <D.18390>:
  monoeg_g_log (0B, 4, "Concurrent cementing hasn\'t been started");
  <D.18199>:
  goto <D.18199>;
  <D.18391>:
  cement_concurrent = 0;
  memcpy (&cement_hash, &cement_hash_concurrent, 976);
}


sgen_cement_lookup (char * obj)
{
  unsigned int D.18392;
  unsigned int D.18393;
  int D.18394;
  _Bool D.18395;
  long int D.18396;
  long int D.18397;
  int cement_enabled.32;
  gboolean D.18403;
  char * D.18404;
  unsigned int D.18409;
  _Bool D.18410;
  int i;

  D.18392 = mono_aligned_addr_hash (obj);
  D.18393 = D.18392 % 61;
  i = (int) D.18393;
  D.18394 = sgen_ptr_in_nursery (obj);
  D.18395 = D.18394 == 0;
  D.18396 = (long int) D.18395;
  D.18397 = __builtin_expect (D.18396, 0);
  if (D.18397 != 0) goto <D.18398>; else goto <D.18399>;
  <D.18398>:
  monoeg_g_log (0B, 4, "Looking up cementing for non-nursery objects makes no sense");
  <D.18204>:
  goto <D.18204>;
  <D.18399>:
  cement_enabled.32 = cement_enabled;
  if (cement_enabled.32 == 0) goto <D.18401>; else goto <D.18402>;
  <D.18401>:
  D.18403 = 0;
  return D.18403;
  <D.18402>:
  D.18404 = cement_hash[i].obj;
  if (D.18404 == 0B) goto <D.18405>; else goto <D.18406>;
  <D.18405>:
  D.18403 = 0;
  return D.18403;
  <D.18406>:
  D.18404 = cement_hash[i].obj;
  if (D.18404 != obj) goto <D.18407>; else goto <D.18408>;
  <D.18407>:
  D.18403 = 0;
  return D.18403;
  <D.18408>:
  D.18409 = cement_hash[i].count;
  D.18410 = D.18409 > 999;
  D.18403 = (gboolean) D.18410;
  return D.18403;
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.18412;
  int sgen_nursery_bits.33;
  int D.18414;
  int D.18415;
  long unsigned int D.18416;
  long unsigned int p.34;
  long unsigned int D.18418;
  char * sgen_nursery_start.35;
  long unsigned int sgen_nursery_start.36;
  _Bool D.18421;

  sgen_nursery_bits.33 = sgen_nursery_bits;
  D.18414 = 1 << sgen_nursery_bits.33;
  D.18415 = -D.18414;
  D.18416 = (long unsigned int) D.18415;
  p.34 = (long unsigned int) p;
  D.18418 = D.18416 & p.34;
  sgen_nursery_start.35 = sgen_nursery_start;
  sgen_nursery_start.36 = (long unsigned int) sgen_nursery_start.35;
  D.18421 = D.18418 == sgen_nursery_start.36;
  D.18412 = (gboolean) D.18421;
  return D.18412;
}


sgen_cement_lookup_or_register (char * obj)
{
  int cement_enabled.37;
  gboolean D.18426;
  int cement_concurrent.38;
  _Bool D.18430;
  long int D.18431;
  long int D.18432;
  unsigned int D.18438;
  unsigned int D.18439;
  int D.18440;
  _Bool D.18441;
  long int D.18442;
  long int D.18443;
  long unsigned int D.18446;
  long unsigned int D.18447;
  struct CementHashEntry * D.18448;
  char * D.18449;
  unsigned int D.18452;
  _Bool D.18453;
  long int D.18454;
  long int D.18455;
  unsigned int D.18463;
  long unsigned int D.18468;
  long unsigned int D.18469;
  int i;
  struct CementHashEntry * hash;
  gboolean concurrent_cementing;

  concurrent_cementing = sgen_concurrent_collection_in_progress ();
  cement_enabled.37 = cement_enabled;
  if (cement_enabled.37 == 0) goto <D.18424>; else goto <D.18425>;
  <D.18424>:
  D.18426 = 0;
  return D.18426;
  <D.18425>:
  if (concurrent_cementing != 0) goto <D.18427>; else goto <D.18428>;
  <D.18427>:
  cement_concurrent.38 = cement_concurrent;
  D.18430 = cement_concurrent.38 == 0;
  D.18431 = (long int) D.18430;
  D.18432 = __builtin_expect (D.18431, 0);
  if (D.18432 != 0) goto <D.18433>; else goto <D.18434>;
  <D.18433>:
  monoeg_g_log (0B, 4, "Cementing wasn\'t inited with concurrent flag");
  <D.18211>:
  goto <D.18211>;
  <D.18434>:
  <D.18428>:
  if (concurrent_cementing != 0) goto <D.18435>; else goto <D.18436>;
  <D.18435>:
  hash = &cement_hash_concurrent;
  goto <D.18437>;
  <D.18436>:
  hash = &cement_hash;
  <D.18437>:
  D.18438 = mono_aligned_addr_hash (obj);
  D.18439 = D.18438 % 61;
  i = (int) D.18439;
  D.18440 = sgen_ptr_in_nursery (obj);
  D.18441 = D.18440 == 0;
  D.18442 = (long int) D.18441;
  D.18443 = __builtin_expect (D.18442, 0);
  if (D.18443 != 0) goto <D.18444>; else goto <D.18445>;
  <D.18444>:
  monoeg_g_log (0B, 4, "Can only cement pointers to nursery objects");
  <D.18212>:
  goto <D.18212>;
  <D.18445>:
  D.18446 = (long unsigned int) i;
  D.18447 = D.18446 * 16;
  D.18448 = hash + D.18447;
  D.18449 = D.18448->obj;
  if (D.18449 == 0B) goto <D.18450>; else goto <D.18451>;
  <D.18450>:
  D.18446 = (long unsigned int) i;
  D.18447 = D.18446 * 16;
  D.18448 = hash + D.18447;
  D.18452 = D.18448->count;
  D.18453 = D.18452 != 0;
  D.18454 = (long int) D.18453;
  D.18455 = __builtin_expect (D.18454, 0);
  if (D.18455 != 0) goto <D.18456>; else goto <D.18457>;
  <D.18456>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.18213>:
  goto <D.18213>;
  <D.18457>:
  D.18446 = (long unsigned int) i;
  D.18447 = D.18446 * 16;
  D.18448 = hash + D.18447;
  D.18448->obj = obj;
  goto <D.18458>;
  <D.18451>:
  D.18446 = (long unsigned int) i;
  D.18447 = D.18446 * 16;
  D.18448 = hash + D.18447;
  D.18449 = D.18448->obj;
  if (D.18449 != obj) goto <D.18459>; else goto <D.18460>;
  <D.18459>:
  D.18426 = 0;
  return D.18426;
  <D.18460>:
  <D.18458>:
  D.18446 = (long unsigned int) i;
  D.18447 = D.18446 * 16;
  D.18448 = hash + D.18447;
  D.18452 = D.18448->count;
  if (D.18452 > 999) goto <D.18461>; else goto <D.18462>;
  <D.18461>:
  D.18426 = 1;
  return D.18426;
  <D.18462>:
  D.18446 = (long unsigned int) i;
  D.18447 = D.18446 * 16;
  D.18448 = hash + D.18447;
  D.18452 = D.18448->count;
  D.18463 = D.18452 + 1;
  D.18448->count = D.18463;
  D.18446 = (long unsigned int) i;
  D.18447 = D.18446 * 16;
  D.18448 = hash + D.18447;
  D.18452 = D.18448->count;
  if (D.18452 == 1000) goto <D.18464>; else goto <D.18465>;
  <D.18464>:
  if (0 != 0) goto <D.18466>; else goto <D.18467>;
  <D.18466>:
  {
    struct MonoVTable * vt;

    D.18468 = MEM[(mword *)obj];
    D.18469 = D.18468 & 18446744073709551612;
    vt = (struct MonoVTable *) D.18469;
  }
  <D.18467>:
  <D.18465>:
  D.18426 = 0;
  return D.18426;
}


sgen_cement_iterate (void (*IterateObjectCallbackFunc) (char *, size_t, void *) callback, void * callback_data)
{
  unsigned int D.18471;
  _Bool D.18474;
  long int D.18475;
  long int D.18476;
  char * D.18479;
  int i;

  i = 0;
  goto <D.18223>;
  <D.18222>:
  D.18471 = cement_hash[i].count;
  if (D.18471 == 0) goto <D.18472>; else goto <D.18473>;
  <D.18472>:
  // predicted unlikely by continue predictor.
  goto <D.18220>;
  <D.18473>:
  D.18471 = cement_hash[i].count;
  D.18474 = D.18471 <= 999;
  D.18475 = (long int) D.18474;
  D.18476 = __builtin_expect (D.18475, 0);
  if (D.18476 != 0) goto <D.18477>; else goto <D.18478>;
  <D.18477>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.18221>:
  goto <D.18221>;
  <D.18478>:
  D.18479 = cement_hash[i].obj;
  callback (D.18479, 0, callback_data);
  <D.18220>:
  i = i + 1;
  <D.18223>:
  if (i <= 60) goto <D.18222>; else goto <D.18224>;
  <D.18224>:
}


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

  i = 0;
  goto <D.18230>;
  <D.18229>:
  D.18480 = cement_hash[i].count;
  if (D.18480 <= 999) goto <D.18481>; else goto <D.18482>;
  <D.18481>:
  cement_hash[i].obj = 0B;
  cement_hash[i].count = 0;
  <D.18482>:
  i = i + 1;
  <D.18230>:
  if (i <= 60) goto <D.18229>; else goto <D.18231>;
  <D.18231>:
}