GC_repeat_read (int fd, char * buf, size_t count)
{
  long unsigned int num_read.0;
  long unsigned int D.7216;
  sizetype num_read.1;
  void * D.7218;
  ssize_t D.7221;
  ssize_t num_read;
  ssize_t result;

  num_read = 0;
  goto <D.7037>;
  <D.7036>:
  num_read.0 = (long unsigned int) num_read;
  D.7216 = count - num_read.0;
  num_read.1 = (sizetype) num_read;
  D.7218 = buf + num_read.1;
  result = read (fd, D.7218, D.7216);
  if (result < 0) goto <D.7219>; else goto <D.7220>;
  <D.7219>:
  D.7221 = result;
  return D.7221;
  <D.7220>:
  if (result == 0) goto <D.7035>; else goto <D.7222>;
  <D.7222>:
  num_read = num_read + result;
  <D.7037>:
  num_read.0 = (long unsigned int) num_read;
  if (num_read.0 < count) goto <D.7036>; else goto <D.7035>;
  <D.7035>:
  D.7221 = num_read;
  return D.7221;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.7224;
  int D.7227;
  ssize_t D.7230;
  long unsigned int D.7231;
  long unsigned int D.7232;
  long unsigned int D.7235;

  D.7224 = __builtin_object_size (__buf, 0);
  if (D.7224 != 18446744073709551615) goto <D.7225>; else goto <D.7226>;
  <D.7225>:
  D.7227 = __builtin_constant_p (__nbytes);
  if (D.7227 == 0) goto <D.7228>; else goto <D.7229>;
  <D.7228>:
  D.7231 = __builtin_object_size (__buf, 0);
  D.7230 = __read_chk (__fd, __buf, __nbytes, D.7231);
  return D.7230;
  <D.7229>:
  D.7232 = __builtin_object_size (__buf, 0);
  if (D.7232 < __nbytes) goto <D.7233>; else goto <D.7234>;
  <D.7233>:
  D.7235 = __builtin_object_size (__buf, 0);
  D.7230 = __read_chk_warn (__fd, __buf, __nbytes, D.7235);
  return D.7230;
  <D.7234>:
  <D.7226>:
  D.7230 = __read_alias (__fd, __buf, __nbytes);
  return D.7230;
}


GC_apply_to_maps (word (*<T14cb>) (char *) fn)
{
  long unsigned int maps_buf_sz.2;
  long unsigned int maps_buf_sz.3;
  char * maps_buf.4;
  char * maps_buf.5;
  word D.7245;
  long unsigned int D.7248;
  long int D.7249;
  long unsigned int D.7252;
  char * D.7253;
  int f;
  int result;
  size_t maps_size;
  static char init_buf[1];
  static char * maps_buf = (char *) &init_buf;
  static size_t maps_buf_sz = 1;

  maps_size = 4000;
  <D.7053>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.7238>; else goto <D.7239>;
  <D.7238>:
  goto <D.7049>;
  <D.7048>:
  maps_buf_sz.2 = maps_buf_sz;
  maps_buf_sz.3 = maps_buf_sz.2 * 2;
  maps_buf_sz = maps_buf_sz.3;
  <D.7049>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.7048>; else goto <D.7050>;
  <D.7050>:
  maps_buf_sz.2 = maps_buf_sz;
  maps_buf.4 = GC_scratch_alloc (maps_buf_sz.2);
  maps_buf = maps_buf.4;
  maps_buf.5 = maps_buf;
  if (maps_buf.5 == 0B) goto <D.7243>; else goto <D.7244>;
  <D.7243>:
  D.7245 = 0;
  return D.7245;
  <D.7244>:
  <D.7239>:
  f = open ("/proc/self/maps", 0);
  if (f == -1) goto <D.7246>; else goto <D.7247>;
  <D.7246>:
  D.7245 = 0;
  return D.7245;
  <D.7247>:
  maps_size = 0;
  <D.7051>:
  maps_buf_sz.2 = maps_buf_sz;
  D.7248 = maps_buf_sz.2 + 18446744073709551615;
  maps_buf.5 = maps_buf;
  D.7249 = GC_repeat_read (f, maps_buf.5, D.7248);
  result = (int) D.7249;
  if (result <= 0) goto <D.7250>; else goto <D.7251>;
  <D.7250>:
  D.7245 = 0;
  return D.7245;
  <D.7251>:
  D.7252 = (long unsigned int) result;
  maps_size = D.7252 + maps_size;
  D.7252 = (long unsigned int) result;
  maps_buf_sz.2 = maps_buf_sz;
  D.7248 = maps_buf_sz.2 + 18446744073709551615;
  if (D.7252 == D.7248) goto <D.7051>; else goto <D.7052>;
  <D.7052>:
  close (f);
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.7053>; else goto <D.7054>;
  <D.7054>:
  maps_buf.5 = maps_buf;
  D.7253 = maps_buf.5 + maps_size;
  *D.7253 = 0;
  maps_buf.5 = maps_buf;
  D.7245 = fn (maps_buf.5);
  return D.7245;
}


