GC_repeat_read (int fd, char * buf, size_t count)
{
  sizetype num_read.0;
  char * D.7249;
  long unsigned int num_read.1;
  long unsigned int D.7251;
  ssize_t D.7254;
  ssize_t num_read;
  ssize_t result;

  num_read = 0;
  goto <D.7092>;
  <D.7091>:
  num_read.0 = (sizetype) num_read;
  D.7249 = buf + num_read.0;
  num_read.1 = (long unsigned int) num_read;
  D.7251 = count - num_read.1;
  result = read (fd, D.7249, D.7251);
  if (result < 0) goto <D.7252>; else goto <D.7253>;
  <D.7252>:
  D.7254 = result;
  return D.7254;
  <D.7253>:
  if (result == 0) goto <D.7090>; else goto <D.7255>;
  <D.7255>:
  num_read = num_read + result;
  <D.7092>:
  num_read.1 = (long unsigned int) num_read;
  if (num_read.1 < count) goto <D.7091>; else goto <D.7090>;
  <D.7090>:
  D.7254 = num_read;
  return D.7254;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
read (int __fd, void * __buf, size_t __nbytes)
{
  long unsigned int D.7257;
  int D.7260;
  ssize_t D.7263;
  long unsigned int D.7264;
  long unsigned int D.7265;
  long unsigned int D.7268;

  D.7257 = __builtin_object_size (__buf, 0);
  if (D.7257 != 18446744073709551615) goto <D.7258>; else goto <D.7259>;
  <D.7258>:
  D.7260 = __builtin_constant_p (__nbytes);
  if (D.7260 == 0) goto <D.7261>; else goto <D.7262>;
  <D.7261>:
  D.7264 = __builtin_object_size (__buf, 0);
  D.7263 = __read_chk (__fd, __buf, __nbytes, D.7264);
  return D.7263;
  <D.7262>:
  D.7265 = __builtin_object_size (__buf, 0);
  if (D.7265 < __nbytes) goto <D.7266>; else goto <D.7267>;
  <D.7266>:
  D.7268 = __builtin_object_size (__buf, 0);
  D.7263 = __read_chk_warn (__fd, __buf, __nbytes, D.7268);
  return D.7263;
  <D.7267>:
  <D.7259>:
  D.7263 = __read_alias (__fd, __buf, __nbytes);
  return D.7263;
}


GC_apply_to_maps (word (*<T154c>) (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.7278;
  long unsigned int D.7281;
  long int D.7282;
  long unsigned int D.7285;
  char * D.7286;
  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.7108>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.7271>; else goto <D.7272>;
  <D.7271>:
  goto <D.7104>;
  <D.7103>:
  maps_buf_sz.2 = maps_buf_sz;
  maps_buf_sz.3 = maps_buf_sz.2 * 2;
  maps_buf_sz = maps_buf_sz.3;
  <D.7104>:
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.7103>; else goto <D.7105>;
  <D.7105>:
  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.7276>; else goto <D.7277>;
  <D.7276>:
  D.7278 = 0;
  return D.7278;
  <D.7277>:
  <D.7272>:
  f = open ("/proc/self/maps", 0);
  if (f == -1) goto <D.7279>; else goto <D.7280>;
  <D.7279>:
  D.7278 = 0;
  return D.7278;
  <D.7280>:
  maps_size = 0;
  <D.7106>:
  maps_buf.5 = maps_buf;
  maps_buf_sz.2 = maps_buf_sz;
  D.7281 = maps_buf_sz.2 + 18446744073709551615;
  D.7282 = GC_repeat_read (f, maps_buf.5, D.7281);
  result = (int) D.7282;
  if (result <= 0) goto <D.7283>; else goto <D.7284>;
  <D.7283>:
  D.7278 = 0;
  return D.7278;
  <D.7284>:
  D.7285 = (long unsigned int) result;
  maps_size = D.7285 + maps_size;
  D.7285 = (long unsigned int) result;
  maps_buf_sz.2 = maps_buf_sz;
  D.7281 = maps_buf_sz.2 + 18446744073709551615;
  if (D.7285 == D.7281) goto <D.7106>; else goto <D.7107>;
  <D.7107>:
  close (f);
  maps_buf_sz.2 = maps_buf_sz;
  if (maps_size >= maps_buf_sz.2) goto <D.7108>; else goto <D.7109>;
  <D.7109>:
  maps_buf.5 = maps_buf;
  D.7286 = maps_buf.5 + maps_size;
  *D.7286 = 0;
  maps_buf.5 = maps_buf;
  D.7278 = fn (maps_buf.5);
  return D.7278;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
open (const char * __path, int __oflag)
{
  int D.7288;
  int D.7291;
  int D.7296;
  int D.7298;
  int D.7299;
  int D.7302;
  int D.7303;

  D.7288 = __builtin_va_arg_pack_len ();
  if (D.7288 > 1) goto <D.7289>; else goto <D.7290>;
  <D.7289>:
  __open_too_many_args ();
  <D.7290>:
  D.7291 = __builtin_constant_p (__oflag);
  if (D.7291 != 0) goto <D.7292>; else goto <D.7293>;
  <D.7292>:
  D.7296 = __oflag & 64;
  if (D.7296 != 0) goto <D.7294>; else goto <D.7297>;
  <D.7297>:
  D.7298 = __oflag & 4259840;
  if (D.7298 == 4259840) goto <D.7294>; else goto <D.7295>;
  <D.7294>:
  D.7299 = __builtin_va_arg_pack_len ();
  if (D.7299 <= 0) goto <D.7300>; else goto <D.7301>;
  <D.7300>:
  __open_missing_mode ();
  D.7302 = __open_2 (__path, __oflag);
  return D.7302;
  <D.7301>:
  <D.7295>:
  D.7302 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7302;
  <D.7293>:
  D.7303 = __builtin_va_arg_pack_len ();
  if (D.7303 <= 0) goto <D.7304>; else goto <D.7305>;
  <D.7304>:
  D.7302 = __open_2 (__path, __oflag);
  return D.7302;
  <D.7305>:
  D.7302 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7302;
}


GC_disable_signals ()
{
  int mask_initialized.6;
  int new_mask.7;
  int D.7311;
  int D.7312;
  int D.7313;
  int D.7314;
  int D.7315;
  int D.7316;
  int D.7317;

  mask_initialized.6 = mask_initialized;
  if (mask_initialized.6 == 0) goto <D.7308>; else goto <D.7309>;
  <D.7308>:
  new_mask = 2147483647;
  new_mask.7 = new_mask;
  D.7311 = new_mask.7 & -1025;
  new_mask = D.7311;
  new_mask.7 = new_mask;
  D.7312 = new_mask.7 & -9;
  new_mask = D.7312;
  new_mask.7 = new_mask;
  D.7313 = new_mask.7 & -5;
  new_mask = D.7313;
  new_mask.7 = new_mask;
  D.7314 = new_mask.7 & -65;
  new_mask = D.7314;
  new_mask.7 = new_mask;
  D.7315 = new_mask.7 & -33;
  new_mask = D.7315;
  new_mask.7 = new_mask;
  D.7316 = new_mask.7 & -17;
  new_mask = D.7316;
  mask_initialized = 1;
  <D.7309>:
  new_mask.7 = new_mask;
  D.7317 = sigsetmask (new_mask.7);
  old_mask = D.7317;
}


GC_enable_signals ()
{
  int old_mask.8;
  int D.7319;

  old_mask.8 = old_mask;
  D.7319 = sigsetmask (old_mask.8);
  dummy = D.7319;
}


GC_setpagesize ()
{
  GC_page_size = 4096;
}


GC_set_and_save_fault_handler (void (*handler) (int) h)
{
  void (*<T7e3>) (int) D.7320;
  void (*<T7e3>) (int) D.7321;

  D.7320 = signal (11, h);
  old_segv_handler = D.7320;
  D.7321 = signal (7, h);
  old_bus_handler = D.7321;
}


GC_linux_stack_base ()
{
  long int D.7325;
  long unsigned int buf_offset.9;
  long unsigned int buf_offset.10;
  const short unsigned int * * D.7328;
  const short unsigned int * D.7329;
  long unsigned int D.7330;
  long unsigned int D.7331;
  const short unsigned int * D.7332;
  short unsigned int D.7333;
  int D.7334;
  int D.7335;
  long unsigned int buf_offset.11;
  long unsigned int buf_offset.12;
  int D.7338;
  int D.7339;
  long unsigned int D.7340;
  long unsigned int buf_offset.13;
  int D.7342;
  char * D.7345;
  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.7322>; else goto <D.7324>;
      <D.7324>:
      D.7325 = read (f, &stat_buf, 4096);
      if (D.7325 <= 53) goto <D.7322>; else goto <D.7323>;
      <D.7322>:
      GC_abort ("Couldn\'t read /proc/self/stat");
      <D.7323>:
      buf_offset.9 = buf_offset;
      buf_offset = buf_offset.9 + 1;
      c = stat_buf[buf_offset.9];
      i = 0;
      goto <D.7145>;
      <D.7144>:
      goto <D.7139>;
      <D.7138>:
      buf_offset.10 = buf_offset;
      buf_offset = buf_offset.10 + 1;
      c = stat_buf[buf_offset.10];
      <D.7139>:
      D.7328 = __ctype_b_loc ();
      D.7329 = *D.7328;
      D.7330 = (long unsigned int) c;
      D.7331 = D.7330 * 2;
      D.7332 = D.7329 + D.7331;
      D.7333 = *D.7332;
      D.7334 = (int) D.7333;
      D.7335 = D.7334 & 32;
      if (D.7335 != 0) goto <D.7138>; else goto <D.7140>;
      <D.7140>:
      goto <D.7142>;
      <D.7141>:
      buf_offset.11 = buf_offset;
      buf_offset = buf_offset.11 + 1;
      c = stat_buf[buf_offset.11];
      <D.7142>:
      D.7328 = __ctype_b_loc ();
      D.7329 = *D.7328;
      D.7330 = (long unsigned int) c;
      D.7331 = D.7330 * 2;
      D.7332 = D.7329 + D.7331;
      D.7333 = *D.7332;
      D.7334 = (int) D.7333;
      D.7335 = D.7334 & 32;
      if (D.7335 == 0) goto <D.7141>; else goto <D.7143>;
      <D.7143>:
      i = i + 1;
      <D.7145>:
      if (i <= 26) goto <D.7144>; else goto <D.7146>;
      <D.7146>:
      goto <D.7148>;
      <D.7147>:
      buf_offset.12 = buf_offset;
      buf_offset = buf_offset.12 + 1;
      c = stat_buf[buf_offset.12];
      <D.7148>:
      D.7328 = __ctype_b_loc ();
      D.7329 = *D.7328;
      D.7330 = (long unsigned int) c;
      D.7331 = D.7330 * 2;
      D.7332 = D.7329 + D.7331;
      D.7333 = *D.7332;
      D.7334 = (int) D.7333;
      D.7335 = D.7334 & 32;
      if (D.7335 != 0) goto <D.7147>; else goto <D.7149>;
      <D.7149>:
      goto <D.7151>;
      <D.7150>:
      result = result * 10;
      D.7338 = (int) c;
      D.7339 = D.7338 + -48;
      D.7340 = (long unsigned int) D.7339;
      result = D.7340 + result;
      buf_offset.13 = buf_offset;
      buf_offset = buf_offset.13 + 1;
      c = stat_buf[buf_offset.13];
      <D.7151>:
      D.7328 = __ctype_b_loc ();
      D.7329 = *D.7328;
      D.7330 = (long unsigned int) c;
      D.7331 = D.7330 * 2;
      D.7332 = D.7329 + D.7331;
      D.7333 = *D.7332;
      D.7334 = (int) D.7333;
      D.7342 = D.7334 & 8;
      if (D.7342 != 0) goto <D.7150>; else goto <D.7152>;
      <D.7152>:
      close (f);
      if (result <= 268435455) goto <D.7343>; else goto <D.7344>;
      <D.7343>:
      GC_abort ("Absurd stack bottom value");
      <D.7344>:
      D.7345 = (char *) result;
      return D.7345;
    }
  finally
    {
      stat_buf = {CLOBBER};
    }
}


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

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


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


GC_unix_get_mem (word bytes)
{
  long unsigned int GC_page_size.14;
  long unsigned int D.7353;
  long unsigned int D.7354;
  char * last_addr.15;
  char * D.7360;
  sizetype D.7361;
  sizetype D.7362;
  char * last_addr.16;
  long unsigned int D.7364;
  long unsigned int last_addr.17;
  long unsigned int D.7366;
  char * last_addr.18;
  long unsigned int result.19;
  long unsigned int D.7369;
  void * result;
  static char * last_addr = 0B;

  GC_page_size.14 = GC_page_size;
  D.7353 = GC_page_size.14 + 18446744073709551615;
  D.7354 = D.7353 & bytes;
  if (D.7354 != 0) goto <D.7355>; else goto <D.7356>;
  <D.7355>:
  GC_abort ("Bad GET_MEM arg");
  <D.7356>:
  last_addr.15 = last_addr;
  result = mmap (last_addr.15, bytes, 3, 34, -1, 0);
  if (result == -1B) goto <D.7358>; else goto <D.7359>;
  <D.7358>:
  D.7360 = 0B;
  return D.7360;
  <D.7359>:
  GC_page_size.14 = GC_page_size;
  D.7361 = bytes + GC_page_size.14;
  D.7362 = D.7361 + 18446744073709551615;
  last_addr.16 = result + D.7362;
  last_addr = last_addr.16;
  GC_page_size.14 = GC_page_size;
  D.7364 = -GC_page_size.14;
  last_addr.15 = last_addr;
  last_addr.17 = (long unsigned int) last_addr.15;
  D.7366 = D.7364 & last_addr.17;
  last_addr.18 = (char *) D.7366;
  last_addr = last_addr.18;
  result.19 = (long unsigned int) result;
  D.7369 = result.19 & 4095;
  if (D.7369 != 0) goto <D.7370>; else goto <D.7371>;
  <D.7370>:
  GC_abort ("GC_unix_get_mem: Memory returned by mmap is not aligned to HBLKSIZE.");
  <D.7371>:
  D.7360 = result;
  return D.7360;
}


GC_unmap_start (char * start, word bytes)
{
  long unsigned int GC_page_size.20;
  sizetype D.7374;
  long unsigned int D.7375;
  long unsigned int result.21;
  long unsigned int D.7377;
  char * D.7378;
  char * D.7379;
  char * D.7382;
  char * result;

  result = start;
  GC_page_size.20 = GC_page_size;
  D.7374 = GC_page_size.20 + 18446744073709551615;
  result = result + D.7374;
  GC_page_size.20 = GC_page_size;
  D.7375 = -GC_page_size.20;
  result.21 = (long unsigned int) result;
  D.7377 = D.7375 & result.21;
  result = (char *) D.7377;
  GC_page_size.20 = GC_page_size;
  D.7378 = result + GC_page_size.20;
  D.7379 = start + bytes;
  if (D.7378 > D.7379) goto <D.7380>; else goto <D.7381>;
  <D.7380>:
  D.7382 = 0B;
  return D.7382;
  <D.7381>:
  D.7382 = result;
  return D.7382;
}


GC_unmap_end (char * start, word bytes)
{
  long unsigned int GC_page_size.22;
  long unsigned int D.7385;
  long unsigned int end_addr.23;
  long unsigned int D.7387;
  char * D.7388;
  char * end_addr;

  end_addr = start + bytes;
  GC_page_size.22 = GC_page_size;
  D.7385 = -GC_page_size.22;
  end_addr.23 = (long unsigned int) end_addr;
  D.7387 = D.7385 & end_addr.23;
  end_addr = (char *) D.7387;
  D.7388 = end_addr;
  return D.7388;
}


GC_unmap (char * start, word bytes)
{
  long int end_addr.24;
  long int start_addr.25;
  long int D.7392;
  long unsigned int D.7397;
  long unsigned int D.7398;
  char * start_addr;
  char * end_addr;
  word len;

  start_addr = GC_unmap_start (start, bytes);
  end_addr = GC_unmap_end (start, bytes);
  end_addr.24 = (long int) end_addr;
  start_addr.25 = (long int) start_addr;
  D.7392 = end_addr.24 - start_addr.25;
  len = (word) D.7392;
  if (start_addr == 0B) goto <D.7393>; else goto <D.7394>;
  <D.7393>:
  return;
  <D.7394>:
  {
    void * result;

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


GC_remap (char * start, word bytes)
{
  long int end_addr.26;
  long int start_addr.27;
  long int D.7402;
  long int len.28;
  int * D.7408;
  int D.7409;
  long int D.7410;
  long unsigned int D.7411;
  long unsigned int D.7412;
  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.26 = (long int) end_addr;
  start_addr.27 = (long int) start_addr;
  D.7402 = end_addr.26 - start_addr.27;
  len = (word) D.7402;
  if (start_addr == 0B) goto <D.7403>; else goto <D.7404>;
  <D.7403>:
  return;
  <D.7404>:
  result = mprotect (start_addr, len, 3);
  if (result != 0) goto <D.7405>; else goto <D.7406>;
  <D.7405>:
  start_addr.27 = (long int) start_addr;
  len.28 = (long int) len;
  D.7408 = __errno_location ();
  D.7409 = *D.7408;
  D.7410 = (long int) D.7409;
  GC_err_printf ("Mprotect failed at 0x%lx (length %ld) with errno %ld\n", start_addr.27, len.28, D.7410, 0, 0, 0);
  GC_abort ("Mprotect remapping failed");
  <D.7406>:
  D.7411 = GC_arrays._unmapped_bytes;
  D.7412 = D.7411 - len;
  GC_arrays._unmapped_bytes = D.7412;
}


GC_unmap_gap (char * start1, word bytes1, char * start2, word bytes2)
{
  long unsigned int D.7416;
  long int end_addr.29;
  long int start_addr.30;
  long int D.7423;
  long unsigned int D.7428;
  long unsigned int D.7429;
  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.7414>; else goto <D.7415>;
  <D.7414>:
  D.7416 = bytes1 + bytes2;
  start_addr = GC_unmap_start (start1, D.7416);
  <D.7415>:
  if (start2_addr == 0B) goto <D.7417>; else goto <D.7418>;
  <D.7417>:
  D.7416 = bytes1 + bytes2;
  end_addr = GC_unmap_end (start1, D.7416);
  <D.7418>:
  if (start_addr == 0B) goto <D.7419>; else goto <D.7420>;
  <D.7419>:
  return;
  <D.7420>:
  end_addr.29 = (long int) end_addr;
  start_addr.30 = (long int) start_addr;
  D.7423 = end_addr.29 - start_addr.30;
  len = (word) D.7423;
  if (len != 0) goto <D.7424>; else goto <D.7425>;
  <D.7424>:
  {
    void * result;

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


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

  D.7431 = 1;
  return D.7431;
}


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

  D.7433 = 1;
  return D.7433;
}


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

  D.7435 = 0;
  return D.7435;
}


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.7437;
  word D.7438;

  D.7437 = strlen (maps);
  GC_err_write (maps, D.7437);
  D.7438 = 1;
  return D.7438;
}