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


memset (void * __dest, int __ch, size_t __len)
{
  int D.17705;
  int D.17710;
  void * D.17712;
  long unsigned int D.17713;

  D.17705 = __builtin_constant_p (__len);
  if (D.17705 != 0) goto <D.17706>; else goto <D.17707>;
  <D.17706>:
  if (__len == 0) goto <D.17708>; else goto <D.17709>;
  <D.17708>:
  D.17710 = __builtin_constant_p (__ch);
  if (D.17710 == 0) goto <D.17703>; else goto <D.17711>;
  <D.17711>:
  if (__ch != 0) goto <D.17703>; else goto <D.17704>;
  <D.17703>:
  __warn_memset_zero_len ();
  D.17712 = __dest;
  return D.17712;
  <D.17704>:
  <D.17709>:
  <D.17707>:
  D.17713 = __builtin_object_size (__dest, 0);
  D.17712 = __builtin___memset_chk (__dest, __ch, __len, D.17713);
  return D.17712;
}


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.17717;
  unsigned int D.17718;
  int D.17719;
  void * D.17720;
  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.17730;
  long unsigned int D.17731;
  void * * D.17732;
  int hash_idx;

  ptr.1 = (long unsigned int) ptr;
  D.17717 = (unsigned int) ptr.1;
  D.17718 = D.17717 * 1737350767;
  D.17719 = (int) D.17718;
  hash_idx = D.17719 & 1023;
  D.17720 = pin_hash_filter[hash_idx];
  if (D.17720 == ptr) goto <D.17721>; else goto <D.17722>;
  <D.17721>:
  return;
  <D.17722>:
  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.17725>; else goto <D.17726>;
  <D.17725>:
  realloc_pin_queue ();
  <D.17726>:
  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.17730 = (long unsigned int) next_pin_slot.5;
  D.17731 = D.17730 * 8;
  D.17732 = pin_queue.4 + D.17731;
  *D.17732 = ptr;
}


realloc_pin_queue ()
{
  int iftmp.7;
  int pin_queue_size.8;
  int D.17738;
  long unsigned int D.17740;
  long unsigned int D.17741;
  int next_pin_slot.9;
  long unsigned int D.17743;
  long unsigned int D.17744;
  void * * pin_queue.10;
  long unsigned int D.17746;
  long unsigned int D.17747;
  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.17736>; else goto <D.17737>;
  <D.17736>:
  pin_queue_size.8 = pin_queue_size;
  D.17738 = pin_queue_size.8 / 2;
  pin_queue_size.8 = pin_queue_size;
  iftmp.7 = D.17738 + pin_queue_size.8;
  goto <D.17739>;
  <D.17737>:
  iftmp.7 = 1024;
  <D.17739>:
  new_size = iftmp.7;
  D.17740 = (long unsigned int) new_size;
  D.17741 = D.17740 * 8;
  new_pin = sgen_alloc_internal_dynamic (D.17741, 0, 1);
  next_pin_slot.9 = next_pin_slot;
  D.17743 = (long unsigned int) next_pin_slot.9;
  D.17744 = D.17743 * 8;
  pin_queue.10 = pin_queue;
  memcpy (new_pin, pin_queue.10, D.17744);
  pin_queue_size.8 = pin_queue_size;
  D.17746 = (long unsigned int) pin_queue_size.8;
  D.17747 = D.17746 * 8;
  pin_queue.10 = pin_queue;
  sgen_free_internal_dynamic (pin_queue.10, D.17747, 0);
  pin_queue = new_pin;
  pin_queue_size = new_size;
  if (0 != 0) goto <D.17748>; else goto <D.17749>;
  <D.17748>:
  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.17749>:
}


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

  D.17752 = __builtin_object_size (__dest, 0);
  D.17751 = __builtin___memcpy_chk (__dest, __src, __len, D.17752);
  return D.17751;
}


sgen_find_optimized_pin_queue_area (void * start, void * end, int * num)
{
  int D.17754;
  void * * D.17757;
  void * * pin_queue.12;
  long unsigned int D.17759;
  long unsigned int D.17760;
  int first;
  int last;

  first = optimized_pin_queue_search (start);
  last = optimized_pin_queue_search (end);
  D.17754 = last - first;
  *num = D.17754;
  if (first == last) goto <D.17755>; else goto <D.17756>;
  <D.17755>:
  D.17757 = 0B;
  return D.17757;
  <D.17756>:
  pin_queue.12 = pin_queue;
  D.17759 = (long unsigned int) first;
  D.17760 = D.17759 * 8;
  D.17757 = pin_queue.12 + D.17760;
  return D.17757;
}


