#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 */

/* Variables and functions */
int /*<<< orphan*/ memset(unsigned short *, int /*<<< orphan*/, int);
void blur(unsigned char *buffer, unsigned short *tmp2, int width, int height,
          int stride, int *m2, int r, int mwidth) {
  int x, y;
  unsigned char *s = buffer;
  unsigned short *t = tmp2 + 1;
  for (y = 0; y < height; y++) {
    memset(t - 1, 0, (width + 1) * sizeof(short));
    for (x = 0; x < r; x++) {
      const int src = s[x];
      if (src) {
        register unsigned short *dstp = t + x - r;
        int mx;
        unsigned *m3 = m2 + src * mwidth;
        for (mx = r - x; mx < mwidth; mx++) {
          dstp[mx] += m3[mx];
        }
      }
    }
    for (; x < width - r; x++) {
      const int src = s[x];
      if (src) {
        register unsigned short *dstp = t + x - r;
        int mx;
        unsigned *m3 = m2 + src * mwidth;
        for (mx = 0; mx < mwidth; mx++) {
          dstp[mx] += m3[mx];
        }
      }
    }
    for (; x < width; x++) {
      const int src = s[x];
      if (src) {
        register unsigned short *dstp = t + x - r;
        int mx;
        const int x2 = r + width - x;
        unsigned *m3 = m2 + src * mwidth;
        for (mx = 0; mx < x2; mx++) {
          dstp[mx] += m3[mx];
        }
      }
    }
    s += stride;
    t += width + 1;
  }
  t = tmp2;
  for (x = 0; x < width; x++) {
    for (y = 0; y < r; y++) {
      unsigned short *srcp = t + y * (width + 1) + 1;
      int src = *srcp;
      if (src) {
        register unsigned short *dstp = srcp - 1 + width + 1;
        const int src2 = (src + 128) >> 8;
        unsigned *m3 = m2 + src2 * mwidth;
        int mx;
        *srcp = 128;
        for (mx = r - 1; mx < mwidth; mx++) {
          *dstp += m3[mx];
          dstp += width + 1;
        }
      }
    }
    for (; y < height - r; y++) {
      unsigned short *srcp = t + y * (width + 1) + 1;
      int src = *srcp;
      if (src) {
        register unsigned short *dstp = srcp - 1 - r * (width + 1);
        const int src2 = (src + 128) >> 8;
        unsigned *m3 = m2 + src2 * mwidth;
        int mx;
        *srcp = 128;
        for (mx = 0; mx < mwidth; mx++) {
          *dstp += m3[mx];
          dstp += width + 1;
        }
      }
    }
    for (; y < height; y++) {
      unsigned short *srcp = t + y * (width + 1) + 1;
      int src = *srcp;
      if (src) {
        const int y2 = r + height - y;
        register unsigned short *dstp = srcp - 1 - r * (width + 1);
        const int src2 = (src + 128) >> 8;
        unsigned *m3 = m2 + src2 * mwidth;
        int mx;
        *srcp = 128;
        for (mx = 0; mx < y2; mx++) {
          *dstp += m3[mx];
          dstp += width + 1;
        }
      }
    }
    t++;
  }
  t = tmp2;
  s = buffer;
  for (y = 0; y < height; y++) {
    for (x = 0; x < width; x++) {
      s[x] = t[x] >> 8;
    }
    s += stride;
    t += width + 1;
  }
}


