GC_repeat_read (int fd, char * buf, size_t count)
{
  sizetype num_read.0;
  void * D.6755;
  unsigned int num_read.1;
  unsigned int D.6757;
  ssize_t D.6760;
  ssize_t num_read;
  ssize_t result;

  num_read = 0;
  goto <D.6598>;
  <D.6597>:
  num_read.0 = (sizetype) num_read;
  D.6755 = buf + num_read.0;
  num_read.1 = (unsigned int) num_read;
  D.6757 = count - num_read.1;
  result = read (fd, D.6755, D.6757);
  if (result < 0) goto <D.6758>; else goto <D.6759>;
  <D.6758>:
  D.6760 = result;
  return D.6760;
  <D.6759>:
  if (result == 0) goto <D.6596>; else goto <D.6761>;
  <D.6761>:
  num_read = num_read + result;
  <D.6598>:
  num_read.1 = (unsigned int) num_read;
  if (num_read.1 < count) goto <D.6597>; else goto <D.6596>;
  <D.6596>:
  D.6760 = num_read;
  return D.6760;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  unsigned int D.6763;
  int D.6766;
  ssize_t D.6769;
  unsigned int D.6770;
  unsigned int D.6771;
  unsigned int D.6774;

  D.6763 = __builtin_object_size (__buf, 0);
  if (D.6763 != 4294967295) goto <D.6764>; else goto <D.6765>;
  <D.6764>:
  D.6766 = __builtin_constant_p (__nbytes);
  if (D.6766 == 0) goto <D.6767>; else goto <D.6768>;
  <D.6767>:
  D.6770 = __builtin_object_size (__buf, 0);
  D.6769 = __read_chk (__fd, __buf, __nbytes, D.6770);
  return D.6769;
  <D.6768>:
  D.6771 = __builtin_object_size (__buf, 0);
  if (D.6771 < __nbytes) goto <D.6772>; else goto <D.6773>;
  <D.6772>:
  D.6774 = __builtin_object_size (__buf, 0);
  D.6769 = __read_chk_warn (__fd, __buf, __nbytes, D.6774);
  return D.6769;
  <D.6773>:
  <D.6765>:
  D.6769 = __read_alias (__fd, __buf, __nbytes);
  return D.6769;
}


GC_apply_to_maps (word (*<T13ff>) (char *) fn)
{
  unsigned int maps_buf_sz.2;
  unsigned int maps_buf_sz.3;
  char * maps_buf.4;
  char * maps_buf.5;
  word D.6784;
  unsigned int D.6787;
  unsigned int result.6;
  char * D.6791;
  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.6614>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.6777>; else goto <D.6778>;
  <D.6777>:
  goto <D.6610>;
  <D.6609>:
  maps_buf_sz.2 = maps_buf_sz;
  maps_buf_sz.3 = maps_buf_sz.2 * 2;
  maps_buf_sz = maps_buf_sz.3;
  <D.6610>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.6609>; else goto <D.6611>;
  <D.6611>:
  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.6782>; else goto <D.6783>;
  <D.6782>:
  D.6784 = 0;
  return D.6784;
  <D.6783>:
  <D.6778>:
  f = open ("/proc/self/maps", 0);
  if (f == -1) goto <D.6785>; else goto <D.6786>;
  <D.6785>:
  D.6784 = 0;
  return D.6784;
  <D.6786>:
  maps_size = 0;
  <D.6612>:
  maps_buf.5 = maps_buf;
  maps_buf_sz.2 = maps_buf_sz;
  D.6787 = maps_buf_sz.2 + 4294967295;
  result = GC_repeat_read (f, maps_buf.5, D.6787);
  if (result <= 0) goto <D.6788>; else goto <D.6789>;
  <D.6788>:
  D.6784 = 0;
  return D.6784;
  <D.6789>:
  result.6 = (unsigned int) result;
  maps_size = maps_size + result.6;
  result.6 = (unsigned int) result;
  maps_buf_sz.2 = maps_buf_sz;
  D.6787 = maps_buf_sz.2 + 4294967295;
  if (result.6 == D.6787) goto <D.6612>; else goto <D.6613>;
  <D.6613>:
  close (f);
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.6614>; else goto <D.6615>;
  <D.6615>:
  maps_buf.5 = maps_buf;
  D.6791 = maps_buf.5 + maps_size;
  *D.6791 = 0;
  maps_buf.5 = maps_buf;
  D.6784 = fn (maps_buf.5);
  return D.6784;
}


