#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 */
unsigned char *allocMemory(int);
int /*<<< orphan*/ blurAlpha(unsigned char *, int, int, int, int, int,
                             unsigned char, int /*<<< orphan*/,
                             int /*<<< orphan*/, int, int);
int /*<<< orphan*/ clearMemory(unsigned char *, unsigned char, int);
int /*<<< orphan*/ compositeDestinationOver(unsigned char *, unsigned char *,
                                            int, int);
int /*<<< orphan*/ compositeSourceAtop(unsigned char *, unsigned char *, int,
                                       int);
int /*<<< orphan*/ compositeSourceIn(unsigned char *, unsigned char *, int,
                                     int);
int /*<<< orphan*/ compositeSourceOut(unsigned char *, unsigned char *, int,
                                      int);
int /*<<< orphan*/ copyMemory(unsigned char *, unsigned char *, int);
int /*<<< orphan*/ freeMemory(unsigned char *);
void dropshadow(unsigned char *img, int width, int height, int dx, int dy,
                unsigned int color, int alpha, int bx, int by, double strength,
                int quality, unsigned int flags) {
  int inner = flags & 1;
  int knockout = (flags >> 1) & 1;
  int hideObject = (flags >> 2) & 1;
  int size = width * height;
  int size4 = size << 2;
  int i;
  unsigned char defaultalpha = (inner == 1) ? 0xff : 0;
  unsigned char *tmp = allocMemory(size4);
  clearMemory(tmp, defaultalpha, size);
  unsigned char *ptmp = tmp;
  unsigned char *pimg = img + 3;
  if (dx == 0 && dy == 0) {
    if (inner == 1) {
      for (i = 0; i < size; ++i) {
        *ptmp++ = 255 - *pimg;
        pimg += 4;
      }
    } else {
      for (i = 0; i < size; ++i) {
        *ptmp++ = *pimg;
        pimg += 4;
      }
    }
  } else {
    int w = width - ((dx) < 0 ? -(dx) : (dx));
    int h = height - ((dy) < 0 ? -(dy) : (dy));
    int width4 = width << 2;
    int x, x4, y;
    if (dx > 0) {
      ptmp += dx;
    } else {
      pimg -= dx * 4;
    }
    if (dy > 0) {
      ptmp += dy * width;
    } else {
      pimg -= dy * width * 4;
    }
    if (inner == 1) {
      for (y = 0; y < h; ++y) {
        for (x = 0, x4 = 0; x < w; ++x, x4 += 4) {
          *(ptmp + x) = 255 - *(pimg + x4);
        }
        ptmp += width;
        pimg += width4;
      }
    } else {
      for (y = 0; y < h; ++y) {
        for (x = 0, x4 = 0; x < w; ++x, x4 += 4) {
          *(ptmp + x) = *(pimg + x4);
        }
        ptmp += width;
        pimg += width4;
      }
    }
  }
  blurAlpha(tmp, width, height, bx, by, quality, defaultalpha, 0, 0, width,
            height);
  unsigned char r = (color >> 16) & 0xff;
  unsigned char g = (color >> 8) & 0xff;
  unsigned char b = color & 0xff;
  unsigned int bgr = r | g << 8 | b << 16 | 0xff000000;
  float af;
  unsigned long ac;
  unsigned int *ptmp32 = (unsigned int *)tmp + size - 1;
  ptmp = tmp + size;
  while (--ptmp >= tmp) {
    ac = *ptmp * strength;
    if (ac >= 255) {
      *ptmp32-- = bgr;
    } else if (ac > 0) {
      af = ac / 255.0;
      *ptmp32-- =
          (int)(r * af) | (int)(g * af) << 8 | (int)(b * af) << 16 | ac << 24;
    } else {
      *ptmp32-- = 0;
    }
  }
  if (inner == 1) {
    if (knockout == 0 && hideObject == 0) {
      compositeSourceAtop(img, tmp, width, height);
    } else {
      compositeSourceIn(img, tmp, width, height);
    }
  } else {
    if (knockout == 1) {
      compositeSourceOut(img, tmp, width, height);
    } else if (hideObject == 1) {
      copyMemory(img, tmp, size4);
    } else {
      compositeDestinationOver(img, tmp, width, height);
    }
  }
  freeMemory(tmp);
}