x86 assembly (clang, -O0):
<blur>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1428 <blur+0x318>
mov    -0x40(%rbp),%rdi
add    $0xfffffffffffffffe,%rdi
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x1,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    123b <blur+0x12b>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     1228 <blur+0x118>
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
movslq 0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    0x10(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1223 <blur+0x113>
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movzwl (%rax,%rcx,2),%edx
add    %esi,%edx
mov    %dx,(%rax,%rcx,2)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11ec <blur+0xdc>
jmp    1228 <blur+0x118>
jmp    122d <blur+0x11d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1182 <blur+0x72>
jmp    1240 <blur+0x130>
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    12fc <blur+0x1ec>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
je     12e9 <blur+0x1d9>
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
movslq 0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    12e4 <blur+0x1d4>
mov    -0x80(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movzwl (%rax,%rcx,2),%edx
add    %esi,%edx
mov    %dx,(%rax,%rcx,2)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12ad <blur+0x19d>
jmp    12e9 <blur+0x1d9>
jmp    12ee <blur+0x1de>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1240 <blur+0x130>
jmp    1301 <blur+0x1f1>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13f1 <blur+0x2e1>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x84(%rbp)
cmpl   $0x0,-0x84(%rbp)
je     13de <blur+0x2ce>
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
movslq 0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    0x10(%rbp),%eax
add    -0x14(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x84(%rbp),%ecx
imul   0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    13d9 <blur+0x2c9>
mov    -0xa0(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x90(%rbp),%rax
movslq -0x94(%rbp),%rcx
movzwl (%rax,%rcx,2),%edx
add    %esi,%edx
mov    %dx,(%rax,%rcx,2)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    138a <blur+0x27a>
jmp    13de <blur+0x2ce>
jmp    13e3 <blur+0x2d3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1301 <blur+0x1f1>
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1152 <blur+0x42>
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1832 <blur+0x722>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    157d <blur+0x46d>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x2,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0xac(%rbp)
cmpl   $0x0,-0xac(%rbp)
je     156a <blur+0x45a>
mov    -0xa8(%rbp),%rax
add    $0xfffffffffffffffe,%rax
movslq -0x14(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x2,%rax
mov    %rax,-0xb8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x80,%eax
sar    $0x8,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xbc(%rbp),%ecx
imul   0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xa8(%rbp),%rax
movw   $0x80,(%rax)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1565 <blur+0x455>
mov    -0xc8(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0xb8(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0xb8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1504 <blur+0x3f4>
jmp    156a <blur+0x45a>
jmp    156f <blur+0x45f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    144a <blur+0x33a>
jmp    1582 <blur+0x472>
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    16c4 <blur+0x5b4>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x2,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0xdc(%rbp)
cmpl   $0x0,-0xdc(%rbp)
je     16b1 <blur+0x5a1>
mov    -0xd8(%rbp),%rax
add    $0xfffffffffffffffe,%rax
mov    0x10(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xdc(%rbp),%eax
add    $0x80,%eax
sar    $0x8,%eax
mov    %eax,-0xec(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xec(%rbp),%ecx
imul   0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0xd8(%rbp),%rax
movw   $0x80,(%rax)
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    16ac <blur+0x59c>
mov    -0xf8(%rbp),%rax
movslq -0xfc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0xe8(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0xe8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    164b <blur+0x53b>
jmp    16b1 <blur+0x5a1>
jmp    16b6 <blur+0x5a6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1582 <blur+0x472>
jmp    16c9 <blur+0x5b9>
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1818 <blur+0x708>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x2,%rax
mov    %rax,-0x108(%rbp)
mov    -0x108(%rbp),%rax
movzwl (%rax),%eax
mov    %eax,-0x10c(%rbp)
cmpl   $0x0,-0x10c(%rbp)
je     1805 <blur+0x6f5>
mov    0x10(%rbp),%eax
add    -0x18(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x108(%rbp),%rax
add    $0xfffffffffffffffe,%rax
mov    0x10(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x118(%rbp)
mov    -0x10c(%rbp),%eax
add    $0x80,%eax
sar    $0x8,%eax
mov    %eax,-0x11c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x11c(%rbp),%ecx
imul   0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x128(%rbp)
mov    -0x108(%rbp),%rax
movw   $0x80,(%rax)
movl   $0x0,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
cmp    -0x110(%rbp),%eax
jge    1800 <blur+0x6f0>
mov    -0x128(%rbp),%rax
movslq -0x12c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x118(%rbp),%rax
movzwl (%rax),%ecx
add    %edx,%ecx
mov    %cx,(%rax)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x118(%rbp),%rax
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x118(%rbp)
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    179c <blur+0x68c>
jmp    1805 <blur+0x6f5>
jmp    180a <blur+0x6fa>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16c9 <blur+0x5b9>
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1437 <blur+0x327>
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18c9 <blur+0x7b9>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1892 <blur+0x782>
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzwl (%rax,%rcx,2),%eax
sar    $0x8,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    185c <blur+0x74c>
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1849 <blur+0x739>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<blur>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %rsi,0x78(%rsp)
mov    %rdi,0xb0(%rsp)
mov    0x138(%rsp),%r14d
mov    0x130(%rsp),%r13d
mov    %rdx,%rax
mov    %rdx,0x18(%rsp)
movslq %edx,%r15
movslq %r8d,%rax
mov    %rax,0xd0(%rsp)
mov    %r13d,%eax
mov    %rax,0xe8(%rsp)
mov    %r14d,%eax
mov    %rax,0xa8(%rsp)
mov    %rcx,0x88(%rsp)
test   %ecx,%ecx
mov    %r15,0xe0(%rsp)
mov    %r9,0x48(%rsp)
jle    1987 <blur+0x877>
mov    0x78(%rsp),%rdx
lea    0x2(%rdx),%rbx
lea    0x1(%r15),%rax
mov    %rax,0x80(%rsp)
lea    (%r15,%r15,1),%eax
add    $0x2,%eax
mov    %eax,0x3c(%rsp)
movslq %r13d,%rax
mov    %rax,%rcx
neg    %rcx
mov    %rcx,0x8(%rsp)
mov    %r15d,%esi
sub    %eax,%esi
mov    0x18(%rsp),%rcx
lea    (%rcx,%r13,1),%r11d
mov    0xa8(%rsp),%rcx
and    $0xfffffff8,%ecx
mov    %rcx,0xf0(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x98(%rsp)
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %rdi,%rcx
mov    %rdi,0x90(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xd8(%rsp)
mov    $0xd,%ecx
sub    %rax,%rcx
lea    (%rdx,%rcx,2),%rcx
mov    %rcx,0x68(%rsp)
mov    $0x1,%ecx
sub    %rax,%rcx
lea    (%rdx,%rcx,2),%rcx
mov    %rcx,0x30(%rsp)
xor    %edi,%edi
test   %eax,%eax
mov    $0x0,%ecx
cmovg  %r13d,%ecx
sub    %rax,%rcx
lea    (%rdx,%rcx,2),%rax
add    $0x1a,%rax
mov    %rax,0x58(%rsp)
lea    0x2(%rdx,%rcx,2),%rax
mov    %rax,0x50(%rsp)
movslq %r14d,%r12
mov    %esi,0xc0(%rsp)
movslq %esi,%rax
mov    %rax,0xa0(%rsp)
lea    -0x8(%r12),%rax
mov    %rax,0xc8(%rsp)
lea    0x2(%r15,%r15,1),%rax
mov    %rax,0xb8(%rsp)
lea    0x30(%r9),%rax
mov    %rax,0x70(%rsp)
mov    0xb0(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    %r11d,0x40(%rsp)
jmp    12fc <blur+0x1ec>
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
add    0xd0(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0x28(%rsp),%rbx
mov    0x80(%rsp),%rax
lea    (%rbx,%rax,2),%rbx
mov    0x60(%rsp),%rdi
add    $0x1,%edi
mov    0xb8(%rsp),%rax
add    %rax,0x68(%rsp)
add    %rax,0x30(%rsp)
add    %rax,0x58(%rsp)
add    %rax,0x50(%rsp)
cmp    0x88(%rsp),%edi
mov    0x130(%rsp),%r13d
je     1987 <blur+0x877>
mov    %rdi,0x60(%rsp)
lea    -0x2(%rbx),%rdi
xor    %esi,%esi
mov    0x3c(%rsp),%edx
call   1030 <memset@plt>
mov    $0x0,%r10d
test   %r13d,%r13d
mov    %rbx,0x28(%rsp)
jle    1548 <blur+0x438>
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,2),%rax
mov    %rax,0x20(%rsp)
mov    0x30(%rsp),%rcx
mov    0x68(%rsp),%r11
xor    %esi,%esi
mov    %r13d,%r14d
jmp    136e <blur+0x25e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rsi
add    $0xffffffff,%r14d
add    $0x2,%r11
add    $0x2,%rcx
cmp    0xe8(%rsp),%rsi
je     1540 <blur+0x430>
mov    0x10(%rsp),%rax
movzbl (%rax,%rsi,1),%eax
test   %eax,%eax
je     1350 <blur+0x240>
mov    %r13d,%edx
sub    %esi,%edx
cmp    0x138(%rsp),%edx
jge    1350 <blur+0x240>
movslq %r14d,%rbp
mov    %r13d,%edx
sub    %esi,%edx
movslq %edx,%rdx
mov    %r12,%r10
sub    %rdx,%r10
imul   0x138(%rsp),%eax
cltq
mov    0x48(%rsp),%rdx
lea    (%rdx,%rax,4),%rbx
cmp    $0x8,%r10
jb     1520 <blur+0x410>
lea    -0x8(%r10),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
cmp    $0x8,%rdx
jae    13d3 <blur+0x2c3>
xor    %eax,%eax
jmp    14a7 <blur+0x397>
mov    0xc8(%rsp),%rdx
sub    %rbp,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%r11,%rbp,2),%r8
add    %rbp,%rax
mov    0x70(%rsp),%rdi
lea    (%rdi,%rax,4),%rdi
xor    %eax,%eax
nopl   0x0(%rax)
movdqu -0x30(%rdi,%rax,4),%xmm0
movdqu -0x20(%rdi,%rax,4),%xmm1
movq   -0x18(%r8,%rax,2),%xmm2
movq   -0x10(%r8,%rax,2),%xmm3
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
paddw  %xmm2,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
paddw  %xmm3,%xmm1
movq   %xmm0,-0x18(%r8,%rax,2)
movq   %xmm1,-0x10(%r8,%rax,2)
movdqu -0x10(%rdi,%rax,4),%xmm0
movdqu (%rdi,%rax,4),%xmm1
movq   -0x8(%r8,%rax,2),%xmm2
movq   (%r8,%rax,2),%xmm3
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
paddw  %xmm2,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
paddw  %xmm3,%xmm1
movq   %xmm0,-0x8(%r8,%rax,2)
movq   %xmm1,(%r8,%rax,2)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    1400 <blur+0x2f0>
mov    %r10,%rdx
and    $0xfffffffffffffff8,%rdx
test   $0x1,%r9b
je     1507 <blur+0x3f7>
mov    0x20(%rsp),%rdi
lea    (%rdi,%rsi,2),%rdi
add    %rbp,%rax
movdqu (%rbx,%rax,4),%xmm0
movdqu 0x10(%rbx,%rax,4),%xmm1
movq   (%rdi,%rax,2),%xmm2
movq   0x8(%rdi,%rax,2),%xmm3
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
paddw  %xmm2,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
paddw  %xmm3,%xmm1
movq   %xmm0,(%rdi,%rax,2)
movq   %xmm1,0x8(%rdi,%rax,2)
cmp    %rdx,%r10
je     1350 <blur+0x240>
add    %rdx,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzwl (%rbx,%rbp,4),%eax
add    %ax,(%rcx,%rbp,2)
add    $0x1,%rbp
cmp    %r12,%rbp
jl     1520 <blur+0x410>
jmp    1350 <blur+0x240>
cs nopw 0x0(%rax,%rax,1)
mov    %r13d,%r10d
mov    0x28(%rsp),%rbx
cmp    0xc0(%rsp),%r10d
jge    1750 <blur+0x640>
mov    %r10d,%r10d
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,2),%r8
mov    0x50(%rsp),%rdx
mov    0x58(%rsp),%rsi
mov    0x48(%rsp),%r9
mov    0x138(%rsp),%r14d
mov    0xa8(%rsp),%rax
mov    0x40(%rsp),%r11d
mov    0xf0(%rsp),%r13
mov    0xa0(%rsp),%rbx
jmp    15b5 <blur+0x4a5>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x2,%rsi
add    $0x2,%rdx
cmp    %rbx,%r10
jge    1762 <blur+0x652>
mov    0x10(%rsp),%rcx
movzbl (%rcx,%r10,1),%ecx
test   %ecx,%ecx
je     15a0 <blur+0x490>
test   %r14d,%r14d
jle    15a0 <blur+0x490>
imul   %r14d,%ecx
movslq %ecx,%rcx
mov    %r9,%rdi
lea    (%r9,%rcx,4),%rdi
cmp    $0x8,%r14d
jae    15e3 <blur+0x4d3>
xor    %ecx,%ecx
jmp    1720 <blur+0x610>
cmpq   $0x0,0x98(%rsp)
je     1736 <blur+0x626>
mov    0x70(%rsp),%rbx
lea    (%rbx,%rcx,4),%rbx
mov    0xd8(%rsp),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x30(%rbx,%rbp,4),%xmm0
movdqu -0x20(%rbx,%rbp,4),%xmm1
movq   -0x18(%rsi,%rbp,2),%xmm2
movq   -0x10(%rsi,%rbp,2),%xmm3
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
paddw  %xmm2,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
paddw  %xmm3,%xmm1
movq   %xmm0,-0x18(%rsi,%rbp,2)
movq   %xmm1,-0x10(%rsi,%rbp,2)
movdqu -0x10(%rbx,%rbp,4),%xmm0
movdqu (%rbx,%rbp,4),%xmm1
movq   -0x8(%rsi,%rbp,2),%xmm2
movq   (%rsi,%rbp,2),%xmm3
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
paddw  %xmm2,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
paddw  %xmm3,%xmm1
movq   %xmm0,-0x8(%rsi,%rbp,2)
movq   %xmm1,(%rsi,%rbp,2)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rcx
jne    1610 <blur+0x500>
testb  $0x1,0x90(%rsp)
01
je     1704 <blur+0x5f4>
lea    (%r8,%r10,2),%rcx
movdqu (%rdi,%rbp,4),%xmm0
movdqu 0x10(%rdi,%rbp,4),%xmm1
movq   (%rcx,%rbp,2),%xmm2
movq   0x8(%rcx,%rbp,2),%xmm3
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
paddw  %xmm2,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
paddw  %xmm3,%xmm1
movq   %xmm0,(%rcx,%rbp,2)
movq   %xmm1,0x8(%rcx,%rbp,2)
mov    %r13,%rcx
cmp    %rax,%r13
mov    0xa0(%rsp),%rbx
je     15a0 <blur+0x490>
nopl   0x0(%rax,%rax,1)
movzwl (%rdi,%rcx,4),%ebp
add    %bp,(%rdx,%rcx,2)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1720 <blur+0x610>
jmp    15a0 <blur+0x490>
xor    %ebp,%ebp
testb  $0x1,0x90(%rsp)
01
jne    16b9 <blur+0x5a9>
jmp    1704 <blur+0x5f4>
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%r9
mov    0x138(%rsp),%r14d
mov    0x40(%rsp),%r11d
cmp    0x18(%rsp),%r10d
jge    12a0 <blur+0x190>
movslq %r10d,%rcx
mov    0x28(%rsp),%rax
mov    0x8(%rsp),%rdx
lea    (%rax,%rdx,2),%rax
mov    %rax,0x20(%rsp)
mov    %r11d,%r8d
sub    %r10d,%r8d
xor    %edi,%edi
jmp    17a4 <blur+0x694>
nopl   (%rax)
add    $0x1,%rcx
add    $0x1,%edi
add    $0xffffffff,%r8d
cmp    %r15,%rcx
je     12a0 <blur+0x190>
mov    %ecx,%r13d
mov    0x10(%rsp),%rax
movzbl (%rax,%r13,1),%edx
test   %edx,%edx
je     1790 <blur+0x680>
mov    %r11d,%ebx
sub    %ecx,%ebx
test   %ebx,%ebx
jle    1790 <blur+0x680>
sub    %r10d,%r11d
sub    %edi,%r11d
imul   %r14d,%edx
movslq %edx,%rdx
lea    (%r9,%rdx,4),%rbp
cmp    $0x8,%r11d
jae    17e1 <blur+0x6d1>
xor    %esi,%esi
mov    0x40(%rsp),%r11d
jmp    195f <blur+0x84f>
mov    %r11d,%esi
and    $0xfffffff8,%esi
add    $0xfffffffffffffff8,%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     18dd <blur+0x7cd>
mov    %r8d,%esi
and    $0xfffffff8,%esi
add    $0xfffffffffffffff8,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x68(%rsp),%rax
lea    (%rax,%r13,2),%r14
mov    0x70(%rsp),%rax
lea    (%rax,%rdx,4),%r15
xor    %edx,%edx
nopl   0x0(%rax)
movdqu -0x30(%r15,%rdx,4),%xmm0
movdqu -0x20(%r15,%rdx,4),%xmm1
movq   -0x18(%r14,%rdx,2),%xmm2
movq   -0x10(%r14,%rdx,2),%xmm3
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
paddw  %xmm2,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
paddw  %xmm3,%xmm1
movq   %xmm0,-0x18(%r14,%rdx,2)
movq   %xmm1,-0x10(%r14,%rdx,2)
movdqu -0x10(%r15,%rdx,4),%xmm0
movdqu (%r15,%rdx,4),%xmm1
movq   -0x8(%r14,%rdx,2),%xmm2
movq   (%r14,%rdx,2),%xmm3
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
paddw  %xmm2,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
paddw  %xmm3,%xmm1
movq   %xmm0,-0x8(%r14,%rdx,2)
movq   %xmm1,(%r14,%rdx,2)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1830 <blur+0x720>
jmp    18df <blur+0x7cf>
xor    %edx,%edx
mov    %r11d,%esi
and    $0xfffffff8,%esi
test   $0x1,%r9b
mov    0x48(%rsp),%r9
mov    0x138(%rsp),%r14d
je     1949 <blur+0x839>
mov    0x20(%rsp),%rax
lea    (%rax,%r13,2),%rax
movdqu 0x0(%rbp,%rdx,4),%xmm0
movdqu 0x10(%rbp,%rdx,4),%xmm1
movq   (%rax,%rdx,2),%xmm2
movq   0x8(%rax,%rdx,2),%xmm3
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
paddw  %xmm2,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
paddw  %xmm3,%xmm1
movq   %xmm0,(%rax,%rdx,2)
movq   %xmm1,0x8(%rax,%rdx,2)
cmp    %r11,%rsi
mov    0xe0(%rsp),%r15
mov    0x40(%rsp),%r11d
je     1790 <blur+0x680>
mov    0x30(%rsp),%rax
lea    (%rax,%r13,2),%rdx
mov    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movzwl 0x0(%rbp,%rsi,4),%eax
add    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
cmp    %rbx,%rsi
jb     1970 <blur+0x860>
jmp    1790 <blur+0x680>
mov    0x18(%rsp),%rax
mov    %eax,%ebp
test   %eax,%eax
mov    %rbp,0x60(%rsp)
jle    1ef8 <blur+0xde8>
lea    0x1(%rbp),%r12
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    0x130(%rsp),%edi
lea    -0x1(%rdi),%edx
mov    0x88(%rsp),%rsi
mov    %esi,%ebx
sub    %edi,%ebx
imul   %edi,%eax
movslq %eax,%rcx
mov    %rcx,%rax
neg    %rax
mov    %rax,0x98(%rsp)
lea    (%rdi,%rsi,1),%eax
mov    %eax,0x20(%rsp)
movslq %edx,%rax
mov    %rax,0xc0(%rsp)
mov    %ebx,0x3c(%rsp)
movslq %ebx,%rax
mov    %rax,0xb8(%rsp)
movslq %esi,%r11
mov    %r14d,%eax
sub    %edi,%eax
mov    %rax,0x70(%rsp)
add    $0x1,%eax
and    $0x3,%eax
mov    %eax,0xa0(%rsp)
mov    0xa8(%rsp),%rsi
mov    %esi,%r13d
and    $0x3,%r13d
mov    %esi,%eax
and    $0xfffffffc,%eax
mov    %rax,0xd8(%rsp)
xor    %ebx,%ebx
test   %edi,%edi
mov    $0x0,%edx
cmovg  %edi,%edx
imul   %r12,%rdx
sub    %rcx,%rdx
add    %rcx,%rcx
mov    0x78(%rsp),%rax
mov    %rax,%rdi
sub    %rcx,%rdi
mov    %rdi,0x50(%rsp)
lea    -0x1(%rsi),%rcx
mov    %rcx,0x68(%rsp)
lea    (%rax,%rdx,2),%rcx
mov    %rcx,0x80(%rsp)
lea    0x2(%rax,%rbp,2),%rcx
mov    %rcx,0x58(%rsp)
lea    0x2(%rbp,%rbp,1),%r10
lea    0xc(%r9),%rcx
mov    %rcx,0x30(%rsp)
lea    0x8(,%rbp,8),%rcx
mov    %rcx,0x90(%rsp)
mov    %rax,0x8(%rsp)
mov    %r11,0x28(%rsp)
jmp    1aea <blur+0x9da>
nopw   0x0(%rax,%rax,1)
addq   $0x2,0x8(%rsp)
mov    0xc8(%rsp),%rbx
add    $0x1,%ebx
addq   $0x2,0x58(%rsp)
addq   $0x2,0x80(%rsp)
addq   $0x2,0x50(%rsp)
cmp    0x18(%rsp),%ebx
mov    0xe0(%rsp),%r15
mov    0x48(%rsp),%r9
mov    0x138(%rsp),%r14d
mov    0x60(%rsp),%rbp
je     1ef8 <blur+0xde8>
mov    %rbx,0xc8(%rsp)
mov    $0x0,%r8d
mov    0x130(%rsp),%eax
test   %eax,%eax
jle    1c1d <blur+0xb0d>
mov    0x8(%rsp),%rax
lea    0x2(%rax),%r11
mov    0x58(%rsp),%rdx
xor    %esi,%esi
mov    0xc0(%rsp),%r15
jmp    1b45 <blur+0xa35>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    %r10,%rdx
cmp    0xe8(%rsp),%rsi
je     1c10 <blur+0xb00>
mov    %rsi,%rdi
imul   %r12,%rdi
movzwl (%r11,%rdi,2),%ecx
test   %ecx,%ecx
je     1b30 <blur+0xa20>
lea    (%r11,%rdi,2),%rdi
movw   $0x80,(%rdi)
mov    0x130(%rsp),%eax
cmp    %eax,%r14d
jl     1b30 <blur+0xa20>
sub    $0xffffff80,%ecx
shr    $0x8,%ecx
imul   %r14d,%ecx
movslq %ecx,%r8
mov    0xa0(%rsp),%ebp
test   %ebp,%ebp
je     1ba5 <blur+0xa95>
lea    (%r9,%r8,4),%rcx
mov    %rdx,%rbx
mov    %r15,%rdi
nopl   0x0(%rax)
movzwl (%rcx,%rdi,4),%eax
add    %ax,(%rbx)
add    $0x1,%rdi
add    %r10,%rbx
add    $0xffffffff,%ebp
jne    1b90 <blur+0xa80>
jmp    1bb1 <blur+0xaa1>
mov    0x60(%rsp),%rax
lea    (%rdi,%rax,2),%rbx
mov    %r15,%rdi
cmpl   $0x3,0x70(%rsp)
mov    0xa8(%rsp),%rbp
jb     1b30 <blur+0xa20>
mov    0x30(%rsp),%rax
lea    (%rax,%r8,4),%rcx
nopl   (%rax)
movzwl -0xc(%rcx,%rdi,4),%eax
add    %ax,(%rbx)
movzwl -0x8(%rcx,%rdi,4),%eax
add    %ax,(%rbx,%r10,1)
add    %r10,%rbx
movzwl -0x4(%rcx,%rdi,4),%eax
add    %ax,(%r10,%rbx,1)
add    %r10,%rbx
movzwl (%rcx,%rdi,4),%eax
add    %ax,(%r10,%rbx,1)
add    %r10,%rbx
add    $0x4,%rdi
add    %r10,%rbx
cmp    %edi,%ebp
jne    1bd0 <blur+0xac0>
jmp    1b30 <blur+0xa20>
xchg   %ax,%ax
mov    0x130(%rsp),%r8d
mov    0x28(%rsp),%r11
cmp    0x3c(%rsp),%r8d
jge    1d50 <blur+0xc40>
mov    %r8d,%r8d
mov    0x8(%rsp),%rax
lea    0x2(%rax),%rbp
mov    0x80(%rsp),%rbx
mov    0xb8(%rsp),%r15
jmp    1c60 <blur+0xb50>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r8
add    %r10,%rbx
cmp    %r15,%r8
jge    1d70 <blur+0xc60>
mov    %r8,%rdx
imul   %r12,%rdx
movzwl 0x0(%rbp,%rdx,2),%ecx
test   %ecx,%ecx
je     1c50 <blur+0xb40>
lea    0x0(,%rdx,2),%rdx
add    %rbp,%rdx
movw   $0x80,(%rdx)
test   %r14d,%r14d
jle    1c50 <blur+0xb40>
sub    $0xffffff80,%ecx
shr    $0x8,%ecx
imul   %r14d,%ecx
movslq %ecx,%r11
cmpq   $0x3,0x68(%rsp)
jae    1cb3 <blur+0xba3>
mov    0x98(%rsp),%rax
lea    (%rdx,%rax,2),%rsi
add    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
test   %r13,%r13
jne    1d26 <blur+0xc16>
jmp    1c50 <blur+0xb40>
mov    0x30(%rsp),%rax
lea    (%rax,%r11,4),%rdi
mov    %rbx,%rdx
xor    %ecx,%ecx
mov    0xd8(%rsp),%r14
nopl   0x0(%rax)
mov    %rdx,%rsi
movzwl -0xc(%rdi,%rcx,4),%eax
add    %ax,(%rdx)
movzwl -0x8(%rdi,%rcx,4),%eax
add    %r10,%rdx
add    %ax,(%rsi,%r10,1)
movzwl -0x4(%rdi,%rcx,4),%eax
add    %ax,(%r10,%rdx,1)
add    %r10,%rdx
movzwl (%rdi,%rcx,4),%eax
add    %ax,(%r10,%rdx,1)
add    %r10,%rdx
add    $0x4,%rcx
add    %r10,%rdx
cmp    %rcx,%r14
jne    1cd0 <blur+0xbc0>
add    0x90(%rsp),%rsi
mov    0x138(%rsp),%r14d
test   %r13,%r13
je     1c50 <blur+0xb40>
add    %r11,%rcx
lea    (%r9,%rcx,4),%rcx
xor    %edx,%edx
nop
movzwl (%rcx,%rdx,4),%eax
add    %ax,(%rsi)
add    $0x1,%rdx
add    %r10,%rsi
cmp    %rdx,%r13
jne    1d30 <blur+0xc20>
jmp    1c50 <blur+0xb40>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%r9d
cmp    0x88(%rsp),%r8d
jl     1d88 <blur+0xc78>
jmp    1aa0 <blur+0x990>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x20(%rsp),%r9d
mov    0x28(%rsp),%r11
cmp    0x88(%rsp),%r8d
jge    1aa0 <blur+0x990>
movslq %r8d,%r15
mov    0x8(%rsp),%rax
add    $0x2,%rax
mov    %rax,0x10(%rsp)
mov    %r12,%rax
imul   %r15,%rax
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,2),%rbx
mov    %r9d,%r14d
sub    %r8d,%r14d
xor    %ebp,%ebp
jmp    1dd7 <blur+0xcc7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r15
add    $0x1,%ebp
add    %r10,%rbx
add    $0xffffffff,%r14d
cmp    %r11,%r15
je     1aa0 <blur+0x990>
mov    %r15,%rdx
imul   %r12,%rdx
mov    0x10(%rsp),%rax
movzwl (%rax,%rdx,2),%ecx
test   %ecx,%ecx
je     1dc0 <blur+0xcb0>
mov    0x10(%rsp),%rax
lea    (%rax,%rdx,2),%rdx
mov    %r9d,%eax
sub    %r15d,%eax
movw   $0x80,(%rdx)
test   %eax,%eax
jle    1dc0 <blur+0xcb0>
mov    %r9d,%esi
sub    %r8d,%esi
sub    %ebp,%esi
lea    -0x1(%rsi),%rax
sub    $0xffffff80,%ecx
shr    $0x8,%ecx
imul   0x138(%rsp),%ecx
movslq %ecx,%rcx
cmp    $0x3,%rax
mov    %rcx,0x40(%rsp)
jae    1e48 <blur+0xd38>
mov    0x98(%rsp),%rax
lea    (%rdx,%rax,2),%rdi
add    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
test   $0x3,%sil
jne    1ec0 <blur+0xdb0>
jmp    1dc0 <blur+0xcb0>
mov    %r12,%r9
mov    %r14d,%r12d
and    $0xfffffffc,%r12d
mov    0x30(%rsp),%rax
lea    (%rax,%rcx,4),%r11
mov    %rbx,%rdx
xor    %ecx,%ecx
mov    %rdx,%rdi
movzwl -0xc(%r11,%rcx,4),%eax
add    %ax,(%rdx)
movzwl -0x8(%r11,%rcx,4),%eax
add    %r10,%rdx
add    %ax,(%rdi,%r10,1)
movzwl -0x4(%r11,%rcx,4),%eax
add    %ax,(%r10,%rdx,1)
add    %r10,%rdx
movzwl (%r11,%rcx,4),%eax
add    %ax,(%r10,%rdx,1)
add    %r10,%rdx
add    $0x4,%rcx
add    %r10,%rdx
cmp    %rcx,%r12
jne    1e60 <blur+0xd50>
add    0x90(%rsp),%rdi
mov    %r9,%r12
mov    0x20(%rsp),%r9d
mov    0x28(%rsp),%r11
test   $0x3,%sil
je     1dc0 <blur+0xcb0>
mov    %r14d,%esi
and    $0x3,%esi
add    0x40(%rsp),%rcx
mov    0x48(%rsp),%rax
lea    (%rax,%rcx,4),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movzwl (%rcx,%rdx,4),%eax
add    %ax,(%rdi)
add    $0x1,%rdx
add    %r10,%rdi
cmp    %rdx,%rsi
jne    1ee0 <blur+0xdd0>
jmp    1dc0 <blur+0xcb0>
mov    0x88(%rsp),%r13
test   %r13d,%r13d
jle    20c7 <blur+0xfb7>
lea    0x1(%r15),%r10
mov    %ebp,%r14d
and    $0xfffffff0,%r14d
lea    -0x10(%r14),%r9
mov    %r9,%r11
shr    $0x4,%r11
add    $0x1,%r11
mov    %r11,%r8
and    $0xfffffffffffffffe,%r8
mov    %r15,%rax
mov    %ebp,%r15d
and    $0x3,%r15d
lea    (%rax,%rax,1),%r12
add    $0x2,%r12
xor    %edi,%edi
mov    0x78(%rsp),%rdx
mov    0xb0(%rsp),%rax
jmp    1f68 <blur+0xe58>
nopl   (%rax)
add    0xd0(%rsp),%rax
add    %r12,%rdx
add    $0x1,%rdi
cmp    %r13d,%edi
je     20c7 <blur+0xfb7>
cmpl   $0x0,0x18(%rsp)
jle    1f50 <blur+0xe40>
cmpl   $0x10,0x18(%rsp)
jb     1fb2 <blur+0xea2>
mov    %rdi,%rcx
imul   %r10,%rcx
add    %rbp,%rcx
mov    0x78(%rsp),%rsi
lea    (%rsi,%rcx,2),%rcx
cmp    %rcx,%rax
jae    2031 <blur+0xf21>
mov    %rdi,%rcx
imul   0xd0(%rsp),%rcx
add    %rbp,%rcx
add    0xb0(%rsp),%rcx
cmp    %rdx,%rcx
jbe    2031 <blur+0xf21>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %rbp,%rsi
test   %r15,%r15
je     1fe2 <blur+0xed2>
mov    %r15,%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x1(%rdx,%rcx,2),%ebx
mov    %bl,(%rax,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbp
jne    1fd0 <blur+0xec0>
cmp    $0x3,%rsi
mov    0x60(%rsp),%rbp
jb     1f50 <blur+0xe40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%rdx,%rcx,2),%ebx
mov    %bl,(%rax,%rcx,1)
movzbl 0x3(%rdx,%rcx,2),%ebx
mov    %bl,0x1(%rax,%rcx,1)
movzbl 0x5(%rdx,%rcx,2),%ebx
mov    %bl,0x2(%rax,%rcx,1)
movzbl 0x7(%rdx,%rcx,2),%ebx
mov    %bl,0x3(%rax,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    2000 <blur+0xef0>
jmp    1f50 <blur+0xe40>
test   %r9,%r9
je     20bd <blur+0xfad>
mov    %r8,%rsi
xor    %ecx,%ecx
nop
movdqu (%rdx,%rcx,2),%xmm0
movdqu 0x10(%rdx,%rcx,2),%xmm1
psrlw  $0x8,%xmm0
psrlw  $0x8,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%rax,%rcx,1)
movdqu 0x20(%rdx,%rcx,2),%xmm0
movdqu 0x30(%rdx,%rcx,2),%xmm1
psrlw  $0x8,%xmm0
psrlw  $0x8,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,0x10(%rax,%rcx,1)
add    $0x20,%rcx
add    $0xfffffffffffffffe,%rsi
jne    2040 <blur+0xf30>
test   $0x1,%r11b
je     20ac <blur+0xf9c>
movdqu (%rdx,%rcx,2),%xmm0
movdqu 0x10(%rdx,%rcx,2),%xmm1
psrlw  $0x8,%xmm0
psrlw  $0x8,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%rax,%rcx,1)
mov    %r14,%rcx
cmp    %rbp,%r14
je     1f50 <blur+0xe40>
jmp    1fb4 <blur+0xea4>
xor    %ecx,%ecx
test   $0x1,%r11b
jne    208e <blur+0xf7e>
jmp    20ac <blur+0xf9c>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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