short *blur_RGB_565(short *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, p, i, 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)&0xF800) >> 11) << 3;
      sir[1] = (((p)&0x7E0) >> 5) << 2;
      sir[2] = ((p)&0x1F) << 3;
      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)&0xF800) >> 11) << 3;
      sir[1] = (((p)&0x7E0) >> 5) << 2;
      sir[2] = ((p)&0x1F) << 3;
      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] = ((((dv[rsum]) >> 3) << 11) | (((dv[gsum]) >> 2) << 5) |
                 ((dv[bsum]) >> 3));
      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_RGB_565>:
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_RGB_565+0x8d>
mov    -0xc(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    11b6 <blur_RGB_565+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,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x74(%rbp),%ecx
shl    $0x8,%ecx
cmp    %ecx,%eax
jge    1234 <blur_RGB_565+0x114>
mov    -0x5c(%rbp),%eax
cltd
idivl  -0x74(%rbp)
mov    %ax,%dx
mov    -0x80(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11ff <blur_RGB_565+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    183d <blur_RGB_565+0x71d>
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,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     151e <blur_RGB_565+0x3fe>
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,-0x5c(%rbp)
jle    1312 <blur_RGB_565+0x1f2>
mov    -0x5c(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    131f <blur_RGB_565+0x1ff>
xor    %eax,%eax
mov    %eax,-0xd4(%rbp)
jmp    131f <blur_RGB_565+0x1ff>
mov    -0xc0(%rbp),%eax
mov    -0xd4(%rbp),%ecx
cmp    %ecx,%eax
jge    1341 <blur_RGB_565+0x221>
mov    -0x18(%rbp),%eax
mov    %eax,-0xd8(%rbp)
jmp    1372 <blur_RGB_565+0x252>
cmpl   $0x0,-0x5c(%rbp)
jle    1359 <blur_RGB_565+0x239>
mov    -0x5c(%rbp),%eax
mov    %eax,-0xdc(%rbp)
jmp    1366 <blur_RGB_565+0x246>
xor    %eax,%eax
mov    %eax,-0xdc(%rbp)
jmp    1366 <blur_RGB_565+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
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x58(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x58(%rbp),%ecx
and    $0xf800,%ecx
sar    $0xb,%ecx
shl    $0x3,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%ecx
and    $0x7e0,%ecx
sar    $0x5,%ecx
shl    $0x2,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x58(%rbp),%ecx
and    $0x1f,%ecx
shl    $0x3,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0xa0(%rbp),%eax
mov    %eax,-0xe0(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jge    1419 <blur_RGB_565+0x2f9>
xor    %eax,%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0xe4(%rbp)
jmp    1422 <blur_RGB_565+0x302>
mov    -0x5c(%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,-0x5c(%rbp)
jle    14ca <blur_RGB_565+0x3aa>
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    150b <blur_RGB_565+0x3eb>
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    1510 <blur_RGB_565+0x3f0>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12d1 <blur_RGB_565+0x1b1>
mov    -0x14(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1826 <blur_RGB_565+0x706>
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    167f <blur_RGB_565+0x55f>
mov    -0x50(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1,%eax
cmp    -0x18(%rbp),%eax
jge    1665 <blur_RGB_565+0x545>
mov    -0x50(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    166e <blur_RGB_565+0x54e>
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
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%ecx
and    $0xf800,%ecx
sar    $0xb,%ecx
shl    $0x3,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%ecx
and    $0x7e0,%ecx
sar    $0x5,%ecx
shl    $0x2,%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x58(%rbp),%ecx
and    $0x1f,%ecx
shl    $0x3,%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    152e <blur_RGB_565+0x40e>
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_RGB_565+0x14c>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d95 <blur_RGB_565+0xc75>
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,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1a94 <blur_RGB_565+0x974>
xor    %eax,%eax
cmp    -0x60(%rbp),%eax
jle    18d9 <blur_RGB_565+0x7b9>
xor    %eax,%eax
mov    %eax,-0x104(%rbp)
jmp    18e2 <blur_RGB_565+0x7c2>
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    -0x5c(%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,-0x5c(%rbp)
jge    1973 <blur_RGB_565+0x853>
xor    %eax,%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x10c(%rbp)
jmp    197c <blur_RGB_565+0x85c>
mov    -0x5c(%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,-0x5c(%rbp)
jle    1a2b <blur_RGB_565+0x90b>
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    1a6c <blur_RGB_565+0x94c>
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    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1a81 <blur_RGB_565+0x961>
mov    -0xc(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1a86 <blur_RGB_565+0x966>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    18b5 <blur_RGB_565+0x795>
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    1d82 <blur_RGB_565+0xc62>
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
sar    $0x3,%eax
shl    $0xb,%eax
mov    -0x80(%rbp),%rcx
movslq -0x48(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
sar    $0x2,%ecx
shl    $0x5,%ecx
or     %ecx,%eax
mov    -0x80(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
sar    $0x3,%ecx
or     %ecx,%eax
mov    %ax,%dx
mov    -0x8(%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,-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    1bfd <blur_RGB_565+0xadd>
mov    -0x54(%rbp),%eax
add    -0xa0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1bdf <blur_RGB_565+0xabf>
mov    -0x54(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0x11c(%rbp)
jmp    1be8 <blur_RGB_565+0xac8>
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,-0x58(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
movslq -0x58(%rbp),%rcx
movswl (%rax,%rcx,2),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x40(%rbp),%rax
movslq -0x58(%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    1aaa <blur_RGB_565+0x98a>
jmp    1d87 <blur_RGB_565+0xc67>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1844 <blur_RGB_565+0x724>
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_RGB_565>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %ecx,%r15d
mov    %edx,%ebp
mov    %esi,%ebx
mov    %rdi,0x38(%rsp)
mov    %edx,%eax
imul   %esi,%eax
lea    (%r15,%r15,1),%ecx
add    $0x1,%ecx
mov    %rcx,0x48(%rsp)
movslq %eax,%r14
add    %r14,%r14
mov    %r14,%rdi
call   1040 <malloc@plt>
mov    %rax,0x98(%rsp)
mov    %r14,%rdi
call   1040 <malloc@plt>
mov    %rax,0x90(%rsp)
mov    %r14,%rdi
call   1040 <malloc@plt>
mov    %rax,0x88(%rsp)
cmp    %ebp,%ebx
mov    %rbp,0x80(%rsp)
mov    %ebp,%eax
mov    %rbx,0x30(%rsp)
cmovg  %ebx,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,0x70(%rsp)
mov    %r15,0x40(%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_RGB_565+0x101>
mov    %ebx,%eax
shl    $0x8,%eax
cmp    $0x2,%eax
mov    $0x1,%esi
cmovae %eax,%esi
test   %eax,%eax
je     1a2f <blur_RGB_565+0x90f>
mov    %esi,%edi
and    $0xffffff00,%edi
xor    %ecx,%ecx
nopl   (%rax)
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_RGB_565+0xd0>
test   $0x1,%sil
je     1221 <blur_RGB_565+0x101>
mov    %ecx,%eax
xor    %edx,%edx
div    %ebx
mov    %ax,0x0(%rbp,%rcx,2)
mov    %rbp,0xd0(%rsp)
mov    0x40(%rsp),%rbx
mov    %ebx,%eax
neg    %eax
mov    %eax,0x1c(%rsp)
mov    0x48(%rsp),%rbp
lea    0x0(%rbp,%rbp,2),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,%r13
lea    0x1(%rbx),%eax
movslq %ebx,%rcx
mov    %rcx,0xd8(%rsp)
mov    0x30(%rsp),%ecx
mov    %rcx,0xc8(%rsp)
mov    %eax,0x7c(%rsp)
mov    %eax,%eax
mov    %rax,0xe0(%rsp)
cmpl   $0x0,0x80(%rsp)
mov    0x38(%rsp),%rsi
mov    %r13,0x58(%rsp)
jle    163a <blur_RGB_565+0x51a>
mov    0x30(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0xc(%rsp)
sub    0x40(%rsp),%ebp
mov    %rbp,0x60(%rsp)
movslq 0x1c(%rsp),%rcx
mov    0xd8(%rsp),%rax
mov    %rcx,0xa8(%rsp)
add    %rcx,%rax
lea    (%rax,%rax,2),%rax
lea    0x8(,%rax,4),%rax
add    %r13,%rax
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
mov    %rax,0x68(%rsp)
movl   $0x0,0x20(%rsp)
movl   $0x0,0x24(%rsp)
jmp    1323 <blur_RGB_565+0x203>
nopl   0x0(%rax,%rax,1)
add    %r12d,0x20(%rsp)
mov    %r8,%r13
mov    0x38(%rsp),%rsi
mov    0x68(%rsp),%rax
add    0x30(%rsp),%eax
mov    %rax,0x68(%rsp)
mov    0x24(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x24(%rsp)
cmp    0x80(%rsp),%eax
je     163a <blur_RGB_565+0x51a>
mov    $0x0,%r10d
mov    $0x0,%ebp
mov    $0x0,%ebx
mov    $0x0,%r9d
mov    $0x0,%r15d
movl   $0x0,0x50(%rsp)
movl   $0x0,0x10(%rsp)
movl   $0x0,0x28(%rsp)
mov    $0x0,%r11d
mov    0x1c(%rsp),%eax
cmp    0x40(%rsp),%eax
jle    1530 <blur_RGB_565+0x410>
cmpl   $0x0,0x30(%rsp)
jle    1630 <blur_RGB_565+0x510>
movslq 0x20(%rsp),%rax
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,2),%rcx
mov    %rcx,0xc0(%rsp)
mov    0x90(%rsp),%rcx
lea    (%rcx,%rax,2),%rcx
mov    %rcx,0xb8(%rsp)
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,2),%rax
mov    %rax,0xb0(%rsp)
xor    %r12d,%r12d
mov    0x40(%rsp),%rcx
mov    0x48(%rsp),%rdi
mov    0x58(%rsp),%r8
mov    0x50(%rsp),%r14d
jmp    14a1 <blur_RGB_565+0x381>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xe0(%rsp),%rdx
add    %r12d,%edx
mov    0xc(%rsp),%edi
cmp    %edi,%edx
cmovge %edi,%edx
mov    0x70(%rsp),%rdi
mov    %edx,(%rdi,%r12,4)
mov    0x38(%rsp),%rdi
add    0x68(%rsp),%edx
movslq %edx,%rdx
movswl (%rdi,%rdx,2),%edx
mov    %edx,%r13d
shr    $0x8,%r13d
and    $0xf8,%r13d
mov    %r13d,(%rax)
mov    %edx,%edi
shr    $0x3,%edi
and    $0xfc,%edi
mov    %edi,0x4(%rax)
shl    $0x3,%edx
movzbl %dl,%edx
mov    %edx,0x8(%rax)
add    0x10(%rsp),%r13d
add    0x28(%rsp),%edi
add    %edx,%r11d
add    %r13d,%ebx
add    %edi,%ebp
add    $0x1,%ecx
mov    %ecx,%eax
cltd
mov    0x48(%rsp),%rsi
idiv   %esi
mov    %edx,%ecx
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
mov    0x58(%rsp),%r8
mov    (%r8,%rax,4),%edx
add    %edx,%r9d
sub    %edx,%r13d
mov    0x4(%r8,%rax,4),%edx
add    %edx,%r15d
sub    %edx,%edi
add    %r11d,%r10d
mov    0x8(%r8,%rax,4),%eax
add    %eax,%r14d
sub    %eax,%r11d
add    $0x1,%r12
mov    %edi,0x28(%rsp)
mov    %rsi,%rdi
mov    %r13d,0x10(%rsp)
cmp    %r12,0xc8(%rsp)
je     12f0 <blur_RGB_565+0x1d0>
movslq %ebx,%rbx
mov    0xd0(%rsp),%rsi
movzwl (%rsi,%rbx,2),%eax
mov    0xc0(%rsp),%rdx
mov    %ax,(%rdx,%r12,2)
movslq %ebp,%rbp
movzwl (%rsi,%rbp,2),%eax
mov    0xb8(%rsp),%rdx
mov    %ax,(%rdx,%r12,2)
movslq %r10d,%r10
movzwl (%rsi,%r10,2),%eax
mov    0xb0(%rsp),%rdx
mov    %ax,(%rdx,%r12,2)
sub    %r9d,%ebx
sub    %r15d,%ebp
sub    %r14d,%r10d
mov    0x60(%rsp),%rax
add    %ecx,%eax
cltd
idiv   %edi
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
sub    (%r8,%rax,4),%r9d
sub    0x4(%r8,%rax,4),%r15d
sub    0x8(%r8,%rax,4),%r14d
lea    (%r8,%rax,4),%rax
cmpl   $0x0,0x24(%rsp)
je     13e0 <blur_RGB_565+0x2c0>
mov    0x70(%rsp),%rdx
mov    (%rdx,%r12,4),%edx
jmp    13fd <blur_RGB_565+0x2dd>
nopl   0x0(%rax,%rax,1)
xor    %r11d,%r11d
mov    0x48(%rsp),%rax
mov    %eax,%r12d
mov    0xa0(%rsp),%rcx
mov    0xa8(%rsp),%rdx
movl   $0x0,0x28(%rsp)
movl   $0x0,0x10(%rsp)
movl   $0x0,0x50(%rsp)
xor    %r15d,%r15d
xor    %r9d,%r9d
xor    %ebx,%ebx
xor    %ebp,%ebp
xor    %r10d,%r10d
jmp    15ab <blur_RGB_565+0x48b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %esi,%r9d
add    %eax,%r15d
add    %r8d,0x50(%rsp)
mov    0x38(%rsp),%rsi
add    %r14d,%ebx
add    %r13d,%ebp
add    %edi,%r10d
add    $0x1,%rdx
add    $0xc,%rcx
add    $0xffffffff,%r12d
je     136b <blur_RGB_565+0x24b>
test   %rdx,%rdx
mov    $0x0,%eax
cmovg  %edx,%eax
cmp    0x30(%rsp),%eax
cmovge 0xc(%rsp),%eax
add    0x20(%rsp),%eax
cltq
movswl (%rsi,%rax,2),%edi
mov    %edi,%esi
shr    $0x8,%esi
and    $0xf8,%esi
mov    %edi,%eax
shr    $0x3,%eax
and    $0xfc,%eax
shl    $0x3,%edi
movzbl %dil,%r8d
mov    %edx,%edi
neg    %edi
cmovns %edx,%edi
add    0x7c(%rsp),%edi
mov    %esi,%r14d
imul   %edi,%r14d
mov    %eax,%r13d
imul   %edi,%r13d
imul   %r8d,%edi
mov    %esi,-0x8(%rcx)
mov    %eax,-0x4(%rcx)
mov    %r8d,(%rcx)
test   %rdx,%rdx
jle    1580 <blur_RGB_565+0x460>
add    %esi,0x10(%rsp)
add    %eax,0x28(%rsp)
add    %r8d,%r11d
jmp    158b <blur_RGB_565+0x46b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x58(%rsp),%r13
jmp    12fd <blur_RGB_565+0x1dd>
cmpl   $0x0,0x30(%rsp)
jle    19d2 <blur_RGB_565+0x8b2>
mov    0x80(%rsp),%rcx
lea    -0x1(%rcx),%edx
mov    0x1c(%rsp),%eax
movslq %eax,%rsi
imul   0x30(%rsp),%eax
mov    %eax,0x1c(%rsp)
mov    0x48(%rsp),%rax
mov    %eax,%edi
mov    0x40(%rsp),%rax
sub    %eax,%edi
mov    %rdi,0x68(%rsp)
mov    %eax,%edi
neg    %edi
cmovs  %eax,%edi
mov    %edx,0x20(%rsp)
movslq %edx,%rax
mov    %rax,0xc0(%rsp)
add    $0x1,%edi
mov    %edi,0x24(%rsp)
mov    %ecx,%eax
mov    %rax,0xb8(%rsp)
mov    0xd8(%rsp),%rax
mov    %rsi,0xa8(%rsp)
add    %rsi,%rax
lea    (%rax,%rax,2),%rax
lea    0x8(,%rax,4),%rax
add    %r13,%rax
mov    %rax,0xa0(%rsp)
mov    0xc8(%rsp),%rax
add    %rax,%rax
mov    %rax,0xb0(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    0x38(%rsp),%rax
mov    %rax,0x50(%rsp)
jmp    1718 <blur_RGB_565+0x5f8>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
addq   $0x2,0x50(%rsp)
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
cmp    0xc8(%rsp),%rcx
mov    %rbp,%r13
je     19d2 <blur_RGB_565+0x8b2>
mov    $0x0,%r10d
mov    $0x0,%r14d
mov    $0x0,%r8d
movl   $0x0,0xc(%rsp)
movl   $0x0,0x60(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%r11d
mov    $0x0,%r9d
mov    $0x0,%r15d
cmpl   $0x0,0x40(%rsp)
js     1850 <blur_RGB_565+0x730>
xor    %r15d,%r15d
mov    0xa0(%rsp),%rax
mov    0xa8(%rsp),%rcx
xor    %r9d,%r9d
xor    %r11d,%r11d
movl   $0x0,0x10(%rsp)
movl   $0x0,0x60(%rsp)
movl   $0x0,0xc(%rsp)
xor    %r8d,%r8d
xor    %r14d,%r14d
xor    %r10d,%r10d
mov    0x1c(%rsp),%r12d
jmp    17de <blur_RGB_565+0x6be>
add    %r13d,0xc(%rsp)
add    %edx,0x60(%rsp)
add    %ebp,0x10(%rsp)
mov    0x58(%rsp),%r13
add    %esi,%r8d
add    %ebx,%r14d
add    %edi,%r10d
cmp    0xc0(%rsp),%rcx
mov    $0x0,%edx
cmovl  0x30(%rsp),%edx
add    %edx,%r12d
add    $0x1,%rcx
add    $0xc,%rax
cmp    %ecx,0x24(%rsp)
je     1850 <blur_RGB_565+0x730>
test   %r12d,%r12d
mov    $0x0,%esi
cmovns %r12d,%esi
add    0x28(%rsp),%esi
mov    0x98(%rsp),%rdx
movswl (%rdx,%rsi,2),%r13d
mov    %r13d,-0x8(%rax)
mov    0x90(%rsp),%rdx
movswl (%rdx,%rsi,2),%edx
mov    %edx,-0x4(%rax)
mov    0x88(%rsp),%rdi
movswl (%rdi,%rsi,2),%ebp
mov    %ebp,(%rax)
mov    %ecx,%edi
neg    %edi
cmovns %ecx,%edi
add    0x7c(%rsp),%edi
mov    %edi,%esi
imul   %r13d,%esi
mov    %edi,%ebx
imul   %edx,%ebx
imul   %ebp,%edi
test   %rcx,%rcx
jle    17a0 <blur_RGB_565+0x680>
add    %r13d,%r11d
add    %edx,%r9d
add    %ebp,%r15d
jmp    17ad <blur_RGB_565+0x68d>
nopl   0x0(%rax)
cmpl   $0x0,0x80(%rsp)
mov    %r13,%rbp
mov    0x10(%rsp),%r13d
mov    0x60(%rsp),%r12d
mov    0xc(%rsp),%esi
jle    16f0 <blur_RGB_565+0x5d0>
mov    0x50(%rsp),%rax
xor    %edi,%edi
mov    0x40(%rsp),%rcx
jmp    1941 <blur_RGB_565+0x821>
mov    0xe0(%rsp),%rdx
add    %edi,%edx
mov    0x20(%rsp),%esi
cmp    %esi,%edx
cmovge %esi,%edx
imul   0x30(%rsp),%edx
mov    0x70(%rsp),%rsi
mov    %edx,(%rsi,%rdi,4)
add    0x28(%rsp),%edx
movslq %edx,%rdx
mov    0x98(%rsp),%rsi
movswl (%rsi,%rdx,2),%esi
mov    %esi,(%rax)
mov    0x90(%rsp),%rbx
movswl (%rbx,%rdx,2),%ebx
mov    %ebx,0x4(%rax)
mov    0x88(%rsp),%rbp
movswl 0x0(%rbp,%rdx,2),%edx
mov    %edx,0x8(%rax)
add    %esi,%r11d
add    %ebx,%r9d
add    %edx,%r15d
add    %r11d,%r8d
add    %r9d,%r14d
add    $0x1,%ecx
mov    %ecx,%eax
cltd
mov    0x48(%rsp),%rbx
idiv   %ebx
mov    %edx,%ecx
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
mov    0x58(%rsp),%rbp
mov    0x0(%rbp,%rax,4),%edx
mov    0xc(%rsp),%esi
add    %edx,%esi
sub    %edx,%r11d
mov    0x4(%rbp,%rax,4),%edx
add    %edx,%r12d
sub    %edx,%r9d
add    %r15d,%r10d
mov    0x8(%rbp,%rax,4),%eax
add    %eax,%r13d
sub    %eax,%r15d
add    $0x1,%rdi
mov    0x10(%rsp),%rax
add    0xb0(%rsp),%rax
cmp    %rdi,0xb8(%rsp)
je     16f0 <blur_RGB_565+0x5d0>
mov    %rax,0x10(%rsp)
movslq %r8d,%r8
mov    0xd0(%rsp),%rbx
movzwl (%rbx,%r8,2),%eax
and    $0xfffffff8,%eax
shl    $0x8,%eax
movslq %r14d,%r14
movzwl (%rbx,%r14,2),%edx
shl    $0x3,%edx
and    $0xffffffe0,%edx
or     %eax,%edx
movslq %r10d,%r10
movswl (%rbx,%r10,2),%eax
sar    $0x3,%eax
or     %edx,%eax
mov    0x10(%rsp),%rdx
mov    %ax,(%rdx)
sub    %esi,%r8d
sub    %r12d,%r14d
sub    %r13d,%r10d
mov    0x68(%rsp),%rax
add    %ecx,%eax
cltd
idivl  0x48(%rsp)
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
sub    0x0(%rbp,%rax,4),%esi
sub    0x4(%rbp,%rax,4),%r12d
sub    0x8(%rbp,%rax,4),%r13d
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
cmpl   $0x0,0x28(%rsp)
mov    %esi,0xc(%rsp)
je     1880 <blur_RGB_565+0x760>
mov    0x70(%rsp),%rdx
mov    (%rdx,%rdi,4),%edx
jmp    18a0 <blur_RGB_565+0x780>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    0x90(%rsp),%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    0xd0(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rax
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%sil
jne    1216 <blur_RGB_565+0xf6>
jmp    1221 <blur_RGB_565+0x101>

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

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