GC_repeat_read (int fd, char * buf, size_t count)
{
  sizetype num_read.0;
  void * D.9384;
  unsigned int num_read.1;
  unsigned int D.9386;
  ssize_t D.9389;
  ssize_t num_read;
  ssize_t result;

  num_read = 0;
  goto <D.9203>;
  <D.9202>:
  num_read.0 = (sizetype) num_read;
  D.9384 = buf + num_read.0;
  num_read.1 = (unsigned int) num_read;
  D.9386 = count - num_read.1;
  result = read (fd, D.9384, D.9386);
  if (result < 0) goto <D.9387>; else goto <D.9388>;
  <D.9387>:
  D.9389 = result;
  return D.9389;
  <D.9388>:
  if (result == 0) goto <D.9201>; else goto <D.9390>;
  <D.9390>:
  num_read = num_read + result;
  <D.9203>:
  num_read.1 = (unsigned int) num_read;
  if (num_read.1 < count) goto <D.9202>; else goto <D.9201>;
  <D.9201>:
  D.9389 = num_read;
  return D.9389;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.9392;
  int D.9395;
  ssize_t D.9398;
  unsigned int D.9399;
  unsigned int D.9400;
  unsigned int D.9403;

  D.9392 = __builtin_object_size (__buf, 0);
  if (D.9392 != 4294967295) goto <D.9393>; else goto <D.9394>;
  <D.9393>:
  D.9395 = __builtin_constant_p (__nbytes);
  if (D.9395 == 0) goto <D.9396>; else goto <D.9397>;
  <D.9396>:
  D.9399 = __builtin_object_size (__buf, 0);
  D.9398 = __read_chk (__fd, __buf, __nbytes, D.9399);
  return D.9398;
  <D.9397>:
  D.9400 = __builtin_object_size (__buf, 0);
  if (D.9400 < __nbytes) goto <D.9401>; else goto <D.9402>;
  <D.9401>:
  D.9403 = __builtin_object_size (__buf, 0);
  D.9398 = __read_chk_warn (__fd, __buf, __nbytes, D.9403);
  return D.9398;
  <D.9402>:
  <D.9394>:
  D.9398 = __read_alias (__fd, __buf, __nbytes);
  return D.9398;
}


GC_apply_to_maps (word (*<T1e88>) (char *) fn)
{
  unsigned int maps_buf_sz.2;
  unsigned int maps_buf_sz.3;
  char * maps_buf.4;
  char * maps_buf.5;
  word D.9413;
  unsigned int D.9416;
  unsigned int result.6;
  char * D.9420;
  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.9219>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.9406>; else goto <D.9407>;
  <D.9406>:
  goto <D.9215>;
  <D.9214>:
  maps_buf_sz.2 = maps_buf_sz;
  maps_buf_sz.3 = maps_buf_sz.2 * 2;
  maps_buf_sz = maps_buf_sz.3;
  <D.9215>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.9214>; else goto <D.9216>;
  <D.9216>:
  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.9411>; else goto <D.9412>;
  <D.9411>:
  D.9413 = 0;
  return D.9413;
  <D.9412>:
  <D.9407>:
  f = open ("/proc/self/maps", 0);
  if (f == -1) goto <D.9414>; else goto <D.9415>;
  <D.9414>:
  D.9413 = 0;
  return D.9413;
  <D.9415>:
  maps_size = 0;
  <D.9217>:
  maps_buf.5 = maps_buf;
  maps_buf_sz.2 = maps_buf_sz;
  D.9416 = maps_buf_sz.2 + 4294967295;
  result = GC_repeat_read (f, maps_buf.5, D.9416);
  if (result <= 0) goto <D.9417>; else goto <D.9418>;
  <D.9417>:
  D.9413 = 0;
  return D.9413;
  <D.9418>:
  result.6 = (unsigned int) result;
  maps_size = maps_size + result.6;
  result.6 = (unsigned int) result;
  maps_buf_sz.2 = maps_buf_sz;
  D.9416 = maps_buf_sz.2 + 4294967295;
  if (result.6 == D.9416) goto <D.9217>; else goto <D.9218>;
  <D.9218>:
  close (f);
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.9219>; else goto <D.9220>;
  <D.9220>:
  maps_buf.5 = maps_buf;
  D.9420 = maps_buf.5 + maps_size;
  *D.9420 = 0;
  maps_buf.5 = maps_buf;
  D.9413 = fn (maps_buf.5);
  return D.9413;
}