optimized_pin_queue_search (void * addr)
{
  int D.17762;
  int D.17763;
  void * * pin_queue.13;
  long unsigned int D.17765;
  long unsigned int D.17766;
  void * * D.17767;
  void * D.17768;
  _Bool D.17772;
  long int D.17773;
  long int D.17774;
  int D.17777;
  int first;
  int last;

  first = 0;
  last = next_pin_slot;
  goto <D.17597>;
  <D.17596>:
  {
    int middle;

    D.17762 = last - first;
    D.17763 = D.17762 >> 1;
    middle = D.17763 + first;
    pin_queue.13 = pin_queue;
    D.17765 = (long unsigned int) middle;
    D.17766 = D.17765 * 8;
    D.17767 = pin_queue.13 + D.17766;
    D.17768 = *D.17767;
    if (D.17768 >= addr) goto <D.17769>; else goto <D.17770>;
    <D.17769>:
    last = middle;
    goto <D.17771>;
    <D.17770>:
    first = middle + 1;
    <D.17771>:
  }
  <D.17597>:
  if (first < last) goto <D.17596>; else goto <D.17598>;
  <D.17598>:
  D.17772 = first != last;
  D.17773 = (long int) D.17772;
  D.17774 = __builtin_expect (D.17773, 0);
  if (D.17774 != 0) goto <D.17775>; else goto <D.17776>;
  <D.17775>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-pinning.c", 89, "first == last");
  <D.17776>:
  D.17777 = first;
  return D.17777;
}


sgen_find_section_pin_queue_start_end (struct GCMemSection * section)
{
  char * D.17781;
  char * D.17782;
  struct FILE * gc_debug_file.14;
  int * D.17784;
  void * * D.17785;
  int D.17788;

  if (0 != 0) goto <D.17779>; else goto <D.17780>;
  <D.17779>:
  D.17781 = section->end_data;
  D.17782 = section->data;
  gc_debug_file.14 = gc_debug_file;
  fprintf (gc_debug_file.14, "Pinning from section %p (%p-%p)\n", section, D.17782, D.17781);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.17780>:
  D.17784 = &section->pin_queue_num_entries;
  D.17781 = section->end_data;
  D.17782 = section->data;
  D.17785 = sgen_find_optimized_pin_queue_area (D.17782, D.17781, D.17784);
  section->pin_queue_start = D.17785;
  if (0 != 0) goto <D.17786>; else goto <D.17787>;
  <D.17786>:
  D.17788 = section->pin_queue_num_entries;
  gc_debug_file.14 = gc_debug_file;
  fprintf (gc_debug_file.14, "Found %d pinning addresses in section %p\n", D.17788, section);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.17787>:
}


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.17792;
  int D.17793;
  long unsigned int D.17794;
  long unsigned int D.17795;
  void * * pin_queue.18;
  long unsigned int D.17797;
  long unsigned int D.17798;
  char * D.17801;
  char * D.17803;
  void * * start;
  void * * end;
  void * addr;

  D.17792 = section->pin_queue_start;
  D.17793 = section->pin_queue_num_entries;
  D.17794 = (long unsigned int) D.17793;
  D.17795 = D.17794 * 8;
  start = D.17792 + D.17795;
  pin_queue.18 = pin_queue;
  D.17797 = (long unsigned int) max_pin_slot;
  D.17798 = D.17797 * 8;
  end = pin_queue.18 + D.17798;
  if (start == 0B) goto <D.17799>; else goto <D.17800>;
  <D.17799>:
  return;
  <D.17800>:
  goto <D.17624>;
  <D.17623>:
  addr = *start;
  D.17801 = section->data;
  if (D.17801 > addr) goto <D.17622>; else goto <D.17802>;
  <D.17802>:
  D.17803 = section->end_data;
  if (D.17803 < addr) goto <D.17622>; else goto <D.17804>;
  <D.17804>:
  *start = 0B;
  start = start + 8;
  <D.17624>:
  if (start < end) goto <D.17623>; else goto <D.17622>;
  <D.17622>:
}


