mono_gc_bzero_aligned (void * dest, size_t size)
{
  unsigned int dest.0;
  unsigned int D.18475;
  _Bool D.18476;
  long int D.18477;
  long int D.18478;
  unsigned int __i.1;
  unsigned int D.18482;
  void * volatile * D.18483;
  unsigned int __i.2;
  unsigned int D.18485;
  void * volatile * D.18486;
  unsigned int __i.3;
  unsigned int D.18488;
  void * volatile * D.18489;
  unsigned int __i.4;
  unsigned int D.18491;
  void * volatile * D.18492;
  unsigned int D.18493;
  unsigned int __i.5;
  unsigned int D.18495;
  void * volatile * D.18496;
  volatile char * d.6;
  volatile char * d;
  size_t tail_bytes;
  size_t word_bytes;

  d = dest;
  dest.0 = (unsigned int) dest;
  D.18475 = dest.0 & 3;
  D.18476 = D.18475 != 0;
  D.18477 = (long int) D.18476;
  D.18478 = __builtin_expect (D.18477, 0);
  if (D.18478 != 0) goto <D.18479>; else goto <D.18480>;
  <D.18479>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc-memfuncs.c", 79, "unaligned_bytes (dest) == 0");
  <D.18480>:
  word_bytes = size & 4294967292;
  switch (word_bytes) <default: <D.18420>, case 4: <D.18391>, case 8: <D.18399>, case 12: <D.18406>, case 16: <D.18413>>
  <D.18391>:
  {
    void * volatile * __d;
    int __n;
    int __i;

    __d = d;
    __n = 1;
    __i = 0;
    goto <D.18396>;
    <D.18395>:
    __i.1 = (unsigned int) __i;
    D.18482 = __i.1 * 4;
    D.18483 = __d + D.18482;
    *D.18483 = 0B;
    __i = __i + 1;
    <D.18396>:
    if (__i < __n) goto <D.18395>; else goto <D.18397>;
    <D.18397>:
  }
  goto <D.18398>;
  <D.18399>:
  {
    void * volatile * __d;
    int __n;
    int __i;

    __d = d;
    __n = 2;
    __i = 0;
    goto <D.18404>;
    <D.18403>:
    __i.2 = (unsigned int) __i;
    D.18485 = __i.2 * 4;
    D.18486 = __d + D.18485;
    *D.18486 = 0B;
    __i = __i + 1;
    <D.18404>:
    if (__i < __n) goto <D.18403>; else goto <D.18405>;
    <D.18405>:
  }
  goto <D.18398>;
  <D.18406>:
  {
    void * volatile * __d;
    int __n;
    int __i;

    __d = d;
    __n = 3;
    __i = 0;
    goto <D.18411>;
    <D.18410>:
    __i.3 = (unsigned int) __i;
    D.18488 = __i.3 * 4;
    D.18489 = __d + D.18488;
    *D.18489 = 0B;
    __i = __i + 1;
    <D.18411>:
    if (__i < __n) goto <D.18410>; else goto <D.18412>;
    <D.18412>:
  }
  goto <D.18398>;
  <D.18413>:
  {
    void * volatile * __d;
    int __n;
    int __i;

    __d = d;
    __n = 4;
    __i = 0;
    goto <D.18418>;
    <D.18417>:
    __i.4 = (unsigned int) __i;
    D.18491 = __i.4 * 4;
    D.18492 = __d + D.18491;
    *D.18492 = 0B;
    __i = __i + 1;
    <D.18418>:
    if (__i < __n) goto <D.18417>; else goto <D.18419>;
    <D.18419>:
  }
  goto <D.18398>;
  <D.18420>:
  {
    void * volatile * __d;
    int __n;
    int __i;

    __d = d;
    D.18493 = word_bytes >> 2;
    __n = (int) D.18493;
    __i = 0;
    goto <D.18425>;
    <D.18424>:
    __i.5 = (unsigned int) __i;
    D.18495 = __i.5 * 4;
    D.18496 = __d + D.18495;
    *D.18496 = 0B;
    __i = __i + 1;
    <D.18425>:
    if (__i < __n) goto <D.18424>; else goto <D.18426>;
    <D.18426>:
  }
  <D.18398>:
  tail_bytes = size & 3;
  if (tail_bytes != 0) goto <D.18497>; else goto <D.18498>;
  <D.18497>:
  d = d + word_bytes;
  <D.18427>:
  d.6 = d;
  d = d.6 + 1;
  *d.6 = 0;
  tail_bytes = tail_bytes + 4294967295;
  if (tail_bytes != 0) goto <D.18427>; else goto <D.18428>;
  <D.18428>:
  <D.18498>:
}


