#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 scalar_t__ uint8_t;
typedef scalar_t__ uint64_t;
typedef scalar_t__ uint32_t;
typedef scalar_t__ uint16_t;
typedef scalar_t__ ssize_t;

/* Variables and functions */
ssize_t imcd_delta(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: {
    if (decode) {
      uint8_t sum = *(uint8_t *)srcptr;
      if (inplace && (stride == sizeof(uint8_t)) &&
          (srcstride == sizeof(uint8_t))) {
        uint8_t *qsrc = (uint8_t *)srcptr;
        for (i = 1; i < size; i++) {
          sum += qsrc[i];
          qsrc[i] = sum;
        }
      } else {
        *(uint8_t *)dstptr = sum;
        for (i = 1; i < size; i++) {
          dstptr += stride;
          srcptr += srcstride;
          sum += *(uint8_t *)srcptr;
          *(uint8_t *)dstptr = sum;
        }
      }
    } else {
      uint8_t src0, src1;
      src0 = *(uint8_t *)srcptr;
      *(uint8_t *)dstptr = src0;
      for (i = 1; i < size; i++) {
        dstptr += stride;
        srcptr += srcstride;
        src1 = *(uint8_t *)srcptr;
        *(uint8_t *)dstptr = src1 - src0;
        src0 = src1;
      }
    }
  }; break;
  case 2: {
    if (decode) {
      uint16_t sum = *(uint16_t *)srcptr;
      if (inplace && (stride == sizeof(uint16_t)) &&
          (srcstride == sizeof(uint16_t))) {
        uint16_t *qsrc = (uint16_t *)srcptr;
        for (i = 1; i < size; i++) {
          sum += qsrc[i];
          qsrc[i] = sum;
        }
      } else {
        *(uint16_t *)dstptr = sum;
        for (i = 1; i < size; i++) {
          dstptr += stride;
          srcptr += srcstride;
          sum += *(uint16_t *)srcptr;
          *(uint16_t *)dstptr = sum;
        }
      }
    } else {
      uint16_t src0, src1;
      src0 = *(uint16_t *)srcptr;
      *(uint16_t *)dstptr = src0;
      for (i = 1; i < size; i++) {
        dstptr += stride;
        srcptr += srcstride;
        src1 = *(uint16_t *)srcptr;
        *(uint16_t *)dstptr = src1 - src0;
        src0 = src1;
      }
    }
  }; break;
  case 4: {
    if (decode) {
      uint32_t sum = *(uint32_t *)srcptr;
      if (inplace && (stride == sizeof(uint32_t)) &&
          (srcstride == sizeof(uint32_t))) {
        uint32_t *qsrc = (uint32_t *)srcptr;
        for (i = 1; i < size; i++) {
          sum += qsrc[i];
          qsrc[i] = sum;
        }
      } else {
        *(uint32_t *)dstptr = sum;
        for (i = 1; i < size; i++) {
          dstptr += stride;
          srcptr += srcstride;
          sum += *(uint32_t *)srcptr;
          *(uint32_t *)dstptr = sum;
        }
      }
    } else {
      uint32_t src0, src1;
      src0 = *(uint32_t *)srcptr;
      *(uint32_t *)dstptr = src0;
      for (i = 1; i < size; i++) {
        dstptr += stride;
        srcptr += srcstride;
        src1 = *(uint32_t *)srcptr;
        *(uint32_t *)dstptr = src1 - src0;
        src0 = src1;
      }
    }
  }; break;
  case 8: {
    if (decode) {
      uint64_t sum = *(uint64_t *)srcptr;
      if (inplace && (stride == sizeof(uint64_t)) &&
          (srcstride == sizeof(uint64_t))) {
        uint64_t *qsrc = (uint64_t *)srcptr;
        for (i = 1; i < size; i++) {
          sum += qsrc[i];
          qsrc[i] = sum;
        }
      } else {
        *(uint64_t *)dstptr = sum;
        for (i = 1; i < size; i++) {
          dstptr += stride;
          srcptr += srcstride;
          sum += *(uint64_t *)srcptr;
          *(uint64_t *)dstptr = sum;
        }
      }
    } else {
      uint64_t src0, src1;
      src0 = *(uint64_t *)srcptr;
      *(uint64_t *)dstptr = src0;
      for (i = 1; i < size; i++) {
        dstptr += stride;
        srcptr += srcstride;
        src1 = *(uint64_t *)srcptr;
        *(uint64_t *)dstptr = src1 - src0;
        src0 = src1;
      }
    }
  }; break;
  default:
    return -5;
  }
  return size;
}


