GC_repeat_read (int fd, char * buf, size_t count)
{
  unsigned int num_read.0;
  unsigned int D.6868;
  sizetype num_read.1;
  void * D.6870;
  ssize_t D.6873;
  ssize_t num_read;
  ssize_t result;

  num_read = 0;
  goto <D.6689>;
  <D.6688>:
  num_read.0 = (unsigned int) num_read;
  D.6868 = count - num_read.0;
  num_read.1 = (sizetype) num_read;
  D.6870 = buf + num_read.1;
  result = read (fd, D.6870, D.6868);
  if (result < 0) goto <D.6871>; else goto <D.6872>;
  <D.6871>:
  D.6873 = result;
  return D.6873;
  <D.6872>:
  if (result == 0) goto <D.6687>; else goto <D.6874>;
  <D.6874>:
  num_read = num_read + result;
  <D.6689>:
  num_read.0 = (unsigned int) num_read;
  if (num_read.0 < count) goto <D.6688>; else goto <D.6687>;
  <D.6687>:
  D.6873 = num_read;
  return D.6873;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.6876;
  int D.6879;
  ssize_t D.6882;
  unsigned int D.6883;
  unsigned int D.6884;
  unsigned int D.6887;

  D.6876 = __builtin_object_size (__buf, 0);
  if (D.6876 != 4294967295) goto <D.6877>; else goto <D.6878>;
  <D.6877>:
  D.6879 = __builtin_constant_p (__nbytes);
  if (D.6879 == 0) goto <D.6880>; else goto <D.6881>;
  <D.6880>:
  D.6883 = __builtin_object_size (__buf, 0);
  D.6882 = __read_chk (__fd, __buf, __nbytes, D.6883);
  return D.6882;
  <D.6881>:
  D.6884 = __builtin_object_size (__buf, 0);
  if (D.6884 < __nbytes) goto <D.6885>; else goto <D.6886>;
  <D.6885>:
  D.6887 = __builtin_object_size (__buf, 0);
  D.6882 = __read_chk_warn (__fd, __buf, __nbytes, D.6887);
  return D.6882;
  <D.6886>:
  <D.6878>:
  D.6882 = __read_alias (__fd, __buf, __nbytes);
  return D.6882;
}


GC_apply_to_maps (word (*<T1450>) (char *) fn)
{
  unsigned int maps_buf_sz.2;
  unsigned int maps_buf_sz.3;
  char * maps_buf.4;
  char * maps_buf.5;
  word D.6897;
  unsigned int D.6900;
  unsigned int result.6;
  char * D.6904;
  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.6705>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.6890>; else goto <D.6891>;
  <D.6890>:
  goto <D.6701>;
  <D.6700>:
  maps_buf_sz.2 = maps_buf_sz;
  maps_buf_sz.3 = maps_buf_sz.2 * 2;
  maps_buf_sz = maps_buf_sz.3;
  <D.6701>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.6700>; else goto <D.6702>;
  <D.6702>:
  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.6895>; else goto <D.6896>;
  <D.6895>:
  D.6897 = 0;
  return D.6897;
  <D.6896>:
  <D.6891>:
  f = open ("/proc/self/maps", 0);
  if (f == -1) goto <D.6898>; else goto <D.6899>;
  <D.6898>:
  D.6897 = 0;
  return D.6897;
  <D.6899>:
  maps_size = 0;
  <D.6703>:
  maps_buf_sz.2 = maps_buf_sz;
  D.6900 = maps_buf_sz.2 + 4294967295;
  maps_buf.5 = maps_buf;
  result = GC_repeat_read (f, maps_buf.5, D.6900);
  if (result <= 0) goto <D.6901>; else goto <D.6902>;
  <D.6901>:
  D.6897 = 0;
  return D.6897;
  <D.6902>:
  result.6 = (unsigned int) result;
  maps_size = maps_size + result.6;
  result.6 = (unsigned int) result;
  maps_buf_sz.2 = maps_buf_sz;
  D.6900 = maps_buf_sz.2 + 4294967295;
  if (result.6 == D.6900) goto <D.6703>; else goto <D.6704>;
  <D.6704>:
  close (f);
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.6705>; else goto <D.6706>;
  <D.6706>:
  maps_buf.5 = maps_buf;
  D.6904 = maps_buf.5 + maps_size;
  *D.6904 = 0;
  maps_buf.5 = maps_buf;
  D.6897 = fn (maps_buf.5);
  return D.6897;
}