open (const char * __path, int __oflag)
{
  int D.6793;
  int D.6796;
  int D.6801;
  int D.6803;
  int D.6804;
  int D.6807;
  int D.6808;

  D.6793 = __builtin_va_arg_pack_len ();
  if (D.6793 > 1) goto <D.6794>; else goto <D.6795>;
  <D.6794>:
  __open_too_many_args ();
  <D.6795>:
  D.6796 = __builtin_constant_p (__oflag);
  if (D.6796 != 0) goto <D.6797>; else goto <D.6798>;
  <D.6797>:
  D.6801 = __oflag & 256;
  if (D.6801 != 0) goto <D.6799>; else goto <D.6802>;
  <D.6802>:
  D.6803 = __oflag & 4259840;
  if (D.6803 == 4259840) goto <D.6799>; else goto <D.6800>;
  <D.6799>:
  D.6804 = __builtin_va_arg_pack_len ();
  if (D.6804 <= 0) goto <D.6805>; else goto <D.6806>;
  <D.6805>:
  __open_missing_mode ();
  D.6807 = __open_2 (__path, __oflag);
  return D.6807;
  <D.6806>:
  <D.6800>:
  D.6807 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.6807;
  <D.6798>:
  D.6808 = __builtin_va_arg_pack_len ();
  if (D.6808 <= 0) goto <D.6809>; else goto <D.6810>;
  <D.6809>:
  D.6807 = __open_2 (__path, __oflag);
  return D.6807;
  <D.6810>:
  D.6807 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.6807;
}