open (const char * __path, int __oflag)
{
  int D.7255;
  int D.7258;
  int D.7263;
  int D.7265;
  int D.7266;
  int D.7269;
  int D.7270;

  D.7255 = __builtin_va_arg_pack_len ();
  if (D.7255 > 1) goto <D.7256>; else goto <D.7257>;
  <D.7256>:
  __open_too_many_args ();
  <D.7257>:
  D.7258 = __builtin_constant_p (__oflag);
  if (D.7258 != 0) goto <D.7259>; else goto <D.7260>;
  <D.7259>:
  D.7263 = __oflag & 64;
  if (D.7263 != 0) goto <D.7261>; else goto <D.7264>;
  <D.7264>:
  D.7265 = __oflag & 4259840;
  if (D.7265 == 4259840) goto <D.7261>; else goto <D.7262>;
  <D.7261>:
  D.7266 = __builtin_va_arg_pack_len ();
  if (D.7266 <= 0) goto <D.7267>; else goto <D.7268>;
  <D.7267>:
  __open_missing_mode ();
  D.7269 = __open_2 (__path, __oflag);
  return D.7269;
  <D.7268>:
  <D.7262>:
  D.7269 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7269;
  <D.7260>:
  D.7270 = __builtin_va_arg_pack_len ();
  if (D.7270 <= 0) goto <D.7271>; else goto <D.7272>;
  <D.7271>:
  D.7269 = __open_2 (__path, __oflag);
  return D.7269;
  <D.7272>:
  D.7269 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7269;
}


GC_init_linux_data_start ()
{
  int GC_no_dls.6;
  char * GC_data_start.7;
  extern char * GC_find_limit ();

  GC_no_dls.6 = GC_no_dls;
  if (GC_no_dls.6 != 0) goto <D.7275>; else goto <D.7276>;
  <D.7275>:
  return;
  <D.7276>:
  if (&__data_start != 0B) goto <D.7277>; else goto <D.7278>;
  <D.7277>:
  GC_data_start = &__data_start;
  return;
  <D.7278>:
  if (&data_start != 0B) goto <D.7279>; else goto <D.7280>;
  <D.7279>:
  GC_data_start = &data_start;
  return;
  <D.7280>:
  GC_data_start.7 = GC_find_limit (&_end, 0);
  GC_data_start = GC_data_start.7;
}


GC_disable_signals ()
{
  int mask_initialized.8;
  int new_mask.9;
  int new_mask.10;
  int new_mask.11;
  int new_mask.12;
  int new_mask.13;
  int new_mask.14;
  int new_mask.15;
  int old_mask.16;

  mask_initialized.8 = mask_initialized;
  if (mask_initialized.8 == 0) goto <D.7284>; else goto <D.7285>;
  <D.7284>:
  new_mask = 2147483647;
  new_mask.9 = new_mask;
  new_mask.10 = new_mask.9 & -1025;
  new_mask = new_mask.10;
  new_mask.9 = new_mask;
  new_mask.11 = new_mask.9 & -9;
  new_mask = new_mask.11;
  new_mask.9 = new_mask;
  new_mask.12 = new_mask.9 & -5;
  new_mask = new_mask.12;
  new_mask.9 = new_mask;
  new_mask.13 = new_mask.9 & -65;
  new_mask = new_mask.13;
  new_mask.9 = new_mask;
  new_mask.14 = new_mask.9 & -33;
  new_mask = new_mask.14;
  new_mask.9 = new_mask;
  new_mask.15 = new_mask.9 & -17;
  new_mask = new_mask.15;
  mask_initialized = 1;
  <D.7285>:
  new_mask.9 = new_mask;
  old_mask.16 = sigsetmask (new_mask.9);
  old_mask = old_mask.16;
}


