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


memset (void * __dest, int __ch, size_t __len)
{
  int D.19907;
  int D.19912;
  void * D.19914;
  unsigned int D.19915;

  D.19907 = __builtin_constant_p (__len);
  if (D.19907 != 0) goto <D.19908>; else goto <D.19909>;
  <D.19908>:
  if (__len == 0) goto <D.19910>; else goto <D.19911>;
  <D.19910>:
  D.19912 = __builtin_constant_p (__ch);
  if (D.19912 == 0) goto <D.19905>; else goto <D.19913>;
  <D.19913>:
  if (__ch != 0) goto <D.19905>; else goto <D.19906>;
  <D.19905>:
  __warn_memset_zero_len ();
  D.19914 = __dest;
  return D.19914;
  <D.19906>:
  <D.19911>:
  <D.19909>:
  D.19915 = __builtin_object_size (__dest, 0);
  D.19914 = __builtin___memset_chk (__dest, __ch, __len, D.19915);
  return D.19914;
}


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.19919;
  int D.19920;
  void * D.19921;
  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.19932;
  void * * D.19933;
  int hash_idx;

  ptr.1 = (unsigned int) ptr;
  D.19919 = ptr.1 * 1737350767;
  D.19920 = (int) D.19919;
  hash_idx = D.19920 & 1023;
  D.19921 = pin_hash_filter[hash_idx];
  if (D.19921 == ptr) goto <D.19922>; else goto <D.19923>;
  <D.19922>:
  return;
  <D.19923>:
  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.19926>; else goto <D.19927>;
  <D.19926>:
  realloc_pin_queue ();
  <D.19927>:
  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.19932 = next_pin_slot.7 * 4;
  D.19933 = pin_queue.4 + D.19932;
  *D.19933 = ptr;
}


realloc_pin_queue ()
{
  int iftmp.8;
  int pin_queue_size.9;
  int D.19939;
  unsigned int new_size.10;
  unsigned int D.19942;
  void * * pin_queue.11;
  int next_pin_slot.12;
  unsigned int next_pin_slot.13;
  unsigned int D.19946;
  unsigned int pin_queue_size.14;
  unsigned int D.19948;
  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.19937>; else goto <D.19938>;
  <D.19937>:
  pin_queue_size.9 = pin_queue_size;
  D.19939 = pin_queue_size.9 / 2;
  pin_queue_size.9 = pin_queue_size;
  iftmp.8 = D.19939 + pin_queue_size.9;
  goto <D.19940>;
  <D.19938>:
  iftmp.8 = 1024;
  <D.19940>:
  new_size = iftmp.8;
  new_size.10 = (unsigned int) new_size;
  D.19942 = new_size.10 * 4;
  new_pin = sgen_alloc_internal_dynamic (D.19942, 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.19946 = next_pin_slot.13 * 4;
  memcpy (new_pin, pin_queue.11, D.19946);
  pin_queue.11 = pin_queue;
  pin_queue_size.9 = pin_queue_size;
  pin_queue_size.14 = (unsigned int) pin_queue_size.9;
  D.19948 = pin_queue_size.14 * 4;
  sgen_free_internal_dynamic (pin_queue.11, D.19948, 0);
  pin_queue = new_pin;
  pin_queue_size = new_size;
  if (0 != 0) goto <D.19949>; else goto <D.19950>;
  <D.19949>:
  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.19950>:
}


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

  D.19953 = __builtin_object_size (__dest, 0);
  D.19952 = __builtin___memcpy_chk (__dest, __src, __len, D.19953);
  return D.19952;
}


sgen_find_optimized_pin_queue_area (void * start, void * end, int * num)
{
  int D.19955;
  void * * D.19958;
  void * * pin_queue.16;
  unsigned int first.17;
  unsigned int D.19961;
  int first;
  int last;

  first = optimized_pin_queue_search (start);
  last = optimized_pin_queue_search (end);
  D.19955 = last - first;
  *num = D.19955;
  if (first == last) goto <D.19956>; else goto <D.19957>;
  <D.19956>:
  D.19958 = 0B;
  return D.19958;
  <D.19957>:
  pin_queue.16 = pin_queue;
  first.17 = (unsigned int) first;
  D.19961 = first.17 * 4;
  D.19958 = pin_queue.16 + D.19961;
  return D.19958;
}


