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


memset (void * __dest, int __ch, size_t __len)
{
  int D.17322;
  int D.17327;
  void * D.17329;
  unsigned int D.17330;

  D.17322 = __builtin_constant_p (__len);
  if (D.17322 != 0) goto <D.17323>; else goto <D.17324>;
  <D.17323>:
  if (__len == 0) goto <D.17325>; else goto <D.17326>;
  <D.17325>:
  D.17327 = __builtin_constant_p (__ch);
  if (D.17327 == 0) goto <D.17320>; else goto <D.17328>;
  <D.17328>:
  if (__ch != 0) goto <D.17320>; else goto <D.17321>;
  <D.17320>:
  __warn_memset_zero_len ();
  D.17329 = __dest;
  return D.17329;
  <D.17321>:
  <D.17326>:
  <D.17324>:
  D.17330 = __builtin_object_size (__dest, 0);
  D.17329 = __builtin___memset_chk (__dest, __ch, __len, D.17330);
  return D.17329;
}


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.17334;
  int D.17335;
  void * D.17336;
  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.17347;
  void * * D.17348;
  int hash_idx;

  ptr.1 = (unsigned int) ptr;
  D.17334 = ptr.1 * 1737350767;
  D.17335 = (int) D.17334;
  hash_idx = D.17335 & 1023;
  D.17336 = pin_hash_filter[hash_idx];
  if (D.17336 == ptr) goto <D.17337>; else goto <D.17338>;
  <D.17337>:
  return;
  <D.17338>:
  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.17341>; else goto <D.17342>;
  <D.17341>:
  realloc_pin_queue ();
  <D.17342>:
  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.17347 = next_pin_slot.7 * 4;
  D.17348 = pin_queue.4 + D.17347;
  *D.17348 = ptr;
}


realloc_pin_queue ()
{
  int iftmp.8;
  int pin_queue_size.9;
  int D.17354;
  unsigned int new_size.10;
  unsigned int D.17357;
  void * * pin_queue.11;
  int next_pin_slot.12;
  unsigned int next_pin_slot.13;
  unsigned int D.17361;
  unsigned int pin_queue_size.14;
  unsigned int D.17363;
  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.17352>; else goto <D.17353>;
  <D.17352>:
  pin_queue_size.9 = pin_queue_size;
  D.17354 = pin_queue_size.9 / 2;
  pin_queue_size.9 = pin_queue_size;
  iftmp.8 = D.17354 + pin_queue_size.9;
  goto <D.17355>;
  <D.17353>:
  iftmp.8 = 1024;
  <D.17355>:
  new_size = iftmp.8;
  new_size.10 = (unsigned int) new_size;
  D.17357 = new_size.10 * 4;
  new_pin = sgen_alloc_internal_dynamic (D.17357, 0, 1);
  pin_queue.11 = pin_queue;
  next_pin_slot.12 = next_pin_slot;
  next_pin_slot.13 = (unsigned int) next_pin_slot.12;
  D.17361 = next_pin_slot.13 * 4;
  memcpy (new_pin, pin_queue.11, D.17361);
  pin_queue.11 = pin_queue;
  pin_queue_size.9 = pin_queue_size;
  pin_queue_size.14 = (unsigned int) pin_queue_size.9;
  D.17363 = pin_queue_size.14 * 4;
  sgen_free_internal_dynamic (pin_queue.11, D.17363, 0);
  pin_queue = new_pin;
  pin_queue_size = new_size;
  if (0 != 0) goto <D.17364>; else goto <D.17365>;
  <D.17364>:
  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.17365>:
}


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

  D.17368 = __builtin_object_size (__dest, 0);
  D.17367 = __builtin___memcpy_chk (__dest, __src, __len, D.17368);
  return D.17367;
}


sgen_find_optimized_pin_queue_area (void * start, void * end, int * num)
{
  int D.17370;
  void * * D.17373;
  void * * pin_queue.16;
  unsigned int first.17;
  unsigned int D.17376;
  int first;
  int last;

  first = optimized_pin_queue_search (start);
  last = optimized_pin_queue_search (end);
  D.17370 = last - first;
  *num = D.17370;
  if (first == last) goto <D.17371>; else goto <D.17372>;
  <D.17371>:
  D.17373 = 0B;
  return D.17373;
  <D.17372>:
  pin_queue.16 = pin_queue;
  first.17 = (unsigned int) first;
  D.17376 = first.17 * 4;
  D.17373 = pin_queue.16 + D.17376;
  return D.17373;
}


