int *StackBlur(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;
  int *r = (int *)malloc(wh * sizeof(int));
  int *g = (int *)malloc(wh * sizeof(int));
  int *b = (int *)malloc(wh * sizeof(int));
  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;
  int *dv = (int *)malloc(256 * divsum * sizeof(int));
  for (i = 0; i < 256 * divsum; i++) {
    dv[i] = (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):
<StackBlur>:
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    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    11ad <StackBlur+0x8d>
mov    -0xc(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    11b6 <StackBlur+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    $0x2,%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    1232 <StackBlur+0x112>
mov    -0x58(%rbp),%eax
cltd
idivl  -0x74(%rbp)
mov    %eax,%edx
mov    -0x80(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    11ff <StackBlur+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    1827 <StackBlur+0x707>
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     1515 <StackBlur+0x3f5>
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    1310 <StackBlur+0x1f0>
mov    -0x58(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    131d <StackBlur+0x1fd>
xor    %eax,%eax
mov    %eax,-0xd4(%rbp)
jmp    131d <StackBlur+0x1fd>
mov    -0xc0(%rbp),%eax
mov    -0xd4(%rbp),%ecx
cmp    %ecx,%eax
jge    133f <StackBlur+0x21f>
mov    -0x18(%rbp),%eax
mov    %eax,-0xd8(%rbp)
jmp    1370 <StackBlur+0x250>
cmpl   $0x0,-0x58(%rbp)
jle    1357 <StackBlur+0x237>
mov    -0x58(%rbp),%eax
mov    %eax,-0xdc(%rbp)
jmp    1364 <StackBlur+0x244>
xor    %eax,%eax
mov    %eax,-0xdc(%rbp)
jmp    1364 <StackBlur+0x244>
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    1410 <StackBlur+0x2f0>
xor    %eax,%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xe4(%rbp)
jmp    1419 <StackBlur+0x2f9>
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    14c1 <StackBlur+0x3a1>
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    1502 <StackBlur+0x3e2>
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    1507 <StackBlur+0x3e7>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12cf <StackBlur+0x1af>
mov    -0x14(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1810 <StackBlur+0x6f0>
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%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,-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    1670 <StackBlur+0x550>
mov    -0x50(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1,%eax
cmp    -0x18(%rbp),%eax
jge    1656 <StackBlur+0x536>
mov    -0x50(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    165f <StackBlur+0x53f>
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    1525 <StackBlur+0x405>
mov    -0xc(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    126a <StackBlur+0x14a>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d77 <StackBlur+0xc57>
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     1a78 <StackBlur+0x958>
xor    %eax,%eax
cmp    -0x60(%rbp),%eax
jle    18c3 <StackBlur+0x7a3>
xor    %eax,%eax
mov    %eax,-0x104(%rbp)
jmp    18cc <StackBlur+0x7ac>
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
mov    (%rax,%rcx,4),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x108(%rbp)
cmpl   $0x0,-0x58(%rbp)
jge    195a <StackBlur+0x83a>
xor    %eax,%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x10c(%rbp)
jmp    1963 <StackBlur+0x843>
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
mov    (%rax,%rcx,4),%eax
imul   -0x9c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x9c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x9c(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x58(%rbp)
jle    1a0f <StackBlur+0x8ef>
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    1a50 <StackBlur+0x930>
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    1a65 <StackBlur+0x945>
mov    -0xc(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1a6a <StackBlur+0x94a>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    189f <StackBlur+0x77f>
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    1d64 <StackBlur+0xc44>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
and    $0xff000000,%edx
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x10,%eax
or     %eax,%edx
mov    -0x80(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x8,%eax
or     %eax,%edx
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
or     (%rax,%rcx,4),%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    1be2 <StackBlur+0xac2>
mov    -0x54(%rbp),%eax
add    -0xa0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1bc4 <StackBlur+0xaa4>
mov    -0x54(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0x11c(%rbp)
jmp    1bcd <StackBlur+0xaad>
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
mov    (%rax,%rcx,4),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x98(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%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    1a8e <StackBlur+0x96e>
jmp    1d69 <StackBlur+0xc49>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    182e <StackBlur+0x70e>
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):
<StackBlur>:
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
shl    $0x2,%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),%ebp
add    $0x2,%ebp
sar    %ebp
imul   %ebp,%ebp
mov    %ebp,%r14d
shl    $0x8,%r14d
lea    0x0(,%r14,4),%rdi
call   1040 <malloc@plt>
mov    %rax,%rbx
test   %ebp,%ebp
je     121c <StackBlur+0xfc>
cmp    $0x2,%r14d
mov    $0x1,%esi
cmovae %r14d,%esi
mov    %esi,%edi
and    $0x7fffff00,%edi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %ecx,%eax
xor    %edx,%edx
div    %ebp
mov    %eax,(%rbx,%rcx,4)
lea    0x1(%rcx),%eax
xor    %edx,%edx
div    %ebp
mov    %eax,0x4(%rbx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    11f0 <StackBlur+0xd0>
test   $0x1,%sil
je     121c <StackBlur+0xfc>
mov    %ecx,%eax
xor    %edx,%edx
div    %ebp
mov    %eax,(%rbx,%rcx,4)
mov    0x30(%rsp),%rbp
mov    %ebp,%eax
neg    %eax
mov    %eax,0x10(%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(%rbp),%eax
movslq %ebp,%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
mov    %rbx,0xc0(%rsp)
jle    15eb <StackBlur+0x4cb>
mov    0x20(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x1c(%rsp)
mov    0x28(%rsp),%rax
sub    0x30(%rsp),%eax
mov    %rax,0x50(%rsp)
movslq 0x10(%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,0x18(%rsp)
jmp    131d <StackBlur+0x1fd>
cs nopw 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    0x18(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x18(%rsp)
cmp    0x70(%rsp),%eax
je     15eb <StackBlur+0x4cb>
mov    $0x0,%r12d
mov    $0x0,%r15d
mov    $0x0,%ebp
movl   $0x0,0x40(%rsp)
movl   $0x0,0x14(%rsp)
movl   $0x0,0x8(%rsp)
mov    $0x0,%r8d
mov    $0x0,%r9d
mov    $0x0,%r14d
mov    0x10(%rsp),%eax
cmp    0x30(%rsp),%eax
jle    1510 <StackBlur+0x3f0>
cmpl   $0x0,0x20(%rsp)
jle    12fa <StackBlur+0x1da>
mov    %r14d,(%rsp)
movslq 0x4(%rsp),%rax
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
mov    %rcx,0xb0(%rsp)
mov    0x80(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
mov    %rcx,0xa8(%rsp)
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,0xa0(%rsp)
xor    %r13d,%r13d
mov    0x30(%rsp),%rcx
mov    0x28(%rsp),%r14
mov    0x8(%rsp),%ebx
mov    0x14(%rsp),%r10d
mov    0x40(%rsp),%r11d
jmp    1474 <StackBlur+0x354>
nop
mov    0xd0(%rsp),%rdx
add    %r13d,%edx
mov    0x1c(%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,%r8d
add    %ebx,%r9d
add    %esi,%edi
add    %r8d,%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,%r11d
sub    %edx,%r8d
mov    0x4(%rsi,%rax,4),%edx
add    %edx,%r10d
sub    %edx,%r9d
add    %edi,%r12d
mov    0x8(%rsi,%rax,4),%eax
mov    0x8(%rsp),%ebx
add    %eax,%ebx
sub    %eax,%edi
mov    %edi,(%rsp)
add    $0x1,%r13
cmp    %r13,0xb8(%rsp)
je     12f0 <StackBlur+0x1d0>
movslq %ebp,%rbp
mov    0xc0(%rsp),%rdx
mov    (%rdx,%rbp,4),%eax
mov    0x38(%rsp),%rdi
mov    0xb0(%rsp),%rsi
mov    %eax,(%rsi,%r13,4)
movslq %r15d,%r15
mov    (%rdx,%r15,4),%eax
mov    0xa8(%rsp),%rsi
mov    %eax,(%rsi,%r13,4)
movslq %r12d,%r12
mov    (%rdx,%r12,4),%eax
mov    0xa0(%rsp),%rdx
mov    %eax,(%rdx,%r13,4)
sub    %r11d,%ebp
sub    %r10d,%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),%r11d
sub    0x4(%rdi,%rax,4),%r10d
sub    0x8(%rdi,%rax,4),%ebx
lea    (%rdi,%rax,4),%rax
cmpl   $0x0,0x18(%rsp)
mov    %ebx,0x8(%rsp)
je     13d0 <StackBlur+0x2b0>
mov    0x60(%rsp),%rdx
mov    (%rdx,%r13,4),%edx
jmp    13ed <StackBlur+0x2cd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %r14d,%r14d
mov    0x28(%rsp),%rax
mov    %eax,%edi
mov    0x90(%rsp),%r10
mov    0x98(%rsp),%rdx
xor    %r9d,%r9d
xor    %r8d,%r8d
movl   $0x0,0x8(%rsp)
movl   $0x0,0x14(%rsp)
movl   $0x0,0x40(%rsp)
xor    %ebp,%ebp
xor    %r15d,%r15d
xor    %r12d,%r12d
jmp    158c <StackBlur+0x46c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %r13d,0x40(%rsp)
add    %esi,0x14(%rsp)
add    %ebx,0x8(%rsp)
add    %r11d,%ebp
add    %ecx,%r15d
add    %eax,%r12d
add    $0x1,%rdx
add    $0xc,%r10
add    $0xffffffff,%edi
mov    0x48(%rsp),%rcx
je     1366 <StackBlur+0x246>
test   %rdx,%rdx
mov    $0x0,%eax
cmovg  %edx,%eax
cmp    0x20(%rsp),%eax
cmovge 0x1c(%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,%r11d
imul   %eax,%r11d
mov    %esi,%ecx
imul   %eax,%ecx
imul   %ebx,%eax
mov    %r13d,-0x8(%r10)
mov    %esi,-0x4(%r10)
mov    %ebx,(%r10)
test   %rdx,%rdx
jle    1560 <StackBlur+0x440>
add    %r13d,%r8d
add    %esi,%r9d
add    %ebx,%r14d
jmp    156d <StackBlur+0x44d>
cmpl   $0x0,0x20(%rsp)
jle    1969 <StackBlur+0x849>
mov    0x70(%rsp),%rcx
lea    -0x1(%rcx),%edx
mov    0x10(%rsp),%eax
movslq %eax,%rsi
imul   0x20(%rsp),%eax
mov    %eax,0x10(%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,0x14(%rsp)
movslq %edx,%rax
mov    %rax,0xb0(%rsp)
add    $0x1,%edi
mov    %edi,0x18(%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,0x8(%rsp)
mov    0x48(%rsp),%rax
mov    %rax,0x40(%rsp)
jmp    16c5 <StackBlur+0x5a5>
nop
mov    0x8(%rsp),%rcx
add    $0x1,%rcx
addq   $0x4,0x40(%rsp)
mov    %rcx,%rax
mov    %rcx,0x8(%rsp)
cmp    0xb8(%rsp),%rcx
je     1969 <StackBlur+0x849>
mov    $0x0,%r9d
mov    $0x0,%r14d
mov    $0x0,%r15d
movl   $0x0,0x4(%rsp)
movl   $0x0,(%rsp)
movl   $0x0,0x50(%rsp)
mov    $0x0,%r8d
mov    $0x0,%r11d
mov    $0x0,%r10d
cmpl   $0x0,0x30(%rsp)
js     17f0 <StackBlur+0x6d0>
xor    %r10d,%r10d
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    %r15d,%r15d
xor    %r14d,%r14d
xor    %r9d,%r9d
mov    0x10(%rsp),%r12d
jmp    1787 <StackBlur+0x667>
nopl   0x0(%rax,%rax,1)
add    %esi,0x4(%rsp)
add    %ebp,(%rsp)
add    %ebx,0x50(%rsp)
add    %r13d,%r15d
add    %edx,%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,0x18(%rsp)
je     17f0 <StackBlur+0x6d0>
test   %r12d,%r12d
mov    $0x0,%edx
cmovns %r12d,%edx
add    0x8(%rsp),%edx
mov    0x88(%rsp),%rsi
mov    (%rsi,%rdx,4),%esi
mov    %esi,-0x8(%rax)
mov    0x80(%rsp),%rdi
mov    (%rdi,%rdx,4),%ebp
mov    %ebp,-0x4(%rax)
mov    0x78(%rsp),%rdi
mov    (%rdi,%rdx,4),%ebx
mov    %ebx,(%rax)
mov    %ecx,%edi
neg    %edi
cmovns %ecx,%edi
add    0x6c(%rsp),%edi
mov    %esi,%r13d
imul   %edi,%r13d
mov    %ebp,%edx
imul   %edi,%edx
imul   %ebx,%edi
test   %rcx,%rcx
jle    1750 <StackBlur+0x630>
add    %esi,%r8d
add    %ebp,%r11d
add    %ebx,%r10d
jmp    175b <StackBlur+0x63b>
xchg   %ax,%ax
mov    %r10d,0x1c(%rsp)
cmpl   $0x0,0x70(%rsp)
mov    0x38(%rsp),%rbx
mov    0x50(%rsp),%r13d
mov    (%rsp),%esi
mov    0x4(%rsp),%r10d
jle    16a0 <StackBlur+0x580>
mov    0x40(%rsp),%r12
xor    %edi,%edi
mov    0x30(%rsp),%rcx
jmp    18ea <StackBlur+0x7ca>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xd0(%rsp),%rdx
add    %edi,%edx
mov    0x14(%rsp),%esi
cmp    %esi,%edx
cmovge %esi,%edx
imul   0x20(%rsp),%edx
mov    0x60(%rsp),%rsi
mov    %edx,(%rsi,%rdi,4)
add    0x8(%rsp),%edx
movslq %edx,%rdx
mov    0x88(%rsp),%rsi
mov    (%rsi,%rdx,4),%esi
mov    %esi,(%rax)
mov    0x80(%rsp),%rbx
mov    (%rbx,%rdx,4),%ebx
mov    %ebx,0x4(%rax)
mov    0x78(%rsp),%rbp
mov    0x0(%rbp,%rdx,4),%edx
mov    %edx,0x8(%rax)
add    %esi,%r8d
add    %ebx,%r11d
mov    0x1c(%rsp),%ebp
add    %edx,%ebp
add    %r8d,%r15d
add    %r11d,%r14d
add    $0x1,%ecx
mov    %ecx,%eax
cltd
mov    0x28(%rsp),%rsi
idiv   %esi
mov    %edx,%ecx
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
mov    0x38(%rsp),%rbx
mov    (%rbx,%rax,4),%edx
add    %edx,%r10d
sub    %edx,%r8d
mov    0x4(%rbx,%rax,4),%edx
mov    (%rsp),%esi
add    %edx,%esi
sub    %edx,%r11d
add    %ebp,%r9d
mov    0x8(%rbx,%rax,4),%eax
add    %eax,%r13d
sub    %eax,%ebp
mov    %ebp,0x1c(%rsp)
add    $0x1,%rdi
add    0xa0(%rsp),%r12
cmp    %rdi,0xa8(%rsp)
je     16a0 <StackBlur+0x580>
movzbl 0x3(%r12),%eax
shl    $0x18,%eax
movslq %r15d,%r15
mov    0xc0(%rsp),%rbp
mov    0x0(%rbp,%r15,4),%edx
shl    $0x10,%edx
or     %eax,%edx
movslq %r14d,%r14
mov    0x0(%rbp,%r14,4),%eax
shl    $0x8,%eax
or     %edx,%eax
movslq %r9d,%r9
or     0x0(%rbp,%r9,4),%eax
mov    %eax,(%r12)
sub    %r10d,%r15d
sub    %esi,%r14d
sub    %r13d,%r9d
mov    0x58(%rsp),%rax
add    %ecx,%eax
cltd
idivl  0x28(%rsp)
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
sub    (%rbx,%rax,4),%r10d
sub    0x4(%rbx,%rax,4),%esi
sub    0x8(%rbx,%rax,4),%r13d
lea    (%rbx,%rax,4),%rax
cmpl   $0x0,0x8(%rsp)
mov    %esi,(%rsp)
je     1830 <StackBlur+0x710>
mov    0x60(%rsp),%rdx
mov    (%rdx,%rdi,4),%edx
jmp    1850 <StackBlur+0x730>
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

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

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