open (const char * __path, int __oflag)
{
  int D.9422;
  int D.9425;
  int D.9430;
  int D.9432;
  int D.9433;
  int D.9436;
  int D.9437;

  D.9422 = __builtin_va_arg_pack_len ();
  if (D.9422 > 1) goto <D.9423>; else goto <D.9424>;
  <D.9423>:
  __open_too_many_args ();
  <D.9424>:
  D.9425 = __builtin_constant_p (__oflag);
  if (D.9425 != 0) goto <D.9426>; else goto <D.9427>;
  <D.9426>:
  D.9430 = __oflag & 64;
  if (D.9430 != 0) goto <D.9428>; else goto <D.9431>;
  <D.9431>:
  D.9432 = __oflag & 4210688;
  if (D.9432 == 4210688) goto <D.9428>; else goto <D.9429>;
  <D.9428>:
  D.9433 = __builtin_va_arg_pack_len ();
  if (D.9433 <= 0) goto <D.9434>; else goto <D.9435>;
  <D.9434>:
  __open_missing_mode ();
  D.9436 = __open_2 (__path, __oflag);
  return D.9436;
  <D.9435>:
  <D.9429>:
  D.9436 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.9436;
  <D.9427>:
  D.9437 = __builtin_va_arg_pack_len ();
  if (D.9437 <= 0) goto <D.9438>; else goto <D.9439>;
  <D.9438>:
  D.9436 = __open_2 (__path, __oflag);
  return D.9436;
  <D.9439>:
  D.9436 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.9436;
}


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

  GC_no_dls.7 = GC_no_dls;
  if (GC_no_dls.7 != 0) goto <D.9442>; else goto <D.9443>;
  <D.9442>:
  return;
  <D.9443>:
  if (&__data_start != 0B) goto <D.9444>; else goto <D.9445>;
  <D.9444>:
  GC_data_start = &__data_start;
  return;
  <D.9445>:
  if (&data_start != 0B) goto <D.9446>; else goto <D.9447>;
  <D.9446>:
  GC_data_start = &data_start;
  return;
  <D.9447>:
  GC_data_start.8 = GC_find_limit (&_end, 0);
  GC_data_start = GC_data_start.8;
}