GC_enable_signals ()
{
  int old_mask.17;
  int dummy.18;

  old_mask.17 = old_mask;
  dummy.18 = sigsetmask (old_mask.17);
  dummy = dummy.18;
}


GC_setpagesize ()
{
  int D.7296;
  long unsigned int GC_page_size.19;

  D.7296 = getpagesize ();
  GC_page_size.19 = (long unsigned int) D.7296;
  GC_page_size = GC_page_size.19;
}


GC_set_and_save_fault_handler (void (*handler) (int) h)
{
  void (*<T763>) (int) old_segv_handler.20;
  void (*<T763>) (int) old_bus_handler.21;

  old_segv_handler.20 = signal (11, h);
  old_segv_handler = old_segv_handler.20;
  old_bus_handler.21 = signal (7, h);
  old_bus_handler = old_bus_handler.21;
}


GC_fault_handler (int sig)
{
  siglongjmp (&GC_jmp_buf, 1);
}


GC_setup_temporary_fault_handler ()
{
  GC_set_and_save_fault_handler (GC_fault_handler);
}


GC_reset_fault_handler ()
{
  void (*<T763>) (int) old_segv_handler.22;
  void (*<T763>) (int) old_bus_handler.23;

  old_segv_handler.22 = old_segv_handler;
  signal (11, old_segv_handler.22);
  old_bus_handler.23 = old_bus_handler;
  signal (7, old_bus_handler.23);
}


GC_find_limit (char * p, GC_bool up)
{
  int D.7302;
  long unsigned int p.24;
  long unsigned int D.7306;
  char * result.25;
  char * result.26;
  char * result.27;
  char * result.28;
  char * result.29;
  char * result.30;
  char D.7316;
  long unsigned int D.7317;
  char * result.31;
  char * result.32;
  char * D.7322;
  static char * volatile result;

  GC_setup_temporary_fault_handler ();
  D.7302 = __sigsetjmp (&GC_jmp_buf, 1);
  if (D.7302 == 0) goto <D.7303>; else goto <D.7304>;
  <D.7303>:
  p.24 = (long unsigned int) p;
  D.7306 = p.24 & 18446744073709551360;
  result.25 = (char *) D.7306;
  result = result.25;
  <D.7094>:
  if (up != 0) goto <D.7308>; else goto <D.7309>;
  <D.7308>:
  result.26 = result;
  result.27 = result.26 + 256;
  result = result.27;
  goto <D.7312>;
  <D.7309>:
  result.28 = result;
  result.29 = result.28 + 18446744073709551360;
  result = result.29;
  <D.7312>:
  result.30 = result;
  D.7316 = *result.30;
  D.7317 = (long unsigned int) D.7316;
  GC_noop1 (D.7317);
  goto <D.7094>;
  <D.7304>:
  GC_reset_fault_handler ();
  if (up == 0) goto <D.7318>; else goto <D.7319>;
  <D.7318>:
  result.31 = result;
  result.32 = result.31 + 256;
  result = result.32;
  <D.7319>:
  D.7322 = result;
  return D.7322;
}