optimized_pin_queue_search (void * addr)
{
  int D.19963;
  int D.19964;
  void * * pin_queue.18;
  unsigned int middle.19;
  unsigned int D.19967;
  void * * D.19968;
  void * D.19969;
  _Bool D.19973;
  long int D.19974;
  long int D.19975;
  int D.19978;
  int first;
  int last;

  first = 0;
  last = next_pin_slot;
  goto <D.19797>;
  <D.19796>:
  {
    int middle;

    D.19963 = last - first;
    D.19964 = D.19963 >> 1;
    middle = D.19964 + first;
    pin_queue.18 = pin_queue;
    middle.19 = (unsigned int) middle;
    D.19967 = middle.19 * 4;
    D.19968 = pin_queue.18 + D.19967;
    D.19969 = *D.19968;
    if (D.19969 >= addr) goto <D.19970>; else goto <D.19971>;
    <D.19970>:
    last = middle;
    goto <D.19972>;
    <D.19971>:
    first = middle + 1;
    <D.19972>:
  }
  <D.19797>:
  if (first < last) goto <D.19796>; else goto <D.19798>;
  <D.19798>:
  D.19973 = first != last;
  D.19974 = (long int) D.19973;
  D.19975 = __builtin_expect (D.19974, 0);
  if (D.19975 != 0) goto <D.19976>; else goto <D.19977>;
  <D.19976>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-pinning.c", 89, "first == last");
  <D.19977>:
  D.19978 = first;
  return D.19978;
}


sgen_find_section_pin_queue_start_end (struct GCMemSection * section)
{
  struct FILE * gc_debug_file.20;
  char * D.19983;
  char * D.19984;
  int * D.19985;
  void * * D.19986;
  int D.19989;

  if (0 != 0) goto <D.19980>; else goto <D.19981>;
  <D.19980>:
  gc_debug_file.20 = gc_debug_file;
  D.19983 = section->data;
  D.19984 = section->end_data;
  fprintf (gc_debug_file.20, "Pinning from section %p (%p-%p)\n", section, D.19983, D.19984);
  gc_debug_file.20 = gc_debug_file;
  fflush (gc_debug_file.20);
  <D.19981>:
  D.19983 = section->data;
  D.19984 = section->end_data;
  D.19985 = &section->pin_queue_num_entries;
  D.19986 = sgen_find_optimized_pin_queue_area (D.19983, D.19984, D.19985);
  section->pin_queue_start = D.19986;
  if (0 != 0) goto <D.19987>; else goto <D.19988>;
  <D.19987>:
  gc_debug_file.20 = gc_debug_file;
  D.19989 = section->pin_queue_num_entries;
  fprintf (gc_debug_file.20, "Found %d pinning addresses in section %p\n", D.19989, section);
  gc_debug_file.20 = gc_debug_file;
  fflush (gc_debug_file.20);
  <D.19988>:
}


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.19993;
  int D.19994;
  unsigned int D.19995;
  unsigned int D.19996;
  void * * pin_queue.24;
  unsigned int max_pin_slot.25;
  unsigned int D.19999;
  char * D.20002;
  char * D.20004;
  void * * start;
  void * * end;
  void * addr;

  D.19993 = section->pin_queue_start;
  D.19994 = section->pin_queue_num_entries;
  D.19995 = (unsigned int) D.19994;
  D.19996 = D.19995 * 4;
  start = D.19993 + D.19996;
  pin_queue.24 = pin_queue;
  max_pin_slot.25 = (unsigned int) max_pin_slot;
  D.19999 = max_pin_slot.25 * 4;
  end = pin_queue.24 + D.19999;
  if (start == 0B) goto <D.20000>; else goto <D.20001>;
  <D.20000>:
  return;
  <D.20001>:
  goto <D.19824>;
  <D.19823>:
  addr = *start;
  D.20002 = section->data;
  if (D.20002 > addr) goto <D.19822>; else goto <D.20003>;
  <D.20003>:
  D.20004 = section->end_data;
  if (D.20004 < addr) goto <D.19822>; else goto <D.20005>;
  <D.20005>:
  *start = 0B;
  start = start + 4;
  <D.19824>:
  if (start < end) goto <D.19823>; else goto <D.19822>;
  <D.19822>:
}


