GC_invalidate_map (struct hdr * hhdr)
{
  map_entry_type * GC_invalid_map.0;
  char * GC_invalid_map.1;
  sizetype displ.2;
  map_entry_type * D.7037;
  long unsigned int displ.3;
  register int displ;

  GC_invalid_map.0 = GC_invalid_map;
  if (GC_invalid_map.0 == 0B) goto <D.7031>; else goto <D.7032>;
  <D.7031>:
  GC_invalid_map.1 = GC_scratch_alloc (4096);
  GC_invalid_map = GC_invalid_map.1;
  GC_invalid_map.0 = GC_invalid_map;
  if (GC_invalid_map.0 == 0B) goto <D.7034>; else goto <D.7035>;
  <D.7034>:
  GC_err_puts ("Cant initialize GC_invalid_map: insufficient memory\n");
  exit (1);
  <D.7035>:
  displ = 0;
  goto <D.6993>;
  <D.6992>:
  GC_invalid_map.0 = GC_invalid_map;
  displ.2 = (sizetype) displ;
  D.7037 = GC_invalid_map.0 + displ.2;
  *D.7037 = 255;
  displ = displ + 1;
  <D.6993>:
  displ.3 = (long unsigned int) displ;
  if (displ.3 <= 4095) goto <D.6992>; else goto <D.6994>;
  <D.6994>:
  <D.7032>:
  GC_invalid_map.0 = GC_invalid_map;
  hhdr->hb_map = GC_invalid_map.0;
}


GC_register_displacement (GC_word offset)
{
  int D.7039;

  D.7039 = GC_test_and_set (&GC_allocate_lock);
  if (D.7039 != 0) goto <D.7040>; else goto <D.7041>;
  <D.7040>:
  GC_lock ();
  <D.7041>:
  GC_register_displacement_inner (offset);
  GC_clear (&GC_allocate_lock);
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.7042;
  unsigned int D.7043;

  D.7043 = __sync_lock_test_and_set_4 (addr, 1);
  D.7042 = (int) D.7043;
  return D.7042;
}


GC_clear (volatile unsigned int * addr)
{
  __sync_synchronize ();
  *addr = 0;
}


GC_register_displacement_inner (word offset)
{
  char D.7049;
  long unsigned int D.7052;
  long unsigned int max_valid_offset.4;
  int GC_all_interior_pointers.5;
  map_entry_type * D.7059;
  map_entry_type * D.7064;
  unsigned char D.7065;
  map_entry_type * D.7069;
  register unsigned int i;
  word map_entry;

  map_entry = offset >> 2;
  if (offset > 2048) goto <D.7045>; else goto <D.7046>;
  <D.7045>:
  GC_abort ("Bad argument to GC_register_displacement");
  <D.7046>:
  if (map_entry > 253) goto <D.7047>; else goto <D.7048>;
  <D.7047>:
  map_entry = 254;
  <D.7048>:
  D.7049 = GC_arrays._valid_offsets[offset];
  if (D.7049 == 0) goto <D.7050>; else goto <D.7051>;
  <D.7050>:
  GC_arrays._valid_offsets[offset] = 1;
  D.7052 = offset & 3;
  GC_arrays._modws_valid_offsets[D.7052] = 1;
  max_valid_offset.4 = max_valid_offset;
  if (offset > max_valid_offset.4) goto <D.7054>; else goto <D.7055>;
  <D.7054>:
  max_valid_offset = offset;
  <D.7055>:
  GC_all_interior_pointers.5 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.5 == 0) goto <D.7057>; else goto <D.7058>;
  <D.7057>:
  i = 0;
  goto <D.7009>;
  <D.7008>:
  D.7059 = GC_arrays._obj_map[i];
  if (D.7059 != 0B) goto <D.7060>; else goto <D.7061>;
  <D.7060>:
  if (i == 0) goto <D.7062>; else goto <D.7063>;
  <D.7062>:
  D.7059 = GC_arrays._obj_map[i];
  D.7064 = D.7059 + offset;
  D.7065 = (unsigned char) map_entry;
  *D.7064 = D.7065;
  goto <D.7066>;
  <D.7063>:
  {
    register unsigned int j;
    register unsigned int lb;

    lb = i << 2;
    if (offset < lb) goto <D.7067>; else goto <D.7068>;
    <D.7067>:
    j = offset;
    goto <D.7006>;
    <D.7005>:
    D.7059 = GC_arrays._obj_map[i];
    D.7069 = D.7059 + j;
    D.7065 = (unsigned char) map_entry;
    *D.7069 = D.7065;
    j = j + lb;
    <D.7006>:
    if (j <= 4095) goto <D.7005>; else goto <D.7007>;
    <D.7007>:
    <D.7068>:
  }
  <D.7066>:
  <D.7061>:
  i = i + 1;
  <D.7009>:
  if (i <= 512) goto <D.7008>; else goto <D.7010>;
  <D.7010>:
  <D.7058>:
  <D.7051>:
}


