#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 abs(int);
int /*<<< orphan*/ blurAlpha(unsigned char *, int, int, int, int, int,
                             unsigned char, int /*<<< orphan*/,
                             int /*<<< orphan*/, int, 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*/ free(unsigned char *);
unsigned char *malloc(int);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
int /*<<< orphan*/ memset(unsigned char *, unsigned char, int);
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 = malloc(size4);
  memset(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 - abs(dx);
    int h = height - abs(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) {
      memcpy(img, tmp, size4);
    } else {
      compositeDestinationOver(img, tmp, width, height);
    }
  }
  free(tmp);
}


x86 assembly (clang, -O0):
<dropshadow>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0xc8,%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   10a0 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x49(%rbp),%al
mov    -0x40(%rbp),%edx
movzbl %al,%esi
call   1070 <memset@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    130d <dropshadow+0x16d>
cmpl   $0x0,-0x20(%rbp)
jne    130d <dropshadow+0x16d>
cmpl   $0x1,-0x34(%rbp)
jne    12bf <dropshadow+0x11f>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    12ba <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    1273 <dropshadow+0xd3>
jmp    1308 <dropshadow+0x168>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1303 <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    12c6 <dropshadow+0x126>
jmp    1308 <dropshadow+0x168>
jmp    1503 <dropshadow+0x363>
mov    -0x14(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x1c(%rbp),%edi
call   1050 <abs@plt>
mov    %eax,%ecx
mov    -0xa8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x20(%rbp),%edi
call   1050 <abs@plt>
mov    %eax,%ecx
mov    -0xa4(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x74(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    1372 <dropshadow+0x1d2>
mov    -0x1c(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    138b <dropshadow+0x1eb>
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    13af <dropshadow+0x20f>
mov    -0x20(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    13cc <dropshadow+0x22c>
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    146f <dropshadow+0x2cf>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    146a <dropshadow+0x2ca>
movl   $0x0,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    143a <dropshadow+0x29a>
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    13f7 <dropshadow+0x257>
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    13dd <dropshadow+0x23d>
jmp    14fe <dropshadow+0x35e>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    14f9 <dropshadow+0x359>
movl   $0x0,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    14c9 <dropshadow+0x329>
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    1490 <dropshadow+0x2f0>
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    1476 <dropshadow+0x2d6>
jmp    14fe <dropshadow+0x35e>
jmp    1503 <dropshadow+0x363>
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   1040 <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     174a <dropshadow+0x5aa>
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  0x9f1(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rcx
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x98(%rbp)
cmpq   $0xff,-0x98(%rbp)
jb     1658 <dropshadow+0x4b8>
mov    -0x88(%rbp),%ecx
mov    -0xa0(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0xa0(%rbp)
mov    %ecx,(%rax)
jmp    1745 <dropshadow+0x5a5>
cmpq   $0x0,-0x98(%rbp)
jbe    1725 <dropshadow+0x585>
movaps 0x9a3(%rip),%xmm1
movq   -0x98(%rbp),%xmm0
ff
punpckldq %xmm1,%xmm0
movapd 0x99f(%rip),%xmm1
subpd  %xmm1,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x970(%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    1740 <dropshadow+0x5a0>
mov    -0xa0(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0xa0(%rbp)
movl   $0x0,(%rax)
jmp    1745 <dropshadow+0x5a5>
jmp    15ce <dropshadow+0x42e>
cmpl   $0x1,-0x34(%rbp)
jne    1798 <dropshadow+0x5f8>
cmpl   $0x0,-0x38(%rbp)
jne    1780 <dropshadow+0x5e0>
cmpl   $0x0,-0x3c(%rbp)
jne    1780 <dropshadow+0x5e0>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1060 <compositeSourceAtop@plt>
jmp    1793 <dropshadow+0x5f3>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   10b0 <compositeSourceIn@plt>
jmp    17f6 <dropshadow+0x656>
cmpl   $0x1,-0x38(%rbp)
jne    17ba <dropshadow+0x61a>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1090 <compositeSourceOut@plt>
jmp    17f1 <dropshadow+0x651>
cmpl   $0x1,-0x3c(%rbp)
jne    17d9 <dropshadow+0x639>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x44(%rbp),%edx
call   1080 <memcpy@plt>
jmp    17ec <dropshadow+0x64c>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   10c0 <compositeDestinationOver@plt>
jmp    17f1 <dropshadow+0x651>
jmp    17f6 <dropshadow+0x656>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
add    $0xc8,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<dropshadow>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %ecx,%r12d
mov    %edx,%r13d
movq   %xmm0,0x78(%rsp)
mov    %r9d,0x58(%rsp)
mov    %r8d,0x18(%rsp)
mov    %rdi,0x10(%rsp)
mov    0xe0(%rsp),%ecx
mov    0xd8(%rsp),%eax
mov    %eax,0x64(%rsp)
mov    0xd0(%rsp),%eax
mov    %eax,0x60(%rsp)
mov    0xc8(%rsp),%eax
mov    %eax,0x5c(%rsp)
mov    %edx,%ebp
mov    %rsi,0x28(%rsp)
imul   %esi,%ebp
lea    0x0(,%rbp,4),%edi
mov    %ecx,0x4(%rsp)
mov    %ecx,%ebx
and    $0x1,%bl
neg    %bl
mov    %edi,0x54(%rsp)
call   1090 <malloc@plt>
mov    %rax,%r14
movzbl %bl,%r15d
mov    %rax,%rdi
mov    %r15d,%esi
mov    %rbp,0x8(%rsp)
mov    %ebp,%edx
call   1060 <memset@plt>
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%ebx
mov    %ebx,%eax
or     %r12d,%eax
mov    %r13,0x80(%rsp)
mov    %r15,0x70(%rsp)
je     1515 <dropshadow+0x385>
mov    %r12d,%ebp
neg    %ebp
cmovns %r12d,%ebp
mov    0x28(%rsp),%rdi
add    %edi,%ebp
mov    %ebx,%esi
neg    %esi
cmovns %ebx,%esi
add    %r13d,%esi
lea    0x0(,%r12,4),%eax
movslq %eax,%r8
neg    %r8
xor    %eax,%eax
test   %r12d,%r12d
cmovg  %rax,%r8
cmovle %eax,%r12d
add    %r14,%r12
mov    %ebx,%ecx
imul   %edi,%ecx
lea    0x0(,%rcx,4),%edx
movslq %edx,%rdx
neg    %rdx
test   %ebx,%ebx
cmovg  %rax,%rdx
cmovle %eax,%ecx
lea    0x0(,%rdi,4),%eax
movslq %ecx,%r15
add    %r12,%r15
mov    0x4(%rsp),%ecx
test   $0x1,%cl
mov    %ebp,0x24(%rsp)
jne    1548 <dropshadow+0x3b8>
test   %esi,%esi
jle    1991 <dropshadow+0x801>
mov    %esi,%r13d
movslq 0x28(%rsp),%rcx
mov    %rcx,0x18(%rsp)
movslq %eax,%r12
mov    %ebp,%r9d
mov    %r9d,%eax
and    $0xf,%eax
test   %rax,%rax
mov    $0x10,%ecx
cmovne %rax,%rcx
mov    %r9,%r10
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
sub    %rcx,%r10
lea    0x0(,%r10,4),%rax
mov    %rax,0x30(%rsp)
mov    %r9d,%eax
and    $0x7,%eax
test   %rax,%rax
mov    $0x8,%ecx
cmovne %rax,%rcx
mov    %r9,0x48(%rsp)
sub    %rcx,%r9
lea    0x0(,%r9,4),%rax
mov    %rax,0x40(%rsp)
add    %r8,%rdx
mov    0x10(%rsp),%rax
lea    (%rax,%rdx,1),%rsi
add    $0xf,%rsi
lea    (%rax,%rdx,1),%r11
add    $0x3,%r11
xor    %r8d,%r8d
jmp    1358 <dropshadow+0x1c8>
add    0x18(%rsp),%r15
add    %r12,%r11
add    $0x1,%r8d
add    %r12,%rsi
cmp    %r13d,%r8d
je     1991 <dropshadow+0x801>
test   %ebp,%ebp
jle    1340 <dropshadow+0x1b0>
cmp    $0x9,%ebp
jae    1370 <dropshadow+0x1e0>
xor    %eax,%eax
xor    %ecx,%ecx
jmp    14e9 <dropshadow+0x359>
nopw   0x0(%rax,%rax,1)
xor    %edi,%edi
cmp    $0x11,%ebp
jb     1480 <dropshadow+0x2f0>
nopl   0x0(%rax,%rax,1)
movzbl 0x3c(%r11,%rdi,4),%eax
movd   %eax,%xmm0
movzbl 0x38(%r11,%rdi,4),%eax
movd   %eax,%xmm1
punpcklbw %xmm0,%xmm1
movzbl 0x34(%r11,%rdi,4),%eax
movd   %eax,%xmm0
movzbl 0x30(%r11,%rdi,4),%eax
movd   %eax,%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm1,%xmm2
movzbl 0x2c(%r11,%rdi,4),%eax
movd   %eax,%xmm0
movzbl 0x28(%r11,%rdi,4),%eax
movd   %eax,%xmm1
punpcklbw %xmm0,%xmm1
movzbl 0x24(%r11,%rdi,4),%eax
movd   %eax,%xmm3
movzbl 0x20(%r11,%rdi,4),%eax
movd   %eax,%xmm0
punpcklbw %xmm3,%xmm0
punpcklwd %xmm1,%xmm0
punpckldq %xmm2,%xmm0
movzbl 0x1c(%r11,%rdi,4),%eax
movd   %eax,%xmm1
movzbl 0x18(%r11,%rdi,4),%eax
movd   %eax,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x14(%r11,%rdi,4),%eax
movd   %eax,%xmm1
movzbl 0x10(%r11,%rdi,4),%eax
movd   %eax,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl 0xc(%r11,%rdi,4),%eax
movd   %eax,%xmm1
movzbl 0x8(%r11,%rdi,4),%eax
movd   %eax,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x4(%r11,%rdi,4),%eax
movd   %eax,%xmm1
movzbl (%r11,%rdi,4),%eax
movd   %eax,%xmm4
punpcklbw %xmm1,%xmm4
punpcklwd %xmm2,%xmm4
punpckldq %xmm3,%xmm4
punpcklqdq %xmm0,%xmm4
movdqu %xmm4,(%r15,%rdi,1)
add    $0x10,%rdi
cmp    %rdi,%r10
jne    1380 <dropshadow+0x1f0>
mov    %r10,%rdi
mov    0x30(%rsp),%rax
mov    %r10,%rcx
cmpl   $0x9,0x38(%rsp)
jb     14e9 <dropshadow+0x359>
movzbl -0xc(%rsi,%rdi,4),%eax
movzbl -0x4(%rsi,%rdi,4),%ecx
movzbl 0x4(%rsi,%rdi,4),%edx
movzbl 0xc(%rsi,%rdi,4),%ebx
movzbl (%rsi,%rdi,4),%ebp
shl    $0x8,%ebp
or     %ecx,%ebp
movzbl -0x8(%rsi,%rdi,4),%ecx
shl    $0x8,%ecx
or     %eax,%ecx
movd   %ecx,%xmm0
pinsrw $0x1,%ebp,%xmm0
movzbl 0x8(%rsi,%rdi,4),%eax
shl    $0x8,%eax
or     %edx,%eax
pinsrw $0x2,%eax,%xmm0
movzbl 0x10(%rsi,%rdi,4),%eax
shl    $0x8,%eax
or     %ebx,%eax
pinsrw $0x3,%eax,%xmm0
movq   %xmm0,(%r15,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r9
jne    1480 <dropshadow+0x2f0>
mov    0x40(%rsp),%rax
mov    %r9,%rcx
mov    0x24(%rsp),%ebp
add    %r11,%rax
lea    (%r15,%rcx,1),%rdi
mov    0x48(%rsp),%rbx
sub    %rcx,%rbx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movzbl (%rax,%rcx,4),%edx
mov    %dl,(%rdi,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1500 <dropshadow+0x370>
jmp    1340 <dropshadow+0x1b0>
lea    0x3(%rcx),%rax
testb  $0x1,0x4(%rsp)
jne    17c9 <dropshadow+0x639>
cmpl   $0x0,0x8(%rsp)
jle    1991 <dropshadow+0x801>
mov    0x8(%rsp),%rsi
lea    -0x1(%rsi),%ecx
cmp    $0x7,%ecx
jae    17f2 <dropshadow+0x662>
mov    %r14,%rcx
jmp    1843 <dropshadow+0x6b3>
mov    %esi,0x18(%rsp)
test   %esi,%esi
jle    1991 <dropshadow+0x801>
movslq 0x28(%rsp),%rcx
mov    %rcx,0x48(%rsp)
movslq %eax,%r12
mov    %ebp,%r11d
mov    %r11d,%eax
and    $0xf,%eax
test   %rax,%rax
mov    $0x10,%ecx
cmovne %rax,%rcx
mov    %r11,%r10
mov    %rcx,%rax
mov    %rcx,0x30(%rsp)
sub    %rcx,%r10
mov    %r11d,%eax
and    $0x7,%eax
test   %rax,%rax
mov    $0x8,%ecx
cmovne %rax,%rcx
lea    0x0(,%r10,4),%rax
mov    %rax,0x68(%rsp)
mov    %r11,0x40(%rsp)
sub    %rcx,%r11
lea    0x0(,%r11,4),%rax
mov    %rax,0x38(%rsp)
add    %r8,%rdx
mov    0x10(%rsp),%rax
lea    (%rax,%rdx,1),%rcx
add    $0xf,%rcx
lea    (%rax,%rdx,1),%r13
add    $0x3,%r13
xor    %r8d,%r8d
pcmpeqd %xmm0,%xmm0
jmp    15fa <dropshadow+0x46a>
nopl   0x0(%rax)
add    0x48(%rsp),%r15
add    %r12,%r13
add    $0x1,%r8d
add    %r12,%rcx
cmp    0x18(%rsp),%r8d
je     1991 <dropshadow+0x801>
test   %ebp,%ebp
jle    15e0 <dropshadow+0x450>
cmp    $0x9,%ebp
jae    1610 <dropshadow+0x480>
xor    %eax,%eax
xor    %esi,%esi
jmp    179d <dropshadow+0x60d>
nopl   0x0(%rax)
xor    %edi,%edi
cmp    $0x11,%ebp
jb     1730 <dropshadow+0x5a0>
nopl   0x0(%rax,%rax,1)
movzbl 0x3c(%r13,%rdi,4),%eax
movd   %eax,%xmm1
movzbl 0x38(%r13,%rdi,4),%eax
movd   %eax,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x34(%r13,%rdi,4),%eax
movd   %eax,%xmm1
movzbl 0x30(%r13,%rdi,4),%eax
movd   %eax,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl 0x2c(%r13,%rdi,4),%eax
movd   %eax,%xmm1
movzbl 0x28(%r13,%rdi,4),%eax
movd   %eax,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x24(%r13,%rdi,4),%eax
movd   %eax,%xmm4
movzbl 0x20(%r13,%rdi,4),%eax
movd   %eax,%xmm1
punpcklbw %xmm4,%xmm1
punpcklwd %xmm2,%xmm1
punpckldq %xmm3,%xmm1
movzbl 0x1c(%r13,%rdi,4),%eax
movd   %eax,%xmm2
movzbl 0x18(%r13,%rdi,4),%eax
movd   %eax,%xmm3
punpcklbw %xmm2,%xmm3
movzbl 0x14(%r13,%rdi,4),%eax
movd   %eax,%xmm2
movzbl 0x10(%r13,%rdi,4),%eax
movd   %eax,%xmm4
punpcklbw %xmm2,%xmm4
punpcklwd %xmm3,%xmm4
movzbl 0xc(%r13,%rdi,4),%eax
movd   %eax,%xmm2
movzbl 0x8(%r13,%rdi,4),%eax
movd   %eax,%xmm3
punpcklbw %xmm2,%xmm3
movzbl 0x4(%r13,%rdi,4),%eax
movd   %eax,%xmm2
movzbl 0x0(%r13,%rdi,4),%eax
movd   %eax,%xmm5
punpcklbw %xmm2,%xmm5
punpcklwd %xmm3,%xmm5
punpckldq %xmm4,%xmm5
punpcklqdq %xmm1,%xmm5
pxor   %xmm0,%xmm5
movdqu %xmm5,(%r15,%rdi,1)
add    $0x10,%rdi
cmp    %rdi,%r10
jne    1620 <dropshadow+0x490>
mov    %r10,%rdi
mov    0x68(%rsp),%rax
mov    %r10,%rsi
cmpl   $0x9,0x30(%rsp)
jb     179d <dropshadow+0x60d>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0xc(%rcx,%rdi,4),%eax
movzbl -0x4(%rcx,%rdi,4),%esi
movzbl 0x4(%rcx,%rdi,4),%ebx
movzbl 0xc(%rcx,%rdi,4),%ebp
movzbl (%rcx,%rdi,4),%edx
shl    $0x8,%edx
or     %esi,%edx
movzbl -0x8(%rcx,%rdi,4),%esi
shl    $0x8,%esi
or     %eax,%esi
movd   %esi,%xmm1
pinsrw $0x1,%edx,%xmm1
movzbl 0x8(%rcx,%rdi,4),%eax
shl    $0x8,%eax
or     %ebx,%eax
pinsrw $0x2,%eax,%xmm1
movzbl 0x10(%rcx,%rdi,4),%eax
shl    $0x8,%eax
or     %ebp,%eax
pinsrw $0x3,%eax,%xmm1
pxor   %xmm0,%xmm1
movq   %xmm1,(%r15,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r11
jne    1730 <dropshadow+0x5a0>
mov    0x38(%rsp),%rax
mov    %r11,%rsi
mov    0x24(%rsp),%ebp
add    %r13,%rax
lea    (%r15,%rsi,1),%rdi
mov    0x40(%rsp),%rbx
sub    %rsi,%rbx
xor    %r9d,%r9d
nop
movzbl (%rax,%r9,4),%edx
not    %dl
mov    %dl,(%rdi,%r9,1)
add    $0x1,%r9
cmp    %r9,%rbx
jne    17b0 <dropshadow+0x620>
jmp    15e0 <dropshadow+0x450>
cmpl   $0x0,0x8(%rsp)
jle    1991 <dropshadow+0x801>
mov    0x8(%rsp),%rbx
lea    -0x1(%rbx),%edx
xor    %edi,%edi
cmp    $0x8,%edx
jae    1874 <dropshadow+0x6e4>
mov    %r14,%rdx
mov    %rax,%rsi
jmp    196e <dropshadow+0x7de>
mov    %esi,%edx
and    $0xfffffff8,%edx
mov    %r14,%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    1800 <dropshadow+0x670>
test   $0x7,%sil
je     1991 <dropshadow+0x801>
mov    0x8(%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    1860 <dropshadow+0x6d0>
jmp    1991 <dropshadow+0x801>
cmp    $0x10,%edx
jae    1880 <dropshadow+0x6f0>
xor    %ecx,%ecx
jmp    1907 <dropshadow+0x777>
lea    0x1(%rdx),%rcx
mov    %ecx,%edi
and    $0xf,%edi
test   %rdi,%rdi
mov    $0x10,%esi
cmovne %rdi,%rsi
sub    %rsi,%rcx
xor    %edi,%edi
movdqa 0x75e(%rip),%xmm0
pcmpeqd %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
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,(%r14,%rdi,1)
add    $0x10,%rdi
cmp    %rdi,%rcx
jne    18b0 <dropshadow+0x720>
cmp    $0x8,%esi
ja     1907 <dropshadow+0x777>
lea    (%rax,%rcx,4),%rsi
lea    (%r14,%rcx,1),%rdx
mov    %ecx,%edi
jmp    196e <dropshadow+0x7de>
add    $0x1,%rdx
mov    %edx,%esi
and    $0x7,%esi
test   %rsi,%rsi
mov    $0x8,%ebp
cmovne %rsi,%rbp
mov    %rdx,%rdi
sub    %rbp,%rdi
lea    (%r14,%rdi,1),%rdx
lea    (%rax,%rdi,4),%rsi
movdqa 0x6ce(%rip),%xmm0
pcmpeqd %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqu (%rax,%rcx,4),%xmm2
movdqu 0x10(%rax,%rcx,4),%xmm3
pand   %xmm0,%xmm3
pand   %xmm0,%xmm2
packuswb %xmm3,%xmm2
packuswb %xmm2,%xmm2
pxor   %xmm1,%xmm2
movq   %xmm2,(%r14,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdi
jne    1940 <dropshadow+0x7b0>
mov    %ebx,%eax
sub    %edi,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rsi,%rcx,4),%ebx
not    %bl
mov    %bl,(%rdx,%rcx,1)
add    $0x1,%rcx
cmp    %ecx,%eax
jne    1980 <dropshadow+0x7f0>
sub    $0x8,%rsp
mov    %r14,%rdi
mov    0x30(%rsp),%r12
mov    %r12d,%esi
mov    0x88(%rsp),%r15
mov    %r15d,%edx
mov    0x64(%rsp),%ecx
mov    0x68(%rsp),%r8d
mov    0x6c(%rsp),%r9d
push   %r15
push   %r12
push   $0x0
push   $0x0
push   0x98(%rsp)
call   1040 <blurAlpha@plt>
add    $0x30,%rsp
movslq 0x8(%rsp),%rax
lea    (%r14,%rax,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %r14,%rcx
movsd  0x78(%rsp),%xmm5
jae    1a20 <dropshadow+0x890>
mov    0x4(%rsp),%ecx
test   $0x1,%cl
jne    1b31 <dropshadow+0x9a1>
test   $0x2,%cl
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
jne    1b54 <dropshadow+0x9c4>
test   $0x4,%cl
jne    1b76 <dropshadow+0x9e6>
mov    %r12d,%edx
mov    %r15d,%ecx
call   10b0 <compositeDestinationOver@plt>
jmp    1b7f <dropshadow+0x9ef>
mov    0x58(%rsp),%ebx
mov    %ebx,%ecx
shr    $0x10,%ecx
movzbl %cl,%edx
movzbl %bh,%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movzbl %bl,%esi
xorps  %xmm1,%xmm1
cvtsi2ss %esi,%xmm1
shl    $0x8,%ecx
or     %edx,%ecx
shl    $0x10,%esi
add    %esi,%ecx
add    $0xff000000,%ecx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
add    $0xffffffffffffffff,%rax
movsd  0x5cd(%rip),%xmm3
movdqa 0x5a4(%rip),%xmm8
movapd 0x5ab(%rip),%xmm9
movsd  0x5bb(%rip),%xmm6
jmp    1aee <dropshadow+0x95e>
nop
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,(%r14,%rax,4)
lea    (%r14,%rax,1),%rdx
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rax
cmp    %r14,%rdx
jb     19e9 <dropshadow+0x859>
movzbl (%r14,%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     1ad5 <dropshadow+0x945>
test   %rdx,%rdx
jne    1a80 <dropshadow+0x8f0>
xor    %esi,%esi
jmp    1ad5 <dropshadow+0x945>
mov    %ecx,%eax
shr    %eax
shr    $0x2,%ecx
or     %eax,%ecx
test   $0x1,%cl
jne    1b61 <dropshadow+0x9d1>
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
mov    %r12d,%edx
mov    %r15d,%ecx
call   1050 <compositeSourceAtop@plt>
jmp    1b7f <dropshadow+0x9ef>
mov    %r12d,%edx
mov    %r15d,%ecx
call   1080 <compositeSourceOut@plt>
jmp    1b7f <dropshadow+0x9ef>
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
mov    %r12d,%edx
mov    %r15d,%ecx
call   10a0 <compositeSourceIn@plt>
jmp    1b7f <dropshadow+0x9ef>
mov    0x54(%rsp),%edx
call   1070 <memcpy@plt>
mov    %r14,%rdi
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@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* @malloc(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 @memset(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 %246
119: ; preds = %77, %12
%120 = load i32, i32* %14
%121 = load i32, i32* %16
%122 = call i32 @abs(i32 %121)
%123 = sub nsw i32 %120, %122
store i32 %123, i32* %35
%124 = load i32, i32* %15
%125 = load i32, i32* %17
%126 = call i32 @abs(i32 %125)
%127 = sub nsw i32 %124, %126
store i32 %127, i32* %36
%128 = load i32, i32* %14
%129 = shl i32 %128, 2
store i32 %129, i32* %37
%130 = load i32, i32* %16
%131 = icmp sgt i32 %130, 0
br i1 %131, label %132, label %137
132: ; preds = %119
%133 = load i32, i32* %16
%134 = load i8*, i8** %33
%135 = sext i32 %133 to i64
%136 = getelementptr inbounds i8, i8* %134, i64 %135
store i8* %136, i8** %33
br label %144
137: ; preds = %119
%138 = load i32, i32* %16
%139 = mul nsw i32 %138, 4
%140 = load i8*, i8** %34
%141 = sext i32 %139 to i64
%142 = sub i64 0, %141
%143 = getelementptr inbounds i8, i8* %140, i64 %142
store i8* %143, i8** %34
br label %144
144: ; preds = %137, %132
%145 = load i32, i32* %17
%146 = icmp sgt i32 %145, 0
br i1 %146, label %147, label %154
147: ; preds = %144
%148 = load i32, i32* %17
%149 = load i32, i32* %14
%150 = mul nsw i32 %148, %149
%151 = load i8*, i8** %33
%152 = sext i32 %150 to i64
%153 = getelementptr inbounds i8, i8* %151, i64 %152
store i8* %153, i8** %33
br label %163
154: ; preds = %144
%155 = load i32, i32* %17
%156 = load i32, i32* %14
%157 = mul nsw i32 %155, %156
%158 = mul nsw i32 %157, 4
%159 = load i8*, i8** %34
%160 = sext i32 %158 to i64
%161 = sub i64 0, %160
%162 = getelementptr inbounds i8, i8* %159, i64 %161
store i8* %162, i8** %34
br label %163
163: ; preds = %154, %147
%164 = load i32, i32* %25
%165 = icmp eq i32 %164, 1
br i1 %165, label %166, label %207
166: ; preds = %163
store i32 0, i32* %40
br label %167
167: ; preds = %203, %166
%168 = load i32, i32* %40
%169 = load i32, i32* %36
%170 = icmp slt i32 %168, %169
br i1 %170, label %171, label %206
171: ; preds = %167
store i32 0, i32* %38
store i32 0, i32* %39
br label %172
172: ; preds = %189, %171
%173 = load i32, i32* %38
%174 = load i32, i32* %35
%175 = icmp slt i32 %173, %174
br i1 %175, label %176, label %194
176: ; preds = %172
%177 = load i8*, i8** %34
%178 = load i32, i32* %39
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i8, i8* %177, i64 %179
%181 = load i8, i8* %180
%182 = zext i8 %181 to i32
%183 = sub nsw i32 255, %182
%184 = trunc i32 %183 to i8
%185 = load i8*, i8** %33
%186 = load i32, i32* %38
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i8, i8* %185, i64 %187
store i8 %184, i8* %188
br label %189
189: ; preds = %176
%190 = load i32, i32* %38
%191 = add nsw i32 %190, 1
store i32 %191, i32* %38
%192 = load i32, i32* %39
%193 = add nsw i32 %192, 4
store i32 %193, i32* %39
br label %172
194: ; preds = %172
%195 = load i32, i32* %14
%196 = load i8*, i8** %33
%197 = sext i32 %195 to i64
%198 = getelementptr inbounds i8, i8* %196, i64 %197
store i8* %198, i8** %33
%199 = load i32, i32* %37
%200 = load i8*, i8** %34
%201 = sext i32 %199 to i64
%202 = getelementptr inbounds i8, i8* %200, i64 %201
store i8* %202, i8** %34
br label %203
203: ; preds = %194
%204 = load i32, i32* %40
%205 = add nsw i32 %204, 1
store i32 %205, i32* %40
br label %167
206: ; preds = %167
br label %245
207: ; preds = %163
store i32 0, i32* %40
br label %208
208: ; preds = %241, %207
%209 = load i32, i32* %40
%210 = load i32, i32* %36
%211 = icmp slt i32 %209, %210
br i1 %211, label %212, label %244
212: ; preds = %208
store i32 0, i32* %38
store i32 0, i32* %39
br label %213
213: ; preds = %227, %212
%214 = load i32, i32* %38
%215 = load i32, i32* %35
%216 = icmp slt i32 %214, %215
br i1 %216, label %217, label %232
217: ; preds = %213
%218 = load i8*, i8** %34
%219 = load i32, i32* %39
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i8, i8* %218, i64 %220
%222 = load i8, i8* %221
%223 = load i8*, i8** %33
%224 = load i32, i32* %38
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds i8, i8* %223, i64 %225
store i8 %222, i8* %226
br label %227
227: ; preds = %217
%228 = load i32, i32* %38
%229 = add nsw i32 %228, 1
store i32 %229, i32* %38
%230 = load i32, i32* %39
%231 = add nsw i32 %230, 4
store i32 %231, i32* %39
br label %213
232: ; preds = %213
%233 = load i32, i32* %14
%234 = load i8*, i8** %33
%235 = sext i32 %233 to i64
%236 = getelementptr inbounds i8, i8* %234, i64 %235
store i8* %236, i8** %33
%237 = load i32, i32* %37
%238 = load i8*, i8** %34
%239 = sext i32 %237 to i64
%240 = getelementptr inbounds i8, i8* %238, i64 %239
store i8* %240, i8** %34
br label %241
241: ; preds = %232
%242 = load i32, i32* %40
%243 = add nsw i32 %242, 1
store i32 %243, i32* %40
br label %208
244: ; preds = %208
br label %245
245: ; preds = %244, %206
br label %246
246: ; preds = %245, %118
%247 = load i8*, i8** %32
%248 = load i32, i32* %14
%249 = load i32, i32* %15
%250 = load i32, i32* %20
%251 = load i32, i32* %21
%252 = load i32, i32* %23
%253 = load i8, i8* %31
%254 = load i32, i32* %14
%255 = load i32, i32* %15
%256 = call i32 @blurAlpha(i8* %247, i32 %248, i32 %249, i32 %250, i32 %251, i32 %252, i8 zeroext %253, i32 0, i32 0, i32 %254, i32 %255)
%257 = load i32, i32* %18
%258 = lshr i32 %257, 16
%259 = and i32 %258, 255
%260 = trunc i32 %259 to i8
store i8 %260, i8* %41
%261 = load i32, i32* %18
%262 = lshr i32 %261, 8
%263 = and i32 %262, 255
%264 = trunc i32 %263 to i8
store i8 %264, i8* %42
%265 = load i32, i32* %18
%266 = and i32 %265, 255
%267 = trunc i32 %266 to i8
store i8 %267, i8* %43
%268 = load i8, i8* %41
%269 = zext i8 %268 to i32
%270 = load i8, i8* %42
%271 = zext i8 %270 to i32
%272 = shl i32 %271, 8
%273 = or i32 %269, %272
%274 = load i8, i8* %43
%275 = zext i8 %274 to i32
%276 = shl i32 %275, 16
%277 = or i32 %273, %276
%278 = or i32 %277, -16777216
store i32 %278, i32* %44
%279 = load i8*, i8** %32
%280 = bitcast i8* %279 to i32*
%281 = load i32, i32* %28
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i32, i32* %280, i64 %282
%284 = getelementptr inbounds i32, i32* %283, i64 -1
store i32* %284, i32** %47
%285 = load i8*, i8** %32
%286 = load i32, i32* %28
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds i8, i8* %285, i64 %287
store i8* %288, i8** %33
br label %289
289: ; preds = %349, %246
%290 = load i8*, i8** %33
%291 = getelementptr inbounds i8, i8* %290, i32 -1
store i8* %291, i8** %33
%292 = load i8*, i8** %32
%293 = icmp uge i8* %291, %292
br i1 %293, label %294, label %350
294: ; preds = %289
%295 = load i8*, i8** %33
%296 = load i8, i8* %295
%297 = zext i8 %296 to i32
%298 = sitofp i32 %297 to double
%299 = load double, double* %22
%300 = fmul double %298, %299
%301 = fptoui double %300 to i64
store i64 %301, i64* %46
%302 = load i64, i64* %46
%303 = icmp uge i64 %302, 255
br i1 %303, label %304, label %308
304: ; preds = %294
%305 = load i32, i32* %44
%306 = load i32*, i32** %47
%307 = getelementptr inbounds i32, i32* %306, i32 -1
store i32* %307, i32** %47
store i32 %305, i32* %306
br label %349
308: ; preds = %294
%309 = load i64, i64* %46
%310 = icmp ugt i64 %309, 0
br i1 %310, label %311, label %345
311: ; preds = %308
%312 = load i64, i64* %46
%313 = uitofp i64 %312 to double
%314 = fdiv double %313, 2.550000e+02
%315 = fptrunc double %314 to float
store float %315, float* %45
%316 = load i8, i8* %41
%317 = zext i8 %316 to i32
%318 = sitofp i32 %317 to float
%319 = load float, float* %45
%320 = fmul float %318, %319
%321 = fptosi float %320 to i32
%322 = load i8, i8* %42
%323 = zext i8 %322 to i32
%324 = sitofp i32 %323 to float
%325 = load float, float* %45
%326 = fmul float %324, %325
%327 = fptosi float %326 to i32
%328 = shl i32 %327, 8
%329 = or i32 %321, %328
%330 = load i8, i8* %43
%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 = shl i32 %335, 16
%337 = or i32 %329, %336
%338 = sext i32 %337 to i64
%339 = load i64, i64* %46
%340 = shl i64 %339, 24
%341 = or i64 %338, %340
%342 = trunc i64 %341 to i32
%343 = load i32*, i32** %47
%344 = getelementptr inbounds i32, i32* %343, i32 -1
store i32* %344, i32** %47
store i32 %342, i32* %343
br label %348
345: ; preds = %308
%346 = load i32*, i32** %47
%347 = getelementptr inbounds i32, i32* %346, i32 -1
store i32* %347, i32** %47
store i32 0, i32* %346
br label %348
348: ; preds = %345, %311
br label %349
349: ; preds = %348, %304
br label %289
350: ; preds = %289
%351 = load i32, i32* %25
%352 = icmp eq i32 %351, 1
br i1 %352, label %353, label %372
353: ; preds = %350
%354 = load i32, i32* %26
%355 = icmp eq i32 %354, 0
br i1 %355, label %356, label %365
356: ; preds = %353
%357 = load i32, i32* %27
%358 = icmp eq i32 %357, 0
br i1 %358, label %359, label %365
359: ; preds = %356
%360 = load i8*, i8** %13
%361 = load i8*, i8** %32
%362 = load i32, i32* %14
%363 = load i32, i32* %15
%364 = call i32 @compositeSourceAtop(i8* %360, i8* %361, i32 %362, i32 %363)
br label %371
365: ; preds = %356, %353
%366 = load i8*, i8** %13
%367 = load i8*, i8** %32
%368 = load i32, i32* %14
%369 = load i32, i32* %15
%370 = call i32 @compositeSourceIn(i8* %366, i8* %367, i32 %368, i32 %369)
br label %371
371: ; preds = %365, %359
br label %397
372: ; preds = %350
%373 = load i32, i32* %26
%374 = icmp eq i32 %373, 1
br i1 %374, label %375, label %381
375: ; preds = %372
%376 = load i8*, i8** %13
%377 = load i8*, i8** %32
%378 = load i32, i32* %14
%379 = load i32, i32* %15
%380 = call i32 @compositeSourceOut(i8* %376, i8* %377, i32 %378, i32 %379)
br label %396
381: ; preds = %372
%382 = load i32, i32* %27
%383 = icmp eq i32 %382, 1
br i1 %383, label %384, label %389
384: ; preds = %381
%385 = load i8*, i8** %13
%386 = load i8*, i8** %32
%387 = load i32, i32* %29
%388 = call i32 @memcpy(i8* %385, i8* %386, i32 %387)
br label %395
389: ; preds = %381
%390 = load i8*, i8** %13
%391 = load i8*, i8** %32
%392 = load i32, i32* %14
%393 = load i32, i32* %15
%394 = call i32 @compositeDestinationOver(i8* %390, i8* %391, i32 %392, i32 %393)
br label %395
395: ; preds = %389, %384
br label %396
396: ; preds = %395, %375
br label %397
397: ; preds = %396, %371
%398 = load i8*, i8** %32
%399 = call i32 @free(i8* %398)
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* @malloc(i32 %17)
%22 = tail call i32 @memset(i8* %21, i8 zeroext %20, i32 %16)
%23 = getelementptr inbounds i8, i8* %0, i64 3
%24 = or i32 %4, %3
%25 = icmp eq i32 %24, 0
br i1 %25, label %26, label %135
26: ; preds = %12
%27 = icmp sgt i32 %16, 0
br i1 %18, label %88, label %28
28: ; preds = %26
br i1 %27, label %29, label %483
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 %59, label %34
34: ; preds = %29
%35 = icmp ult i32 %30, 16
br i1 %35, label %63, label %36
36: ; preds = %34
%37 = and i64 %32, 15
%38 = icmp eq i64 %37, 0
%39 = select i1 %38, i64 16, i64 %37
%40 = sub nsw i64 %32, %39
br label %41
41: ; preds = %41, %36
%42 = phi i64 [ 0, %36 ], [ %51, %41 ]
%43 = getelementptr i8, i8* %21, i64 %42
%44 = shl i64 %42, 2
%45 = getelementptr i8, i8* %23, i64 %44
%46 = bitcast i8* %45 to <64 x i8>*
%47 = load <64 x i8>, <64 x i8>* %46
%48 = shufflevector <64 x i8> %47, <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>
%49 = xor <16 x i8> %48, <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>
%50 = bitcast i8* %43 to <16 x i8>*
store <16 x i8> %49, <16 x i8>* %50
%51 = add nuw i64 %42, 16
%52 = icmp eq i64 %51, %40
br i1 %52, label %53, label %41
53: ; preds = %41
%54 = shl nsw i64 %40, 2
%55 = getelementptr i8, i8* %23, i64 %54
%56 = getelementptr i8, i8* %21, i64 %40
%57 = trunc i64 %40 to i32
%58 = icmp ult i64 %39, 9
br i1 %58, label %59, label %63
59: ; preds = %76, %29, %53
%60 = phi i32 [ 0, %29 ], [ %57, %53 ], [ %72, %76 ]
%61 = phi i8* [ %21, %29 ], [ %56, %53 ], [ %73, %76 ]
%62 = phi i8* [ %23, %29 ], [ %55, %53 ], [ %75, %76 ]
br label %95
63: ; preds = %34, %53
%64 = phi i64 [ %40, %53 ], [ 0, %34 ]
%65 = add i32 %16, -1
%66 = zext i32 %65 to i64
%67 = add nuw nsw i64 %66, 1
%68 = and i64 %67, 7
%69 = icmp eq i64 %68, 0
%70 = select i1 %69, i64 8, i64 %68
%71 = sub nsw i64 %67, %70
%72 = trunc i64 %71 to i32
%73 = getelementptr i8, i8* %21, i64 %71
%74 = shl nsw i64 %71, 2
%75 = getelementptr i8, i8* %23, i64 %74
br label %76
76: ; preds = %76, %63
%77 = phi i64 [ %64, %63 ], [ %86, %76 ]
%78 = getelementptr i8, i8* %21, i64 %77
%79 = shl i64 %77, 2
%80 = getelementptr i8, i8* %23, i64 %79
%81 = bitcast i8* %80 to <32 x i8>*
%82 = load <32 x i8>, <32 x i8>* %81
%83 = shufflevector <32 x i8> %82, <32 x i8> poison, <8 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28>
%84 = xor <8 x i8> %83, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%85 = bitcast i8* %78 to <8 x i8>*
store <8 x i8> %84, <8 x i8>* %85
%86 = add nuw i64 %77, 8
%87 = icmp eq i64 %86, %71
br i1 %87, label %59, label %76
88: ; preds = %26
br i1 %27, label %89, label %483
89: ; preds = %88
%90 = add i32 %16, -1
%91 = and i32 %16, 7
%92 = icmp ult i32 %90, 7
br i1 %92, label %470, label %93
93: ; preds = %89
%94 = and i32 %16, -8
br label %105
95: ; preds = %59, %95
%96 = phi i32 [ %103, %95 ], [ %60, %59 ]
%97 = phi i8* [ %101, %95 ], [ %61, %59 ]
%98 = phi i8* [ %102, %95 ], [ %62, %59 ]
%99 = load i8, i8* %98
%100 = xor i8 %99, -1
%101 = getelementptr inbounds i8, i8* %97, i64 1
store i8 %100, i8* %97
%102 = getelementptr inbounds i8, i8* %98, i64 4
%103 = add nuw nsw i32 %96, 1
%104 = icmp eq i32 %103, %16
br i1 %104, label %483, label %95
105: ; preds = %105, %93
%106 = phi i8* [ %21, %93 ], [ %131, %105 ]
%107 = phi i8* [ %23, %93 ], [ %132, %105 ]
%108 = phi i32 [ 0, %93 ], [ %133, %105 ]
%109 = load i8, i8* %107
%110 = getelementptr inbounds i8, i8* %106, i64 1
store i8 %109, i8* %106
%111 = getelementptr inbounds i8, i8* %107, i64 4
%112 = load i8, i8* %111
%113 = getelementptr inbounds i8, i8* %106, i64 2
store i8 %112, i8* %110
%114 = getelementptr inbounds i8, i8* %107, i64 8
%115 = load i8, i8* %114
%116 = getelementptr inbounds i8, i8* %106, i64 3
store i8 %115, i8* %113
%117 = getelementptr inbounds i8, i8* %107, i64 12
%118 = load i8, i8* %117
%119 = getelementptr inbounds i8, i8* %106, i64 4
store i8 %118, i8* %116
%120 = getelementptr inbounds i8, i8* %107, i64 16
%121 = load i8, i8* %120
%122 = getelementptr inbounds i8, i8* %106, i64 5
store i8 %121, i8* %119
%123 = getelementptr inbounds i8, i8* %107, i64 20
%124 = load i8, i8* %123
%125 = getelementptr inbounds i8, i8* %106, i64 6
store i8 %124, i8* %122
%126 = getelementptr inbounds i8, i8* %107, i64 24
%127 = load i8, i8* %126
%128 = getelementptr inbounds i8, i8* %106, i64 7
store i8 %127, i8* %125
%129 = getelementptr inbounds i8, i8* %107, i64 28
%130 = load i8, i8* %129
%131 = getelementptr inbounds i8, i8* %106, i64 8
store i8 %130, i8* %128
%132 = getelementptr inbounds i8, i8* %107, i64 32
%133 = add i32 %108, 8
%134 = icmp eq i32 %133, %94
br i1 %134, label %470, label %105
135: ; preds = %12
%136 = tail call i32 @llvm.abs.i32(i32 %3, i1 true)
%137 = sub i32 %1, %136
%138 = tail call i32 @llvm.abs.i32(i32 %4, i1 true)
%139 = sub i32 %2, %138
%140 = shl i32 %1, 2
%141 = icmp sgt i32 %3, 0
%142 = shl nsw i32 %3, 2
%143 = sext i32 %142 to i64
%144 = sub nsw i64 0, %143
%145 = select i1 %141, i64 0, i64 %144
%146 = getelementptr i8, i8* %23, i64 %145
%147 = select i1 %141, i32 %3, i32 0
%148 = zext i32 %147 to i64
%149 = getelementptr i8, i8* %21, i64 %148
%150 = icmp sgt i32 %4, 0
%151 = mul nsw i32 %4, %1
%152 = shl nsw i32 %151, 2
%153 = sext i32 %152 to i64
%154 = sub nsw i64 0, %153
%155 = select i1 %150, i64 0, i64 %154
%156 = getelementptr i8, i8* %146, i64 %155
%157 = select i1 %150, i32 %151, i32 0
%158 = sext i32 %157 to i64
%159 = getelementptr i8, i8* %149, i64 %158
%160 = icmp sgt i32 %139, 0
br i1 %18, label %180, label %161
161: ; preds = %135
br i1 %160, label %162, label %483
162: ; preds = %161
%163 = icmp sgt i32 %137, 0
%164 = sext i32 %1 to i64
%165 = sext i32 %140 to i64
%166 = zext i32 %137 to i64
%167 = icmp ult i32 %137, 9
%168 = icmp ult i32 %137, 17
%169 = and i64 %166, 15
%170 = icmp eq i64 %169, 0
%171 = select i1 %170, i64 16, i64 %169
%172 = sub nsw i64 %166, %171
%173 = shl nsw i64 %172, 2
%174 = icmp ult i64 %171, 9
%175 = and i64 %166, 7
%176 = icmp eq i64 %175, 0
%177 = select i1 %176, i64 8, i64 %175
%178 = sub nsw i64 %166, %177
%179 = shl nsw i64 %178, 2
br label %199
180: ; preds = %135
br i1 %160, label %181, label %483
181: ; preds = %180
%182 = icmp sgt i32 %137, 0
%183 = sext i32 %1 to i64
%184 = sext i32 %140 to i64
%185 = zext i32 %137 to i64
%186 = icmp ult i32 %137, 9
%187 = icmp ult i32 %137, 17
%188 = and i64 %185, 15
%189 = icmp eq i64 %188, 0
%190 = select i1 %189, i64 16, i64 %188
%191 = sub nsw i64 %185, %190
%192 = shl nsw i64 %191, 2
%193 = icmp ult i64 %190, 9
%194 = and i64 %185, 7
%195 = icmp eq i64 %194, 0
%196 = select i1 %195, i64 8, i64 %194
%197 = sub nsw i64 %185, %196
%198 = shl nsw i64 %197, 2
br label %336
199: ; preds = %162, %331
%200 = phi i8* [ %159, %162 ], [ %332, %331 ]
%201 = phi i8* [ %156, %162 ], [ %333, %331 ]
%202 = phi i32 [ 0, %162 ], [ %334, %331 ]
br i1 %163, label %203, label %331
203: ; preds = %199
br i1 %167, label %318, label %204
204: ; preds = %203
br i1 %168, label %277, label %205
205: ; preds = %204, %205
%206 = phi i64 [ %274, %205 ], [ 0, %204 ]
%207 = shl i64 %206, 2
%208 = or i64 %207, 4
%209 = or i64 %207, 8
%210 = or i64 %207, 12
%211 = or i64 %207, 16
%212 = or i64 %207, 20
%213 = or i64 %207, 24
%214 = or i64 %207, 28
%215 = or i64 %207, 32
%216 = or i64 %207, 36
%217 = or i64 %207, 40
%218 = or i64 %207, 44
%219 = or i64 %207, 48
%220 = or i64 %207, 52
%221 = or i64 %207, 56
%222 = or i64 %207, 60
%223 = getelementptr inbounds i8, i8* %201, i64 %207
%224 = getelementptr inbounds i8, i8* %201, i64 %208
%225 = getelementptr inbounds i8, i8* %201, i64 %209
%226 = getelementptr inbounds i8, i8* %201, i64 %210
%227 = getelementptr inbounds i8, i8* %201, i64 %211
%228 = getelementptr inbounds i8, i8* %201, i64 %212
%229 = getelementptr inbounds i8, i8* %201, i64 %213
%230 = getelementptr inbounds i8, i8* %201, i64 %214
%231 = getelementptr inbounds i8, i8* %201, i64 %215
%232 = getelementptr inbounds i8, i8* %201, i64 %216
%233 = getelementptr inbounds i8, i8* %201, i64 %217
%234 = getelementptr inbounds i8, i8* %201, i64 %218
%235 = getelementptr inbounds i8, i8* %201, i64 %219
%236 = getelementptr inbounds i8, i8* %201, i64 %220
%237 = getelementptr inbounds i8, i8* %201, i64 %221
%238 = getelementptr inbounds i8, i8* %201, i64 %222
%239 = load i8, i8* %223
%240 = load i8, i8* %224
%241 = load i8, i8* %225
%242 = load i8, i8* %226
%243 = load i8, i8* %227
%244 = load i8, i8* %228
%245 = load i8, i8* %229
%246 = load i8, i8* %230
%247 = load i8, i8* %231
%248 = load i8, i8* %232
%249 = load i8, i8* %233
%250 = load i8, i8* %234
%251 = load i8, i8* %235
%252 = load i8, i8* %236
%253 = load i8, i8* %237
%254 = load i8, i8* %238
%255 = insertelement <16 x i8> poison, i8 %239, i64 0
%256 = insertelement <16 x i8> %255, i8 %240, i64 1
%257 = insertelement <16 x i8> %256, i8 %241, i64 2
%258 = insertelement <16 x i8> %257, i8 %242, i64 3
%259 = insertelement <16 x i8> %258, i8 %243, i64 4
%260 = insertelement <16 x i8> %259, i8 %244, i64 5
%261 = insertelement <16 x i8> %260, i8 %245, i64 6
%262 = insertelement <16 x i8> %261, i8 %246, i64 7
%263 = insertelement <16 x i8> %262, i8 %247, i64 8
%264 = insertelement <16 x i8> %263, i8 %248, i64 9
%265 = insertelement <16 x i8> %264, i8 %249, i64 10
%266 = insertelement <16 x i8> %265, i8 %250, i64 11
%267 = insertelement <16 x i8> %266, i8 %251, i64 12
%268 = insertelement <16 x i8> %267, i8 %252, i64 13
%269 = insertelement <16 x i8> %268, i8 %253, i64 14
%270 = insertelement <16 x i8> %269, i8 %254, i64 15
%271 = xor <16 x i8> %270, <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>
%272 = getelementptr inbounds i8, i8* %200, i64 %206
%273 = bitcast i8* %272 to <16 x i8>*
store <16 x i8> %271, <16 x i8>* %273
%274 = add nuw i64 %206, 16
%275 = icmp eq i64 %274, %172
br i1 %275, label %276, label %205
276: ; preds = %205
br i1 %174, label %318, label %277
277: ; preds = %204, %276
%278 = phi i64 [ %172, %276 ], [ 0, %204 ]
br label %279
279: ; preds = %279, %277
%280 = phi i64 [ %278, %277 ], [ %316, %279 ]
%281 = shl i64 %280, 2
%282 = add i64 %281, 4
%283 = add i64 %281, 8
%284 = add i64 %281, 12
%285 = add i64 %281, 16
%286 = add i64 %281, 20
%287 = add i64 %281, 24
%288 = add i64 %281, 28
%289 = getelementptr inbounds i8, i8* %201, i64 %281
%290 = getelementptr inbounds i8, i8* %201, i64 %282
%291 = getelementptr inbounds i8, i8* %201, i64 %283
%292 = getelementptr inbounds i8, i8* %201, i64 %284
%293 = getelementptr inbounds i8, i8* %201, i64 %285
%294 = getelementptr inbounds i8, i8* %201, i64 %286
%295 = getelementptr inbounds i8, i8* %201, i64 %287
%296 = getelementptr inbounds i8, i8* %201, i64 %288
%297 = load i8, i8* %289
%298 = load i8, i8* %290
%299 = load i8, i8* %291
%300 = load i8, i8* %292
%301 = load i8, i8* %293
%302 = load i8, i8* %294
%303 = load i8, i8* %295
%304 = load i8, i8* %296
%305 = insertelement <8 x i8> poison, i8 %297, i64 0
%306 = insertelement <8 x i8> %305, i8 %298, i64 1
%307 = insertelement <8 x i8> %306, i8 %299, i64 2
%308 = insertelement <8 x i8> %307, i8 %300, i64 3
%309 = insertelement <8 x i8> %308, i8 %301, i64 4
%310 = insertelement <8 x i8> %309, i8 %302, i64 5
%311 = insertelement <8 x i8> %310, i8 %303, i64 6
%312 = insertelement <8 x i8> %311, i8 %304, i64 7
%313 = xor <8 x i8> %312, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%314 = getelementptr inbounds i8, i8* %200, i64 %280
%315 = bitcast i8* %314 to <8 x i8>*
store <8 x i8> %313, <8 x i8>* %315
%316 = add nuw i64 %280, 8
%317 = icmp eq i64 %316, %178
br i1 %317, label %318, label %279
318: ; preds = %279, %203, %276
%319 = phi i64 [ 0, %203 ], [ %173, %276 ], [ %179, %279 ]
%320 = phi i64 [ 0, %203 ], [ %172, %276 ], [ %178, %279 ]
br label %321
321: ; preds = %318, %321
%322 = phi i64 [ %329, %321 ], [ %319, %318 ]
%323 = phi i64 [ %328, %321 ], [ %320, %318 ]
%324 = getelementptr inbounds i8, i8* %201, i64 %322
%325 = load i8, i8* %324
%326 = xor i8 %325, -1
%327 = getelementptr inbounds i8, i8* %200, i64 %323
store i8 %326, i8* %327
%328 = add nuw nsw i64 %323, 1
%329 = add nuw nsw i64 %322, 4
%330 = icmp eq i64 %328, %166
br i1 %330, label %331, label %321
331: ; preds = %321, %199
%332 = getelementptr inbounds i8, i8* %200, i64 %164
%333 = getelementptr inbounds i8, i8* %201, i64 %165
%334 = add nuw nsw i32 %202, 1
%335 = icmp eq i32 %334, %139
br i1 %335, label %483, label %199
336: ; preds = %181, %465
%337 = phi i8* [ %159, %181 ], [ %466, %465 ]
%338 = phi i8* [ %156, %181 ], [ %467, %465 ]
%339 = phi i32 [ 0, %181 ], [ %468, %465 ]
br i1 %182, label %340, label %465
340: ; preds = %336
br i1 %186, label %453, label %341
341: ; preds = %340
br i1 %187, label %413, label %342
342: ; preds = %341, %342
%343 = phi i64 [ %410, %342 ], [ 0, %341 ]
%344 = shl i64 %343, 2
%345 = or i64 %344, 4
%346 = or i64 %344, 8
%347 = or i64 %344, 12
%348 = or i64 %344, 16
%349 = or i64 %344, 20
%350 = or i64 %344, 24
%351 = or i64 %344, 28
%352 = or i64 %344, 32
%353 = or i64 %344, 36
%354 = or i64 %344, 40
%355 = or i64 %344, 44
%356 = or i64 %344, 48
%357 = or i64 %344, 52
%358 = or i64 %344, 56
%359 = or i64 %344, 60
%360 = getelementptr inbounds i8, i8* %338, i64 %344
%361 = getelementptr inbounds i8, i8* %338, i64 %345
%362 = getelementptr inbounds i8, i8* %338, i64 %346
%363 = getelementptr inbounds i8, i8* %338, i64 %347
%364 = getelementptr inbounds i8, i8* %338, i64 %348
%365 = getelementptr inbounds i8, i8* %338, i64 %349
%366 = getelementptr inbounds i8, i8* %338, i64 %350
%367 = getelementptr inbounds i8, i8* %338, i64 %351
%368 = getelementptr inbounds i8, i8* %338, i64 %352
%369 = getelementptr inbounds i8, i8* %338, i64 %353
%370 = getelementptr inbounds i8, i8* %338, i64 %354
%371 = getelementptr inbounds i8, i8* %338, i64 %355
%372 = getelementptr inbounds i8, i8* %338, i64 %356
%373 = getelementptr inbounds i8, i8* %338, i64 %357
%374 = getelementptr inbounds i8, i8* %338, i64 %358
%375 = getelementptr inbounds i8, i8* %338, i64 %359
%376 = load i8, i8* %360
%377 = load i8, i8* %361
%378 = load i8, i8* %362
%379 = load i8, i8* %363
%380 = load i8, i8* %364
%381 = load i8, i8* %365
%382 = load i8, i8* %366
%383 = load i8, i8* %367
%384 = load i8, i8* %368
%385 = load i8, i8* %369
%386 = load i8, i8* %370
%387 = load i8, i8* %371
%388 = load i8, i8* %372
%389 = load i8, i8* %373
%390 = load i8, i8* %374
%391 = load i8, i8* %375
%392 = insertelement <16 x i8> poison, i8 %376, i64 0
%393 = insertelement <16 x i8> %392, i8 %377, i64 1
%394 = insertelement <16 x i8> %393, i8 %378, i64 2
%395 = insertelement <16 x i8> %394, i8 %379, i64 3
%396 = insertelement <16 x i8> %395, i8 %380, i64 4
%397 = insertelement <16 x i8> %396, i8 %381, i64 5
%398 = insertelement <16 x i8> %397, i8 %382, i64 6
%399 = insertelement <16 x i8> %398, i8 %383, i64 7
%400 = insertelement <16 x i8> %399, i8 %384, i64 8
%401 = insertelement <16 x i8> %400, i8 %385, i64 9
%402 = insertelement <16 x i8> %401, i8 %386, i64 10
%403 = insertelement <16 x i8> %402, i8 %387, i64 11
%404 = insertelement <16 x i8> %403, i8 %388, i64 12
%405 = insertelement <16 x i8> %404, i8 %389, i64 13
%406 = insertelement <16 x i8> %405, i8 %390, i64 14
%407 = insertelement <16 x i8> %406, i8 %391, i64 15
%408 = getelementptr inbounds i8, i8* %337, i64 %343
%409 = bitcast i8* %408 to <16 x i8>*
store <16 x i8> %407, <16 x i8>* %409
%410 = add nuw i64 %343, 16
%411 = icmp eq i64 %410, %191
br i1 %411, label %412, label %342
412: ; preds = %342
br i1 %193, label %453, label %413
413: ; preds = %341, %412
%414 = phi i64 [ %191, %412 ], [ 0, %341 ]
br label %415
415: ; preds = %415, %413
%416 = phi i64 [ %414, %413 ], [ %451, %415 ]
%417 = shl i64 %416, 2
%418 = add i64 %417, 4
%419 = add i64 %417, 8
%420 = add i64 %417, 12
%421 = add i64 %417, 16
%422 = add i64 %417, 20
%423 = add i64 %417, 24
%424 = add i64 %417, 28
%425 = getelementptr inbounds i8, i8* %338, i64 %417
%426 = getelementptr inbounds i8, i8* %338, i64 %418
%427 = getelementptr inbounds i8, i8* %338, i64 %419
%428 = getelementptr inbounds i8, i8* %338, i64 %420
%429 = getelementptr inbounds i8, i8* %338, i64 %421
%430 = getelementptr inbounds i8, i8* %338, i64 %422
%431 = getelementptr inbounds i8, i8* %338, i64 %423
%432 = getelementptr inbounds i8, i8* %338, i64 %424
%433 = load i8, i8* %425
%434 = load i8, i8* %426
%435 = load i8, i8* %427
%436 = load i8, i8* %428
%437 = load i8, i8* %429
%438 = load i8, i8* %430
%439 = load i8, i8* %431
%440 = load i8, i8* %432
%441 = insertelement <8 x i8> poison, i8 %433, i64 0
%442 = insertelement <8 x i8> %441, i8 %434, i64 1
%443 = insertelement <8 x i8> %442, i8 %435, i64 2
%444 = insertelement <8 x i8> %443, i8 %436, i64 3
%445 = insertelement <8 x i8> %444, i8 %437, i64 4
%446 = insertelement <8 x i8> %445, i8 %438, i64 5
%447 = insertelement <8 x i8> %446, i8 %439, i64 6
%448 = insertelement <8 x i8> %447, i8 %440, i64 7
%449 = getelementptr inbounds i8, i8* %337, i64 %416
%450 = bitcast i8* %449 to <8 x i8>*
store <8 x i8> %448, <8 x i8>* %450
%451 = add nuw i64 %416, 8
%452 = icmp eq i64 %451, %197
br i1 %452, label %453, label %415
453: ; preds = %415, %340, %412
%454 = phi i64 [ 0, %340 ], [ %192, %412 ], [ %198, %415 ]
%455 = phi i64 [ 0, %340 ], [ %191, %412 ], [ %197, %415 ]
br label %456
456: ; preds = %453, %456
%457 = phi i64 [ %463, %456 ], [ %454, %453 ]
%458 = phi i64 [ %462, %456 ], [ %455, %453 ]
%459 = getelementptr inbounds i8, i8* %338, i64 %457
%460 = load i8, i8* %459
%461 = getelementptr inbounds i8, i8* %337, i64 %458
store i8 %460, i8* %461
%462 = add nuw nsw i64 %458, 1
%463 = add nuw nsw i64 %457, 4
%464 = icmp eq i64 %462, %185
br i1 %464, label %465, label %456
465: ; preds = %456, %336
%466 = getelementptr inbounds i8, i8* %337, i64 %183
%467 = getelementptr inbounds i8, i8* %338, i64 %184
%468 = add nuw nsw i32 %339, 1
%469 = icmp eq i32 %468, %139
br i1 %469, label %483, label %336
470: ; preds = %105, %89
%471 = phi i8* [ %21, %89 ], [ %131, %105 ]
%472 = phi i8* [ %23, %89 ], [ %132, %105 ]
%473 = icmp eq i32 %91, 0
br i1 %473, label %483, label %474
474: ; preds = %470, %474
%475 = phi i8* [ %479, %474 ], [ %471, %470 ]
%476 = phi i8* [ %480, %474 ], [ %472, %470 ]
%477 = phi i32 [ %481, %474 ], [ 0, %470 ]
%478 = load i8, i8* %476
%479 = getelementptr inbounds i8, i8* %475, i64 1
store i8 %478, i8* %475
%480 = getelementptr inbounds i8, i8* %476, i64 4
%481 = add i32 %477, 1
%482 = icmp eq i32 %481, %91
br i1 %482, label %483, label %474
483: ; preds = %331, %465, %95, %470, %474, %161, %180, %28, %88
%484 = 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)
%485 = lshr i32 %5, 16
%486 = lshr i32 %5, 8
%487 = and i32 %485, 255
%488 = and i32 %486, 255
%489 = shl nuw nsw i32 %488, 8
%490 = or i32 %489, %487
%491 = and i32 %5, 255
%492 = shl nuw nsw i32 %491, 16
%493 = or i32 %490, %492
%494 = or i32 %493, -16777216
%495 = sext i32 %16 to i64
%496 = getelementptr inbounds i8, i8* %21, i64 %495
%497 = getelementptr inbounds i8, i8* %496, i64 -1
%498 = icmp ult i8* %497, %21
br i1 %498, label %537, label %499
499: ; preds = %483
%500 = bitcast i8* %21 to i32*
%501 = getelementptr inbounds i32, i32* %500, i64 %495
%502 = sitofp i32 %487 to float
%503 = sitofp i32 %488 to float
%504 = sitofp i32 %491 to float
br label %505
505: ; preds = %499, %533
%506 = phi i8* [ %497, %499 ], [ %535, %533 ]
%507 = phi i32* [ %501, %499 ], [ %508, %533 ]
%508 = getelementptr inbounds i32, i32* %507, i64 -1
%509 = load i8, i8* %506
%510 = uitofp i8 %509 to double
%511 = fmul double %510, %9
%512 = fptoui double %511 to i64
%513 = icmp ugt i64 %512, 254
br i1 %513, label %533, label %514
514: ; preds = %505
%515 = icmp eq i64 %512, 0
br i1 %515, label %533, label %516
516: ; preds = %514
%517 = uitofp i64 %512 to double
%518 = fdiv double %517, 2.550000e+02
%519 = fptrunc double %518 to float
%520 = fmul float %502, %519
%521 = fptosi float %520 to i32
%522 = fmul float %503, %519
%523 = fptosi float %522 to i32
%524 = shl i32 %523, 8
%525 = fmul float %504, %519
%526 = fptosi float %525 to i32
%527 = shl i32 %526, 16
%528 = trunc i64 %512 to i32
%529 = shl nuw i32 %528, 24
%530 = or i32 %529, %521
%531 = or i32 %530, %524
%532 = or i32 %531, %527
br label %533
533: ; preds = %514, %505, %516
%534 = phi i32 [ %532, %516 ], [ %494, %505 ], [ 0, %514 ]
store i32 %534, i32* %508
%535 = getelementptr inbounds i8, i8* %506, i64 -1
%536 = icmp ult i8* %535, %21
br i1 %536, label %537, label %505
537: ; preds = %533, %483
br i1 %18, label %546, label %538
538: ; preds = %537
%539 = or i32 %14, %15
%540 = and i32 %539, 1
%541 = icmp eq i32 %540, 0
br i1 %541, label %542, label %544
542: ; preds = %538
%543 = tail call i32 @compositeSourceAtop(i8* %0, i8* %21, i32 %1, i32 %2)
br label %558
544: ; preds = %538
%545 = tail call i32 @compositeSourceIn(i8* %0, i8* %21, i32 %1, i32 %2)
br label %558
546: ; preds = %537
%547 = and i32 %11, 2
%548 = icmp eq i32 %547, 0
br i1 %548, label %551, label %549
549: ; preds = %546
%550 = tail call i32 @compositeSourceOut(i8* %0, i8* %21, i32 %1, i32 %2)
br label %558
551: ; preds = %546
%552 = and i32 %11, 4
%553 = icmp eq i32 %552, 0
br i1 %553, label %556, label %554
554: ; preds = %551
%555 = tail call i32 @memcpy(i8* %0, i8* %21, i32 %17)
br label %558
556: ; preds = %551
%557 = tail call i32 @compositeDestinationOver(i8* %0, i8* %21, i32 %1, i32 %2)
br label %558
558: ; preds = %549, %556, %554, %542, %544
%559 = tail call i32 @free(i8* %21)
ret void
}