__attribute__((visibility ("hidden")))
sgen_init_pinning ()
{
  memset (&pin_hash_filter, 0, 8192);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.17847;
  long unsigned int D.17848;

  D.17848 = __builtin_object_size (__dest, 0);
  D.17847 = __builtin___memset_chk (__dest, __ch, __len, D.17848);
  return D.17847;
}


__attribute__((visibility ("hidden")))
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;
}


__attribute__((visibility ("hidden")))
sgen_pin_stage_ptr (void * ptr)
{
  long unsigned int ptr.1;
  unsigned int D.17852;
  unsigned int D.17853;
  int D.17854;
  void * D.17855;
  int next_pin_slot.2;
  int pin_queue_size.3;
  void * * pin_queue.4;
  int next_pin_slot.5;
  int D.17864;
  long unsigned int D.17865;
  long unsigned int D.17866;
  void * * D.17867;
  int hash_idx;

  ptr.1 = (long unsigned int) ptr;
  D.17852 = (unsigned int) ptr.1;
  D.17853 = D.17852 * 1737350767;
  D.17854 = (int) D.17853;
  hash_idx = D.17854 & 1023;
  D.17855 = pin_hash_filter[hash_idx];
  if (D.17855 == ptr) goto <D.17856>; else goto <D.17857>;
  <D.17856>:
  return;
  <D.17857>:
  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.17860>; else goto <D.17861>;
  <D.17860>:
  realloc_pin_queue ();
  <D.17861>:
  pin_queue.4 = pin_queue;
  next_pin_slot.2 = next_pin_slot;
  next_pin_slot.5 = next_pin_slot.2;
  D.17864 = next_pin_slot.5 + 1;
  next_pin_slot = D.17864;
  D.17865 = (long unsigned int) next_pin_slot.5;
  D.17866 = D.17865 * 8;
  D.17867 = pin_queue.4 + D.17866;
  *D.17867 = ptr;
}


realloc_pin_queue ()
{
  int iftmp.6;
  int pin_queue_size.7;
  int D.17873;
  long unsigned int D.17875;
  long unsigned int D.17876;
  void * * pin_queue.8;
  int next_pin_slot.9;
  long unsigned int D.17879;
  long unsigned int D.17880;
  long unsigned int D.17881;
  long unsigned int D.17882;
  struct FILE * gc_debug_file.10;
  int new_size;
  void * * new_pin;

  pin_queue_size.7 = pin_queue_size;
  if (pin_queue_size.7 != 0) goto <D.17871>; else goto <D.17872>;
  <D.17871>:
  pin_queue_size.7 = pin_queue_size;
  D.17873 = pin_queue_size.7 / 2;
  pin_queue_size.7 = pin_queue_size;
  iftmp.6 = D.17873 + pin_queue_size.7;
  goto <D.17874>;
  <D.17872>:
  iftmp.6 = 1024;
  <D.17874>:
  new_size = iftmp.6;
  D.17875 = (long unsigned int) new_size;
  D.17876 = D.17875 * 8;
  new_pin = sgen_alloc_internal_dynamic (D.17876, 0, 1);
  pin_queue.8 = pin_queue;
  next_pin_slot.9 = next_pin_slot;
  D.17879 = (long unsigned int) next_pin_slot.9;
  D.17880 = D.17879 * 8;
  memcpy (new_pin, pin_queue.8, D.17880);
  pin_queue.8 = pin_queue;
  pin_queue_size.7 = pin_queue_size;
  D.17881 = (long unsigned int) pin_queue_size.7;
  D.17882 = D.17881 * 8;
  sgen_free_internal_dynamic (pin_queue.8, D.17882, 0);
  pin_queue = new_pin;
  pin_queue_size = new_size;
  if (0 != 0) goto <D.17883>; else goto <D.17884>;
  <D.17883>:
  gc_debug_file.10 = gc_debug_file;
  fprintf (gc_debug_file.10, "Reallocated pin queue to size: %d\n", new_size);
  gc_debug_file.10 = gc_debug_file;
  fflush (gc_debug_file.10);
  <D.17884>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.17886;
  long unsigned int D.17887;

  D.17887 = __builtin_object_size (__dest, 0);
  D.17886 = __builtin___memcpy_chk (__dest, __src, __len, D.17887);
  return D.17886;
}