sgen_optimize_pin_queue (int start_slot)
{
  struct FILE * gc_debug_file.26;
  int next_pin_slot.27;
  int D.20011;
  void * * pin_queue.28;
  unsigned int start_slot.29;
  unsigned int D.20016;
  void * * D.20017;
  unsigned int next_pin_slot.30;
  unsigned int D.20019;
  void * * cur.31;
  void * D.20021;
  void * D.20022;
  void * D.20023;
  int start.32;
  int pin_queue.33;
  int D.20027;
  int next_pin_slot.34;
  void * * start;
  void * * cur;
  void * * end;

  if (0 != 0) goto <D.20007>; else goto <D.20008>;
  <D.20007>:
  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.20008>:
  next_pin_slot.27 = next_pin_slot;
  D.20011 = next_pin_slot.27 - start_slot;
  if (D.20011 > 1) goto <D.20012>; else goto <D.20013>;
  <D.20012>:
  pin_queue.28 = pin_queue;
  start_slot.29 = (unsigned int) start_slot;
  D.20016 = start_slot.29 * 4;
  D.20017 = pin_queue.28 + D.20016;
  next_pin_slot.27 = next_pin_slot;
  D.20011 = next_pin_slot.27 - start_slot;
  sgen_sort_addresses (D.20017, D.20011);
  <D.20013>:
  pin_queue.28 = pin_queue;
  start_slot.29 = (unsigned int) start_slot;
  D.20016 = start_slot.29 * 4;
  cur = pin_queue.28 + D.20016;
  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.20019 = next_pin_slot.30 * 4;
  end = pin_queue.28 + D.20019;
  goto <D.19835>;
  <D.19834>:
  cur.31 = cur;
  cur = cur.31 + 4;
  D.20021 = *cur.31;
  *start = D.20021;
  goto <D.19832>;
  <D.19831>:
  cur = cur + 4;
  <D.19832>:
  D.20022 = *start;
  D.20023 = *cur;
  if (D.20022 == D.20023) goto <D.20024>; else goto <D.19833>;
  <D.20024>:
  if (cur < end) goto <D.19831>; else goto <D.19833>;
  <D.19833>:
  start = start + 4;
  <D.19835>:
  if (cur < end) goto <D.19834>; else goto <D.19836>;
  <D.19836>:
  start.32 = (int) start;
  pin_queue.28 = pin_queue;
  pin_queue.33 = (int) pin_queue.28;
  D.20027 = start.32 - pin_queue.33;
  next_pin_slot.34 = D.20027 /[ex] 4;
  next_pin_slot = next_pin_slot.34;
  if (0 != 0) goto <D.20029>; else goto <D.20030>;
  <D.20029>:
  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.20030>:
}


sgen_get_pinned_count ()
{
  int D.20031;

  D.20031 = next_pin_slot;
  return D.20031;
}


sgen_dump_pin_queue ()
{
  struct FILE * gc_debug_file.35;
  void * * pin_queue.36;
  unsigned int i.37;
  unsigned int D.20038;
  void * * D.20039;
  void * D.20040;
  const char * D.20041;
  unsigned int D.20042;
  int last_num_pinned.38;
  int i;

  i = 0;
  goto <D.19845>;
  <D.19844>:
  if (0 != 0) goto <D.20033>; else goto <D.20034>;
  <D.20033>:
  gc_debug_file.35 = gc_debug_file;
  pin_queue.36 = pin_queue;
  i.37 = (unsigned int) i;
  D.20038 = i.37 * 4;
  D.20039 = pin_queue.36 + D.20038;
  D.20040 = *D.20039;
  pin_queue.36 = pin_queue;
  i.37 = (unsigned int) i;
  D.20038 = i.37 * 4;
  D.20039 = pin_queue.36 + D.20038;
  D.20040 = *D.20039;
  D.20041 = sgen_safe_name (D.20040);
  pin_queue.36 = pin_queue;
  i.37 = (unsigned int) i;
  D.20038 = i.37 * 4;
  D.20039 = pin_queue.36 + D.20038;
  D.20040 = *D.20039;
  D.20042 = sgen_safe_object_get_size (D.20040);
  fprintf (gc_debug_file.35, "Bastard pinning obj %p (%s), size: %d\n", D.20040, D.20041, D.20042);
  gc_debug_file.35 = gc_debug_file;
  fflush (gc_debug_file.35);
  <D.20034>:
  i = i + 1;
  <D.19845>:
  last_num_pinned.38 = last_num_pinned;
  if (i < last_num_pinned.38) goto <D.19844>; else goto <D.19846>;
  <D.19846>:
}