GC_disable_signals ()
{
  int mask_initialized.7;
  int new_mask.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.7 = mask_initialized;
  if (mask_initialized.7 == 0) goto <D.6813>; else goto <D.6814>;
  <D.6813>:
  new_mask = 2147483647;
  new_mask.8 = new_mask;
  new_mask.9 = new_mask.8 & -1025;
  new_mask = new_mask.9;
  new_mask.8 = new_mask;
  new_mask.10 = new_mask.8 & -9;
  new_mask = new_mask.10;
  new_mask.8 = new_mask;
  new_mask.11 = new_mask.8 & -5;
  new_mask = new_mask.11;
  new_mask.8 = new_mask;
  new_mask.12 = new_mask.8 & -513;
  new_mask = new_mask.12;
  new_mask.8 = new_mask;
  new_mask.13 = new_mask.8 & -33;
  new_mask = new_mask.13;
  new_mask.8 = new_mask;
  new_mask.14 = new_mask.8 & -65;
  new_mask = new_mask.14;
  new_mask.8 = new_mask;
  new_mask.15 = new_mask.8 & -17;
  new_mask = new_mask.15;
  mask_initialized = 1;
  <D.6814>:
  new_mask.8 = new_mask;
  old_mask.16 = sigsetmask (new_mask.8);
  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.6826;
  long unsigned int GC_page_size.19;

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


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

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


GC_linux_stack_base ()
{
  int D.6833;
  unsigned int buf_offset.22;
  unsigned int buf_offset.23;
  const short unsigned int * * D.6836;
  const short unsigned int * D.6837;
  unsigned int D.6838;
  unsigned int D.6839;
  const short unsigned int * D.6840;
  short unsigned int D.6841;
  int D.6842;
  int D.6843;
  unsigned int buf_offset.24;
  unsigned int buf_offset.25;
  long unsigned int D.6846;
  long unsigned int D.6847;
  unsigned int buf_offset.26;
  int D.6849;
  char * D.6852;
  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.6830>; else goto <D.6832>;
      <D.6832>:
      D.6833 = read (f, &stat_buf, 4096);
      if (D.6833 <= 53) goto <D.6830>; else goto <D.6831>;
      <D.6830>:
      GC_abort ("Couldn\'t read /proc/self/stat");
      <D.6831>:
      buf_offset.22 = buf_offset;
      buf_offset = buf_offset.22 + 1;
      c = stat_buf[buf_offset.22];
      i = 0;
      goto <D.6651>;
      <D.6650>:
      goto <D.6645>;
      <D.6644>:
      buf_offset.23 = buf_offset;
      buf_offset = buf_offset.23 + 1;
      c = stat_buf[buf_offset.23];
      <D.6645>:
      D.6836 = __ctype_b_loc ();
      D.6837 = *D.6836;
      D.6838 = (unsigned int) c;
      D.6839 = D.6838 * 2;
      D.6840 = D.6837 + D.6839;
      D.6841 = *D.6840;
      D.6842 = (int) D.6841;
      D.6843 = D.6842 & 8192;
      if (D.6843 != 0) goto <D.6644>; else goto <D.6646>;
      <D.6646>:
      goto <D.6648>;
      <D.6647>:
      buf_offset.24 = buf_offset;
      buf_offset = buf_offset.24 + 1;
      c = stat_buf[buf_offset.24];
      <D.6648>:
      D.6836 = __ctype_b_loc ();
      D.6837 = *D.6836;
      D.6838 = (unsigned int) c;
      D.6839 = D.6838 * 2;
      D.6840 = D.6837 + D.6839;
      D.6841 = *D.6840;
      D.6842 = (int) D.6841;
      D.6843 = D.6842 & 8192;
      if (D.6843 == 0) goto <D.6647>; else goto <D.6649>;
      <D.6649>:
      i = i + 1;
      <D.6651>:
      if (i <= 26) goto <D.6650>; else goto <D.6652>;
      <D.6652>:
      goto <D.6654>;
      <D.6653>:
      buf_offset.25 = buf_offset;
      buf_offset = buf_offset.25 + 1;
      c = stat_buf[buf_offset.25];
      <D.6654>:
      D.6836 = __ctype_b_loc ();
      D.6837 = *D.6836;
      D.6838 = (unsigned int) c;
      D.6839 = D.6838 * 2;
      D.6840 = D.6837 + D.6839;
      D.6841 = *D.6840;
      D.6842 = (int) D.6841;
      D.6843 = D.6842 & 8192;
      if (D.6843 != 0) goto <D.6653>; else goto <D.6655>;
      <D.6655>:
      goto <D.6657>;
      <D.6656>:
      result = result * 10;
      D.6846 = (long unsigned int) c;
      D.6847 = D.6846 + result;
      result = D.6847 + 4294967248;
      buf_offset.26 = buf_offset;
      buf_offset = buf_offset.26 + 1;
      c = stat_buf[buf_offset.26];
      <D.6657>:
      D.6836 = __ctype_b_loc ();
      D.6837 = *D.6836;
      D.6838 = (unsigned int) c;
      D.6839 = D.6838 * 2;
      D.6840 = D.6837 + D.6839;
      D.6841 = *D.6840;
      D.6842 = (int) D.6841;
      D.6849 = D.6842 & 2048;
      if (D.6849 != 0) goto <D.6656>; else goto <D.6658>;
      <D.6658>:
      close (f);
      if (result <= 268435455) goto <D.6850>; else goto <D.6851>;
      <D.6850>:
      GC_abort ("Absurd stack bottom value");
      <D.6851>:
      D.6852 = (char *) result;
      return D.6852;
    }
  finally
    {
      stat_buf = {CLOBBER};
    }
}


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

  result = GC_linux_stack_base ();
  if (result == 0B) goto <D.6855>; else goto <D.6856>;
  <D.6855>:
  result = 4294967292B;
  <D.6856>:
  D.6857 = result;
  return D.6857;
}


GC_register_data_segments ()
{
  GC_add_roots_inner (&__data_start, &_end, 0);
}


