void boxfilter(float *input, float *temp1, float *temp2, int hw, int m, int n,
               int o) {
  int sz = m * n * o;
  for (int i = 0; i < sz; i++) {
    temp1[i] = input[i];
  }
  for (int k = 0; k < o; k++) {
    for (int j = 0; j < n; j++) {
      for (int i = 1; i < m; i++) {
        temp1[i + j * m + k * m * n] += temp1[(i - 1) + j * m + k * m * n];
      }
    }
  }
  for (int k = 0; k < o; k++) {
    for (int j = 0; j < n; j++) {
      for (int i = 0; i < (hw + 1); i++) {
        temp2[i + j * m + k * m * n] = temp1[(i + hw) + j * m + k * m * n];
      }
      for (int i = (hw + 1); i < (m - hw); i++) {
        temp2[i + j * m + k * m * n] = temp1[(i + hw) + j * m + k * m * n] -
                                       temp1[(i - hw - 1) + j * m + k * m * n];
      }
      for (int i = (m - hw); i < m; i++) {
        temp2[i + j * m + k * m * n] = temp1[(m - 1) + j * m + k * m * n] -
                                       temp1[(i - hw - 1) + j * m + k * m * n];
      }
    }
  }
  for (int k = 0; k < o; k++) {
    for (int j = 1; j < n; j++) {
      for (int i = 0; i < m; i++) {
        temp2[i + j * m + k * m * n] += temp2[i + (j - 1) * m + k * m * n];
      }
    }
  }
  for (int k = 0; k < o; k++) {
    for (int i = 0; i < m; i++) {
      for (int j = 0; j < (hw + 1); j++) {
        temp1[i + j * m + k * m * n] = temp2[i + (j + hw) * m + k * m * n];
      }
      for (int j = (hw + 1); j < (n - hw); j++) {
        temp1[i + j * m + k * m * n] = temp2[i + (j + hw) * m + k * m * n] -
                                       temp2[i + (j - hw - 1) * m + k * m * n];
      }
      for (int j = (n - hw); j < n; j++) {
        temp1[i + j * m + k * m * n] = temp2[i + (n - 1) * m + k * m * n] -
                                       temp2[i + (j - hw - 1) * m + k * m * n];
      }
    }
  }
  for (int k = 1; k < o; k++) {
    for (int j = 0; j < n; j++) {
      for (int i = 0; i < m; i++) {
        temp1[i + j * m + k * m * n] += temp1[i + j * m + (k - 1) * m * n];
      }
    }
  }
  for (int j = 0; j < n; j++) {
    for (int i = 0; i < m; i++) {
      for (int k = 0; k < (hw + 1); k++) {
        input[i + j * m + k * m * n] = temp1[i + j * m + (k + hw) * m * n];
      }
      for (int k = (hw + 1); k < (o - hw); k++) {
        input[i + j * m + k * m * n] = temp1[i + j * m + (k + hw) * m * n] -
                                       temp1[i + j * m + (k - hw - 1) * m * n];
      }
      for (int k = (o - hw); k < o; k++) {
        input[i + j * m + k * m * n] = temp1[i + j * m + (o - 1) * m * n] -
                                       temp1[i + j * m + (k - hw - 1) * m * n];
      }
    }
  }
}