optimized_pin_queue_search (void * addr)
{
  int D.17378;
  int D.17379;
  void * * pin_queue.18;
  unsigned int middle.19;
  unsigned int D.17382;
  void * * D.17383;
  void * D.17384;
  _Bool D.17388;
  long int D.17389;
  long int D.17390;
  int D.17393;
  int first;
  int last;

  first = 0;
  last = next_pin_slot;
  goto <D.17214>;
  <D.17213>:
  {
    int middle;

    D.17378 = last - first;
    D.17379 = D.17378 >> 1;
    middle = D.17379 + first;
    pin_queue.18 = pin_queue;
    middle.19 = (unsigned int) middle;
    D.17382 = middle.19 * 4;
    D.17383 = pin_queue.18 + D.17382;
    D.17384 = *D.17383;
    if (D.17384 >= addr) goto <D.17385>; else goto <D.17386>;
    <D.17385>:
    last = middle;
    goto <D.17387>;
    <D.17386>:
    first = middle + 1;
    <D.17387>:
  }
  <D.17214>:
  if (first < last) goto <D.17213>; else goto <D.17215>;
  <D.17215>:
  D.17388 = first != last;
  D.17389 = (long int) D.17388;
  D.17390 = __builtin_expect (D.17389, 0);
  if (D.17390 != 0) goto <D.17391>; else goto <D.17392>;
  <D.17391>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-pinning.c", 89, "first == last");
  <D.17392>:
  D.17393 = first;
  return D.17393;
}


sgen_find_section_pin_queue_start_end (struct GCMemSection * section)
{
  struct FILE * gc_debug_file.20;
  char * D.17398;
  char * D.17399;
  int * D.17400;
  void * * D.17401;
  int D.17404;

  if (0 != 0) goto <D.17395>; else goto <D.17396>;
  <D.17395>:
  gc_debug_file.20 = gc_debug_file;
  D.17398 = section->data;
  D.17399 = section->end_data;
  fprintf (gc_debug_file.20, "Pinning from section %p (%p-%p)\n", section, D.17398, D.17399);
  gc_debug_file.20 = gc_debug_file;
  fflush (gc_debug_file.20);
  <D.17396>:
  D.17398 = section->data;
  D.17399 = section->end_data;
  D.17400 = &section->pin_queue_num_entries;
  D.17401 = sgen_find_optimized_pin_queue_area (D.17398, D.17399, D.17400);
  section->pin_queue_start = D.17401;
  if (0 != 0) goto <D.17402>; else goto <D.17403>;
  <D.17402>:
  gc_debug_file.20 = gc_debug_file;
  D.17404 = section->pin_queue_num_entries;
  fprintf (gc_debug_file.20, "Found %d pinning addresses in section %p\n", D.17404, section);
  gc_debug_file.20 = gc_debug_file;
  fflush (gc_debug_file.20);
  <D.17403>:
}


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.17408;
  int D.17409;
  unsigned int D.17410;
  unsigned int D.17411;
  void * * pin_queue.24;
  unsigned int max_pin_slot.25;
  unsigned int D.17414;
  char * D.17417;
  char * D.17419;
  void * * start;
  void * * end;
  void * addr;

  D.17408 = section->pin_queue_start;
  D.17409 = section->pin_queue_num_entries;
  D.17410 = (unsigned int) D.17409;
  D.17411 = D.17410 * 4;
  start = D.17408 + D.17411;
  pin_queue.24 = pin_queue;
  max_pin_slot.25 = (unsigned int) max_pin_slot;
  D.17414 = max_pin_slot.25 * 4;
  end = pin_queue.24 + D.17414;
  if (start == 0B) goto <D.17415>; else goto <D.17416>;
  <D.17415>:
  return;
  <D.17416>:
  goto <D.17241>;
  <D.17240>:
  addr = *start;
  D.17417 = section->data;
  if (D.17417 > addr) goto <D.17239>; else goto <D.17418>;
  <D.17418>:
  D.17419 = section->end_data;
  if (D.17419 < addr) goto <D.17239>; else goto <D.17420>;
  <D.17420>:
  *start = 0B;
  start = start + 4;
  <D.17241>:
  if (start < end) goto <D.17240>; else goto <D.17239>;
  <D.17239>:
}