open (const char * __path, int __oflag)
{
  int D.6906;
  int D.6909;
  int D.6914;
  int D.6916;
  int D.6917;
  int D.6920;
  int D.6921;

  D.6906 = __builtin_va_arg_pack_len ();
  if (D.6906 > 1) goto <D.6907>; else goto <D.6908>;
  <D.6907>:
  __open_too_many_args ();
  <D.6908>:
  D.6909 = __builtin_constant_p (__oflag);
  if (D.6909 != 0) goto <D.6910>; else goto <D.6911>;
  <D.6910>:
  D.6914 = __oflag & 64;
  if (D.6914 != 0) goto <D.6912>; else goto <D.6915>;
  <D.6915>:
  D.6916 = __oflag & 4259840;
  if (D.6916 == 4259840) goto <D.6912>; else goto <D.6913>;
  <D.6912>:
  D.6917 = __builtin_va_arg_pack_len ();
  if (D.6917 <= 0) goto <D.6918>; else goto <D.6919>;
  <D.6918>:
  __open_missing_mode ();
  D.6920 = __open_2 (__path, __oflag);
  return D.6920;
  <D.6919>:
  <D.6913>:
  D.6920 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.6920;
  <D.6911>:
  D.6921 = __builtin_va_arg_pack_len ();
  if (D.6921 <= 0) goto <D.6922>; else goto <D.6923>;
  <D.6922>:
  D.6920 = __open_2 (__path, __oflag);
  return D.6920;
  <D.6923>:
  D.6920 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.6920;
}


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.6926>; else goto <D.6927>;
  <D.6926>:
  return;
  <D.6927>:
  if (&__data_start != 0B) goto <D.6928>; else goto <D.6929>;
  <D.6928>:
  GC_data_start = &__data_start;
  return;
  <D.6929>:
  if (&data_start != 0B) goto <D.6930>; else goto <D.6931>;
  <D.6930>:
  GC_data_start = &data_start;
  return;
  <D.6931>:
  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.6935>; else goto <D.6936>;
  <D.6935>:
  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.6936>:
  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.6947;
  long unsigned int GC_page_size.20;

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


