mono_pagesize ()
{
  int saved_pagesize.0;
  int D.7114;
  int saved_pagesize.1;
  static int saved_pagesize = 0;

  saved_pagesize.0 = saved_pagesize;
  if (saved_pagesize.0 != 0) goto <D.7112>; else goto <D.7113>;
  <D.7112>:
  D.7114 = saved_pagesize;
  return D.7114;
  <D.7113>:
  saved_pagesize.1 = getpagesize ();
  saved_pagesize = saved_pagesize.1;
  D.7114 = saved_pagesize;
  return D.7114;
}


mono_valloc (void * addr, size_t length, int flags)
{
  int D.7117;
  int D.7120;
  void * D.7129;
  void * ptr;
  int mflags;
  int prot;

  mflags = 0;
  prot = prot_from_flags (flags);
  D.7117 = flags & 128;
  if (D.7117 != 0) goto <D.7118>; else goto <D.7119>;
  <D.7118>:
  mflags = mflags | 16;
  <D.7119>:
  D.7120 = flags & 256;
  if (D.7120 != 0) goto <D.7121>; else goto <D.7122>;
  <D.7121>:
  mflags = mflags;
  <D.7122>:
  mflags = mflags | 32;
  mflags = mflags | 2;
  ptr = mmap (addr, length, prot, mflags, -1, 0);
  if (ptr == -1B) goto <D.7123>; else goto <D.7124>;
  <D.7123>:
  {
    int fd;

    fd = open ("/dev/zero", 0);
    if (fd != -1) goto <D.7125>; else goto <D.7126>;
    <D.7125>:
    ptr = mmap (addr, length, prot, mflags, fd, 0);
    close (fd);
    <D.7126>:
    if (ptr == -1B) goto <D.7127>; else goto <D.7128>;
    <D.7127>:
    D.7129 = 0B;
    return D.7129;
    <D.7128>:
  }
  <D.7124>:
  D.7129 = ptr;
  return D.7129;
}