sgen_cement_init (gboolean enabled)
{
  cement_enabled = enabled;
}


sgen_cement_reset ()
{
  int cement_concurrent.39;
  _Bool D.20045;
  long int D.20046;
  long int D.20047;

  cement_concurrent.39 = cement_concurrent;
  D.20045 = cement_concurrent.39 != 0;
  D.20046 = (long int) D.20045;
  D.20047 = __builtin_expect (D.20046, 0);
  if (D.20047 != 0) goto <D.20048>; else goto <D.20049>;
  <D.20048>:
  monoeg_g_log (0B, 4, "Concurrent cementing cannot simply be reset");
  <D.19861>:
  goto <D.19861>;
  <D.20049>:
  memset (&cement_hash, 0, 488);
}


sgen_cement_concurrent_start ()
{
  int cement_concurrent.40;
  _Bool D.20051;
  long int D.20052;
  long int D.20053;

  cement_concurrent.40 = cement_concurrent;
  D.20051 = cement_concurrent.40 != 0;
  D.20052 = (long int) D.20051;
  D.20053 = __builtin_expect (D.20052, 0);
  if (D.20053 != 0) goto <D.20054>; else goto <D.20055>;
  <D.20054>:
  monoeg_g_log (0B, 4, "Concurrent cementing has already been started");
  <D.19865>:
  goto <D.19865>;
  <D.20055>:
  cement_concurrent = 1;
  memset (&cement_hash_concurrent, 0, 488);
}


sgen_cement_concurrent_finish ()
{
  int cement_concurrent.41;
  _Bool D.20057;
  long int D.20058;
  long int D.20059;

  cement_concurrent.41 = cement_concurrent;
  D.20057 = cement_concurrent.41 == 0;
  D.20058 = (long int) D.20057;
  D.20059 = __builtin_expect (D.20058, 0);
  if (D.20059 != 0) goto <D.20060>; else goto <D.20061>;
  <D.20060>:
  monoeg_g_log (0B, 4, "Concurrent cementing hasn\'t been started");
  <D.19869>:
  goto <D.19869>;
  <D.20061>:
  cement_concurrent = 0;
  memcpy (&cement_hash, &cement_hash_concurrent, 488);
}


sgen_cement_lookup (char * obj)
{
  unsigned int D.20062;
  unsigned int D.20063;
  int D.20064;
  _Bool D.20065;
  long int D.20066;
  long int D.20067;
  int cement_enabled.42;
  gboolean D.20073;
  char * D.20074;
  unsigned int D.20079;
  _Bool D.20080;
  int i;

  D.20062 = mono_aligned_addr_hash (obj);
  D.20063 = D.20062 % 61;
  i = (int) D.20063;
  D.20064 = sgen_ptr_in_nursery (obj);
  D.20065 = D.20064 == 0;
  D.20066 = (long int) D.20065;
  D.20067 = __builtin_expect (D.20066, 0);
  if (D.20067 != 0) goto <D.20068>; else goto <D.20069>;
  <D.20068>:
  monoeg_g_log (0B, 4, "Looking up cementing for non-nursery objects makes no sense");
  <D.19874>:
  goto <D.19874>;
  <D.20069>:
  cement_enabled.42 = cement_enabled;
  if (cement_enabled.42 == 0) goto <D.20071>; else goto <D.20072>;
  <D.20071>:
  D.20073 = 0;
  return D.20073;
  <D.20072>:
  D.20074 = cement_hash[i].obj;
  if (D.20074 == 0B) goto <D.20075>; else goto <D.20076>;
  <D.20075>:
  D.20073 = 0;
  return D.20073;
  <D.20076>:
  D.20074 = cement_hash[i].obj;
  if (D.20074 != obj) goto <D.20077>; else goto <D.20078>;
  <D.20077>:
  D.20073 = 0;
  return D.20073;
  <D.20078>:
  D.20079 = cement_hash[i].count;
  D.20080 = D.20079 > 999;
  D.20073 = (gboolean) D.20080;
  return D.20073;
}