sgen_optimize_pin_queue (int start_slot)
{
  int next_pin_slot.19;
  struct FILE * gc_debug_file.20;
  int D.17810;
  void * * pin_queue.21;
  long unsigned int D.17814;
  long unsigned int D.17815;
  void * * D.17816;
  long unsigned int D.17817;
  long unsigned int D.17818;
  void * * cur.22;
  void * D.17820;
  void * D.17821;
  void * D.17822;
  long int start.23;
  long int pin_queue.24;
  long int D.17826;
  long int D.17827;
  int next_pin_slot.25;
  void * * start;
  void * * cur;
  void * * end;

  if (0 != 0) goto <D.17806>; else goto <D.17807>;
  <D.17806>:
  next_pin_slot.19 = next_pin_slot;
  gc_debug_file.20 = gc_debug_file;
  fprintf (gc_debug_file.20, "Sorting pin queue, size: %d\n", next_pin_slot.19);
  gc_debug_file.20 = gc_debug_file;
  fflush (gc_debug_file.20);
  <D.17807>:
  next_pin_slot.19 = next_pin_slot;
  D.17810 = next_pin_slot.19 - start_slot;
  if (D.17810 > 1) goto <D.17811>; else goto <D.17812>;
  <D.17811>:
  next_pin_slot.19 = next_pin_slot;
  D.17810 = next_pin_slot.19 - start_slot;
  pin_queue.21 = pin_queue;
  D.17814 = (long unsigned int) start_slot;
  D.17815 = D.17814 * 8;
  D.17816 = pin_queue.21 + D.17815;
  sgen_sort_addresses (D.17816, D.17810);
  <D.17812>:
  pin_queue.21 = pin_queue;
  D.17814 = (long unsigned int) start_slot;
  D.17815 = D.17814 * 8;
  cur = pin_queue.21 + D.17815;
  start = cur;
  pin_queue.21 = pin_queue;
  next_pin_slot.19 = next_pin_slot;
  D.17817 = (long unsigned int) next_pin_slot.19;
  D.17818 = D.17817 * 8;
  end = pin_queue.21 + D.17818;
  goto <D.17635>;
  <D.17634>:
  cur.22 = cur;
  cur = cur.22 + 8;
  D.17820 = *cur.22;
  *start = D.17820;
  goto <D.17632>;
  <D.17631>:
  cur = cur + 8;
  <D.17632>:
  D.17821 = *start;
  D.17822 = *cur;
  if (D.17821 == D.17822) goto <D.17823>; else goto <D.17633>;
  <D.17823>:
  if (cur < end) goto <D.17631>; else goto <D.17633>;
  <D.17633>:
  start = start + 8;
  <D.17635>:
  if (cur < end) goto <D.17634>; else goto <D.17636>;
  <D.17636>:
  start.23 = (long int) start;
  pin_queue.21 = pin_queue;
  pin_queue.24 = (long int) pin_queue.21;
  D.17826 = start.23 - pin_queue.24;
  D.17827 = D.17826 /[ex] 8;
  next_pin_slot.25 = (int) D.17827;
  next_pin_slot = next_pin_slot.25;
  if (0 != 0) goto <D.17829>; else goto <D.17830>;
  <D.17829>:
  next_pin_slot.19 = next_pin_slot;
  gc_debug_file.20 = gc_debug_file;
  fprintf (gc_debug_file.20, "Pin queue reduced to size: %d\n", next_pin_slot.19);
  gc_debug_file.20 = gc_debug_file;
  fflush (gc_debug_file.20);
  <D.17830>:
}


sgen_get_pinned_count ()
{
  int D.17831;

  D.17831 = next_pin_slot;
  return D.17831;
}