x86 assembly (clang, -O0):
<dropshadow>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0xd8,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    0x30(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    0x30(%rbp),%eax
shr    $0x1,%eax
and    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    0x30(%rbp),%eax
shr    $0x2,%eax
and    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%edx
xor    %eax,%eax
mov    $0xff,%ecx
cmp    $0x1,%edx
cmove  %ecx,%eax
mov    %al,-0x49(%rbp)
mov    -0x44(%rbp),%edi
call   1070 <allocMemory@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x49(%rbp),%al
mov    -0x40(%rbp),%edx
movzbl %al,%esi
call   10a0 <clearMemory@plt>
mov    -0x58(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x68(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    12fd <dropshadow+0x16d>
cmpl   $0x0,-0x20(%rbp)
jne    12fd <dropshadow+0x16d>
cmpl   $0x1,-0x34(%rbp)
jne    12af <dropshadow+0x11f>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    12aa <dropshadow+0x11a>
mov    -0x68(%rbp),%rax
movzbl (%rax),%ecx
mov    $0xff,%eax
sub    %ecx,%eax
mov    %al,%cl
mov    -0x60(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x60(%rbp)
mov    %cl,(%rax)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1263 <dropshadow+0xd3>
jmp    12f8 <dropshadow+0x168>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    12f3 <dropshadow+0x163>
mov    -0x68(%rbp),%rax
mov    (%rax),%cl
mov    -0x60(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x60(%rbp)
mov    %cl,(%rax)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12b6 <dropshadow+0x126>
jmp    12f8 <dropshadow+0x168>
jmp    1531 <dropshadow+0x3a1>
mov    -0x14(%rbp),%eax
mov    %eax,-0xa4(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    1320 <dropshadow+0x190>
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0xa8(%rbp)
jmp    1329 <dropshadow+0x199>
mov    -0x1c(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0xa8(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0xac(%rbp)
cmpl   $0x0,-0x20(%rbp)
jge    135d <dropshadow+0x1cd>
xor    %eax,%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0xb0(%rbp)
jmp    1366 <dropshadow+0x1d6>
mov    -0x20(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0xac(%rbp),%eax
mov    -0xb0(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x74(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    13a0 <dropshadow+0x210>
mov    -0x1c(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    13b9 <dropshadow+0x229>
mov    -0x1c(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    13dd <dropshadow+0x24d>
mov    -0x20(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    13fa <dropshadow+0x26a>
mov    -0x20(%rbp),%ecx
imul   -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
cmpl   $0x1,-0x34(%rbp)
jne    149d <dropshadow+0x30d>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1498 <dropshadow+0x308>
movl   $0x0,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1468 <dropshadow+0x2d8>
mov    -0x68(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
mov    $0xff,%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x7c(%rbp)
jmp    1425 <dropshadow+0x295>
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    140b <dropshadow+0x27b>
jmp    152c <dropshadow+0x39c>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1527 <dropshadow+0x397>
movl   $0x0,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    14f7 <dropshadow+0x367>
mov    -0x68(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x7c(%rbp)
jmp    14be <dropshadow+0x32e>
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    14a4 <dropshadow+0x314>
jmp    152c <dropshadow+0x39c>
jmp    1531 <dropshadow+0x3a1>
mov    -0x58(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    0x18(%rbp),%ecx
mov    0x20(%rbp),%r8d
mov    0x28(%rbp),%r9d
mov    -0x49(%rbp),%r11b
mov    -0x14(%rbp),%r10d
mov    -0x18(%rbp),%eax
xor    %ebx,%ebx
movzbl %r11b,%r11d
mov    %r11d,(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    %r10d,0x18(%rsp)
mov    %eax,0x20(%rsp)
call   1030 <blurAlpha@plt>
mov    -0x24(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,-0x81(%rbp)
mov    -0x24(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,-0x82(%rbp)
mov    -0x24(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x83(%rbp)
movzbl -0x81(%rbp),%eax
movzbl -0x82(%rbp),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
movzbl -0x83(%rbp),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
or     $0xff000000,%eax
mov    %eax,-0x88(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x60(%rbp)
cmp    -0x58(%rbp),%rax
jb     1778 <dropshadow+0x5e8>
mov    -0x60(%rbp),%rax
movzbl (%rax),%eax
cvtsi2sd %eax,%xmm0
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movaps %xmm0,%xmm1
cvttsd2si %xmm1,%rax
mov    %rax,%rdx
sar    $0x3f,%rdx
movsd  0x9c3(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rcx
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x98(%rbp)
cmpq   $0xff,-0x98(%rbp)
jb     1686 <dropshadow+0x4f6>
mov    -0x88(%rbp),%ecx
mov    -0xa0(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0xa0(%rbp)
mov    %ecx,(%rax)
jmp    1773 <dropshadow+0x5e3>
cmpq   $0x0,-0x98(%rbp)
jbe    1753 <dropshadow+0x5c3>
movaps 0x975(%rip),%xmm1
movq   -0x98(%rbp),%xmm0
ff
punpckldq %xmm1,%xmm0
movapd 0x971(%rip),%xmm1
subpd  %xmm1,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x942(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movzbl -0x81(%rbp),%eax
cvtsi2ss %eax,%xmm0
mulss  -0x8c(%rbp),%xmm0
ff
cvttss2si %xmm0,%eax
movzbl -0x82(%rbp),%ecx
cvtsi2ss %ecx,%xmm0
mulss  -0x8c(%rbp),%xmm0
ff
cvttss2si %xmm0,%ecx
shl    $0x8,%ecx
or     %ecx,%eax
movzbl -0x83(%rbp),%ecx
cvtsi2ss %ecx,%xmm0
mulss  -0x8c(%rbp),%xmm0
ff
cvttss2si %xmm0,%ecx
shl    $0x10,%ecx
or     %ecx,%eax
cltq
mov    -0x98(%rbp),%rcx
shl    $0x18,%rcx
or     %rcx,%rax
mov    %eax,%ecx
mov    -0xa0(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0xa0(%rbp)
mov    %ecx,(%rax)
jmp    176e <dropshadow+0x5de>
mov    -0xa0(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0xa0(%rbp)
movl   $0x0,(%rax)
jmp    1773 <dropshadow+0x5e3>
jmp    15fc <dropshadow+0x46c>
cmpl   $0x1,-0x34(%rbp)
jne    17c6 <dropshadow+0x636>
cmpl   $0x0,-0x38(%rbp)
jne    17ae <dropshadow+0x61e>
cmpl   $0x0,-0x3c(%rbp)
jne    17ae <dropshadow+0x61e>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1060 <compositeSourceAtop@plt>
jmp    17c1 <dropshadow+0x631>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1090 <compositeSourceIn@plt>
jmp    1824 <dropshadow+0x694>
cmpl   $0x1,-0x38(%rbp)
jne    17e8 <dropshadow+0x658>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1080 <compositeSourceOut@plt>
jmp    181f <dropshadow+0x68f>
cmpl   $0x1,-0x3c(%rbp)
jne    1807 <dropshadow+0x677>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x44(%rbp),%edx
call   1040 <copyMemory@plt>
jmp    181a <dropshadow+0x68a>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   10b0 <compositeDestinationOver@plt>
jmp    181f <dropshadow+0x68f>
jmp    1824 <dropshadow+0x694>
mov    -0x58(%rbp),%rdi
call   1050 <freeMemory@plt>
add    $0xd8,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<dropshadow>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %ecx,%r13d
mov    %edx,%ebp
movq   %xmm0,0x98(%rsp)
mov    %r9d,0x80(%rsp)
mov    %r8d,0x28(%rsp)
mov    %rdi,%r12
mov    0x100(%rsp),%ecx
mov    0xf8(%rsp),%eax
mov    %eax,0x8c(%rsp)
mov    0xf0(%rsp),%eax
mov    %eax,0x88(%rsp)
mov    0xe8(%rsp),%eax
mov    %eax,0x84(%rsp)
mov    %edx,%r15d
mov    %rsi,0x48(%rsp)
imul   %esi,%r15d
lea    0x0(,%r15,4),%edi
mov    %ecx,0x34(%rsp)
mov    %ecx,%ebx
and    $0x1,%bl
neg    %bl
mov    %edi,0x7c(%rsp)
call   1070 <allocMemory@plt>
mov    %rax,%r14
movzbl %bl,%ebx
mov    %rax,%rdi
mov    %ebx,%esi
mov    %r15,0x20(%rsp)
mov    %r15d,%edx
call   10a0 <clearMemory@plt>
mov    0x28(%rsp),%esi
mov    %r12,0x10(%rsp)
lea    0x3(%r12),%rax
mov    %esi,%ecx
or     %r13d,%ecx
mov    %r14,0x18(%rsp)
mov    %rbp,0xa0(%rsp)
mov    %rbx,0x90(%rsp)
je     1624 <dropshadow+0x494>
mov    %r13d,%ecx
neg    %ecx
cmovns %r13d,%ecx
mov    0x48(%rsp),%rdx
add    %edx,%ecx
mov    %ecx,0xc(%rsp)
mov    %esi,%edi
neg    %edi
cmovns %esi,%edi
add    %ebp,%edi
lea    0x0(,%r13,4),%ecx
movslq %ecx,%rcx
neg    %rcx
xor    %r9d,%r9d
test   %r13d,%r13d
cmovg  %r9,%rcx
cmovle %r9d,%r13d
lea    0x0(,%rdx,4),%r8d
add    %rcx,%rax
lea    (%r14,%r13,1),%r12
mov    %esi,%ebx
imul   %edx,%ebx
lea    0x0(,%rbx,4),%edx
movslq %edx,%rdx
neg    %rdx
test   %esi,%esi
cmovg  %r9,%rdx
cmovle %r9d,%ebx
add    %rdx,%rax
movslq %ebx,%r9
add    %r9,%r12
testb  $0x1,0x34(%rsp)
mov    %edi,0x44(%rsp)
jne    1657 <dropshadow+0x4c7>
test   %edi,%edi
mov    0xc(%rsp),%esi
jle    1bf2 <dropshadow+0xa62>
mov    %edi,%ebx
movslq 0x48(%rsp),%r10
movslq %r8d,%rdi
mov    %rdi,0x28(%rsp)
mov    %esi,%r11d
add    %r13,%r9
lea    (%r9,%r11,1),%rdi
mov    %rdi,0x68(%rsp)
add    %rdx,%rcx
lea    (%rcx,%r11,4),%rdx
mov    %rdx,0x70(%rsp)
mov    %r11d,%edx
and    $0xf,%edx
test   %rdx,%rdx
mov    $0x10,%edi
cmovne %rdx,%rdi
mov    %r11,%r8
mov    %rdi,%rdx
mov    %rdi,0x58(%rsp)
sub    %rdi,%r8
lea    0x0(,%r8,4),%rdx
mov    %rdx,0x50(%rsp)
mov    %r11d,%edi
and    $0x7,%edi
test   %rdi,%rdi
mov    $0x8,%ebp
cmovne %rdi,%rbp
mov    %r11,0x38(%rsp)
sub    %rbp,%r11
lea    0x0(,%r11,4),%rdx
mov    %rdx,0x60(%rsp)
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,1),%r13
add    $0xf,%r13
mov    0x18(%rsp),%rcx
add    %rcx,%r9
add    $0x3,%r9
xor    %r15d,%r15d
jmp    13ae <dropshadow+0x21e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %r10,%r12
mov    0x28(%rsp),%rcx
add    %rcx,%rax
add    $0x1,%r15
add    %rcx,%r13
add    %r10,%r9
cmp    %ebx,%r15d
je     1bf2 <dropshadow+0xa62>
test   %esi,%esi
jle    1390 <dropshadow+0x200>
cmp    $0x9,%esi
jb     13e5 <dropshadow+0x255>
mov    %r15,%rcx
imul   0x28(%rsp),%rcx
add    0x70(%rsp),%rcx
add    0x10(%rsp),%rcx
cmp    %rcx,%r12
jae    13ef <dropshadow+0x25f>
mov    %r15,%rcx
imul   %r10,%rcx
add    0x68(%rsp),%rcx
add    0x18(%rsp),%rcx
cmp    %rcx,%rax
jae    13ef <dropshadow+0x25f>
xor    %ecx,%ecx
xor    %r14d,%r14d
jmp    1580 <dropshadow+0x3f0>
cmp    $0x11,%esi
jae    13fb <dropshadow+0x26b>
xor    %ebp,%ebp
jmp    1500 <dropshadow+0x370>
xor    %ecx,%ecx
nopl   (%rax)
movzbl 0x3c(%rax,%rcx,4),%esi
movd   %esi,%xmm0
movzbl 0x38(%rax,%rcx,4),%esi
movd   %esi,%xmm1
punpcklbw %xmm0,%xmm1
movzbl 0x34(%rax,%rcx,4),%esi
movd   %esi,%xmm0
movzbl 0x30(%rax,%rcx,4),%esi
movd   %esi,%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm1,%xmm2
movzbl 0x2c(%rax,%rcx,4),%esi
movd   %esi,%xmm0
movzbl 0x28(%rax,%rcx,4),%esi
movd   %esi,%xmm1
punpcklbw %xmm0,%xmm1
movzbl 0x24(%rax,%rcx,4),%esi
movd   %esi,%xmm3
movzbl 0x20(%rax,%rcx,4),%esi
movd   %esi,%xmm0
punpcklbw %xmm3,%xmm0
punpcklwd %xmm1,%xmm0
punpckldq %xmm2,%xmm0
movzbl 0x1c(%rax,%rcx,4),%esi
movd   %esi,%xmm1
movzbl 0x18(%rax,%rcx,4),%esi
movd   %esi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x14(%rax,%rcx,4),%esi
movd   %esi,%xmm1
movzbl 0x10(%rax,%rcx,4),%esi
movd   %esi,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl 0xc(%rax,%rcx,4),%esi
movd   %esi,%xmm1
movzbl 0x8(%rax,%rcx,4),%esi
movd   %esi,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x4(%rax,%rcx,4),%esi
movd   %esi,%xmm1
movzbl (%rax,%rcx,4),%esi
movd   %esi,%xmm4
punpcklbw %xmm1,%xmm4
punpcklwd %xmm2,%xmm4
punpckldq %xmm3,%xmm4
punpcklqdq %xmm0,%xmm4
movdqu %xmm4,(%r12,%rcx,1)
add    $0x10,%rcx
cmp    %rcx,%r8
jne    1400 <dropshadow+0x270>
mov    %r8,%rbp
mov    0x50(%rsp),%rcx
mov    %r8,%r14
cmpl   $0x9,0x58(%rsp)
mov    0xc(%rsp),%esi
jb     1580 <dropshadow+0x3f0>
nopl   0x0(%rax,%rax,1)
movzbl -0xc(%r13,%rbp,4),%ecx
movzbl -0x4(%r13,%rbp,4),%esi
movzbl 0x4(%r13,%rbp,4),%edi
movzbl 0xc(%r13,%rbp,4),%ebx
movzbl 0x0(%r13,%rbp,4),%edx
shl    $0x8,%edx
or     %esi,%edx
movzbl -0x8(%r13,%rbp,4),%esi
shl    $0x8,%esi
or     %ecx,%esi
movd   %esi,%xmm0
pinsrw $0x1,%edx,%xmm0
movzbl 0x8(%r13,%rbp,4),%ecx
shl    $0x8,%ecx
or     %edi,%ecx
pinsrw $0x2,%ecx,%xmm0
movzbl 0x10(%r13,%rbp,4),%ecx
shl    $0x8,%ecx
or     %ebx,%ecx
pinsrw $0x3,%ecx,%xmm0
movq   %xmm0,(%r12,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%r11
jne    1500 <dropshadow+0x370>
mov    0x60(%rsp),%rcx
mov    %r11,%r14
mov    0xc(%rsp),%esi
mov    0x44(%rsp),%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %r10,%rdi
mov    0x38(%rsp),%rdx
mov    %edx,%r10d
sub    %r14d,%r10d
mov    %r14,%rbp
not    %rbp
add    %rdx,%rbp
and    $0x3,%r10
je     15c6 <dropshadow+0x436>
shl    $0x2,%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rax,%rcx,1),%edx
mov    %dl,(%r12,%r14,1)
add    $0x1,%r14
add    $0x4,%rcx
add    $0xfffffffffffffffc,%r10
jne    15b0 <dropshadow+0x420>
cmp    $0x3,%rbp
mov    %rdi,%r10
jb     1390 <dropshadow+0x200>
add    %r13,%rcx
mov    0x38(%rsp),%rbp
sub    %r14,%rbp
add    %r9,%r14
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl -0xc(%rcx,%rdi,4),%edx
mov    %dl,-0x3(%r14,%rdi,1)
movzbl -0x8(%rcx,%rdi,4),%edx
mov    %dl,-0x2(%r14,%rdi,1)
movzbl -0x4(%rcx,%rdi,4),%edx
mov    %dl,-0x1(%r14,%rdi,1)
movzbl (%rcx,%rdi,4),%edx
mov    %dl,(%r14,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    15f0 <dropshadow+0x460>
jmp    1390 <dropshadow+0x200>
mov    0x34(%rsp),%ecx
test   $0x1,%cl
jne    1998 <dropshadow+0x808>
cmpl   $0x0,0x20(%rsp)
jle    1bf2 <dropshadow+0xa62>
mov    0x20(%rsp),%rsi
lea    -0x1(%rsi),%ecx
cmp    $0x7,%ecx
jae    19c0 <dropshadow+0x830>
mov    0x18(%rsp),%rcx
jmp    1a13 <dropshadow+0x883>
test   %edi,%edi
mov    0xc(%rsp),%esi
jle    1bf2 <dropshadow+0xa62>
movslq 0x48(%rsp),%rdi
mov    %rdi,0x28(%rsp)
movslq %r8d,%r15
mov    %esi,%r14d
add    %r13,%r9
lea    (%r9,%r14,1),%rdi
mov    %rdi,0x68(%rsp)
add    %rdx,%rcx
lea    (%rcx,%r14,4),%rdx
mov    %rdx,0x70(%rsp)
mov    %r14d,%edx
and    $0xf,%edx
test   %rdx,%rdx
mov    $0x10,%edi
cmovne %rdx,%rdi
mov    %r14,%r11
mov    %rdi,%rdx
mov    %rdi,0x58(%rsp)
sub    %rdi,%r11
lea    0x0(,%r11,4),%rdx
mov    %rdx,0x50(%rsp)
mov    %r14d,%edx
and    $0x7,%edx
test   %rdx,%rdx
mov    $0x8,%edi
cmovne %rdx,%rdi
mov    %r14,0x38(%rsp)
sub    %rdi,%r14
lea    0x0(,%r14,4),%rdx
mov    %rdx,0x60(%rsp)
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,1),%r13
add    $0xf,%r13
mov    0x18(%rsp),%rcx
add    %rcx,%r9
add    $0x3,%r9
xor    %r10d,%r10d
pcmpeqd %xmm0,%xmm0
jmp    1730 <dropshadow+0x5a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
add    %rcx,%r12
add    %r15,%rax
add    $0x1,%r10
add    %r15,%r13
add    %rcx,%r9
cmp    0x44(%rsp),%r10d
je     1bf2 <dropshadow+0xa62>
test   %esi,%esi
jle    1710 <dropshadow+0x580>
cmp    $0x9,%esi
jb     1767 <dropshadow+0x5d7>
mov    %r10,%rcx
imul   %r15,%rcx
add    0x70(%rsp),%rcx
add    0x10(%rsp),%rcx
cmp    %rcx,%r12
jae    1770 <dropshadow+0x5e0>
mov    %r10,%rcx
imul   0x28(%rsp),%rcx
add    0x68(%rsp),%rcx
add    0x18(%rsp),%rcx
cmp    %rcx,%rax
jae    1770 <dropshadow+0x5e0>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1900 <dropshadow+0x770>
cmp    $0x11,%esi
jae    177c <dropshadow+0x5ec>
xor    %edi,%edi
jmp    1880 <dropshadow+0x6f0>
xor    %ecx,%ecx
xchg   %ax,%ax
movzbl 0x3c(%rax,%rcx,4),%edx
movd   %edx,%xmm1
movzbl 0x38(%rax,%rcx,4),%edx
movd   %edx,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x34(%rax,%rcx,4),%edx
movd   %edx,%xmm1
movzbl 0x30(%rax,%rcx,4),%edx
movd   %edx,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl 0x2c(%rax,%rcx,4),%edx
movd   %edx,%xmm1
movzbl 0x28(%rax,%rcx,4),%edx
movd   %edx,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x24(%rax,%rcx,4),%edx
movd   %edx,%xmm4
movzbl 0x20(%rax,%rcx,4),%edx
movd   %edx,%xmm1
punpcklbw %xmm4,%xmm1
punpcklwd %xmm2,%xmm1
punpckldq %xmm3,%xmm1
movzbl 0x1c(%rax,%rcx,4),%edx
movd   %edx,%xmm2
movzbl 0x18(%rax,%rcx,4),%edx
movd   %edx,%xmm3
punpcklbw %xmm2,%xmm3
movzbl 0x14(%rax,%rcx,4),%edx
movd   %edx,%xmm2
movzbl 0x10(%rax,%rcx,4),%edx
movd   %edx,%xmm4
punpcklbw %xmm2,%xmm4
punpcklwd %xmm3,%xmm4
movzbl 0xc(%rax,%rcx,4),%edx
movd   %edx,%xmm2
movzbl 0x8(%rax,%rcx,4),%edx
movd   %edx,%xmm3
punpcklbw %xmm2,%xmm3
movzbl 0x4(%rax,%rcx,4),%edx
movd   %edx,%xmm2
movzbl (%rax,%rcx,4),%edx
movd   %edx,%xmm5
punpcklbw %xmm2,%xmm5
punpcklwd %xmm3,%xmm5
punpckldq %xmm4,%xmm5
punpcklqdq %xmm1,%xmm5
pxor   %xmm0,%xmm5
movdqu %xmm5,(%r12,%rcx,1)
add    $0x10,%rcx
cmp    %rcx,%r11
jne    1780 <dropshadow+0x5f0>
mov    %r11,%rdi
mov    0x50(%rsp),%rcx
mov    %r11,%rdx
cmpl   $0x9,0x58(%rsp)
jb     1900 <dropshadow+0x770>
nopl   0x0(%rax,%rax,1)
movzbl -0xc(%r13,%rdi,4),%ecx
movzbl -0x4(%r13,%rdi,4),%edx
movzbl 0x4(%r13,%rdi,4),%ebp
movzbl 0xc(%r13,%rdi,4),%ebx
movzbl 0x0(%r13,%rdi,4),%esi
shl    $0x8,%esi
or     %edx,%esi
movzbl -0x8(%r13,%rdi,4),%edx
shl    $0x8,%edx
or     %ecx,%edx
movd   %edx,%xmm1
pinsrw $0x1,%esi,%xmm1
movzbl 0x8(%r13,%rdi,4),%ecx
shl    $0x8,%ecx
or     %ebp,%ecx
pinsrw $0x2,%ecx,%xmm1
movzbl 0x10(%r13,%rdi,4),%ecx
shl    $0x8,%ecx
or     %ebx,%ecx
pinsrw $0x3,%ecx,%xmm1
pxor   %xmm0,%xmm1
movq   %xmm1,(%r12,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r14
jne    1880 <dropshadow+0x6f0>
mov    0x60(%rsp),%rcx
mov    %r14,%rdx
mov    0xc(%rsp),%esi
cs nopw 0x0(%rax,%rax,1)
mov    0x38(%rsp),%rbx
mov    %ebx,%r8d
sub    %edx,%r8d
mov    %rdx,%rdi
not    %rdi
add    %rbx,%rdi
and    $0x3,%r8
je     1938 <dropshadow+0x7a8>
shl    $0x2,%r8
xchg   %ax,%ax
movzbl (%rax,%rcx,1),%ebx
not    %bl
mov    %bl,(%r12,%rdx,1)
add    $0x1,%rdx
add    $0x4,%rcx
add    $0xfffffffffffffffc,%r8
jne    1920 <dropshadow+0x790>
cmp    $0x3,%rdi
jb     1710 <dropshadow+0x580>
add    %r13,%rcx
mov    0x38(%rsp),%rdi
sub    %rdx,%rdi
add    %r9,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl -0xc(%rcx,%rbp,4),%ebx
not    %bl
mov    %bl,-0x3(%rdx,%rbp,1)
movzbl -0x8(%rcx,%rbp,4),%ebx
not    %bl
mov    %bl,-0x2(%rdx,%rbp,1)
movzbl -0x4(%rcx,%rbp,4),%ebx
not    %bl
mov    %bl,-0x1(%rdx,%rbp,1)
movzbl (%rcx,%rbp,4),%ebx
not    %bl
mov    %bl,(%rdx,%rbp,1)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    1960 <dropshadow+0x7d0>
jmp    1710 <dropshadow+0x580>
cmpl   $0x0,0x20(%rsp)
jle    1bf2 <dropshadow+0xa62>
mov    0x20(%rsp),%rbx
lea    -0x1(%rbx),%ecx
xor    %edx,%edx
cmp    $0x8,%ecx
jae    1a44 <dropshadow+0x8b4>
mov    0x18(%rsp),%rcx
jmp    1b71 <dropshadow+0x9e1>
mov    %esi,%edx
and    $0xfffffff8,%edx
mov    0x18(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movzbl (%rax),%ebx
mov    %bl,(%rcx)
movzbl 0x4(%rax),%ebx
mov    %bl,0x1(%rcx)
movzbl 0x8(%rax),%ebx
mov    %bl,0x2(%rcx)
movzbl 0xc(%rax),%ebx
mov    %bl,0x3(%rcx)
movzbl 0x10(%rax),%ebx
mov    %bl,0x4(%rcx)
movzbl 0x14(%rax),%ebx
mov    %bl,0x5(%rcx)
movzbl 0x18(%rax),%ebx
mov    %bl,0x6(%rcx)
movzbl 0x1c(%rax),%ebx
mov    %bl,0x7(%rcx)
add    $0x8,%rcx
add    $0x20,%rax
add    $0xfffffff8,%edx
jne    19d0 <dropshadow+0x840>
test   $0x7,%sil
je     1bf2 <dropshadow+0xa62>
mov    0x20(%rsp),%rdx
and    $0x7,%edx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movzbl (%rax,%rsi,4),%ebx
mov    %bl,(%rcx,%rsi,1)
add    $0x1,%rsi
cmp    %esi,%edx
jne    1a30 <dropshadow+0x8a0>
jmp    1bf2 <dropshadow+0xa62>
mov    0x10(%rsp),%rsi
lea    (%rsi,%rcx,4),%rsi
add    $0x4,%rsi
mov    0x18(%rsp),%rbp
cmp    %rsi,%rbp
jae    1a70 <dropshadow+0x8e0>
lea    (%rcx,%rbp,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%rax
jae    1a70 <dropshadow+0x8e0>
mov    %rbp,%rcx
jmp    1b71 <dropshadow+0x9e1>
cmp    $0x10,%ecx
jae    1a7c <dropshadow+0x8ec>
xor    %esi,%esi
jmp    1b07 <dropshadow+0x977>
lea    0x1(%rcx),%rsi
mov    %esi,%edi
and    $0xf,%edi
test   %rdi,%rdi
mov    $0x10,%edx
cmovne %rdi,%rdx
sub    %rdx,%rsi
xor    %edi,%edi
movdqa 0x562(%rip),%xmm0
pcmpeqd %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%rax,%rdi,4),%xmm2
movdqu 0x10(%rax,%rdi,4),%xmm3
movdqu 0x20(%rax,%rdi,4),%xmm4
movdqu 0x30(%rax,%rdi,4),%xmm5
pand   %xmm0,%xmm5
pand   %xmm0,%xmm4
packuswb %xmm5,%xmm4
pand   %xmm0,%xmm3
pand   %xmm0,%xmm2
packuswb %xmm3,%xmm2
packuswb %xmm4,%xmm2
pxor   %xmm1,%xmm2
movdqu %xmm2,0x0(%rbp,%rdi,1)
add    $0x10,%rdi
cmp    %rdi,%rsi
jne    1ab0 <dropshadow+0x920>
cmp    $0x8,%edx
ja     1b07 <dropshadow+0x977>
lea    (%rax,%rsi,4),%rax
lea    (%rsi,%rbp,1),%rcx
mov    %esi,%edx
jmp    1b71 <dropshadow+0x9e1>
add    $0x1,%rcx
mov    %ecx,%edx
and    $0x7,%edx
test   %rdx,%rdx
mov    $0x8,%edi
cmovne %rdx,%rdi
mov    %rcx,%rdx
sub    %rdi,%rdx
lea    (%rdx,%rbp,1),%rcx
lea    (%rax,%rdx,4),%rdi
movdqa 0x4ce(%rip),%xmm0
pcmpeqd %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqu (%rax,%rsi,4),%xmm2
movdqu 0x10(%rax,%rsi,4),%xmm3
pand   %xmm0,%xmm3
pand   %xmm0,%xmm2
packuswb %xmm3,%xmm2
packuswb %xmm2,%xmm2
pxor   %xmm1,%xmm2
movq   %xmm2,0x0(%rbp,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1b40 <dropshadow+0x9b0>
mov    %rdi,%rax
mov    %ebx,%edi
sub    %edx,%edi
mov    %edx,%esi
not    %esi
add    %ebx,%esi
and    $0x3,%edi
je     1ba9 <dropshadow+0xa19>
neg    %edi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rax),%ebx
not    %bl
mov    %bl,(%rcx)
add    $0x1,%rcx
add    $0x4,%rax
add    $0xffffffffffffffff,%rbp
cmp    %ebp,%edi
jne    1b90 <dropshadow+0xa00>
sub    %ebp,%edx
cmp    $0x3,%esi
jb     1bf2 <dropshadow+0xa62>
mov    0x20(%rsp),%rsi
sub    %edx,%esi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzbl (%rax,%rdx,4),%ebx
not    %bl
mov    %bl,(%rcx,%rdx,1)
movzbl 0x4(%rax,%rdx,4),%ebx
not    %bl
mov    %bl,0x1(%rcx,%rdx,1)
movzbl 0x8(%rax,%rdx,4),%ebx
not    %bl
mov    %bl,0x2(%rcx,%rdx,1)
movzbl 0xc(%rax,%rdx,4),%ebx
not    %bl
mov    %bl,0x3(%rcx,%rdx,1)
add    $0x4,%rdx
cmp    %edx,%esi
jne    1bc0 <dropshadow+0xa30>
sub    $0x8,%rsp
mov    0x20(%rsp),%rbx
mov    %rbx,%rdi
mov    0x50(%rsp),%r15
mov    %r15d,%esi
mov    0xa8(%rsp),%r14
mov    %r14d,%edx
mov    0x8c(%rsp),%ecx
mov    0x90(%rsp),%r8d
mov    0x94(%rsp),%r9d
push   %r14
push   %r15
push   $0x0
push   $0x0
push   0xb8(%rsp)
call   1030 <blurAlpha@plt>
add    $0x30,%rsp
movslq 0x20(%rsp),%rax
lea    (%rbx,%rax,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %rbx,%rcx
movsd  0x98(%rsp),%xmm5
jae    1c92 <dropshadow+0xb02>
mov    0x34(%rsp),%ecx
test   $0x1,%cl
jne    1daf <dropshadow+0xc1f>
test   $0x2,%cl
jne    1dd2 <dropshadow+0xc42>
test   $0x4,%cl
jne    1dfc <dropshadow+0xc6c>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   10b0 <compositeDestinationOver@plt>
jmp    1e0d <dropshadow+0xc7d>
mov    0x80(%rsp),%edx
mov    %edx,%ecx
shr    $0x10,%ecx
movzbl %cl,%edi
movzbl %dh,%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movzbl %dl,%esi
xorps  %xmm1,%xmm1
cvtsi2ss %esi,%xmm1
shl    $0x8,%ecx
or     %edi,%ecx
shl    $0x10,%esi
add    %esi,%ecx
add    $0xff000000,%ecx
xorps  %xmm2,%xmm2
cvtsi2ss %edi,%xmm2
add    $0xffffffffffffffff,%rax
movsd  0x358(%rip),%xmm3
movdqa 0x32f(%rip),%xmm8
movapd 0x336(%rip),%xmm9
movsd  0x346(%rip),%xmm6
jmp    1d6d <dropshadow+0xbdd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   %rdx,%xmm4
punpckldq %xmm8,%xmm4
subpd  %xmm9,%xmm4
movapd %xmm4,%xmm7
unpckhpd %xmm4,%xmm7
addsd  %xmm4,%xmm7
divsd  %xmm6,%xmm7
xorps  %xmm4,%xmm4
cvtsd2ss %xmm7,%xmm4
movaps %xmm2,%xmm7
mulss  %xmm4,%xmm7
cvttss2si %xmm7,%esi
movaps %xmm0,%xmm7
mulss  %xmm4,%xmm7
cvttss2si %xmm7,%edi
shl    $0x8,%edi
mulss  %xmm1,%xmm4
cvttss2si %xmm4,%ebp
shl    $0x10,%ebp
shl    $0x18,%edx
or     %esi,%edx
or     %edi,%edx
or     %ebp,%edx
mov    %edx,%esi
mov    %esi,(%rbx,%rax,4)
lea    (%rbx,%rax,1),%rdx
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rax
cmp    %rbx,%rdx
jb     1c5b <dropshadow+0xacb>
movzbl (%rbx,%rax,1),%edx
xorps  %xmm7,%xmm7
cvtsi2sd %edx,%xmm7
mulsd  %xmm5,%xmm7
cvttsd2si %xmm7,%rsi
mov    %rsi,%rdi
subsd  %xmm3,%xmm7
cvttsd2si %xmm7,%rdx
sar    $0x3f,%rdi
and    %rdi,%rdx
or     %rsi,%rdx
mov    %ecx,%esi
cmp    $0xfe,%rdx
ja     1d55 <dropshadow+0xbc5>
test   %rdx,%rdx
jne    1d00 <dropshadow+0xb70>
xor    %esi,%esi
jmp    1d55 <dropshadow+0xbc5>
mov    %ecx,%eax
shr    %eax
shr    $0x2,%ecx
or     %eax,%ecx
test   $0x1,%cl
jne    1de7 <dropshadow+0xc57>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1060 <compositeSourceAtop@plt>
jmp    1e0d <dropshadow+0xc7d>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1080 <compositeSourceOut@plt>
jmp    1e0d <dropshadow+0xc7d>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
mov    %r14d,%ecx
call   1090 <compositeSourceIn@plt>
jmp    1e0d <dropshadow+0xc7d>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    0x7c(%rsp),%edx
call   1040 <copyMemory@plt>
mov    %rbx,%rdi
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <freeMemory@plt>

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

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