x86 assembly (clang, -O0):
<imcd_delta>:
push   %rbp
mov    %rsp,%rbp
sub    $0x98,%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,-0xe9(%rbp)
je     114e <imcd_delta+0x4e>
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
sete   %al
mov    %al,-0xe9(%rbp)
mov    -0xe9(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     1176 <imcd_delta+0x76>
mov    -0x18(%rbp),%rax
mov    %rax,-0xf8(%rbp)
jmp    11ad <imcd_delta+0xad>
mov    -0x18(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    1194 <imcd_delta+0x94>
mov    -0x18(%rbp),%rax
mov    %rax,-0x100(%rbp)
jmp    119f <imcd_delta+0x9f>
mov    -0x30(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     11d2 <imcd_delta+0xd2>
mov    -0x20(%rbp),%rax
mov    %rax,-0x108(%rbp)
jmp    11dd <imcd_delta+0xdd>
mov    -0x38(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x108(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     120a <imcd_delta+0x10a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x110(%rbp)
jmp    1215 <imcd_delta+0x115>
mov    -0x28(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x18(%rbp)
jl     1236 <imcd_delta+0x136>
cmpq   $0x0,-0x30(%rbp)
jge    1243 <imcd_delta+0x143>
movq   $0xfffffffffffffffb,-0x8(%rbp)
ff
jmp    193b <imcd_delta+0x83b>
cmpq   $0x0,-0x48(%rbp)
jg     125b <imcd_delta+0x15b>
movq   $0x0,-0x8(%rbp)
jmp    193b <imcd_delta+0x83b>
mov    0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x118(%rbp)
sub    $0x7,%rax
ja     1926 <imcd_delta+0x826>
mov    -0x118(%rbp),%rax
lea    0xd7e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x0,0x18(%rbp)
je     1386 <imcd_delta+0x286>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     1318 <imcd_delta+0x218>
cmpq   $0x8,-0x50(%rbp)
jne    1318 <imcd_delta+0x218>
cmpq   $0x8,-0x20(%rbp)
jne    1318 <imcd_delta+0x218>
mov    -0x58(%rbp),%rax
mov    %rax,-0x78(%rbp)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1313 <imcd_delta+0x213>
mov    -0x78(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rdx
mov    -0x78(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    12d0 <imcd_delta+0x1d0>
jmp    1381 <imcd_delta+0x281>
mov    -0x70(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    137c <imcd_delta+0x27c>
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),%rax
add    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    132b <imcd_delta+0x22b>
jmp    1381 <imcd_delta+0x281>
jmp    140b <imcd_delta+0x30b>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1406 <imcd_delta+0x306>
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),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rcx
sub    -0x80(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x88(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    13a4 <imcd_delta+0x2a4>
jmp    140b <imcd_delta+0x30b>
jmp    1933 <imcd_delta+0x833>
cmpl   $0x0,0x18(%rbp)
je     152c <imcd_delta+0x42c>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     14b2 <imcd_delta+0x3b2>
cmpq   $0x8,-0x50(%rbp)
jne    14b2 <imcd_delta+0x3b2>
cmpq   $0x8,-0x20(%rbp)
jne    14b2 <imcd_delta+0x3b2>
mov    -0x58(%rbp),%rax
mov    %rax,-0x98(%rbp)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    14ad <imcd_delta+0x3ad>
mov    -0x98(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rdx
mov    -0x98(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    145b <imcd_delta+0x35b>
jmp    1527 <imcd_delta+0x427>
mov    -0x90(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1522 <imcd_delta+0x422>
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),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    14c8 <imcd_delta+0x3c8>
jmp    1527 <imcd_delta+0x427>
jmp    15bd <imcd_delta+0x4bd>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    15b8 <imcd_delta+0x4b8>
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),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rcx
sub    -0xa0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xa8(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1550 <imcd_delta+0x450>
jmp    15bd <imcd_delta+0x4bd>
jmp    1933 <imcd_delta+0x833>
cmpl   $0x0,0x18(%rbp)
je     16de <imcd_delta+0x5de>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xb0(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     1664 <imcd_delta+0x564>
cmpq   $0x8,-0x50(%rbp)
jne    1664 <imcd_delta+0x564>
cmpq   $0x8,-0x20(%rbp)
jne    1664 <imcd_delta+0x564>
mov    -0x58(%rbp),%rax
mov    %rax,-0xb8(%rbp)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    165f <imcd_delta+0x55f>
mov    -0xb8(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rdx
mov    -0xb8(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    160d <imcd_delta+0x50d>
jmp    16d9 <imcd_delta+0x5d9>
mov    -0xb0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    16d4 <imcd_delta+0x5d4>
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),%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    167a <imcd_delta+0x57a>
jmp    16d9 <imcd_delta+0x5d9>
jmp    176f <imcd_delta+0x66f>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    176a <imcd_delta+0x66a>
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),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rcx
sub    -0xc0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xc8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1702 <imcd_delta+0x602>
jmp    176f <imcd_delta+0x66f>
jmp    1933 <imcd_delta+0x833>
cmpl   $0x0,0x18(%rbp)
je     1890 <imcd_delta+0x790>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xd0(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     1816 <imcd_delta+0x716>
cmpq   $0x8,-0x50(%rbp)
jne    1816 <imcd_delta+0x716>
cmpq   $0x8,-0x20(%rbp)
jne    1816 <imcd_delta+0x716>
mov    -0x58(%rbp),%rax
mov    %rax,-0xd8(%rbp)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1811 <imcd_delta+0x711>
mov    -0xd8(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    -0xd0(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rdx
mov    -0xd8(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    17bf <imcd_delta+0x6bf>
jmp    188b <imcd_delta+0x78b>
mov    -0xd0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1886 <imcd_delta+0x786>
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),%rax
add    -0xd0(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    182c <imcd_delta+0x72c>
jmp    188b <imcd_delta+0x78b>
jmp    1921 <imcd_delta+0x821>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    191c <imcd_delta+0x81c>
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),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rcx
sub    -0xe0(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xe8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    18b4 <imcd_delta+0x7b4>
jmp    1921 <imcd_delta+0x821>
jmp    1933 <imcd_delta+0x833>
movq   $0xfffffffffffffffb,-0x8(%rbp)
ff
jmp    193b <imcd_delta+0x83b>
mov    -0x48(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x98,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<imcd_delta>:
push   %r15
push   %r14
push   %r13
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     1a85 <imcd_delta+0x985>
test   %r10,%r10
jle    1226 <imcd_delta+0x126>
mov    0x30(%rsp),%rsi
add    $0xffffffffffffffff,%rsi
cmp    $0x7,%rsi
ja     1a85 <imcd_delta+0x985>
mov    0x38(%rsp),%r8d
lea    0xe96(%rip),%rbx
movslq (%rbx,%rsi,4),%rsi
add    %rbx,%rsi
jmp    *%rsi
mov    (%rdi),%r13
test   %r8d,%r8d
je     1446 <imcd_delta+0x346>
cmp    $0x8,%r9
sete   %al
cmp    $0x8,%rdx
jne    151e <imcd_delta+0x41e>
and    %al,%r11b
je     151e <imcd_delta+0x41e>
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%rdx
lea    -0x2(%r10),%rbx
mov    %edx,%eax
and    $0x3,%eax
mov    $0x1,%ecx
cmp    $0x3,%rbx
jb     11fb <imcd_delta+0xfb>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
add    0x8(%rdi,%rcx,8),%r13
mov    %r13,0x8(%rdi,%rcx,8)
add    0x10(%rdi,%rcx,8),%r13
mov    %r13,0x10(%rdi,%rcx,8)
add    0x18(%rdi,%rcx,8),%r13
mov    %r13,0x18(%rdi,%rcx,8)
add    0x20(%rdi,%rcx,8),%r13
mov    %r13,0x20(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    11c6 <imcd_delta+0xc6>
add    $0x1,%rcx
test   %rax,%rax
je     1a82 <imcd_delta+0x982>
lea    (%rdi,%rcx,8),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
add    (%rcx,%rdx,8),%r13
mov    %r13,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1210 <imcd_delta+0x110>
jmp    1a82 <imcd_delta+0x982>
xor    %eax,%eax
jmp    1a85 <imcd_delta+0x985>
mov    (%rdi),%r13
test   %r8d,%r8d
je     147c <imcd_delta+0x37c>
cmp    $0x8,%r9
sete   %al
cmp    $0x8,%rdx
jne    1554 <imcd_delta+0x454>
and    %al,%r11b
je     1554 <imcd_delta+0x454>
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%rdx
lea    -0x2(%r10),%rbx
mov    %edx,%eax
and    $0x3,%eax
mov    $0x1,%ecx
cmp    $0x3,%rbx
jb     12b5 <imcd_delta+0x1b5>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
add    0x8(%rdi,%rcx,8),%r13
mov    %r13,0x8(%rdi,%rcx,8)
add    0x10(%rdi,%rcx,8),%r13
mov    %r13,0x10(%rdi,%rcx,8)
add    0x18(%rdi,%rcx,8),%r13
mov    %r13,0x18(%rdi,%rcx,8)
add    0x20(%rdi,%rcx,8),%r13
mov    %r13,0x20(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1280 <imcd_delta+0x180>
add    $0x1,%rcx
test   %rax,%rax
je     1a82 <imcd_delta+0x982>
lea    (%rdi,%rcx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    (%rcx,%rdx,8),%r13
mov    %r13,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    12d0 <imcd_delta+0x1d0>
jmp    1a82 <imcd_delta+0x982>
mov    (%rdi),%r13
test   %r8d,%r8d
je     14b2 <imcd_delta+0x3b2>
cmp    $0x8,%r9
sete   %al
cmp    $0x8,%rdx
jne    158a <imcd_delta+0x48a>
and    %al,%r11b
je     158a <imcd_delta+0x48a>
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%rdx
lea    -0x2(%r10),%rsi
mov    %edx,%eax
and    $0x3,%eax
mov    $0x1,%ecx
cmp    $0x3,%rsi
jb     136e <imcd_delta+0x26e>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
add    0x8(%rdi,%rcx,8),%r13
mov    %r13,0x8(%rdi,%rcx,8)
add    0x10(%rdi,%rcx,8),%r13
mov    %r13,0x10(%rdi,%rcx,8)
add    0x18(%rdi,%rcx,8),%r13
mov    %r13,0x18(%rdi,%rcx,8)
add    0x20(%rdi,%rcx,8),%r13
mov    %r13,0x20(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1339 <imcd_delta+0x239>
add    $0x1,%rcx
test   %rax,%rax
je     1a82 <imcd_delta+0x982>
lea    (%rdi,%rcx,8),%rcx
xor    %edx,%edx
nopl   (%rax)
add    (%rcx,%rdx,8),%r13
mov    %r13,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1380 <imcd_delta+0x280>
jmp    1a82 <imcd_delta+0x982>
mov    (%rdi),%r13
test   %r8d,%r8d
je     14e8 <imcd_delta+0x3e8>
cmp    $0x8,%r9
sete   %al
cmp    $0x8,%rdx
jne    15c0 <imcd_delta+0x4c0>
and    %al,%r11b
je     15c0 <imcd_delta+0x4c0>
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%rdx
lea    -0x2(%r10),%rbx
mov    %edx,%eax
and    $0x3,%eax
mov    $0x1,%ecx
cmp    $0x3,%rbx
jb     141e <imcd_delta+0x31e>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
add    0x8(%rdi,%rcx,8),%r13
mov    %r13,0x8(%rdi,%rcx,8)
add    0x10(%rdi,%rcx,8),%r13
mov    %r13,0x10(%rdi,%rcx,8)
add    0x18(%rdi,%rcx,8),%r13
mov    %r13,0x18(%rdi,%rcx,8)
add    0x20(%rdi,%rcx,8),%r13
mov    %r13,0x20(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    13e9 <imcd_delta+0x2e9>
add    $0x1,%rcx
test   %rax,%rax
je     1a82 <imcd_delta+0x982>
lea    (%rdi,%rcx,8),%rcx
xor    %edx,%edx
nopl   (%rax)
add    (%rcx,%rdx,8),%r13
mov    %r13,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1430 <imcd_delta+0x330>
jmp    1a82 <imcd_delta+0x982>
mov    %r13,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%r11
lea    -0x2(%r10),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    15f6 <imcd_delta+0x4f6>
mov    %rdi,%rax
mov    %rcx,%rbx
jmp    166e <imcd_delta+0x56e>
mov    %r13,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%r11
lea    -0x2(%r10),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    16a0 <imcd_delta+0x5a0>
mov    %rdi,%rax
mov    %rcx,%rbx
jmp    170e <imcd_delta+0x60e>
mov    %r13,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%r11
lea    -0x2(%r10),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1740 <imcd_delta+0x640>
mov    %rdi,%rsi
mov    %rcx,%rax
jmp    17ae <imcd_delta+0x6ae>
mov    %r13,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%r11
lea    -0x2(%r10),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    17e0 <imcd_delta+0x6e0>
mov    %rdi,%rax
mov    %rcx,%rbx
jmp    184e <imcd_delta+0x74e>
mov    %r13,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%r11
lea    -0x2(%r10),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1880 <imcd_delta+0x780>
mov    %rdi,%rax
mov    %rcx,%rbx
jmp    18d2 <imcd_delta+0x7d2>
mov    %r13,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%r11
lea    -0x2(%r10),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1907 <imcd_delta+0x807>
mov    %rdi,%rax
mov    %rcx,%rbx
jmp    1959 <imcd_delta+0x859>
mov    %r13,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%r11
lea    -0x2(%r10),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1987 <imcd_delta+0x887>
mov    %rdi,%rax
mov    %rcx,%rsi
jmp    19d9 <imcd_delta+0x8d9>
mov    %r13,(%rcx)
mov    $0x1,%eax
cmp    $0x2,%r10
jb     1a85 <imcd_delta+0x985>
lea    -0x1(%r10),%r11
lea    -0x2(%r10),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1a04 <imcd_delta+0x904>
mov    %rdi,%rbx
mov    %rcx,%rax
jmp    1a56 <imcd_delta+0x956>
and    $0xfffffffffffffffc,%r11
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rcx,%r9,1),%rbx
lea    (%rdi,%rdx,1),%rax
mov    (%rdi,%rdx,1),%r12
mov    %r12,%rsi
sub    %r13,%rsi
mov    %rsi,(%rcx,%r9,1)
add    %r9,%rbx
add    %rdx,%rax
mov    (%rdi,%rdx,2),%r13
mov    %r13,%rsi
sub    %r12,%rsi
mov    %rsi,(%rcx,%r9,2)
add    %r9,%rbx
add    %rdx,%rax
mov    (%rdi,%r14,1),%r12
mov    %r12,%rsi
sub    %r13,%rsi
mov    %rsi,(%rcx,%r15,1)
add    %r9,%rbx
add    %rdx,%rax
mov    (%rdi,%rdx,4),%r13
mov    %r13,%rsi
sub    %r12,%rsi
mov    %rsi,(%rcx,%r9,4)
mov    %rax,%rdi
mov    %rbx,%rcx
add    $0xfffffffffffffffc,%r11
jne    1610 <imcd_delta+0x510>
test   %r8,%r8
je     1a82 <imcd_delta+0x982>
add    %rdx,%rax
add    %r9,%rbx
nopl   (%rax)
mov    (%rax),%rcx
mov    %rcx,%rsi
sub    %r13,%rsi
mov    %rsi,(%rbx)
add    %rdx,%rax
add    %r9,%rbx
mov    %rcx,%r13
add    $0xffffffffffffffff,%r8
jne    1680 <imcd_delta+0x580>
jmp    1a82 <imcd_delta+0x982>
and    $0xfffffffffffffffc,%r11
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
nopl   0x0(%rax)
lea    (%rcx,%r9,1),%rbx
lea    (%rdi,%rdx,1),%rax
mov    (%rdi,%rdx,1),%r12
mov    %r12,%rsi
sub    %r13,%rsi
mov    %rsi,(%rcx,%r9,1)
add    %r9,%rbx
add    %rdx,%rax
mov    (%rdi,%rdx,2),%r13
mov    %r13,%rsi
sub    %r12,%rsi
mov    %rsi,(%rcx,%r9,2)
add    %r9,%rbx
add    %rdx,%rax
mov    (%rdi,%r14,1),%r12
mov    %r12,%rsi
sub    %r13,%rsi
mov    %rsi,(%rcx,%r15,1)
add    %r9,%rbx
add    %rdx,%rax
mov    (%rdi,%rdx,4),%r13
mov    %r13,%rsi
sub    %r12,%rsi
mov    %rsi,(%rcx,%r9,4)
mov    %rax,%rdi
mov    %rbx,%rcx
add    $0xfffffffffffffffc,%r11
jne    16b0 <imcd_delta+0x5b0>
test   %r8,%r8
je     1a82 <imcd_delta+0x982>
add    %rdx,%rax
add    %r9,%rbx
nopl   (%rax)
mov    (%rax),%rcx
mov    %rcx,%rsi
sub    %r13,%rsi
mov    %rsi,(%rbx)
add    %rdx,%rax
add    %r9,%rbx
mov    %rcx,%r13
add    $0xffffffffffffffff,%r8
jne    1720 <imcd_delta+0x620>
jmp    1a82 <imcd_delta+0x982>
and    $0xfffffffffffffffc,%r11
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
nopl   0x0(%rax)
lea    (%rcx,%r9,1),%rax
lea    (%rdi,%rdx,1),%rsi
mov    (%rdi,%rdx,1),%r12
mov    %r12,%rbx
sub    %r13,%rbx
mov    %rbx,(%rcx,%r9,1)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%rdx,2),%r13
mov    %r13,%rbx
sub    %r12,%rbx
mov    %rbx,(%rcx,%r9,2)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%r14,1),%r12
mov    %r12,%rbx
sub    %r13,%rbx
mov    %rbx,(%rcx,%r15,1)
add    %r9,%rax
add    %rdx,%rsi
mov    (%rdi,%rdx,4),%r13
mov    %r13,%rdi
sub    %r12,%rdi
mov    %rdi,(%rcx,%r9,4)
mov    %rsi,%rdi
mov    %rax,%rcx
add    $0xfffffffffffffffc,%r11
jne    1750 <imcd_delta+0x650>
test   %r8,%r8
je     1a82 <imcd_delta+0x982>
add    %rdx,%rsi
add    %r9,%rax
nopl   (%rax)
mov    (%rsi),%rcx
mov    %rcx,%rdi
sub    %r13,%rdi
mov    %rdi,(%rax)
add    %rdx,%rsi
add    %r9,%rax
mov    %rcx,%r13
add    $0xffffffffffffffff,%r8
jne    17c0 <imcd_delta+0x6c0>
jmp    1a82 <imcd_delta+0x982>
and    $0xfffffffffffffffc,%r11
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
nopl   0x0(%rax)
lea    (%rcx,%r9,1),%rbx
lea    (%rdi,%rdx,1),%rax
mov    (%rdi,%rdx,1),%r12
mov    %r12,%rsi
sub    %r13,%rsi
mov    %rsi,(%rcx,%r9,1)
add    %r9,%rbx
add    %rdx,%rax
mov    (%rdi,%rdx,2),%r13
mov    %r13,%rsi
sub    %r12,%rsi
mov    %rsi,(%rcx,%r9,2)
add    %r9,%rbx
add    %rdx,%rax
mov    (%rdi,%r14,1),%r12
mov    %r12,%rsi
sub    %r13,%rsi
mov    %rsi,(%rcx,%r15,1)
add    %r9,%rbx
add    %rdx,%rax
mov    (%rdi,%rdx,4),%r13
mov    %r13,%rsi
sub    %r12,%rsi
mov    %rsi,(%rcx,%r9,4)
mov    %rax,%rdi
mov    %rbx,%rcx
add    $0xfffffffffffffffc,%r11
jne    17f0 <imcd_delta+0x6f0>
test   %r8,%r8
je     1a82 <imcd_delta+0x982>
add    %rdx,%rax
add    %r9,%rbx
nopl   (%rax)
mov    (%rax),%rcx
mov    %rcx,%rsi
sub    %r13,%rsi
mov    %rsi,(%rbx)
add    %rdx,%rax
add    %r9,%rbx
mov    %rcx,%r13
add    $0xffffffffffffffff,%r8
jne    1860 <imcd_delta+0x760>
jmp    1a82 <imcd_delta+0x982>
and    $0xfffffffffffffffc,%r11
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
lea    (%rcx,%r9,1),%rbx
lea    (%rdi,%rdx,1),%rax
add    (%rdi,%rdx,1),%r13
mov    %r13,(%rcx,%r9,1)
add    %r9,%rbx
add    %rdx,%rax
add    (%rdi,%rdx,2),%r13
mov    %r13,(%rcx,%r9,2)
add    %r9,%rbx
add    (%rdi,%r14,1),%r13
add    %rdx,%rax
mov    %r13,(%rcx,%r15,1)
add    %r9,%rbx
add    %rdx,%rax
add    (%rdi,%rdx,4),%r13
mov    %r13,(%rcx,%r9,4)
mov    %rax,%rdi
mov    %rbx,%rcx
add    $0xfffffffffffffffc,%r11
jne    188c <imcd_delta+0x78c>
test   %r8,%r8
je     1a82 <imcd_delta+0x982>
add    %rdx,%rax
add    %r9,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    (%rax),%r13
mov    %r13,(%rbx)
add    %rdx,%rax
add    %r9,%rbx
add    $0xffffffffffffffff,%r8
jne    18f0 <imcd_delta+0x7f0>
jmp    1a82 <imcd_delta+0x982>
and    $0xfffffffffffffffc,%r11
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
lea    (%rcx,%r9,1),%rbx
lea    (%rdi,%rdx,1),%rax
add    (%rdi,%rdx,1),%r13
mov    %r13,(%rcx,%r9,1)
add    %r9,%rbx
add    %rdx,%rax
add    (%rdi,%rdx,2),%r13
mov    %r13,(%rcx,%r9,2)
add    %r9,%rbx
add    (%rdi,%r14,1),%r13
add    %rdx,%rax
mov    %r13,(%rcx,%r15,1)
add    %r9,%rbx
add    %rdx,%rax
add    (%rdi,%rdx,4),%r13
mov    %r13,(%rcx,%r9,4)
mov    %rax,%rdi
mov    %rbx,%rcx
add    $0xfffffffffffffffc,%r11
jne    1913 <imcd_delta+0x813>
test   %r8,%r8
je     1a82 <imcd_delta+0x982>
add    %rdx,%rax
add    %r9,%rbx
nopl   0x0(%rax,%rax,1)
add    (%rax),%r13
mov    %r13,(%rbx)
add    %rdx,%rax
add    %r9,%rbx
add    $0xffffffffffffffff,%r8
jne    1970 <imcd_delta+0x870>
jmp    1a82 <imcd_delta+0x982>
and    $0xfffffffffffffffc,%r11
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
lea    (%rcx,%r9,1),%rsi
lea    (%rdi,%rdx,1),%rax
add    (%rdi,%rdx,1),%r13
mov    %r13,(%rcx,%r9,1)
add    %r9,%rsi
add    %rdx,%rax
add    (%rdi,%rdx,2),%r13
mov    %r13,(%rcx,%r9,2)
add    %r9,%rsi
add    (%rdi,%r14,1),%r13
add    %rdx,%rax
mov    %r13,(%rcx,%r15,1)
add    %r9,%rsi
add    %rdx,%rax
add    (%rdi,%rdx,4),%r13
mov    %r13,(%rcx,%r9,4)
mov    %rax,%rdi
mov    %rsi,%rcx
add    $0xfffffffffffffffc,%r11
jne    1993 <imcd_delta+0x893>
test   %r8,%r8
je     1a82 <imcd_delta+0x982>
add    %rdx,%rax
add    %r9,%rsi
nopl   0x0(%rax,%rax,1)
add    (%rax),%r13
mov    %r13,(%rsi)
add    %rdx,%rax
add    %r9,%rsi
add    $0xffffffffffffffff,%r8
jne    19f0 <imcd_delta+0x8f0>
jmp    1a82 <imcd_delta+0x982>
and    $0xfffffffffffffffc,%r11
lea    (%rdx,%rdx,2),%r14
lea    (%r9,%r9,2),%r15
lea    (%rcx,%r9,1),%rax
lea    (%rdi,%rdx,1),%rbx
add    (%rdi,%rdx,1),%r13
mov    %r13,(%rcx,%r9,1)
add    %r9,%rax
add    %rdx,%rbx
add    (%rdi,%rdx,2),%r13
mov    %r13,(%rcx,%r9,2)
add    %r9,%rax
add    (%rdi,%r14,1),%r13
add    %rdx,%rbx
mov    %r13,(%rcx,%r15,1)
add    %r9,%rax
add    %rdx,%rbx
add    (%rdi,%rdx,4),%r13
mov    %r13,(%rcx,%r9,4)
mov    %rbx,%rdi
mov    %rax,%rcx
add    $0xfffffffffffffffc,%r11
jne    1a10 <imcd_delta+0x910>
test   %r8,%r8
je     1a82 <imcd_delta+0x982>
add    %rdx,%rbx
add    %r9,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    (%rbx),%r13
mov    %r13,(%rax)
add    %rdx,%rbx
add    %r9,%rax
add    $0xffffffffffffffff,%r8
jne    1a70 <imcd_delta+0x970>
mov    %r10,%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

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