sgen_dump_pin_queue ()
{
  void * * pin_queue.26;
  long unsigned int D.17836;
  long unsigned int D.17837;
  void * * D.17838;
  void * D.17839;
  unsigned int D.17840;
  const char * D.17841;
  struct FILE * gc_debug_file.27;
  int last_num_pinned.28;
  int i;

  i = 0;
  goto <D.17645>;
  <D.17644>:
  if (0 != 0) goto <D.17833>; else goto <D.17834>;
  <D.17833>:
  pin_queue.26 = pin_queue;
  D.17836 = (long unsigned int) i;
  D.17837 = D.17836 * 8;
  D.17838 = pin_queue.26 + D.17837;
  D.17839 = *D.17838;
  D.17840 = sgen_safe_object_get_size (D.17839);
  pin_queue.26 = pin_queue;
  D.17836 = (long unsigned int) i;
  D.17837 = D.17836 * 8;
  D.17838 = pin_queue.26 + D.17837;
  D.17839 = *D.17838;
  D.17841 = sgen_safe_name (D.17839);
  pin_queue.26 = pin_queue;
  D.17836 = (long unsigned int) i;
  D.17837 = D.17836 * 8;
  D.17838 = pin_queue.26 + D.17837;
  D.17839 = *D.17838;
  gc_debug_file.27 = gc_debug_file;
  fprintf (gc_debug_file.27, "Bastard pinning obj %p (%s), size: %d\n", D.17839, D.17841, D.17840);
  gc_debug_file.27 = gc_debug_file;
  fflush (gc_debug_file.27);
  <D.17834>:
  i = i + 1;
  <D.17645>:
  last_num_pinned.28 = last_num_pinned;
  if (i < last_num_pinned.28) goto <D.17644>; else goto <D.17646>;
  <D.17646>:
}


sgen_cement_init (gboolean enabled)
{
  cement_enabled = enabled;
}


sgen_cement_reset ()
{
  int cement_concurrent.29;
  _Bool D.17845;
  long int D.17846;
  long int D.17847;

  cement_concurrent.29 = cement_concurrent;
  D.17845 = cement_concurrent.29 != 0;
  D.17846 = (long int) D.17845;
  D.17847 = __builtin_expect (D.17846, 0);
  if (D.17847 != 0) goto <D.17848>; else goto <D.17849>;
  <D.17848>:
  monoeg_g_log (0B, 4, "Concurrent cementing cannot simply be reset");
  <D.17661>:
  goto <D.17661>;
  <D.17849>:
  memset (&cement_hash, 0, 976);
}


sgen_cement_concurrent_start ()
{
  int cement_concurrent.30;
  _Bool D.17851;
  long int D.17852;
  long int D.17853;

  cement_concurrent.30 = cement_concurrent;
  D.17851 = cement_concurrent.30 != 0;
  D.17852 = (long int) D.17851;
  D.17853 = __builtin_expect (D.17852, 0);
  if (D.17853 != 0) goto <D.17854>; else goto <D.17855>;
  <D.17854>:
  monoeg_g_log (0B, 4, "Concurrent cementing has already been started");
  <D.17665>:
  goto <D.17665>;
  <D.17855>:
  cement_concurrent = 1;
  memset (&cement_hash_concurrent, 0, 976);
}


sgen_cement_concurrent_finish ()
{
  int cement_concurrent.31;
  _Bool D.17857;
  long int D.17858;
  long int D.17859;

  cement_concurrent.31 = cement_concurrent;
  D.17857 = cement_concurrent.31 == 0;
  D.17858 = (long int) D.17857;
  D.17859 = __builtin_expect (D.17858, 0);
  if (D.17859 != 0) goto <D.17860>; else goto <D.17861>;
  <D.17860>:
  monoeg_g_log (0B, 4, "Concurrent cementing hasn\'t been started");
  <D.17669>:
  goto <D.17669>;
  <D.17861>:
  cement_concurrent = 0;
  memcpy (&cement_hash, &cement_hash_concurrent, 976);
}