GC_disable_signals ()
{
  int mask_initialized.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 new_mask.16;
  int old_mask.17;

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


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

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


GC_setpagesize ()
{
  int D.9463;
  long unsigned int GC_page_size.20;

  D.9463 = getpagesize ();
  GC_page_size.20 = (long unsigned int) D.9463;
  GC_page_size = GC_page_size.20;
}


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

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


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 (*<T112e>) (int) old_segv_handler.23;
  void (*<T112e>) (int) old_bus_handler.24;

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


GC_find_limit (char * p, GC_bool up)
{
  int D.9469;
  long unsigned int p.25;
  long unsigned int D.9473;
  char * result.26;
  char * result.27;
  char * result.28;
  char * result.29;
  char * result.30;
  char * result.31;
  char D.9483;
  long unsigned int D.9484;
  char * result.32;
  char * result.33;
  char * D.9489;
  static char * volatile result;

  GC_setup_temporary_fault_handler ();
  D.9469 = __sigsetjmp (&GC_jmp_buf, 1);
  if (D.9469 == 0) goto <D.9470>; else goto <D.9471>;
  <D.9470>:
  p.25 = (long unsigned int) p;
  D.9473 = p.25 & 4294967040;
  result.26 = (char *) D.9473;
  result = result.26;
  <D.9260>:
  if (up != 0) goto <D.9475>; else goto <D.9476>;
  <D.9475>:
  result.27 = result;
  result.28 = result.27 + 256;
  result = result.28;
  goto <D.9479>;
  <D.9476>:
  result.29 = result;
  result.30 = result.29 + 4294967040;
  result = result.30;
  <D.9479>:
  result.31 = result;
  D.9483 = *result.31;
  D.9484 = (long unsigned int) D.9483;
  GC_noop1 (D.9484);
  goto <D.9260>;
  <D.9471>:
  GC_reset_fault_handler ();
  if (up == 0) goto <D.9485>; else goto <D.9486>;
  <D.9485>:
  result.32 = result;
  result.33 = result.32 + 256;
  result = result.33;
  <D.9486>:
  D.9489 = result;
  return D.9489;
}


GC_linux_stack_base ()
{
  int D.9494;
  unsigned int buf_offset.34;
  unsigned int buf_offset.35;
  const short unsigned int * * D.9497;
  const short unsigned int * D.9498;
  unsigned int D.9499;
  unsigned int D.9500;
  const short unsigned int * D.9501;
  short unsigned int D.9502;
  int D.9503;
  int D.9504;
  unsigned int buf_offset.36;
  unsigned int buf_offset.37;
  long unsigned int D.9507;
  long unsigned int D.9508;
  unsigned int buf_offset.38;
  int D.9510;
  char * D.9513;
  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.9491>; else goto <D.9493>;
      <D.9493>:
      D.9494 = read (f, &stat_buf, 4096);
      if (D.9494 <= 53) goto <D.9491>; else goto <D.9492>;
      <D.9491>:
      GC_abort ("Couldn\'t read /proc/self/stat");
      <D.9492>:
      buf_offset.34 = buf_offset;
      buf_offset = buf_offset.34 + 1;
      c = stat_buf[buf_offset.34];
      i = 0;
      goto <D.9278>;
      <D.9277>:
      goto <D.9272>;
      <D.9271>:
      buf_offset.35 = buf_offset;
      buf_offset = buf_offset.35 + 1;
      c = stat_buf[buf_offset.35];
      <D.9272>:
      D.9497 = __ctype_b_loc ();
      D.9498 = *D.9497;
      D.9499 = (unsigned int) c;
      D.9500 = D.9499 * 2;
      D.9501 = D.9498 + D.9500;
      D.9502 = *D.9501;
      D.9503 = (int) D.9502;
      D.9504 = D.9503 & 8192;
      if (D.9504 != 0) goto <D.9271>; else goto <D.9273>;
      <D.9273>:
      goto <D.9275>;
      <D.9274>:
      buf_offset.36 = buf_offset;
      buf_offset = buf_offset.36 + 1;
      c = stat_buf[buf_offset.36];
      <D.9275>:
      D.9497 = __ctype_b_loc ();
      D.9498 = *D.9497;
      D.9499 = (unsigned int) c;
      D.9500 = D.9499 * 2;
      D.9501 = D.9498 + D.9500;
      D.9502 = *D.9501;
      D.9503 = (int) D.9502;
      D.9504 = D.9503 & 8192;
      if (D.9504 == 0) goto <D.9274>; else goto <D.9276>;
      <D.9276>:
      i = i + 1;
      <D.9278>:
      if (i <= 26) goto <D.9277>; else goto <D.9279>;
      <D.9279>:
      goto <D.9281>;
      <D.9280>:
      buf_offset.37 = buf_offset;
      buf_offset = buf_offset.37 + 1;
      c = stat_buf[buf_offset.37];
      <D.9281>:
      D.9497 = __ctype_b_loc ();
      D.9498 = *D.9497;
      D.9499 = (unsigned int) c;
      D.9500 = D.9499 * 2;
      D.9501 = D.9498 + D.9500;
      D.9502 = *D.9501;
      D.9503 = (int) D.9502;
      D.9504 = D.9503 & 8192;
      if (D.9504 != 0) goto <D.9280>; else goto <D.9282>;
      <D.9282>:
      goto <D.9284>;
      <D.9283>:
      result = result * 10;
      D.9507 = (long unsigned int) c;
      D.9508 = D.9507 + result;
      result = D.9508 + 4294967248;
      buf_offset.38 = buf_offset;
      buf_offset = buf_offset.38 + 1;
      c = stat_buf[buf_offset.38];
      <D.9284>:
      D.9497 = __ctype_b_loc ();
      D.9498 = *D.9497;
      D.9499 = (unsigned int) c;
      D.9500 = D.9499 * 2;
      D.9501 = D.9498 + D.9500;
      D.9502 = *D.9501;
      D.9503 = (int) D.9502;
      D.9510 = D.9503 & 2048;
      if (D.9510 != 0) goto <D.9283>; else goto <D.9285>;
      <D.9285>:
      close (f);
      if (result <= 268435455) goto <D.9511>; else goto <D.9512>;
      <D.9511>:
      GC_abort ("Absurd stack bottom value");
      <D.9512>:
      D.9513 = (char *) result;
      return D.9513;
    }
  finally
    {
      stat_buf = {CLOBBER};
    }
}


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

  result = GC_linux_stack_base ();
  if (result == 0B) goto <D.9516>; else goto <D.9517>;
  <D.9516>:
  result = 4294967292B;
  <D.9517>:
  D.9518 = result;
  return D.9518;
}