GC_linux_stack_base ()
{
  long int D.7327;
  long unsigned int buf_offset.33;
  long unsigned int buf_offset.34;
  const short unsigned int * * D.7330;
  const short unsigned int * D.7331;
  long unsigned int D.7332;
  long unsigned int D.7333;
  const short unsigned int * D.7334;
  short unsigned int D.7335;
  int D.7336;
  int D.7337;
  long unsigned int buf_offset.35;
  long unsigned int buf_offset.36;
  int D.7340;
  int D.7341;
  long unsigned int D.7342;
  long unsigned int buf_offset.37;
  int D.7344;
  char * D.7347;
  char stat_buf[4096];
  int f;
  char c;
  word result;
  size_t i;
  size_t buf_offset;

  try
    {
      result = 0;
      buf_offset = 0;
      f = open ("/proc/self/stat", 0);
      if (f < 0) goto <D.7324>; else goto <D.7326>;
      <D.7326>:
      D.7327 = read (f, &stat_buf, 4096);
      if (D.7327 <= 53) goto <D.7324>; else goto <D.7325>;
      <D.7324>:
      GC_abort ("Couldn\'t read /proc/self/stat");
      <D.7325>:
      buf_offset.33 = buf_offset;
      buf_offset = buf_offset.33 + 1;
      c = stat_buf[buf_offset.33];
      i = 0;
      goto <D.7112>;
      <D.7111>:
      goto <D.7106>;
      <D.7105>:
      buf_offset.34 = buf_offset;
      buf_offset = buf_offset.34 + 1;
      c = stat_buf[buf_offset.34];
      <D.7106>:
      D.7330 = __ctype_b_loc ();
      D.7331 = *D.7330;
      D.7332 = (long unsigned int) c;
      D.7333 = D.7332 * 2;
      D.7334 = D.7331 + D.7333;
      D.7335 = *D.7334;
      D.7336 = (int) D.7335;
      D.7337 = D.7336 & 8192;
      if (D.7337 != 0) goto <D.7105>; else goto <D.7107>;
      <D.7107>:
      goto <D.7109>;
      <D.7108>:
      buf_offset.35 = buf_offset;
      buf_offset = buf_offset.35 + 1;
      c = stat_buf[buf_offset.35];
      <D.7109>:
      D.7330 = __ctype_b_loc ();
      D.7331 = *D.7330;
      D.7332 = (long unsigned int) c;
      D.7333 = D.7332 * 2;
      D.7334 = D.7331 + D.7333;
      D.7335 = *D.7334;
      D.7336 = (int) D.7335;
      D.7337 = D.7336 & 8192;
      if (D.7337 == 0) goto <D.7108>; else goto <D.7110>;
      <D.7110>:
      i = i + 1;
      <D.7112>:
      if (i <= 26) goto <D.7111>; else goto <D.7113>;
      <D.7113>:
      goto <D.7115>;
      <D.7114>:
      buf_offset.36 = buf_offset;
      buf_offset = buf_offset.36 + 1;
      c = stat_buf[buf_offset.36];
      <D.7115>:
      D.7330 = __ctype_b_loc ();
      D.7331 = *D.7330;
      D.7332 = (long unsigned int) c;
      D.7333 = D.7332 * 2;
      D.7334 = D.7331 + D.7333;
      D.7335 = *D.7334;
      D.7336 = (int) D.7335;
      D.7337 = D.7336 & 8192;
      if (D.7337 != 0) goto <D.7114>; else goto <D.7116>;
      <D.7116>:
      goto <D.7118>;
      <D.7117>:
      result = result * 10;
      D.7340 = (int) c;
      D.7341 = D.7340 + -48;
      D.7342 = (long unsigned int) D.7341;
      result = D.7342 + result;
      buf_offset.37 = buf_offset;
      buf_offset = buf_offset.37 + 1;
      c = stat_buf[buf_offset.37];
      <D.7118>:
      D.7330 = __ctype_b_loc ();
      D.7331 = *D.7330;
      D.7332 = (long unsigned int) c;
      D.7333 = D.7332 * 2;
      D.7334 = D.7331 + D.7333;
      D.7335 = *D.7334;
      D.7336 = (int) D.7335;
      D.7344 = D.7336 & 2048;
      if (D.7344 != 0) goto <D.7117>; else goto <D.7119>;
      <D.7119>:
      close (f);
      if (result <= 268435455) goto <D.7345>; else goto <D.7346>;
      <D.7345>:
      GC_abort ("Absurd stack bottom value");
      <D.7346>:
      D.7347 = (char *) result;
      return D.7347;
    }
  finally
    {
      stat_buf = {CLOBBER};
    }
}


GC_get_stack_base ()
{
  char * D.7352;
  word dummy;
  char * result;

  result = GC_linux_stack_base ();
  if (result == 0B) goto <D.7350>; else goto <D.7351>;
  <D.7350>:
  result = -8B;
  <D.7351>:
  D.7352 = result;
  return D.7352;
}


GC_register_data_segments ()
{
  char * GC_data_start.38;

  GC_data_start.38 = GC_data_start;
  GC_add_roots_inner (GC_data_start.38, &_end, 0);
}