__attribute__((visibility ("hidden")))
sgen_find_optimized_pin_queue_area (void * start, void * end, int * num)
{
  int D.17889;
  void * * D.17892;
  void * * pin_queue.11;
  long unsigned int D.17894;
  long unsigned int D.17895;
  int first;
  int last;

  first = optimized_pin_queue_search (start);
  last = optimized_pin_queue_search (end);
  D.17889 = last - first;
  *num = D.17889;
  if (first == last) goto <D.17890>; else goto <D.17891>;
  <D.17890>:
  D.17892 = 0B;
  return D.17892;
  <D.17891>:
  pin_queue.11 = pin_queue;
  D.17894 = (long unsigned int) first;
  D.17895 = D.17894 * 8;
  D.17892 = pin_queue.11 + D.17895;
  return D.17892;
}


optimized_pin_queue_search (void * addr)
{
  int D.17897;
  int D.17898;
  void * * pin_queue.12;
  long unsigned int D.17900;
  long unsigned int D.17901;
  void * * D.17902;
  void * D.17903;
  _Bool D.17907;
  long int D.17908;
  long int D.17909;
  int D.17912;
  int first;
  int last;

  first = 0;
  last = next_pin_slot;
  goto <D.17741>;
  <D.17740>:
  {
    int middle;

    D.17897 = last - first;
    D.17898 = D.17897 >> 1;
    middle = D.17898 + first;
    pin_queue.12 = pin_queue;
    D.17900 = (long unsigned int) middle;
    D.17901 = D.17900 * 8;
    D.17902 = pin_queue.12 + D.17901;
    D.17903 = *D.17902;
    if (D.17903 >= addr) goto <D.17904>; else goto <D.17905>;
    <D.17904>:
    last = middle;
    goto <D.17906>;
    <D.17905>:
    first = middle + 1;
    <D.17906>:
  }
  <D.17741>:
  if (first < last) goto <D.17740>; else goto <D.17742>;
  <D.17742>:
  D.17907 = first != last;
  D.17908 = (long int) D.17907;
  D.17909 = __builtin_expect (D.17908, 0);
  if (D.17909 != 0) goto <D.17910>; else goto <D.17911>;
  <D.17910>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-pinning.c", 89, "first == last");
  <D.17911>:
  D.17912 = first;
  return D.17912;
}


__attribute__((visibility ("hidden")))
sgen_find_section_pin_queue_start_end (struct GCMemSection * section)
{
  struct FILE * gc_debug_file.13;
  char * D.17917;
  char * D.17918;
  int * D.17919;
  void * * D.17920;
  int D.17923;

  if (0 != 0) goto <D.17914>; else goto <D.17915>;
  <D.17914>:
  gc_debug_file.13 = gc_debug_file;
  D.17917 = section->data;
  D.17918 = section->end_data;
  fprintf (gc_debug_file.13, "Pinning from section %p (%p-%p)\n", section, D.17917, D.17918);
  gc_debug_file.13 = gc_debug_file;
  fflush (gc_debug_file.13);
  <D.17915>:
  D.17917 = section->data;
  D.17918 = section->end_data;
  D.17919 = &section->pin_queue_num_entries;
  D.17920 = sgen_find_optimized_pin_queue_area (D.17917, D.17918, D.17919);
  section->pin_queue_start = D.17920;
  if (0 != 0) goto <D.17921>; else goto <D.17922>;
  <D.17921>:
  gc_debug_file.13 = gc_debug_file;
  D.17923 = section->pin_queue_num_entries;
  fprintf (gc_debug_file.13, "Found %d pinning addresses in section %p\n", D.17923, section);
  gc_debug_file.13 = gc_debug_file;
  fflush (gc_debug_file.13);
  <D.17922>:
}