sgen_optimize_pin_queue (int start_slot)
{
  struct FILE * gc_debug_file.26;
  int next_pin_slot.27;
  int D.17426;
  void * * pin_queue.28;
  unsigned int start_slot.29;
  unsigned int D.17431;
  void * * D.17432;
  unsigned int next_pin_slot.30;
  unsigned int D.17434;
  void * * cur.31;
  void * D.17436;
  void * D.17437;
  void * D.17438;
  int start.32;
  int pin_queue.33;
  int D.17442;
  int next_pin_slot.34;
  void * * start;
  void * * cur;
  void * * end;

  if (0 != 0) goto <D.17422>; else goto <D.17423>;
  <D.17422>:
  gc_debug_file.26 = gc_debug_file;
  next_pin_slot.27 = next_pin_slot;
  fprintf (gc_debug_file.26, "Sorting pin queue, size: %d\n", next_pin_slot.27);
  gc_debug_file.26 = gc_debug_file;
  fflush (gc_debug_file.26);
  <D.17423>:
  next_pin_slot.27 = next_pin_slot;
  D.17426 = next_pin_slot.27 - start_slot;
  if (D.17426 > 1) goto <D.17427>; else goto <D.17428>;
  <D.17427>:
  pin_queue.28 = pin_queue;
  start_slot.29 = (unsigned int) start_slot;
  D.17431 = start_slot.29 * 4;
  D.17432 = pin_queue.28 + D.17431;
  next_pin_slot.27 = next_pin_slot;
  D.17426 = next_pin_slot.27 - start_slot;
  sgen_sort_addresses (D.17432, D.17426);
  <D.17428>:
  pin_queue.28 = pin_queue;
  start_slot.29 = (unsigned int) start_slot;
  D.17431 = start_slot.29 * 4;
  cur = pin_queue.28 + D.17431;
  start = cur;
  pin_queue.28 = pin_queue;
  next_pin_slot.27 = next_pin_slot;
  next_pin_slot.30 = (unsigned int) next_pin_slot.27;
  D.17434 = next_pin_slot.30 * 4;
  end = pin_queue.28 + D.17434;
  goto <D.17252>;
  <D.17251>:
  cur.31 = cur;
  cur = cur.31 + 4;
  D.17436 = *cur.31;
  *start = D.17436;
  goto <D.17249>;
  <D.17248>:
  cur = cur + 4;
  <D.17249>:
  D.17437 = *start;
  D.17438 = *cur;
  if (D.17437 == D.17438) goto <D.17439>; else goto <D.17250>;
  <D.17439>:
  if (cur < end) goto <D.17248>; else goto <D.17250>;
  <D.17250>:
  start = start + 4;
  <D.17252>:
  if (cur < end) goto <D.17251>; else goto <D.17253>;
  <D.17253>:
  start.32 = (int) start;
  pin_queue.28 = pin_queue;
  pin_queue.33 = (int) pin_queue.28;
  D.17442 = start.32 - pin_queue.33;
  next_pin_slot.34 = D.17442 /[ex] 4;
  next_pin_slot = next_pin_slot.34;
  if (0 != 0) goto <D.17444>; else goto <D.17445>;
  <D.17444>:
  gc_debug_file.26 = gc_debug_file;
  next_pin_slot.27 = next_pin_slot;
  fprintf (gc_debug_file.26, "Pin queue reduced to size: %d\n", next_pin_slot.27);
  gc_debug_file.26 = gc_debug_file;
  fflush (gc_debug_file.26);
  <D.17445>:
}


sgen_get_pinned_count ()
{
  int D.17446;

  D.17446 = next_pin_slot;
  return D.17446;
}