GC_unix_get_mem (word bytes)
{
  long unsigned int GC_page_size.39;
  long unsigned int D.7356;
  long unsigned int D.7357;
  char * last_addr.40;
  char * D.7363;
  sizetype D.7364;
  sizetype D.7365;
  char * last_addr.41;
  long unsigned int D.7367;
  long unsigned int last_addr.42;
  long unsigned int D.7369;
  char * last_addr.43;
  long unsigned int result.44;
  long unsigned int D.7372;
  void * result;
  static char * last_addr = 0B;

  GC_page_size.39 = GC_page_size;
  D.7356 = GC_page_size.39 + 18446744073709551615;
  D.7357 = D.7356 & bytes;
  if (D.7357 != 0) goto <D.7358>; else goto <D.7359>;
  <D.7358>:
  GC_abort ("Bad GET_MEM arg");
  <D.7359>:
  last_addr.40 = last_addr;
  result = mmap (last_addr.40, bytes, 3, 34, -1, 0);
  if (result == -1B) goto <D.7361>; else goto <D.7362>;
  <D.7361>:
  D.7363 = 0B;
  return D.7363;
  <D.7362>:
  GC_page_size.39 = GC_page_size;
  D.7364 = bytes + GC_page_size.39;
  D.7365 = D.7364 + 18446744073709551615;
  last_addr.41 = result + D.7365;
  last_addr = last_addr.41;
  GC_page_size.39 = GC_page_size;
  D.7367 = -GC_page_size.39;
  last_addr.40 = last_addr;
  last_addr.42 = (long unsigned int) last_addr.40;
  D.7369 = D.7367 & last_addr.42;
  last_addr.43 = (char *) D.7369;
  last_addr = last_addr.43;
  result.44 = (long unsigned int) result;
  D.7372 = result.44 & 4095;
  if (D.7372 != 0) goto <D.7373>; else goto <D.7374>;
  <D.7373>:
  GC_abort ("GC_unix_get_mem: Memory returned by mmap is not aligned to HBLKSIZE.");
  <D.7374>:
  D.7363 = result;
  return D.7363;
}


GC_unmap_start (char * start, word bytes)
{
  long unsigned int GC_page_size.45;
  sizetype D.7377;
  long unsigned int D.7378;
  long unsigned int result.46;
  long unsigned int D.7380;
  char * D.7381;
  char * D.7382;
  char * D.7385;
  char * result;

  result = start;
  GC_page_size.45 = GC_page_size;
  D.7377 = GC_page_size.45 + 18446744073709551615;
  result = result + D.7377;
  GC_page_size.45 = GC_page_size;
  D.7378 = -GC_page_size.45;
  result.46 = (long unsigned int) result;
  D.7380 = D.7378 & result.46;
  result = (char *) D.7380;
  GC_page_size.45 = GC_page_size;
  D.7381 = result + GC_page_size.45;
  D.7382 = start + bytes;
  if (D.7381 > D.7382) goto <D.7383>; else goto <D.7384>;
  <D.7383>:
  D.7385 = 0B;
  return D.7385;
  <D.7384>:
  D.7385 = result;
  return D.7385;
}


GC_unmap_end (char * start, word bytes)
{
  long unsigned int GC_page_size.47;
  long unsigned int D.7388;
  long unsigned int end_addr.48;
  long unsigned int D.7390;
  char * D.7391;
  char * end_addr;

  end_addr = start + bytes;
  GC_page_size.47 = GC_page_size;
  D.7388 = -GC_page_size.47;
  end_addr.48 = (long unsigned int) end_addr;
  D.7390 = D.7388 & end_addr.48;
  end_addr = (char *) D.7390;
  D.7391 = end_addr;
  return D.7391;
}


GC_unmap (char * start, word bytes)
{
  long int end_addr.49;
  long int start_addr.50;
  long int D.7395;
  long unsigned int D.7400;
  long unsigned int D.7401;
  char * start_addr;
  char * end_addr;
  word len;

  start_addr = GC_unmap_start (start, bytes);
  end_addr = GC_unmap_end (start, bytes);
  end_addr.49 = (long int) end_addr;
  start_addr.50 = (long int) start_addr;
  D.7395 = end_addr.49 - start_addr.50;
  len = (word) D.7395;
  if (start_addr == 0B) goto <D.7396>; else goto <D.7397>;
  <D.7396>:
  return;
  <D.7397>:
  {
    void * result;

    result = mmap (start_addr, len, 0, 50, -1, 0);
    if (result != start_addr) goto <D.7398>; else goto <D.7399>;
    <D.7398>:
    GC_abort ("mmap(...PROT_NONE...) failed");
    <D.7399>:
  }
  D.7400 = GC_arrays._unmapped_bytes;
  D.7401 = D.7400 + len;
  GC_arrays._unmapped_bytes = D.7401;
}