GC_set_and_save_fault_handler (void (*handler) (int) h)
{
  void (*<T690>) (int) old_segv_handler.21;
  void (*<T690>) (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 (*<T690>) (int) old_segv_handler.23;
  void (*<T690>) (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.6953;
  long unsigned int p.25;
  long unsigned int D.6957;
  char * result.26;
  char * result.27;
  char * result.28;
  char * result.29;
  char * result.30;
  char * result.31;
  char D.6967;
  long unsigned int D.6968;
  char * result.32;
  char * result.33;
  char * D.6973;
  static char * volatile result;

  GC_setup_temporary_fault_handler ();
  D.6953 = __sigsetjmp (&GC_jmp_buf, 1);
  if (D.6953 == 0) goto <D.6954>; else goto <D.6955>;
  <D.6954>:
  p.25 = (long unsigned int) p;
  D.6957 = p.25 & 4294967040;
  result.26 = (char *) D.6957;
  result = result.26;
  <D.6746>:
  if (up != 0) goto <D.6959>; else goto <D.6960>;
  <D.6959>:
  result.27 = result;
  result.28 = result.27 + 256;
  result = result.28;
  goto <D.6963>;
  <D.6960>:
  result.29 = result;
  result.30 = result.29 + 4294967040;
  result = result.30;
  <D.6963>:
  result.31 = result;
  D.6967 = *result.31;
  D.6968 = (long unsigned int) D.6967;
  GC_noop1 (D.6968);
  goto <D.6746>;
  <D.6955>:
  GC_reset_fault_handler ();
  if (up == 0) goto <D.6969>; else goto <D.6970>;
  <D.6969>:
  result.32 = result;
  result.33 = result.32 + 256;
  result = result.33;
  <D.6970>:
  D.6973 = result;
  return D.6973;
}


GC_linux_stack_base ()
{
  int D.6978;
  unsigned int buf_offset.34;
  unsigned int buf_offset.35;
  const short unsigned int * * D.6981;
  const short unsigned int * D.6982;
  unsigned int D.6983;
  unsigned int D.6984;
  const short unsigned int * D.6985;
  short unsigned int D.6986;
  int D.6987;
  int D.6988;
  unsigned int buf_offset.36;
  unsigned int buf_offset.37;
  long unsigned int D.6991;
  long unsigned int D.6992;
  unsigned int buf_offset.38;
  int D.6994;
  char * D.6997;
  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.6975>; else goto <D.6977>;
      <D.6977>:
      D.6978 = read (f, &stat_buf, 4096);
      if (D.6978 <= 53) goto <D.6975>; else goto <D.6976>;
      <D.6975>:
      GC_abort ("Couldn\'t read /proc/self/stat");
      <D.6976>:
      buf_offset.34 = buf_offset;
      buf_offset = buf_offset.34 + 1;
      c = stat_buf[buf_offset.34];
      i = 0;
      goto <D.6764>;
      <D.6763>:
      goto <D.6758>;
      <D.6757>:
      buf_offset.35 = buf_offset;
      buf_offset = buf_offset.35 + 1;
      c = stat_buf[buf_offset.35];
      <D.6758>:
      D.6981 = __ctype_b_loc ();
      D.6982 = *D.6981;
      D.6983 = (unsigned int) c;
      D.6984 = D.6983 * 2;
      D.6985 = D.6982 + D.6984;
      D.6986 = *D.6985;
      D.6987 = (int) D.6986;
      D.6988 = D.6987 & 8192;
      if (D.6988 != 0) goto <D.6757>; else goto <D.6759>;
      <D.6759>:
      goto <D.6761>;
      <D.6760>:
      buf_offset.36 = buf_offset;
      buf_offset = buf_offset.36 + 1;
      c = stat_buf[buf_offset.36];
      <D.6761>:
      D.6981 = __ctype_b_loc ();
      D.6982 = *D.6981;
      D.6983 = (unsigned int) c;
      D.6984 = D.6983 * 2;
      D.6985 = D.6982 + D.6984;
      D.6986 = *D.6985;
      D.6987 = (int) D.6986;
      D.6988 = D.6987 & 8192;
      if (D.6988 == 0) goto <D.6760>; else goto <D.6762>;
      <D.6762>:
      i = i + 1;
      <D.6764>:
      if (i <= 26) goto <D.6763>; else goto <D.6765>;
      <D.6765>:
      goto <D.6767>;
      <D.6766>:
      buf_offset.37 = buf_offset;
      buf_offset = buf_offset.37 + 1;
      c = stat_buf[buf_offset.37];
      <D.6767>:
      D.6981 = __ctype_b_loc ();
      D.6982 = *D.6981;
      D.6983 = (unsigned int) c;
      D.6984 = D.6983 * 2;
      D.6985 = D.6982 + D.6984;
      D.6986 = *D.6985;
      D.6987 = (int) D.6986;
      D.6988 = D.6987 & 8192;
      if (D.6988 != 0) goto <D.6766>; else goto <D.6768>;
      <D.6768>:
      goto <D.6770>;
      <D.6769>:
      result = result * 10;
      D.6991 = (long unsigned int) c;
      D.6992 = D.6991 + result;
      result = D.6992 + 4294967248;
      buf_offset.38 = buf_offset;
      buf_offset = buf_offset.38 + 1;
      c = stat_buf[buf_offset.38];
      <D.6770>:
      D.6981 = __ctype_b_loc ();
      D.6982 = *D.6981;
      D.6983 = (unsigned int) c;
      D.6984 = D.6983 * 2;
      D.6985 = D.6982 + D.6984;
      D.6986 = *D.6985;
      D.6987 = (int) D.6986;
      D.6994 = D.6987 & 2048;
      if (D.6994 != 0) goto <D.6769>; else goto <D.6771>;
      <D.6771>:
      close (f);
      if (result <= 268435455) goto <D.6995>; else goto <D.6996>;
      <D.6995>:
      GC_abort ("Absurd stack bottom value");
      <D.6996>:
      D.6997 = (char *) result;
      return D.6997;
    }
  finally
    {
      stat_buf = {CLOBBER};
    }
}


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

  result = GC_linux_stack_base ();
  if (result == 0B) goto <D.7000>; else goto <D.7001>;
  <D.7000>:
  result = 4294967292B;
  <D.7001>:
  D.7002 = result;
  return D.7002;
}


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.7006;
  long unsigned int D.7007;
  char * last_addr.41;
  char * D.7013;
  sizetype D.7014;
  sizetype D.7015;
  char * last_addr.42;
  long unsigned int D.7017;
  long unsigned int last_addr.43;
  long unsigned int D.7019;
  char * last_addr.44;
  long unsigned int result.45;
  long unsigned int D.7022;
  void * result;
  static char * last_addr = 4096B;

  GC_page_size.40 = GC_page_size;
  D.7006 = GC_page_size.40 + 4294967295;
  D.7007 = D.7006 & bytes;
  if (D.7007 != 0) goto <D.7008>; else goto <D.7009>;
  <D.7008>:
  GC_abort ("Bad GET_MEM arg");
  <D.7009>:
  last_addr.41 = last_addr;
  result = mmap (last_addr.41, bytes, 3, 34, -1, 0);
  if (result == 4294967295B) goto <D.7011>; else goto <D.7012>;
  <D.7011>:
  D.7013 = 0B;
  return D.7013;
  <D.7012>:
  GC_page_size.40 = GC_page_size;
  D.7014 = bytes + GC_page_size.40;
  D.7015 = D.7014 + 4294967295;
  last_addr.42 = result + D.7015;
  last_addr = last_addr.42;
  GC_page_size.40 = GC_page_size;
  D.7017 = -GC_page_size.40;
  last_addr.41 = last_addr;
  last_addr.43 = (long unsigned int) last_addr.41;
  D.7019 = D.7017 & last_addr.43;
  last_addr.44 = (char *) D.7019;
  last_addr = last_addr.44;
  result.45 = (long unsigned int) result;
  D.7022 = result.45 & 4095;
  if (D.7022 != 0) goto <D.7023>; else goto <D.7024>;
  <D.7023>:
  GC_abort ("GC_unix_get_mem: Memory returned by mmap is not aligned to HBLKSIZE.");
  <D.7024>:
  D.7013 = result;
  return D.7013;
}