sgen_dump_pin_queue ()
{
  struct FILE * gc_debug_file.35;
  void * * pin_queue.36;
  unsigned int i.37;
  unsigned int D.17453;
  void * * D.17454;
  void * D.17455;
  const char * D.17456;
  unsigned int D.17457;
  int last_num_pinned.38;
  int i;

  i = 0;
  goto <D.17262>;
  <D.17261>:
  if (0 != 0) goto <D.17448>; else goto <D.17449>;
  <D.17448>:
  gc_debug_file.35 = gc_debug_file;
  pin_queue.36 = pin_queue;
  i.37 = (unsigned int) i;
  D.17453 = i.37 * 4;
  D.17454 = pin_queue.36 + D.17453;
  D.17455 = *D.17454;
  pin_queue.36 = pin_queue;
  i.37 = (unsigned int) i;
  D.17453 = i.37 * 4;
  D.17454 = pin_queue.36 + D.17453;
  D.17455 = *D.17454;
  D.17456 = sgen_safe_name (D.17455);
  pin_queue.36 = pin_queue;
  i.37 = (unsigned int) i;
  D.17453 = i.37 * 4;
  D.17454 = pin_queue.36 + D.17453;
  D.17455 = *D.17454;
  D.17457 = sgen_safe_object_get_size (D.17455);
  fprintf (gc_debug_file.35, "Bastard pinning obj %p (%s), size: %d\n", D.17455, D.17456, D.17457);
  gc_debug_file.35 = gc_debug_file;
  fflush (gc_debug_file.35);
  <D.17449>:
  i = i + 1;
  <D.17262>:
  last_num_pinned.38 = last_num_pinned;
  if (i < last_num_pinned.38) goto <D.17261>; else goto <D.17263>;
  <D.17263>:
}


sgen_cement_init (gboolean enabled)
{
  cement_enabled = enabled;
}


sgen_cement_reset ()
{
  int cement_concurrent.39;
  _Bool D.17460;
  long int D.17461;
  long int D.17462;

  cement_concurrent.39 = cement_concurrent;
  D.17460 = cement_concurrent.39 != 0;
  D.17461 = (long int) D.17460;
  D.17462 = __builtin_expect (D.17461, 0);
  if (D.17462 != 0) goto <D.17463>; else goto <D.17464>;
  <D.17463>:
  monoeg_g_log (0B, 4, "Concurrent cementing cannot simply be reset");
  <D.17278>:
  goto <D.17278>;
  <D.17464>:
  memset (&cement_hash, 0, 488);
}


sgen_cement_concurrent_start ()
{
  int cement_concurrent.40;
  _Bool D.17466;
  long int D.17467;
  long int D.17468;

  cement_concurrent.40 = cement_concurrent;
  D.17466 = cement_concurrent.40 != 0;
  D.17467 = (long int) D.17466;
  D.17468 = __builtin_expect (D.17467, 0);
  if (D.17468 != 0) goto <D.17469>; else goto <D.17470>;
  <D.17469>:
  monoeg_g_log (0B, 4, "Concurrent cementing has already been started");
  <D.17282>:
  goto <D.17282>;
  <D.17470>:
  cement_concurrent = 1;
  memset (&cement_hash_concurrent, 0, 488);
}


sgen_cement_concurrent_finish ()
{
  int cement_concurrent.41;
  _Bool D.17472;
  long int D.17473;
  long int D.17474;

  cement_concurrent.41 = cement_concurrent;
  D.17472 = cement_concurrent.41 == 0;
  D.17473 = (long int) D.17472;
  D.17474 = __builtin_expect (D.17473, 0);
  if (D.17474 != 0) goto <D.17475>; else goto <D.17476>;
  <D.17475>:
  monoeg_g_log (0B, 4, "Concurrent cementing hasn\'t been started");
  <D.17286>:
  goto <D.17286>;
  <D.17476>:
  cement_concurrent = 0;
  memcpy (&cement_hash, &cement_hash_concurrent, 488);
}