GC_unix_get_mem (word bytes)
{
  long unsigned int GC_page_size.27;
  long unsigned int D.6860;
  long unsigned int D.6861;
  char * last_addr.28;
  char * D.6867;
  sizetype D.6868;
  sizetype D.6869;
  char * last_addr.29;
  long unsigned int D.6871;
  long unsigned int last_addr.30;
  long unsigned int D.6873;
  char * last_addr.31;
  long unsigned int result.32;
  long unsigned int D.6876;
  void * result;
  static char * last_addr = 0B;

  GC_page_size.27 = GC_page_size;
  D.6860 = GC_page_size.27 + 4294967295;
  D.6861 = D.6860 & bytes;
  if (D.6861 != 0) goto <D.6862>; else goto <D.6863>;
  <D.6862>:
  GC_abort ("Bad GET_MEM arg");
  <D.6863>:
  last_addr.28 = last_addr;
  result = mmap (last_addr.28, bytes, 3, 2050, -1, 0);
  if (result == 4294967295B) goto <D.6865>; else goto <D.6866>;
  <D.6865>:
  D.6867 = 0B;
  return D.6867;
  <D.6866>:
  GC_page_size.27 = GC_page_size;
  D.6868 = bytes + GC_page_size.27;
  D.6869 = D.6868 + 4294967295;
  last_addr.29 = result + D.6869;
  last_addr = last_addr.29;
  GC_page_size.27 = GC_page_size;
  D.6871 = -GC_page_size.27;
  last_addr.28 = last_addr;
  last_addr.30 = (long unsigned int) last_addr.28;
  D.6873 = D.6871 & last_addr.30;
  last_addr.31 = (char *) D.6873;
  last_addr = last_addr.31;
  result.32 = (long unsigned int) result;
  D.6876 = result.32 & 4095;
  if (D.6876 != 0) goto <D.6877>; else goto <D.6878>;
  <D.6877>:
  GC_abort ("GC_unix_get_mem: Memory returned by mmap is not aligned to HBLKSIZE.");
  <D.6878>:
  D.6867 = result;
  return D.6867;
}


GC_unmap_start (char * start, word bytes)
{
  long unsigned int GC_page_size.33;
  sizetype D.6881;
  long unsigned int D.6882;
  long unsigned int result.34;
  long unsigned int D.6884;
  char * D.6885;
  char * D.6886;
  char * D.6889;
  char * result;

  result = start;
  GC_page_size.33 = GC_page_size;
  D.6881 = GC_page_size.33 + 4294967295;
  result = result + D.6881;
  GC_page_size.33 = GC_page_size;
  D.6882 = -GC_page_size.33;
  result.34 = (long unsigned int) result;
  D.6884 = D.6882 & result.34;
  result = (char *) D.6884;
  GC_page_size.33 = GC_page_size;
  D.6885 = result + GC_page_size.33;
  D.6886 = start + bytes;
  if (D.6885 > D.6886) goto <D.6887>; else goto <D.6888>;
  <D.6887>:
  D.6889 = 0B;
  return D.6889;
  <D.6888>:
  D.6889 = result;
  return D.6889;
}


GC_unmap_end (char * start, word bytes)
{
  long unsigned int GC_page_size.35;
  long unsigned int D.6892;
  long unsigned int end_addr.36;
  long unsigned int D.6894;
  char * D.6895;
  char * end_addr;

  end_addr = start + bytes;
  GC_page_size.35 = GC_page_size;
  D.6892 = -GC_page_size.35;
  end_addr.36 = (long unsigned int) end_addr;
  D.6894 = D.6892 & end_addr.36;
  end_addr = (char *) D.6894;
  D.6895 = end_addr;
  return D.6895;
}