GC_remap (char * start, word bytes)
{
  long int end_addr.51;
  long int start_addr.52;
  long int D.7405;
  int * D.7410;
  int D.7411;
  long int D.7412;
  long int len.53;
  long unsigned int D.7414;
  long unsigned int D.7415;
  char * start_addr;
  char * end_addr;
  word len;
  int result;

  start_addr = GC_unmap_start (start, bytes);
  end_addr = GC_unmap_end (start, bytes);
  end_addr.51 = (long int) end_addr;
  start_addr.52 = (long int) start_addr;
  D.7405 = end_addr.51 - start_addr.52;
  len = (word) D.7405;
  if (start_addr == 0B) goto <D.7406>; else goto <D.7407>;
  <D.7406>:
  return;
  <D.7407>:
  result = mprotect (start_addr, len, 3);
  if (result != 0) goto <D.7408>; else goto <D.7409>;
  <D.7408>:
  D.7410 = __errno_location ();
  D.7411 = *D.7410;
  D.7412 = (long int) D.7411;
  len.53 = (long int) len;
  start_addr.52 = (long int) start_addr;
  GC_err_printf ("Mprotect failed at 0x%lx (length %ld) with errno %ld\n", start_addr.52, len.53, D.7412, 0, 0, 0);
  GC_abort ("Mprotect remapping failed");
  <D.7409>:
  D.7414 = GC_arrays._unmapped_bytes;
  D.7415 = D.7414 - len;
  GC_arrays._unmapped_bytes = D.7415;
}


GC_unmap_gap (char * start1, word bytes1, char * start2, word bytes2)
{
  long unsigned int D.7419;
  long int end_addr.54;
  long int start_addr.55;
  long int D.7426;
  long unsigned int D.7431;
  long unsigned int D.7432;
  char * start1_addr;
  char * end1_addr;
  char * start2_addr;
  char * end2_addr;
  char * start_addr;
  char * end_addr;
  word len;

  start1_addr = GC_unmap_start (start1, bytes1);
  end1_addr = GC_unmap_end (start1, bytes1);
  start2_addr = GC_unmap_start (start2, bytes2);
  end2_addr = GC_unmap_end (start2, bytes2);
  start_addr = end1_addr;
  end_addr = start2_addr;
  if (start1_addr == 0B) goto <D.7417>; else goto <D.7418>;
  <D.7417>:
  D.7419 = bytes1 + bytes2;
  start_addr = GC_unmap_start (start1, D.7419);
  <D.7418>:
  if (start2_addr == 0B) goto <D.7420>; else goto <D.7421>;
  <D.7420>:
  D.7419 = bytes1 + bytes2;
  end_addr = GC_unmap_end (start1, D.7419);
  <D.7421>:
  if (start_addr == 0B) goto <D.7422>; else goto <D.7423>;
  <D.7422>:
  return;
  <D.7423>:
  end_addr.54 = (long int) end_addr;
  start_addr.55 = (long int) start_addr;
  D.7426 = end_addr.54 - start_addr.55;
  len = (word) D.7426;
  if (len != 0) goto <D.7427>; else goto <D.7428>;
  <D.7427>:
  {
    void * result;

    result = mmap (start_addr, len, 0, 50, -1, 0);
    if (result != start_addr) goto <D.7429>; else goto <D.7430>;
    <D.7429>:
    GC_abort ("mmap(...PROT_NONE...) failed");
    <D.7430>:
  }
  <D.7428>:
  D.7431 = GC_arrays._unmapped_bytes;
  D.7432 = D.7431 + len;
  GC_arrays._unmapped_bytes = D.7432;
}


GC_default_push_other_roots ()
{
  GC_push_all_stacks ();
}


GC_dirty_init ()
{
  GC_dirty_maintained = 1;
}


GC_read_dirty ()
{

}


GC_page_was_dirty (struct hblk * h)
{
  GC_bool D.7434;

  D.7434 = 1;
  return D.7434;
}


GC_page_was_ever_dirty (struct hblk * h)
{
  GC_bool D.7436;

  D.7436 = 1;
  return D.7436;
}


GC_is_fresh (struct hblk * h, word n)
{

}


GC_remove_protection (struct hblk * h, word nblocks, GC_bool is_ptrfree)
{

}


GC_incremental_protection_needs ()
{
  int D.7438;

  D.7438 = 0;
  return D.7438;
}


GC_print_address_map ()
{
  GC_err_puts ("---------- Begin address map ----------\n");
  GC_apply_to_maps (dump_maps);
  GC_err_puts ("---------- End address map ----------\n");
}


dump_maps (char * maps)
{
  long unsigned int D.7440;
  word D.7441;

  D.7440 = strlen (maps);
  GC_err_write (maps, D.7440);
  D.7441 = 1;
  return D.7441;
}