sgen_cement_lookup (char * obj)
{
  unsigned int D.17477;
  unsigned int D.17478;
  int D.17479;
  _Bool D.17480;
  long int D.17481;
  long int D.17482;
  int cement_enabled.42;
  gboolean D.17488;
  char * D.17489;
  unsigned int D.17494;
  _Bool D.17495;
  int i;

  D.17477 = mono_aligned_addr_hash (obj);
  D.17478 = D.17477 % 61;
  i = (int) D.17478;
  D.17479 = sgen_ptr_in_nursery (obj);
  D.17480 = D.17479 == 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, "Looking up cementing for non-nursery objects makes no sense");
  <D.17291>:
  goto <D.17291>;
  <D.17484>:
  cement_enabled.42 = cement_enabled;
  if (cement_enabled.42 == 0) goto <D.17486>; else goto <D.17487>;
  <D.17486>:
  D.17488 = 0;
  return D.17488;
  <D.17487>:
  D.17489 = cement_hash[i].obj;
  if (D.17489 == 0B) goto <D.17490>; else goto <D.17491>;
  <D.17490>:
  D.17488 = 0;
  return D.17488;
  <D.17491>:
  D.17489 = cement_hash[i].obj;
  if (D.17489 != obj) goto <D.17492>; else goto <D.17493>;
  <D.17492>:
  D.17488 = 0;
  return D.17488;
  <D.17493>:
  D.17494 = cement_hash[i].count;
  D.17495 = D.17494 > 999;
  D.17488 = (gboolean) D.17495;
  return D.17488;
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.17497;
  int sgen_nursery_bits.43;
  int D.17499;
  int D.17500;
  unsigned int D.17501;
  unsigned int p.44;
  unsigned int D.17503;
  char * sgen_nursery_start.45;
  unsigned int sgen_nursery_start.46;
  _Bool D.17506;

  sgen_nursery_bits.43 = sgen_nursery_bits;
  D.17499 = 1 << sgen_nursery_bits.43;
  D.17500 = -D.17499;
  D.17501 = (unsigned int) D.17500;
  p.44 = (unsigned int) p;
  D.17503 = D.17501 & p.44;
  sgen_nursery_start.45 = sgen_nursery_start;
  sgen_nursery_start.46 = (unsigned int) sgen_nursery_start.45;
  D.17506 = D.17503 == sgen_nursery_start.46;
  D.17497 = (gboolean) D.17506;
  return D.17497;
}


