int *blur_ARGB_8888(int *pix, int w, int h, int radius) {
  int wm = w - 1;
  int hm = h - 1;
  int wh = w * h;
  int div = radius + radius + 1;
  short *r = (short *)malloc(wh * sizeof(short));
  short *g = (short *)malloc(wh * sizeof(short));
  short *b = (short *)malloc(wh * sizeof(short));
  int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
  int *vmin = (int *)malloc(((w) > (h) ? (w) : (h)) * sizeof(int));
  int divsum = (div + 1) >> 1;
  divsum *= divsum;
  short *dv = (short *)malloc(256 * divsum * sizeof(short));
  for (i = 0; i < 256 * divsum; i++) {
    dv[i] = (short)(i / divsum);
  }
  yw = yi = 0;
  int(*stack)[3] = (int(*)[3])malloc(div * 3 * sizeof(int));
  int stackpointer;
  int stackstart;
  int *sir;
  int rbs;
  int r1 = radius + 1;
  int routsum, goutsum, boutsum;
  int rinsum, ginsum, binsum;
  for (y = 0; y < h; y++) {
    rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum =
        bsum = 0;
    for (i = -radius; i <= radius; i++) {
      p = pix[yi +
              (((wm) < (((i) > (0) ? (i) : (0))) ? (wm)
                                                 : (((i) > (0) ? (i) : (0)))))];
      sir = stack[i + radius];
      sir[0] = (p & 0xff0000) >> 16;
      sir[1] = (p & 0x00ff00) >> 8;
      sir[2] = (p & 0x0000ff);
      rbs = r1 - ((i) < (0) ? (-i) : (i));
      rsum += sir[0] * rbs;
      gsum += sir[1] * rbs;
      bsum += sir[2] * rbs;
      if (i > 0) {
        rinsum += sir[0];
        ginsum += sir[1];
        binsum += sir[2];
      } else {
        routsum += sir[0];
        goutsum += sir[1];
        boutsum += sir[2];
      }
    }
    stackpointer = radius;
    for (x = 0; x < w; x++) {
      r[yi] = dv[rsum];
      g[yi] = dv[gsum];
      b[yi] = dv[bsum];
      rsum -= routsum;
      gsum -= goutsum;
      bsum -= boutsum;
      stackstart = stackpointer - radius + div;
      sir = stack[stackstart % div];
      routsum -= sir[0];
      goutsum -= sir[1];
      boutsum -= sir[2];
      if (y == 0) {
        vmin[x] = ((x + radius + 1) < (wm) ? (x + radius + 1) : (wm));
      }
      p = pix[yw + vmin[x]];
      sir[0] = (p & 0xff0000) >> 16;
      sir[1] = (p & 0x00ff00) >> 8;
      sir[2] = (p & 0x0000ff);
      rinsum += sir[0];
      ginsum += sir[1];
      binsum += sir[2];
      rsum += rinsum;
      gsum += ginsum;
      bsum += binsum;
      stackpointer = (stackpointer + 1) % div;
      sir = stack[(stackpointer) % div];
      routsum += sir[0];
      goutsum += sir[1];
      boutsum += sir[2];
      rinsum -= sir[0];
      ginsum -= sir[1];
      binsum -= sir[2];
      yi++;
    }
    yw += w;
  }
  for (x = 0; x < w; x++) {
    rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum =
        bsum = 0;
    yp = -radius * w;
    for (i = -radius; i <= radius; i++) {
      yi = ((0) > (yp) ? (0) : (yp)) + x;
      sir = stack[i + radius];
      sir[0] = r[yi];
      sir[1] = g[yi];
      sir[2] = b[yi];
      rbs = r1 - ((i) < (0) ? (-i) : (i));
      rsum += r[yi] * rbs;
      gsum += g[yi] * rbs;
      bsum += b[yi] * rbs;
      if (i > 0) {
        rinsum += sir[0];
        ginsum += sir[1];
        binsum += sir[2];
      } else {
        routsum += sir[0];
        goutsum += sir[1];
        boutsum += sir[2];
      }
      if (i < hm) {
        yp += w;
      }
    }
    yi = x;
    stackpointer = radius;
    for (y = 0; y < h; y++) {
      pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) |
                dv[bsum];
      rsum -= routsum;
      gsum -= goutsum;
      bsum -= boutsum;
      stackstart = stackpointer - radius + div;
      sir = stack[stackstart % div];
      routsum -= sir[0];
      goutsum -= sir[1];
      boutsum -= sir[2];
      if (x == 0) {
        vmin[y] = ((y + r1) < (hm) ? (y + r1) : (hm)) * w;
      }
      p = x + vmin[y];
      sir[0] = r[p];
      sir[1] = g[p];
      sir[2] = b[p];
      rinsum += sir[0];
      ginsum += sir[1];
      binsum += sir[2];
      rsum += rinsum;
      gsum += ginsum;
      bsum += binsum;
      stackpointer = (stackpointer + 1) % div;
      sir = stack[stackpointer];
      routsum += sir[0];
      goutsum += sir[1];
      boutsum += sir[2];
      rinsum -= sir[0];
      ginsum -= sir[1];
      binsum -= sir[2];
      yi += w;
    }
  }
  free(r);
  free(g);
  free(b);
  free(vmin);
  free(dv);
  free(stack);
  return (pix);
}