prot_from_flags (int flags)
{
  int D.7131;
  int D.7134;
  int D.7137;
  int D.7140;
  int prot;

  prot = 0;
  D.7131 = flags & 1;
  if (D.7131 != 0) goto <D.7132>; else goto <D.7133>;
  <D.7132>:
  prot = prot | 1;
  <D.7133>:
  D.7134 = flags & 2;
  if (D.7134 != 0) goto <D.7135>; else goto <D.7136>;
  <D.7135>:
  prot = prot | 2;
  <D.7136>:
  D.7137 = flags & 4;
  if (D.7137 != 0) goto <D.7138>; else goto <D.7139>;
  <D.7138>:
  prot = prot | 4;
  <D.7139>:
  D.7140 = prot;
  return D.7140;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
open (const char * __path, int __oflag)
{
  int D.7142;
  int D.7145;
  int D.7150;
  int D.7152;
  int D.7153;
  int D.7156;
  int D.7157;

  D.7142 = __builtin_va_arg_pack_len ();
  if (D.7142 > 1) goto <D.7143>; else goto <D.7144>;
  <D.7143>:
  __open_too_many_args ();
  <D.7144>:
  D.7145 = __builtin_constant_p (__oflag);
  if (D.7145 != 0) goto <D.7146>; else goto <D.7147>;
  <D.7146>:
  D.7150 = __oflag & 64;
  if (D.7150 != 0) goto <D.7148>; else goto <D.7151>;
  <D.7151>:
  D.7152 = __oflag & 4259840;
  if (D.7152 == 4259840) goto <D.7148>; else goto <D.7149>;
  <D.7148>:
  D.7153 = __builtin_va_arg_pack_len ();
  if (D.7153 <= 0) goto <D.7154>; else goto <D.7155>;
  <D.7154>:
  __open_missing_mode ();
  D.7156 = __open_2 (__path, __oflag);
  return D.7156;
  <D.7155>:
  <D.7149>:
  D.7156 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7156;
  <D.7147>:
  D.7157 = __builtin_va_arg_pack_len ();
  if (D.7157 <= 0) goto <D.7158>; else goto <D.7159>;
  <D.7158>:
  D.7156 = __open_2 (__path, __oflag);
  return D.7156;
  <D.7159>:
  D.7156 = __open_alias (__path, __oflag, __builtin_va_arg_pack ());
  return D.7156;
}


mono_vfree (void * addr, size_t length)
{
  int D.7161;

  D.7161 = munmap (addr, length);
  return D.7161;
}


mono_file_map (size_t length, int flags, int fd, guint64 offset, void * * ret_handle)
{
  int D.7163;
  int D.7166;
  int D.7169;
  int D.7172;
  long int offset.2;
  void * D.7178;
  void * length.3;
  void * ptr;
  int mflags;
  int prot;

  mflags = 0;
  prot = prot_from_flags (flags);
  D.7163 = flags & 16;
  if (D.7163 != 0) goto <D.7164>; else goto <D.7165>;
  <D.7164>:
  mflags = mflags | 2;
  <D.7165>:
  D.7166 = flags & 32;
  if (D.7166 != 0) goto <D.7167>; else goto <D.7168>;
  <D.7167>:
  mflags = mflags | 1;
  <D.7168>:
  D.7169 = flags & 128;
  if (D.7169 != 0) goto <D.7170>; else goto <D.7171>;
  <D.7170>:
  mflags = mflags | 16;
  <D.7171>:
  D.7172 = flags & 256;
  if (D.7172 != 0) goto <D.7173>; else goto <D.7174>;
  <D.7173>:
  mflags = mflags;
  <D.7174>:
  offset.2 = (long int) offset;
  ptr = mmap (0B, length, prot, mflags, fd, offset.2);
  if (ptr == -1B) goto <D.7176>; else goto <D.7177>;
  <D.7176>:
  D.7178 = 0B;
  return D.7178;
  <D.7177>:
  length.3 = (void *) length;
  *ret_handle = length.3;
  D.7178 = ptr;
  return D.7178;
}


mono_file_unmap (void * addr, void * handle)
{
  int D.7181;
  long unsigned int handle.4;

  handle.4 = (long unsigned int) handle;
  D.7181 = munmap (addr, handle.4);
  return D.7181;
}


mono_mprotect (void * addr, size_t length, int flags)
{
  int D.7184;
  int D.7187;
  int D.7190;
  int prot;

  prot = prot_from_flags (flags);
  D.7184 = flags & 8;
  if (D.7184 != 0) goto <D.7185>; else goto <D.7186>;
  <D.7185>:
  D.7187 = madvise (addr, length, 4);
  if (D.7187 != 0) goto <D.7188>; else goto <D.7189>;
  <D.7188>:
  memset (addr, 0, length);
  <D.7189>:
  <D.7186>:
  D.7190 = mprotect (addr, length, prot);
  return D.7190;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.7192;
  long unsigned int D.7193;

  D.7193 = __builtin_object_size (__dest, 0);
  D.7192 = __builtin___memset_chk (__dest, __ch, __len, D.7193);
  return D.7192;
}


mono_shared_area ()
{
  int D.7195;
  void * malloced_shared_area.5;
  void * D.7201;
  void * D.7202;
  int * D.7205;
  int D.7206;
  long int D.7211;
  int D.7212;
  long unsigned int D.7215;
  int fd;
  int pid;
  int size;
  char buf[128];
  void * res;
  struct SAreaHeader * header;

  try
    {
      pid = getpid ();
      size = mono_pagesize ();
      D.7195 = shared_area_disabled ();
      if (D.7195 != 0) goto <D.7196>; else goto <D.7197>;
      <D.7196>:
      malloced_shared_area.5 = malloced_shared_area;
      if (malloced_shared_area.5 == 0B) goto <D.7199>; else goto <D.7200>;
      <D.7199>:
      D.7201 = malloc_shared_area (0);
      malloced_shared_area = D.7201;
      <D.7200>:
      D.7202 = malloced_shared_area;
      return D.7202;
      <D.7197>:
      mono_shared_area_instances_helper (0B, 0, 1);
      monoeg_g_snprintf (&buf, 128, "/mono.%d", pid);
      fd = shm_open (&buf, 194, 416);
      if (fd == -1) goto <D.7203>; else goto <D.7204>;
      <D.7203>:
      D.7205 = __errno_location ();
      D.7206 = *D.7205;
      if (D.7206 == 17) goto <D.7207>; else goto <D.7208>;
      <D.7207>:
      shm_unlink (&buf);
      fd = shm_open (&buf, 194, 416);
      <D.7208>:
      <D.7204>:
      if (fd == -1) goto <D.7209>; else goto <D.7210>;
      <D.7209>:
      D.7202 = malloc_shared_area (pid);
      return D.7202;
      <D.7210>:
      D.7211 = (long int) size;
      D.7212 = ftruncate (fd, D.7211);
      if (D.7212 != 0) goto <D.7213>; else goto <D.7214>;
      <D.7213>:
      shm_unlink (&buf);
      close (fd);
      <D.7214>:
      D.7215 = (long unsigned int) size;
      res = mmap (0B, D.7215, 3, 1, fd, 0);
      if (res == -1B) goto <D.7216>; else goto <D.7217>;
      <D.7216>:
      shm_unlink (&buf);
      close (fd);
      D.7202 = malloc_shared_area (pid);
      return D.7202;
      <D.7217>:
      close (fd);
      header = res;
      header->size = size;
      header->pid = pid;
      header->stats_start = 16;
      header->stats_end = 16;
      atexit (mono_shared_area_remove);
      D.7202 = res;
      return D.7202;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


shared_area_disabled ()
{
  int use_shared_area.6;
  const gchar * D.7223;
  gboolean D.7227;
  _Bool D.7228;

  use_shared_area.6 = use_shared_area;
  if (use_shared_area.6 == 0) goto <D.7221>; else goto <D.7222>;
  <D.7221>:
  D.7223 = monoeg_g_getenv ("MONO_DISABLE_SHARED_AREA");
  if (D.7223 != 0B) goto <D.7224>; else goto <D.7225>;
  <D.7224>:
  use_shared_area = -1;
  goto <D.7226>;
  <D.7225>:
  use_shared_area = 1;
  <D.7226>:
  <D.7222>:
  use_shared_area.6 = use_shared_area;
  D.7228 = use_shared_area.6 == -1;
  D.7227 = (gboolean) D.7228;
  return D.7227;
}


mono_shared_area_instances_helper (void * * array, int count, gboolean cleanup)
{
  int D.7232;
  _Bool iftmp.7;
  long unsigned int D.7234;
  int D.7237;
  int D.7239;
  const char * D.7242;
  long int D.7243;
  char * nend.8;
  char D.7249;
  int i.9;
  long unsigned int D.7254;
  long unsigned int D.7255;
  void * * D.7256;
  long int D.7257;
  void * D.7258;
  int D.7263;
  int * D.7266;
  int D.7267;
  const char * name;
  int i;
  int curpid;
  struct GDir * dir;

  i = 0;
  curpid = getpid ();
  dir = monoeg_g_dir_open ("/dev/shm/", 0, 0B);
  if (dir == 0B) goto <D.7230>; else goto <D.7231>;
  <D.7230>:
  D.7232 = mono_shared_area_instances_slow (array, count, cleanup);
  return D.7232;
  <D.7231>:
  goto <D.7072>;
  <D.7075>:
  {
    int pid;
    char * nend;

    try
      {
        D.7234 = __strlen_g ("mono.");
        if (D.7234 <= 4) goto <D.7235>; else goto <D.7236>;
        <D.7235>:
        D.7237 = strcmp (name, "mono.");
        iftmp.7 = D.7237 != 0;
        goto <D.7238>;
        <D.7236>:
        D.7239 = strncmp (name, "mono.", 5);
        iftmp.7 = D.7239 != 0;
        <D.7238>:
        if (iftmp.7 != 0) goto <D.7240>; else goto <D.7241>;
        <D.7240>:
        // predicted unlikely by continue predictor.
        goto <D.7072>;
        <D.7241>:
        D.7242 = name + 5;
        D.7243 = strtol (D.7242, &nend, 10);
        pid = (int) D.7243;
        if (pid <= 0) goto <D.7244>; else goto <D.7246>;
        <D.7246>:
        D.7242 = name + 5;
        nend.8 = nend;
        if (D.7242 == nend.8) goto <D.7244>; else goto <D.7248>;
        <D.7248>:
        nend.8 = nend;
        D.7249 = *nend.8;
        if (D.7249 != 0) goto <D.7244>; else goto <D.7245>;
        <D.7244>:
        // predicted unlikely by continue predictor.
        goto <D.7072>;
        <D.7245>:
        if (cleanup == 0) goto <D.7250>; else goto <D.7251>;
        <D.7250>:
        if (i < count) goto <D.7252>; else goto <D.7073>;
        <D.7252>:
        i.9 = i;
        i = i.9 + 1;
        D.7254 = (long unsigned int) i.9;
        D.7255 = D.7254 * 8;
        D.7256 = array + D.7255;
        D.7257 = (long int) pid;
        D.7258 = (void *) D.7257;
        *D.7256 = D.7258;
        <D.7251>:
        if (curpid != pid) goto <D.7261>; else goto <D.7262>;
        <D.7261>:
        D.7263 = kill (pid, 0);
        if (D.7263 == -1) goto <D.7264>; else goto <D.7265>;
        <D.7264>:
        D.7266 = __errno_location ();
        D.7267 = *D.7266;
        if (D.7267 == 3) goto <D.7259>; else goto <D.7268>;
        <D.7268>:
        D.7266 = __errno_location ();
        D.7267 = *D.7266;
        if (D.7267 == 12) goto <D.7259>; else goto <D.7260>;
        <D.7259>:
        {
          char buf[128];

          try
            {
              monoeg_g_snprintf (&buf, 128, "/mono.%d", pid);
              shm_unlink (&buf);
            }
          finally
            {
              buf = {CLOBBER};
            }
        }
        <D.7260>:
        <D.7265>:
        <D.7262>:
      }
    finally
      {
        nend = {CLOBBER};
      }
  }
  <D.7072>:
  name = monoeg_g_dir_read_name (dir);
  if (name != 0B) goto <D.7075>; else goto <D.7073>;
  <D.7073>:
  monoeg_g_dir_close (dir);
  D.7232 = i;
  return D.7232;
}


mono_shared_area_instances_slow (void * * array, int count, gboolean cleanup)
{
  long unsigned int D.7273;
  long unsigned int D.7274;
  void * * D.7275;
  void * D.7276;
  int j.10;
  long unsigned int D.7283;
  long unsigned int D.7284;
  void * * D.7285;
  int num.11;
  int D.7287;
  int i;
  int j;
  int num;
  void * data;
  void * * processes;

  try
    {
      j = 0;
      processes = mono_process_list (&num);
      i = 0;
      goto <D.7060>;
      <D.7059>:
      D.7273 = (long unsigned int) i;
      D.7274 = D.7273 * 8;
      D.7275 = processes + D.7274;
      D.7276 = *D.7275;
      data = mono_shared_area_for_pid (D.7276);
      if (data == 0B) goto <D.7277>; else goto <D.7278>;
      <D.7277>:
      // predicted unlikely by continue predictor.
      goto <D.7057>;
      <D.7278>:
      mono_shared_area_unload (data);
      if (cleanup == 0) goto <D.7279>; else goto <D.7280>;
      <D.7279>:
      if (j < count) goto <D.7281>; else goto <D.7058>;
      <D.7281>:
      j.10 = j;
      j = j.10 + 1;
      D.7283 = (long unsigned int) j.10;
      D.7284 = D.7283 * 8;
      D.7285 = array + D.7284;
      D.7273 = (long unsigned int) i;
      D.7274 = D.7273 * 8;
      D.7275 = processes + D.7274;
      D.7276 = *D.7275;
      *D.7285 = D.7276;
      <D.7280>:
      <D.7057>:
      i = i + 1;
      <D.7060>:
      num.11 = num;
      if (i < num.11) goto <D.7059>; else goto <D.7058>;
      <D.7058>:
      monoeg_g_free (processes);
      D.7287 = j;
      return D.7287;
    }
  finally
    {
      num = {CLOBBER};
    }
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.7290;
  long int __ptr.12;
  long int __str.13;
  long int D.7293;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.12 = (long int) __ptr;
  __str.13 = (long int) __str;
  D.7293 = __ptr.12 - __str.13;
  D.7290 = (size_t) D.7293;
  return D.7290;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.14;
  int iftmp.15;
  int D.7303;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.7296>; else goto <D.7297>;
  <D.7296>:
  if (__ret == 1) goto <D.7299>; else goto <D.7300>;
  <D.7299>:
  iftmp.15 = -1;
  goto <D.7301>;
  <D.7300>:
  iftmp.15 = 1;
  <D.7301>:
  iftmp.14 = iftmp.15;
  goto <D.7302>;
  <D.7297>:
  iftmp.14 = 0;
  <D.7302>:
  __ret = iftmp.14;
  D.7303 = __ret;
  return D.7303;
}


malloc_shared_area (int pid)
{
  long unsigned int D.7305;
  void * D.7306;
  int size;
  struct SAreaHeader * sarea;

  size = mono_pagesize ();
  D.7305 = (long unsigned int) size;
  sarea = monoeg_malloc0 (D.7305);
  sarea->size = size;
  sarea->pid = pid;
  sarea->stats_start = 16;
  sarea->stats_end = 16;
  D.7306 = sarea;
  return D.7306;
}


mono_shared_area_remove ()
{
  int D.7308;
  void * malloced_shared_area.16;
  int D.7314;
  char buf[128];

  try
    {
      D.7308 = shared_area_disabled ();
      if (D.7308 != 0) goto <D.7309>; else goto <D.7310>;
      <D.7309>:
      malloced_shared_area.16 = malloced_shared_area;
      if (malloced_shared_area.16 != 0B) goto <D.7312>; else goto <D.7313>;
      <D.7312>:
      malloced_shared_area.16 = malloced_shared_area;
      monoeg_g_free (malloced_shared_area.16);
      <D.7313>:
      return;
      <D.7310>:
      D.7314 = getpid ();
      monoeg_g_snprintf (&buf, 128, "/mono.%d", D.7314);
      shm_unlink (&buf);
      malloced_shared_area.16 = malloced_shared_area;
      if (malloced_shared_area.16 != 0B) goto <D.7315>; else goto <D.7316>;
      <D.7315>:
      malloced_shared_area.16 = malloced_shared_area;
      monoeg_g_free (malloced_shared_area.16);
      <D.7316>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_shared_area_for_pid (void * pid)
{
  int D.7320;
  void * D.7323;
  long int pid.17;
  int D.7325;
  long unsigned int D.7328;
  int fd;
  int size;
  char buf[128];
  void * res;

  try
    {
      size = mono_pagesize ();
      D.7320 = shared_area_disabled ();
      if (D.7320 != 0) goto <D.7321>; else goto <D.7322>;
      <D.7321>:
      D.7323 = 0B;
      return D.7323;
      <D.7322>:
      pid.17 = (long int) pid;
      D.7325 = (int) pid.17;
      monoeg_g_snprintf (&buf, 128, "/mono.%d", D.7325);
      fd = shm_open (&buf, 0, 288);
      if (fd == -1) goto <D.7326>; else goto <D.7327>;
      <D.7326>:
      D.7323 = 0B;
      return D.7323;
      <D.7327>:
      D.7328 = (long unsigned int) size;
      res = mmap (0B, D.7328, 1, 1, fd, 0);
      if (res == -1B) goto <D.7329>; else goto <D.7330>;
      <D.7329>:
      close (fd);
      D.7323 = 0B;
      return D.7323;
      <D.7330>:
      close (fd);
      D.7323 = res;
      return D.7323;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_shared_area_unload (void * area)
{
  int D.7333;
  long unsigned int D.7334;

  D.7333 = mono_pagesize ();
  D.7334 = (long unsigned int) D.7333;
  munmap (area, D.7334);
}


mono_shared_area_instances (void * * array, int count)
{
  int D.7335;

  D.7335 = mono_shared_area_instances_helper (array, count, 0);
  return D.7335;
}


mono_valloc_aligned (size_t size, size_t alignment, int flags)
{
  long unsigned int D.7337;
  void * D.7340;
  long int aligned.18;
  long int mem.19;
  long int D.7345;
  long unsigned int D.7346;
  char * D.7347;
  sizetype D.7348;
  char * D.7349;
  long int D.7352;
  long int D.7353;
  long int D.7354;
  long unsigned int D.7355;
  char * mem;
  char * aligned;

  D.7337 = size + alignment;
  mem = mono_valloc (0B, D.7337, flags);
  if (mem == 0B) goto <D.7338>; else goto <D.7339>;
  <D.7338>:
  D.7340 = 0B;
  return D.7340;
  <D.7339>:
  aligned = aligned_address (mem, size, alignment);
  if (aligned > mem) goto <D.7341>; else goto <D.7342>;
  <D.7341>:
  aligned.18 = (long int) aligned;
  mem.19 = (long int) mem;
  D.7345 = aligned.18 - mem.19;
  D.7346 = (long unsigned int) D.7345;
  mono_vfree (mem, D.7346);
  <D.7342>:
  D.7347 = aligned + size;
  D.7348 = size + alignment;
  D.7349 = mem + D.7348;
  if (D.7347 < D.7349) goto <D.7350>; else goto <D.7351>;
  <D.7350>:
  D.7347 = aligned + size;
  D.7348 = size + alignment;
  D.7349 = mem + D.7348;
  D.7352 = (long int) D.7349;
  D.7347 = aligned + size;
  D.7353 = (long int) D.7347;
  D.7354 = D.7352 - D.7353;
  D.7355 = (long unsigned int) D.7354;
  mono_vfree (D.7347, D.7355);
  <D.7351>:
  D.7340 = aligned;
  return D.7340;
}


aligned_address (char * mem, size_t size, size_t alignment)
{
  sizetype D.7357;
  char * D.7358;
  long unsigned int D.7359;
  long unsigned int D.7360;
  long unsigned int D.7361;
  int iftmp.20;
  char * D.7367;
  sizetype D.7368;
  char * D.7369;
  long unsigned int D.7371;
  long unsigned int aligned.21;
  long unsigned int D.7373;
  _Bool D.7374;
  long int D.7375;
  long int D.7376;
  char * D.7379;
  char * aligned;

  D.7357 = alignment + 18446744073709551615;
  D.7358 = mem + D.7357;
  D.7359 = (long unsigned int) D.7358;
  D.7360 = -alignment;
  D.7361 = D.7359 & D.7360;
  aligned = (char *) D.7361;
  if (aligned < mem) goto <D.7363>; else goto <D.7366>;
  <D.7366>:
  D.7367 = aligned + size;
  D.7368 = size + alignment;
  D.7369 = mem + D.7368;
  if (D.7367 > D.7369) goto <D.7363>; else goto <D.7370>;
  <D.7370>:
  D.7371 = alignment + 18446744073709551615;
  aligned.21 = (long unsigned int) aligned;
  D.7373 = D.7371 & aligned.21;
  if (D.7373 != 0) goto <D.7363>; else goto <D.7364>;
  <D.7363>:
  iftmp.20 = 1;
  goto <D.7365>;
  <D.7364>:
  iftmp.20 = 0;
  <D.7365>:
  D.7374 = iftmp.20 != 0;
  D.7375 = (long int) D.7374;
  D.7376 = __builtin_expect (D.7375, 0);
  if (D.7376 != 0) goto <D.7377>; else goto <D.7378>;
  <D.7377>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-mmap.c", 69, "aligned >= mem && aligned + size <= mem + size + alignment && !((gulong)aligned & (alignment - 1))");
  <D.7378>:
  D.7379 = aligned;
  return D.7379;
}