#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int uint8_t;
typedef int uint64_t;
typedef int uint32_t;
typedef int uint16_t;
typedef scalar_t__ ssize_t;

/* Variables and functions */
ssize_t imcd_xor(void *src, const ssize_t srcsize, const ssize_t srcstride,
                 void *dst, const ssize_t dstsize, const ssize_t dststride,
                 const ssize_t itemsize, const int decode) {
  const int inplace = (dst == NULL) || (dst == src);
  const ssize_t size =
      inplace ? srcsize : (((srcsize) < (dstsize)) ? (srcsize) : (dstsize));
  const ssize_t stride = inplace ? srcstride : dststride;
  char *srcptr = (char *)src;
  char *dstptr = inplace ? (char *)src : (char *)dst;
  ssize_t i;
  if ((srcsize < 0) || (dstsize < 0)) {
    return -5;
  }
  if (size <= 0) {
    return 0;
  }
  switch (itemsize) {
  case 1: {
    uint8_t prev, t;
    if (decode) {
      if (inplace && (stride == sizeof(uint8_t)) &&
          (srcstride == sizeof(uint8_t))) {
        uint8_t *psrc = (uint8_t *)srcptr;
        prev = psrc[0];
        for (i = 1; i < size; i++) {
          prev = psrc[i] ^= prev;
        }
      } else {
        *(uint8_t *)dstptr = prev = (*(uint8_t *)srcptr);
        for (i = 1; i < size; i++) {
          dstptr += stride;
          srcptr += srcstride;
          *(uint8_t *)dstptr = prev = (*(uint8_t *)srcptr) ^ prev;
        }
      }
    } else {
      *(uint8_t *)dstptr = prev = (*(uint8_t *)srcptr);
      for (i = 1; i < size; i++) {
        dstptr += stride;
        srcptr += srcstride;
        t = (*(uint8_t *)srcptr);
        *(uint8_t *)dstptr = t ^ prev;
        prev = t;
      }
    }
  }; break;
  case 2: {
    uint16_t prev, t;
    if (decode) {
      if (inplace && (stride == sizeof(uint16_t)) &&
          (srcstride == sizeof(uint16_t))) {
        uint16_t *psrc = (uint16_t *)srcptr;
        prev = psrc[0];
        for (i = 1; i < size; i++) {
          prev = psrc[i] ^= prev;
        }
      } else {
        *(uint16_t *)dstptr = prev = (*(uint16_t *)srcptr);
        for (i = 1; i < size; i++) {
          dstptr += stride;
          srcptr += srcstride;
          *(uint16_t *)dstptr = prev = (*(uint16_t *)srcptr) ^ prev;
        }
      }
    } else {
      *(uint16_t *)dstptr = prev = (*(uint16_t *)srcptr);
      for (i = 1; i < size; i++) {
        dstptr += stride;
        srcptr += srcstride;
        t = (*(uint16_t *)srcptr);
        *(uint16_t *)dstptr = t ^ prev;
        prev = t;
      }
    }
  }; break;
  case 4: {
    uint32_t prev, t;
    if (decode) {
      if (inplace && (stride == sizeof(uint32_t)) &&
          (srcstride == sizeof(uint32_t))) {
        uint32_t *psrc = (uint32_t *)srcptr;
        prev = psrc[0];
        for (i = 1; i < size; i++) {
          prev = psrc[i] ^= prev;
        }
      } else {
        *(uint32_t *)dstptr = prev = (*(uint32_t *)srcptr);
        for (i = 1; i < size; i++) {
          dstptr += stride;
          srcptr += srcstride;
          *(uint32_t *)dstptr = prev = (*(uint32_t *)srcptr) ^ prev;
        }
      }
    } else {
      *(uint32_t *)dstptr = prev = (*(uint32_t *)srcptr);
      for (i = 1; i < size; i++) {
        dstptr += stride;
        srcptr += srcstride;
        t = (*(uint32_t *)srcptr);
        *(uint32_t *)dstptr = t ^ prev;
        prev = t;
      }
    }
  }; break;
  case 8: {
    uint64_t prev, t;
    if (decode) {
      if (inplace && (stride == sizeof(uint64_t)) &&
          (srcstride == sizeof(uint64_t))) {
        uint64_t *psrc = (uint64_t *)srcptr;
        prev = psrc[0];
        for (i = 1; i < size; i++) {
          prev = psrc[i] ^= prev;
        }
      } else {
        *(uint64_t *)dstptr = prev = (*(uint64_t *)srcptr);
        for (i = 1; i < size; i++) {
          dstptr += stride;
          srcptr += srcstride;
          *(uint64_t *)dstptr = prev = (*(uint64_t *)srcptr) ^ prev;
        }
      }
    } else {
      *(uint64_t *)dstptr = prev = (*(uint64_t *)srcptr);
      for (i = 1; i < size; i++) {
        dstptr += stride;
        srcptr += srcstride;
        t = (*(uint64_t *)srcptr);
        *(uint64_t *)dstptr = t ^ prev;
        prev = t;
      }
    }
  }; break;
  default:
    return -5;
  }
  return size;
}