sgen_cement_lookup_or_register (char * obj)
{
  int cement_enabled.47;
  gboolean D.17511;
  int cement_concurrent.48;
  _Bool D.17515;
  long int D.17516;
  long int D.17517;
  unsigned int D.17523;
  unsigned int D.17524;
  int D.17525;
  _Bool D.17526;
  long int D.17527;
  long int D.17528;
  unsigned int i.49;
  unsigned int D.17532;
  struct CementHashEntry * D.17533;
  char * D.17534;
  unsigned int D.17537;
  _Bool D.17538;
  long int D.17539;
  long int D.17540;
  unsigned int D.17548;
  unsigned int D.17553;
  unsigned int D.17554;
  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.17509>; else goto <D.17510>;
  <D.17509>:
  D.17511 = 0;
  return D.17511;
  <D.17510>:
  if (concurrent_cementing != 0) goto <D.17512>; else goto <D.17513>;
  <D.17512>:
  cement_concurrent.48 = cement_concurrent;
  D.17515 = cement_concurrent.48 == 0;
  D.17516 = (long int) D.17515;
  D.17517 = __builtin_expect (D.17516, 0);
  if (D.17517 != 0) goto <D.17518>; else goto <D.17519>;
  <D.17518>:
  monoeg_g_log (0B, 4, "Cementing wasn\'t inited with concurrent flag");
  <D.17298>:
  goto <D.17298>;
  <D.17519>:
  <D.17513>:
  if (concurrent_cementing != 0) goto <D.17520>; else goto <D.17521>;
  <D.17520>:
  hash = &cement_hash_concurrent;
  goto <D.17522>;
  <D.17521>:
  hash = &cement_hash;
  <D.17522>:
  D.17523 = mono_aligned_addr_hash (obj);
  D.17524 = D.17523 % 61;
  i = (int) D.17524;
  D.17525 = sgen_ptr_in_nursery (obj);
  D.17526 = D.17525 == 0;
  D.17527 = (long int) D.17526;
  D.17528 = __builtin_expect (D.17527, 0);
  if (D.17528 != 0) goto <D.17529>; else goto <D.17530>;
  <D.17529>:
  monoeg_g_log (0B, 4, "Can only cement pointers to nursery objects");
  <D.17299>:
  goto <D.17299>;
  <D.17530>:
  i.49 = (unsigned int) i;
  D.17532 = i.49 * 8;
  D.17533 = hash + D.17532;
  D.17534 = D.17533->obj;
  if (D.17534 == 0B) goto <D.17535>; else goto <D.17536>;
  <D.17535>:
  i.49 = (unsigned int) i;
  D.17532 = i.49 * 8;
  D.17533 = hash + D.17532;
  D.17537 = D.17533->count;
  D.17538 = D.17537 != 0;
  D.17539 = (long int) D.17538;
  D.17540 = __builtin_expect (D.17539, 0);
  if (D.17540 != 0) goto <D.17541>; else goto <D.17542>;
  <D.17541>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.17300>:
  goto <D.17300>;
  <D.17542>:
  i.49 = (unsigned int) i;
  D.17532 = i.49 * 8;
  D.17533 = hash + D.17532;
  D.17533->obj = obj;
  goto <D.17543>;
  <D.17536>:
  i.49 = (unsigned int) i;
  D.17532 = i.49 * 8;
  D.17533 = hash + D.17532;
  D.17534 = D.17533->obj;
  if (D.17534 != obj) goto <D.17544>; else goto <D.17545>;
  <D.17544>:
  D.17511 = 0;
  return D.17511;
  <D.17545>:
  <D.17543>:
  i.49 = (unsigned int) i;
  D.17532 = i.49 * 8;
  D.17533 = hash + D.17532;
  D.17537 = D.17533->count;
  if (D.17537 > 999) goto <D.17546>; else goto <D.17547>;
  <D.17546>:
  D.17511 = 1;
  return D.17511;
  <D.17547>:
  i.49 = (unsigned int) i;
  D.17532 = i.49 * 8;
  D.17533 = hash + D.17532;
  D.17537 = D.17533->count;
  D.17548 = D.17537 + 1;
  D.17533->count = D.17548;
  i.49 = (unsigned int) i;
  D.17532 = i.49 * 8;
  D.17533 = hash + D.17532;
  D.17537 = D.17533->count;
  if (D.17537 == 1000) goto <D.17549>; else goto <D.17550>;
  <D.17549>:
  if (0 != 0) goto <D.17551>; else goto <D.17552>;
  <D.17551>:
  {
    struct MonoVTable * vt;

    D.17553 = MEM[(mword *)obj];
    D.17554 = D.17553 & 4294967292;
    vt = (struct MonoVTable *) D.17554;
  }
  <D.17552>:
  <D.17550>:
  D.17511 = 0;
  return D.17511;
}


sgen_cement_iterate (void (*IterateObjectCallbackFunc) (char *, size_t, void *) callback, void * callback_data)
{
  unsigned int D.17556;
  _Bool D.17559;
  long int D.17560;
  long int D.17561;
  char * D.17564;
  int i;

  i = 0;
  goto <D.17310>;
  <D.17309>:
  D.17556 = cement_hash[i].count;
  if (D.17556 == 0) goto <D.17557>; else goto <D.17558>;
  <D.17557>:
  // predicted unlikely by continue predictor.
  goto <D.17307>;
  <D.17558>:
  D.17556 = cement_hash[i].count;
  D.17559 = D.17556 <= 999;
  D.17560 = (long int) D.17559;
  D.17561 = __builtin_expect (D.17560, 0);
  if (D.17561 != 0) goto <D.17562>; else goto <D.17563>;
  <D.17562>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.17308>:
  goto <D.17308>;
  <D.17563>:
  D.17564 = cement_hash[i].obj;
  callback (D.17564, 0, callback_data);
  <D.17307>:
  i = i + 1;
  <D.17310>:
  if (i <= 60) goto <D.17309>; else goto <D.17311>;
  <D.17311>:
}


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

  i = 0;
  goto <D.17317>;
  <D.17316>:
  D.17565 = cement_hash[i].count;
  if (D.17565 <= 999) goto <D.17566>; else goto <D.17567>;
  <D.17566>:
  cement_hash[i].obj = 0B;
  cement_hash[i].count = 0;
  <D.17567>:
  i = i + 1;
  <D.17317>:
  if (i <= 60) goto <D.17316>; else goto <D.17318>;
  <D.17318>:
}