x86 assembly (clang, -O0):
<blur_ARGB_8888>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x1,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x1,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x1,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    11ad <blur_ARGB_8888+0x8d>
mov    -0xc(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    11b6 <blur_ARGB_8888+0x96>
mov    -0x10(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
imul   -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
shl    $0x8,%eax
movslq %eax,%rdi
shl    $0x1,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x74(%rbp),%ecx
shl    $0x8,%ecx
cmp    %ecx,%eax
jge    1234 <blur_ARGB_8888+0x114>
mov    -0x58(%rbp),%eax
cltd
idivl  -0x74(%rbp)
mov    %ax,%dx
mov    -0x80(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    11ff <blur_ARGB_8888+0xdf>
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
imul   $0x3,-0x24(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    182f <blur_ARGB_8888+0x70f>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0xac(%rbp)
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0xb8(%rbp)
movl   $0x0,-0xb4(%rbp)
movl   $0x0,-0xb0(%rbp)
xor    %eax,%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1517 <blur_ARGB_8888+0x3f7>
mov    -0x8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0xc0(%rbp)
cmpl   $0x0,-0x58(%rbp)
jle    1312 <blur_ARGB_8888+0x1f2>
mov    -0x58(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    131f <blur_ARGB_8888+0x1ff>
xor    %eax,%eax
mov    %eax,-0xd4(%rbp)
jmp    131f <blur_ARGB_8888+0x1ff>
mov    -0xc0(%rbp),%eax
mov    -0xd4(%rbp),%ecx
cmp    %ecx,%eax
jge    1341 <blur_ARGB_8888+0x221>
mov    -0x18(%rbp),%eax
mov    %eax,-0xd8(%rbp)
jmp    1372 <blur_ARGB_8888+0x252>
cmpl   $0x0,-0x58(%rbp)
jle    1359 <blur_ARGB_8888+0x239>
mov    -0x58(%rbp),%eax
mov    %eax,-0xdc(%rbp)
jmp    1366 <blur_ARGB_8888+0x246>
xor    %eax,%eax
mov    %eax,-0xdc(%rbp)
jmp    1366 <blur_ARGB_8888+0x246>
mov    -0xdc(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd0(%rbp),%rax
mov    -0xc4(%rbp),%ecx
mov    -0xd8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x5c(%rbp),%ecx
and    $0xff0000,%ecx
sar    $0x10,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x5c(%rbp),%ecx
and    $0xff00,%ecx
sar    $0x8,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x5c(%rbp),%ecx
and    $0xff,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0xa0(%rbp),%eax
mov    %eax,-0xe0(%rbp)
cmpl   $0x0,-0x58(%rbp)
jge    1412 <blur_ARGB_8888+0x2f2>
xor    %eax,%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xe4(%rbp)
jmp    141b <blur_ARGB_8888+0x2fb>
mov    -0x58(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe0(%rbp),%eax
mov    -0xe4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
imul   -0x9c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%eax
imul   -0x9c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%eax
imul   -0x9c(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x58(%rbp)
jle    14c3 <blur_ARGB_8888+0x3a3>
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
add    -0xb0(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%eax
add    -0xb4(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%eax
add    -0xb8(%rbp),%eax
mov    %eax,-0xb8(%rbp)
jmp    1504 <blur_ARGB_8888+0x3e4>
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%eax
add    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
jmp    1509 <blur_ARGB_8888+0x3e9>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12d1 <blur_ARGB_8888+0x1b1>
mov    -0x14(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1818 <blur_ARGB_8888+0x6f8>
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0xa4(%rbp),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0xa8(%rbp),%ecx
mov    -0x48(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8c(%rbp),%eax
sub    -0x14(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x90(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    -0xf0(%rbp),%rax
movslq %edx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    (%rax),%ecx
mov    -0xa4(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0xa8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0xac(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xac(%rbp)
cmpl   $0x0,-0x54(%rbp)
jne    1678 <blur_ARGB_8888+0x558>
mov    -0x50(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1,%eax
cmp    -0x18(%rbp),%eax
jge    165e <blur_ARGB_8888+0x53e>
mov    -0x50(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1667 <blur_ARGB_8888+0x547>
mov    -0x18(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf4(%rbp),%edx
mov    -0x70(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x70(%rbp),%rdx
movslq -0x50(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%ecx
and    $0xff0000,%ecx
sar    $0x10,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x5c(%rbp),%ecx
and    $0xff00,%ecx
sar    $0x8,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x5c(%rbp),%ecx
and    $0xff,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
add    -0xb0(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%eax
add    -0xb4(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%eax
add    -0xb8(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb0(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0xb4(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0xb8(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x8c(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x8c(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    -0x100(%rbp),%rax
movslq %edx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%eax
add    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x98(%rbp),%rax
mov    (%rax),%ecx
mov    -0xb0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0xb4(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0xb8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1527 <blur_ARGB_8888+0x407>
mov    -0xc(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    126c <blur_ARGB_8888+0x14c>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d8d <blur_ARGB_8888+0xc6d>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0xac(%rbp)
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0xb8(%rbp)
movl   $0x0,-0xb4(%rbp)
movl   $0x0,-0xb0(%rbp)
xor    %eax,%eax
sub    -0x14(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x60(%rbp)
xor    %eax,%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1a86 <blur_ARGB_8888+0x966>
xor    %eax,%eax
cmp    -0x60(%rbp),%eax
jle    18cb <blur_ARGB_8888+0x7ab>
xor    %eax,%eax
mov    %eax,-0x104(%rbp)
jmp    18d4 <blur_ARGB_8888+0x7b4>
mov    -0x60(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x108(%rbp)
cmpl   $0x0,-0x58(%rbp)
jge    1965 <blur_ARGB_8888+0x845>
xor    %eax,%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x10c(%rbp)
jmp    196e <blur_ARGB_8888+0x84e>
mov    -0x58(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x108(%rbp),%eax
mov    -0x10c(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
imul   -0x9c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
imul   -0x9c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
imul   -0x9c(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x58(%rbp)
jle    1a1d <blur_ARGB_8888+0x8fd>
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
add    -0xb0(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%eax
add    -0xb4(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%eax
add    -0xb8(%rbp),%eax
mov    %eax,-0xb8(%rbp)
jmp    1a5e <blur_ARGB_8888+0x93e>
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%eax
add    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a73 <blur_ARGB_8888+0x953>
mov    -0xc(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1a78 <blur_ARGB_8888+0x958>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    18a7 <blur_ARGB_8888+0x787>
mov    -0x50(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d7a <blur_ARGB_8888+0xc5a>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
and    $0xff000000,%edx
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
shl    $0x10,%eax
or     %eax,%edx
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
shl    $0x8,%eax
or     %eax,%edx
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
or     %eax,%edx
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa4(%rbp),%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0xa8(%rbp),%ecx
mov    -0x48(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0xac(%rbp),%ecx
mov    -0x4c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8c(%rbp),%eax
sub    -0x14(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x90(%rbp),%eax
cltd
idivl  -0x24(%rbp)
mov    -0x118(%rbp),%rax
movslq %edx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    (%rax),%ecx
mov    -0xa4(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0xa8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0xac(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xac(%rbp)
cmpl   $0x0,-0x50(%rbp)
jne    1bf5 <blur_ARGB_8888+0xad5>
mov    -0x54(%rbp),%eax
add    -0xa0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1bd7 <blur_ARGB_8888+0xab7>
mov    -0x54(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0x11c(%rbp)
jmp    1be0 <blur_ARGB_8888+0xac0>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x11c(%rbp),%edx
imul   -0xc(%rbp),%edx
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
mov    -0x70(%rbp),%rcx
movslq -0x54(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
add    -0xb0(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%eax
add    -0xb4(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%eax
add    -0xb8(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb0(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0xb4(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0xb8(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0x24(%rbp)
mov    %edx,-0x8c(%rbp)
mov    -0x88(%rbp),%rax
movslq -0x8c(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    (%rax),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%eax
add    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x98(%rbp),%rax
mov    (%rax),%ecx
mov    -0xb0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0xb4(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x98(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0xb8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xc(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1a9c <blur_ARGB_8888+0x97c>
jmp    1d7f <blur_ARGB_8888+0xc5f>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1836 <blur_ARGB_8888+0x716>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x8(%rbp),%rax
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<blur_ARGB_8888>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %ecx,%r15d
mov    %edx,%ebp
mov    %esi,%ebx
mov    %rdi,0x48(%rsp)
mov    %edx,%eax
imul   %esi,%eax
lea    (%r15,%r15,1),%ecx
add    $0x1,%ecx
mov    %rcx,0x28(%rsp)
movslq %eax,%r14
add    %r14,%r14
mov    %r14,%rdi
call   1040 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %r14,%rdi
call   1040 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %r14,%rdi
call   1040 <malloc@plt>
mov    %rax,0x78(%rsp)
cmp    %ebp,%ebx
mov    %rbp,0x70(%rsp)
mov    %ebp,%eax
mov    %rbx,0x20(%rsp)
cmovg  %ebx,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %r15,0x30(%rsp)
lea    (%r15,%r15,1),%ebx
add    $0x2,%ebx
sar    %ebx
imul   %ebx,%ebx
mov    %ebx,%edi
shl    $0x9,%edi
call   1040 <malloc@plt>
mov    %rax,%rbp
test   %ebx,%ebx
je     1221 <blur_ARGB_8888+0x101>
mov    %ebx,%eax
shl    $0x8,%eax
cmp    $0x2,%eax
mov    $0x1,%esi
cmovae %eax,%esi
test   %eax,%eax
je     19f3 <blur_ARGB_8888+0x8d3>
mov    %esi,%edi
and    $0xffffff00,%edi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %ecx,%eax
xor    %edx,%edx
div    %ebx
mov    %ax,0x0(%rbp,%rcx,2)
lea    0x1(%rcx),%eax
xor    %edx,%edx
div    %ebx
mov    %ax,0x2(%rbp,%rcx,2)
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    11f0 <blur_ARGB_8888+0xd0>
test   $0x1,%sil
je     1221 <blur_ARGB_8888+0x101>
mov    %ecx,%eax
xor    %edx,%edx
div    %ebx
mov    %ax,0x0(%rbp,%rcx,2)
mov    %rbp,0xc0(%rsp)
mov    0x30(%rsp),%rbx
mov    %ebx,%eax
neg    %eax
mov    %eax,0x8(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rax,2),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,0x38(%rsp)
lea    0x1(%rbx),%eax
movslq %ebx,%rcx
mov    %rcx,0xc8(%rsp)
mov    0x20(%rsp),%ecx
mov    %rcx,0xb8(%rsp)
mov    %eax,0x6c(%rsp)
mov    %eax,%eax
mov    %rax,0xd0(%rsp)
cmpl   $0x0,0x70(%rsp)
mov    0x48(%rsp),%rcx
jle    15f0 <blur_ARGB_8888+0x4d0>
mov    0x20(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x14(%rsp)
mov    0x28(%rsp),%rax
sub    0x30(%rsp),%eax
mov    %rax,0x50(%rsp)
movslq 0x8(%rsp),%rdx
mov    0xc8(%rsp),%rax
mov    %rdx,0x98(%rsp)
add    %rdx,%rax
lea    (%rax,%rax,2),%rax
mov    0x38(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
add    $0x8,%rax
mov    %rax,0x90(%rsp)
xor    %eax,%eax
mov    %rax,0x58(%rsp)
movl   $0x0,0x4(%rsp)
movl   $0x0,0x10(%rsp)
jmp    131d <blur_ARGB_8888+0x1fd>
nopl   0x0(%rax,%rax,1)
add    %r13d,0x4(%rsp)
mov    0x48(%rsp),%rcx
mov    0x58(%rsp),%rax
add    0x20(%rsp),%eax
mov    %rax,0x58(%rsp)
mov    0x10(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x10(%rsp)
cmp    0x70(%rsp),%eax
je     15f0 <blur_ARGB_8888+0x4d0>
mov    $0x0,%r12d
mov    $0x0,%r15d
mov    $0x0,%ebp
movl   $0x0,0x40(%rsp)
movl   $0x0,0xc(%rsp)
mov    $0x0,%ebx
mov    $0x0,%r11d
mov    $0x0,%r9d
movl   $0x0,(%rsp)
mov    0x8(%rsp),%eax
cmp    0x30(%rsp),%eax
jle    1510 <blur_ARGB_8888+0x3f0>
cmpl   $0x0,0x20(%rsp)
jle    12fa <blur_ARGB_8888+0x1da>
movslq 0x4(%rsp),%rax
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,2),%rcx
mov    %rcx,0xb0(%rsp)
mov    0x80(%rsp),%rcx
lea    (%rcx,%rax,2),%rcx
mov    %rcx,0xa8(%rsp)
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,2),%rax
mov    %rax,0xa0(%rsp)
xor    %r13d,%r13d
mov    0x30(%rsp),%rcx
mov    0x28(%rsp),%r14
mov    0xc(%rsp),%r8d
mov    0x40(%rsp),%r10d
jmp    1474 <blur_ARGB_8888+0x354>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xd0(%rsp),%rdx
add    %r13d,%edx
mov    0x14(%rsp),%esi
cmp    %esi,%edx
cmovge %esi,%edx
mov    0x60(%rsp),%rsi
mov    %edx,(%rsi,%r13,4)
mov    (%rsp),%edi
add    0x58(%rsp),%edx
movslq %edx,%rdx
mov    0x48(%rsp),%rsi
mov    (%rsi,%rdx,4),%edx
movzbl %dh,%ebx
movzbl %dl,%esi
shr    $0x10,%edx
movzbl %dl,%edx
mov    %edx,(%rax)
mov    %ebx,0x4(%rax)
mov    %esi,0x8(%rax)
add    %edx,%r11d
add    %ebx,%r9d
add    %esi,%edi
add    %r11d,%ebp
add    %r9d,%r15d
add    $0x1,%ecx
mov    %ecx,%eax
cltd
mov    0x28(%rsp),%r14
idiv   %r14d
mov    %edx,%ecx
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
mov    0x38(%rsp),%rsi
mov    (%rsi,%rax,4),%edx
add    %edx,%r10d
sub    %edx,%r11d
mov    0x4(%rsi,%rax,4),%edx
add    %edx,%r8d
sub    %edx,%r9d
add    %edi,%r12d
mov    0x8(%rsi,%rax,4),%eax
mov    0x18(%rsp),%ebx
add    %eax,%ebx
sub    %eax,%edi
mov    %edi,(%rsp)
add    $0x1,%r13
cmp    %r13,0xb8(%rsp)
je     12f0 <blur_ARGB_8888+0x1d0>
movslq %ebp,%rbp
mov    0xc0(%rsp),%rdx
movzwl (%rdx,%rbp,2),%eax
mov    0x38(%rsp),%rdi
mov    0xb0(%rsp),%rsi
mov    %ax,(%rsi,%r13,2)
movslq %r15d,%r15
movzwl (%rdx,%r15,2),%eax
mov    0xa8(%rsp),%rsi
mov    %ax,(%rsi,%r13,2)
movslq %r12d,%r12
movzwl (%rdx,%r12,2),%eax
mov    0xa0(%rsp),%rdx
mov    %ax,(%rdx,%r13,2)
sub    %r10d,%ebp
sub    %r8d,%r15d
sub    %ebx,%r12d
mov    0x50(%rsp),%rax
add    %ecx,%eax
cltd
idiv   %r14d
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
sub    (%rdi,%rax,4),%r10d
sub    0x4(%rdi,%rax,4),%r8d
sub    0x8(%rdi,%rax,4),%ebx
lea    (%rdi,%rax,4),%rax
cmpl   $0x0,0x10(%rsp)
mov    %ebx,0x18(%rsp)
je     13d0 <blur_ARGB_8888+0x2b0>
mov    0x60(%rsp),%rdx
mov    (%rdx,%r13,4),%edx
jmp    13ed <blur_ARGB_8888+0x2cd>
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rsp)
mov    0x28(%rsp),%rax
mov    %eax,%edi
mov    0x90(%rsp),%r8
mov    0x98(%rsp),%rdx
xor    %r9d,%r9d
xor    %r11d,%r11d
xor    %ebx,%ebx
movl   $0x0,0xc(%rsp)
movl   $0x0,0x40(%rsp)
xor    %ebp,%ebp
xor    %r15d,%r15d
xor    %r12d,%r12d
jmp    1580 <blur_ARGB_8888+0x460>
add    %r13d,0x40(%rsp)
add    %esi,0xc(%rsp)
mov    0x18(%rsp),%ecx
add    %ebx,%ecx
mov    %ecx,%ebx
add    %r10d,%ebp
add    %r14d,%r15d
add    %eax,%r12d
add    $0x1,%rdx
add    $0xc,%r8
add    $0xffffffff,%edi
mov    0x48(%rsp),%rcx
je     1364 <blur_ARGB_8888+0x244>
mov    %ebx,0x18(%rsp)
test   %rdx,%rdx
mov    $0x0,%eax
cmovg  %edx,%eax
cmp    0x20(%rsp),%eax
cmovge 0x14(%rsp),%eax
add    0x4(%rsp),%eax
cltq
mov    (%rcx,%rax,4),%eax
movzbl %ah,%esi
movzbl %al,%ebx
shr    $0x10,%eax
movzbl %al,%r13d
mov    %edx,%eax
neg    %eax
cmovns %edx,%eax
add    0x6c(%rsp),%eax
mov    %r13d,%r10d
imul   %eax,%r10d
mov    %esi,%r14d
imul   %eax,%r14d
imul   %ebx,%eax
mov    %r13d,-0x8(%r8)
mov    %esi,-0x4(%r8)
mov    %ebx,(%r8)
test   %rdx,%rdx
jle    1550 <blur_ARGB_8888+0x430>
add    %r13d,%r11d
add    %esi,%r9d
add    %ebx,(%rsp)
mov    0x18(%rsp),%ebx
jmp    1561 <blur_ARGB_8888+0x441>
cmpl   $0x0,0x20(%rsp)
jle    1997 <blur_ARGB_8888+0x877>
mov    0x70(%rsp),%rcx
lea    -0x1(%rcx),%edx
mov    0x8(%rsp),%eax
movslq %eax,%rsi
imul   0x20(%rsp),%eax
mov    %eax,0x8(%rsp)
mov    0x28(%rsp),%rax
mov    %eax,%edi
mov    0x30(%rsp),%rax
sub    %eax,%edi
mov    %rdi,0x58(%rsp)
mov    %eax,%edi
neg    %edi
cmovs  %eax,%edi
mov    %edx,0xc(%rsp)
movslq %edx,%rax
mov    %rax,0xb0(%rsp)
add    $0x1,%edi
mov    %edi,0x10(%rsp)
mov    %ecx,%eax
mov    %rax,0xa8(%rsp)
mov    0xc8(%rsp),%rax
mov    %rsi,0x98(%rsp)
add    %rsi,%rax
lea    (%rax,%rax,2),%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
add    $0x8,%rax
mov    %rax,0x90(%rsp)
mov    0xb8(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    0x48(%rsp),%rax
mov    %rax,0x40(%rsp)
jmp    16d5 <blur_ARGB_8888+0x5b5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
addq   $0x4,0x40(%rsp)
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
cmp    0xb8(%rsp),%rcx
je     1997 <blur_ARGB_8888+0x877>
mov    $0x0,%r9d
mov    $0x0,%r14d
mov    $0x0,%r10d
movl   $0x0,0x4(%rsp)
movl   $0x0,(%rsp)
movl   $0x0,0x50(%rsp)
mov    $0x0,%r8d
mov    $0x0,%r11d
mov    $0x0,%r15d
cmpl   $0x0,0x30(%rsp)
js     1810 <blur_ARGB_8888+0x6f0>
xor    %r15d,%r15d
mov    0x90(%rsp),%rax
mov    0x98(%rsp),%rcx
xor    %r11d,%r11d
xor    %r8d,%r8d
movl   $0x0,0x50(%rsp)
movl   $0x0,(%rsp)
movl   $0x0,0x4(%rsp)
xor    %r10d,%r10d
xor    %r14d,%r14d
xor    %r9d,%r9d
mov    0x8(%rsp),%r12d
jmp    1798 <blur_ARGB_8888+0x678>
nopl   0x0(%rax,%rax,1)
add    %r13d,0x4(%rsp)
add    %edx,(%rsp)
add    %ebx,0x50(%rsp)
add    %esi,%r10d
add    %ebp,%r14d
add    %edi,%r9d
cmp    0xb0(%rsp),%rcx
mov    $0x0,%edx
cmovl  0x20(%rsp),%edx
add    %edx,%r12d
add    $0x1,%rcx
add    $0xc,%rax
cmp    %ecx,0x10(%rsp)
je     1810 <blur_ARGB_8888+0x6f0>
test   %r12d,%r12d
mov    $0x0,%esi
cmovns %r12d,%esi
add    0x18(%rsp),%esi
mov    0x88(%rsp),%rdx
movswl (%rdx,%rsi,2),%r13d
mov    %r13d,-0x8(%rax)
mov    0x80(%rsp),%rdx
movswl (%rdx,%rsi,2),%edx
mov    %edx,-0x4(%rax)
mov    0x78(%rsp),%rdi
movswl (%rdi,%rsi,2),%ebx
mov    %ebx,(%rax)
mov    %ecx,%edi
neg    %edi
cmovns %ecx,%edi
add    0x6c(%rsp),%edi
mov    %edi,%esi
imul   %r13d,%esi
mov    %edi,%ebp
imul   %edx,%ebp
imul   %ebx,%edi
test   %rcx,%rcx
jle    1760 <blur_ARGB_8888+0x640>
add    %r13d,%r8d
add    %edx,%r11d
add    %ebx,%r15d
jmp    176c <blur_ARGB_8888+0x64c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15d,0x14(%rsp)
cmpl   $0x0,0x70(%rsp)
mov    0x38(%rsp),%rbp
mov    0x50(%rsp),%r13d
mov    (%rsp),%ebx
mov    0x4(%rsp),%r15d
jle    16b0 <blur_ARGB_8888+0x590>
mov    0x40(%rsp),%r12
xor    %edi,%edi
mov    0x30(%rsp),%rcx
jmp    190e <blur_ARGB_8888+0x7ee>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xd0(%rsp),%rdx
add    %edi,%edx
mov    0xc(%rsp),%esi
cmp    %esi,%edx
cmovge %esi,%edx
imul   0x20(%rsp),%edx
mov    0x60(%rsp),%rsi
mov    %edx,(%rsi,%rdi,4)
add    0x18(%rsp),%edx
movslq %edx,%rdx
mov    0x88(%rsp),%rsi
movswl (%rsi,%rdx,2),%esi
mov    %esi,(%rax)
mov    0x80(%rsp),%rbx
movswl (%rbx,%rdx,2),%ebx
mov    %ebx,0x4(%rax)
mov    0x78(%rsp),%rbp
movswl 0x0(%rbp,%rdx,2),%edx
mov    %edx,0x8(%rax)
add    %esi,%r8d
add    %ebx,%r11d
mov    0x14(%rsp),%esi
add    %edx,%esi
add    %r8d,%r10d
add    %r11d,%r14d
add    $0x1,%ecx
mov    %ecx,%eax
cltd
mov    0x28(%rsp),%rbx
idiv   %ebx
mov    %edx,%ecx
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
mov    0x38(%rsp),%rbp
mov    0x0(%rbp,%rax,4),%edx
add    %edx,%r15d
sub    %edx,%r8d
mov    0x4(%rbp,%rax,4),%edx
mov    (%rsp),%ebx
add    %edx,%ebx
sub    %edx,%r11d
add    %esi,%r9d
mov    0x8(%rbp,%rax,4),%eax
add    %eax,%r13d
sub    %eax,%esi
mov    %esi,0x14(%rsp)
add    $0x1,%rdi
add    0xa0(%rsp),%r12
cmp    %rdi,0xa8(%rsp)
je     16b0 <blur_ARGB_8888+0x590>
movzbl 0x3(%r12),%eax
shl    $0x18,%eax
movslq %r10d,%r10
mov    0xc0(%rsp),%rsi
movzwl (%rsi,%r10,2),%edx
shl    $0x10,%edx
or     %eax,%edx
movslq %r14d,%r14
movswl (%rsi,%r14,2),%eax
shl    $0x8,%eax
movslq %r9d,%r9
movswl (%rsi,%r9,2),%esi
or     %eax,%esi
or     %edx,%esi
mov    %esi,(%r12)
sub    %r15d,%r10d
sub    %ebx,%r14d
sub    %r13d,%r9d
mov    0x58(%rsp),%rax
add    %ecx,%eax
cltd
idivl  0x28(%rsp)
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
sub    0x0(%rbp,%rax,4),%r15d
sub    0x4(%rbp,%rax,4),%ebx
sub    0x8(%rbp,%rax,4),%r13d
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
cmpl   $0x0,0x18(%rsp)
mov    %ebx,(%rsp)
je     1850 <blur_ARGB_8888+0x730>
mov    0x60(%rsp),%rdx
mov    (%rdx,%rdi,4),%edx
jmp    1870 <blur_ARGB_8888+0x750>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0xc0(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%sil
jne    1216 <blur_ARGB_8888+0xf6>
jmp    1221 <blur_ARGB_8888+0x101>

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

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