mono_gc_bzero_atomic (void * dest, size_t size)
{
  unsigned int dest.7;
  unsigned int D.18501;

  dest.7 = (unsigned int) dest;
  D.18501 = dest.7 & 3;
  if (D.18501 != 0) goto <D.18502>; else goto <D.18503>;
  <D.18502>:
  memset (dest, 0, size);
  goto <D.18504>;
  <D.18503>:
  mono_gc_bzero_aligned (dest, size);
  <D.18504>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.18507;
  int D.18512;
  void * D.18514;
  unsigned int D.18515;

  D.18507 = __builtin_constant_p (__len);
  if (D.18507 != 0) goto <D.18508>; else goto <D.18509>;
  <D.18508>:
  if (__len == 0) goto <D.18510>; else goto <D.18511>;
  <D.18510>:
  D.18512 = __builtin_constant_p (__ch);
  if (D.18512 == 0) goto <D.18505>; else goto <D.18513>;
  <D.18513>:
  if (__ch != 0) goto <D.18505>; else goto <D.18506>;
  <D.18505>:
  __warn_memset_zero_len ();
  D.18514 = __dest;
  return D.18514;
  <D.18506>:
  <D.18511>:
  <D.18509>:
  D.18515 = __builtin_object_size (__dest, 0);
  D.18514 = __builtin___memset_chk (__dest, __ch, __len, D.18515);
  return D.18514;
}