sgen_cement_lookup (char * obj)
{
  unsigned int D.17862;
  unsigned int D.17863;
  int D.17864;
  _Bool D.17865;
  long int D.17866;
  long int D.17867;
  int cement_enabled.32;
  gboolean D.17873;
  char * D.17874;
  unsigned int D.17879;
  _Bool D.17880;
  int i;

  D.17862 = mono_aligned_addr_hash (obj);
  D.17863 = D.17862 % 61;
  i = (int) D.17863;
  D.17864 = sgen_ptr_in_nursery (obj);
  D.17865 = D.17864 == 0;
  D.17866 = (long int) D.17865;
  D.17867 = __builtin_expect (D.17866, 0);
  if (D.17867 != 0) goto <D.17868>; else goto <D.17869>;
  <D.17868>:
  monoeg_g_log (0B, 4, "Looking up cementing for non-nursery objects makes no sense");
  <D.17674>:
  goto <D.17674>;
  <D.17869>:
  cement_enabled.32 = cement_enabled;
  if (cement_enabled.32 == 0) goto <D.17871>; else goto <D.17872>;
  <D.17871>:
  D.17873 = 0;
  return D.17873;
  <D.17872>:
  D.17874 = cement_hash[i].obj;
  if (D.17874 == 0B) goto <D.17875>; else goto <D.17876>;
  <D.17875>:
  D.17873 = 0;
  return D.17873;
  <D.17876>:
  D.17874 = cement_hash[i].obj;
  if (D.17874 != obj) goto <D.17877>; else goto <D.17878>;
  <D.17877>:
  D.17873 = 0;
  return D.17873;
  <D.17878>:
  D.17879 = cement_hash[i].count;
  D.17880 = D.17879 > 999;
  D.17873 = (gboolean) D.17880;
  return D.17873;
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.17882;
  int sgen_nursery_bits.33;
  int D.17884;
  int D.17885;
  long unsigned int D.17886;
  long unsigned int p.34;
  long unsigned int D.17888;
  char * sgen_nursery_start.35;
  long unsigned int sgen_nursery_start.36;
  _Bool D.17891;

  sgen_nursery_bits.33 = sgen_nursery_bits;
  D.17884 = 1 << sgen_nursery_bits.33;
  D.17885 = -D.17884;
  D.17886 = (long unsigned int) D.17885;
  p.34 = (long unsigned int) p;
  D.17888 = D.17886 & p.34;
  sgen_nursery_start.35 = sgen_nursery_start;
  sgen_nursery_start.36 = (long unsigned int) sgen_nursery_start.35;
  D.17891 = D.17888 == sgen_nursery_start.36;
  D.17882 = (gboolean) D.17891;
  return D.17882;
}