GC_unmap_start (char * start, word bytes)
{
  long unsigned int GC_page_size.46;
  sizetype D.7027;
  long unsigned int D.7028;
  long unsigned int result.47;
  long unsigned int D.7030;
  char * D.7031;
  char * D.7032;
  char * D.7035;
  char * result;

  result = start;
  GC_page_size.46 = GC_page_size;
  D.7027 = GC_page_size.46 + 4294967295;
  result = result + D.7027;
  GC_page_size.46 = GC_page_size;
  D.7028 = -GC_page_size.46;
  result.47 = (long unsigned int) result;
  D.7030 = D.7028 & result.47;
  result = (char *) D.7030;
  GC_page_size.46 = GC_page_size;
  D.7031 = result + GC_page_size.46;
  D.7032 = start + bytes;
  if (D.7031 > D.7032) goto <D.7033>; else goto <D.7034>;
  <D.7033>:
  D.7035 = 0B;
  return D.7035;
  <D.7034>:
  D.7035 = result;
  return D.7035;
}


GC_unmap_end (char * start, word bytes)
{
  long unsigned int GC_page_size.48;
  long unsigned int D.7038;
  long unsigned int end_addr.49;
  long unsigned int D.7040;
  char * D.7041;
  char * end_addr;

  end_addr = start + bytes;
  GC_page_size.48 = GC_page_size;
  D.7038 = -GC_page_size.48;
  end_addr.49 = (long unsigned int) end_addr;
  D.7040 = D.7038 & end_addr.49;
  end_addr = (char *) D.7040;
  D.7041 = end_addr;
  return D.7041;
}