mono_gc_memmove_aligned (void * dest, const void * src, size_t size)
{
  unsigned int dest.8;
  unsigned int D.18518;
  _Bool D.18519;
  long int D.18520;
  long int D.18521;
  unsigned int src.9;
  unsigned int D.18525;
  _Bool D.18526;
  long int D.18527;
  long int D.18528;
  int dest.10;
  int src.11;
  int D.18538;
  unsigned int D.18539;
  unsigned int p.12;
  unsigned int D.18542;
  char * D.18543;
  char D.18544;
  unsigned int start.13;
  unsigned int D.18546;
  unsigned int D.18547;
  int p.14;
  int word_start.15;
  int D.18550;
  sizetype D.18551;
  unsigned int D.18552;
  unsigned int __i.16;
  unsigned int D.18554;
  void * volatile * D.18555;
  void * * D.18556;
  void * D.18557;
  unsigned int D.18558;
  unsigned int __i.17;
  unsigned int D.18560;
  void * volatile * D.18561;
  void * * D.18562;
  void * D.18563;
  sizetype D.18566;
  volatile char * d.18;
  const char * s.19;
  char D.18569;

  dest.8 = (unsigned int) dest;
  D.18518 = dest.8 & 3;
  D.18519 = D.18518 != 0;
  D.18520 = (long int) D.18519;
  D.18521 = __builtin_expect (D.18520, 0);
  if (D.18521 != 0) goto <D.18522>; else goto <D.18523>;
  <D.18522>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc-memfuncs.c", 158, "unaligned_bytes (dest) == 0");
  <D.18523>:
  src.9 = (unsigned int) src;
  D.18525 = src.9 & 3;
  D.18526 = D.18525 != 0;
  D.18527 = (long int) D.18526;
  D.18528 = __builtin_expect (D.18527, 0);
  if (D.18528 != 0) goto <D.18529>; else goto <D.18530>;
  <D.18529>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc-memfuncs.c", 159, "unaligned_bytes (src) == 0");
  <D.18530>:
  if (size <= 3) goto <D.18531>; else goto <D.18532>;
  <D.18531>:
  memmove (dest, src, size);
  return;
  <D.18532>:
  if (dest > src) goto <D.18535>; else goto <D.18533>;
  <D.18535>:
  dest.10 = (int) dest;
  src.11 = (int) src;
  D.18538 = dest.10 - src.11;
  D.18539 = (unsigned int) D.18538;
  if (D.18539 < size) goto <D.18540>; else goto <D.18533>;
  <D.18540>:
  {
    volatile char * p;
    char * s;
    char * start;
    char * align_end;
    char * word_start;
    size_t bytes_to_memmove;

    p = dest + size;
    s = src + size;
    start = dest;
    p.12 = (unsigned int) p;
    D.18542 = p.12 & 4294967292;
    D.18543 = (char *) D.18542;
    align_end = MAX_EXPR <D.18543, dest>;
    goto <D.18445>;
    <D.18444>:
    p = p + 4294967295;
    s = s + 4294967295;
    D.18544 = *s;
    *p = D.18544;
    <D.18445>:
    if (p > align_end) goto <D.18444>; else goto <D.18446>;
    <D.18446>:
    start.13 = (unsigned int) start;
    D.18546 = start.13 + 3;
    D.18547 = D.18546 & 4294967292;
    word_start = (char *) D.18547;
    p.14 = (int) p;
    word_start.15 = (int) word_start;
    D.18550 = p.14 - word_start.15;
    bytes_to_memmove = (size_t) D.18550;
    D.18551 = -bytes_to_memmove;
    p = p + D.18551;
    D.18551 = -bytes_to_memmove;
    s = s + D.18551;
    {
      void * volatile * __d;
      void * * __s;
      int __n;
      int __i;

      __d = p;
      __s = s;
      D.18552 = bytes_to_memmove >> 2;
      __n = (int) D.18552;
      __i = __n + -1;
      goto <D.18452>;
      <D.18451>:
      __i.16 = (unsigned int) __i;
      D.18554 = __i.16 * 4;
      D.18555 = __d + D.18554;
      __i.16 = (unsigned int) __i;
      D.18554 = __i.16 * 4;
      D.18556 = __s + D.18554;
      D.18557 = *D.18556;
      *D.18555 = D.18557;
      __i = __i + -1;
      <D.18452>:
      if (__i >= 0) goto <D.18451>; else goto <D.18453>;
      <D.18453>:
    }
  }
  goto <D.18534>;
  <D.18533>:
  {
    volatile char * d;
    const char * s;
    size_t tail_bytes;

    d = dest;
    s = src;
    {
      void * volatile * __d;
      void * * __s;
      int __n;
      int __i;

      __d = d;
      __s = s;
      D.18558 = size >> 2;
      __n = (int) D.18558;
      __i = 0;
      goto <D.18462>;
      <D.18461>:
      __i.17 = (unsigned int) __i;
      D.18560 = __i.17 * 4;
      D.18561 = __d + D.18560;
      __i.17 = (unsigned int) __i;
      D.18560 = __i.17 * 4;
      D.18562 = __s + D.18560;
      D.18563 = *D.18562;
      *D.18561 = D.18563;
      __i = __i + 1;
      <D.18462>:
      if (__i < __n) goto <D.18461>; else goto <D.18463>;
      <D.18463>:
    }
    tail_bytes = size & 3;
    if (tail_bytes != 0) goto <D.18564>; else goto <D.18565>;
    <D.18564>:
    D.18566 = size & 4294967292;
    d = d + D.18566;
    D.18566 = size & 4294967292;
    s = s + D.18566;
    <D.18464>:
    d.18 = d;
    d = d.18 + 1;
    s.19 = s;
    s = s.19 + 1;
    D.18569 = *s.19;
    *d.18 = D.18569;
    tail_bytes = tail_bytes + 4294967295;
    if (tail_bytes != 0) goto <D.18464>; else goto <D.18465>;
    <D.18465>:
    <D.18565>:
  }
  <D.18534>:
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.18571;
  unsigned int D.18572;

  D.18572 = __builtin_object_size (__dest, 0);
  D.18571 = __builtin___memmove_chk (__dest, __src, __len, D.18572);
  return D.18571;
}


mono_gc_memmove_atomic (void * dest, const void * src, size_t size)
{
  unsigned int dest.20;
  unsigned int src.21;
  unsigned int D.18576;
  unsigned int D.18577;

  dest.20 = (unsigned int) dest;
  src.21 = (unsigned int) src;
  D.18576 = dest.20 | src.21;
  D.18577 = D.18576 & 3;
  if (D.18577 != 0) goto <D.18578>; else goto <D.18579>;
  <D.18578>:
  memmove (dest, src, size);
  goto <D.18580>;
  <D.18579>:
  mono_gc_memmove_aligned (dest, src, size);
  <D.18580>:
}