sgen_cement_lookup_or_register (char * obj)
{
  int cement_enabled.37;
  gboolean D.17896;
  int cement_concurrent.38;
  _Bool D.17900;
  long int D.17901;
  long int D.17902;
  unsigned int D.17908;
  unsigned int D.17909;
  int D.17910;
  _Bool D.17911;
  long int D.17912;
  long int D.17913;
  long unsigned int D.17916;
  long unsigned int D.17917;
  struct CementHashEntry * D.17918;
  char * D.17919;
  unsigned int D.17922;
  _Bool D.17923;
  long int D.17924;
  long int D.17925;
  unsigned int D.17933;
  long unsigned int D.17938;
  long unsigned int D.17939;
  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.17894>; else goto <D.17895>;
  <D.17894>:
  D.17896 = 0;
  return D.17896;
  <D.17895>:
  if (concurrent_cementing != 0) goto <D.17897>; else goto <D.17898>;
  <D.17897>:
  cement_concurrent.38 = cement_concurrent;
  D.17900 = cement_concurrent.38 == 0;
  D.17901 = (long int) D.17900;
  D.17902 = __builtin_expect (D.17901, 0);
  if (D.17902 != 0) goto <D.17903>; else goto <D.17904>;
  <D.17903>:
  monoeg_g_log (0B, 4, "Cementing wasn\'t inited with concurrent flag");
  <D.17681>:
  goto <D.17681>;
  <D.17904>:
  <D.17898>:
  if (concurrent_cementing != 0) goto <D.17905>; else goto <D.17906>;
  <D.17905>:
  hash = &cement_hash_concurrent;
  goto <D.17907>;
  <D.17906>:
  hash = &cement_hash;
  <D.17907>:
  D.17908 = mono_aligned_addr_hash (obj);
  D.17909 = D.17908 % 61;
  i = (int) D.17909;
  D.17910 = sgen_ptr_in_nursery (obj);
  D.17911 = D.17910 == 0;
  D.17912 = (long int) D.17911;
  D.17913 = __builtin_expect (D.17912, 0);
  if (D.17913 != 0) goto <D.17914>; else goto <D.17915>;
  <D.17914>:
  monoeg_g_log (0B, 4, "Can only cement pointers to nursery objects");
  <D.17682>:
  goto <D.17682>;
  <D.17915>:
  D.17916 = (long unsigned int) i;
  D.17917 = D.17916 * 16;
  D.17918 = hash + D.17917;
  D.17919 = D.17918->obj;
  if (D.17919 == 0B) goto <D.17920>; else goto <D.17921>;
  <D.17920>:
  D.17916 = (long unsigned int) i;
  D.17917 = D.17916 * 16;
  D.17918 = hash + D.17917;
  D.17922 = D.17918->count;
  D.17923 = D.17922 != 0;
  D.17924 = (long int) D.17923;
  D.17925 = __builtin_expect (D.17924, 0);
  if (D.17925 != 0) goto <D.17926>; else goto <D.17927>;
  <D.17926>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.17683>:
  goto <D.17683>;
  <D.17927>:
  D.17916 = (long unsigned int) i;
  D.17917 = D.17916 * 16;
  D.17918 = hash + D.17917;
  D.17918->obj = obj;
  goto <D.17928>;
  <D.17921>:
  D.17916 = (long unsigned int) i;
  D.17917 = D.17916 * 16;
  D.17918 = hash + D.17917;
  D.17919 = D.17918->obj;
  if (D.17919 != obj) goto <D.17929>; else goto <D.17930>;
  <D.17929>:
  D.17896 = 0;
  return D.17896;
  <D.17930>:
  <D.17928>:
  D.17916 = (long unsigned int) i;
  D.17917 = D.17916 * 16;
  D.17918 = hash + D.17917;
  D.17922 = D.17918->count;
  if (D.17922 > 999) goto <D.17931>; else goto <D.17932>;
  <D.17931>:
  D.17896 = 1;
  return D.17896;
  <D.17932>:
  D.17916 = (long unsigned int) i;
  D.17917 = D.17916 * 16;
  D.17918 = hash + D.17917;
  D.17922 = D.17918->count;
  D.17933 = D.17922 + 1;
  D.17918->count = D.17933;
  D.17916 = (long unsigned int) i;
  D.17917 = D.17916 * 16;
  D.17918 = hash + D.17917;
  D.17922 = D.17918->count;
  if (D.17922 == 1000) goto <D.17934>; else goto <D.17935>;
  <D.17934>:
  if (0 != 0) goto <D.17936>; else goto <D.17937>;
  <D.17936>:
  {
    struct MonoVTable * vt;

    D.17938 = MEM[(mword *)obj];
    D.17939 = D.17938 & 18446744073709551612;
    vt = (struct MonoVTable *) D.17939;
  }
  <D.17937>:
  <D.17935>:
  D.17896 = 0;
  return D.17896;
}


sgen_cement_iterate (void (*IterateObjectCallbackFunc) (char *, size_t, void *) callback, void * callback_data)
{
  unsigned int D.17941;
  _Bool D.17944;
  long int D.17945;
  long int D.17946;
  char * D.17949;
  int i;

  i = 0;
  goto <D.17693>;
  <D.17692>:
  D.17941 = cement_hash[i].count;
  if (D.17941 == 0) goto <D.17942>; else goto <D.17943>;
  <D.17942>:
  // predicted unlikely by continue predictor.
  goto <D.17690>;
  <D.17943>:
  D.17941 = cement_hash[i].count;
  D.17944 = D.17941 <= 999;
  D.17945 = (long int) D.17944;
  D.17946 = __builtin_expect (D.17945, 0);
  if (D.17946 != 0) goto <D.17947>; else goto <D.17948>;
  <D.17947>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.17691>:
  goto <D.17691>;
  <D.17948>:
  D.17949 = cement_hash[i].obj;
  callback (D.17949, 0, callback_data);
  <D.17690>:
  i = i + 1;
  <D.17693>:
  if (i <= 60) goto <D.17692>; else goto <D.17694>;
  <D.17694>:
}


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

  i = 0;
  goto <D.17700>;
  <D.17699>:
  D.17950 = cement_hash[i].count;
  if (D.17950 <= 999) goto <D.17951>; else goto <D.17952>;
  <D.17951>:
  cement_hash[i].obj = 0B;
  cement_hash[i].count = 0;
  <D.17952>:
  i = i + 1;
  <D.17700>:
  if (i <= 60) goto <D.17699>; else goto <D.17701>;
  <D.17701>:
}