sgen_ptr_in_nursery (void * p)
{
  gboolean D.20082;
  int sgen_nursery_bits.43;
  int D.20084;
  int D.20085;
  unsigned int D.20086;
  unsigned int p.44;
  unsigned int D.20088;
  char * sgen_nursery_start.45;
  unsigned int sgen_nursery_start.46;
  _Bool D.20091;

  sgen_nursery_bits.43 = sgen_nursery_bits;
  D.20084 = 1 << sgen_nursery_bits.43;
  D.20085 = -D.20084;
  D.20086 = (unsigned int) D.20085;
  p.44 = (unsigned int) p;
  D.20088 = D.20086 & p.44;
  sgen_nursery_start.45 = sgen_nursery_start;
  sgen_nursery_start.46 = (unsigned int) sgen_nursery_start.45;
  D.20091 = D.20088 == sgen_nursery_start.46;
  D.20082 = (gboolean) D.20091;
  return D.20082;
}


sgen_cement_lookup_or_register (char * obj)
{
  int cement_enabled.47;
  gboolean D.20096;
  int cement_concurrent.48;
  _Bool D.20100;
  long int D.20101;
  long int D.20102;
  unsigned int D.20108;
  unsigned int D.20109;
  int D.20110;
  _Bool D.20111;
  long int D.20112;
  long int D.20113;
  unsigned int i.49;
  unsigned int D.20117;
  struct CementHashEntry * D.20118;
  char * D.20119;
  unsigned int D.20122;
  _Bool D.20123;
  long int D.20124;
  long int D.20125;
  unsigned int D.20133;
  unsigned int D.20138;
  unsigned int D.20139;
  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.20094>; else goto <D.20095>;
  <D.20094>:
  D.20096 = 0;
  return D.20096;
  <D.20095>:
  if (concurrent_cementing != 0) goto <D.20097>; else goto <D.20098>;
  <D.20097>:
  cement_concurrent.48 = cement_concurrent;
  D.20100 = cement_concurrent.48 == 0;
  D.20101 = (long int) D.20100;
  D.20102 = __builtin_expect (D.20101, 0);
  if (D.20102 != 0) goto <D.20103>; else goto <D.20104>;
  <D.20103>:
  monoeg_g_log (0B, 4, "Cementing wasn\'t inited with concurrent flag");
  <D.19881>:
  goto <D.19881>;
  <D.20104>:
  <D.20098>:
  if (concurrent_cementing != 0) goto <D.20105>; else goto <D.20106>;
  <D.20105>:
  hash = &cement_hash_concurrent;
  goto <D.20107>;
  <D.20106>:
  hash = &cement_hash;
  <D.20107>:
  D.20108 = mono_aligned_addr_hash (obj);
  D.20109 = D.20108 % 61;
  i = (int) D.20109;
  D.20110 = sgen_ptr_in_nursery (obj);
  D.20111 = D.20110 == 0;
  D.20112 = (long int) D.20111;
  D.20113 = __builtin_expect (D.20112, 0);
  if (D.20113 != 0) goto <D.20114>; else goto <D.20115>;
  <D.20114>:
  monoeg_g_log (0B, 4, "Can only cement pointers to nursery objects");
  <D.19882>:
  goto <D.19882>;
  <D.20115>:
  i.49 = (unsigned int) i;
  D.20117 = i.49 * 8;
  D.20118 = hash + D.20117;
  D.20119 = D.20118->obj;
  if (D.20119 == 0B) goto <D.20120>; else goto <D.20121>;
  <D.20120>:
  i.49 = (unsigned int) i;
  D.20117 = i.49 * 8;
  D.20118 = hash + D.20117;
  D.20122 = D.20118->count;
  D.20123 = D.20122 != 0;
  D.20124 = (long int) D.20123;
  D.20125 = __builtin_expect (D.20124, 0);
  if (D.20125 != 0) goto <D.20126>; else goto <D.20127>;
  <D.20126>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.19883>:
  goto <D.19883>;
  <D.20127>:
  i.49 = (unsigned int) i;
  D.20117 = i.49 * 8;
  D.20118 = hash + D.20117;
  D.20118->obj = obj;
  goto <D.20128>;
  <D.20121>:
  i.49 = (unsigned int) i;
  D.20117 = i.49 * 8;
  D.20118 = hash + D.20117;
  D.20119 = D.20118->obj;
  if (D.20119 != obj) goto <D.20129>; else goto <D.20130>;
  <D.20129>:
  D.20096 = 0;
  return D.20096;
  <D.20130>:
  <D.20128>:
  i.49 = (unsigned int) i;
  D.20117 = i.49 * 8;
  D.20118 = hash + D.20117;
  D.20122 = D.20118->count;
  if (D.20122 > 999) goto <D.20131>; else goto <D.20132>;
  <D.20131>:
  D.20096 = 1;
  return D.20096;
  <D.20132>:
  i.49 = (unsigned int) i;
  D.20117 = i.49 * 8;
  D.20118 = hash + D.20117;
  D.20122 = D.20118->count;
  D.20133 = D.20122 + 1;
  D.20118->count = D.20133;
  i.49 = (unsigned int) i;
  D.20117 = i.49 * 8;
  D.20118 = hash + D.20117;
  D.20122 = D.20118->count;
  if (D.20122 == 1000) goto <D.20134>; else goto <D.20135>;
  <D.20134>:
  if (0 != 0) goto <D.20136>; else goto <D.20137>;
  <D.20136>:
  {
    struct MonoVTable * vt;

    D.20138 = MEM[(mword *)obj];
    D.20139 = D.20138 & 4294967292;
    vt = (struct MonoVTable *) D.20139;
  }
  <D.20137>:
  <D.20135>:
  D.20096 = 0;
  return D.20096;
}