GC_unmap (char * start, word bytes)
{
  int end_addr.50;
  int start_addr.51;
  int D.7045;
  long unsigned int D.7050;
  long unsigned int D.7051;
  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.7045 = end_addr.50 - start_addr.51;
  len = (word) D.7045;
  if (start_addr == 0B) goto <D.7046>; else goto <D.7047>;
  <D.7046>:
  return;
  <D.7047>:
  {
    void * result;

    result = mmap (start_addr, len, 0, 50, -1, 0);
    if (result != start_addr) goto <D.7048>; else goto <D.7049>;
    <D.7048>:
    GC_abort ("mmap(...PROT_NONE...) failed");
    <D.7049>:
  }
  D.7050 = GC_arrays._unmapped_bytes;
  D.7051 = D.7050 + len;
  GC_arrays._unmapped_bytes = D.7051;
}


GC_remap (char * start, word bytes)
{
  int end_addr.52;
  int start_addr.53;
  int D.7055;
  int * D.7060;
  int D.7061;
  long int len.54;
  long int start_addr.55;
  long unsigned int D.7064;
  long unsigned int D.7065;
  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.7055 = end_addr.52 - start_addr.53;
  len = (word) D.7055;
  if (start_addr == 0B) goto <D.7056>; else goto <D.7057>;
  <D.7056>:
  return;
  <D.7057>:
  result = mprotect (start_addr, len, 3);
  if (result != 0) goto <D.7058>; else goto <D.7059>;
  <D.7058>:
  D.7060 = __errno_location ();
  D.7061 = *D.7060;
  len.54 = (long int) len;
  start_addr.55 = (long int) start_addr;
  GC_err_printf ("Mprotect failed at 0x%lx (length %ld) with errno %ld\n", start_addr.55, len.54, D.7061, 0, 0, 0);
  GC_abort ("Mprotect remapping failed");
  <D.7059>:
  D.7064 = GC_arrays._unmapped_bytes;
  D.7065 = D.7064 - len;
  GC_arrays._unmapped_bytes = D.7065;
}


GC_unmap_gap (char * start1, word bytes1, char * start2, word bytes2)
{
  long unsigned int D.7069;
  int end_addr.56;
  int start_addr.57;
  int D.7076;
  long unsigned int D.7081;
  long unsigned int D.7082;
  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.7067>; else goto <D.7068>;
  <D.7067>:
  D.7069 = bytes1 + bytes2;
  start_addr = GC_unmap_start (start1, D.7069);
  <D.7068>:
  if (start2_addr == 0B) goto <D.7070>; else goto <D.7071>;
  <D.7070>:
  D.7069 = bytes1 + bytes2;
  end_addr = GC_unmap_end (start1, D.7069);
  <D.7071>:
  if (start_addr == 0B) goto <D.7072>; else goto <D.7073>;
  <D.7072>:
  return;
  <D.7073>:
  end_addr.56 = (int) end_addr;
  start_addr.57 = (int) start_addr;
  D.7076 = end_addr.56 - start_addr.57;
  len = (word) D.7076;
  if (len != 0) goto <D.7077>; else goto <D.7078>;
  <D.7077>:
  {
    void * result;

    result = mmap (start_addr, len, 0, 50, -1, 0);
    if (result != start_addr) goto <D.7079>; else goto <D.7080>;
    <D.7079>:
    GC_abort ("mmap(...PROT_NONE...) failed");
    <D.7080>:
  }
  <D.7078>:
  D.7081 = GC_arrays._unmapped_bytes;
  D.7082 = D.7081 + len;
  GC_arrays._unmapped_bytes = D.7082;
}


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

  D.7084 = 1;
  return D.7084;
}


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

  D.7086 = 1;
  return D.7086;
}


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

  D.7088 = 0;
  return D.7088;
}


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.7090;
  word D.7091;

  D.7090 = strlen (maps);
  GC_err_write (maps, D.7090);
  D.7091 = 1;
  return D.7091;
}