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

  num_read = 0;
  goto <D.7534>;
  <D.7533>:
  num_read.0 = (sizetype) num_read;
  D.7673 = buf + num_read.0;
  num_read.1 = (long unsigned int) num_read;
  D.7675 = count - num_read.1;
  result = read (fd, D.7673, D.7675);
  if (result < 0) goto <D.7676>; else goto <D.7677>;
  <D.7676>:
  D.7678 = result;
  return D.7678;
  <D.7677>:
  if (result == 0) goto <D.7532>; else goto <D.7679>;
  <D.7679>:
  num_read = num_read + result;
  <D.7534>:
  num_read.1 = (long unsigned int) num_read;
  if (num_read.1 < count) goto <D.7533>; else goto <D.7532>;
  <D.7532>:
  D.7678 = num_read;
  return D.7678;
}


read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.7681;
  int D.7684;
  ssize_t D.7687;
  long unsigned int D.7688;
  long unsigned int D.7689;
  long unsigned int D.7692;

  D.7681 = __builtin_object_size (__buf, 0);
  if (D.7681 != 18446744073709551615) goto <D.7682>; else goto <D.7683>;
  <D.7682>:
  D.7684 = __builtin_constant_p (__nbytes);
  if (D.7684 == 0) goto <D.7685>; else goto <D.7686>;
  <D.7685>:
  D.7688 = __builtin_object_size (__buf, 0);
  D.7687 = __read_chk (__fd, __buf, __nbytes, D.7688);
  return D.7687;
  <D.7686>:
  D.7689 = __builtin_object_size (__buf, 0);
  if (D.7689 < __nbytes) goto <D.7690>; else goto <D.7691>;
  <D.7690>:
  D.7692 = __builtin_object_size (__buf, 0);
  D.7687 = __read_chk_warn (__fd, __buf, __nbytes, D.7692);
  return D.7687;
  <D.7691>:
  <D.7683>:
  D.7687 = __read_alias (__fd, __buf, __nbytes);
  return D.7687;
}


GC_apply_to_maps (word (*<T151e>) (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.7702;
  long unsigned int D.7705;
  long int D.7706;
  long unsigned int D.7709;
  char * D.7710;
  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.7550>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.7695>; else goto <D.7696>;
  <D.7695>:
  goto <D.7546>;
  <D.7545>:
  maps_buf_sz.2 = maps_buf_sz;
  maps_buf_sz.3 = maps_buf_sz.2 * 2;
  maps_buf_sz = maps_buf_sz.3;
  <D.7546>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.7545>; else goto <D.7547>;
  <D.7547>:
  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.7700>; else goto <D.7701>;
  <D.7700>:
  D.7702 = 0;
  return D.7702;
  <D.7701>:
  <D.7696>:
  f = open ("/proc/self/maps", 0);
  if (f == -1) goto <D.7703>; else goto <D.7704>;
  <D.7703>:
  D.7702 = 0;
  return D.7702;
  <D.7704>:
  maps_size = 0;
  <D.7548>:
  maps_buf.5 = maps_buf;
  maps_buf_sz.2 = maps_buf_sz;
  D.7705 = maps_buf_sz.2 + 18446744073709551615;
  D.7706 = GC_repeat_read (f, maps_buf.5, D.7705);
  result = (int) D.7706;
  if (result <= 0) goto <D.7707>; else goto <D.7708>;
  <D.7707>:
  D.7702 = 0;
  return D.7702;
  <D.7708>:
  D.7709 = (long unsigned int) result;
  maps_size = D.7709 + maps_size;
  D.7709 = (long unsigned int) result;
  maps_buf_sz.2 = maps_buf_sz;
  D.7705 = maps_buf_sz.2 + 18446744073709551615;
  if (D.7709 == D.7705) goto <D.7548>; else goto <D.7549>;
  <D.7549>:
  close (f);
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.7550>; else goto <D.7551>;
  <D.7551>:
  maps_buf.5 = maps_buf;
  D.7710 = maps_buf.5 + maps_size;
  *D.7710 = 0;
  maps_buf.5 = maps_buf;
  D.7702 = fn (maps_buf.5);
  return D.7702;
}


open (const char * __path, int __oflag)
{
  int D.7712;
  int D.7715;
  int D.7720;
  int D.7722;
  int D.7723;
  int D.7726;
  int D.7727;

  D.7712 = __builtin_va_arg_pack_len ();
  if (D.7712 > 1) goto <D.7713>; else goto <D.7714>;
  <D.7713>:
  __open_too_many_args ();
  <D.7714>:
  D.7715 = __builtin_constant_p (__oflag);
  if (D.7715 != 0) goto <D.7716>; else goto <D.7717>;
  <D.7716>:
  D.7720 = __oflag & 64;
  if (D.7720 != 0) goto <D.7718>; else goto <D.7721>;
  <D.7721>:
  D.7722 = __oflag & 4259840;
  if (D.7722 == 4259840) goto <D.7718>; else goto <D.7719>;
  <D.7718>:
  D.7723 = __builtin_va_arg_pack_len ();
  if (D.7723 <= 0) goto <D.7724>; else goto <D.7725>;
  <D.7724>:
  __open_missing_mode ();
  D.7726 = __open_2 (__path, __oflag);
  return D.7726;
  <D.7725>:
  <D.7719>:
  D.7726 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7726;
  <D.7717>:
  D.7727 = __builtin_va_arg_pack_len ();
  if (D.7727 <= 0) goto <D.7728>; else goto <D.7729>;
  <D.7728>:
  D.7726 = __open_2 (__path, __oflag);
  return D.7726;
  <D.7729>:
  D.7726 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7726;
}


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.7732>; else goto <D.7733>;
  <D.7732>:
  return;
  <D.7733>:
  if (&__data_start != 0B) goto <D.7734>; else goto <D.7735>;
  <D.7734>:
  GC_data_start = &__data_start;
  return;
  <D.7735>:
  if (&data_start != 0B) goto <D.7736>; else goto <D.7737>;
  <D.7736>:
  GC_data_start = &data_start;
  return;
  <D.7737>:
  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.7741>; else goto <D.7742>;
  <D.7741>:
  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.7742>:
  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.7753;
  long unsigned int GC_page_size.19;

  D.7753 = getpagesize ();
  GC_page_size.19 = (long unsigned int) D.7753;
  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.7759;
  long unsigned int p.24;
  long unsigned int D.7763;
  char * result.25;
  char * result.26;
  char * result.27;
  char * result.28;
  char * result.29;
  char * result.30;
  char D.7773;
  long unsigned int D.7774;
  char * result.31;
  char * result.32;
  char * D.7779;
  static char * volatile result;

  GC_setup_temporary_fault_handler ();
  D.7759 = __sigsetjmp (&GC_jmp_buf, 1);
  if (D.7759 == 0) goto <D.7760>; else goto <D.7761>;
  <D.7760>:
  p.24 = (long unsigned int) p;
  D.7763 = p.24 & 18446744073709551360;
  result.25 = (char *) D.7763;
  result = result.25;
  <D.7591>:
  if (up != 0) goto <D.7765>; else goto <D.7766>;
  <D.7765>:
  result.26 = result;
  result.27 = result.26 + 256;
  result = result.27;
  goto <D.7769>;
  <D.7766>:
  result.28 = result;
  result.29 = result.28 + 18446744073709551360;
  result = result.29;
  <D.7769>:
  result.30 = result;
  D.7773 = *result.30;
  D.7774 = (long unsigned int) D.7773;
  GC_noop1 (D.7774);
  goto <D.7591>;
  <D.7761>:
  GC_reset_fault_handler ();
  if (up == 0) goto <D.7775>; else goto <D.7776>;
  <D.7775>:
  result.31 = result;
  result.32 = result.31 + 256;
  result = result.32;
  <D.7776>:
  D.7779 = result;
  return D.7779;
}