x86 assembly (clang, -O0):
<boxfilter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x20(%rbp),%eax
imul   -0x24(%rbp),%eax
imul   0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    116b <boxfilter+0x6b>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1137 <boxfilter+0x37>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    122a <boxfilter+0x12a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1217 <boxfilter+0x117>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1204 <boxfilter+0x104>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x30(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x30(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1198 <boxfilter+0x98>
jmp    1209 <boxfilter+0x109>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1185 <boxfilter+0x85>
jmp    121c <boxfilter+0x11c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1172 <boxfilter+0x72>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1424 <boxfilter+0x324>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1411 <boxfilter+0x311>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12c3 <boxfilter+0x1c3>
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1257 <boxfilter+0x157>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1363 <boxfilter+0x263>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x40(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12cc <boxfilter+0x1cc>
mov    -0x20(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13fe <boxfilter+0x2fe>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x40(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x40(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x3c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    136c <boxfilter+0x26c>
jmp    1403 <boxfilter+0x303>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1244 <boxfilter+0x144>
jmp    1416 <boxfilter+0x316>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1231 <boxfilter+0x131>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    14e3 <boxfilter+0x3e3>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14d0 <boxfilter+0x3d0>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    14bd <boxfilter+0x3bd>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    -0x54(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x50(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x50(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1451 <boxfilter+0x351>
jmp    14c2 <boxfilter+0x3c2>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    143e <boxfilter+0x33e>
jmp    14d5 <boxfilter+0x3d5>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    142b <boxfilter+0x32b>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    16dd <boxfilter+0x5dd>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    16ca <boxfilter+0x5ca>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    157c <boxfilter+0x47c>
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x64(%rbp),%edx
add    -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x5c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x5c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1510 <boxfilter+0x410>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    161c <boxfilter+0x51c>
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x68(%rbp),%edx
add    -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x5c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x68(%rbp),%edx
sub    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x5c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x68(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x5c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1585 <boxfilter+0x485>
mov    -0x24(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    16b7 <boxfilter+0x5b7>
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x5c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x6c(%rbp),%edx
sub    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x5c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x6c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x5c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1625 <boxfilter+0x525>
jmp    16bc <boxfilter+0x5bc>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    14fd <boxfilter+0x3fd>
jmp    16cf <boxfilter+0x5cf>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    14ea <boxfilter+0x3ea>
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    179c <boxfilter+0x69c>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1789 <boxfilter+0x689>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1776 <boxfilter+0x676>
mov    -0x10(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x74(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x70(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x74(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x70(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    170a <boxfilter+0x60a>
jmp    177b <boxfilter+0x67b>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    16f7 <boxfilter+0x5f7>
jmp    178e <boxfilter+0x68e>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    16e4 <boxfilter+0x5e4>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    19cf <boxfilter+0x8cf>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    19bc <boxfilter+0x8bc>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1847 <boxfilter+0x747>
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x84(%rbp),%edx
add    -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x84(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    17cc <boxfilter+0x6cc>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    18fc <boxfilter+0x7fc>
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x88(%rbp),%edx
add    -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x88(%rbp),%edx
sub    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x88(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1853 <boxfilter+0x753>
mov    0x10(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    19a9 <boxfilter+0x8a9>
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    0x10(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x8c(%rbp),%edx
sub    -0x1c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
mov    -0x8c(%rbp),%edx
imul   -0x20(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1908 <boxfilter+0x808>
jmp    19ae <boxfilter+0x8ae>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    17b6 <boxfilter+0x6b6>
jmp    19c1 <boxfilter+0x8c1>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    17a3 <boxfilter+0x6a3>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<boxfilter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a0,%rsp
mov    0x1d8(%rsp),%ebp
mov    %r9,%rax
mov    %r9,-0x28(%rsp)
mov    %r9d,%ebx
imul   %r8d,%ebx
mov    %ebx,%eax
imul   %ebp,%eax
test   %eax,%eax
mov    %rbx,-0x38(%rsp)
jle    12bb <boxfilter+0x1bb>
mov    %eax,%r9d
cmp    $0x8,%eax
jb     1157 <boxfilter+0x57>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    11cc <boxfilter+0xcc>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    11cc <boxfilter+0xcc>
xor    %ebp,%ebp
mov    %rbp,%r10
not    %r10
add    %r9,%r10
mov    %r9,%rax
and    $0x3,%rax
je     1184 <boxfilter+0x84>
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rbp,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rax
jne    1170 <boxfilter+0x70>
cmp    $0x3,%r10
jb     12bb <boxfilter+0x1bb>
xchg   %ax,%ax
movss  (%rdi,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rbp,4)
movss  0x4(%rdi,%rbp,4),%xmm0
movss  %xmm0,0x4(%rsi,%rbp,4)
movss  0x8(%rdi,%rbp,4),%xmm0
movss  %xmm0,0x8(%rsi,%rbp,4)
movss  0xc(%rdi,%rbp,4),%xmm0
movss  %xmm0,0xc(%rsi,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%r9
jne    1190 <boxfilter+0x90>
jmp    12bb <boxfilter+0x1bb>
mov    %r9d,%ebp
and    $0xfffffff8,%ebp
lea    -0x8(%rbp),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rax
jae    11f2 <boxfilter+0xf2>
xor    %ebx,%ebx
jmp    1268 <boxfilter+0x168>
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
add    $0xfffffffffffffffe,%rax
and    %rax,%r11
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rdi,%rbx,4),%xmm0
movups 0x10(%rdi,%rbx,4),%xmm1
movups %xmm0,(%rsi,%rbx,4)
movups %xmm1,0x10(%rsi,%rbx,4)
movups 0x20(%rdi,%rbx,4),%xmm0
movups 0x30(%rdi,%rbx,4),%xmm1
movups %xmm0,0x20(%rsi,%rbx,4)
movups %xmm1,0x30(%rsi,%rbx,4)
movups 0x40(%rdi,%rbx,4),%xmm0
movups 0x50(%rdi,%rbx,4),%xmm1
movups %xmm0,0x40(%rsi,%rbx,4)
movups %xmm1,0x50(%rsi,%rbx,4)
movups 0x60(%rdi,%rbx,4),%xmm0
movups 0x70(%rdi,%rbx,4),%xmm1
movups %xmm0,0x60(%rsi,%rbx,4)
movups %xmm1,0x70(%rsi,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%r11
jne    1210 <boxfilter+0x110>
test   %r10,%r10
je     12ad <boxfilter+0x1ad>
lea    (%rsi,%rbx,4),%r11
add    $0x10,%r11
lea    (%rdi,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbx,%rax,1),%xmm0
movups (%rbx,%rax,1),%xmm1
movups %xmm0,-0x10(%r11,%rax,1)
movups %xmm1,(%r11,%rax,1)
add    $0x20,%rax
cmp    %rax,%r10
jne    1290 <boxfilter+0x190>
cmp    %r9,%rbp
mov    -0x38(%rsp),%rbx
jne    1159 <boxfilter+0x59>
mov    %rdi,0x188(%rsp)
mov    %rcx,-0x30(%rsp)
mov    %r8d,%eax
mov    %rax,-0x60(%rsp)
movslq %r8d,%rax
mov    %rax,0x68(%rsp)
mov    -0x28(%rsp),%eax
mov    %rax,0x70(%rsp)
mov    0x1d8(%rsp),%eax
test   %eax,%eax
mov    %r8,-0x18(%rsp)
jle    2e51 <boxfilter+0x1d51>
mov    -0x60(%rsp),%rax
lea    -0x2(%rax),%rcx
mov    %rcx,-0x80(%rsp)
lea    -0x1(%rax),%rcx
lea    (%rsi,%rax,4),%rdi
add    $0xfffffffffffffffc,%rdi
mov    %rdi,-0x78(%rsp)
mov    %rcx,0x8(%rsp)
and    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x50(%rsp)
add    $0x1,%rcx
mov    %rcx,-0x20(%rsp)
neg    %rax
mov    %rax,0x10(%rsp)
movl   $0x0,-0x68(%rsp)
movl   $0x1,-0x40(%rsp)
movl   $0xffffffff,-0x58(%rsp)
ff
movl   $0x0,-0x48(%rsp)
jmp    138b <boxfilter+0x28b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x48(%rsp),%ecx
add    $0x1,%ecx
mov    -0x38(%rsp),%rbx
add    %ebx,-0x68(%rsp)
add    %ebx,-0x40(%rsp)
add    %ebx,-0x58(%rsp)
mov    0x1d8(%rsp),%eax
mov    %ecx,-0x48(%rsp)
cmp    %eax,%ecx
je     154d <boxfilter+0x44d>
cmpl   $0x0,-0x28(%rsp)
jle    1360 <boxfilter+0x260>
mov    -0x38(%rsp),%r15
imul   -0x48(%rsp),%r15d
lea    0x1(%r15),%eax
mov    %rax,-0x70(%rsp)
xor    %r9d,%r9d
mov    -0x58(%rsp),%eax
mov    %eax,%r10d
mov    -0x40(%rsp),%eax
mov    %eax,%r11d
mov    -0x68(%rsp),%eax
mov    %eax,%r13d
jmp    13d4 <boxfilter+0x2d4>
add    $0x1,%r9d
add    %r8d,%r13d
add    %r8d,%r11d
add    %r8d,%r10d
cmp    -0x28(%rsp),%r9d
je     1360 <boxfilter+0x260>
cmp    $0x2,%r8d
jl     13c0 <boxfilter+0x2c0>
mov    %r9d,%eax
imul   %r8d,%eax
lea    (%r15,%rax,1),%r14d
mov    $0x1,%r12d
cmpq   $0x8,0x8(%rsp)
jae    1490 <boxfilter+0x390>
mov    %r12,%rdi
testb  $0x1,-0x60(%rsp)
jne    1426 <boxfilter+0x326>
add    %r15d,%eax
add    $0xffffffff,%eax
add    %r12d,%eax
cltq
movss  (%rsi,%rax,4),%xmm0
add    %r12d,%r14d
movslq %r14d,%rax
addss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
lea    0x1(%r12),%rdi
not    %r12
cmp    0x10(%rsp),%r12
je     13c0 <boxfilter+0x2c0>
lea    (%rdi,%r13,1),%eax
lea    (%r11,%rdi,1),%ebp
mov    -0x60(%rsp),%rcx
sub    %rdi,%rcx
lea    (%r10,%rdi,1),%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm0
cltq
addss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
movslq %ebp,%rbp
addss  (%rsi,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rbp,4)
add    $0x2,%eax
add    $0x2,%ebp
add    $0x2,%ebx
add    $0xfffffffffffffffe,%rcx
jne    1450 <boxfilter+0x350>
jmp    13c0 <boxfilter+0x2c0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x70(%rsp),%rcx
add    %eax,%ecx
mov    -0x80(%rsp),%rbx
lea    (%rcx,%rbx,1),%edi
cmp    %ecx,%edi
jl     13f7 <boxfilter+0x2f7>
mov    %rbx,%rdi
shr    $0x20,%rdi
jne    13f7 <boxfilter+0x2f7>
add    %r14d,%ebx
cmp    %r14d,%ebx
jl     13f7 <boxfilter+0x2f7>
test   %rdi,%rdi
jne    13f7 <boxfilter+0x2f7>
movslq %ecx,%rcx
lea    (%rsi,%rcx,4),%rbx
movslq %r14d,%rdi
mov    -0x78(%rsp),%rbp
lea    0x0(%rbp,%rdi,4),%rbp
cmp    %rbp,%rbx
jae    14f8 <boxfilter+0x3f8>
mov    -0x78(%rsp),%rbx
lea    (%rbx,%rcx,4),%rcx
lea    (%rsi,%rdi,4),%rdi
cmp    %rcx,%rdi
jb     13f7 <boxfilter+0x2f7>
mov    -0x50(%rsp),%rcx
mov    %r13d,%edi
movslq %edi,%rdi
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
lea    0x1(%rdi),%ebx
movslq %ebx,%rbx
movups (%rsi,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rsi,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rsi,%rbx,4)
movups %xmm0,0x10(%rsi,%rbx,4)
add    $0x8,%edi
add    $0xfffffffffffffff8,%rcx
jne    1500 <boxfilter+0x400>
mov    -0x20(%rsp),%r12
mov    -0x50(%rsp),%rcx
cmp    %rcx,0x8(%rsp)
je     13c0 <boxfilter+0x2c0>
jmp    13f7 <boxfilter+0x2f7>
mov    0x1d8(%rsp),%eax
test   %eax,%eax
jle    2e51 <boxfilter+0x1d51>
mov    %r8d,%r9d
mov    -0x30(%rsp),%r11
sub    %r11d,%r9d
movslq %r9d,%r14
lea    0x1(%r14),%rdi
mov    0x68(%rsp),%rax
cmp    %rax,%rdi
cmovle %rax,%rdi
lea    0x1(%r11),%r12d
mov    %r14,%rax
not    %rax
add    %rdi,%rax
mov    %rax,0x30(%rsp)
mov    $0x1,%eax
sub    %r11d,%eax
mov    %rax,0xe8(%rsp)
lea    (%r11,%r11,1),%r10d
mov    %r10d,%eax
neg    %eax
mov    %rax,0x198(%rsp)
lea    0x0(,%r14,4),%rax
mov    %rsi,%rbp
sub    %rax,%rbp
mov    %rbp,0x138(%rsp)
mov    %rdx,%rbp
sub    %rax,%rbp
mov    %rbp,0x48(%rsp)
mov    %rdi,0xb8(%rsp)
mov    %rdi,%r15
sub    %r14,%r15
mov    %r8d,%ebx
sub    %r10d,%ebx
add    $0xfffffffe,%ebx
mov    %r12d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x120(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x160(%rsp)
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %r11d,%ebp
not    %ebp
mov    %rdi,%rax
mov    %rdi,0x128(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xf0(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x180(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x110(%rsp)
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
mov    %r15,0x50(%rsp)
and    $0xfffffffffffffff8,%r15
lea    -0x1(%r12),%rax
mov    %rax,0x58(%rsp)
sub    %r8d,%eax
mov    %rax,0xe0(%rsp)
mov    %r11d,%eax
neg    %eax
mov    %eax,-0xc(%rsp)
mov    %r10d,0x14c(%rsp)
not    %r10d
add    %r8d,%r10d
mov    %r10d,0xa8(%rsp)
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
mov    %rax,0x150(%rsp)
lea    0x4(%rsi),%rax
mov    %rax,0x168(%rsp)
lea    0x1(%r11,%r11,1),%r10d
lea    0x4(%rdx,%rbx,4),%rax
mov    %rax,0x130(%rsp)
mov    %rbx,-0x58(%rsp)
lea    0x4(%rsi,%rbx,4),%rax
mov    %rax,0xb0(%rsp)
mov    %r11d,%edi
lea    (%rdx,%r12,4),%rax
mov    %rax,0x170(%rsp)
lea    (%rsi,%r12,4),%rax
mov    %rax,0x178(%rsp)
mov    %rbp,0x38(%rsp)
lea    0x0(%rbp,%r8,1),%eax
mov    %eax,0xd8(%rsp)
lea    (%rcx,%r12,1),%rax
mov    %rax,0x100(%rsp)
mov    %rcx,0x108(%rsp)
lea    (%rcx,%r11,1),%eax
mov    %eax,0xf8(%rsp)
mov    %r14,-0x78(%rsp)
mov    %r15,0x18(%rsp)
lea    (%r15,%r14,1),%rax
mov    %rax,0x118(%rsp)
movl   $0x8,0xa0(%rsp)
xor    %eax,%eax
mov    %rax,0x98(%rsp)
mov    %r9d,0x60(%rsp)
mov    %r9d,0x90(%rsp)
mov    %r12,-0x80(%rsp)
mov    %r12,0x88(%rsp)
mov    %r10,%rax
mov    %r10,0x190(%rsp)
mov    %r10,0x80(%rsp)
mov    %rdi,%rax
mov    %rdi,0x158(%rsp)
mov    %rdi,0x78(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
jmp    17ed <boxfilter+0x6ed>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
mov    -0x38(%rsp),%rbx
add    %ebx,0xa0(%rsp)
add    %rbx,0x78(%rsp)
add    %rbx,0x98(%rsp)
add    %rbx,0x80(%rsp)
add    %rbx,0x88(%rsp)
add    %ebx,-0xc(%rsp)
add    %ebx,0xa8(%rsp)
add    %ebx,0x90(%rsp)
add    %rbx,0x38(%rsp)
mov    0x1d8(%rsp),%eax
mov    %rcx,0x40(%rsp)
cmp    %eax,%ecx
je     1f8d <boxfilter+0xe8d>
cmpl   $0x0,-0x28(%rsp)
mov    -0x60(%rsp),%rcx
jle    1790 <boxfilter+0x690>
mov    0x40(%rsp),%rax
mov    %rax,%rbp
mov    -0x38(%rsp),%r8
imul   %r8,%rbp
mov    0x158(%rsp),%rdi
add    %rbp,%rdi
mov    %rdi,0x20(%rsp)
mov    -0x80(%rsp),%rdi
add    %rbp,%rdi
mov    %rdi,0xc8(%rsp)
mov    0x190(%rsp),%rdi
mov    %rbp,(%rsp)
add    %rbp,%rdi
mov    %rdi,0xc0(%rsp)
mov    %rax,%rbx
imul   0x70(%rsp),%rbx
mov    0x198(%rsp),%rdi
add    %rbx,%rdi
mov    %rdi,0xd0(%rsp)
mov    0xe8(%rsp),%rdi
mov    %rbx,0x140(%rsp)
add    %rbx,%rdi
mov    %rdi,0x28(%rsp)
mov    %r8d,%edi
imul   %eax,%edi
mov    %edi,-0x40(%rsp)
mov    0x38(%rsp),%r13
mov    0x90(%rsp),%r8d
mov    0xa8(%rsp),%eax
mov    %eax,-0x20(%rsp)
mov    -0xc(%rsp),%eax
mov    %eax,%r14d
mov    0x88(%rsp),%rdi
mov    0x80(%rsp),%rbp
mov    0x98(%rsp),%r15
mov    0x78(%rsp),%r10
mov    0xa0(%rsp),%eax
mov    %eax,-0x8(%rsp)
xor    %r9d,%r9d
jmp    1915 <boxfilter+0x815>
nopl   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%r9
add    $0x1,%r9
mov    -0x60(%rsp),%rcx
add    %rcx,%r10
mov    -0x18(%rsp),%rax
add    %eax,-0x8(%rsp)
add    %rcx,%r15
mov    -0x50(%rsp),%rbp
add    %rcx,%rbp
mov    -0x48(%rsp),%rdi
add    %rcx,%rdi
add    %eax,%r14d
add    %eax,-0x20(%rsp)
add    %eax,%r8d
add    %rcx,%r13
cmp    0x70(%rsp),%r9
je     1790 <boxfilter+0x690>
mov    %rbp,-0x50(%rsp)
mov    %rdi,-0x48(%rsp)
mov    %r9d,%r12d
imul   %ecx,%r12d
test   %r11d,%r11d
mov    -0x80(%rsp),%rcx
mov    %r9,%rax
mov    %r9,-0x70(%rsp)
js     1b37 <boxfilter+0xa37>
imul   -0x18(%rsp),%r9d
add    -0x40(%rsp),%r9d
lea    (%r9,%r11,1),%edi
cmp    $0x8,%ecx
jae    1960 <boxfilter+0x860>
xor    %ebp,%ebp
jmp    1ac0 <boxfilter+0x9c0>
nopw   0x0(%rax,%rax,1)
mov    %rdi,-0x68(%rsp)
mov    (%rsp),%rax
add    %r12d,%eax
mov    0x58(%rsp),%rbx
lea    (%rax,%rbx,1),%edi
cmp    %eax,%edi
jl     19f3 <boxfilter+0x8f3>
mov    %rbx,%rax
shr    $0x20,%rax
jne    19f3 <boxfilter+0x8f3>
mov    0x20(%rsp),%rdi
add    %r12d,%edi
lea    (%rdi,%rbx,1),%ebp
cmp    %edi,%ebp
jl     19f3 <boxfilter+0x8f3>
mov    $0x0,%ebp
test   %rax,%rax
mov    -0x68(%rsp),%rdi
jne    1ac0 <boxfilter+0x9c0>
mov    (%rsp),%rax
add    %r12d,%eax
mov    0x20(%rsp),%rcx
lea    (%rcx,%r12,1),%edi
cltq
lea    (%rdx,%rax,4),%rbp
movslq %edi,%rdi
mov    0x178(%rsp),%rcx
lea    (%rcx,%rdi,4),%rbx
cmp    %rbx,%rbp
jae    19ff <boxfilter+0x8ff>
mov    0x170(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
lea    (%rsi,%rdi,4),%rdi
cmp    %rax,%rdi
jae    19ff <boxfilter+0x8ff>
xor    %ebp,%ebp
mov    -0x80(%rsp),%rcx
mov    -0x68(%rsp),%rdi
jmp    1ac0 <boxfilter+0x9c0>
xor    %ebp,%ebp
mov    -0x68(%rsp),%rdi
jmp    1ac0 <boxfilter+0x9c0>
cmpq   $0x0,0x160(%rsp)
je     1a6b <boxfilter+0x96b>
mov    0xf0(%rsp),%rbp
mov    -0x8(%rsp),%eax
mov    %r10d,%r11d
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movslq %r11d,%r11
movups (%rsi,%r11,4),%xmm0
movups 0x10(%rsi,%r11,4),%xmm1
lea    -0x8(%rax),%edi
movslq %edi,%rdi
movups %xmm0,(%rdx,%rdi,4)
movups %xmm1,0x10(%rdx,%rdi,4)
lea    0x8(%r11),%edi
movslq %edi,%rdi
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
cltq
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
add    $0x10,%rbx
add    $0x10,%r11d
add    $0x10,%eax
add    $0xfffffffffffffffe,%rbp
jne    1a20 <boxfilter+0x920>
jmp    1a6d <boxfilter+0x96d>
xor    %ebx,%ebx
testb  $0x1,0x128(%rsp)
01
mov    -0x68(%rsp),%rdi
je     1a99 <boxfilter+0x999>
lea    (%rdi,%rbx,1),%eax
cltq
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
add    %r9d,%ebx
movslq %ebx,%rax
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
mov    0x120(%rsp),%rax
mov    %rax,%rbp
mov    -0x80(%rsp),%rcx
cmp    %rcx,%rax
mov    -0x30(%rsp),%r11
je     1b37 <boxfilter+0xa37>
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rax
test   $0x1,%cl
je     1ae4 <boxfilter+0x9e4>
add    %ebp,%edi
movslq %edi,%rax
movss  (%rsi,%rax,4),%xmm0
add    %ebp,%r9d
movslq %r9d,%rax
movss  %xmm0,(%rdx,%rax,4)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    0x180(%rsp),%rbp
je     1b37 <boxfilter+0xa37>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r10,%rax,1),%rdi
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm0
lea    (%r15,%rax,1),%rbp
movslq %ebp,%rbp
movss  %xmm0,(%rdx,%rbp,4)
add    $0x1,%edi
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm0
add    $0x1,%ebp
movslq %ebp,%rdi
movss  %xmm0,(%rdx,%rdi,4)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1b00 <boxfilter+0xa00>
mov    %r8d,-0x68(%rsp)
cmp    0x60(%rsp),%ecx
jge    1d9d <boxfilter+0xc9d>
mov    -0x80(%rsp),%rbx
mov    %r11d,%r9d
cmpl   $0x7,-0x58(%rsp)
jb     1cc0 <boxfilter+0xbc0>
mov    0xc8(%rsp),%rax
add    %r12d,%eax
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%edi
mov    -0x80(%rsp),%rbx
mov    %r11d,%r9d
cmp    %eax,%edi
jl     1cc0 <boxfilter+0xbc0>
mov    0xc0(%rsp),%rax
add    %r12d,%eax
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%edi
mov    -0x80(%rsp),%rbx
mov    %r11d,%r9d
cmp    %eax,%edi
jl     1cc0 <boxfilter+0xbc0>
mov    (%rsp),%rax
add    %r12d,%eax
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%edi
mov    -0x80(%rsp),%rbx
mov    %r11d,%r9d
cmp    %eax,%edi
jl     1cc0 <boxfilter+0xbc0>
mov    0xc8(%rsp),%rax
add    %r12d,%eax
mov    (%rsp),%rcx
lea    (%rcx,%r12,1),%edi
add    0xc0(%rsp),%r12d
cltq
lea    (%rdx,%rax,4),%rbp
mov    0x130(%rsp),%rcx
lea    (%rcx,%rax,4),%rbx
movslq %edi,%rax
lea    (%rsi,%rax,4),%r9
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
movslq %r12d,%rdi
lea    (%rsi,%rdi,4),%r11
lea    (%rcx,%rdi,4),%rdi
cmp    %rax,%rbp
setb   %cl
cmp    %rbx,%r9
setb   %r12b
cmp    %rdi,%rbp
setb   %al
cmp    %rbx,%r11
mov    -0x30(%rsp),%r11
setb   %dil
mov    -0x80(%rsp),%rbx
mov    %r11d,%r9d
test   %r12b,%cl
jne    1cc0 <boxfilter+0xbc0>
mov    -0x80(%rsp),%rbx
mov    %r11d,%r9d
and    %dil,%al
jne    1cc0 <boxfilter+0xbc0>
xor    %eax,%eax
mov    0x108(%rsp),%rcx
mov    -0x48(%rsp),%rbp
mov    -0x50(%rsp),%rbx
xchg   %ax,%ax
lea    (%rbx,%rax,1),%edi
movslq %edi,%rdi
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
lea    (%r15,%rax,1),%edi
movslq %edi,%rdi
movups (%rsi,%rdi,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rsi,%rdi,4),%xmm2
subps  %xmm2,%xmm1
lea    0x0(%rbp,%rax,1),%edi
movslq %edi,%rdi
movups %xmm0,(%rdx,%rdi,4)
movups %xmm1,0x10(%rdx,%rdi,4)
add    $0x8,%rax
cmp    %rax,%rcx
jne    1c60 <boxfilter+0xb60>
mov    0x100(%rsp),%rbx
mov    0xf8(%rsp),%r9d
cmp    %rcx,0x110(%rsp)
je     1d9d <boxfilter+0xc9d>
nopl   0x0(%rax)
mov    -0x70(%rsp),%rdi
mov    -0x18(%rsp),%rcx
imul   %ecx,%edi
add    -0x40(%rsp),%edi
mov    %edi,%r8d
sub    %r11d,%r8d
mov    %r11,%r12
add    %ebx,%r11d
mov    %ecx,%ebp
sub    %r11d,%ebp
test   $0x1,%bpl
jne    1cf0 <boxfilter+0xbf0>
mov    %rbx,%rbp
jmp    1d1d <boxfilter+0xc1d>
nopl   (%rax)
lea    (%rdi,%r12,1),%ebp
add    %ebx,%ebp
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm0
add    %r8d,%r9d
movslq %r9d,%rbp
subss  (%rsi,%rbp,4),%xmm0
add    %ebx,%edi
movslq %edi,%rdi
movss  %xmm0,(%rdx,%rdi,4)
mov    %rbx,%rbp
add    $0x1,%rbp
mov    %ebx,%r9d
mov    %r12,%r11
cmp    %ebx,0xd8(%rsp)
mov    0xe0(%rsp),%rax
je     1d9d <boxfilter+0xc9d>
add    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r10,%rbp,1),%edi
add    $0xffffffff,%edi
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm0
add    %r8d,%r9d
movslq %r9d,%rdi
subss  (%rsi,%rdi,4),%xmm0
lea    (%r10,%rbp,1),%edi
lea    (%r15,%rbp,1),%ebx
lea    -0x1(%r15,%rbp,1),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rdx,%rcx,4)
movslq %edi,%rcx
movss  (%rsi,%rcx,4),%xmm0
lea    -0x1(%r14,%rbp,1),%ecx
movslq %ecx,%rcx
subss  (%rsi,%rcx,4),%xmm0
movslq %ebx,%rcx
movss  %xmm0,(%rdx,%rcx,4)
lea    (%rax,%rbp,1),%ecx
add    $0x2,%ecx
mov    %ebp,%r9d
add    $0x2,%ebp
cmp    $0x1,%ecx
jne    1d40 <boxfilter+0xc40>
test   %r11d,%r11d
mov    0x68(%rsp),%r12
mov    -0x68(%rsp),%r8d
jle    18d0 <boxfilter+0x7d0>
mov    -0x70(%rsp),%rax
mov    -0x18(%rsp),%rcx
imul   %ecx,%eax
add    -0x40(%rsp),%eax
add    %ecx,%eax
add    $0xffffffff,%eax
cltq
mov    -0x78(%rsp),%rbx
cmpq   $0x8,0x50(%rsp)
jae    1e10 <boxfilter+0xd10>
lea    (%r15,%rbx,1),%edi
nopl   0x0(%rax)
movss  (%rsi,%rax,4),%xmm0
lea    (%rbx,%r13,1),%ecx
movslq %ecx,%rcx
subss  (%rsi,%rcx,4),%xmm0
movslq %edi,%rdi
movss  %xmm0,(%rdx,%rdi,4)
add    $0x1,%rbx
add    $0x1,%edi
cmp    %r12,%rbx
jl     1de0 <boxfilter+0xce0>
jmp    18d0 <boxfilter+0x7d0>
nopw   0x0(%rax,%rax,1)
mov    -0x78(%rsp),%rbx
cmpl   $0x1,-0x18(%rsp)
jne    1dd5 <boxfilter+0xcd5>
mov    0x28(%rsp),%rcx
mov    -0x70(%rsp),%rdi
add    %ecx,%edi
mov    0x30(%rsp),%rcx
lea    (%rdi,%rcx,1),%ebp
mov    -0x78(%rsp),%rbx
cmp    %edi,%ebp
jl     1dd5 <boxfilter+0xcd5>
mov    0x30(%rsp),%rdi
shr    $0x20,%rdi
mov    -0x78(%rsp),%rbx
jne    1dd5 <boxfilter+0xcd5>
mov    0xd0(%rsp),%rcx
mov    -0x70(%rsp),%rbp
add    %ecx,%ebp
mov    0x30(%rsp),%rcx
lea    (%rcx,%rbp,1),%r9d
mov    -0x78(%rsp),%rbx
cmp    %ebp,%r9d
jl     1dd5 <boxfilter+0xcd5>
mov    -0x78(%rsp),%rbx
test   %rdi,%rdi
jne    1dd5 <boxfilter+0xcd5>
mov    0xd0(%rsp),%rcx
mov    -0x70(%rsp),%rbx
lea    (%rcx,%rbx,1),%edi
mov    0x28(%rsp),%rcx
lea    (%rcx,%rbx,1),%ebp
movslq %edi,%rdi
mov    0xb8(%rsp),%rcx
lea    (%rcx,%rdi,1),%r11
movslq %ebp,%rbp
lea    (%rcx,%rbp,1),%r9
mov    0x140(%rsp),%rcx
add    %ecx,%ebx
lea    (%rsi,%rdi,4),%rcx
mov    0x138(%rsp),%rdi
lea    (%rdi,%r11,4),%r11
lea    (%rdx,%rbp,4),%rbp
mov    0x48(%rsp),%rdi
lea    (%rdi,%r9,4),%rdi
movslq %ebx,%rbx
cmp    %rdi,%rcx
setb   %cl
cmp    %r11,%rbp
lea    (%rsi,%rbx,4),%r9
setb   %r11b
cmp    %rdi,%r9
mov    0x168(%rsp),%rdi
lea    (%rdi,%rbx,4),%rbx
setb   %dil
cmp    %rbx,%rbp
setb   %r9b
mov    -0x78(%rsp),%rbx
test   %r11b,%cl
mov    -0x30(%rsp),%r11
jne    1dd5 <boxfilter+0xcd5>
mov    -0x78(%rsp),%rbx
and    %r9b,%dil
jne    1dd5 <boxfilter+0xcd5>
movss  (%rsi,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0x18(%rsp),%rdi
mov    %r8d,%ebp
mov    -0x20(%rsp),%ecx
mov    %ecx,%ebx
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rbx
movups (%rsi,%rbx,4),%xmm1
movups 0x10(%rsi,%rbx,4),%xmm2
movaps %xmm0,%xmm3
subps  %xmm1,%xmm3
movaps %xmm0,%xmm1
subps  %xmm2,%xmm1
movslq %ebp,%rbp
movups %xmm3,(%rdx,%rbp,4)
movups %xmm1,0x10(%rdx,%rbp,4)
add    $0x8,%ebx
add    $0x8,%ebp
add    $0xfffffffffffffff8,%rdi
jne    1f40 <boxfilter+0xe40>
mov    0x118(%rsp),%rbx
mov    0x18(%rsp),%rcx
cmp    %rcx,0x50(%rsp)
je     18d0 <boxfilter+0x7d0>
jmp    1dd5 <boxfilter+0xcd5>
mov    0x1d8(%rsp),%eax
test   %eax,%eax
mov    -0x18(%rsp),%r15
jle    2e51 <boxfilter+0x1d51>
mov    -0x60(%rsp),%rax
lea    (%rdx,%rax,4),%rcx
mov    %rcx,-0x78(%rsp)
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x48(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x50(%rsp)
mov    %rax,-0x68(%rsp)
xor    %r13d,%r13d
jmp    1ff3 <boxfilter+0xef3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13d
mov    -0x38(%rsp),%rbx
add    %rbx,-0x68(%rsp)
add    %rbx,-0x50(%rsp)
mov    0x1d8(%rsp),%ecx
cmp    %ecx,%r13d
je     21d6 <boxfilter+0x10d6>
cmpl   $0x2,-0x28(%rsp)
jl     1fd0 <boxfilter+0xed0>
mov    -0x38(%rsp),%r8
imul   %r13d,%r8d
lea    (%r8,%r15,1),%ecx
mov    %rcx,-0x70(%rsp)
mov    $0x1,%r9d
xor    %r11d,%r11d
mov    -0x50(%rsp),%rcx
mov    -0x68(%rsp),%r12
jmp    204a <boxfilter+0xf4a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9d
add    $0x1,%r11d
add    %rax,%rcx
add    %rax,%r12
cmp    -0x28(%rsp),%r9d
mov    -0x18(%rsp),%r15
je     1fd0 <boxfilter+0xed0>
test   %r15d,%r15d
jle    2030 <boxfilter+0xf30>
mov    -0x18(%rsp),%rbp
cmp    $0x8,%ebp
jae    2070 <boxfilter+0xf70>
xor    %r10d,%r10d
jmp    2140 <boxfilter+0x1040>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r11d,%edi
imul   %ebp,%edi
mov    -0x70(%rsp),%rbp
lea    (%rdi,%rbp,1),%r15d
mov    0x8(%rsp),%rbp
lea    (%r15,%rbp,1),%ebx
cmp    %r15d,%ebx
jl     2059 <boxfilter+0xf59>
mov    %rbp,%r14
shr    $0x20,%r14
jne    20d9 <boxfilter+0xfd9>
add    %r8d,%edi
lea    (%rdi,%rbp,1),%ebx
cmp    %edi,%ebx
jl     20d9 <boxfilter+0xfd9>
mov    $0x0,%r10d
test   %r14,%r14
mov    -0x60(%rsp),%rax
jne    2140 <boxfilter+0x1040>
movslq %r15d,%r14
lea    (%rdx,%r14,4),%r10
movslq %edi,%rdi
mov    -0x78(%rsp),%rax
lea    (%rax,%rdi,4),%rbx
cmp    %rbx,%r10
jae    20e3 <boxfilter+0xfe3>
lea    (%rax,%r14,4),%rbx
lea    (%rdx,%rdi,4),%rdi
cmp    %rbx,%rdi
jae    20e3 <boxfilter+0xfe3>
xor    %r10d,%r10d
mov    -0x60(%rsp),%rax
jmp    2140 <boxfilter+0x1040>
mov    %ecx,%edi
mov    -0x48(%rsp),%rbx
mov    -0x18(%rsp),%rax
nop
movslq %edi,%rdi
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
lea    (%rax,%rdi,1),%ebp
movslq %ebp,%rbp
movups (%rdx,%rbp,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rdx,%rbp,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rdx,%rbp,4)
movups %xmm0,0x10(%rdx,%rbp,4)
add    $0x8,%edi
add    $0xfffffffffffffff8,%rbx
jne    20f0 <boxfilter+0xff0>
mov    -0x48(%rsp),%rdi
mov    %rdi,%r10
mov    -0x60(%rsp),%rax
cmp    %rax,%rdi
je     2030 <boxfilter+0xf30>
nopl   0x0(%rax)
mov    %r10,%rbx
test   $0x1,%al
je     217d <boxfilter+0x107d>
lea    -0x1(%r9),%edi
mov    -0x18(%rsp),%rbp
imul   %ebp,%edi
mov    %r9d,%ebx
imul   %ebp,%ebx
lea    (%r8,%r10,1),%ebp
add    %ebp,%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm0
add    %ebp,%ebx
movslq %ebx,%rdi
addss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
mov    %r10,%rbx
or     $0x1,%rbx
not    %r10
cmp    0x10(%rsp),%r10
je     2030 <boxfilter+0xf30>
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbx,1),%rdi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm0
lea    (%r12,%rbx,1),%rbp
movslq %ebp,%rbp
addss  (%rdx,%rbp,4),%xmm0
movss  %xmm0,(%rdx,%rbp,4)
add    $0x1,%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm0
add    $0x1,%ebp
movslq %ebp,%rdi
addss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x2,%rbx
cmp    %rbx,%rax
jne    2190 <boxfilter+0x1090>
jmp    2030 <boxfilter+0xf30>
mov    0x1d8(%rsp),%eax
test   %eax,%eax
jle    2e51 <boxfilter+0x1d51>
mov    -0x28(%rsp),%rcx
mov    %ecx,%r13d
mov    -0x30(%rsp),%r11
sub    %r11d,%r13d
lea    -0x1(%rcx),%edi
mov    %edi,%eax
imul   %r15d,%eax
mov    %eax,0x8(%rsp)
movslq %r13d,%r10
movslq %ecx,%r9
lea    0x1(%r10),%rbx
cmp    %r9,%rbx
cmovle %r9,%rbx
mov    %r10,%rax
not    %rax
add    %rbx,%rax
mov    %rax,-0x20(%rsp)
mov    %rdi,%rax
mov    %rdi,0xf8(%rsp)
mov    %edi,%r8d
mov    0x14c(%rsp),%edi
sub    %edi,%r8d
lea    0x0(,%r10,4),%rax
mov    %rdx,%rbp
sub    %rax,%rbp
mov    %rbp,0xc0(%rsp)
mov    %rsi,%rbp
sub    %rax,%rbp
mov    %rbp,0x140(%rsp)
mov    %rbx,0xc8(%rsp)
sub    %r10,%rbx
sub    %edi,%ecx
add    $0xfffffffe,%ecx
lea    0x1(%rcx),%rbp
mov    -0x80(%rsp),%r14
mov    %r14d,%eax
and    $0xfffffff8,%eax
mov    %rax,0xa8(%rsp)
mov    0x128(%rsp),%rdi
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
and    %rax,%rdi
mov    %rdi,0x118(%rsp)
movabs $0x1fffffff8,%rdi
mov    %rbp,0x90(%rsp)
and    %rbp,%rdi
mov    %rbx,-0x8(%rsp)
mov    %rbx,%r12
and    $0xfffffffffffffff8,%r12
mov    0x58(%rsp),%rax
lea    0x8(%rax),%ebx
imul   %r15d,%ebx
mov    %rbx,0x110(%rsp)
mov    %r15d,%ebx
shl    $0x4,%ebx
mov    %ebx,0x108(%rsp)
mov    %r15d,%ebx
imul   %eax,%ebx
mov    %rbx,0x100(%rsp)
mov    %r15d,%ebx
imul   %r14d,%ebx
mov    %rbx,0x88(%rsp)
lea    (%r11,%r11,1),%ebp
add    $0x1,%ebp
mov    %rbp,%rbx
mov    %rbp,0xe8(%rsp)
imul   %r15d,%ebp
mov    %rbp,0x80(%rsp)
mov    %r10d,%ebx
imul   %r15d,%ebx
mov    %ebx,0x38(%rsp)
mov    %r8,%rbx
mov    %r8,0xf0(%rsp)
mov    %r8d,%ebp
imul   %r15d,%ebp
mov    %ebp,-0xc(%rsp)
mov    %eax,%ebp
not    %ebp
mov    %rbp,0x60(%rsp)
lea    0x4(%rdx),%rbp
mov    %rbp,0x138(%rsp)
lea    0x4(%rsi,%rcx,4),%rbp
mov    %rbp,0x40(%rsp)
mov    %rcx,-0x50(%rsp)
lea    0x4(%rdx,%rcx,4),%rcx
mov    %rcx,0x130(%rsp)
lea    (%rdi,%r14,1),%rcx
mov    %rcx,0x78(%rsp)
mov    %rdi,0xb0(%rsp)
lea    (%rdi,%r11,1),%ecx
mov    %ecx,0x120(%rsp)
mov    %r10,-0x78(%rsp)
mov    %r12,0xb8(%rsp)
lea    (%r12,%r10,1),%rcx
mov    %rcx,0xa0(%rsp)
lea    0x0(,%r15,8),%ecx
mov    %rcx,0x20(%rsp)
lea    (%r15,%r15,1),%r12d
lea    0x1(%rax),%r14d
xor    %eax,%eax
mov    %rax,0x48(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %r14d,0x98(%rsp)
jmp    2416 <boxfilter+0x1316>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
mov    -0x38(%rsp),%rbx
mov    0x48(%rsp),%rax
add    %ebx,%eax
mov    %rax,0x48(%rsp)
add    %ebx,0x38(%rsp)
add    %ebx,-0xc(%rsp)
mov    0x1d8(%rsp),%eax
mov    %rcx,0x18(%rsp)
cmp    %eax,%ecx
je     2b5f <boxfilter+0x1a5f>
test   %r15d,%r15d
mov    -0x80(%rsp),%rbx
jle    23e0 <boxfilter+0x12e0>
mov    0x18(%rsp),%rcx
mov    %rcx,%rdi
imul   0x70(%rsp),%rdi
mov    0x158(%rsp),%rax
add    %rdi,%rax
mov    %rax,0x30(%rsp)
lea    (%rdi,%rbx,1),%rax
mov    %rax,0xe0(%rsp)
mov    0xe8(%rsp),%rax
lea    (%rdi,%rax,1),%rax
mov    %rax,0xd8(%rsp)
mov    0xf0(%rsp),%rax
lea    (%rdi,%rax,1),%rax
mov    %rax,0x50(%rsp)
lea    (%rdi,%r13,1),%rax
mov    %rax,(%rsp)
mov    0xf8(%rsp),%rax
mov    %rdi,-0x58(%rsp)
add    %rdi,%rax
mov    %rax,0xd0(%rsp)
mov    -0x38(%rsp),%rax
imul   %ecx,%eax
mov    %rax,-0x48(%rsp)
mov    -0xc(%rsp),%eax
mov    %eax,-0x68(%rsp)
mov    0x38(%rsp),%eax
mov    %eax,-0x40(%rsp)
mov    0x48(%rsp),%rax
mov    %eax,-0x70(%rsp)
xor    %r10d,%r10d
jmp    24e3 <boxfilter+0x13e3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
addl   $0x1,-0x70(%rsp)
addl   $0x1,-0x40(%rsp)
addl   $0x1,-0x68(%rsp)
cmp    -0x60(%rsp),%r10
mov    -0x80(%rsp),%rbx
je     23e0 <boxfilter+0x12e0>
test   %r11d,%r11d
js     25b4 <boxfilter+0x14b4>
mov    -0x48(%rsp),%rax
lea    (%rax,%r10,1),%r8d
cmp    $0x8,%ebx
jae    2840 <boxfilter+0x1740>
xor    %ecx,%ecx
mov    %rcx,%rbp
test   $0x1,%bl
je     2536 <boxfilter+0x1436>
mov    -0x30(%rsp),%rdi
add    %ecx,%edi
imul   %r15d,%edi
add    %r8d,%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm0
mov    %ecx,%edi
imul   %r15d,%edi
add    %r8d,%edi
movslq %edi,%rax
movss  %xmm0,(%rsi,%rax,4)
mov    %rcx,%rbp
or     $0x1,%rbp
not    %rcx
cmp    0x180(%rsp),%rcx
je     25b4 <boxfilter+0x14b4>
mov    %rbx,%rax
sub    %rbp,%rax
mov    %r15d,%r8d
imul   %ebp,%r8d
mov    -0x70(%rsp),%edi
add    %edi,%r8d
mov    0x58(%rsp),%rcx
lea    (%rcx,%rbp,1),%r11d
imul   %r15d,%r11d
add    %edi,%r11d
lea    0x1(%rbp),%ecx
imul   %r15d,%ecx
add    %edi,%ecx
add    %r14d,%ebp
imul   %r15d,%ebp
add    %edi,%ebp
nopl   0x0(%rax)
movslq %r11d,%r11
movss  (%rdx,%r11,4),%xmm0
movslq %r8d,%r8
movss  %xmm0,(%rsi,%r8,4)
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm0
movslq %ecx,%rcx
movss  %xmm0,(%rsi,%rcx,4)
add    %r12d,%r8d
add    %r12d,%r11d
add    %r12d,%ecx
add    %r12d,%ebp
add    $0xfffffffffffffffe,%rax
jne    2580 <boxfilter+0x1480>
cmp    %r13d,%ebx
mov    -0x30(%rsp),%r11
jge    27c1 <boxfilter+0x16c1>
mov    -0x80(%rsp),%rbp
mov    %r11d,%eax
cmpl   $0x7,-0x50(%rsp)
jb     2760 <boxfilter+0x1660>
mov    -0x80(%rsp),%rbp
mov    %r11d,%eax
cmp    $0x1,%r15d
jne    2760 <boxfilter+0x1660>
mov    0xe0(%rsp),%rax
lea    (%rax,%r10,1),%ecx
mov    -0x50(%rsp),%rax
lea    (%rax,%rcx,1),%edi
mov    -0x80(%rsp),%rbp
mov    %r11d,%eax
cmp    %ecx,%edi
jl     2760 <boxfilter+0x1660>
mov    0xd8(%rsp),%rax
lea    (%rax,%r10,1),%ecx
mov    -0x50(%rsp),%rax
lea    (%rax,%rcx,1),%edi
mov    -0x80(%rsp),%rbp
mov    %r11d,%eax
cmp    %ecx,%edi
jl     2760 <boxfilter+0x1660>
mov    -0x58(%rsp),%rax
lea    (%rax,%r10,1),%ecx
mov    -0x50(%rsp),%rax
lea    (%rax,%rcx,1),%edi
mov    -0x80(%rsp),%rbp
mov    %r11d,%eax
cmp    %ecx,%edi
jl     2760 <boxfilter+0x1660>
mov    0xe0(%rsp),%rax
add    %r10d,%eax
mov    -0x58(%rsp),%rcx
lea    (%rcx,%r10,1),%ecx
mov    0xd8(%rsp),%rdi
lea    (%rdi,%r10,1),%edi
cltq
lea    (%rsi,%rax,4),%rbp
mov    0x40(%rsp),%rbx
lea    (%rbx,%rax,4),%r8
movslq %ecx,%rcx
lea    (%rdx,%rcx,4),%rbx
mov    0x130(%rsp),%rax
lea    (%rax,%rcx,4),%rcx
movslq %edi,%rdi
cmp    %rcx,%rbp
setb   0x28(%rsp)
cmp    %r8,%rbx
lea    (%rax,%rdi,4),%rcx
setb   %bl
cmp    %rcx,%rbp
lea    (%rdx,%rdi,4),%rdi
setb   %cl
cmp    %r8,%rdi
setb   %dil
mov    -0x80(%rsp),%rbp
mov    %r11d,%eax
test   %bl,0x28(%rsp)
jne    2760 <boxfilter+0x1660>
mov    -0x80(%rsp),%rbp
mov    %r11d,%eax
and    %dil,%cl
jne    2760 <boxfilter+0x1660>
mov    0xb0(%rsp),%rax
mov    -0x70(%rsp),%ecx
mov    0x88(%rsp),%r8
mov    0x80(%rsp),%rbx
mov    0x20(%rsp),%rbp
nopl   0x0(%rax)
lea    (%rbx,%rcx,1),%edi
movslq %edi,%rdi
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
movslq %ecx,%rcx
movups (%rdx,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rdx,%rcx,4),%xmm2
subps  %xmm2,%xmm1
lea    (%r8,%rcx,1),%edi
movslq %edi,%rdi
movups %xmm0,(%rsi,%rdi,4)
movups %xmm1,0x10(%rsi,%rdi,4)
add    %ebp,%ecx
add    $0xfffffffffffffff8,%rax
jne    2700 <boxfilter+0x1600>
mov    0x78(%rsp),%rbp
mov    0x120(%rsp),%eax
mov    0x90(%rsp),%rcx
cmp    0xb0(%rsp),%rcx
je     27c1 <boxfilter+0x16c1>
nopw   0x0(%rax,%rax,1)
mov    -0x48(%rsp),%rcx
lea    (%rcx,%r10,1),%r8d
mov    %r15d,%ebx
imul   %ebp,%ebx
mov    -0x70(%rsp),%edi
add    %edi,%ebx
mov    0x58(%rsp),%rcx
add    %ebp,%ecx
imul   %r15d,%ecx
add    %edi,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm0
sub    %r11d,%eax
imul   %r15d,%eax
add    %r8d,%eax
cltq
subss  (%rdx,%rax,4),%xmm0
movslq %ebx,%rbx
movss  %xmm0,(%rsi,%rbx,4)
add    %r15d,%ebx
add    %r15d,%ecx
mov    %ebp,%eax
add    $0x1,%ebp
cmp    %ebp,%r13d
jne    2790 <boxfilter+0x1690>
test   %r11d,%r11d
jle    24c0 <boxfilter+0x13c0>
mov    -0x48(%rsp),%rax
add    %r10d,%eax
add    0x8(%rsp),%eax
movslq %eax,%rbp
mov    -0x78(%rsp),%rax
cmpq   $0x8,-0x8(%rsp)
jae    28f0 <boxfilter+0x17f0>
mov    %r15d,%ecx
imul   %eax,%ecx
mov    -0x70(%rsp),%r8d
add    %r8d,%ecx
mov    0x60(%rsp),%rdi
lea    (%rdi,%rax,1),%ebx
imul   %r15d,%ebx
add    %r8d,%ebx
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rbp,4),%xmm0
movslq %ebx,%rbx
subss  (%rdx,%rbx,4),%xmm0
movslq %ecx,%rcx
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rax
add    %r15d,%ecx
add    %r15d,%ebx
cmp    %r9,%rax
jl     2810 <boxfilter+0x1710>
jmp    24c0 <boxfilter+0x13c0>
nopl   0x0(%rax)
cmp    $0x1,%r15d
jne    24fe <boxfilter+0x13fe>
mov    -0x58(%rsp),%rax
lea    (%rax,%r10,1),%ecx
mov    0x58(%rsp),%rbp
lea    (%rcx,%rbp,1),%edi
cmp    %ecx,%edi
jl     24fe <boxfilter+0x13fe>
mov    %rbp,%rdi
shr    $0x20,%rdi
jne    24fe <boxfilter+0x13fe>
mov    0x30(%rsp),%rax
lea    (%rax,%r10,1),%ecx
add    %ecx,%ebp
cmp    %ecx,%ebp
jl     24fe <boxfilter+0x13fe>
mov    $0x0,%ecx
test   %rdi,%rdi
jne    2500 <boxfilter+0x1400>
mov    -0x58(%rsp),%rax
lea    (%rax,%r10,1),%ecx
mov    0x30(%rsp),%rax
lea    (%rax,%r10,1),%edi
movslq %ecx,%rcx
lea    (%rsi,%rcx,4),%rbp
movslq %edi,%rdi
mov    0x170(%rsp),%rbx
lea    (%rbx,%rdi,4),%rbx
cmp    %rbx,%rbp
jae    2a6e <boxfilter+0x196e>
mov    0x178(%rsp),%rbp
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
lea    (%rdx,%rdi,4),%rdi
cmp    %rcx,%rdi
jae    2a6e <boxfilter+0x196e>
xor    %ecx,%ecx
mov    -0x80(%rsp),%rbx
jmp    2500 <boxfilter+0x1400>
xchg   %ax,%ax
mov    -0x78(%rsp),%rax
cmp    $0x1,%r15d
jne    27ea <boxfilter+0x16ea>
mov    (%rsp),%rax
lea    (%rax,%r10,1),%ecx
mov    -0x20(%rsp),%rax
lea    (%rcx,%rax,1),%edi
mov    -0x78(%rsp),%rax
cmp    %ecx,%edi
jl     27ea <boxfilter+0x16ea>
mov    -0x20(%rsp),%rcx
shr    $0x20,%rcx
mov    -0x78(%rsp),%rax
jne    27ea <boxfilter+0x16ea>
mov    0x50(%rsp),%rax
lea    (%rax,%r10,1),%edi
mov    -0x20(%rsp),%rax
lea    (%rdi,%rax,1),%ebx
mov    -0x78(%rsp),%rax
cmp    %edi,%ebx
jl     27ea <boxfilter+0x16ea>
mov    -0x78(%rsp),%rax
test   %rcx,%rcx
jne    27ea <boxfilter+0x16ea>
mov    0x50(%rsp),%rax
add    %r10d,%eax
mov    (%rsp),%rcx
lea    (%rcx,%r10,1),%ecx
cltq
mov    0xc8(%rsp),%rdi
lea    (%rdi,%rax,1),%r8
movslq %ecx,%rcx
lea    (%rdi,%rcx,1),%r11
mov    0xd0(%rsp),%rdi
add    %r10d,%edi
lea    (%rdx,%rax,4),%rax
mov    0xc0(%rsp),%rbx
lea    (%rbx,%r8,4),%r8
lea    (%rsi,%rcx,4),%rbx
mov    0x140(%rsp),%rcx
lea    (%rcx,%r11,4),%rcx
movslq %edi,%rdi
cmp    %rcx,%rax
setb   %r11b
cmp    %r8,%rbx
lea    (%rdx,%rdi,4),%rax
setb   %r8b
cmp    %rcx,%rax
mov    0x138(%rsp),%rax
lea    (%rax,%rdi,4),%rax
setb   %cl
cmp    %rax,%rbx
setb   %bl
mov    -0x78(%rsp),%rax
test   %r8b,%r11b
mov    -0x30(%rsp),%r11
jne    27ea <boxfilter+0x16ea>
mov    -0x78(%rsp),%rax
and    %bl,%cl
jne    27ea <boxfilter+0x16ea>
movss  (%rdx,%rbp,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0xb8(%rsp),%rax
mov    -0x68(%rsp),%ecx
mov    -0x40(%rsp),%edi
mov    0x20(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movups (%rdx,%rcx,4),%xmm1
movups 0x10(%rdx,%rcx,4),%xmm2
movaps %xmm0,%xmm3
subps  %xmm1,%xmm3
movaps %xmm0,%xmm1
subps  %xmm2,%xmm1
movslq %edi,%rdi
movups %xmm3,(%rsi,%rdi,4)
movups %xmm1,0x10(%rsi,%rdi,4)
add    %ebx,%edi
add    %ebx,%ecx
add    $0xfffffffffffffff8,%rax
jne    2a20 <boxfilter+0x1920>
mov    0xa0(%rsp),%rax
mov    0xb8(%rsp),%rcx
cmp    %rcx,-0x8(%rsp)
je     24c0 <boxfilter+0x13c0>
jmp    27ea <boxfilter+0x16ea>
mov    %r8d,0x28(%rsp)
cmpq   $0x0,0x160(%rsp)
je     2afa <boxfilter+0x19fa>
mov    0x118(%rsp),%rcx
mov    -0x70(%rsp),%eax
mov    %eax,%ebx
xor    %ebp,%ebp
mov    0x110(%rsp),%rax
mov    0x108(%rsp),%r8d
mov    0x100(%rsp),%r11
mov    0x20(%rsp),%r14
nop
lea    (%r11,%rbx,1),%edi
movslq %edi,%rdi
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
movslq %ebx,%rbx
movups %xmm0,(%rsi,%rbx,4)
movups %xmm1,0x10(%rsi,%rbx,4)
lea    (%rax,%rbx,1),%edi
movslq %edi,%rdi
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
lea    (%r14,%rbx,1),%edi
movslq %edi,%rdi
movups %xmm0,(%rsi,%rdi,4)
movups %xmm1,0x10(%rsi,%rdi,4)
add    $0x10,%rbp
add    %r8d,%ebx
add    $0xfffffffffffffffe,%rcx
jne    2ab0 <boxfilter+0x19b0>
jmp    2afc <boxfilter+0x19fc>
xor    %ebp,%ebp
testb  $0x1,0x128(%rsp)
01
mov    0x28(%rsp),%r8d
je     2b39 <boxfilter+0x1a39>
mov    -0x30(%rsp),%rax
lea    (%rax,%rbp,1),%ecx
imul   %r15d,%ecx
add    %r8d,%ecx
movslq %ecx,%rcx
movups (%rdx,%rcx,4),%xmm0
movups 0x10(%rdx,%rcx,4),%xmm1
imul   %r15d,%ebp
add    %r8d,%ebp
movslq %ebp,%rcx
movups %xmm0,(%rsi,%rcx,4)
movups %xmm1,0x10(%rsi,%rcx,4)
mov    0xa8(%rsp),%rdi
mov    %rdi,%rcx
mov    -0x80(%rsp),%rbx
cmp    %rbx,%rdi
mov    0x98(%rsp),%r14d
jne    2500 <boxfilter+0x1400>
jmp    25b4 <boxfilter+0x14b4>
mov    0x1d8(%rsp),%eax
cmp    $0x2,%eax
jl     2e51 <boxfilter+0x1d51>
mov    0x1d8(%rsp),%eax
mov    %eax,%eax
mov    %rax,0x8(%rsp)
mov    -0x60(%rsp),%rax
and    $0xfffffff8,%eax
mov    %rax,-0x48(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x50(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,%rcx
mov    %rax,-0x68(%rsp)
and    %rax,0x150(%rsp)
lea    0x30(%rsi),%rax
mov    %rax,0x60(%rsp)
mov    0x68(%rsp),%rax
lea    0x0(,%rax,4),%rcx
mov    $0x1,%eax
mov    %rax,-0x40(%rsp)
xor    %eax,%eax
mov    %rax,-0x58(%rsp)
mov    %ebx,%eax
mov    %ebx,-0x20(%rsp)
movl   $0x0,-0x8(%rsp)
jmp    2c23 <boxfilter+0x1b23>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x40(%rsp),%rax
add    $0x1,%rax
addl   $0x1,-0x8(%rsp)
mov    -0x38(%rsp),%rbx
add    %ebx,-0x20(%rsp)
mov    -0x58(%rsp),%rdx
add    %ebx,%edx
mov    %rdx,-0x58(%rsp)
mov    %rax,-0x40(%rsp)
cmp    0x8(%rsp),%rax
je     2e51 <boxfilter+0x1d51>
cmpl   $0x0,-0x28(%rsp)
jle    2bf0 <boxfilter+0x1af0>
mov    -0x38(%rsp),%rbx
mov    %ebx,%edx
imul   -0x8(%rsp),%edx
lea    (%rbx,%rdx,1),%eax
movslq %eax,%rbp
mov    -0x60(%rsp),%rax
lea    (%rax,%rbp,1),%rdi
mov    %rdi,-0x80(%rsp)
movslq %edx,%rdx
mov    %rdx,-0x78(%rsp)
add    %rax,%rdx
movslq -0x20(%rsp),%r8
mov    0x168(%rsp),%rax
lea    (%rax,%r8,4),%r14
movslq -0x58(%rsp),%rdi
lea    (%rsi,%rdi,4),%r13
mov    0x60(%rsp),%rax
lea    (%rax,%r8,4),%r9
lea    (%rax,%rdi,4),%r12
mov    -0x40(%rsp),%rdi
lea    -0x1(%rdi),%eax
imul   %ebx,%eax
imul   %ebx,%edi
movslq %eax,%r8
movslq %edi,%rax
mov    %rax,-0x70(%rsp)
xor    %r10d,%r10d
jmp    2cbb <boxfilter+0x1bbb>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %rcx,%r9
add    %rcx,%r12
add    %rcx,%r14
add    %rcx,%r13
cmp    0x70(%rsp),%r10
je     2bf0 <boxfilter+0x1af0>
test   %r15d,%r15d
jle    2ca0 <boxfilter+0x1ba0>
mov    %r10,%r11
imul   0x68(%rsp),%r11
cmp    $0x8,%r15d
jb     2d07 <boxfilter+0x1c07>
lea    (%r11,%rbp,1),%rdi
lea    (%rdx,%r11,1),%rbx
lea    (%rsi,%rdi,4),%rdi
lea    (%rsi,%rbx,4),%rbx
cmp    %rbx,%rdi
jae    2d86 <boxfilter+0x1c86>
mov    -0x80(%rsp),%rax
lea    (%rax,%r11,1),%rdi
mov    -0x78(%rsp),%rax
lea    (%r11,%rax,1),%rbx
lea    (%rsi,%rdi,4),%rdi
lea    (%rsi,%rbx,4),%rbx
cmp    %rdi,%rbx
jae    2d86 <boxfilter+0x1c86>
xor    %ebx,%ebx
mov    -0x60(%rsp),%rax
mov    %rbx,%rdi
test   $0x1,%al
je     2d39 <boxfilter+0x1c39>
add    %rbx,%r11
lea    (%r11,%r8,1),%rdi
movss  (%rsi,%rdi,4),%xmm0
add    -0x70(%rsp),%r11
addss  (%rsi,%r11,4),%xmm0
movss  %xmm0,(%rsi,%r11,4)
mov    %rbx,%rdi
or     $0x1,%rdi
not    %rbx
cmp    0x10(%rsp),%rbx
mov    -0x60(%rsp),%rbx
je     2ca0 <boxfilter+0x1ba0>
nopl   0x0(%rax)
movss  0x0(%r13,%rdi,4),%xmm0
addss  -0x4(%r14,%rdi,4),%xmm0
movss  %xmm0,-0x4(%r14,%rdi,4)
movss  0x4(%r13,%rdi,4),%xmm0
addss  (%r14,%rdi,4),%xmm0
movss  %xmm0,(%r14,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rbx
jne    2d50 <boxfilter+0x1c50>
jmp    2ca0 <boxfilter+0x1ba0>
mov    %r8,%rax
cmpq   $0x0,-0x50(%rsp)
je     2dfd <boxfilter+0x1cfd>
mov    0x150(%rsp),%r8
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x30(%r12,%rbx,4),%xmm0
movups -0x20(%r12,%rbx,4),%xmm1
movups -0x30(%r9,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%r9,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups -0x10(%r9,%rbx,4),%xmm1
movups (%r9,%rbx,4),%xmm3
movups %xmm2,-0x30(%r9,%rbx,4)
movups %xmm0,-0x20(%r9,%rbx,4)
movups -0x10(%r12,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups (%r12,%rbx,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,-0x10(%r9,%rbx,4)
movups %xmm1,(%r9,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%r8
jne    2da0 <boxfilter+0x1ca0>
jmp    2dff <boxfilter+0x1cff>
xor    %ebx,%ebx
testb  $0x1,-0x68(%rsp)
mov    %rax,%r8
je     2e36 <boxfilter+0x1d36>
add    %r11,%rbx
lea    (%rbx,%r8,1),%rdi
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
add    -0x70(%rsp),%rbx
movups (%rsi,%rbx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rsi,%rbx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rsi,%rbx,4)
movups %xmm0,0x10(%rsi,%rbx,4)
mov    -0x48(%rsp),%rdi
mov    %rdi,%rbx
mov    -0x60(%rsp),%rax
cmp    %rax,%rdi
je     2ca0 <boxfilter+0x1ba0>
jmp    2d0e <boxfilter+0x1c0e>
cmpl   $0x0,-0x28(%rsp)
mov    0x188(%rsp),%r14
jle    30b2 <boxfilter+0x1fb2>
mov    0x1d8(%rsp),%eax
mov    %rax,%rdx
mov    %edx,%edi
mov    -0x30(%rsp),%rcx
sub    %ecx,%edi
lea    0x1(%rcx),%r9d
lea    -0x1(%rax),%ebp
mov    %ebx,%eax
imul   %ebp,%eax
mov    %edi,-0x78(%rsp)
movslq %edi,%rdi
movslq %edx,%r11
cltq
mov    %rax,-0x50(%rsp)
mov    %r9d,%r13d
and    $0xfffffffe,%r13d
mov    %r9,-0x28(%rsp)
imul   %ebx,%r9d
lea    (%rbx,%rbx,1),%r8d
mov    %ebx,%r15d
imul   %ecx,%r15d
lea    0x1(%rcx,%rcx,1),%r12d
imul   %ebx,%r12d
sub    %ecx,%ebp
sub    %ecx,%ebp
mov    %rdi,-0x48(%rsp)
mov    %edi,%eax
imul   %ebx,%eax
mov    %eax,-0x68(%rsp)
mov    %ebx,%eax
mov    %ebp,-0x58(%rsp)
imul   %ebp,%eax
mov    %eax,-0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
jmp    2efc <boxfilter+0x1dfc>
mov    0x10(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
cmp    0x70(%rsp),%rcx
je     30b2 <boxfilter+0x1fb2>
cmpl   $0x0,-0x18(%rsp)
jle    2ee0 <boxfilter+0x1de0>
mov    0x10(%rsp),%rax
imul   0x68(%rsp),%rax
mov    %rax,-0x80(%rsp)
xor    %ebx,%ebx
jmp    2f30 <boxfilter+0x1e30>
nopw   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rbx
add    $0x1,%rbx
cmp    -0x60(%rsp),%rbx
je     2ee0 <boxfilter+0x1de0>
cmpl   $0x0,-0x30(%rsp)
js     2fe7 <boxfilter+0x1ee7>
mov    -0x80(%rsp),%rax
lea    (%rbx,%rax,1),%r10
cmpl   $0x0,-0x30(%rsp)
je     2fb0 <boxfilter+0x1eb0>
mov    %r14,%rdx
xor    %r14d,%r14d
xor    %ecx,%ecx
mov    -0x38(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
lea    (%r15,%r14,1),%eax
cltq
add    %r10,%rax
movss  (%rsi,%rax,4),%xmm0
movslq %r14d,%r14
lea    (%r10,%r14,1),%rax
movss  %xmm0,(%rdx,%rax,4)
lea    (%r9,%r14,1),%eax
cltq
add    %r10,%rax
movss  (%rsi,%rax,4),%xmm0
lea    (%rdi,%r14,1),%eax
cltq
add    %r10,%rax
movss  %xmm0,(%rdx,%rax,4)
add    $0x2,%rcx
add    %r8d,%r14d
cmp    %rcx,%r13
jne    2f60 <boxfilter+0x1e60>
jmp    2fb5 <boxfilter+0x1eb5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %ecx,%ecx
mov    %r14,%rdx
testb  $0x1,-0x28(%rsp)
mov    %rdx,%r14
je     2fe7 <boxfilter+0x1ee7>
mov    -0x30(%rsp),%rax
add    %ecx,%eax
mov    -0x38(%rsp),%rdx
imul   %edx,%eax
cltq
add    %r10,%rax
movss  (%rsi,%rax,4),%xmm0
imul   %edx,%ecx
movslq %ecx,%rax
add    %r10,%rax
movss  %xmm0,(%r14,%rax,4)
mov    -0x28(%rsp),%rax
cmp    -0x78(%rsp),%eax
mov    -0x38(%rsp),%r10
jge    3042 <boxfilter+0x1f42>
mov    -0x80(%rsp),%rax
lea    (%rbx,%rax,1),%rcx
xor    %eax,%eax
mov    -0x58(%rsp),%edi
cs nopw 0x0(%rax,%rax,1)
lea    (%r12,%rax,1),%edx
movslq %edx,%rdx
add    %rcx,%rdx
movss  (%rsi,%rdx,4),%xmm0
cltq
lea    (%rcx,%rax,1),%rdx
subss  (%rsi,%rdx,4),%xmm0
lea    (%r9,%rax,1),%edx
movslq %edx,%rdx
add    %rcx,%rdx
movss  %xmm0,(%r14,%rdx,4)
add    %r10d,%eax
add    $0xffffffff,%edi
jne    3010 <boxfilter+0x1f10>
mov    %rbx,-0x70(%rsp)
cmpl   $0x0,-0x30(%rsp)
jle    2f20 <boxfilter+0x1e20>
mov    -0x80(%rsp),%rax
mov    -0x70(%rsp),%rcx
add    %rcx,%rax
mov    -0x50(%rsp),%rcx
add    %rax,%rcx
mov    -0x40(%rsp),%edx
mov    %edx,%edi
mov    -0x68(%rsp),%edx
mov    -0x48(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
movss  (%rsi,%rcx,4),%xmm0
movslq %edi,%rdi
lea    (%rax,%rdi,1),%rbx
subss  (%rsi,%rbx,4),%xmm0
movslq %edx,%rdx
lea    (%rax,%rdx,1),%rbx
movss  %xmm0,(%r14,%rbx,4)
add    $0x1,%rbp
add    %r10d,%edx
add    %r10d,%edi
cmp    %r11,%rbp
jl     3080 <boxfilter+0x1f80>
jmp    2f20 <boxfilter+0x1e20>
add    $0x1a0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @boxfilter(float* nocapture %0, float* nocapture %1, float* nocapture %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = mul i32 %5, %4
%9 = mul i32 %8, %6
%10 = icmp sgt i32 %9, 0
br i1 %10, label %11, label %117
11: ; preds = %7
%12 = zext i32 %9 to i64
%13 = icmp ult i32 %9, 8
br i1 %13, label %99, label %14
14: ; preds = %11
%15 = getelementptr float, float* %1, i64 %12
%16 = getelementptr float, float* %0, i64 %12
%17 = icmp ugt float* %16, %1
%18 = icmp ugt float* %15, %0
%19 = and i1 %17, %18
br i1 %19, label %99, label %20
20: ; preds = %14
%21 = and i64 %12, 4294967288
%22 = add nsw i64 %21, -8
%23 = lshr exact i64 %22, 3
%24 = add nuw nsw i64 %23, 1
%25 = and i64 %24, 3
%26 = icmp ult i64 %22, 24
br i1 %26, label %78, label %27
27: ; preds = %20
%28 = and i64 %24, 4611686018427387900
br label %29
29: ; preds = %29, %27
%30 = phi i64 [ 0, %27 ], [ %75, %29 ]
%31 = phi i64 [ 0, %27 ], [ %76, %29 ]
%32 = getelementptr inbounds float, float* %0, i64 %30
%33 = bitcast float* %32 to <4 x float>*
%34 = load <4 x float>, <4 x float>* %33
%35 = getelementptr inbounds float, float* %32, i64 4
%36 = bitcast float* %35 to <4 x float>*
%37 = load <4 x float>, <4 x float>* %36
%38 = getelementptr inbounds float, float* %1, i64 %30
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> %34, <4 x float>* %39
%40 = getelementptr inbounds float, float* %38, i64 4
%41 = bitcast float* %40 to <4 x float>*
store <4 x float> %37, <4 x float>* %41
%42 = or i64 %30, 8
%43 = getelementptr inbounds float, float* %0, i64 %42
%44 = bitcast float* %43 to <4 x float>*
%45 = load <4 x float>, <4 x float>* %44
%46 = getelementptr inbounds float, float* %43, i64 4
%47 = bitcast float* %46 to <4 x float>*
%48 = load <4 x float>, <4 x float>* %47
%49 = getelementptr inbounds float, float* %1, i64 %42
%50 = bitcast float* %49 to <4 x float>*
store <4 x float> %45, <4 x float>* %50
%51 = getelementptr inbounds float, float* %49, i64 4
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %48, <4 x float>* %52
%53 = or i64 %30, 16
%54 = getelementptr inbounds float, float* %0, i64 %53
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = getelementptr inbounds float, float* %54, i64 4
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = getelementptr inbounds float, float* %1, i64 %53
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> %56, <4 x float>* %61
%62 = getelementptr inbounds float, float* %60, i64 4
%63 = bitcast float* %62 to <4 x float>*
store <4 x float> %59, <4 x float>* %63
%64 = or i64 %30, 24
%65 = getelementptr inbounds float, float* %0, i64 %64
%66 = bitcast float* %65 to <4 x float>*
%67 = load <4 x float>, <4 x float>* %66
%68 = getelementptr inbounds float, float* %65, i64 4
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = getelementptr inbounds float, float* %1, i64 %64
%72 = bitcast float* %71 to <4 x float>*
store <4 x float> %67, <4 x float>* %72
%73 = getelementptr inbounds float, float* %71, i64 4
%74 = bitcast float* %73 to <4 x float>*
store <4 x float> %70, <4 x float>* %74
%75 = add nuw i64 %30, 32
%76 = add i64 %31, 4
%77 = icmp eq i64 %76, %28
br i1 %77, label %78, label %29
78: ; preds = %29, %20
%79 = phi i64 [ 0, %20 ], [ %75, %29 ]
%80 = icmp eq i64 %25, 0
br i1 %80, label %97, label %81
81: ; preds = %78, %81
%82 = phi i64 [ %94, %81 ], [ %79, %78 ]
%83 = phi i64 [ %95, %81 ], [ 0, %78 ]
%84 = getelementptr inbounds float, float* %0, i64 %82
%85 = bitcast float* %84 to <4 x float>*
%86 = load <4 x float>, <4 x float>* %85
%87 = getelementptr inbounds float, float* %84, i64 4
%88 = bitcast float* %87 to <4 x float>*
%89 = load <4 x float>, <4 x float>* %88
%90 = getelementptr inbounds float, float* %1, i64 %82
%91 = bitcast float* %90 to <4 x float>*
store <4 x float> %86, <4 x float>* %91
%92 = getelementptr inbounds float, float* %90, i64 4
%93 = bitcast float* %92 to <4 x float>*
store <4 x float> %89, <4 x float>* %93
%94 = add nuw i64 %82, 8
%95 = add i64 %83, 1
%96 = icmp eq i64 %95, %25
br i1 %96, label %97, label %81
97: ; preds = %81, %78
%98 = icmp eq i64 %21, %12
br i1 %98, label %117, label %99
99: ; preds = %14, %11, %97
%100 = phi i64 [ 0, %14 ], [ 0, %11 ], [ %21, %97 ]
%101 = xor i64 %100, -1
%102 = add nsw i64 %101, %12
%103 = and i64 %12, 3
%104 = icmp eq i64 %103, 0
br i1 %104, label %114, label %105
105: ; preds = %99, %105
%106 = phi i64 [ %111, %105 ], [ %100, %99 ]
%107 = phi i64 [ %112, %105 ], [ 0, %99 ]
%108 = getelementptr inbounds float, float* %0, i64 %106
%109 = load float, float* %108
%110 = getelementptr inbounds float, float* %1, i64 %106
store float %109, float* %110
%111 = add nuw nsw i64 %106, 1
%112 = add i64 %107, 1
%113 = icmp eq i64 %112, %103
br i1 %113, label %114, label %105
114: ; preds = %105, %99
%115 = phi i64 [ %100, %99 ], [ %111, %105 ]
%116 = icmp ult i64 %102, 3
br i1 %116, label %117, label %141
117: ; preds = %114, %141, %97, %7
%118 = icmp sgt i32 %6, 0
br i1 %118, label %119, label %1422
119: ; preds = %117
%120 = icmp sgt i32 %5, 0
%121 = icmp sgt i32 %4, 1
%122 = zext i32 %4 to i64
%123 = add nsw i64 %122, -2
%124 = mul i32 %5, %4
%125 = mul i32 %5, %4
%126 = add nsw i64 %122, -1
%127 = getelementptr float, float* %1, i64 %126
%128 = getelementptr float, float* %1, i64 %126
%129 = add nsw i64 %122, -1
%130 = icmp ult i64 %129, 8
%131 = trunc i64 %123 to i32
%132 = icmp ugt i64 %123, 4294967295
%133 = trunc i64 %123 to i32
%134 = icmp ugt i64 %123, 4294967295
%135 = and i64 %129, -8
%136 = or i64 %135, 1
%137 = icmp eq i64 %129, %135
%138 = and i64 %122, 1
%139 = icmp eq i64 %138, 0
%140 = sub nsw i64 0, %122
br label %160
141: ; preds = %114, %141
%142 = phi i64 [ %158, %141 ], [ %115, %114 ]
%143 = getelementptr inbounds float, float* %0, i64 %142
%144 = load float, float* %143
%145 = getelementptr inbounds float, float* %1, i64 %142
store float %144, float* %145
%146 = add nuw nsw i64 %142, 1
%147 = getelementptr inbounds float, float* %0, i64 %146
%148 = load float, float* %147
%149 = getelementptr inbounds float, float* %1, i64 %146
store float %148, float* %149
%150 = add nuw nsw i64 %142, 2
%151 = getelementptr inbounds float, float* %0, i64 %150
%152 = load float, float* %151
%153 = getelementptr inbounds float, float* %1, i64 %150
store float %152, float* %153
%154 = add nuw nsw i64 %142, 3
%155 = getelementptr inbounds float, float* %0, i64 %154
%156 = load float, float* %155
%157 = getelementptr inbounds float, float* %1, i64 %154
store float %156, float* %157
%158 = add nuw nsw i64 %142, 4
%159 = icmp eq i64 %158, %12
br i1 %159, label %117, label %141
160: ; preds = %119, %343
%161 = phi i32 [ 0, %119 ], [ %344, %343 ]
%162 = mul i32 %125, %161
%163 = add i32 %162, 1
%164 = mul i32 %124, %161
%165 = add i32 %164, 1
br i1 %120, label %166, label %343
166: ; preds = %160
%167 = mul i32 %8, %161
br label %268
168: ; preds = %343
br i1 %118, label %169, label %1422
169: ; preds = %168
%170 = icmp sgt i32 %5, 0
%171 = icmp slt i32 %3, 0
%172 = sub i32 %4, %3
%173 = add i32 %3, 1
%174 = icmp slt i32 %173, %172
%175 = icmp sgt i32 %3, 0
%176 = xor i32 %3, -1
%177 = zext i32 %173 to i64
%178 = sext i32 %172 to i64
%179 = sext i32 %4 to i64
%180 = zext i32 %5 to i64
%181 = zext i32 %173 to i64
%182 = add nsw i64 %178, 1
%183 = call i64 @llvm.smax.i64(i64 %182, i64 %179)
%184 = xor i64 %178, -1
%185 = add i64 %183, %184
%186 = sub i32 1, %3
%187 = zext i32 %186 to i64
%188 = mul i32 %3, -2
%189 = zext i32 %188 to i64
%190 = zext i32 %188 to i64
%191 = sub nsw i64 0, %178
%192 = getelementptr float, float* %1, i64 %191
%193 = add nsw i64 %178, 1
%194 = call i64 @llvm.smax.i64(i64 %193, i64 %179)
%195 = sub i32 1, %3
%196 = zext i32 %195 to i64
%197 = getelementptr float, float* %2, i64 %191
%198 = getelementptr float, float* %1, i64 1
%199 = add nsw i64 %178, 1
%200 = call i64 @llvm.smax.i64(i64 %199, i64 %179)
%201 = sub i64 %200, %178
%202 = add i32 %4, -2
%203 = shl i32 %3, 1
%204 = sub i32 %202, %203
%205 = mul i32 %5, %4
%206 = zext i32 %205 to i64
%207 = or i32 %203, 1
%208 = zext i32 %207 to i64
%209 = zext i32 %205 to i64
%210 = add i32 %4, -2
%211 = shl i32 %3, 1
%212 = sub i32 %210, %211
%213 = zext i32 %212 to i64
%214 = add nuw nsw i64 %213, 1
%215 = getelementptr float, float* %2, i64 %214
%216 = getelementptr float, float* %1, i64 %214
%217 = or i32 %211, 1
%218 = zext i32 %217 to i64
%219 = getelementptr float, float* %1, i64 %214
%220 = add i32 %4, -2
%221 = mul i32 %3, -2
%222 = add i32 %221, %220
%223 = zext i32 %222 to i64
%224 = add nuw nsw i64 %223, 1
%225 = add nsw i64 %181, -1
%226 = mul i32 %5, %4
%227 = zext i32 %226 to i64
%228 = zext i32 %3 to i64
%229 = zext i32 %226 to i64
%230 = getelementptr float, float* %2, i64 %181
%231 = zext i32 %3 to i64
%232 = getelementptr float, float* %1, i64 %181
%233 = and i64 %181, 4294967288
%234 = add nsw i64 %233, -8
%235 = lshr exact i64 %234, 3
%236 = add nuw nsw i64 %235, 1
%237 = xor i32 %3, -1
%238 = add i32 %237, %4
%239 = icmp ult i32 %173, 8
%240 = trunc i64 %225 to i32
%241 = icmp ugt i64 %225, 4294967295
%242 = trunc i64 %225 to i32
%243 = icmp ugt i64 %225, 4294967295
%244 = and i64 %181, 4294967288
%245 = and i64 %236, 1
%246 = icmp eq i64 %234, 0
%247 = and i64 %236, 4611686018427387902
%248 = icmp eq i64 %245, 0
%249 = icmp eq i64 %244, %181
%250 = and i64 %181, 1
%251 = icmp eq i64 %250, 0
%252 = sub nsw i64 0, %181
%253 = icmp ult i32 %222, 7
%254 = and i64 %224, 8589934584
%255 = add nuw nsw i64 %254, %177
%256 = trunc i64 %254 to i32
%257 = add i32 %256, %3
%258 = icmp eq i64 %224, %254
%259 = icmp ult i64 %201, 8
%260 = icmp ne i32 %4, 1
%261 = trunc i64 %185 to i32
%262 = icmp ugt i64 %185, 4294967295
%263 = trunc i64 %185 to i32
%264 = icmp ugt i64 %185, 4294967295
%265 = and i64 %201, -8
%266 = add i64 %265, %178
%267 = icmp eq i64 %201, %265
br label %374
268: ; preds = %166, %346
%269 = phi i32 [ 0, %166 ], [ %347, %346 ]
%270 = mul i32 %269, %4
%271 = add i32 %163, %270
%272 = sext i32 %271 to i64
%273 = getelementptr float, float* %1, i64 %272
%274 = getelementptr float, float* %127, i64 %272
%275 = add i32 %162, %270
%276 = sext i32 %275 to i64
%277 = getelementptr float, float* %1, i64 %276
%278 = getelementptr float, float* %128, i64 %276
%279 = mul i32 %269, %4
%280 = add i32 %165, %279
%281 = add i32 %164, %279
br i1 %121, label %282, label %346
282: ; preds = %268
%283 = mul nsw i32 %269, %4
%284 = add i32 %283, %167
%285 = add i32 %284, -1
br i1 %130, label %325, label %286
286: ; preds = %282
%287 = add i32 %280, %131
%288 = icmp slt i32 %287, %280
%289 = or i1 %288, %132
%290 = add i32 %281, %133
%291 = icmp slt i32 %290, %281
%292 = or i1 %291, %134
%293 = or i1 %289, %292
br i1 %293, label %325, label %294
294: ; preds = %286
%295 = icmp ult float* %273, %278
%296 = icmp ult float* %277, %274
%297 = and i1 %295, %296
br i1 %297, label %325, label %298
298: ; preds = %294, %298
%299 = phi i64 [ %322, %298 ], [ 0, %294 ]
%300 = trunc i64 %299 to i32
%301 = or i32 %300, 1
%302 = add i32 %285, %301
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds float, float* %1, i64 %303
%305 = bitcast float* %304 to <4 x float>*
%306 = load <4 x float>, <4 x float>* %305
%307 = getelementptr inbounds float, float* %304, i64 4
%308 = bitcast float* %307 to <4 x float>*
%309 = load <4 x float>, <4 x float>* %308
%310 = add i32 %284, %301
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds float, float* %1, i64 %311
%313 = bitcast float* %312 to <4 x float>*
%314 = load <4 x float>, <4 x float>* %313
%315 = getelementptr inbounds float, float* %312, i64 4
%316 = bitcast float* %315 to <4 x float>*
%317 = load <4 x float>, <4 x float>* %316
%318 = fadd <4 x float> %306, %314
%319 = fadd <4 x float> %309, %317
%320 = bitcast float* %312 to <4 x float>*
store <4 x float> %318, <4 x float>* %320
%321 = bitcast float* %315 to <4 x float>*
store <4 x float> %319, <4 x float>* %321
%322 = add nuw i64 %299, 8
%323 = icmp eq i64 %322, %135
br i1 %323, label %324, label %298
324: ; preds = %298
br i1 %137, label %346, label %325
325: ; preds = %294, %286, %282, %324
%326 = phi i64 [ 1, %294 ], [ 1, %286 ], [ 1, %282 ], [ %136, %324 ]
%327 = xor i64 %326, -1
br i1 %139, label %328, label %340
328: ; preds = %325
%329 = trunc i64 %326 to i32
%330 = add i32 %285, %329
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds float, float* %1, i64 %331
%333 = load float, float* %332
%334 = add i32 %284, %329
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float, float* %1, i64 %335
%337 = load float, float* %336
%338 = fadd float %333, %337
store float %338, float* %336
%339 = add nuw nsw i64 %326, 1
br label %340
340: ; preds = %328, %325
%341 = phi i64 [ %326, %325 ], [ %339, %328 ]
%342 = icmp eq i64 %327, %140
br i1 %342, label %346, label %349
343: ; preds = %346, %160
%344 = add nuw nsw i32 %161, 1
%345 = icmp eq i32 %344, %6
br i1 %345, label %168, label %160
346: ; preds = %340, %349, %324, %268
%347 = add nuw nsw i32 %269, 1
%348 = icmp eq i32 %347, %5
br i1 %348, label %343, label %268
349: ; preds = %340, %349
%350 = phi i64 [ %372, %349 ], [ %341, %340 ]
%351 = trunc i64 %350 to i32
%352 = add i32 %285, %351
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float, float* %1, i64 %353
%355 = load float, float* %354
%356 = add i32 %284, %351
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds float, float* %1, i64 %357
%359 = load float, float* %358
%360 = fadd float %355, %359
store float %360, float* %358
%361 = trunc i64 %350 to i32
%362 = add i32 %361, 1
%363 = add i32 %284, %361
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds float, float* %1, i64 %364
%366 = load float, float* %365
%367 = add i32 %284, %362
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds float, float* %1, i64 %368
%370 = load float, float* %369
%371 = fadd float %366, %370
store float %371, float* %369
%372 = add nuw nsw i64 %350, 2
%373 = icmp eq i64 %372, %122
br i1 %373, label %346, label %349
374: ; preds = %169, %567
%375 = phi i64 [ 0, %169 ], [ %570, %567 ]
%376 = phi i32 [ 0, %169 ], [ %568, %567 ]
%377 = mul i64 %375, %229
%378 = add i64 %377, %231
%379 = mul i64 %375, %227
%380 = add i64 %379, %228
%381 = mul i64 %375, %209
%382 = add i64 %381, %181
%383 = add i64 %381, %218
%384 = mul i64 %375, %206
%385 = add i64 %384, %181
%386 = add i64 %384, %208
%387 = mul i64 %375, %180
%388 = add i64 %387, %190
%389 = add i64 %387, %196
%390 = mul i64 %375, %180
%391 = add i64 %390, %187
%392 = add i64 %390, %189
br i1 %170, label %393, label %567
393: ; preds = %374
%394 = mul i32 %8, %376
br label %415
395: ; preds = %567
br i1 %118, label %396, label %1422
396: ; preds = %395
%397 = icmp sgt i32 %5, 1
%398 = icmp sgt i32 %4, 0
%399 = zext i32 %4 to i64
%400 = add nsw i64 %122, -1
%401 = mul i32 %5, %4
%402 = mul i32 %5, %4
%403 = getelementptr float, float* %2, i64 %122
%404 = getelementptr float, float* %2, i64 %122
%405 = icmp ult i32 %4, 8
%406 = trunc i64 %400 to i32
%407 = icmp ugt i64 %400, 4294967295
%408 = trunc i64 %400 to i32
%409 = icmp ugt i64 %400, 4294967295
%410 = and i64 %122, 4294967288
%411 = icmp eq i64 %410, %122
%412 = and i64 %122, 1
%413 = icmp eq i64 %412, 0
%414 = sub nsw i64 0, %122
br label %783
415: ; preds = %393, %766
%416 = phi i64 [ 0, %393 ], [ %767, %766 ]
%417 = mul i64 %416, %122
%418 = add i64 %377, %417
%419 = shl i64 %418, 32
%420 = ashr exact i64 %419, 32
%421 = getelementptr float, float* %2, i64 %420
%422 = getelementptr float, float* %230, i64 %420
%423 = add i64 %378, %417
%424 = shl i64 %423, 32
%425 = ashr exact i64 %424, 32
%426 = getelementptr float, float* %1, i64 %425
%427 = getelementptr float, float* %232, i64 %425
%428 = mul i64 %416, %122
%429 = add i64 %379, %428
%430 = trunc i64 %429 to i32
%431 = add i64 %380, %428
%432 = trunc i64 %431 to i32
%433 = mul i64 %416, %122
%434 = add i64 %382, %433
%435 = shl i64 %434, 32
%436 = ashr exact i64 %435, 32
%437 = getelementptr float, float* %2, i64 %436
%438 = getelementptr float, float* %215, i64 %436
%439 = add i64 %381, %433
%440 = shl i64 %439, 32
%441 = ashr exact i64 %440, 32
%442 = getelementptr float, float* %1, i64 %441
%443 = getelementptr float, float* %216, i64 %441
%444 = add i64 %383, %433
%445 = shl i64 %444, 32
%446 = ashr exact i64 %445, 32
%447 = getelementptr float, float* %1, i64 %446
%448 = getelementptr float, float* %219, i64 %446
%449 = mul i64 %416, %122
%450 = add i64 %385, %449
%451 = trunc i64 %450 to i32
%452 = add i64 %386, %449
%453 = trunc i64 %452 to i32
%454 = add i64 %384, %449
%455 = trunc i64 %454 to i32
%456 = add i64 %388, %416
%457 = shl i64 %456, 32
%458 = ashr exact i64 %457, 32
%459 = getelementptr float, float* %1, i64 %458
%460 = add i64 %194, %458
%461 = getelementptr float, float* %192, i64 %460
%462 = add i64 %389, %416
%463 = shl i64 %462, 32
%464 = ashr exact i64 %463, 32
%465 = getelementptr float, float* %2, i64 %464
%466 = add i64 %194, %464
%467 = getelementptr float, float* %197, i64 %466
%468 = add i64 %387, %416
%469 = shl i64 %468, 32
%470 = ashr exact i64 %469, 32
%471 = getelementptr float, float* %1, i64 %470
%472 = getelementptr float, float* %198, i64 %470
%473 = add i64 %391, %416
%474 = trunc i64 %473 to i32
%475 = add i64 %392, %416
%476 = trunc i64 %475 to i32
br i1 %171, label %571, label %477
477: ; preds = %415
%478 = trunc i64 %416 to i32
%479 = mul i32 %478, %4
%480 = add i32 %479, %394
%481 = add i32 %480, %3
br i1 %239, label %551, label %482
482: ; preds = %477
%483 = add i32 %430, %240
%484 = icmp slt i32 %483, %430
%485 = or i1 %484, %241
%486 = add i32 %432, %242
%487 = icmp slt i32 %486, %432
%488 = or i1 %487, %243
%489 = or i1 %485, %488
br i1 %489, label %551, label %490
490: ; preds = %482
%491 = icmp ult float* %421, %427
%492 = icmp ult float* %426, %422
%493 = and i1 %491, %492
br i1 %493, label %551, label %494
494: ; preds = %490
br i1 %246, label %532, label %495
495: ; preds = %494, %495
%496 = phi i64 [ %529, %495 ], [ 0, %494 ]
%497 = phi i64 [ %530, %495 ], [ 0, %494 ]
%498 = trunc i64 %496 to i32
%499 = add i32 %481, %498
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds float, float* %1, i64 %500
%502 = bitcast float* %501 to <4 x float>*
%503 = load <4 x float>, <4 x float>* %502
%504 = getelementptr inbounds float, float* %501, i64 4
%505 = bitcast float* %504 to <4 x float>*
%506 = load <4 x float>, <4 x float>* %505
%507 = add i32 %480, %498
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds float, float* %2, i64 %508
%510 = bitcast float* %509 to <4 x float>*
store <4 x float> %503, <4 x float>* %510
%511 = getelementptr inbounds float, float* %509, i64 4
%512 = bitcast float* %511 to <4 x float>*
store <4 x float> %506, <4 x float>* %512
%513 = trunc i64 %496 to i32
%514 = or i32 %513, 8
%515 = add i32 %481, %514
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds float, float* %1, i64 %516
%518 = bitcast float* %517 to <4 x float>*
%519 = load <4 x float>, <4 x float>* %518
%520 = getelementptr inbounds float, float* %517, i64 4
%521 = bitcast float* %520 to <4 x float>*
%522 = load <4 x float>, <4 x float>* %521
%523 = add i32 %480, %514
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds float, float* %2, i64 %524
%526 = bitcast float* %525 to <4 x float>*
store <4 x float> %519, <4 x float>* %526
%527 = getelementptr inbounds float, float* %525, i64 4
%528 = bitcast float* %527 to <4 x float>*
store <4 x float> %522, <4 x float>* %528
%529 = add nuw i64 %496, 16
%530 = add i64 %497, 2
%531 = icmp eq i64 %530, %247
br i1 %531, label %532, label %495
532: ; preds = %495, %494
%533 = phi i64 [ 0, %494 ], [ %529, %495 ]
br i1 %248, label %550, label %534
534: ; preds = %532
%535 = trunc i64 %533 to i32
%536 = add i32 %481, %535
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds float, float* %1, i64 %537
%539 = bitcast float* %538 to <4 x float>*
%540 = load <4 x float>, <4 x float>* %539
%541 = getelementptr inbounds float, float* %538, i64 4
%542 = bitcast float* %541 to <4 x float>*
%543 = load <4 x float>, <4 x float>* %542
%544 = add i32 %480, %535
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds float, float* %2, i64 %545
%547 = bitcast float* %546 to <4 x float>*
store <4 x float> %540, <4 x float>* %547
%548 = getelementptr inbounds float, float* %546, i64 4
%549 = bitcast float* %548 to <4 x float>*
store <4 x float> %543, <4 x float>* %549
br label %550
550: ; preds = %532, %534
br i1 %249, label %571, label %551
551: ; preds = %490, %482, %477, %550
%552 = phi i64 [ 0, %490 ], [ 0, %482 ], [ 0, %477 ], [ %244, %550 ]
%553 = xor i64 %552, -1
br i1 %251, label %564, label %554
554: ; preds = %551
%555 = trunc i64 %552 to i32
%556 = add i32 %481, %555
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds float, float* %1, i64 %557
%559 = load float, float* %558
%560 = add i32 %480, %555
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds float, float* %2, i64 %561
store float %559, float* %562
%563 = or i64 %552, 1
br label %564
564: ; preds = %554, %551
%565 = phi i64 [ %552, %551 ], [ %563, %554 ]
%566 = icmp eq i64 %553, %252
br i1 %566, label %571, label %654
567: ; preds = %766, %374
%568 = add nuw nsw i32 %376, 1
%569 = icmp eq i32 %568, %6
%570 = add i64 %375, 1
br i1 %569, label %395, label %374
571: ; preds = %564, %654, %550, %415
br i1 %174, label %572, label %675
572: ; preds = %571
%573 = trunc i64 %416 to i32
%574 = mul i32 %573, %4
%575 = add i32 %574, %394
%576 = add i32 %575, %3
%577 = sub i32 %575, %3
br i1 %253, label %627, label %578
578: ; preds = %572
%579 = add i32 %204, %451
%580 = icmp slt i32 %579, %451
%581 = add i32 %204, %453
%582 = icmp slt i32 %581, %453
%583 = add i32 %204, %455
%584 = icmp slt i32 %583, %455
%585 = or i1 %580, %582
%586 = or i1 %585, %584
br i1 %586, label %627, label %587
587: ; preds = %578
%588 = icmp ult float* %437, %443
%589 = icmp ult float* %442, %438
%590 = and i1 %588, %589
%591 = icmp ult float* %437, %448
%592 = icmp ult float* %447, %438
%593 = and i1 %591, %592
%594 = or i1 %590, %593
br i1 %594, label %627, label %595
595: ; preds = %587, %595
%596 = phi i64 [ %624, %595 ], [ 0, %587 ]
%597 = trunc i64 %596 to i32
%598 = trunc i64 %596 to i32
%599 = add i32 %173, %598
%600 = add i32 %576, %599
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds float, float* %1, i64 %601
%603 = bitcast float* %602 to <4 x float>*
%604 = load <4 x float>, <4 x float>* %603
%605 = getelementptr inbounds float, float* %602, i64 4
%606 = bitcast float* %605 to <4 x float>*
%607 = load <4 x float>, <4 x float>* %606
%608 = add i32 %575, %597
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds float, float* %1, i64 %609
%611 = bitcast float* %610 to <4 x float>*
%612 = load <4 x float>, <4 x float>* %611
%613 = getelementptr inbounds float, float* %610, i64 4
%614 = bitcast float* %613 to <4 x float>*
%615 = load <4 x float>, <4 x float>* %614
%616 = fsub <4 x float> %604, %612
%617 = fsub <4 x float> %607, %615
%618 = add i32 %575, %599
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds float, float* %2, i64 %619
%621 = bitcast float* %620 to <4 x float>*
store <4 x float> %616, <4 x float>* %621
%622 = getelementptr inbounds float, float* %620, i64 4
%623 = bitcast float* %622 to <4 x float>*
store <4 x float> %617, <4 x float>* %623
%624 = add nuw i64 %596, 8
%625 = icmp eq i64 %624, %254
br i1 %625, label %626, label %595
626: ; preds = %595
br i1 %258, label %675, label %627
627: ; preds = %587, %578, %572, %626
%628 = phi i64 [ %177, %587 ], [ %177, %578 ], [ %177, %572 ], [ %255, %626 ]
%629 = phi i32 [ %3, %587 ], [ %3, %578 ], [ %3, %572 ], [ %257, %626 ]
%630 = trunc i64 %628 to i32
%631 = add i32 %630, %3
%632 = sub i32 %4, %631
%633 = and i32 %632, 1
%634 = icmp eq i32 %633, 0
br i1 %634, label %650, label %635
635: ; preds = %627
%636 = trunc i64 %628 to i32
%637 = add i32 %576, %636
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds float, float* %1, i64 %638
%640 = load float, float* %639
%641 = add i32 %577, %629
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds float, float* %1, i64 %642
%644 = load float, float* %643
%645 = fsub float %640, %644
%646 = add i32 %575, %636
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds float, float* %2, i64 %647
store float %645, float* %648
%649 = add nsw i64 %628, 1
br label %650
650: ; preds = %635, %627
%651 = phi i64 [ %628, %627 ], [ %649, %635 ]
%652 = phi i32 [ %629, %627 ], [ %636, %635 ]
%653 = icmp eq i32 %238, %630
br i1 %653, label %675, label %733
654: ; preds = %564, %654
%655 = phi i64 [ %673, %654 ], [ %565, %564 ]
%656 = trunc i64 %655 to i32
%657 = add i32 %481, %656
%658 = sext i32 %657 to i64
%659 = getelementptr inbounds float, float* %1, i64 %658
%660 = load float, float* %659
%661 = add i32 %480, %656
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds float, float* %2, i64 %662
store float %660, float* %663
%664 = trunc i64 %655 to i32
%665 = add i32 %664, 1
%666 = add i32 %481, %665
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds float, float* %1, i64 %667
%669 = load float, float* %668
%670 = add i32 %480, %665
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds float, float* %2, i64 %671
store float %669, float* %672
%673 = add nuw nsw i64 %655, 2
%674 = icmp eq i64 %673, %181
br i1 %674, label %571, label %654
675: ; preds = %650, %733, %626, %571
br i1 %175, label %676, label %766
676: ; preds = %675
%677 = trunc i64 %416 to i32
%678 = mul i32 %677, %4
%679 = add i32 %678, %394
%680 = add i32 %679, -1
%681 = add i32 %680, %4
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds float, float* %1, i64 %682
%684 = add i32 %679, %176
br i1 %259, label %731, label %685
685: ; preds = %676
%686 = add i32 %474, %261
%687 = icmp slt i32 %686, %474
%688 = or i1 %687, %262
%689 = add i32 %476, %263
%690 = icmp slt i32 %689, %476
%691 = or i1 %690, %264
%692 = or i1 %260, %688
%693 = or i1 %692, %691
br i1 %693, label %731, label %694
694: ; preds = %685
%695 = icmp ult float* %459, %467
%696 = icmp ult float* %465, %461
%697 = and i1 %695, %696
%698 = icmp ult float* %471, %467
%699 = icmp ult float* %465, %472
%700 = and i1 %698, %699
%701 = or i1 %697, %700
br i1 %701, label %731, label %702
702: ; preds = %694
%703 = load float, float* %683
%704 = insertelement <4 x float> poison, float %703, i64 0
%705 = shufflevector <4 x float> %704, <4 x float> poison, <4 x i32> zeroinitializer
%706 = insertelement <4 x float> poison, float %703, i64 0
%707 = shufflevector <4 x float> %706, <4 x float> poison, <4 x i32> zeroinitializer
br label %708
708: ; preds = %708, %702
%709 = phi i64 [ 0, %702 ], [ %728, %708 ]
%710 = trunc i64 %709 to i32
%711 = add i32 %172, %710
%712 = add i32 %684, %711
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds float, float* %1, i64 %713
%715 = bitcast float* %714 to <4 x float>*
%716 = load <4 x float>, <4 x float>* %715
%717 = getelementptr inbounds float, float* %714, i64 4
%718 = bitcast float* %717 to <4 x float>*
%719 = load <4 x float>, <4 x float>* %718
%720 = fsub <4 x float> %705, %716
%721 = fsub <4 x float> %707, %719
%722 = add i32 %679, %711
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds float, float* %2, i64 %723
%725 = bitcast float* %724 to <4 x float>*
store <4 x float> %720, <4 x float>* %725
%726 = getelementptr inbounds float, float* %724, i64 4
%727 = bitcast float* %726 to <4 x float>*
store <4 x float> %721, <4 x float>* %727
%728 = add nuw i64 %709, 8
%729 = icmp eq i64 %728, %265
br i1 %729, label %730, label %708
730: ; preds = %708
br i1 %267, label %766, label %731
731: ; preds = %694, %685, %676, %730
%732 = phi i64 [ %178, %694 ], [ %178, %685 ], [ %178, %676 ], [ %266, %730 ]
br label %769
733: ; preds = %650, %733
%734 = phi i64 [ %763, %733 ], [ %651, %650 ]
%735 = phi i32 [ %750, %733 ], [ %652, %650 ]
%736 = trunc i64 %734 to i32
%737 = add i32 %576, %736
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds float, float* %1, i64 %738
%740 = load float, float* %739
%741 = add i32 %577, %735
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds float, float* %1, i64 %742
%744 = load float, float* %743
%745 = fsub float %740, %744
%746 = add i32 %575, %736
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds float, float* %2, i64 %747
store float %745, float* %748
%749 = trunc i64 %734 to i32
%750 = add i32 %749, 1
%751 = add i32 %576, %750
%752 = sext i32 %751 to i64
%753 = getelementptr inbounds float, float* %1, i64 %752
%754 = load float, float* %753
%755 = add i32 %577, %736
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds float, float* %1, i64 %756
%758 = load float, float* %757
%759 = fsub float %754, %758
%760 = add i32 %575, %750
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds float, float* %2, i64 %761
store float %759, float* %762
%763 = add nuw nsw i64 %734, 2
%764 = trunc i64 %763 to i32
%765 = icmp eq i32 %172, %764
br i1 %765, label %675, label %733
766: ; preds = %769, %730, %675
%767 = add nuw nsw i64 %416, 1
%768 = icmp eq i64 %767, %180
br i1 %768, label %567, label %415
769: ; preds = %731, %769
%770 = phi i64 [ %781, %769 ], [ %732, %731 ]
%771 = load float, float* %683
%772 = trunc i64 %770 to i32
%773 = add i32 %684, %772
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds float, float* %1, i64 %774
%776 = load float, float* %775
%777 = fsub float %771, %776
%778 = add i32 %679, %772
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds float, float* %2, i64 %779
store float %777, float* %780
%781 = add nsw i64 %770, 1
%782 = icmp slt i64 %781, %179
br i1 %782, label %769, label %766
783: ; preds = %396, %958
%784 = phi i32 [ 0, %396 ], [ %959, %958 ]
%785 = mul i32 %402, %784
%786 = add i32 %785, %4
%787 = mul i32 %401, %784
%788 = add i32 %787, %4
br i1 %397, label %789, label %958
789: ; preds = %783
%790 = mul i32 %8, %784
br label %881
791: ; preds = %958
br i1 %118, label %792, label %1422
792: ; preds = %791
%793 = icmp sgt i32 %4, 0
%794 = icmp slt i32 %3, 0
%795 = sub i32 %5, %3
%796 = add i32 %3, 1
%797 = icmp slt i32 %796, %795
%798 = icmp sgt i32 %3, 0
%799 = add i32 %5, -1
%800 = mul nsw i32 %799, %4
%801 = xor i32 %3, -1
%802 = zext i32 %796 to i64
%803 = sext i32 %795 to i64
%804 = sext i32 %5 to i64
%805 = zext i32 %4 to i64
%806 = zext i32 %796 to i64
%807 = add nsw i64 %803, 1
%808 = call i64 @llvm.smax.i64(i64 %807, i64 %804)
%809 = xor i64 %803, -1
%810 = add i64 %808, %809
%811 = zext i32 %795 to i64
%812 = add i32 %5, -1
%813 = mul i32 %3, -2
%814 = add i32 %813, %812
%815 = zext i32 %814 to i64
%816 = zext i32 %814 to i64
%817 = sub nsw i64 0, %803
%818 = getelementptr float, float* %2, i64 %817
%819 = add nsw i64 %803, 1
%820 = call i64 @llvm.smax.i64(i64 %819, i64 %804)
%821 = zext i32 %795 to i64
%822 = getelementptr float, float* %1, i64 %817
%823 = zext i32 %799 to i64
%824 = getelementptr float, float* %2, i64 1
%825 = add nsw i64 %803, 1
%826 = call i64 @llvm.smax.i64(i64 %825, i64 %804)
%827 = sub i64 %826, %803
%828 = add i32 %5, -2
%829 = shl i32 %3, 1
%830 = sub i32 %828, %829
%831 = or i32 %829, 1
%832 = zext i32 %831 to i64
%833 = zext i32 %830 to i64
%834 = add nuw nsw i64 %833, 1
%835 = getelementptr float, float* %1, i64 %834
%836 = getelementptr float, float* %2, i64 %834
%837 = or i32 %829, 1
%838 = zext i32 %837 to i64
%839 = getelementptr float, float* %2, i64 %834
%840 = add i32 %5, -2
%841 = mul i32 %3, -2
%842 = add i32 %841, %840
%843 = zext i32 %842 to i64
%844 = add nuw nsw i64 %843, 1
%845 = add nsw i64 %181, -1
%846 = zext i32 %3 to i64
%847 = getelementptr float, float* %1, i64 %181
%848 = zext i32 %3 to i64
%849 = getelementptr float, float* %2, i64 %181
%850 = icmp ult i32 %173, 8
%851 = icmp ne i32 %4, 1
%852 = trunc i64 %845 to i32
%853 = icmp ugt i64 %845, 4294967295
%854 = trunc i64 %845 to i32
%855 = icmp ugt i64 %845, 4294967295
%856 = and i64 %181, 4294967288
%857 = and i64 %236, 1
%858 = icmp eq i64 %234, 0
%859 = and i64 %236, 4611686018427387902
%860 = icmp eq i64 %857, 0
%861 = icmp eq i64 %856, %181
%862 = and i64 %181, 1
%863 = icmp eq i64 %862, 0
%864 = sub nsw i64 0, %181
%865 = icmp ult i32 %842, 7
%866 = icmp ne i32 %4, 1
%867 = and i64 %844, 8589934584
%868 = add nuw nsw i64 %867, %802
%869 = trunc i64 %867 to i32
%870 = add i32 %869, %3
%871 = icmp eq i64 %844, %867
%872 = icmp ult i64 %827, 8
%873 = icmp ne i32 %4, 1
%874 = trunc i64 %810 to i32
%875 = icmp ugt i64 %810, 4294967295
%876 = trunc i64 %810 to i32
%877 = icmp ugt i64 %810, 4294967295
%878 = and i64 %827, -8
%879 = add i64 %878, %803
%880 = icmp eq i64 %827, %878
br label %992
881: ; preds = %789, %961
%882 = phi i32 [ 0, %789 ], [ %964, %961 ]
%883 = phi i32 [ 1, %789 ], [ %962, %961 ]
%884 = mul i32 %882, %4
%885 = add i32 %786, %884
%886 = sext i32 %885 to i64
%887 = getelementptr float, float* %2, i64 %886
%888 = getelementptr float, float* %403, i64 %886
%889 = add i32 %785, %884
%890 = sext i32 %889 to i64
%891 = getelementptr float, float* %2, i64 %890
%892 = getelementptr float, float* %404, i64 %890
%893 = mul i32 %882, %4
%894 = add i32 %788, %893
%895 = add i32 %787, %893
br i1 %398, label %896, label %961
896: ; preds = %881
%897 = add nsw i32 %883, -1
%898 = mul nsw i32 %897, %4
%899 = mul nsw i32 %883, %4
br i1 %405, label %939, label %900
900: ; preds = %896
%901 = add i32 %894, %406
%902 = icmp slt i32 %901, %894
%903 = or i1 %902, %407
%904 = add i32 %895, %408
%905 = icmp slt i32 %904, %895
%906 = or i1 %905, %409
%907 = or i1 %903, %906
br i1 %907, label %939, label %908
908: ; preds = %900
%909 = icmp ult float* %887, %892
%910 = icmp ult float* %891, %888
%911 = and i1 %909, %910
br i1 %911, label %939, label %912
912: ; preds = %908, %912
%913 = phi i64 [ %936, %912 ], [ 0, %908 ]
%914 = trunc i64 %913 to i32
%915 = add i32 %790, %914
%916 = add i32 %915, %898
%917 = sext i32 %916 to i64
%918 = getelementptr inbounds float, float* %2, i64 %917
%919 = bitcast float* %918 to <4 x float>*
%920 = load <4 x float>, <4 x float>* %919
%921 = getelementptr inbounds float, float* %918, i64 4
%922 = bitcast float* %921 to <4 x float>*
%923 = load <4 x float>, <4 x float>* %922
%924 = add i32 %915, %899
%925 = sext i32 %924 to i64
%926 = getelementptr inbounds float, float* %2, i64 %925
%927 = bitcast float* %926 to <4 x float>*
%928 = load <4 x float>, <4 x float>* %927
%929 = getelementptr inbounds float, float* %926, i64 4
%930 = bitcast float* %929 to <4 x float>*
%931 = load <4 x float>, <4 x float>* %930
%932 = fadd <4 x float> %920, %928
%933 = fadd <4 x float> %923, %931
%934 = bitcast float* %926 to <4 x float>*
store <4 x float> %932, <4 x float>* %934
%935 = bitcast float* %929 to <4 x float>*
store <4 x float> %933, <4 x float>* %935
%936 = add nuw i64 %913, 8
%937 = icmp eq i64 %936, %410
br i1 %937, label %938, label %912
938: ; preds = %912
br i1 %411, label %961, label %939
939: ; preds = %908, %900, %896, %938
%940 = phi i64 [ 0, %908 ], [ 0, %900 ], [ 0, %896 ], [ %410, %938 ]
%941 = xor i64 %940, -1
br i1 %413, label %955, label %942
942: ; preds = %939
%943 = trunc i64 %940 to i32
%944 = add i32 %790, %943
%945 = add i32 %944, %898
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds float, float* %2, i64 %946
%948 = load float, float* %947
%949 = add i32 %944, %899
%950 = sext i32 %949 to i64
%951 = getelementptr inbounds float, float* %2, i64 %950
%952 = load float, float* %951
%953 = fadd float %948, %952
store float %953, float* %951
%954 = or i64 %940, 1
br label %955
955: ; preds = %942, %939
%956 = phi i64 [ %940, %939 ], [ %954, %942 ]
%957 = icmp eq i64 %941, %414
br i1 %957, label %961, label %965
958: ; preds = %961, %783
%959 = add nuw nsw i32 %784, 1
%960 = icmp eq i32 %959, %6
br i1 %960, label %791, label %783
961: ; preds = %955, %965, %938, %881
%962 = add nuw nsw i32 %883, 1
%963 = icmp eq i32 %962, %5
%964 = add i32 %882, 1
br i1 %963, label %958, label %881
965: ; preds = %955, %965
%966 = phi i64 [ %990, %965 ], [ %956, %955 ]
%967 = trunc i64 %966 to i32
%968 = add i32 %790, %967
%969 = add i32 %968, %898
%970 = sext i32 %969 to i64
%971 = getelementptr inbounds float, float* %2, i64 %970
%972 = load float, float* %971
%973 = add i32 %968, %899
%974 = sext i32 %973 to i64
%975 = getelementptr inbounds float, float* %2, i64 %974
%976 = load float, float* %975
%977 = fadd float %972, %976
store float %977, float* %975
%978 = trunc i64 %966 to i32
%979 = add i32 %978, 1
%980 = add i32 %790, %979
%981 = add i32 %980, %898
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds float, float* %2, i64 %982
%984 = load float, float* %983
%985 = add i32 %980, %899
%986 = sext i32 %985 to i64
%987 = getelementptr inbounds float, float* %2, i64 %986
%988 = load float, float* %987
%989 = fadd float %984, %988
store float %989, float* %987
%990 = add nuw nsw i64 %966, 2
%991 = icmp eq i64 %990, %399
br i1 %991, label %961, label %965
992: ; preds = %792, %1202
%993 = phi i64 [ 0, %792 ], [ %1205, %1202 ]
%994 = phi i32 [ 0, %792 ], [ %1203, %1202 ]
%995 = mul i64 %993, %180
%996 = add i64 %995, %848
%997 = mul i64 %993, %180
%998 = add i64 %997, %846
%999 = mul i64 %993, %180
%1000 = add i64 %999, %181
%1001 = add i64 %999, %838
%1002 = mul i64 %993, %180
%1003 = add i64 %1002, %181
%1004 = add i64 %1002, %832
%1005 = mul i64 %993, %180
%1006 = add i64 %1005, %816
%1007 = add i64 %1005, %821
%1008 = add i64 %1005, %823
%1009 = mul i64 %993, %180
%1010 = add i64 %1009, %811
%1011 = add i64 %1009, %815
br i1 %793, label %1012, label %1202
1012: ; preds = %992
%1013 = mul i32 %8, %994
br label %1039
1014: ; preds = %1202
%1015 = icmp sgt i32 %6, 1
br i1 %1015, label %1016, label %1422
1016: ; preds = %1014
%1017 = icmp sgt i32 %5, 0
%1018 = icmp sgt i32 %4, 0
%1019 = sext i32 %4 to i64
%1020 = zext i32 %6 to i64
%1021 = zext i32 %5 to i64
%1022 = zext i32 %4 to i64
%1023 = mul i32 %5, %4
%1024 = mul i32 %5, %4
%1025 = and i64 %122, 4294967288
%1026 = add nsw i64 %1025, -8
%1027 = lshr exact i64 %1026, 3
%1028 = add nuw nsw i64 %1027, 1
%1029 = icmp ult i32 %4, 8
%1030 = and i64 %122, 4294967288
%1031 = and i64 %1028, 1
%1032 = icmp eq i64 %1026, 0
%1033 = and i64 %1028, 4611686018427387902
%1034 = icmp eq i64 %1031, 0
%1035 = icmp eq i64 %1030, %122
%1036 = and i64 %122, 1
%1037 = icmp eq i64 %1036, 0
%1038 = sub nsw i64 0, %122
br label %1405
1039: ; preds = %1012, %1384
%1040 = phi i64 [ 0, %1012 ], [ %1385, %1384 ]
%1041 = add i64 %995, %1040
%1042 = shl i64 %1041, 32
%1043 = ashr exact i64 %1042, 32
%1044 = getelementptr float, float* %1, i64 %1043
%1045 = getelementptr float, float* %847, i64 %1043
%1046 = add i64 %996, %1040
%1047 = shl i64 %1046, 32
%1048 = ashr exact i64 %1047, 32
%1049 = getelementptr float, float* %2, i64 %1048
%1050 = getelementptr float, float* %849, i64 %1048
%1051 = add i64 %997, %1040
%1052 = trunc i64 %1051 to i32
%1053 = add i64 %998, %1040
%1054 = trunc i64 %1053 to i32
%1055 = add i64 %1000, %1040
%1056 = shl i64 %1055, 32
%1057 = ashr exact i64 %1056, 32
%1058 = getelementptr float, float* %1, i64 %1057
%1059 = getelementptr float, float* %835, i64 %1057
%1060 = add i64 %999, %1040
%1061 = shl i64 %1060, 32
%1062 = ashr exact i64 %1061, 32
%1063 = getelementptr float, float* %2, i64 %1062
%1064 = getelementptr float, float* %836, i64 %1062
%1065 = add i64 %1001, %1040
%1066 = shl i64 %1065, 32
%1067 = ashr exact i64 %1066, 32
%1068 = getelementptr float, float* %2, i64 %1067
%1069 = getelementptr float, float* %839, i64 %1067
%1070 = add i64 %1003, %1040
%1071 = trunc i64 %1070 to i32
%1072 = add i64 %1004, %1040
%1073 = trunc i64 %1072 to i32
%1074 = add i64 %1002, %1040
%1075 = trunc i64 %1074 to i32
%1076 = add i64 %1006, %1040
%1077 = shl i64 %1076, 32
%1078 = ashr exact i64 %1077, 32
%1079 = getelementptr float, float* %2, i64 %1078
%1080 = add i64 %820, %1078
%1081 = getelementptr float, float* %818, i64 %1080
%1082 = add i64 %1007, %1040
%1083 = shl i64 %1082, 32
%1084 = ashr exact i64 %1083, 32
%1085 = getelementptr float, float* %1, i64 %1084
%1086 = add i64 %820, %1084
%1087 = getelementptr float, float* %822, i64 %1086
%1088 = add i64 %1008, %1040
%1089 = shl i64 %1088, 32
%1090 = ashr exact i64 %1089, 32
%1091 = getelementptr float, float* %2, i64 %1090
%1092 = getelementptr float, float* %824, i64 %1090
%1093 = add i64 %1010, %1040
%1094 = trunc i64 %1093 to i32
%1095 = add i64 %1011, %1040
%1096 = trunc i64 %1095 to i32
br i1 %794, label %1206, label %1097
1097: ; preds = %1039
%1098 = trunc i64 %1040 to i32
%1099 = add i32 %1013, %1098
br i1 %850, label %1182, label %1100
1100: ; preds = %1097
%1101 = add i32 %1052, %852
%1102 = icmp slt i32 %1101, %1052
%1103 = or i1 %1102, %853
%1104 = add i32 %1054, %854
%1105 = icmp slt i32 %1104, %1054
%1106 = or i1 %1105, %855
%1107 = or i1 %851, %1103
%1108 = or i1 %1107, %1106
br i1 %1108, label %1182, label %1109
1109: ; preds = %1100
%1110 = icmp ult float* %1044, %1050
%1111 = icmp ult float* %1049, %1045
%1112 = and i1 %1110, %1111
br i1 %1112, label %1182, label %1113
1113: ; preds = %1109
br i1 %858, label %1159, label %1114
1114: ; preds = %1113, %1114
%1115 = phi i64 [ %1156, %1114 ], [ 0, %1113 ]
%1116 = phi i64 [ %1157, %1114 ], [ 0, %1113 ]
%1117 = trunc i64 %1115 to i32
%1118 = trunc i64 %1115 to i32
%1119 = add i32 %1117, %3
%1120 = mul i32 %1119, %4
%1121 = add i32 %1099, %1120
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds float, float* %2, i64 %1122
%1124 = bitcast float* %1123 to <4 x float>*
%1125 = load <4 x float>, <4 x float>* %1124
%1126 = getelementptr inbounds float, float* %1123, i64 4
%1127 = bitcast float* %1126 to <4 x float>*
%1128 = load <4 x float>, <4 x float>* %1127
%1129 = mul i32 %1118, %4
%1130 = add i32 %1099, %1129
%1131 = sext i32 %1130 to i64
%1132 = getelementptr inbounds float, float* %1, i64 %1131
%1133 = bitcast float* %1132 to <4 x float>*
store <4 x float> %1125, <4 x float>* %1133
%1134 = getelementptr inbounds float, float* %1132, i64 4
%1135 = bitcast float* %1134 to <4 x float>*
store <4 x float> %1128, <4 x float>* %1135
%1136 = or i64 %1115, 8
%1137 = trunc i64 %1136 to i32
%1138 = trunc i64 %1136 to i32
%1139 = add i32 %1137, %3
%1140 = mul i32 %1139, %4
%1141 = add i32 %1099, %1140
%1142 = sext i32 %1141 to i64
%1143 = getelementptr inbounds float, float* %2, i64 %1142
%1144 = bitcast float* %1143 to <4 x float>*
%1145 = load <4 x float>, <4 x float>* %1144
%1146 = getelementptr inbounds float, float* %1143, i64 4
%1147 = bitcast float* %1146 to <4 x float>*
%1148 = load <4 x float>, <4 x float>* %1147
%1149 = mul i32 %1138, %4
%1150 = add i32 %1099, %1149
%1151 = sext i32 %1150 to i64
%1152 = getelementptr inbounds float, float* %1, i64 %1151
%1153 = bitcast float* %1152 to <4 x float>*
store <4 x float> %1145, <4 x float>* %1153
%1154 = getelementptr inbounds float, float* %1152, i64 4
%1155 = bitcast float* %1154 to <4 x float>*
store <4 x float> %1148, <4 x float>* %1155
%1156 = add nuw i64 %1115, 16
%1157 = add i64 %1116, 2
%1158 = icmp eq i64 %1157, %859
br i1 %1158, label %1159, label %1114
1159: ; preds = %1114, %1113
%1160 = phi i64 [ 0, %1113 ], [ %1156, %1114 ]
br i1 %860, label %1181, label %1161
1161: ; preds = %1159
%1162 = trunc i64 %1160 to i32
%1163 = trunc i64 %1160 to i32
%1164 = add i32 %1162, %3
%1165 = mul i32 %1164, %4
%1166 = add i32 %1099, %1165
%1167 = sext i32 %1166 to i64
%1168 = getelementptr inbounds float, float* %2, i64 %1167
%1169 = bitcast float* %1168 to <4 x float>*
%1170 = load <4 x float>, <4 x float>* %1169
%1171 = getelementptr inbounds float, float* %1168, i64 4
%1172 = bitcast float* %1171 to <4 x float>*
%1173 = load <4 x float>, <4 x float>* %1172
%1174 = mul i32 %1163, %4
%1175 = add i32 %1099, %1174
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds float, float* %1, i64 %1176
%1178 = bitcast float* %1177 to <4 x float>*
store <4 x float> %1170, <4 x float>* %1178
%1179 = getelementptr inbounds float, float* %1177, i64 4
%1180 = bitcast float* %1179 to <4 x float>*
store <4 x float> %1173, <4 x float>* %1180
br label %1181
1181: ; preds = %1159, %1161
br i1 %861, label %1206, label %1182
1182: ; preds = %1109, %1100, %1097, %1181
%1183 = phi i64 [ 0, %1109 ], [ 0, %1100 ], [ 0, %1097 ], [ %856, %1181 ]
%1184 = xor i64 %1183, -1
br i1 %863, label %1199, label %1185
1185: ; preds = %1182
%1186 = trunc i64 %1183 to i32
%1187 = add i32 %1186, %3
%1188 = mul i32 %1187, %4
%1189 = add i32 %1099, %1188
%1190 = sext i32 %1189 to i64
%1191 = getelementptr inbounds float, float* %2, i64 %1190
%1192 = load float, float* %1191
%1193 = trunc i64 %1183 to i32
%1194 = mul i32 %1193, %4
%1195 = add i32 %1099, %1194
%1196 = sext i32 %1195 to i64
%1197 = getelementptr inbounds float, float* %1, i64 %1196
store float %1192, float* %1197
%1198 = or i64 %1183, 1
br label %1199
1199: ; preds = %1185, %1182
%1200 = phi i64 [ %1183, %1182 ], [ %1198, %1185 ]
%1201 = icmp eq i64 %1184, %864
br i1 %1201, label %1206, label %1269
1202: ; preds = %1384, %992
%1203 = add nuw nsw i32 %994, 1
%1204 = icmp eq i32 %1203, %6
%1205 = add i64 %993, 1
br i1 %1204, label %1014, label %992
1206: ; preds = %1199, %1269, %1181, %1039
br i1 %797, label %1207, label %1298
1207: ; preds = %1206
%1208 = trunc i64 %1040 to i32
%1209 = add i32 %1013, %1208
br i1 %865, label %1266, label %1210
1210: ; preds = %1207
%1211 = add i32 %830, %1071
%1212 = icmp slt i32 %1211, %1071
%1213 = add i32 %830, %1073
%1214 = icmp slt i32 %1213, %1073
%1215 = add i32 %830, %1075
%1216 = icmp slt i32 %1215, %1075
%1217 = or i1 %866, %1212
%1218 = or i1 %1217, %1214
%1219 = or i1 %1218, %1216
br i1 %1219, label %1266, label %1220
1220: ; preds = %1210
%1221 = icmp ult float* %1058, %1064
%1222 = icmp ult float* %1063, %1059
%1223 = and i1 %1221, %1222
%1224 = icmp ult float* %1058, %1069
%1225 = icmp ult float* %1068, %1059
%1226 = and i1 %1224, %1225
%1227 = or i1 %1223, %1226
br i1 %1227, label %1266, label %1228
1228: ; preds = %1220, %1228
%1229 = phi i64 [ %1263, %1228 ], [ 0, %1220 ]
%1230 = trunc i64 %1229 to i32
%1231 = trunc i64 %1229 to i32
%1232 = add i32 %796, %1231
%1233 = trunc i64 %1229 to i32
%1234 = add i32 %796, %1233
%1235 = add i32 %1232, %3
%1236 = mul i32 %1235, %4
%1237 = add i32 %1209, %1236
%1238 = sext i32 %1237 to i64
%1239 = getelementptr inbounds float, float* %2, i64 %1238
%1240 = bitcast float* %1239 to <4 x float>*
%1241 = load <4 x float>, <4 x float>* %1240
%1242 = getelementptr inbounds float, float* %1239, i64 4
%1243 = bitcast float* %1242 to <4 x float>*
%1244 = load <4 x float>, <4 x float>* %1243
%1245 = mul nsw i32 %1230, %4
%1246 = add i32 %1209, %1245
%1247 = sext i32 %1246 to i64
%1248 = getelementptr inbounds float, float* %2, i64 %1247
%1249 = bitcast float* %1248 to <4 x float>*
%1250 = load <4 x float>, <4 x float>* %1249
%1251 = getelementptr inbounds float, float* %1248, i64 4
%1252 = bitcast float* %1251 to <4 x float>*
%1253 = load <4 x float>, <4 x float>* %1252
%1254 = fsub <4 x float> %1241, %1250
%1255 = fsub <4 x float> %1244, %1253
%1256 = mul i32 %1234, %4
%1257 = add i32 %1209, %1256
%1258 = sext i32 %1257 to i64
%1259 = getelementptr inbounds float, float* %1, i64 %1258
%1260 = bitcast float* %1259 to <4 x float>*
store <4 x float> %1254, <4 x float>* %1260
%1261 = getelementptr inbounds float, float* %1259, i64 4
%1262 = bitcast float* %1261 to <4 x float>*
store <4 x float> %1255, <4 x float>* %1262
%1263 = add nuw i64 %1229, 8
%1264 = icmp eq i64 %1263, %867
br i1 %1264, label %1265, label %1228
1265: ; preds = %1228
br i1 %871, label %1298, label %1266
1266: ; preds = %1220, %1210, %1207, %1265
%1267 = phi i64 [ %802, %1220 ], [ %802, %1210 ], [ %802, %1207 ], [ %868, %1265 ]
%1268 = phi i32 [ %3, %1220 ], [ %3, %1210 ], [ %3, %1207 ], [ %870, %1265 ]
br label %1358
1269: ; preds = %1199, %1269
%1270 = phi i64 [ %1296, %1269 ], [ %1200, %1199 ]
%1271 = trunc i64 %1270 to i32
%1272 = add i32 %1271, %3
%1273 = mul i32 %1272, %4
%1274 = add i32 %1099, %1273
%1275 = sext i32 %1274 to i64
%1276 = getelementptr inbounds float, float* %2, i64 %1275
%1277 = load float, float* %1276
%1278 = trunc i64 %1270 to i32
%1279 = mul i32 %1278, %4
%1280 = add i32 %1099, %1279
%1281 = sext i32 %1280 to i64
%1282 = getelementptr inbounds float, float* %1, i64 %1281
store float %1277, float* %1282
%1283 = add nuw nsw i64 %1270, 1
%1284 = trunc i64 %1283 to i32
%1285 = add i32 %1284, %3
%1286 = mul i32 %1285, %4
%1287 = add i32 %1099, %1286
%1288 = sext i32 %1287 to i64
%1289 = getelementptr inbounds float, float* %2, i64 %1288
%1290 = load float, float* %1289
%1291 = trunc i64 %1283 to i32
%1292 = mul i32 %1291, %4
%1293 = add i32 %1099, %1292
%1294 = sext i32 %1293 to i64
%1295 = getelementptr inbounds float, float* %1, i64 %1294
store float %1290, float* %1295
%1296 = add nuw nsw i64 %1270, 2
%1297 = icmp eq i64 %1296, %806
br i1 %1297, label %1206, label %1269
1298: ; preds = %1358, %1265, %1206
br i1 %798, label %1299, label %1384
1299: ; preds = %1298
%1300 = trunc i64 %1040 to i32
%1301 = add i32 %1013, %1300
%1302 = add i32 %1301, %800
%1303 = sext i32 %1302 to i64
%1304 = getelementptr inbounds float, float* %2, i64 %1303
br i1 %872, label %1356, label %1305
1305: ; preds = %1299
%1306 = add i32 %1094, %874
%1307 = icmp slt i32 %1306, %1094
%1308 = or i1 %1307, %875
%1309 = add i32 %1096, %876
%1310 = icmp slt i32 %1309, %1096
%1311 = or i1 %1310, %877
%1312 = or i1 %873, %1308
%1313 = or i1 %1312, %1311
br i1 %1313, label %1356, label %1314
1314: ; preds = %1305
%1315 = icmp ult float* %1079, %1087
%1316 = icmp ult float* %1085, %1081
%1317 = and i1 %1315, %1316
%1318 = icmp ult float* %1091, %1087
%1319 = icmp ult float* %1085, %1092
%1320 = and i1 %1318, %1319
%1321 = or i1 %1317, %1320
br i1 %1321, label %1356, label %1322
1322: ; preds = %1314
%1323 = load float, float* %1304
%1324 = insertelement <4 x float> poison, float %1323, i64 0
%1325 = shufflevector <4 x float> %1324, <4 x float> poison, <4 x i32> zeroinitializer
%1326 = insertelement <4 x float> poison, float %1323, i64 0
%1327 = shufflevector <4 x float> %1326, <4 x float> poison, <4 x i32> zeroinitializer
br label %1328
1328: ; preds = %1328, %1322
%1329 = phi i64 [ 0, %1322 ], [ %1353, %1328 ]
%1330 = trunc i64 %1329 to i32
%1331 = add i32 %795, %1330
%1332 = trunc i64 %1329 to i32
%1333 = add i32 %795, %1332
%1334 = add i32 %1331, %801
%1335 = mul nsw i32 %1334, %4
%1336 = add i32 %1301, %1335
%1337 = sext i32 %1336 to i64
%1338 = getelementptr inbounds float, float* %2, i64 %1337
%1339 = bitcast float* %1338 to <4 x float>*
%1340 = load <4 x float>, <4 x float>* %1339
%1341 = getelementptr inbounds float, float* %1338, i64 4
%1342 = bitcast float* %1341 to <4 x float>*
%1343 = load <4 x float>, <4 x float>* %1342
%1344 = fsub <4 x float> %1325, %1340
%1345 = fsub <4 x float> %1327, %1343
%1346 = mul i32 %1333, %4
%1347 = add i32 %1301, %1346
%1348 = sext i32 %1347 to i64
%1349 = getelementptr inbounds float, float* %1, i64 %1348
%1350 = bitcast float* %1349 to <4 x float>*
store <4 x float> %1344, <4 x float>* %1350
%1351 = getelementptr inbounds float, float* %1349, i64 4
%1352 = bitcast float* %1351 to <4 x float>*
store <4 x float> %1345, <4 x float>* %1352
%1353 = add nuw i64 %1329, 8
%1354 = icmp eq i64 %1353, %878
br i1 %1354, label %1355, label %1328
1355: ; preds = %1328
br i1 %880, label %1384, label %1356
1356: ; preds = %1314, %1305, %1299, %1355
%1357 = phi i64 [ %803, %1314 ], [ %803, %1305 ], [ %803, %1299 ], [ %879, %1355 ]
br label %1387
1358: ; preds = %1266, %1358
%1359 = phi i64 [ %1380, %1358 ], [ %1267, %1266 ]
%1360 = phi i32 [ %1381, %1358 ], [ %1268, %1266 ]
%1361 = trunc i64 %1359 to i32
%1362 = add i32 %1361, %3
%1363 = mul i32 %1362, %4
%1364 = add i32 %1209, %1363
%1365 = sext i32 %1364 to i64
%1366 = getelementptr inbounds float, float* %2, i64 %1365
%1367 = load float, float* %1366
%1368 = sub i32 %1360, %3
%1369 = mul nsw i32 %1368, %4
%1370 = add i32 %1209, %1369
%1371 = sext i32 %1370 to i64
%1372 = getelementptr inbounds float, float* %2, i64 %1371
%1373 = load float, float* %1372
%1374 = fsub float %1367, %1373
%1375 = trunc i64 %1359 to i32
%1376 = mul i32 %1375, %4
%1377 = add i32 %1209, %1376
%1378 = sext i32 %1377 to i64
%1379 = getelementptr inbounds float, float* %1, i64 %1378
store float %1374, float* %1379
%1380 = add i64 %1359, 1
%1381 = trunc i64 %1359 to i32
%1382 = trunc i64 %1380 to i32
%1383 = icmp eq i32 %795, %1382
br i1 %1383, label %1298, label %1358
1384: ; preds = %1387, %1355, %1298
%1385 = add nuw nsw i64 %1040, 1
%1386 = icmp eq i64 %1385, %805
br i1 %1386, label %1202, label %1039
1387: ; preds = %1356, %1387
%1388 = phi i64 [ %1403, %1387 ], [ %1357, %1356 ]
%1389 = load float, float* %1304
%1390 = trunc i64 %1388 to i32
%1391 = add i32 %1390, %801
%1392 = mul nsw i32 %1391, %4
%1393 = add i32 %1301, %1392
%1394 = sext i32 %1393 to i64
%1395 = getelementptr inbounds float, float* %2, i64 %1394
%1396 = load float, float* %1395
%1397 = fsub float %1389, %1396
%1398 = trunc i64 %1388 to i32
%1399 = mul i32 %1398, %4
%1400 = add i32 %1301, %1399
%1401 = sext i32 %1400 to i64
%1402 = getelementptr inbounds float, float* %1, i64 %1401
store float %1397, float* %1402
%1403 = add nsw i64 %1388, 1
%1404 = icmp slt i64 %1403, %804
br i1 %1404, label %1387, label %1384
1405: ; preds = %1016, %1547
%1406 = phi i32 [ 0, %1016 ], [ %1550, %1547 ]
%1407 = phi i64 [ 1, %1016 ], [ %1548, %1547 ]
%1408 = mul i32 %1024, %1406
%1409 = add i32 %1023, %1408
%1410 = sext i32 %1409 to i64
%1411 = add nsw i64 %122, %1410
%1412 = sext i32 %1408 to i64
%1413 = add nsw i64 %122, %1412
br i1 %1017, label %1414, label %1547
1414: ; preds = %1405
%1415 = trunc i64 %1407 to i32
%1416 = add i32 %1415, -1
%1417 = mul i32 %8, %1416
%1418 = trunc i64 %1407 to i32
%1419 = mul i32 %8, %1418
%1420 = sext i32 %1417 to i64
%1421 = sext i32 %1419 to i64
br label %1445
1422: ; preds = %1547, %117, %168, %395, %791, %1014
%1423 = icmp sgt i32 %5, 0
br i1 %1423, label %1424, label %1579
1424: ; preds = %1422
%1425 = icmp sgt i32 %4, 0
%1426 = icmp slt i32 %3, 0
%1427 = sub i32 %6, %3
%1428 = add i32 %3, 1
%1429 = icmp slt i32 %1428, %1427
%1430 = icmp sgt i32 %3, 0
%1431 = add nsw i32 %6, -1
%1432 = mul i32 %8, %1431
%1433 = xor i32 %3, -1
%1434 = zext i32 %1428 to i64
%1435 = sext i32 %1427 to i64
%1436 = sext i32 %6 to i64
%1437 = sext i32 %1432 to i64
%1438 = sext i32 %4 to i64
%1439 = zext i32 %5 to i64
%1440 = zext i32 %4 to i64
%1441 = and i64 %1434, 1
%1442 = icmp eq i32 %3, 0
%1443 = and i64 %1434, 4294967294
%1444 = icmp eq i64 %1441, 0
br label %1575
1445: ; preds = %1414, %1551
%1446 = phi i64 [ 0, %1414 ], [ %1552, %1551 ]
%1447 = mul i64 %1446, %179
%1448 = add i64 %1447, %1410
%1449 = getelementptr float, float* %1, i64 %1448
%1450 = add i64 %1411, %1447
%1451 = getelementptr float, float* %1, i64 %1450
%1452 = add i64 %1447, %1412
%1453 = getelementptr float, float* %1, i64 %1452
%1454 = add i64 %1413, %1447
%1455 = getelementptr float, float* %1, i64 %1454
br i1 %1018, label %1456, label %1551
1456: ; preds = %1445
%1457 = mul nsw i64 %1446, %1019
br i1 %1029, label %1531, label %1458
1458: ; preds = %1456
%1459 = icmp ult float* %1449, %1455
%1460 = icmp ult float* %1453, %1451
%1461 = and i1 %1459, %1460
br i1 %1461, label %1531, label %1462
1462: ; preds = %1458
br i1 %1032, label %1508, label %1463
1463: ; preds = %1462, %1463
%1464 = phi i64 [ %1505, %1463 ], [ 0, %1462 ]
%1465 = phi i64 [ %1506, %1463 ], [ 0, %1462 ]
%1466 = add nsw i64 %1464, %1457
%1467 = add nsw i64 %1466, %1420
%1468 = getelementptr inbounds float, float* %1, i64 %1467
%1469 = bitcast float* %1468 to <4 x float>*
%1470 = load <4 x float>, <4 x float>* %1469
%1471 = getelementptr inbounds float, float* %1468, i64 4
%1472 = bitcast float* %1471 to <4 x float>*
%1473 = load <4 x float>, <4 x float>* %1472
%1474 = add nsw i64 %1466, %1421
%1475 = getelementptr inbounds float, float* %1, i64 %1474
%1476 = bitcast float* %1475 to <4 x float>*
%1477 = load <4 x float>, <4 x float>* %1476
%1478 = getelementptr inbounds float, float* %1475, i64 4
%1479 = bitcast float* %1478 to <4 x float>*
%1480 = load <4 x float>, <4 x float>* %1479
%1481 = fadd <4 x float> %1470, %1477
%1482 = fadd <4 x float> %1473, %1480
%1483 = bitcast float* %1475 to <4 x float>*
store <4 x float> %1481, <4 x float>* %1483
%1484 = bitcast float* %1478 to <4 x float>*
store <4 x float> %1482, <4 x float>* %1484
%1485 = or i64 %1464, 8
%1486 = add nsw i64 %1485, %1457
%1487 = add nsw i64 %1486, %1420
%1488 = getelementptr inbounds float, float* %1, i64 %1487
%1489 = bitcast float* %1488 to <4 x float>*
%1490 = load <4 x float>, <4 x float>* %1489
%1491 = getelementptr inbounds float, float* %1488, i64 4
%1492 = bitcast float* %1491 to <4 x float>*
%1493 = load <4 x float>, <4 x float>* %1492
%1494 = add nsw i64 %1486, %1421
%1495 = getelementptr inbounds float, float* %1, i64 %1494
%1496 = bitcast float* %1495 to <4 x float>*
%1497 = load <4 x float>, <4 x float>* %1496
%1498 = getelementptr inbounds float, float* %1495, i64 4
%1499 = bitcast float* %1498 to <4 x float>*
%1500 = load <4 x float>, <4 x float>* %1499
%1501 = fadd <4 x float> %1490, %1497
%1502 = fadd <4 x float> %1493, %1500
%1503 = bitcast float* %1495 to <4 x float>*
store <4 x float> %1501, <4 x float>* %1503
%1504 = bitcast float* %1498 to <4 x float>*
store <4 x float> %1502, <4 x float>* %1504
%1505 = add nuw i64 %1464, 16
%1506 = add i64 %1465, 2
%1507 = icmp eq i64 %1506, %1033
br i1 %1507, label %1508, label %1463
1508: ; preds = %1463, %1462
%1509 = phi i64 [ 0, %1462 ], [ %1505, %1463 ]
br i1 %1034, label %1530, label %1510
1510: ; preds = %1508
%1511 = add nsw i64 %1509, %1457
%1512 = add nsw i64 %1511, %1420
%1513 = getelementptr inbounds float, float* %1, i64 %1512
%1514 = bitcast float* %1513 to <4 x float>*
%1515 = load <4 x float>, <4 x float>* %1514
%1516 = getelementptr inbounds float, float* %1513, i64 4
%1517 = bitcast float* %1516 to <4 x float>*
%1518 = load <4 x float>, <4 x float>* %1517
%1519 = add nsw i64 %1511, %1421
%1520 = getelementptr inbounds float, float* %1, i64 %1519
%1521 = bitcast float* %1520 to <4 x float>*
%1522 = load <4 x float>, <4 x float>* %1521
%1523 = getelementptr inbounds float, float* %1520, i64 4
%1524 = bitcast float* %1523 to <4 x float>*
%1525 = load <4 x float>, <4 x float>* %1524
%1526 = fadd <4 x float> %1515, %1522
%1527 = fadd <4 x float> %1518, %1525
%1528 = bitcast float* %1520 to <4 x float>*
store <4 x float> %1526, <4 x float>* %1528
%1529 = bitcast float* %1523 to <4 x float>*
store <4 x float> %1527, <4 x float>* %1529
br label %1530
1530: ; preds = %1508, %1510
br i1 %1035, label %1551, label %1531
1531: ; preds = %1458, %1456, %1530
%1532 = phi i64 [ 0, %1458 ], [ 0, %1456 ], [ %1030, %1530 ]
%1533 = xor i64 %1532, -1
br i1 %1037, label %1544, label %1534
1534: ; preds = %1531
%1535 = add nsw i64 %1532, %1457
%1536 = add nsw i64 %1535, %1420
%1537 = getelementptr inbounds float, float* %1, i64 %1536
%1538 = load float, float* %1537
%1539 = add nsw i64 %1535, %1421
%1540 = getelementptr inbounds float, float* %1, i64 %1539
%1541 = load float, float* %1540
%1542 = fadd float %1538, %1541
store float %1542, float* %1540
%1543 = or i64 %1532, 1
br label %1544
1544: ; preds = %1534, %1531
%1545 = phi i64 [ %1532, %1531 ], [ %1543, %1534 ]
%1546 = icmp eq i64 %1533, %1038
br i1 %1546, label %1551, label %1554
1547: ; preds = %1551, %1405
%1548 = add nuw nsw i64 %1407, 1
%1549 = icmp eq i64 %1548, %1020
%1550 = add i32 %1406, 1
br i1 %1549, label %1422, label %1405
1551: ; preds = %1544, %1554, %1530, %1445
%1552 = add nuw nsw i64 %1446, 1
%1553 = icmp eq i64 %1552, %1021
br i1 %1553, label %1547, label %1445
1554: ; preds = %1544, %1554
%1555 = phi i64 [ %1573, %1554 ], [ %1545, %1544 ]
%1556 = add nsw i64 %1555, %1457
%1557 = add nsw i64 %1556, %1420
%1558 = getelementptr inbounds float, float* %1, i64 %1557
%1559 = load float, float* %1558
%1560 = add nsw i64 %1556, %1421
%1561 = getelementptr inbounds float, float* %1, i64 %1560
%1562 = load float, float* %1561
%1563 = fadd float %1559, %1562
store float %1563, float* %1561
%1564 = add nuw nsw i64 %1555, 1
%1565 = add nsw i64 %1564, %1457
%1566 = add nsw i64 %1565, %1420
%1567 = getelementptr inbounds float, float* %1, i64 %1566
%1568 = load float, float* %1567
%1569 = add nsw i64 %1565, %1421
%1570 = getelementptr inbounds float, float* %1, i64 %1569
%1571 = load float, float* %1570
%1572 = fadd float %1568, %1571
store float %1572, float* %1570
%1573 = add nuw nsw i64 %1555, 2
%1574 = icmp eq i64 %1573, %1022
br i1 %1574, label %1551, label %1554
1575: ; preds = %1424, %1584
%1576 = phi i64 [ 0, %1424 ], [ %1585, %1584 ]
br i1 %1425, label %1577, label %1584
1577: ; preds = %1575
%1578 = mul nsw i64 %1576, %1438
br label %1580
1579: ; preds = %1584, %1422
ret void
1580: ; preds = %1577, %1666
%1581 = phi i64 [ 0, %1577 ], [ %1667, %1666 ]
br i1 %1426, label %1602, label %1582
1582: ; preds = %1580
%1583 = add nsw i64 %1581, %1578
br i1 %1442, label %1587, label %1605
1584: ; preds = %1666, %1575
%1585 = add nuw nsw i64 %1576, 1
%1586 = icmp eq i64 %1585, %1439
br i1 %1586, label %1579, label %1575
1587: ; preds = %1605, %1582
%1588 = phi i64 [ 0, %1582 ], [ %1633, %1605 ]
br i1 %1444, label %1602, label %1589
1589: ; preds = %1587
%1590 = trunc i64 %1588 to i32
%1591 = add i32 %1590, %3
%1592 = mul i32 %8, %1591
%1593 = sext i32 %1592 to i64
%1594 = add nsw i64 %1583, %1593
%1595 = getelementptr inbounds float, float* %1, i64 %1594
%1596 = load float, float* %1595
%1597 = trunc i64 %1588 to i32
%1598 = mul i32 %8, %1597
%1599 = sext i32 %1598 to i64
%1600 = add nsw i64 %1583, %1599
%1601 = getelementptr inbounds float, float* %0, i64 %1600
store float %1596, float* %1601
br label %1602
1602: ; preds = %1589, %1587, %1580
br i1 %1429, label %1603, label %1636
1603: ; preds = %1602
%1604 = add nsw i64 %1581, %1578
br label %1641
1605: ; preds = %1582, %1605
%1606 = phi i64 [ %1633, %1605 ], [ 0, %1582 ]
%1607 = phi i64 [ %1634, %1605 ], [ 0, %1582 ]
%1608 = trunc i64 %1606 to i32
%1609 = add i32 %1608, %3
%1610 = mul i32 %8, %1609
%1611 = sext i32 %1610 to i64
%1612 = add nsw i64 %1583, %1611
%1613 = getelementptr inbounds float, float* %1, i64 %1612
%1614 = load float, float* %1613
%1615 = trunc i64 %1606 to i32
%1616 = mul i32 %8, %1615
%1617 = sext i32 %1616 to i64
%1618 = add nsw i64 %1583, %1617
%1619 = getelementptr inbounds float, float* %0, i64 %1618
store float %1614, float* %1619
%1620 = or i64 %1606, 1
%1621 = trunc i64 %1620 to i32
%1622 = add i32 %1621, %3
%1623 = mul i32 %8, %1622
%1624 = sext i32 %1623 to i64
%1625 = add nsw i64 %1583, %1624
%1626 = getelementptr inbounds float, float* %1, i64 %1625
%1627 = load float, float* %1626
%1628 = trunc i64 %1620 to i32
%1629 = mul i32 %8, %1628
%1630 = sext i32 %1629 to i64
%1631 = add nsw i64 %1583, %1630
%1632 = getelementptr inbounds float, float* %0, i64 %1631
store float %1627, float* %1632
%1633 = add nuw nsw i64 %1606, 2
%1634 = add i64 %1607, 2
%1635 = icmp eq i64 %1634, %1443
br i1 %1635, label %1587, label %1605
1636: ; preds = %1641, %1602
br i1 %1430, label %1637, label %1666
1637: ; preds = %1636
%1638 = add nsw i64 %1581, %1578
%1639 = add nsw i64 %1638, %1437
%1640 = getelementptr inbounds float, float* %1, i64 %1639
br label %1669
1641: ; preds = %1603, %1641
%1642 = phi i64 [ %1434, %1603 ], [ %1663, %1641 ]
%1643 = phi i32 [ %3, %1603 ], [ %1658, %1641 ]
%1644 = trunc i64 %1642 to i32
%1645 = add i32 %1644, %3
%1646 = mul i32 %8, %1645
%1647 = sext i32 %1646 to i64
%1648 = add nsw i64 %1604, %1647
%1649 = getelementptr inbounds float, float* %1, i64 %1648
%1650 = load float, float* %1649
%1651 = sub i32 %1643, %3
%1652 = mul i32 %8, %1651
%1653 = sext i32 %1652 to i64
%1654 = add nsw i64 %1604, %1653
%1655 = getelementptr inbounds float, float* %1, i64 %1654
%1656 = load float, float* %1655
%1657 = fsub float %1650, %1656
%1658 = trunc i64 %1642 to i32
%1659 = mul i32 %8, %1658
%1660 = sext i32 %1659 to i64
%1661 = add nsw i64 %1604, %1660
%1662 = getelementptr inbounds float, float* %0, i64 %1661
store float %1657, float* %1662
%1663 = add i64 %1642, 1
%1664 = trunc i64 %1663 to i32
%1665 = icmp eq i32 %1427, %1664
br i1 %1665, label %1636, label %1641
1666: ; preds = %1669, %1636
%1667 = add nuw nsw i64 %1581, 1
%1668 = icmp eq i64 %1667, %1440
br i1 %1668, label %1584, label %1580
1669: ; preds = %1637, %1669
%1670 = phi i64 [ %1435, %1637 ], [ %1684, %1669 ]
%1671 = load float, float* %1640
%1672 = trunc i64 %1670 to i32
%1673 = add i32 %1672, %1433
%1674 = mul i32 %8, %1673
%1675 = sext i32 %1674 to i64
%1676 = add nsw i64 %1638, %1675
%1677 = getelementptr inbounds float, float* %1, i64 %1676
%1678 = load float, float* %1677
%1679 = fsub float %1671, %1678
%1680 = mul i32 %8, %1672
%1681 = sext i32 %1680 to i64
%1682 = add nsw i64 %1638, %1681
%1683 = getelementptr inbounds float, float* %0, i64 %1682
store float %1679, float* %1683
%1684 = add nsw i64 %1670, 1
%1685 = icmp slt i64 %1684, %1436
br i1 %1685, label %1669, label %1666
}