GC_register_data_segments ()
{
  char * GC_data_start.39;

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


GC_unix_get_mem (word bytes)
{
  long unsigned int GC_page_size.40;
  long unsigned int D.9522;
  long unsigned int D.9523;
  char * last_addr.41;
  char * D.9529;
  sizetype D.9530;
  sizetype D.9531;
  char * last_addr.42;
  long unsigned int D.9533;
  long unsigned int last_addr.43;
  long unsigned int D.9535;
  char * last_addr.44;
  long unsigned int result.45;
  long unsigned int D.9538;
  void * result;
  static char * last_addr = 0B;

  GC_page_size.40 = GC_page_size;
  D.9522 = GC_page_size.40 + 4294967295;
  D.9523 = D.9522 & bytes;
  if (D.9523 != 0) goto <D.9524>; else goto <D.9525>;
  <D.9524>:
  GC_abort ("Bad GET_MEM arg");
  <D.9525>:
  last_addr.41 = last_addr;
  result = mmap (last_addr.41, bytes, 3, 34, -1, 0);
  if (result == 4294967295B) goto <D.9527>; else goto <D.9528>;
  <D.9527>:
  D.9529 = 0B;
  return D.9529;
  <D.9528>:
  GC_page_size.40 = GC_page_size;
  D.9530 = bytes + GC_page_size.40;
  D.9531 = D.9530 + 4294967295;
  last_addr.42 = result + D.9531;
  last_addr = last_addr.42;
  GC_page_size.40 = GC_page_size;
  D.9533 = -GC_page_size.40;
  last_addr.41 = last_addr;
  last_addr.43 = (long unsigned int) last_addr.41;
  D.9535 = D.9533 & last_addr.43;
  last_addr.44 = (char *) D.9535;
  last_addr = last_addr.44;
  result.45 = (long unsigned int) result;
  D.9538 = result.45 & 4095;
  if (D.9538 != 0) goto <D.9539>; else goto <D.9540>;
  <D.9539>:
  GC_abort ("GC_unix_get_mem: Memory returned by mmap is not aligned to HBLKSIZE.");
  <D.9540>:
  D.9529 = result;
  return D.9529;
}


GC_unmap_start (char * start, word bytes)
{
  long unsigned int GC_page_size.46;
  sizetype D.9543;
  long unsigned int D.9544;
  long unsigned int result.47;
  long unsigned int D.9546;
  char * D.9547;
  char * D.9548;
  char * D.9551;
  char * result;

  result = start;
  GC_page_size.46 = GC_page_size;
  D.9543 = GC_page_size.46 + 4294967295;
  result = result + D.9543;
  GC_page_size.46 = GC_page_size;
  D.9544 = -GC_page_size.46;
  result.47 = (long unsigned int) result;
  D.9546 = D.9544 & result.47;
  result = (char *) D.9546;
  GC_page_size.46 = GC_page_size;
  D.9547 = result + GC_page_size.46;
  D.9548 = start + bytes;
  if (D.9547 > D.9548) goto <D.9549>; else goto <D.9550>;
  <D.9549>:
  D.9551 = 0B;
  return D.9551;
  <D.9550>:
  D.9551 = result;
  return D.9551;
}


GC_unmap_end (char * start, word bytes)
{
  long unsigned int GC_page_size.48;
  long unsigned int D.9554;
  long unsigned int end_addr.49;
  long unsigned int D.9556;
  char * D.9557;
  char * end_addr;

  end_addr = start + bytes;
  GC_page_size.48 = GC_page_size;
  D.9554 = -GC_page_size.48;
  end_addr.49 = (long unsigned int) end_addr;
  D.9556 = D.9554 & end_addr.49;
  end_addr = (char *) D.9556;
  D.9557 = end_addr;
  return D.9557;
}


GC_unmap (char * start, word bytes)
{
  int end_addr.50;
  int start_addr.51;
  int D.9561;
  long unsigned int D.9566;
  long unsigned int D.9567;
  char * start_addr;
  char * end_addr;
  word len;

  start_addr = GC_unmap_start (start, bytes);
  end_addr = GC_unmap_end (start, bytes);
  end_addr.50 = (int) end_addr;
  start_addr.51 = (int) start_addr;
  D.9561 = end_addr.50 - start_addr.51;
  len = (word) D.9561;
  if (start_addr == 0B) goto <D.9562>; else goto <D.9563>;
  <D.9562>:
  return;
  <D.9563>:
  {
    void * result;

    result = mmap (start_addr, len, 0, 50, -1, 0);
    if (result != start_addr) goto <D.9564>; else goto <D.9565>;
    <D.9564>:
    GC_abort ("mmap(...PROT_NONE...) failed");
    <D.9565>:
  }
  D.9566 = GC_arrays._unmapped_bytes;
  D.9567 = D.9566 + len;
  GC_arrays._unmapped_bytes = D.9567;
}


GC_remap (char * start, word bytes)
{
  int end_addr.52;
  int start_addr.53;
  int D.9571;
  long int start_addr.54;
  long int len.55;
  int * D.9578;
  int D.9579;
  long unsigned int D.9580;
  long unsigned int D.9581;
  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.52 = (int) end_addr;
  start_addr.53 = (int) start_addr;
  D.9571 = end_addr.52 - start_addr.53;
  len = (word) D.9571;
  if (start_addr == 0B) goto <D.9572>; else goto <D.9573>;
  <D.9572>:
  return;
  <D.9573>:
  result = mprotect (start_addr, len, 3);
  if (result != 0) goto <D.9574>; else goto <D.9575>;
  <D.9574>:
  start_addr.54 = (long int) start_addr;
  len.55 = (long int) len;
  D.9578 = __errno_location ();
  D.9579 = *D.9578;
  GC_err_printf ("Mprotect failed at 0x%lx (length %ld) with errno %ld\n", start_addr.54, len.55, D.9579, 0, 0, 0);
  GC_abort ("Mprotect remapping failed");
  <D.9575>:
  D.9580 = GC_arrays._unmapped_bytes;
  D.9581 = D.9580 - len;
  GC_arrays._unmapped_bytes = D.9581;
}


GC_unmap_gap (char * start1, word bytes1, char * start2, word bytes2)
{
  long unsigned int D.9585;
  int end_addr.56;
  int start_addr.57;
  int D.9592;
  long unsigned int D.9597;
  long unsigned int D.9598;
  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.9583>; else goto <D.9584>;
  <D.9583>:
  D.9585 = bytes1 + bytes2;
  start_addr = GC_unmap_start (start1, D.9585);
  <D.9584>:
  if (start2_addr == 0B) goto <D.9586>; else goto <D.9587>;
  <D.9586>:
  D.9585 = bytes1 + bytes2;
  end_addr = GC_unmap_end (start1, D.9585);
  <D.9587>:
  if (start_addr == 0B) goto <D.9588>; else goto <D.9589>;
  <D.9588>:
  return;
  <D.9589>:
  end_addr.56 = (int) end_addr;
  start_addr.57 = (int) start_addr;
  D.9592 = end_addr.56 - start_addr.57;
  len = (word) D.9592;
  if (len != 0) goto <D.9593>; else goto <D.9594>;
  <D.9593>:
  {
    void * result;

    result = mmap (start_addr, len, 0, 50, -1, 0);
    if (result != start_addr) goto <D.9595>; else goto <D.9596>;
    <D.9595>:
    GC_abort ("mmap(...PROT_NONE...) failed");
    <D.9596>:
  }
  <D.9594>:
  D.9597 = GC_arrays._unmapped_bytes;
  D.9598 = D.9597 + len;
  GC_arrays._unmapped_bytes = D.9598;
}


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.9600;

  D.9600 = 1;
  return D.9600;
}


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

  D.9602 = 1;
  return D.9602;
}


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.9604;

  D.9604 = 0;
  return D.9604;
}


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)
{
  unsigned int D.9606;
  word D.9607;

  D.9606 = strlen (maps);
  GC_err_write (maps, D.9606);
  D.9607 = 1;
  return D.9607;
}