GC_linux_stack_base ()
{
  long int D.7784;
  long unsigned int buf_offset.33;
  long unsigned int buf_offset.34;
  const short unsigned int * * D.7787;
  const short unsigned int * D.7788;
  long unsigned int D.7789;
  long unsigned int D.7790;
  const short unsigned int * D.7791;
  short unsigned int D.7792;
  int D.7793;
  int D.7794;
  long unsigned int buf_offset.35;
  long unsigned int buf_offset.36;
  int D.7797;
  int D.7798;
  long unsigned int D.7799;
  long unsigned int buf_offset.37;
  int D.7801;
  char * D.7804;
  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.7781>; else goto <D.7783>;
      <D.7783>:
      D.7784 = read (f, &stat_buf, 4096);
      if (D.7784 <= 53) goto <D.7781>; else goto <D.7782>;
      <D.7781>:
      GC_abort ("Couldn\'t read /proc/self/stat");
      <D.7782>:
      buf_offset.33 = buf_offset;
      buf_offset = buf_offset.33 + 1;
      c = stat_buf[buf_offset.33];
      i = 0;
      goto <D.7609>;
      <D.7608>:
      goto <D.7603>;
      <D.7602>:
      buf_offset.34 = buf_offset;
      buf_offset = buf_offset.34 + 1;
      c = stat_buf[buf_offset.34];
      <D.7603>:
      D.7787 = __ctype_b_loc ();
      D.7788 = *D.7787;
      D.7789 = (long unsigned int) c;
      D.7790 = D.7789 * 2;
      D.7791 = D.7788 + D.7790;
      D.7792 = *D.7791;
      D.7793 = (int) D.7792;
      D.7794 = D.7793 & 8192;
      if (D.7794 != 0) goto <D.7602>; else goto <D.7604>;
      <D.7604>:
      goto <D.7606>;
      <D.7605>:
      buf_offset.35 = buf_offset;
      buf_offset = buf_offset.35 + 1;
      c = stat_buf[buf_offset.35];
      <D.7606>:
      D.7787 = __ctype_b_loc ();
      D.7788 = *D.7787;
      D.7789 = (long unsigned int) c;
      D.7790 = D.7789 * 2;
      D.7791 = D.7788 + D.7790;
      D.7792 = *D.7791;
      D.7793 = (int) D.7792;
      D.7794 = D.7793 & 8192;
      if (D.7794 == 0) goto <D.7605>; else goto <D.7607>;
      <D.7607>:
      i = i + 1;
      <D.7609>:
      if (i <= 26) goto <D.7608>; else goto <D.7610>;
      <D.7610>:
      goto <D.7612>;
      <D.7611>:
      buf_offset.36 = buf_offset;
      buf_offset = buf_offset.36 + 1;
      c = stat_buf[buf_offset.36];
      <D.7612>:
      D.7787 = __ctype_b_loc ();
      D.7788 = *D.7787;
      D.7789 = (long unsigned int) c;
      D.7790 = D.7789 * 2;
      D.7791 = D.7788 + D.7790;
      D.7792 = *D.7791;
      D.7793 = (int) D.7792;
      D.7794 = D.7793 & 8192;
      if (D.7794 != 0) goto <D.7611>; else goto <D.7613>;
      <D.7613>:
      goto <D.7615>;
      <D.7614>:
      result = result * 10;
      D.7797 = (int) c;
      D.7798 = D.7797 + -48;
      D.7799 = (long unsigned int) D.7798;
      result = D.7799 + result;
      buf_offset.37 = buf_offset;
      buf_offset = buf_offset.37 + 1;
      c = stat_buf[buf_offset.37];
      <D.7615>:
      D.7787 = __ctype_b_loc ();
      D.7788 = *D.7787;
      D.7789 = (long unsigned int) c;
      D.7790 = D.7789 * 2;
      D.7791 = D.7788 + D.7790;
      D.7792 = *D.7791;
      D.7793 = (int) D.7792;
      D.7801 = D.7793 & 2048;
      if (D.7801 != 0) goto <D.7614>; else goto <D.7616>;
      <D.7616>:
      close (f);
      if (result <= 268435455) goto <D.7802>; else goto <D.7803>;
      <D.7802>:
      GC_abort ("Absurd stack bottom value");
      <D.7803>:
      D.7804 = (char *) result;
      return D.7804;
    }
  finally
    {
      stat_buf = {CLOBBER};
    }
}


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

  result = GC_linux_stack_base ();
  if (result == 0B) goto <D.7807>; else goto <D.7808>;
  <D.7807>:
  result = -8B;
  <D.7808>:
  D.7809 = result;
  return D.7809;
}


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.7813;
  long unsigned int D.7814;
  char * last_addr.40;
  char * D.7820;
  sizetype D.7821;
  sizetype D.7822;
  char * last_addr.41;
  long unsigned int D.7824;
  long unsigned int last_addr.42;
  long unsigned int D.7826;
  char * last_addr.43;
  long unsigned int result.44;
  long unsigned int D.7829;
  void * result;
  static char * last_addr = 0B;

  GC_page_size.39 = GC_page_size;
  D.7813 = GC_page_size.39 + 18446744073709551615;
  D.7814 = D.7813 & bytes;
  if (D.7814 != 0) goto <D.7815>; else goto <D.7816>;
  <D.7815>:
  GC_abort ("Bad GET_MEM arg");
  <D.7816>:
  last_addr.40 = last_addr;
  result = mmap (last_addr.40, bytes, 3, 34, -1, 0);
  if (result == -1B) goto <D.7818>; else goto <D.7819>;
  <D.7818>:
  D.7820 = 0B;
  return D.7820;
  <D.7819>:
  GC_page_size.39 = GC_page_size;
  D.7821 = bytes + GC_page_size.39;
  D.7822 = D.7821 + 18446744073709551615;
  last_addr.41 = result + D.7822;
  last_addr = last_addr.41;
  GC_page_size.39 = GC_page_size;
  D.7824 = -GC_page_size.39;
  last_addr.40 = last_addr;
  last_addr.42 = (long unsigned int) last_addr.40;
  D.7826 = D.7824 & last_addr.42;
  last_addr.43 = (char *) D.7826;
  last_addr = last_addr.43;
  result.44 = (long unsigned int) result;
  D.7829 = result.44 & 4095;
  if (D.7829 != 0) goto <D.7830>; else goto <D.7831>;
  <D.7830>:
  GC_abort ("GC_unix_get_mem: Memory returned by mmap is not aligned to HBLKSIZE.");
  <D.7831>:
  D.7820 = result;
  return D.7820;
}


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

  D.7833 = 1;
  return D.7833;
}


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

  D.7835 = 1;
  return D.7835;
}


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

  D.7837 = 0;
  return D.7837;
}


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.7839;
  word D.7840;

  D.7839 = strlen (maps);
  GC_err_write (maps, D.7839);
  D.7840 = 1;
  return D.7840;
}