sgen_cement_iterate (void (*IterateObjectCallbackFunc) (char *, size_t, void *) callback, void * callback_data)
{
  unsigned int D.20141;
  _Bool D.20144;
  long int D.20145;
  long int D.20146;
  char * D.20149;
  int i;

  i = 0;
  goto <D.19893>;
  <D.19892>:
  D.20141 = cement_hash[i].count;
  if (D.20141 == 0) goto <D.20142>; else goto <D.20143>;
  <D.20142>:
  // predicted unlikely by continue predictor.
  goto <D.19890>;
  <D.20143>:
  D.20141 = cement_hash[i].count;
  D.20144 = D.20141 <= 999;
  D.20145 = (long int) D.20144;
  D.20146 = __builtin_expect (D.20145, 0);
  if (D.20146 != 0) goto <D.20147>; else goto <D.20148>;
  <D.20147>:
  monoeg_g_log (0B, 4, "Cementing hash inconsistent");
  <D.19891>:
  goto <D.19891>;
  <D.20148>:
  D.20149 = cement_hash[i].obj;
  callback (D.20149, 0, callback_data);
  <D.19890>:
  i = i + 1;
  <D.19893>:
  if (i <= 60) goto <D.19892>; else goto <D.19894>;
  <D.19894>:
}


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

  i = 0;
  goto <D.19900>;
  <D.19899>:
  D.20150 = cement_hash[i].count;
  if (D.20150 <= 999) goto <D.20151>; else goto <D.20152>;
  <D.20151>:
  cement_hash[i].obj = 0B;
  cement_hash[i].count = 0;
  <D.20152>:
  i = i + 1;
  <D.19900>:
  if (i <= 60) goto <D.19899>; else goto <D.19901>;
  <D.19901>:
}