GC_unmap (char * start, word bytes)
{
  int end_addr.37;
  int start_addr.38;
  int D.6899;
  long unsigned int D.6904;
  long unsigned int D.6905;
  char * start_addr;
  char * end_addr;
  word len;

  start_addr = GC_unmap_start (start, bytes);
  end_addr = GC_unmap_end (start, bytes);
  end_addr.37 = (int) end_addr;
  start_addr.38 = (int) start_addr;
  D.6899 = end_addr.37 - start_addr.38;
  len = (word) D.6899;
  if (start_addr == 0B) goto <D.6900>; else goto <D.6901>;
  <D.6900>:
  return;
  <D.6901>:
  {
    void * result;

    result = mmap (start_addr, len, 0, 2066, -1, 0);
    if (result != start_addr) goto <D.6902>; else goto <D.6903>;
    <D.6902>:
    GC_abort ("mmap(...PROT_NONE...) failed");
    <D.6903>:
  }
  D.6904 = GC_arrays._unmapped_bytes;
  D.6905 = D.6904 + len;
  GC_arrays._unmapped_bytes = D.6905;
}


GC_remap (char * start, word bytes)
{
  int end_addr.39;
  int start_addr.40;
  int D.6909;
  long int start_addr.41;
  long int len.42;
  int * D.6916;
  int D.6917;
  long unsigned int D.6918;
  long unsigned int D.6919;
  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.39 = (int) end_addr;
  start_addr.40 = (int) start_addr;
  D.6909 = end_addr.39 - start_addr.40;
  len = (word) D.6909;
  if (start_addr == 0B) goto <D.6910>; else goto <D.6911>;
  <D.6910>:
  return;
  <D.6911>:
  result = mprotect (start_addr, len, 3);
  if (result != 0) goto <D.6912>; else goto <D.6913>;
  <D.6912>:
  start_addr.41 = (long int) start_addr;
  len.42 = (long int) len;
  D.6916 = __errno_location ();
  D.6917 = *D.6916;
  GC_err_printf ("Mprotect failed at 0x%lx (length %ld) with errno %ld\n", start_addr.41, len.42, D.6917, 0, 0, 0);
  GC_abort ("Mprotect remapping failed");
  <D.6913>:
  D.6918 = GC_arrays._unmapped_bytes;
  D.6919 = D.6918 - len;
  GC_arrays._unmapped_bytes = D.6919;
}


GC_unmap_gap (char * start1, word bytes1, char * start2, word bytes2)
{
  long unsigned int D.6923;
  int end_addr.43;
  int start_addr.44;
  int D.6930;
  long unsigned int D.6935;
  long unsigned int D.6936;
  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.6921>; else goto <D.6922>;
  <D.6921>:
  D.6923 = bytes1 + bytes2;
  start_addr = GC_unmap_start (start1, D.6923);
  <D.6922>:
  if (start2_addr == 0B) goto <D.6924>; else goto <D.6925>;
  <D.6924>:
  D.6923 = bytes1 + bytes2;
  end_addr = GC_unmap_end (start1, D.6923);
  <D.6925>:
  if (start_addr == 0B) goto <D.6926>; else goto <D.6927>;
  <D.6926>:
  return;
  <D.6927>:
  end_addr.43 = (int) end_addr;
  start_addr.44 = (int) start_addr;
  D.6930 = end_addr.43 - start_addr.44;
  len = (word) D.6930;
  if (len != 0) goto <D.6931>; else goto <D.6932>;
  <D.6931>:
  {
    void * result;

    result = mmap (start_addr, len, 0, 2066, -1, 0);
    if (result != start_addr) goto <D.6933>; else goto <D.6934>;
    <D.6933>:
    GC_abort ("mmap(...PROT_NONE...) failed");
    <D.6934>:
  }
  <D.6932>:
  D.6935 = GC_arrays._unmapped_bytes;
  D.6936 = D.6935 + len;
  GC_arrays._unmapped_bytes = D.6936;
}


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

  D.6938 = 1;
  return D.6938;
}


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

  D.6940 = 1;
  return D.6940;
}


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

  D.6942 = 0;
  return D.6942;
}


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.6944;
  word D.6945;

  D.6944 = strlen (maps);
  GC_err_write (maps, D.6944);
  D.6945 = 1;
  return D.6945;
}