x86 assembly (clang, -O0):
<imcd_xor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x58,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    $0x1,%al
cmpq   $0x0,-0x28(%rbp)
mov    %al,-0xa9(%rbp)
je     114b <imcd_xor+0x4b>
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
sete   %al
mov    %al,-0xa9(%rbp)
mov    -0xa9(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     1173 <imcd_xor+0x73>
mov    -0x18(%rbp),%rax
mov    %rax,-0xb8(%rbp)
jmp    11aa <imcd_xor+0xaa>
mov    -0x18(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    1191 <imcd_xor+0x91>
mov    -0x18(%rbp),%rax
mov    %rax,-0xc0(%rbp)
jmp    119c <imcd_xor+0x9c>
mov    -0x30(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     11cf <imcd_xor+0xcf>
mov    -0x20(%rbp),%rax
mov    %rax,-0xc8(%rbp)
jmp    11da <imcd_xor+0xda>
mov    -0x38(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     1207 <imcd_xor+0x107>
mov    -0x10(%rbp),%rax
mov    %rax,-0xd0(%rbp)
jmp    1212 <imcd_xor+0x112>
mov    -0x28(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x18(%rbp)
jl     1233 <imcd_xor+0x133>
cmpq   $0x0,-0x30(%rbp)
jge    1240 <imcd_xor+0x140>
movq   $0xfffffffffffffffb,-0x8(%rbp)
ff
jmp    1860 <imcd_xor+0x760>
cmpq   $0x0,-0x48(%rbp)
jg     1258 <imcd_xor+0x158>
movq   $0x0,-0x8(%rbp)
jmp    1860 <imcd_xor+0x760>
mov    0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xd8(%rbp)
sub    $0x7,%rax
ja     184b <imcd_xor+0x74b>
mov    -0xd8(%rbp),%rax
lea    0xd81(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x0,0x18(%rbp)
je     136d <imcd_xor+0x26d>
cmpl   $0x0,-0x3c(%rbp)
je     1303 <imcd_xor+0x203>
cmpq   $0x4,-0x50(%rbp)
jne    1303 <imcd_xor+0x203>
cmpq   $0x4,-0x20(%rbp)
jne    1303 <imcd_xor+0x203>
mov    -0x58(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x6c(%rbp)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    12fe <imcd_xor+0x1fe>
mov    -0x6c(%rbp),%eax
mov    -0x78(%rbp),%rcx
mov    -0x68(%rbp),%rdx
xor    (%rcx,%rdx,4),%eax
mov    %eax,(%rcx,%rdx,4)
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    12cb <imcd_xor+0x1cb>
jmp    1368 <imcd_xor+0x268>
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
mov    %ecx,-0x6c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1363 <imcd_xor+0x263>
mov    -0x50(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
xor    -0x6c(%rbp),%ecx
mov    %ecx,-0x6c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    131a <imcd_xor+0x21a>
jmp    1368 <imcd_xor+0x268>
jmp    13db <imcd_xor+0x2db>
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
mov    %ecx,-0x6c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    13d6 <imcd_xor+0x2d6>
mov    -0x50(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%ecx
xor    -0x6c(%rbp),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1384 <imcd_xor+0x284>
jmp    13db <imcd_xor+0x2db>
jmp    1858 <imcd_xor+0x758>
cmpl   $0x0,0x18(%rbp)
je     14ce <imcd_xor+0x3ce>
cmpl   $0x0,-0x3c(%rbp)
je     1464 <imcd_xor+0x364>
cmpq   $0x4,-0x50(%rbp)
jne    1464 <imcd_xor+0x364>
cmpq   $0x4,-0x20(%rbp)
jne    1464 <imcd_xor+0x364>
mov    -0x58(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x7c(%rbp)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    145f <imcd_xor+0x35f>
mov    -0x7c(%rbp),%eax
mov    -0x88(%rbp),%rcx
mov    -0x68(%rbp),%rdx
xor    (%rcx,%rdx,4),%eax
mov    %eax,(%rcx,%rdx,4)
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1429 <imcd_xor+0x329>
jmp    14c9 <imcd_xor+0x3c9>
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
mov    %ecx,-0x7c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    14c4 <imcd_xor+0x3c4>
mov    -0x50(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
xor    -0x7c(%rbp),%ecx
mov    %ecx,-0x7c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    147b <imcd_xor+0x37b>
jmp    14c9 <imcd_xor+0x3c9>
jmp    153c <imcd_xor+0x43c>
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
mov    %ecx,-0x7c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1537 <imcd_xor+0x437>
mov    -0x50(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%ecx
xor    -0x7c(%rbp),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x80(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    14e5 <imcd_xor+0x3e5>
jmp    153c <imcd_xor+0x43c>
jmp    1858 <imcd_xor+0x758>
cmpl   $0x0,0x18(%rbp)
je     1641 <imcd_xor+0x541>
cmpl   $0x0,-0x3c(%rbp)
je     15ce <imcd_xor+0x4ce>
cmpq   $0x4,-0x50(%rbp)
jne    15ce <imcd_xor+0x4ce>
cmpq   $0x4,-0x20(%rbp)
jne    15ce <imcd_xor+0x4ce>
mov    -0x58(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x8c(%rbp)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    15c9 <imcd_xor+0x4c9>
mov    -0x8c(%rbp),%eax
mov    -0x98(%rbp),%rcx
mov    -0x68(%rbp),%rdx
xor    (%rcx,%rdx,4),%eax
mov    %eax,(%rcx,%rdx,4)
mov    %eax,-0x8c(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    158d <imcd_xor+0x48d>
jmp    163c <imcd_xor+0x53c>
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
mov    %ecx,-0x8c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1637 <imcd_xor+0x537>
mov    -0x50(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
xor    -0x8c(%rbp),%ecx
mov    %ecx,-0x8c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    15e8 <imcd_xor+0x4e8>
jmp    163c <imcd_xor+0x53c>
jmp    16c1 <imcd_xor+0x5c1>
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
mov    %ecx,-0x8c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    16bc <imcd_xor+0x5bc>
mov    -0x50(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%ecx
xor    -0x8c(%rbp),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x90(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    165b <imcd_xor+0x55b>
jmp    16c1 <imcd_xor+0x5c1>
jmp    1858 <imcd_xor+0x758>
cmpl   $0x0,0x18(%rbp)
je     17c6 <imcd_xor+0x6c6>
cmpl   $0x0,-0x3c(%rbp)
je     1753 <imcd_xor+0x653>
cmpq   $0x4,-0x50(%rbp)
jne    1753 <imcd_xor+0x653>
cmpq   $0x4,-0x20(%rbp)
jne    1753 <imcd_xor+0x653>
mov    -0x58(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x9c(%rbp)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    174e <imcd_xor+0x64e>
mov    -0x9c(%rbp),%eax
mov    -0xa8(%rbp),%rcx
mov    -0x68(%rbp),%rdx
xor    (%rcx,%rdx,4),%eax
mov    %eax,(%rcx,%rdx,4)
mov    %eax,-0x9c(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1712 <imcd_xor+0x612>
jmp    17c1 <imcd_xor+0x6c1>
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
mov    %ecx,-0x9c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    17bc <imcd_xor+0x6bc>
mov    -0x50(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
xor    -0x9c(%rbp),%ecx
mov    %ecx,-0x9c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    176d <imcd_xor+0x66d>
jmp    17c1 <imcd_xor+0x6c1>
jmp    1846 <imcd_xor+0x746>
mov    -0x58(%rbp),%rax
mov    (%rax),%ecx
mov    %ecx,-0x9c(%rbp)
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1841 <imcd_xor+0x741>
mov    -0x50(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    17e0 <imcd_xor+0x6e0>
jmp    1846 <imcd_xor+0x746>
jmp    1858 <imcd_xor+0x758>
movq   $0xfffffffffffffffb,-0x8(%rbp)
ff
jmp    1860 <imcd_xor+0x760>
mov    -0x48(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x58,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<imcd_xor>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
test   %rcx,%rcx
sete   %al
cmp    %rdi,%rcx
sete   %r11b
or     %al,%r11b
cmp    %r8,%rsi
mov    %r8,%r10
cmovl  %rsi,%r10
test   %r11b,%r11b
cmovne %rdi,%rcx
cmovne %rdx,%r9
cmovne %rsi,%r10
mov    $0xfffffffffffffffb,%rax
or     %rsi,%r8
js     1a25 <imcd_xor+0x925>
test   %r10,%r10
jle    1214 <imcd_xor+0x114>
mov    0x30(%rsp),%rbx
add    $0xffffffffffffffff,%rbx
cmp    $0x7,%rbx
ja     1a25 <imcd_xor+0x925>
mov    0x38(%rsp),%r8d
lea    0xe97(%rip),%rsi
movslq (%rsi,%rbx,4),%rbx
add    %rsi,%rbx
jmp    *%rbx
test   %r8d,%r8d
je     1424 <imcd_xor+0x324>
cmp    $0x4,%r9
sete   %al
cmp    $0x4,%rdx
jne    1508 <imcd_xor+0x408>
and    %al,%r11b
je     1508 <imcd_xor+0x408>
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
mov    (%rdi),%eax
lea    -0x1(%r10),%rsi
lea    -0x2(%r10),%rbx
mov    %esi,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rbx
jb     11f1 <imcd_xor+0xf1>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
xor    0x4(%rdi,%rdx,4),%eax
mov    %eax,0x4(%rdi,%rdx,4)
xor    0x8(%rdi,%rdx,4),%eax
mov    %eax,0x8(%rdi,%rdx,4)
xor    0xc(%rdi,%rdx,4),%eax
mov    %eax,0xc(%rdi,%rdx,4)
xor    0x10(%rdi,%rdx,4),%eax
mov    %eax,0x10(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    11c4 <imcd_xor+0xc4>
add    $0x1,%rdx
test   %rcx,%rcx
je     1a22 <imcd_xor+0x922>
lea    (%rdi,%rdx,4),%rdx
xor    %esi,%esi
xor    (%rdx,%rsi,4),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1200 <imcd_xor+0x100>
jmp    1a22 <imcd_xor+0x922>
xor    %eax,%eax
jmp    1a25 <imcd_xor+0x925>
test   %r8d,%r8d
je     145d <imcd_xor+0x35d>
cmp    $0x4,%r9
sete   %al
cmp    $0x4,%rdx
jne    1541 <imcd_xor+0x441>
and    %al,%r11b
je     1541 <imcd_xor+0x441>
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
mov    (%rdi),%eax
lea    -0x1(%r10),%rsi
lea    -0x2(%r10),%rbp
mov    %esi,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rbp
jb     129a <imcd_xor+0x19a>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
xor    0x4(%rdi,%rdx,4),%eax
mov    %eax,0x4(%rdi,%rdx,4)
xor    0x8(%rdi,%rdx,4),%eax
mov    %eax,0x8(%rdi,%rdx,4)
xor    0xc(%rdi,%rdx,4),%eax
mov    %eax,0xc(%rdi,%rdx,4)
xor    0x10(%rdi,%rdx,4),%eax
mov    %eax,0x10(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    126d <imcd_xor+0x16d>
add    $0x1,%rdx
test   %rcx,%rcx
je     1a22 <imcd_xor+0x922>
lea    (%rdi,%rdx,4),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
xor    (%rdx,%rsi,4),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    12b0 <imcd_xor+0x1b0>
jmp    1a22 <imcd_xor+0x922>
test   %r8d,%r8d
je     1496 <imcd_xor+0x396>
cmp    $0x4,%r9
sete   %al
cmp    $0x4,%rdx
jne    157a <imcd_xor+0x47a>
and    %al,%r11b
je     157a <imcd_xor+0x47a>
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
mov    (%rdi),%eax
lea    -0x1(%r10),%rsi
lea    -0x2(%r10),%rbp
mov    %esi,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rbp
jb     1343 <imcd_xor+0x243>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
xor    0x4(%rdi,%rdx,4),%eax
mov    %eax,0x4(%rdi,%rdx,4)
xor    0x8(%rdi,%rdx,4),%eax
mov    %eax,0x8(%rdi,%rdx,4)
xor    0xc(%rdi,%rdx,4),%eax
mov    %eax,0xc(%rdi,%rdx,4)
xor    0x10(%rdi,%rdx,4),%eax
mov    %eax,0x10(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1316 <imcd_xor+0x216>
add    $0x1,%rdx
test   %rcx,%rcx
je     1a22 <imcd_xor+0x922>
lea    (%rdi,%rdx,4),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    (%rdx,%rsi,4),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1360 <imcd_xor+0x260>
jmp    1a22 <imcd_xor+0x922>
test   %r8d,%r8d
je     14cf <imcd_xor+0x3cf>
cmp    $0x4,%r9
sete   %al
cmp    $0x4,%rdx
jne    15b3 <imcd_xor+0x4b3>
and    %al,%r11b
je     15b3 <imcd_xor+0x4b3>
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
mov    (%rdi),%eax
lea    -0x1(%r10),%rsi
lea    -0x2(%r10),%rbp
mov    %esi,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rbp
jb     13f3 <imcd_xor+0x2f3>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
xor    0x4(%rdi,%rdx,4),%eax
mov    %eax,0x4(%rdi,%rdx,4)
xor    0x8(%rdi,%rdx,4),%eax
mov    %eax,0x8(%rdi,%rdx,4)
xor    0xc(%rdi,%rdx,4),%eax
mov    %eax,0xc(%rdi,%rdx,4)
xor    0x10(%rdi,%rdx,4),%eax
mov    %eax,0x10(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    13c6 <imcd_xor+0x2c6>
add    $0x1,%rdx
test   %rcx,%rcx
je     1a22 <imcd_xor+0x922>
lea    (%rdi,%rdx,4),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    (%rdx,%rsi,4),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1410 <imcd_xor+0x310>
jmp    1a22 <imcd_xor+0x922>
mov    (%rdi),%r11d
mov    %r11d,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
lea    -0x1(%r10),%r12
lea    -0x2(%r10),%rax
mov    %r12d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    15ec <imcd_xor+0x4ec>
mov    %rdi,%rsi
mov    %rcx,%rax
jmp    164e <imcd_xor+0x54e>
mov    (%rdi),%r11d
mov    %r11d,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
lea    -0x1(%r10),%r12
lea    -0x2(%r10),%rax
mov    %r12d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    167c <imcd_xor+0x57c>
mov    %rdi,%rsi
mov    %rcx,%rax
jmp    16de <imcd_xor+0x5de>
mov    (%rdi),%r11d
mov    %r11d,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
lea    -0x1(%r10),%r12
lea    -0x2(%r10),%rax
mov    %r12d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    170c <imcd_xor+0x60c>
mov    %rdi,%rsi
mov    %rcx,%rax
jmp    176e <imcd_xor+0x66e>
mov    (%rdi),%r11d
mov    %r11d,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
lea    -0x1(%r10),%r12
lea    -0x2(%r10),%rax
mov    %r12d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    179c <imcd_xor+0x69c>
mov    %rdi,%rax
mov    %rcx,%rsi
jmp    17fe <imcd_xor+0x6fe>
mov    (%rdi),%r11d
mov    %r11d,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
lea    -0x1(%r10),%rbx
lea    -0x2(%r10),%rax
mov    %ebx,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    182c <imcd_xor+0x72c>
mov    %rdi,%rsi
mov    %rcx,%rax
jmp    187e <imcd_xor+0x77e>
mov    (%rdi),%r11d
mov    %r11d,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
lea    -0x1(%r10),%rbx
lea    -0x2(%r10),%rax
mov    %ebx,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    18a7 <imcd_xor+0x7a7>
mov    %rdi,%rsi
mov    %rcx,%rax
jmp    18f9 <imcd_xor+0x7f9>
mov    (%rdi),%r11d
mov    %r11d,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
lea    -0x1(%r10),%rbx
lea    -0x2(%r10),%rax
mov    %ebx,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1927 <imcd_xor+0x827>
mov    %rdi,%rsi
mov    %rcx,%rax
jmp    1979 <imcd_xor+0x879>
mov    (%rdi),%r11d
mov    %r11d,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a25 <imcd_xor+0x925>
lea    -0x1(%r10),%rbx
lea    -0x2(%r10),%rax
mov    %ebx,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    19a4 <imcd_xor+0x8a4>
mov    %rdi,%rax
mov    %rcx,%rsi
jmp    19f6 <imcd_xor+0x8f6>
and    $0xfffffffffffffffc,%r12
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%r9,1),%rax
lea    (%rdi,%rdx,1),%rsi
mov    (%rdi,%rdx,1),%ebp
xor    %ebp,%r11d
mov    %r11d,(%rcx,%r9,1)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%rdx,2),%ebx
xor    %ebx,%ebp
mov    %ebp,(%rcx,%r9,2)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%r14,1),%ebp
xor    %ebp,%ebx
mov    %ebx,(%rcx,%r15,1)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%rdx,4),%r11d
xor    %r11d,%ebp
mov    %ebp,(%rcx,%r9,4)
mov    %rsi,%rdi
mov    %rax,%rcx
add    $0xfffffffffffffffc,%r12
jne    1600 <imcd_xor+0x500>
test   %r8,%r8
je     1a22 <imcd_xor+0x922>
add    %rdx,%rsi
add    %r9,%rax
nopl   (%rax)
mov    (%rsi),%ecx
xor    %ecx,%r11d
mov    %r11d,(%rax)
add    %rdx,%rsi
add    %r9,%rax
mov    %ecx,%r11d
add    $0xffffffffffffffff,%r8
jne    1660 <imcd_xor+0x560>
jmp    1a22 <imcd_xor+0x922>
and    $0xfffffffffffffffc,%r12
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%r9,1),%rax
lea    (%rdi,%rdx,1),%rsi
mov    (%rdi,%rdx,1),%ebp
xor    %ebp,%r11d
mov    %r11d,(%rcx,%r9,1)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%rdx,2),%ebx
xor    %ebx,%ebp
mov    %ebp,(%rcx,%r9,2)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%r14,1),%ebp
xor    %ebp,%ebx
mov    %ebx,(%rcx,%r15,1)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%rdx,4),%r11d
xor    %r11d,%ebp
mov    %ebp,(%rcx,%r9,4)
mov    %rsi,%rdi
mov    %rax,%rcx
add    $0xfffffffffffffffc,%r12
jne    1690 <imcd_xor+0x590>
test   %r8,%r8
je     1a22 <imcd_xor+0x922>
add    %rdx,%rsi
add    %r9,%rax
nopl   (%rax)
mov    (%rsi),%ecx
xor    %ecx,%r11d
mov    %r11d,(%rax)
add    %rdx,%rsi
add    %r9,%rax
mov    %ecx,%r11d
add    $0xffffffffffffffff,%r8
jne    16f0 <imcd_xor+0x5f0>
jmp    1a22 <imcd_xor+0x922>
and    $0xfffffffffffffffc,%r12
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%r9,1),%rax
lea    (%rdi,%rdx,1),%rsi
mov    (%rdi,%rdx,1),%ebp
xor    %ebp,%r11d
mov    %r11d,(%rcx,%r9,1)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%rdx,2),%ebx
xor    %ebx,%ebp
mov    %ebp,(%rcx,%r9,2)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%r14,1),%ebp
xor    %ebp,%ebx
mov    %ebx,(%rcx,%r15,1)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%rdx,4),%r11d
xor    %r11d,%ebp
mov    %ebp,(%rcx,%r9,4)
mov    %rsi,%rdi
mov    %rax,%rcx
add    $0xfffffffffffffffc,%r12
jne    1720 <imcd_xor+0x620>
test   %r8,%r8
je     1a22 <imcd_xor+0x922>
add    %rdx,%rsi
add    %r9,%rax
nopl   (%rax)
mov    (%rsi),%ecx
xor    %ecx,%r11d
mov    %r11d,(%rax)
add    %rdx,%rsi
add    %r9,%rax
mov    %ecx,%r11d
add    $0xffffffffffffffff,%r8
jne    1780 <imcd_xor+0x680>
jmp    1a22 <imcd_xor+0x922>
and    $0xfffffffffffffffc,%r12
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%r9,1),%rsi
lea    (%rdi,%rdx,1),%rax
mov    (%rdi,%rdx,1),%ebp
xor    %ebp,%r11d
mov    %r11d,(%rcx,%r9,1)
add    %r9,%rsi
add    %rdx,%rax
mov    (%rdi,%rdx,2),%ebx
xor    %ebx,%ebp
mov    %ebp,(%rcx,%r9,2)
add    %r9,%rsi
add    %rdx,%rax
mov    (%rdi,%r14,1),%ebp
xor    %ebp,%ebx
mov    %ebx,(%rcx,%r15,1)
add    %r9,%rsi
add    %rdx,%rax
mov    (%rdi,%rdx,4),%r11d
xor    %r11d,%ebp
mov    %ebp,(%rcx,%r9,4)
mov    %rax,%rdi
mov    %rsi,%rcx
add    $0xfffffffffffffffc,%r12
jne    17b0 <imcd_xor+0x6b0>
test   %r8,%r8
je     1a22 <imcd_xor+0x922>
add    %rdx,%rax
add    %r9,%rsi
nopl   (%rax)
mov    (%rax),%ecx
xor    %ecx,%r11d
mov    %r11d,(%rsi)
add    %rdx,%rax
add    %r9,%rsi
mov    %ecx,%r11d
add    $0xffffffffffffffff,%r8
jne    1810 <imcd_xor+0x710>
jmp    1a22 <imcd_xor+0x922>
and    $0xfffffffffffffffc,%rbx
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
lea    (%rcx,%r9,1),%rax
lea    (%rdi,%rdx,1),%rsi
xor    (%rdi,%rdx,1),%r11d
mov    %r11d,(%rcx,%r9,1)
add    %r9,%rax
add    %rdx,%rsi
xor    (%rdi,%rdx,2),%r11d
mov    %r11d,(%rcx,%r9,2)
add    %r9,%rax
xor    (%rdi,%r14,1),%r11d
add    %rdx,%rsi
mov    %r11d,(%rcx,%r15,1)
add    %r9,%rax
add    %rdx,%rsi
xor    (%rdi,%rdx,4),%r11d
mov    %r11d,(%rcx,%r9,4)
mov    %rsi,%rdi
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rbx
jne    1838 <imcd_xor+0x738>
test   %r8,%r8
je     1a22 <imcd_xor+0x922>
add    %rdx,%rsi
add    %r9,%rax
nopl   (%rax)
xor    (%rsi),%r11d
mov    %r11d,(%rax)
add    %rdx,%rsi
add    %r9,%rax
add    $0xffffffffffffffff,%r8
jne    1890 <imcd_xor+0x790>
jmp    1a22 <imcd_xor+0x922>
and    $0xfffffffffffffffc,%rbx
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
lea    (%rcx,%r9,1),%rax
lea    (%rdi,%rdx,1),%rsi
xor    (%rdi,%rdx,1),%r11d
mov    %r11d,(%rcx,%r9,1)
add    %r9,%rax
add    %rdx,%rsi
xor    (%rdi,%rdx,2),%r11d
mov    %r11d,(%rcx,%r9,2)
add    %r9,%rax
xor    (%rdi,%r14,1),%r11d
add    %rdx,%rsi
mov    %r11d,(%rcx,%r15,1)
add    %r9,%rax
add    %rdx,%rsi
xor    (%rdi,%rdx,4),%r11d
mov    %r11d,(%rcx,%r9,4)
mov    %rsi,%rdi
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rbx
jne    18b3 <imcd_xor+0x7b3>
test   %r8,%r8
je     1a22 <imcd_xor+0x922>
add    %rdx,%rsi
add    %r9,%rax
nopl   0x0(%rax,%rax,1)
xor    (%rsi),%r11d
mov    %r11d,(%rax)
add    %rdx,%rsi
add    %r9,%rax
add    $0xffffffffffffffff,%r8
jne    1910 <imcd_xor+0x810>
jmp    1a22 <imcd_xor+0x922>
and    $0xfffffffffffffffc,%rbx
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
lea    (%rcx,%r9,1),%rax
lea    (%rdi,%rdx,1),%rsi
xor    (%rdi,%rdx,1),%r11d
mov    %r11d,(%rcx,%r9,1)
add    %r9,%rax
add    %rdx,%rsi
xor    (%rdi,%rdx,2),%r11d
mov    %r11d,(%rcx,%r9,2)
add    %r9,%rax
xor    (%rdi,%r14,1),%r11d
add    %rdx,%rsi
mov    %r11d,(%rcx,%r15,1)
add    %r9,%rax
add    %rdx,%rsi
xor    (%rdi,%rdx,4),%r11d
mov    %r11d,(%rcx,%r9,4)
mov    %rsi,%rdi
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rbx
jne    1933 <imcd_xor+0x833>
test   %r8,%r8
je     1a22 <imcd_xor+0x922>
add    %rdx,%rsi
add    %r9,%rax
nopl   0x0(%rax,%rax,1)
xor    (%rsi),%r11d
mov    %r11d,(%rax)
add    %rdx,%rsi
add    %r9,%rax
add    $0xffffffffffffffff,%r8
jne    1990 <imcd_xor+0x890>
jmp    1a22 <imcd_xor+0x922>
and    $0xfffffffffffffffc,%rbx
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
lea    (%rcx,%r9,1),%rsi
lea    (%rdi,%rdx,1),%rax
xor    (%rdi,%rdx,1),%r11d
mov    %r11d,(%rcx,%r9,1)
add    %r9,%rsi
add    %rdx,%rax
xor    (%rdi,%rdx,2),%r11d
mov    %r11d,(%rcx,%r9,2)
add    %r9,%rsi
xor    (%rdi,%r14,1),%r11d
add    %rdx,%rax
mov    %r11d,(%rcx,%r15,1)
add    %r9,%rsi
add    %rdx,%rax
xor    (%rdi,%rdx,4),%r11d
mov    %r11d,(%rcx,%r9,4)
mov    %rax,%rdi
mov    %rsi,%rcx
add    $0xfffffffffffffffc,%rbx
jne    19b0 <imcd_xor+0x8b0>
test   %r8,%r8
je     1a22 <imcd_xor+0x922>
add    %rdx,%rax
add    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    (%rax),%r11d
mov    %r11d,(%rsi)
add    %rdx,%rax
add    %r9,%rsi
add    $0xffffffffffffffff,%r8
jne    1a10 <imcd_xor+0x910>
mov    %r10,%rax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i64 @imcd_xor(i8* %0, i64 %1, i64 %2, i8* %3, i64 %4, i64 %5, i64 %6, i32 %7) {
%9 = alloca i64
%10 = alloca i8*
%11 = alloca i64
%12 = alloca i64
%13 = alloca i8*
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i32
%18 = alloca i32
%19 = alloca i64
%20 = alloca i64
%21 = alloca i8*
%22 = alloca i8*
%23 = alloca i64
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32*
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32*
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32*
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32*
store i8* %0, i8** %10
store i64 %1, i64* %11
store i64 %2, i64* %12
store i8* %3, i8** %13
store i64 %4, i64* %14
store i64 %5, i64* %15
store i64 %6, i64* %16
store i32 %7, i32* %17
%36 = load i8*, i8** %13
%37 = icmp eq i8* %36, null
br i1 %37, label %42, label %38
38: ; preds = %8
%39 = load i8*, i8** %13
%40 = load i8*, i8** %10
%41 = icmp eq i8* %39, %40
br label %42
42: ; preds = %38, %8
%43 = phi i1 [ true, %8 ], [ %41, %38 ]
%44 = zext i1 %43 to i32
store i32 %44, i32* %18
%45 = load i32, i32* %18
%46 = icmp ne i32 %45, 0
br i1 %46, label %47, label %49
47: ; preds = %42
%48 = load i64, i64* %11
br label %59
49: ; preds = %42
%50 = load i64, i64* %11
%51 = load i64, i64* %14
%52 = icmp slt i64 %50, %51
br i1 %52, label %53, label %55
53: ; preds = %49
%54 = load i64, i64* %11
br label %57
55: ; preds = %49
%56 = load i64, i64* %14
br label %57
57: ; preds = %55, %53
%58 = phi i64 [ %54, %53 ], [ %56, %55 ]
br label %59
59: ; preds = %57, %47
%60 = phi i64 [ %48, %47 ], [ %58, %57 ]
store i64 %60, i64* %19
%61 = load i32, i32* %18
%62 = icmp ne i32 %61, 0
br i1 %62, label %63, label %65
63: ; preds = %59
%64 = load i64, i64* %12
br label %67
65: ; preds = %59
%66 = load i64, i64* %15
br label %67
67: ; preds = %65, %63
%68 = phi i64 [ %64, %63 ], [ %66, %65 ]
store i64 %68, i64* %20
%69 = load i8*, i8** %10
store i8* %69, i8** %21
%70 = load i32, i32* %18
%71 = icmp ne i32 %70, 0
br i1 %71, label %72, label %74
72: ; preds = %67
%73 = load i8*, i8** %10
br label %76
74: ; preds = %67
%75 = load i8*, i8** %13
br label %76
76: ; preds = %74, %72
%77 = phi i8* [ %73, %72 ], [ %75, %74 ]
store i8* %77, i8** %22
%78 = load i64, i64* %11
%79 = icmp slt i64 %78, 0
br i1 %79, label %83, label %80
80: ; preds = %76
%81 = load i64, i64* %14
%82 = icmp slt i64 %81, 0
br i1 %82, label %83, label %84
83: ; preds = %80, %76
store i64 -5, i64* %9
br label %465
84: ; preds = %80
%85 = load i64, i64* %19
%86 = icmp sle i64 %85, 0
br i1 %86, label %87, label %88
87: ; preds = %84
store i64 0, i64* %9
br label %465
88: ; preds = %84
%89 = load i64, i64* %16
switch i64 %89, label %462 [
i64 1, label %90
i64 2, label %183
i64 4, label %276
i64 8, label %369
]
90: ; preds = %88
%91 = load i32, i32* %17
%92 = icmp ne i32 %91, 0
br i1 %92, label %93, label %152
93: ; preds = %90
%94 = load i32, i32* %18
%95 = icmp ne i32 %94, 0
br i1 %95, label %96, label %123
96: ; preds = %93
%97 = load i64, i64* %20
%98 = icmp eq i64 %97, 4
br i1 %98, label %99, label %123
99: ; preds = %96
%100 = load i64, i64* %12
%101 = icmp eq i64 %100, 4
br i1 %101, label %102, label %123
102: ; preds = %99
%103 = load i8*, i8** %21
%104 = bitcast i8* %103 to i32*
store i32* %104, i32** %26
%105 = load i32*, i32** %26
%106 = getelementptr inbounds i32, i32* %105, i64 0
%107 = load i32, i32* %106
store i32 %107, i32* %24
store i64 1, i64* %23
br label %108
108: ; preds = %119, %102
%109 = load i64, i64* %23
%110 = load i64, i64* %19
%111 = icmp slt i64 %109, %110
br i1 %111, label %112, label %122
112: ; preds = %108
%113 = load i32, i32* %24
%114 = load i32*, i32** %26
%115 = load i64, i64* %23
%116 = getelementptr inbounds i32, i32* %114, i64 %115
%117 = load i32, i32* %116
%118 = xor i32 %117, %113
store i32 %118, i32* %116
store i32 %118, i32* %24
br label %119
119: ; preds = %112
%120 = load i64, i64* %23
%121 = add nsw i64 %120, 1
store i64 %121, i64* %23
br label %108
122: ; preds = %108
br label %151
123: ; preds = %99, %96, %93
%124 = load i8*, i8** %21
%125 = bitcast i8* %124 to i32*
%126 = load i32, i32* %125
store i32 %126, i32* %24
%127 = load i8*, i8** %22
%128 = bitcast i8* %127 to i32*
store i32 %126, i32* %128
store i64 1, i64* %23
br label %129
129: ; preds = %147, %123
%130 = load i64, i64* %23
%131 = load i64, i64* %19
%132 = icmp slt i64 %130, %131
br i1 %132, label %133, label %150
133: ; preds = %129
%134 = load i64, i64* %20
%135 = load i8*, i8** %22
%136 = getelementptr inbounds i8, i8* %135, i64 %134
store i8* %136, i8** %22
%137 = load i64, i64* %12
%138 = load i8*, i8** %21
%139 = getelementptr inbounds i8, i8* %138, i64 %137
store i8* %139, i8** %21
%140 = load i8*, i8** %21
%141 = bitcast i8* %140 to i32*
%142 = load i32, i32* %141
%143 = load i32, i32* %24
%144 = xor i32 %142, %143
store i32 %144, i32* %24
%145 = load i8*, i8** %22
%146 = bitcast i8* %145 to i32*
store i32 %144, i32* %146
br label %147
147: ; preds = %133
%148 = load i64, i64* %23
%149 = add nsw i64 %148, 1
store i64 %149, i64* %23
br label %129
150: ; preds = %129
br label %151
151: ; preds = %150, %122
br label %182
152: ; preds = %90
%153 = load i8*, i8** %21
%154 = bitcast i8* %153 to i32*
%155 = load i32, i32* %154
store i32 %155, i32* %24
%156 = load i8*, i8** %22
%157 = bitcast i8* %156 to i32*
store i32 %155, i32* %157
store i64 1, i64* %23
br label %158
158: ; preds = %178, %152
%159 = load i64, i64* %23
%160 = load i64, i64* %19
%161 = icmp slt i64 %159, %160
br i1 %161, label %162, label %181
162: ; preds = %158
%163 = load i64, i64* %20
%164 = load i8*, i8** %22
%165 = getelementptr inbounds i8, i8* %164, i64 %163
store i8* %165, i8** %22
%166 = load i64, i64* %12
%167 = load i8*, i8** %21
%168 = getelementptr inbounds i8, i8* %167, i64 %166
store i8* %168, i8** %21
%169 = load i8*, i8** %21
%170 = bitcast i8* %169 to i32*
%171 = load i32, i32* %170
store i32 %171, i32* %25
%172 = load i32, i32* %25
%173 = load i32, i32* %24
%174 = xor i32 %172, %173
%175 = load i8*, i8** %22
%176 = bitcast i8* %175 to i32*
store i32 %174, i32* %176
%177 = load i32, i32* %25
store i32 %177, i32* %24
br label %178
178: ; preds = %162
%179 = load i64, i64* %23
%180 = add nsw i64 %179, 1
store i64 %180, i64* %23
br label %158
181: ; preds = %158
br label %182
182: ; preds = %181, %151
br label %463
183: ; preds = %88
%184 = load i32, i32* %17
%185 = icmp ne i32 %184, 0
br i1 %185, label %186, label %245
186: ; preds = %183
%187 = load i32, i32* %18
%188 = icmp ne i32 %187, 0
br i1 %188, label %189, label %216
189: ; preds = %186
%190 = load i64, i64* %20
%191 = icmp eq i64 %190, 4
br i1 %191, label %192, label %216
192: ; preds = %189
%193 = load i64, i64* %12
%194 = icmp eq i64 %193, 4
br i1 %194, label %195, label %216
195: ; preds = %192
%196 = load i8*, i8** %21
%197 = bitcast i8* %196 to i32*
store i32* %197, i32** %29
%198 = load i32*, i32** %29
%199 = getelementptr inbounds i32, i32* %198, i64 0
%200 = load i32, i32* %199
store i32 %200, i32* %27
store i64 1, i64* %23
br label %201
201: ; preds = %212, %195
%202 = load i64, i64* %23
%203 = load i64, i64* %19
%204 = icmp slt i64 %202, %203
br i1 %204, label %205, label %215
205: ; preds = %201
%206 = load i32, i32* %27
%207 = load i32*, i32** %29
%208 = load i64, i64* %23
%209 = getelementptr inbounds i32, i32* %207, i64 %208
%210 = load i32, i32* %209
%211 = xor i32 %210, %206
store i32 %211, i32* %209
store i32 %211, i32* %27
br label %212
212: ; preds = %205
%213 = load i64, i64* %23
%214 = add nsw i64 %213, 1
store i64 %214, i64* %23
br label %201
215: ; preds = %201
br label %244
216: ; preds = %192, %189, %186
%217 = load i8*, i8** %21
%218 = bitcast i8* %217 to i32*
%219 = load i32, i32* %218
store i32 %219, i32* %27
%220 = load i8*, i8** %22
%221 = bitcast i8* %220 to i32*
store i32 %219, i32* %221
store i64 1, i64* %23
br label %222
222: ; preds = %240, %216
%223 = load i64, i64* %23
%224 = load i64, i64* %19
%225 = icmp slt i64 %223, %224
br i1 %225, label %226, label %243
226: ; preds = %222
%227 = load i64, i64* %20
%228 = load i8*, i8** %22
%229 = getelementptr inbounds i8, i8* %228, i64 %227
store i8* %229, i8** %22
%230 = load i64, i64* %12
%231 = load i8*, i8** %21
%232 = getelementptr inbounds i8, i8* %231, i64 %230
store i8* %232, i8** %21
%233 = load i8*, i8** %21
%234 = bitcast i8* %233 to i32*
%235 = load i32, i32* %234
%236 = load i32, i32* %27
%237 = xor i32 %235, %236
store i32 %237, i32* %27
%238 = load i8*, i8** %22
%239 = bitcast i8* %238 to i32*
store i32 %237, i32* %239
br label %240
240: ; preds = %226
%241 = load i64, i64* %23
%242 = add nsw i64 %241, 1
store i64 %242, i64* %23
br label %222
243: ; preds = %222
br label %244
244: ; preds = %243, %215
br label %275
245: ; preds = %183
%246 = load i8*, i8** %21
%247 = bitcast i8* %246 to i32*
%248 = load i32, i32* %247
store i32 %248, i32* %27
%249 = load i8*, i8** %22
%250 = bitcast i8* %249 to i32*
store i32 %248, i32* %250
store i64 1, i64* %23
br label %251
251: ; preds = %271, %245
%252 = load i64, i64* %23
%253 = load i64, i64* %19
%254 = icmp slt i64 %252, %253
br i1 %254, label %255, label %274
255: ; preds = %251
%256 = load i64, i64* %20
%257 = load i8*, i8** %22
%258 = getelementptr inbounds i8, i8* %257, i64 %256
store i8* %258, i8** %22
%259 = load i64, i64* %12
%260 = load i8*, i8** %21
%261 = getelementptr inbounds i8, i8* %260, i64 %259
store i8* %261, i8** %21
%262 = load i8*, i8** %21
%263 = bitcast i8* %262 to i32*
%264 = load i32, i32* %263
store i32 %264, i32* %28
%265 = load i32, i32* %28
%266 = load i32, i32* %27
%267 = xor i32 %265, %266
%268 = load i8*, i8** %22
%269 = bitcast i8* %268 to i32*
store i32 %267, i32* %269
%270 = load i32, i32* %28
store i32 %270, i32* %27
br label %271
271: ; preds = %255
%272 = load i64, i64* %23
%273 = add nsw i64 %272, 1
store i64 %273, i64* %23
br label %251
274: ; preds = %251
br label %275
275: ; preds = %274, %244
br label %463
276: ; preds = %88
%277 = load i32, i32* %17
%278 = icmp ne i32 %277, 0
br i1 %278, label %279, label %338
279: ; preds = %276
%280 = load i32, i32* %18
%281 = icmp ne i32 %280, 0
br i1 %281, label %282, label %309
282: ; preds = %279
%283 = load i64, i64* %20
%284 = icmp eq i64 %283, 4
br i1 %284, label %285, label %309
285: ; preds = %282
%286 = load i64, i64* %12
%287 = icmp eq i64 %286, 4
br i1 %287, label %288, label %309
288: ; preds = %285
%289 = load i8*, i8** %21
%290 = bitcast i8* %289 to i32*
store i32* %290, i32** %32
%291 = load i32*, i32** %32
%292 = getelementptr inbounds i32, i32* %291, i64 0
%293 = load i32, i32* %292
store i32 %293, i32* %30
store i64 1, i64* %23
br label %294
294: ; preds = %305, %288
%295 = load i64, i64* %23
%296 = load i64, i64* %19
%297 = icmp slt i64 %295, %296
br i1 %297, label %298, label %308
298: ; preds = %294
%299 = load i32, i32* %30
%300 = load i32*, i32** %32
%301 = load i64, i64* %23
%302 = getelementptr inbounds i32, i32* %300, i64 %301
%303 = load i32, i32* %302
%304 = xor i32 %303, %299
store i32 %304, i32* %302
store i32 %304, i32* %30
br label %305
305: ; preds = %298
%306 = load i64, i64* %23
%307 = add nsw i64 %306, 1
store i64 %307, i64* %23
br label %294
308: ; preds = %294
br label %337
309: ; preds = %285, %282, %279
%310 = load i8*, i8** %21
%311 = bitcast i8* %310 to i32*
%312 = load i32, i32* %311
store i32 %312, i32* %30
%313 = load i8*, i8** %22
%314 = bitcast i8* %313 to i32*
store i32 %312, i32* %314
store i64 1, i64* %23
br label %315
315: ; preds = %333, %309
%316 = load i64, i64* %23
%317 = load i64, i64* %19
%318 = icmp slt i64 %316, %317
br i1 %318, label %319, label %336
319: ; preds = %315
%320 = load i64, i64* %20
%321 = load i8*, i8** %22
%322 = getelementptr inbounds i8, i8* %321, i64 %320
store i8* %322, i8** %22
%323 = load i64, i64* %12
%324 = load i8*, i8** %21
%325 = getelementptr inbounds i8, i8* %324, i64 %323
store i8* %325, i8** %21
%326 = load i8*, i8** %21
%327 = bitcast i8* %326 to i32*
%328 = load i32, i32* %327
%329 = load i32, i32* %30
%330 = xor i32 %328, %329
store i32 %330, i32* %30
%331 = load i8*, i8** %22
%332 = bitcast i8* %331 to i32*
store i32 %330, i32* %332
br label %333
333: ; preds = %319
%334 = load i64, i64* %23
%335 = add nsw i64 %334, 1
store i64 %335, i64* %23
br label %315
336: ; preds = %315
br label %337
337: ; preds = %336, %308
br label %368
338: ; preds = %276
%339 = load i8*, i8** %21
%340 = bitcast i8* %339 to i32*
%341 = load i32, i32* %340
store i32 %341, i32* %30
%342 = load i8*, i8** %22
%343 = bitcast i8* %342 to i32*
store i32 %341, i32* %343
store i64 1, i64* %23
br label %344
344: ; preds = %364, %338
%345 = load i64, i64* %23
%346 = load i64, i64* %19
%347 = icmp slt i64 %345, %346
br i1 %347, label %348, label %367
348: ; preds = %344
%349 = load i64, i64* %20
%350 = load i8*, i8** %22
%351 = getelementptr inbounds i8, i8* %350, i64 %349
store i8* %351, i8** %22
%352 = load i64, i64* %12
%353 = load i8*, i8** %21
%354 = getelementptr inbounds i8, i8* %353, i64 %352
store i8* %354, i8** %21
%355 = load i8*, i8** %21
%356 = bitcast i8* %355 to i32*
%357 = load i32, i32* %356
store i32 %357, i32* %31
%358 = load i32, i32* %31
%359 = load i32, i32* %30
%360 = xor i32 %358, %359
%361 = load i8*, i8** %22
%362 = bitcast i8* %361 to i32*
store i32 %360, i32* %362
%363 = load i32, i32* %31
store i32 %363, i32* %30
br label %364
364: ; preds = %348
%365 = load i64, i64* %23
%366 = add nsw i64 %365, 1
store i64 %366, i64* %23
br label %344
367: ; preds = %344
br label %368
368: ; preds = %367, %337
br label %463
369: ; preds = %88
%370 = load i32, i32* %17
%371 = icmp ne i32 %370, 0
br i1 %371, label %372, label %431
372: ; preds = %369
%373 = load i32, i32* %18
%374 = icmp ne i32 %373, 0
br i1 %374, label %375, label %402
375: ; preds = %372
%376 = load i64, i64* %20
%377 = icmp eq i64 %376, 4
br i1 %377, label %378, label %402
378: ; preds = %375
%379 = load i64, i64* %12
%380 = icmp eq i64 %379, 4
br i1 %380, label %381, label %402
381: ; preds = %378
%382 = load i8*, i8** %21
%383 = bitcast i8* %382 to i32*
store i32* %383, i32** %35
%384 = load i32*, i32** %35
%385 = getelementptr inbounds i32, i32* %384, i64 0
%386 = load i32, i32* %385
store i32 %386, i32* %33
store i64 1, i64* %23
br label %387
387: ; preds = %398, %381
%388 = load i64, i64* %23
%389 = load i64, i64* %19
%390 = icmp slt i64 %388, %389
br i1 %390, label %391, label %401
391: ; preds = %387
%392 = load i32, i32* %33
%393 = load i32*, i32** %35
%394 = load i64, i64* %23
%395 = getelementptr inbounds i32, i32* %393, i64 %394
%396 = load i32, i32* %395
%397 = xor i32 %396, %392
store i32 %397, i32* %395
store i32 %397, i32* %33
br label %398
398: ; preds = %391
%399 = load i64, i64* %23
%400 = add nsw i64 %399, 1
store i64 %400, i64* %23
br label %387
401: ; preds = %387
br label %430
402: ; preds = %378, %375, %372
%403 = load i8*, i8** %21
%404 = bitcast i8* %403 to i32*
%405 = load i32, i32* %404
store i32 %405, i32* %33
%406 = load i8*, i8** %22
%407 = bitcast i8* %406 to i32*
store i32 %405, i32* %407
store i64 1, i64* %23
br label %408
408: ; preds = %426, %402
%409 = load i64, i64* %23
%410 = load i64, i64* %19
%411 = icmp slt i64 %409, %410
br i1 %411, label %412, label %429
412: ; preds = %408
%413 = load i64, i64* %20
%414 = load i8*, i8** %22
%415 = getelementptr inbounds i8, i8* %414, i64 %413
store i8* %415, i8** %22
%416 = load i64, i64* %12
%417 = load i8*, i8** %21
%418 = getelementptr inbounds i8, i8* %417, i64 %416
store i8* %418, i8** %21
%419 = load i8*, i8** %21
%420 = bitcast i8* %419 to i32*
%421 = load i32, i32* %420
%422 = load i32, i32* %33
%423 = xor i32 %421, %422
store i32 %423, i32* %33
%424 = load i8*, i8** %22
%425 = bitcast i8* %424 to i32*
store i32 %423, i32* %425
br label %426
426: ; preds = %412
%427 = load i64, i64* %23
%428 = add nsw i64 %427, 1
store i64 %428, i64* %23
br label %408
429: ; preds = %408
br label %430
430: ; preds = %429, %401
br label %461
431: ; preds = %369
%432 = load i8*, i8** %21
%433 = bitcast i8* %432 to i32*
%434 = load i32, i32* %433
store i32 %434, i32* %33
%435 = load i8*, i8** %22
%436 = bitcast i8* %435 to i32*
store i32 %434, i32* %436
store i64 1, i64* %23
br label %437
437: ; preds = %457, %431
%438 = load i64, i64* %23
%439 = load i64, i64* %19
%440 = icmp slt i64 %438, %439
br i1 %440, label %441, label %460
441: ; preds = %437
%442 = load i64, i64* %20
%443 = load i8*, i8** %22
%444 = getelementptr inbounds i8, i8* %443, i64 %442
store i8* %444, i8** %22
%445 = load i64, i64* %12
%446 = load i8*, i8** %21
%447 = getelementptr inbounds i8, i8* %446, i64 %445
store i8* %447, i8** %21
%448 = load i8*, i8** %21
%449 = bitcast i8* %448 to i32*
%450 = load i32, i32* %449
store i32 %450, i32* %34
%451 = load i32, i32* %34
%452 = load i32, i32* %33
%453 = xor i32 %451, %452
%454 = load i8*, i8** %22
%455 = bitcast i8* %454 to i32*
store i32 %453, i32* %455
%456 = load i32, i32* %34
store i32 %456, i32* %33
br label %457
457: ; preds = %441
%458 = load i64, i64* %23
%459 = add nsw i64 %458, 1
store i64 %459, i64* %23
br label %437
460: ; preds = %437
br label %461
461: ; preds = %460, %430
br label %463
462: ; preds = %88
store i64 -5, i64* %9
br label %465
463: ; preds = %461, %368, %275, %182
%464 = load i64, i64* %19
store i64 %464, i64* %9
br label %465
465: ; preds = %463, %462, %87, %83
%466 = load i64, i64* %9
ret i64 %466
}

LLVM IR (-O2):
define i64 @imcd_xor(i8* %0, i64 %1, i64 %2, i8* writeonly %3, i64 %4, i64 %5, i64 %6, i32 %7) {
%9 = icmp eq i8* %3, null
%10 = icmp eq i8* %3, %0
%11 = or i1 %9, %10
%12 = icmp slt i64 %1, %4
%13 = select i1 %11, i8* %0, i8* %3
%14 = select i1 %11, i64 %2, i64 %5
%15 = or i1 %11, %12
%16 = select i1 %15, i64 %1, i64 %4
%17 = or i64 %4, %1
%18 = icmp sgt i64 %17, -1
br i1 %18, label %19, label %722
19: ; preds = %8
%20 = icmp slt i64 %16, 1
br i1 %20, label %722, label %21
21: ; preds = %19
switch i64 %6, label %722 [
i64 1, label %22
i64 2, label %147
i64 4, label %272
i64 8, label %397
]
22: ; preds = %21
%23 = icmp eq i32 %7, 0
br i1 %23, label %104, label %24
24: ; preds = %22
%25 = icmp eq i64 %14, 4
%26 = and i1 %11, %25
%27 = icmp eq i64 %2, 4
%28 = and i1 %27, %26
%29 = bitcast i8* %0 to i32*
br i1 %28, label %30, label %62
30: ; preds = %24
%31 = icmp ugt i64 %16, 1
br i1 %31, label %32, label %722
32: ; preds = %30
%33 = load i32, i32* %29
%34 = add i64 %16, -1
%35 = add i64 %16, -2
%36 = and i64 %34, 3
%37 = icmp ult i64 %35, 3
br i1 %37, label %540, label %38
38: ; preds = %32
%39 = and i64 %34, -4
br label %40
40: ; preds = %40, %38
%41 = phi i64 [ 1, %38 ], [ %59, %40 ]
%42 = phi i32 [ %33, %38 ], [ %58, %40 ]
%43 = phi i64 [ 0, %38 ], [ %60, %40 ]
%44 = getelementptr inbounds i32, i32* %29, i64 %41
%45 = load i32, i32* %44
%46 = xor i32 %45, %42
store i32 %46, i32* %44
%47 = add nuw nsw i64 %41, 1
%48 = getelementptr inbounds i32, i32* %29, i64 %47
%49 = load i32, i32* %48
%50 = xor i32 %49, %46
store i32 %50, i32* %48
%51 = add nuw nsw i64 %41, 2
%52 = getelementptr inbounds i32, i32* %29, i64 %51
%53 = load i32, i32* %52
%54 = xor i32 %53, %50
store i32 %54, i32* %52
%55 = add nuw nsw i64 %41, 3
%56 = getelementptr inbounds i32, i32* %29, i64 %55
%57 = load i32, i32* %56
%58 = xor i32 %57, %54
store i32 %58, i32* %56
%59 = add nuw nsw i64 %41, 4
%60 = add i64 %43, 4
%61 = icmp eq i64 %60, %39
br i1 %61, label %540, label %40
62: ; preds = %24
%63 = load i32, i32* %29
%64 = bitcast i8* %13 to i32*
store i32 %63, i32* %64
%65 = icmp ugt i64 %16, 1
br i1 %65, label %66, label %722
66: ; preds = %62
%67 = add i64 %16, -1
%68 = add i64 %16, -2
%69 = and i64 %67, 3
%70 = icmp ult i64 %68, 3
br i1 %70, label %554, label %71
71: ; preds = %66
%72 = and i64 %67, -4
br label %73
73: ; preds = %73, %71
%74 = phi i8* [ %0, %71 ], [ %97, %73 ]
%75 = phi i8* [ %13, %71 ], [ %96, %73 ]
%76 = phi i32 [ %63, %71 ], [ %100, %73 ]
%77 = phi i64 [ 0, %71 ], [ %102, %73 ]
%78 = getelementptr inbounds i8, i8* %75, i64 %14
%79 = getelementptr inbounds i8, i8* %74, i64 %2
%80 = bitcast i8* %79 to i32*
%81 = load i32, i32* %80
%82 = xor i32 %81, %76
%83 = bitcast i8* %78 to i32*
store i32 %82, i32* %83
%84 = getelementptr inbounds i8, i8* %78, i64 %14
%85 = getelementptr inbounds i8, i8* %79, i64 %2
%86 = bitcast i8* %85 to i32*
%87 = load i32, i32* %86
%88 = xor i32 %87, %82
%89 = bitcast i8* %84 to i32*
store i32 %88, i32* %89
%90 = getelementptr inbounds i8, i8* %84, i64 %14
%91 = getelementptr inbounds i8, i8* %85, i64 %2
%92 = bitcast i8* %91 to i32*
%93 = load i32, i32* %92
%94 = xor i32 %93, %88
%95 = bitcast i8* %90 to i32*
store i32 %94, i32* %95
%96 = getelementptr inbounds i8, i8* %90, i64 %14
%97 = getelementptr inbounds i8, i8* %91, i64 %2
%98 = bitcast i8* %97 to i32*
%99 = load i32, i32* %98
%100 = xor i32 %99, %94
%101 = bitcast i8* %96 to i32*
store i32 %100, i32* %101
%102 = add i64 %77, 4
%103 = icmp eq i64 %102, %72
br i1 %103, label %554, label %73
104: ; preds = %22
%105 = bitcast i8* %0 to i32*
%106 = load i32, i32* %105
%107 = bitcast i8* %13 to i32*
store i32 %106, i32* %107
%108 = icmp ugt i64 %16, 1
br i1 %108, label %109, label %722
109: ; preds = %104
%110 = add i64 %16, -1
%111 = add i64 %16, -2
%112 = and i64 %110, 3
%113 = icmp ult i64 %111, 3
br i1 %113, label %522, label %114
114: ; preds = %109
%115 = and i64 %110, -4
br label %116
116: ; preds = %116, %114
%117 = phi i8* [ %0, %114 ], [ %140, %116 ]
%118 = phi i8* [ %13, %114 ], [ %139, %116 ]
%119 = phi i32 [ %106, %114 ], [ %142, %116 ]
%120 = phi i64 [ 0, %114 ], [ %145, %116 ]
%121 = getelementptr inbounds i8, i8* %118, i64 %14
%122 = getelementptr inbounds i8, i8* %117, i64 %2
%123 = bitcast i8* %122 to i32*
%124 = load i32, i32* %123
%125 = xor i32 %124, %119
%126 = bitcast i8* %121 to i32*
store i32 %125, i32* %126
%127 = getelementptr inbounds i8, i8* %121, i64 %14
%128 = getelementptr inbounds i8, i8* %122, i64 %2
%129 = bitcast i8* %128 to i32*
%130 = load i32, i32* %129
%131 = xor i32 %130, %124
%132 = bitcast i8* %127 to i32*
store i32 %131, i32* %132
%133 = getelementptr inbounds i8, i8* %127, i64 %14
%134 = getelementptr inbounds i8, i8* %128, i64 %2
%135 = bitcast i8* %134 to i32*
%136 = load i32, i32* %135
%137 = xor i32 %136, %130
%138 = bitcast i8* %133 to i32*
store i32 %137, i32* %138
%139 = getelementptr inbounds i8, i8* %133, i64 %14
%140 = getelementptr inbounds i8, i8* %134, i64 %2
%141 = bitcast i8* %140 to i32*
%142 = load i32, i32* %141
%143 = xor i32 %142, %136
%144 = bitcast i8* %139 to i32*
store i32 %143, i32* %144
%145 = add i64 %120, 4
%146 = icmp eq i64 %145, %115
br i1 %146, label %522, label %116
147: ; preds = %21
%148 = icmp eq i32 %7, 0
br i1 %148, label %229, label %149
149: ; preds = %147
%150 = icmp eq i64 %14, 4
%151 = and i1 %11, %150
%152 = icmp eq i64 %2, 4
%153 = and i1 %152, %151
%154 = bitcast i8* %0 to i32*
br i1 %153, label %155, label %187
155: ; preds = %149
%156 = icmp ugt i64 %16, 1
br i1 %156, label %157, label %722
157: ; preds = %155
%158 = load i32, i32* %154
%159 = add i64 %16, -1
%160 = add i64 %16, -2
%161 = and i64 %159, 3
%162 = icmp ult i64 %160, 3
br i1 %162, label %590, label %163
163: ; preds = %157
%164 = and i64 %159, -4
br label %165
165: ; preds = %165, %163
%166 = phi i64 [ 1, %163 ], [ %184, %165 ]
%167 = phi i32 [ %158, %163 ], [ %183, %165 ]
%168 = phi i64 [ 0, %163 ], [ %185, %165 ]
%169 = getelementptr inbounds i32, i32* %154, i64 %166
%170 = load i32, i32* %169
%171 = xor i32 %170, %167
store i32 %171, i32* %169
%172 = add nuw nsw i64 %166, 1
%173 = getelementptr inbounds i32, i32* %154, i64 %172
%174 = load i32, i32* %173
%175 = xor i32 %174, %171
store i32 %175, i32* %173
%176 = add nuw nsw i64 %166, 2
%177 = getelementptr inbounds i32, i32* %154, i64 %176
%178 = load i32, i32* %177
%179 = xor i32 %178, %175
store i32 %179, i32* %177
%180 = add nuw nsw i64 %166, 3
%181 = getelementptr inbounds i32, i32* %154, i64 %180
%182 = load i32, i32* %181
%183 = xor i32 %182, %179
store i32 %183, i32* %181
%184 = add nuw nsw i64 %166, 4
%185 = add i64 %168, 4
%186 = icmp eq i64 %185, %164
br i1 %186, label %590, label %165
187: ; preds = %149
%188 = load i32, i32* %154
%189 = bitcast i8* %13 to i32*
store i32 %188, i32* %189
%190 = icmp ugt i64 %16, 1
br i1 %190, label %191, label %722
191: ; preds = %187
%192 = add i64 %16, -1
%193 = add i64 %16, -2
%194 = and i64 %192, 3
%195 = icmp ult i64 %193, 3
br i1 %195, label %604, label %196
196: ; preds = %191
%197 = and i64 %192, -4
br label %198
198: ; preds = %198, %196
%199 = phi i8* [ %0, %196 ], [ %222, %198 ]
%200 = phi i8* [ %13, %196 ], [ %221, %198 ]
%201 = phi i32 [ %188, %196 ], [ %225, %198 ]
%202 = phi i64 [ 0, %196 ], [ %227, %198 ]
%203 = getelementptr inbounds i8, i8* %200, i64 %14
%204 = getelementptr inbounds i8, i8* %199, i64 %2
%205 = bitcast i8* %204 to i32*
%206 = load i32, i32* %205
%207 = xor i32 %206, %201
%208 = bitcast i8* %203 to i32*
store i32 %207, i32* %208
%209 = getelementptr inbounds i8, i8* %203, i64 %14
%210 = getelementptr inbounds i8, i8* %204, i64 %2
%211 = bitcast i8* %210 to i32*
%212 = load i32, i32* %211
%213 = xor i32 %212, %207
%214 = bitcast i8* %209 to i32*
store i32 %213, i32* %214
%215 = getelementptr inbounds i8, i8* %209, i64 %14
%216 = getelementptr inbounds i8, i8* %210, i64 %2
%217 = bitcast i8* %216 to i32*
%218 = load i32, i32* %217
%219 = xor i32 %218, %213
%220 = bitcast i8* %215 to i32*
store i32 %219, i32* %220
%221 = getelementptr inbounds i8, i8* %215, i64 %14
%222 = getelementptr inbounds i8, i8* %216, i64 %2
%223 = bitcast i8* %222 to i32*
%224 = load i32, i32* %223
%225 = xor i32 %224, %219
%226 = bitcast i8* %221 to i32*
store i32 %225, i32* %226
%227 = add i64 %202, 4
%228 = icmp eq i64 %227, %197
br i1 %228, label %604, label %198
229: ; preds = %147
%230 = bitcast i8* %0 to i32*
%231 = load i32, i32* %230
%232 = bitcast i8* %13 to i32*
store i32 %231, i32* %232
%233 = icmp ugt i64 %16, 1
br i1 %233, label %234, label %722
234: ; preds = %229
%235 = add i64 %16, -1
%236 = add i64 %16, -2
%237 = and i64 %235, 3
%238 = icmp ult i64 %236, 3
br i1 %238, label %572, label %239
239: ; preds = %234
%240 = and i64 %235, -4
br label %241
241: ; preds = %241, %239
%242 = phi i8* [ %0, %239 ], [ %265, %241 ]
%243 = phi i8* [ %13, %239 ], [ %264, %241 ]
%244 = phi i32 [ %231, %239 ], [ %267, %241 ]
%245 = phi i64 [ 0, %239 ], [ %270, %241 ]
%246 = getelementptr inbounds i8, i8* %243, i64 %14
%247 = getelementptr inbounds i8, i8* %242, i64 %2
%248 = bitcast i8* %247 to i32*
%249 = load i32, i32* %248
%250 = xor i32 %249, %244
%251 = bitcast i8* %246 to i32*
store i32 %250, i32* %251
%252 = getelementptr inbounds i8, i8* %246, i64 %14
%253 = getelementptr inbounds i8, i8* %247, i64 %2
%254 = bitcast i8* %253 to i32*
%255 = load i32, i32* %254
%256 = xor i32 %255, %249
%257 = bitcast i8* %252 to i32*
store i32 %256, i32* %257
%258 = getelementptr inbounds i8, i8* %252, i64 %14
%259 = getelementptr inbounds i8, i8* %253, i64 %2
%260 = bitcast i8* %259 to i32*
%261 = load i32, i32* %260
%262 = xor i32 %261, %255
%263 = bitcast i8* %258 to i32*
store i32 %262, i32* %263
%264 = getelementptr inbounds i8, i8* %258, i64 %14
%265 = getelementptr inbounds i8, i8* %259, i64 %2
%266 = bitcast i8* %265 to i32*
%267 = load i32, i32* %266
%268 = xor i32 %267, %261
%269 = bitcast i8* %264 to i32*
store i32 %268, i32* %269
%270 = add i64 %245, 4
%271 = icmp eq i64 %270, %240
br i1 %271, label %572, label %241
272: ; preds = %21
%273 = icmp eq i32 %7, 0
br i1 %273, label %354, label %274
274: ; preds = %272
%275 = icmp eq i64 %14, 4
%276 = and i1 %11, %275
%277 = icmp eq i64 %2, 4
%278 = and i1 %277, %276
%279 = bitcast i8* %0 to i32*
br i1 %278, label %280, label %312
280: ; preds = %274
%281 = icmp ugt i64 %16, 1
br i1 %281, label %282, label %722
282: ; preds = %280
%283 = load i32, i32* %279
%284 = add i64 %16, -1
%285 = add i64 %16, -2
%286 = and i64 %284, 3
%287 = icmp ult i64 %285, 3
br i1 %287, label %640, label %288
288: ; preds = %282
%289 = and i64 %284, -4
br label %290
290: ; preds = %290, %288
%291 = phi i64 [ 1, %288 ], [ %309, %290 ]
%292 = phi i32 [ %283, %288 ], [ %308, %290 ]
%293 = phi i64 [ 0, %288 ], [ %310, %290 ]
%294 = getelementptr inbounds i32, i32* %279, i64 %291
%295 = load i32, i32* %294
%296 = xor i32 %295, %292
store i32 %296, i32* %294
%297 = add nuw nsw i64 %291, 1
%298 = getelementptr inbounds i32, i32* %279, i64 %297
%299 = load i32, i32* %298
%300 = xor i32 %299, %296
store i32 %300, i32* %298
%301 = add nuw nsw i64 %291, 2
%302 = getelementptr inbounds i32, i32* %279, i64 %301
%303 = load i32, i32* %302
%304 = xor i32 %303, %300
store i32 %304, i32* %302
%305 = add nuw nsw i64 %291, 3
%306 = getelementptr inbounds i32, i32* %279, i64 %305
%307 = load i32, i32* %306
%308 = xor i32 %307, %304
store i32 %308, i32* %306
%309 = add nuw nsw i64 %291, 4
%310 = add i64 %293, 4
%311 = icmp eq i64 %310, %289
br i1 %311, label %640, label %290
312: ; preds = %274
%313 = load i32, i32* %279
%314 = bitcast i8* %13 to i32*
store i32 %313, i32* %314
%315 = icmp ugt i64 %16, 1
br i1 %315, label %316, label %722
316: ; preds = %312
%317 = add i64 %16, -1
%318 = add i64 %16, -2
%319 = and i64 %317, 3
%320 = icmp ult i64 %318, 3
br i1 %320, label %654, label %321
321: ; preds = %316
%322 = and i64 %317, -4
br label %323
323: ; preds = %323, %321
%324 = phi i8* [ %0, %321 ], [ %347, %323 ]
%325 = phi i8* [ %13, %321 ], [ %346, %323 ]
%326 = phi i32 [ %313, %321 ], [ %350, %323 ]
%327 = phi i64 [ 0, %321 ], [ %352, %323 ]
%328 = getelementptr inbounds i8, i8* %325, i64 %14
%329 = getelementptr inbounds i8, i8* %324, i64 %2
%330 = bitcast i8* %329 to i32*
%331 = load i32, i32* %330
%332 = xor i32 %331, %326
%333 = bitcast i8* %328 to i32*
store i32 %332, i32* %333
%334 = getelementptr inbounds i8, i8* %328, i64 %14
%335 = getelementptr inbounds i8, i8* %329, i64 %2
%336 = bitcast i8* %335 to i32*
%337 = load i32, i32* %336
%338 = xor i32 %337, %332
%339 = bitcast i8* %334 to i32*
store i32 %338, i32* %339
%340 = getelementptr inbounds i8, i8* %334, i64 %14
%341 = getelementptr inbounds i8, i8* %335, i64 %2
%342 = bitcast i8* %341 to i32*
%343 = load i32, i32* %342
%344 = xor i32 %343, %338
%345 = bitcast i8* %340 to i32*
store i32 %344, i32* %345
%346 = getelementptr inbounds i8, i8* %340, i64 %14
%347 = getelementptr inbounds i8, i8* %341, i64 %2
%348 = bitcast i8* %347 to i32*
%349 = load i32, i32* %348
%350 = xor i32 %349, %344
%351 = bitcast i8* %346 to i32*
store i32 %350, i32* %351
%352 = add i64 %327, 4
%353 = icmp eq i64 %352, %322
br i1 %353, label %654, label %323
354: ; preds = %272
%355 = bitcast i8* %0 to i32*
%356 = load i32, i32* %355
%357 = bitcast i8* %13 to i32*
store i32 %356, i32* %357
%358 = icmp ugt i64 %16, 1
br i1 %358, label %359, label %722
359: ; preds = %354
%360 = add i64 %16, -1
%361 = add i64 %16, -2
%362 = and i64 %360, 3
%363 = icmp ult i64 %361, 3
br i1 %363, label %622, label %364
364: ; preds = %359
%365 = and i64 %360, -4
br label %366
366: ; preds = %366, %364
%367 = phi i8* [ %0, %364 ], [ %390, %366 ]
%368 = phi i8* [ %13, %364 ], [ %389, %366 ]
%369 = phi i32 [ %356, %364 ], [ %392, %366 ]
%370 = phi i64 [ 0, %364 ], [ %395, %366 ]
%371 = getelementptr inbounds i8, i8* %368, i64 %14
%372 = getelementptr inbounds i8, i8* %367, i64 %2
%373 = bitcast i8* %372 to i32*
%374 = load i32, i32* %373
%375 = xor i32 %374, %369
%376 = bitcast i8* %371 to i32*
store i32 %375, i32* %376
%377 = getelementptr inbounds i8, i8* %371, i64 %14
%378 = getelementptr inbounds i8, i8* %372, i64 %2
%379 = bitcast i8* %378 to i32*
%380 = load i32, i32* %379
%381 = xor i32 %380, %374
%382 = bitcast i8* %377 to i32*
store i32 %381, i32* %382
%383 = getelementptr inbounds i8, i8* %377, i64 %14
%384 = getelementptr inbounds i8, i8* %378, i64 %2
%385 = bitcast i8* %384 to i32*
%386 = load i32, i32* %385
%387 = xor i32 %386, %380
%388 = bitcast i8* %383 to i32*
store i32 %387, i32* %388
%389 = getelementptr inbounds i8, i8* %383, i64 %14
%390 = getelementptr inbounds i8, i8* %384, i64 %2
%391 = bitcast i8* %390 to i32*
%392 = load i32, i32* %391
%393 = xor i32 %392, %386
%394 = bitcast i8* %389 to i32*
store i32 %393, i32* %394
%395 = add i64 %370, 4
%396 = icmp eq i64 %395, %365
br i1 %396, label %622, label %366
397: ; preds = %21
%398 = icmp eq i32 %7, 0
br i1 %398, label %479, label %399
399: ; preds = %397
%400 = icmp eq i64 %14, 4
%401 = and i1 %11, %400
%402 = icmp eq i64 %2, 4
%403 = and i1 %402, %401
%404 = bitcast i8* %0 to i32*
br i1 %403, label %405, label %437
405: ; preds = %399
%406 = icmp ugt i64 %16, 1
br i1 %406, label %407, label %722
407: ; preds = %405
%408 = load i32, i32* %404
%409 = add i64 %16, -1
%410 = add i64 %16, -2
%411 = and i64 %409, 3
%412 = icmp ult i64 %410, 3
br i1 %412, label %690, label %413
413: ; preds = %407
%414 = and i64 %409, -4
br label %415
415: ; preds = %415, %413
%416 = phi i32 [ %408, %413 ], [ %433, %415 ]
%417 = phi i64 [ 1, %413 ], [ %434, %415 ]
%418 = phi i64 [ 0, %413 ], [ %435, %415 ]
%419 = getelementptr inbounds i32, i32* %404, i64 %417
%420 = load i32, i32* %419
%421 = xor i32 %420, %416
store i32 %421, i32* %419
%422 = add nuw nsw i64 %417, 1
%423 = getelementptr inbounds i32, i32* %404, i64 %422
%424 = load i32, i32* %423
%425 = xor i32 %424, %421
store i32 %425, i32* %423
%426 = add nuw nsw i64 %417, 2
%427 = getelementptr inbounds i32, i32* %404, i64 %426
%428 = load i32, i32* %427
%429 = xor i32 %428, %425
store i32 %429, i32* %427
%430 = add nuw nsw i64 %417, 3
%431 = getelementptr inbounds i32, i32* %404, i64 %430
%432 = load i32, i32* %431
%433 = xor i32 %432, %429
store i32 %433, i32* %431
%434 = add nuw nsw i64 %417, 4
%435 = add i64 %418, 4
%436 = icmp eq i64 %435, %414
br i1 %436, label %690, label %415
437: ; preds = %399
%438 = load i32, i32* %404
%439 = bitcast i8* %13 to i32*
store i32 %438, i32* %439
%440 = icmp ugt i64 %16, 1
br i1 %440, label %441, label %722
441: ; preds = %437
%442 = add i64 %16, -1
%443 = add i64 %16, -2
%444 = and i64 %442, 3
%445 = icmp ult i64 %443, 3
br i1 %445, label %704, label %446
446: ; preds = %441
%447 = and i64 %442, -4
br label %448
448: ; preds = %448, %446
%449 = phi i8* [ %0, %446 ], [ %472, %448 ]
%450 = phi i32 [ %438, %446 ], [ %475, %448 ]
%451 = phi i8* [ %13, %446 ], [ %471, %448 ]
%452 = phi i64 [ 0, %446 ], [ %477, %448 ]
%453 = getelementptr inbounds i8, i8* %451, i64 %14
%454 = getelementptr inbounds i8, i8* %449, i64 %2
%455 = bitcast i8* %454 to i32*
%456 = load i32, i32* %455
%457 = xor i32 %456, %450
%458 = bitcast i8* %453 to i32*
store i32 %457, i32* %458
%459 = getelementptr inbounds i8, i8* %453, i64 %14
%460 = getelementptr inbounds i8, i8* %454, i64 %2
%461 = bitcast i8* %460 to i32*
%462 = load i32, i32* %461
%463 = xor i32 %462, %457
%464 = bitcast i8* %459 to i32*
store i32 %463, i32* %464
%465 = getelementptr inbounds i8, i8* %459, i64 %14
%466 = getelementptr inbounds i8, i8* %460, i64 %2
%467 = bitcast i8* %466 to i32*
%468 = load i32, i32* %467
%469 = xor i32 %468, %463
%470 = bitcast i8* %465 to i32*
store i32 %469, i32* %470
%471 = getelementptr inbounds i8, i8* %465, i64 %14
%472 = getelementptr inbounds i8, i8* %466, i64 %2
%473 = bitcast i8* %472 to i32*
%474 = load i32, i32* %473
%475 = xor i32 %474, %469
%476 = bitcast i8* %471 to i32*
store i32 %475, i32* %476
%477 = add i64 %452, 4
%478 = icmp eq i64 %477, %447
br i1 %478, label %704, label %448
479: ; preds = %397
%480 = bitcast i8* %0 to i32*
%481 = load i32, i32* %480
%482 = bitcast i8* %13 to i32*
store i32 %481, i32* %482
%483 = icmp ugt i64 %16, 1
br i1 %483, label %484, label %722
484: ; preds = %479
%485 = add i64 %16, -1
%486 = add i64 %16, -2
%487 = and i64 %485, 3
%488 = icmp ult i64 %486, 3
br i1 %488, label %672, label %489
489: ; preds = %484
%490 = and i64 %485, -4
br label %491
491: ; preds = %491, %489
%492 = phi i8* [ %0, %489 ], [ %515, %491 ]
%493 = phi i32 [ %481, %489 ], [ %517, %491 ]
%494 = phi i8* [ %13, %489 ], [ %514, %491 ]
%495 = phi i64 [ 0, %489 ], [ %520, %491 ]
%496 = getelementptr inbounds i8, i8* %494, i64 %14
%497 = getelementptr inbounds i8, i8* %492, i64 %2
%498 = bitcast i8* %497 to i32*
%499 = load i32, i32* %498
%500 = xor i32 %499, %493
%501 = bitcast i8* %496 to i32*
store i32 %500, i32* %501
%502 = getelementptr inbounds i8, i8* %496, i64 %14
%503 = getelementptr inbounds i8, i8* %497, i64 %2
%504 = bitcast i8* %503 to i32*
%505 = load i32, i32* %504
%506 = xor i32 %505, %499
%507 = bitcast i8* %502 to i32*
store i32 %506, i32* %507
%508 = getelementptr inbounds i8, i8* %502, i64 %14
%509 = getelementptr inbounds i8, i8* %503, i64 %2
%510 = bitcast i8* %509 to i32*
%511 = load i32, i32* %510
%512 = xor i32 %511, %505
%513 = bitcast i8* %508 to i32*
store i32 %512, i32* %513
%514 = getelementptr inbounds i8, i8* %508, i64 %14
%515 = getelementptr inbounds i8, i8* %509, i64 %2
%516 = bitcast i8* %515 to i32*
%517 = load i32, i32* %516
%518 = xor i32 %517, %511
%519 = bitcast i8* %514 to i32*
store i32 %518, i32* %519
%520 = add i64 %495, 4
%521 = icmp eq i64 %520, %490
br i1 %521, label %672, label %491
522: ; preds = %116, %109
%523 = phi i8* [ %0, %109 ], [ %140, %116 ]
%524 = phi i8* [ %13, %109 ], [ %139, %116 ]
%525 = phi i32 [ %106, %109 ], [ %142, %116 ]
%526 = icmp eq i64 %112, 0
br i1 %526, label %722, label %527
527: ; preds = %522, %527
%528 = phi i8* [ %533, %527 ], [ %523, %522 ]
%529 = phi i8* [ %532, %527 ], [ %524, %522 ]
%530 = phi i32 [ %535, %527 ], [ %525, %522 ]
%531 = phi i64 [ %538, %527 ], [ 0, %522 ]
%532 = getelementptr inbounds i8, i8* %529, i64 %14
%533 = getelementptr inbounds i8, i8* %528, i64 %2
%534 = bitcast i8* %533 to i32*
%535 = load i32, i32* %534
%536 = xor i32 %535, %530
%537 = bitcast i8* %532 to i32*
store i32 %536, i32* %537
%538 = add i64 %531, 1
%539 = icmp eq i64 %538, %112
br i1 %539, label %722, label %527
540: ; preds = %40, %32
%541 = phi i64 [ 1, %32 ], [ %59, %40 ]
%542 = phi i32 [ %33, %32 ], [ %58, %40 ]
%543 = icmp eq i64 %36, 0
br i1 %543, label %722, label %544
544: ; preds = %540, %544
%545 = phi i64 [ %551, %544 ], [ %541, %540 ]
%546 = phi i32 [ %550, %544 ], [ %542, %540 ]
%547 = phi i64 [ %552, %544 ], [ 0, %540 ]
%548 = getelementptr inbounds i32, i32* %29, i64 %545
%549 = load i32, i32* %548
%550 = xor i32 %549, %546
store i32 %550, i32* %548
%551 = add nuw nsw i64 %545, 1
%552 = add i64 %547, 1
%553 = icmp eq i64 %552, %36
br i1 %553, label %722, label %544
554: ; preds = %73, %66
%555 = phi i8* [ %0, %66 ], [ %97, %73 ]
%556 = phi i8* [ %13, %66 ], [ %96, %73 ]
%557 = phi i32 [ %63, %66 ], [ %100, %73 ]
%558 = icmp eq i64 %69, 0
br i1 %558, label %722, label %559
559: ; preds = %554, %559
%560 = phi i8* [ %565, %559 ], [ %555, %554 ]
%561 = phi i8* [ %564, %559 ], [ %556, %554 ]
%562 = phi i32 [ %568, %559 ], [ %557, %554 ]
%563 = phi i64 [ %570, %559 ], [ 0, %554 ]
%564 = getelementptr inbounds i8, i8* %561, i64 %14
%565 = getelementptr inbounds i8, i8* %560, i64 %2
%566 = bitcast i8* %565 to i32*
%567 = load i32, i32* %566
%568 = xor i32 %567, %562
%569 = bitcast i8* %564 to i32*
store i32 %568, i32* %569
%570 = add i64 %563, 1
%571 = icmp eq i64 %570, %69
br i1 %571, label %722, label %559
572: ; preds = %241, %234
%573 = phi i8* [ %0, %234 ], [ %265, %241 ]
%574 = phi i8* [ %13, %234 ], [ %264, %241 ]
%575 = phi i32 [ %231, %234 ], [ %267, %241 ]
%576 = icmp eq i64 %237, 0
br i1 %576, label %722, label %577
577: ; preds = %572, %577
%578 = phi i8* [ %583, %577 ], [ %573, %572 ]
%579 = phi i8* [ %582, %577 ], [ %574, %572 ]
%580 = phi i32 [ %585, %577 ], [ %575, %572 ]
%581 = phi i64 [ %588, %577 ], [ 0, %572 ]
%582 = getelementptr inbounds i8, i8* %579, i64 %14
%583 = getelementptr inbounds i8, i8* %578, i64 %2
%584 = bitcast i8* %583 to i32*
%585 = load i32, i32* %584
%586 = xor i32 %585, %580
%587 = bitcast i8* %582 to i32*
store i32 %586, i32* %587
%588 = add i64 %581, 1
%589 = icmp eq i64 %588, %237
br i1 %589, label %722, label %577
590: ; preds = %165, %157
%591 = phi i64 [ 1, %157 ], [ %184, %165 ]
%592 = phi i32 [ %158, %157 ], [ %183, %165 ]
%593 = icmp eq i64 %161, 0
br i1 %593, label %722, label %594
594: ; preds = %590, %594
%595 = phi i64 [ %601, %594 ], [ %591, %590 ]
%596 = phi i32 [ %600, %594 ], [ %592, %590 ]
%597 = phi i64 [ %602, %594 ], [ 0, %590 ]
%598 = getelementptr inbounds i32, i32* %154, i64 %595
%599 = load i32, i32* %598
%600 = xor i32 %599, %596
store i32 %600, i32* %598
%601 = add nuw nsw i64 %595, 1
%602 = add i64 %597, 1
%603 = icmp eq i64 %602, %161
br i1 %603, label %722, label %594
604: ; preds = %198, %191
%605 = phi i8* [ %0, %191 ], [ %222, %198 ]
%606 = phi i8* [ %13, %191 ], [ %221, %198 ]
%607 = phi i32 [ %188, %191 ], [ %225, %198 ]
%608 = icmp eq i64 %194, 0
br i1 %608, label %722, label %609
609: ; preds = %604, %609
%610 = phi i8* [ %615, %609 ], [ %605, %604 ]
%611 = phi i8* [ %614, %609 ], [ %606, %604 ]
%612 = phi i32 [ %618, %609 ], [ %607, %604 ]
%613 = phi i64 [ %620, %609 ], [ 0, %604 ]
%614 = getelementptr inbounds i8, i8* %611, i64 %14
%615 = getelementptr inbounds i8, i8* %610, i64 %2
%616 = bitcast i8* %615 to i32*
%617 = load i32, i32* %616
%618 = xor i32 %617, %612
%619 = bitcast i8* %614 to i32*
store i32 %618, i32* %619
%620 = add i64 %613, 1
%621 = icmp eq i64 %620, %194
br i1 %621, label %722, label %609
622: ; preds = %366, %359
%623 = phi i8* [ %0, %359 ], [ %390, %366 ]
%624 = phi i8* [ %13, %359 ], [ %389, %366 ]
%625 = phi i32 [ %356, %359 ], [ %392, %366 ]
%626 = icmp eq i64 %362, 0
br i1 %626, label %722, label %627
627: ; preds = %622, %627
%628 = phi i8* [ %633, %627 ], [ %623, %622 ]
%629 = phi i8* [ %632, %627 ], [ %624, %622 ]
%630 = phi i32 [ %635, %627 ], [ %625, %622 ]
%631 = phi i64 [ %638, %627 ], [ 0, %622 ]
%632 = getelementptr inbounds i8, i8* %629, i64 %14
%633 = getelementptr inbounds i8, i8* %628, i64 %2
%634 = bitcast i8* %633 to i32*
%635 = load i32, i32* %634
%636 = xor i32 %635, %630
%637 = bitcast i8* %632 to i32*
store i32 %636, i32* %637
%638 = add i64 %631, 1
%639 = icmp eq i64 %638, %362
br i1 %639, label %722, label %627
640: ; preds = %290, %282
%641 = phi i64 [ 1, %282 ], [ %309, %290 ]
%642 = phi i32 [ %283, %282 ], [ %308, %290 ]
%643 = icmp eq i64 %286, 0
br i1 %643, label %722, label %644
644: ; preds = %640, %644
%645 = phi i64 [ %651, %644 ], [ %641, %640 ]
%646 = phi i32 [ %650, %644 ], [ %642, %640 ]
%647 = phi i64 [ %652, %644 ], [ 0, %640 ]
%648 = getelementptr inbounds i32, i32* %279, i64 %645
%649 = load i32, i32* %648
%650 = xor i32 %649, %646
store i32 %650, i32* %648
%651 = add nuw nsw i64 %645, 1
%652 = add i64 %647, 1
%653 = icmp eq i64 %652, %286
br i1 %653, label %722, label %644
654: ; preds = %323, %316
%655 = phi i8* [ %0, %316 ], [ %347, %323 ]
%656 = phi i8* [ %13, %316 ], [ %346, %323 ]
%657 = phi i32 [ %313, %316 ], [ %350, %323 ]
%658 = icmp eq i64 %319, 0
br i1 %658, label %722, label %659
659: ; preds = %654, %659
%660 = phi i8* [ %665, %659 ], [ %655, %654 ]
%661 = phi i8* [ %664, %659 ], [ %656, %654 ]
%662 = phi i32 [ %668, %659 ], [ %657, %654 ]
%663 = phi i64 [ %670, %659 ], [ 0, %654 ]
%664 = getelementptr inbounds i8, i8* %661, i64 %14
%665 = getelementptr inbounds i8, i8* %660, i64 %2
%666 = bitcast i8* %665 to i32*
%667 = load i32, i32* %666
%668 = xor i32 %667, %662
%669 = bitcast i8* %664 to i32*
store i32 %668, i32* %669
%670 = add i64 %663, 1
%671 = icmp eq i64 %670, %319
br i1 %671, label %722, label %659
672: ; preds = %491, %484
%673 = phi i8* [ %0, %484 ], [ %515, %491 ]
%674 = phi i32 [ %481, %484 ], [ %517, %491 ]
%675 = phi i8* [ %13, %484 ], [ %514, %491 ]
%676 = icmp eq i64 %487, 0
br i1 %676, label %722, label %677
677: ; preds = %672, %677
%678 = phi i8* [ %683, %677 ], [ %673, %672 ]
%679 = phi i32 [ %685, %677 ], [ %674, %672 ]
%680 = phi i8* [ %682, %677 ], [ %675, %672 ]
%681 = phi i64 [ %688, %677 ], [ 0, %672 ]
%682 = getelementptr inbounds i8, i8* %680, i64 %14
%683 = getelementptr inbounds i8, i8* %678, i64 %2
%684 = bitcast i8* %683 to i32*
%685 = load i32, i32* %684
%686 = xor i32 %685, %679
%687 = bitcast i8* %682 to i32*
store i32 %686, i32* %687
%688 = add i64 %681, 1
%689 = icmp eq i64 %688, %487
br i1 %689, label %722, label %677
690: ; preds = %415, %407
%691 = phi i32 [ %408, %407 ], [ %433, %415 ]
%692 = phi i64 [ 1, %407 ], [ %434, %415 ]
%693 = icmp eq i64 %411, 0
br i1 %693, label %722, label %694
694: ; preds = %690, %694
%695 = phi i32 [ %700, %694 ], [ %691, %690 ]
%696 = phi i64 [ %701, %694 ], [ %692, %690 ]
%697 = phi i64 [ %702, %694 ], [ 0, %690 ]
%698 = getelementptr inbounds i32, i32* %404, i64 %696
%699 = load i32, i32* %698
%700 = xor i32 %699, %695
store i32 %700, i32* %698
%701 = add nuw nsw i64 %696, 1
%702 = add i64 %697, 1
%703 = icmp eq i64 %702, %411
br i1 %703, label %722, label %694
704: ; preds = %448, %441
%705 = phi i8* [ %0, %441 ], [ %472, %448 ]
%706 = phi i32 [ %438, %441 ], [ %475, %448 ]
%707 = phi i8* [ %13, %441 ], [ %471, %448 ]
%708 = icmp eq i64 %444, 0
br i1 %708, label %722, label %709
709: ; preds = %704, %709
%710 = phi i8* [ %715, %709 ], [ %705, %704 ]
%711 = phi i32 [ %718, %709 ], [ %706, %704 ]
%712 = phi i8* [ %714, %709 ], [ %707, %704 ]
%713 = phi i64 [ %720, %709 ], [ 0, %704 ]
%714 = getelementptr inbounds i8, i8* %712, i64 %14
%715 = getelementptr inbounds i8, i8* %710, i64 %2
%716 = bitcast i8* %715 to i32*
%717 = load i32, i32* %716
%718 = xor i32 %717, %711
%719 = bitcast i8* %714 to i32*
store i32 %718, i32* %719
%720 = add i64 %713, 1
%721 = icmp eq i64 %720, %444
br i1 %721, label %722, label %709
722: ; preds = %704, %709, %690, %694, %672, %677, %654, %659, %640, %644, %622, %627, %604, %609, %590, %594, %572, %577, %554, %559, %540, %544, %522, %527, %437, %405, %479, %312, %280, %354, %187, %155, %229, %62, %30, %104, %21, %19, %8
%723 = phi i64 [ -5, %8 ], [ 0, %19 ], [ -5, %21 ], [ 1, %104 ], [ 1, %30 ], [ 1, %62 ], [ 1, %229 ], [ 1, %155 ], [ 1, %187 ], [ 1, %354 ], [ 1, %280 ], [ 1, %312 ], [ 1, %479 ], [ 1, %405 ], [ 1, %437 ], [ %16, %527 ], [ %16, %522 ], [ %16, %544 ], [ %16, %540 ], [ %16, %559 ], [ %16, %554 ], [ %16, %577 ], [ %16, %572 ], [ %16, %594 ], [ %16, %590 ], [ %16, %609 ], [ %16, %604 ], [ %16, %627 ], [ %16, %622 ], [ %16, %644 ], [ %16, %640 ], [ %16, %659 ], [ %16, %654 ], [ %16, %677 ], [ %16, %672 ], [ %16, %694 ], [ %16, %690 ], [ %16, %709 ], [ %16, %704 ]
ret i64 %723
}