GC_add_map_entry (word sz)
{
  map_entry_type * D.7072;
  GC_bool D.7075;
  int GC_all_interior_pointers.6;
  char D.7084;
  map_entry_type * D.7087;
  unsigned char D.7088;
  long unsigned int max_valid_offset.7;
  unsigned int D.7096;
  map_entry_type * D.7097;
  long unsigned int D.7098;
  long unsigned int D.7099;
  register unsigned int obj_start;
  register unsigned int displ;
  register map_entry_type * new_map;
  word map_entry;

  if (sz > 512) goto <D.7070>; else goto <D.7071>;
  <D.7070>:
  sz = 0;
  <D.7071>:
  D.7072 = GC_arrays._obj_map[sz];
  if (D.7072 != 0B) goto <D.7073>; else goto <D.7074>;
  <D.7073>:
  D.7075 = 1;
  return D.7075;
  <D.7074>:
  new_map = GC_scratch_alloc (4096);
  if (new_map == 0B) goto <D.7076>; else goto <D.7077>;
  <D.7076>:
  D.7075 = 0;
  return D.7075;
  <D.7077>:
  memset (new_map, 255, 4096);
  if (sz == 0) goto <D.7078>; else goto <D.7079>;
  <D.7078>:
  displ = 0;
  goto <D.7019>;
  <D.7018>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.6 != 0) goto <D.7080>; else goto <D.7083>;
  <D.7083>:
  D.7084 = GC_arrays._valid_offsets[displ];
  if (D.7084 != 0) goto <D.7080>; else goto <D.7081>;
  <D.7080>:
  map_entry = displ >> 2;
  if (map_entry > 253) goto <D.7085>; else goto <D.7086>;
  <D.7085>:
  map_entry = 254;
  <D.7086>:
  D.7087 = new_map + displ;
  D.7088 = (unsigned char) map_entry;
  *D.7087 = D.7088;
  <D.7081>:
  displ = displ + 1;
  <D.7019>:
  max_valid_offset.7 = max_valid_offset;
  if (displ <= max_valid_offset.7) goto <D.7018>; else goto <D.7020>;
  <D.7020>:
  goto <D.7090>;
  <D.7079>:
  obj_start = 0;
  goto <D.7025>;
  <D.7024>:
  displ = 0;
  goto <D.7022>;
  <D.7021>:
  GC_all_interior_pointers.6 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.6 != 0) goto <D.7091>; else goto <D.7093>;
  <D.7093>:
  D.7084 = GC_arrays._valid_offsets[displ];
  if (D.7084 != 0) goto <D.7091>; else goto <D.7092>;
  <D.7091>:
  map_entry = displ >> 2;
  if (map_entry > 253) goto <D.7094>; else goto <D.7095>;
  <D.7094>:
  map_entry = 254;
  <D.7095>:
  D.7096 = obj_start + displ;
  D.7097 = new_map + D.7096;
  D.7088 = (unsigned char) map_entry;
  *D.7097 = D.7088;
  <D.7092>:
  displ = displ + 1;
  <D.7022>:
  max_valid_offset.7 = max_valid_offset;
  if (displ <= max_valid_offset.7) goto <D.7021>; else goto <D.7023>;
  <D.7023>:
  D.7098 = sz << 2;
  obj_start = D.7098 + obj_start;
  <D.7025>:
  D.7098 = sz << 2;
  D.7099 = D.7098 + obj_start;
  if (D.7099 <= 4096) goto <D.7024>; else goto <D.7026>;
  <D.7026>:
  <D.7090>:
  GC_arrays._obj_map[sz] = new_map;
  D.7075 = 1;
  return D.7075;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.7103;
  int D.7108;
  void * D.7110;
  unsigned int D.7111;

  D.7103 = __builtin_constant_p (__len);
  if (D.7103 != 0) goto <D.7104>; else goto <D.7105>;
  <D.7104>:
  if (__len == 0) goto <D.7106>; else goto <D.7107>;
  <D.7106>:
  D.7108 = __builtin_constant_p (__ch);
  if (D.7108 == 0) goto <D.7101>; else goto <D.7109>;
  <D.7109>:
  if (__ch != 0) goto <D.7101>; else goto <D.7102>;
  <D.7101>:
  __warn_memset_zero_len ();
  D.7110 = __dest;
  return D.7110;
  <D.7102>:
  <D.7107>:
  <D.7105>:
  D.7111 = __builtin_object_size (__dest, 0);
  D.7110 = __builtin___memset_chk (__dest, __ch, __len, D.7111);
  return D.7110;
}