__attribute__((visibility ("hidden")))
sgen_pinning_setup_section (struct GCMemSection * section)
{
  void * * pin_queue.14;
  int next_pin_slot.15;

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


__attribute__((visibility ("hidden")))
sgen_pinning_trim_queue_to_section (struct GCMemSection * section)
{
  int D.17926;

  D.17926 = section->pin_queue_num_entries;
  next_pin_slot = D.17926;
}


__attribute__((visibility ("hidden")))
sgen_pin_queue_clear_discarded_entries (struct GCMemSection * section, int max_pin_slot)
{
  void * * D.17927;
  int D.17928;
  long unsigned int D.17929;
  long unsigned int D.17930;
  void * * pin_queue.16;
  long unsigned int D.17932;
  long unsigned int D.17933;
  char * D.17936;
  char * D.17938;
  void * * start;
  void * * end;
  void * addr;

  D.17927 = section->pin_queue_start;
  D.17928 = section->pin_queue_num_entries;
  D.17929 = (long unsigned int) D.17928;
  D.17930 = D.17929 * 8;
  start = D.17927 + D.17930;
  pin_queue.16 = pin_queue;
  D.17932 = (long unsigned int) max_pin_slot;
  D.17933 = D.17932 * 8;
  end = pin_queue.16 + D.17933;
  if (start == 0B) goto <D.17934>; else goto <D.17935>;
  <D.17934>:
  return;
  <D.17935>:
  goto <D.17768>;
  <D.17767>:
  addr = *start;
  D.17936 = section->data;
  if (D.17936 > addr) goto <D.17766>; else goto <D.17937>;
  <D.17937>:
  D.17938 = section->end_data;
  if (D.17938 < addr) goto <D.17766>; else goto <D.17939>;
  <D.17939>:
  *start = 0B;
  start = start + 8;
  <D.17768>:
  if (start < end) goto <D.17767>; else goto <D.17766>;
  <D.17766>:
}


__attribute__((visibility ("hidden")))
sgen_optimize_pin_queue (int start_slot)
{
  struct FILE * gc_debug_file.17;
  int next_pin_slot.18;
  int D.17945;
  void * * pin_queue.19;
  long unsigned int D.17949;
  long unsigned int D.17950;
  void * * D.17951;
  long unsigned int D.17952;
  long unsigned int D.17953;
  void * * cur.20;
  void * D.17955;
  void * D.17956;
  void * D.17957;
  long int start.21;
  long int pin_queue.22;
  long int D.17961;
  long int D.17962;
  int D.17963;
  void * * start;
  void * * cur;
  void * * end;

  if (0 != 0) goto <D.17941>; else goto <D.17942>;
  <D.17941>:
  gc_debug_file.17 = gc_debug_file;
  next_pin_slot.18 = next_pin_slot;
  fprintf (gc_debug_file.17, "Sorting pin queue, size: %d\n", next_pin_slot.18);
  gc_debug_file.17 = gc_debug_file;
  fflush (gc_debug_file.17);
  <D.17942>:
  next_pin_slot.18 = next_pin_slot;
  D.17945 = next_pin_slot.18 - start_slot;
  if (D.17945 > 1) goto <D.17946>; else goto <D.17947>;
  <D.17946>:
  pin_queue.19 = pin_queue;
  D.17949 = (long unsigned int) start_slot;
  D.17950 = D.17949 * 8;
  D.17951 = pin_queue.19 + D.17950;
  next_pin_slot.18 = next_pin_slot;
  D.17945 = next_pin_slot.18 - start_slot;
  sgen_sort_addresses (D.17951, D.17945);
  <D.17947>:
  pin_queue.19 = pin_queue;
  D.17949 = (long unsigned int) start_slot;
  D.17950 = D.17949 * 8;
  cur = pin_queue.19 + D.17950;
  start = cur;
  pin_queue.19 = pin_queue;
  next_pin_slot.18 = next_pin_slot;
  D.17952 = (long unsigned int) next_pin_slot.18;
  D.17953 = D.17952 * 8;
  end = pin_queue.19 + D.17953;
  goto <D.17779>;
  <D.17778>:
  cur.20 = cur;
  cur = cur.20 + 8;
  D.17955 = *cur.20;
  *start = D.17955;
  goto <D.17776>;
  <D.17775>:
  cur = cur + 8;
  <D.17776>:
  D.17956 = *start;
  D.17957 = *cur;
  if (D.17956 == D.17957) goto <D.17958>; else goto <D.17777>;
  <D.17958>:
  if (cur < end) goto <D.17775>; else goto <D.17777>;
  <D.17777>:
  start = start + 8;
  <D.17779>:
  if (cur < end) goto <D.17778>; else goto <D.17780>;
  <D.17780>:
  start.21 = (long int) start;
  pin_queue.19 = pin_queue;
  pin_queue.22 = (long int) pin_queue.19;
  D.17961 = start.21 - pin_queue.22;
  D.17962 = D.17961 /[ex] 8;
  D.17963 = (int) D.17962;
  next_pin_slot = D.17963;
  if (0 != 0) goto <D.17964>; else goto <D.17965>;
  <D.17964>:
  gc_debug_file.17 = gc_debug_file;
  next_pin_slot.18 = next_pin_slot;
  fprintf (gc_debug_file.17, "Pin queue reduced to size: %d\n", next_pin_slot.18);
  gc_debug_file.17 = gc_debug_file;
  fflush (gc_debug_file.17);
  <D.17965>:
}


__attribute__((visibility ("hidden")))
sgen_get_pinned_count ()
{
  int D.17966;

  D.17966 = next_pin_slot;
  return D.17966;
}


__attribute__((visibility ("hidden")))
sgen_dump_pin_queue ()
{
  struct FILE * gc_debug_file.23;
  void * * pin_queue.24;
  long unsigned int D.17972;
  long unsigned int D.17973;
  void * * D.17974;
  void * D.17975;
  const char * D.17976;
  unsigned int D.17977;
  int last_num_pinned.25;
  int i;

  i = 0;
  goto <D.17789>;
  <D.17788>:
  if (0 != 0) goto <D.17968>; else goto <D.17969>;
  <D.17968>:
  gc_debug_file.23 = gc_debug_file;
  pin_queue.24 = pin_queue;
  D.17972 = (long unsigned int) i;
  D.17973 = D.17972 * 8;
  D.17974 = pin_queue.24 + D.17973;
  D.17975 = *D.17974;
  pin_queue.24 = pin_queue;
  D.17972 = (long unsigned int) i;
  D.17973 = D.17972 * 8;
  D.17974 = pin_queue.24 + D.17973;
  D.17975 = *D.17974;
  D.17976 = sgen_safe_name (D.17975);
  pin_queue.24 = pin_queue;
  D.17972 = (long unsigned int) i;
  D.17973 = D.17972 * 8;
  D.17974 = pin_queue.24 + D.17973;
  D.17975 = *D.17974;
  D.17977 = sgen_safe_object_get_size (D.17975);
  fprintf (gc_debug_file.23, "Bastard pinning obj %p (%s), size: %d\n", D.17975, D.17976, D.17977);
  gc_debug_file.23 = gc_debug_file;
  fflush (gc_debug_file.23);
  <D.17969>:
  i = i + 1;
  <D.17789>:
  last_num_pinned.25 = last_num_pinned;
  if (i < last_num_pinned.25) goto <D.17788>; else goto <D.17790>;
  <D.17790>:
}


__attribute__((visibility ("hidden")))
sgen_cement_init (gboolean enabled)
{
  cement_enabled = enabled;
}


__attribute__((visibility ("hidden")))
sgen_cement_reset ()
{
  int cement_concurrent.26;
  _Bool D.17980;
  long int D.17981;
  long int D.17982;

  cement_concurrent.26 = cement_concurrent;
  D.17980 = cement_concurrent.26 != 0;
  D.17981 = (long int) D.17980;
  D.17982 = __builtin_expect (D.17981, 0);
  if (D.17982 != 0) goto <D.17983>; else goto <D.17984>;
  <D.17983>:
  monoeg_g_log (0B, 4, "Concurrent cementing cannot simply be reset");
  <D.17805>:
  goto <D.17805>;
  <D.17984>:
  memset (&cement_hash, 0, 976);
}


__attribute__((visibility ("hidden")))
sgen_cement_concurrent_start ()
{
  int cement_concurrent.27;
  _Bool D.17986;
  long int D.17987;
  long int D.17988;

  cement_concurrent.27 = cement_concurrent;
  D.17986 = cement_concurrent.27 != 0;
  D.17987 = (long int) D.17986;
  D.17988 = __builtin_expect (D.17987, 0);
  if (D.17988 != 0) goto <D.17989>; else goto <D.17990>;
  <D.17989>:
  monoeg_g_log (0B, 4, "Concurrent cementing has already been started");
  <D.17809>:
  goto <D.17809>;
  <D.17990>:
  cement_concurrent = 1;
  memset (&cement_hash_concurrent, 0, 976);
}


__attribute__((visibility ("hidden")))
sgen_cement_concurrent_finish ()
{
  int cement_concurrent.28;
  _Bool D.17992;
  long int D.17993;
  long int D.17994;

  cement_concurrent.28 = cement_concurrent;
  D.17992 = cement_concurrent.28 == 0;
  D.17993 = (long int) D.17992;
  D.17994 = __builtin_expect (D.17993, 0);
  if (D.17994 != 0) goto <D.17995>; else goto <D.17996>;
  <D.17995>:
  monoeg_g_log (0B, 4, "Concurrent cementing hasn\'t been started");
  <D.17813>:
  goto <D.17813>;
  <D.17996>:
  cement_concurrent = 0;
  memcpy (&cement_hash, &cement_hash_concurrent, 976);
}


__attribute__((visibility ("hidden")))
sgen_cement_lookup (char * obj)
{
  unsigned int D.17997;
  unsigned int D.17998;
  int D.17999;
  _Bool D.18000;
  long int D.18001;
  long int D.18002;
  int cement_enabled.29;
  gboolean D.18008;
  char * D.18009;
  unsigned int D.18014;
  _Bool D.18015;
  int i;

  D.17997 = mono_aligned_addr_hash (obj);
  D.17998 = D.17997 % 61;
  i = (int) D.17998;
  D.17999 = sgen_ptr_in_nursery (obj);
  D.18000 = D.17999 == 0;
  D.18001 = (long int) D.18000;
  D.18002 = __builtin_expect (D.18001, 0);
  if (D.18002 != 0) goto <D.18003>; else goto <D.18004>;
  <D.18003>:
  monoeg_g_log (0B, 4, "Looking up cementing for non-nursery objects makes no sense");
  <D.17818>:
  goto <D.17818>;
  <D.18004>:
  cement_enabled.29 = cement_enabled;
  if (cement_enabled.29 == 0) goto <D.18006>; else goto <D.18007>;
  <D.18006>:
  D.18008 = 0;
  return D.18008;
  <D.18007>:
  D.18009 = cement_hash[i].obj;
  if (D.18009 == 0B) goto <D.18010>; else goto <D.18011>;
  <D.18010>:
  D.18008 = 0;
  return D.18008;
  <D.18011>:
  D.18009 = cement_hash[i].obj;
  if (D.18009 != obj) goto <D.18012>; else goto <D.18013>;
  <D.18012>:
  D.18008 = 0;
  return D.18008;
  <D.18013>:
  D.18014 = cement_hash[i].count;
  D.18015 = D.18014 > 999;
  D.18008 = (gboolean) D.18015;
  return D.18008;
}


__attribute__((always_inline))
sgen_ptr_in_nursery (void * p)
{
  gboolean D.18017;
  int sgen_nursery_bits.30;
  int D.18019;
  int D.18020;
  long unsigned int D.18021;
  long unsigned int p.31;
  long unsigned int D.18023;
  char * sgen_nursery_start.32;
  long unsigned int sgen_nursery_start.33;
  _Bool D.18026;

  sgen_nursery_bits.30 = sgen_nursery_bits;
  D.18019 = 1 << sgen_nursery_bits.30;
  D.18020 = -D.18019;
  D.18021 = (long unsigned int) D.18020;
  p.31 = (long unsigned int) p;
  D.18023 = D.18021 & p.31;
  sgen_nursery_start.32 = sgen_nursery_start;
  sgen_nursery_start.33 = (long unsigned int) sgen_nursery_start.32;
  D.18026 = D.18023 == sgen_nursery_start.33;
  D.18017 = (gboolean) D.18026;
  return D.18017;
}


__attribute__((visibility ("hidden")))
sgen_cement_lookup_or_register (char * obj)
{
  int cement_enabled.34;
  gboolean D.18031;
  int cement_concurrent.35;
  _Bool D.18035;
  long int D.18036;
  long int D.18037;
  unsigned int D.18043;
  unsigned int D.18044;
  int D.18045;
  _Bool D.18046;
  long int D.18047;
  long int D.18048;
  long unsigned int D.18051;
  long unsigned int D.18052;
  struct CementHashEntry * D.18053;
  char * D.18054;
  unsigned int D.18057;
  _Bool D.18058;
  long int D.18059;
  long int D.18060;
  unsigned int D.18068;
  long unsigned int D.18073;
  long unsigned int D.18074;
  int i;
  struct CementHashEntry * hash;
  gboolean concurrent_cementing;

  concurrent_cementing = sgen_concurrent_collection_in_progress ();
  cement_enabled.34 = cement_enabled;
  if (cement_enabled.34 == 0) goto <D.18029>; else goto <D.18030>;
  <D.18029>:
  D.18031 = 0;
  return D.18031;
  <D.18030>:
  if (concurrent_cementing != 0) goto <D.18032>; else goto <D.18033>;
  <D.18032>:
  cement_concurrent.35 = cement_concurrent;
  D.18035 = cement_concurrent.35 == 0;
  D.18036 = (long int) D.18035;
  D.18037 = __builtin_expect (D.18036, 0);
  if (D.18037 != 0) goto <D.18038>; else goto <D.18039>;
  <D.18038>:
  monoeg_g_log (0B, 4, "Cementing wasn\'t inited with concurrent flag");
  <D.17825>:
  goto <D.17825>;
  <D.18039>:
  <D.18033>:
  if (concurrent_cementing != 0) goto <D.18040>; else goto <D.18041>;
  <D.18040>:
  hash = &cement_hash_concurrent;
  goto <D.18042>;
  <D.18041>:
  hash = &cement_hash;
  <D.18042>:
  D.18043 = mono_aligned_addr_hash (obj);
  D.18044 = D.18043 % 61;
  i = (int) D.18044;
  D.18045 = sgen_ptr_in_nursery (obj);
  D.18046 = D.18045 == 0;
  D.18047 = (long int) D.18046;
  D.18048 = __builtin_expect (D.18047, 0);
  if (D.18048 != 0) goto <D.18049>; else goto <D.18050>;
  <D.18049>:
  monoeg_g_log (0B, 4, "Can only cement pointers to nursery objects");
  <D.17826>:
  goto <D.17826>;
  <D.18050>:
  D.18051 = (long unsigned int) i;
  D.18052 = D.18051 * 16;
  D.18053 = hash + D.18052;
  D.18054 = D.18053->obj;
  if (D.18054 == 0B) goto <D.18055>; else goto <D.18056>;
  <D.18055>:
  D.18051 = (long unsigned int) i;
  D.18052 = D.18051 * 16;
  D.18053 = hash + D.18052;
  D.18057 = D.18053->count;
  D.18058 = D.18057 != 0;
  D.18059 = (long int) D.18058;
  D.18060 = __builtin_expect (D.18059, 0);
  if (D.18060 != 0) goto <D.18061>; else goto <D.18062>;
  <D.18061>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.17827>:
  goto <D.17827>;
  <D.18062>:
  D.18051 = (long unsigned int) i;
  D.18052 = D.18051 * 16;
  D.18053 = hash + D.18052;
  D.18053->obj = obj;
  goto <D.18063>;
  <D.18056>:
  D.18051 = (long unsigned int) i;
  D.18052 = D.18051 * 16;
  D.18053 = hash + D.18052;
  D.18054 = D.18053->obj;
  if (D.18054 != obj) goto <D.18064>; else goto <D.18065>;
  <D.18064>:
  D.18031 = 0;
  return D.18031;
  <D.18065>:
  <D.18063>:
  D.18051 = (long unsigned int) i;
  D.18052 = D.18051 * 16;
  D.18053 = hash + D.18052;
  D.18057 = D.18053->count;
  if (D.18057 > 999) goto <D.18066>; else goto <D.18067>;
  <D.18066>:
  D.18031 = 1;
  return D.18031;
  <D.18067>:
  D.18051 = (long unsigned int) i;
  D.18052 = D.18051 * 16;
  D.18053 = hash + D.18052;
  D.18057 = D.18053->count;
  D.18068 = D.18057 + 1;
  D.18053->count = D.18068;
  D.18051 = (long unsigned int) i;
  D.18052 = D.18051 * 16;
  D.18053 = hash + D.18052;
  D.18057 = D.18053->count;
  if (D.18057 == 1000) goto <D.18069>; else goto <D.18070>;
  <D.18069>:
  if (0 != 0) goto <D.18071>; else goto <D.18072>;
  <D.18071>:
  {
    struct MonoVTable * vt;

    D.18073 = MEM[(mword *)obj];
    D.18074 = D.18073 & 18446744073709551612;
    vt = (struct MonoVTable *) D.18074;
  }
  <D.18072>:
  <D.18070>:
  D.18031 = 0;
  return D.18031;
}


__attribute__((visibility ("hidden")))
sgen_cement_iterate (void (*IterateObjectCallbackFunc) (char *, size_t, void *) callback, void * callback_data)
{
  unsigned int D.18076;
  _Bool D.18079;
  long int D.18080;
  long int D.18081;
  char * D.18084;
  int i;

  i = 0;
  goto <D.17837>;
  <D.17836>:
  D.18076 = cement_hash[i].count;
  if (D.18076 == 0) goto <D.18077>; else goto <D.18078>;
  <D.18077>:
  // predicted unlikely by continue predictor.
  goto <D.17834>;
  <D.18078>:
  D.18076 = cement_hash[i].count;
  D.18079 = D.18076 <= 999;
  D.18080 = (long int) D.18079;
  D.18081 = __builtin_expect (D.18080, 0);
  if (D.18081 != 0) goto <D.18082>; else goto <D.18083>;
  <D.18082>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.17835>:
  goto <D.17835>;
  <D.18083>:
  D.18084 = cement_hash[i].obj;
  callback (D.18084, 0, callback_data);
  <D.17834>:
  i = i + 1;
  <D.17837>:
  if (i <= 60) goto <D.17836>; else goto <D.17838>;
  <D.17838>:
}


__attribute__((visibility ("hidden")))
sgen_cement_clear_below_threshold ()
{
  unsigned int D.18085;
  int i;

  i = 0;
  goto <D.17844>;
  <D.17843>:
  D.18085 = cement_hash[i].count;
  if (D.18085 <= 999) goto <D.18086>; else goto <D.18087>;
  <D.18086>:
  cement_hash[i].obj = 0B;
  cement_hash[i].count = 0;
  <D.18087>:
  i = i + 1;
  <D.17844>:
  if (i <= 60) goto <D.17843>; else goto <D.17845>;
  <D.17845>:
}