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];
      }
    }
  }
  if (o > 1) {
    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>
cmpl   $0x1,0x10(%rbp)
jle    19de <boxfilter+0x8de>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    19d9 <boxfilter+0x8d9>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    19c6 <boxfilter+0x8c6>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1851 <boxfilter+0x751>
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    17d6 <boxfilter+0x6d6>
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    1906 <boxfilter+0x806>
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    185d <boxfilter+0x75d>
mov    0x10(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    19b3 <boxfilter+0x8b3>
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    1912 <boxfilter+0x812>
jmp    19b8 <boxfilter+0x8b8>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    17c0 <boxfilter+0x6c0>
jmp    19cb <boxfilter+0x8cb>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    17ad <boxfilter+0x6ad>
jmp    19de <boxfilter+0x8de>
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    %rdi,%r12
mov    0x1d8(%rsp),%edi
mov    %r9,%rax
mov    %r9,-0x38(%rsp)
imul   %r8d,%eax
mov    %rax,-0x50(%rsp)
imul   %edi,%eax
test   %eax,%eax
jle    12b4 <boxfilter+0x1b4>
mov    %eax,%r10d
cmp    $0x8,%eax
jb     1159 <boxfilter+0x59>
lea    (%r12,%r10,4),%rax
cmp    %rsi,%rax
jbe    11d0 <boxfilter+0xd0>
lea    (%rsi,%r10,4),%rax
cmp    %r12,%rax
jbe    11d0 <boxfilter+0xd0>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %r10,%rax
mov    %r10,%rdi
and    $0x3,%rdi
je     1185 <boxfilter+0x85>
nopl   (%rax)
movss  (%r12,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rbp,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdi
jne    1170 <boxfilter+0x70>
cmp    $0x3,%rax
jb     12b4 <boxfilter+0x1b4>
nop
movss  (%r12,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rbp,4)
movss  0x4(%r12,%rbp,4),%xmm0
movss  %xmm0,0x4(%rsi,%rbp,4)
movss  0x8(%r12,%rbp,4),%xmm0
movss  %xmm0,0x8(%rsi,%rbp,4)
movss  0xc(%r12,%rbp,4),%xmm0
movss  %xmm0,0xc(%rsi,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%r10
jne    1190 <boxfilter+0x90>
jmp    12b4 <boxfilter+0x1b4>
mov    %r10d,%ebp
and    $0xfffffff8,%ebp
lea    -0x8(%rbp),%rdi
mov    %rdi,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r9d
and    $0x3,%r9d
cmp    $0x18,%rdi
jae    11f6 <boxfilter+0xf6>
xor    %ebx,%ebx
jmp    1270 <boxfilter+0x170>
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rax
xor    %ebx,%ebx
nopl   0x0(%rax)
movups (%r12,%rbx,4),%xmm0
movups 0x10(%r12,%rbx,4),%xmm1
movups %xmm0,(%rsi,%rbx,4)
movups %xmm1,0x10(%rsi,%rbx,4)
movups 0x20(%r12,%rbx,4),%xmm0
movups 0x30(%r12,%rbx,4),%xmm1
movups %xmm0,0x20(%rsi,%rbx,4)
movups %xmm1,0x30(%rsi,%rbx,4)
movups 0x40(%r12,%rbx,4),%xmm0
movups 0x50(%r12,%rbx,4),%xmm1
movups %xmm0,0x40(%rsi,%rbx,4)
movups %xmm1,0x50(%rsi,%rbx,4)
movups 0x60(%r12,%rbx,4),%xmm0
movups 0x70(%r12,%rbx,4),%xmm1
movups %xmm0,0x60(%rsi,%rbx,4)
movups %xmm1,0x70(%rsi,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rax
jne    1210 <boxfilter+0x110>
test   %r9,%r9
je     12ab <boxfilter+0x1ab>
lea    (%rsi,%rbx,4),%rdi
add    $0x10,%rdi
lea    (%r12,%rbx,4),%rax
add    $0x10,%rax
shl    $0x5,%r9
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rax,%rbx,1),%xmm0
movups (%rax,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1290 <boxfilter+0x190>
cmp    %r10,%rbp
jne    115b <boxfilter+0x5b>
mov    %rcx,-0x68(%rsp)
xor    %eax,%eax
mov    %rax,-0x60(%rsp)
mov    %r8d,%eax
mov    0x1d8(%rsp),%ecx
test   %ecx,%ecx
mov    %r8,-0x28(%rsp)
mov    %rax,-0x10(%rsp)
jle    21e4 <boxfilter+0x10e4>
mov    %r12,0x68(%rsp)
lea    -0x2(%rax),%rcx
mov    %rcx,-0x78(%rsp)
lea    -0x1(%rax),%rcx
lea    (%rsi,%rax,4),%rdi
add    $0xfffffffffffffffc,%rdi
mov    %rdi,-0x70(%rsp)
mov    %rcx,0x8(%rsp)
and    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x40(%rsp)
add    $0x1,%rcx
mov    %rcx,-0x30(%rsp)
neg    %rax
mov    %rax,0x20(%rsp)
movl   $0x1,-0x48(%rsp)
movl   $0xffffffff,0x10(%rsp)
ff
movl   $0x0,-0x58(%rsp)
jmp    1373 <boxfilter+0x273>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x58(%rsp),%edi
add    $0x1,%edi
mov    -0x50(%rsp),%rax
mov    -0x60(%rsp),%rcx
add    %eax,%ecx
mov    %rcx,-0x60(%rsp)
add    %eax,-0x48(%rsp)
add    %eax,0x10(%rsp)
mov    0x1d8(%rsp),%eax
mov    %edi,-0x58(%rsp)
cmp    %eax,%edi
je     153d <boxfilter+0x43d>
cmpl   $0x0,-0x38(%rsp)
jle    1340 <boxfilter+0x240>
mov    -0x50(%rsp),%r13
imul   -0x58(%rsp),%r13d
lea    0x1(%r13),%eax
mov    %rax,-0x80(%rsp)
xor    %r14d,%r14d
mov    0x10(%rsp),%eax
mov    %eax,%r9d
mov    -0x48(%rsp),%eax
mov    %eax,%r10d
mov    -0x60(%rsp),%r11
jmp    13c8 <boxfilter+0x2c8>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14d
add    %r8d,%r11d
add    %r8d,%r10d
add    %r8d,%r9d
cmp    -0x38(%rsp),%r14d
je     1340 <boxfilter+0x240>
cmp    $0x2,%r8d
jl     13b0 <boxfilter+0x2b0>
mov    %r14d,%eax
imul   %r8d,%eax
lea    (%rax,%r13,1),%r12d
mov    $0x1,%r15d
cmpq   $0x8,0x8(%rsp)
jae    1480 <boxfilter+0x380>
mov    %r15,%rdi
testb  $0x1,-0x10(%rsp)
jne    1419 <boxfilter+0x319>
add    %r13d,%eax
add    $0xffffffff,%eax
add    %r15d,%eax
cltq
movss  (%rsi,%rax,4),%xmm0
add    %r15d,%r12d
movslq %r12d,%rax
addss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
lea    0x1(%r15),%rdi
not    %r15
cmp    0x20(%rsp),%r15
je     13b0 <boxfilter+0x2b0>
lea    (%r11,%rdi,1),%eax
lea    (%r10,%rdi,1),%ecx
mov    -0x10(%rsp),%rbp
sub    %rdi,%rbp
lea    (%r9,%rdi,1),%ebx
nopw   0x0(%rax,%rax,1)
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm0
cltq
addss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
movslq %ecx,%rcx
addss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x2,%eax
add    $0x2,%ecx
add    $0x2,%ebx
add    $0xfffffffffffffffe,%rbp
jne    1440 <boxfilter+0x340>
jmp    13b0 <boxfilter+0x2b0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x80(%rsp),%rcx
add    %eax,%ecx
mov    -0x78(%rsp),%rbx
lea    (%rcx,%rbx,1),%edi
cmp    %ecx,%edi
jl     13eb <boxfilter+0x2eb>
mov    %rbx,%rdi
shr    $0x20,%rdi
jne    13eb <boxfilter+0x2eb>
add    %r12d,%ebx
cmp    %r12d,%ebx
jl     13eb <boxfilter+0x2eb>
test   %rdi,%rdi
jne    13eb <boxfilter+0x2eb>
movslq %ecx,%rcx
lea    (%rsi,%rcx,4),%rbx
movslq %r12d,%rdi
mov    -0x70(%rsp),%rbp
lea    0x0(%rbp,%rdi,4),%rbp
cmp    %rbp,%rbx
jae    14e8 <boxfilter+0x3e8>
mov    -0x70(%rsp),%rbx
lea    (%rbx,%rcx,4),%rcx
lea    (%rsi,%rdi,4),%rdi
cmp    %rcx,%rdi
jb     13eb <boxfilter+0x2eb>
mov    -0x40(%rsp),%rcx
mov    %r11d,%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    14f0 <boxfilter+0x3f0>
mov    -0x30(%rsp),%r15
mov    -0x40(%rsp),%rcx
cmp    %rcx,0x8(%rsp)
je     13b0 <boxfilter+0x2b0>
jmp    13eb <boxfilter+0x2eb>
mov    0x1d8(%rsp),%eax
test   %eax,%eax
mov    -0x50(%rsp),%r10
jle    2b4e <boxfilter+0x1a4e>
mov    %r8d,%r9d
mov    -0x68(%rsp),%r14
sub    %r14d,%r9d
lea    0x1(%r14),%r12d
movslq %r9d,%r11
movslq %r8d,%rax
mov    %rax,0x60(%rsp)
lea    0x1(%r11),%rdi
cmp    %rax,%rdi
cmovle %rax,%rdi
mov    %r11,%rax
not    %rax
add    %rdi,%rax
mov    %rax,0x30(%rsp)
mov    $0x1,%eax
sub    %r14d,%eax
mov    %rax,0xe0(%rsp)
lea    (%r14,%r14,1),%r10d
mov    %r10d,%eax
neg    %eax
mov    %rax,0x198(%rsp)
lea    0x0(,%r11,4),%rax
mov    %rsi,%rbp
sub    %rax,%rbp
mov    %rbp,0xa8(%rsp)
mov    %rdx,%rbp
sub    %rax,%rbp
mov    %rbp,0x140(%rsp)
mov    %rdi,0x148(%rsp)
mov    %rdi,%r15
sub    %r11,%r15
mov    %r8d,%ebx
sub    %r10d,%ebx
add    $0xfffffffe,%ebx
mov    %r12d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x118(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x170(%rsp)
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %r14d,%ecx
not    %ecx
mov    %rdi,%rax
mov    %rdi,0x120(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xe8(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0xd8(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x108(%rsp)
mov    %rax,%rbp
and    $0xfffffffffffffff8,%rbp
mov    %r15,0x50(%rsp)
and    $0xfffffffffffffff8,%r15
lea    -0x1(%r12),%rax
mov    %rax,-0x20(%rsp)
sub    %r8d,%eax
mov    %rax,0xd0(%rsp)
mov    %r14d,%eax
neg    %eax
mov    %eax,-0x4(%rsp)
mov    %r10d,0x15c(%rsp)
not    %r10d
add    %r8d,%r10d
mov    %r10d,-0x8(%rsp)
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
mov    %rax,0x160(%rsp)
mov    -0x38(%rsp),%eax
mov    %rax,0x10(%rsp)
lea    0x4(%rsi),%rax
mov    %rax,0x178(%rsp)
lea    0x1(%r14,%r14,1),%r10d
lea    0x4(%rdx,%rbx,4),%rax
mov    %rax,0x130(%rsp)
mov    %rbx,-0x30(%rsp)
lea    0x4(%rsi,%rbx,4),%rax
mov    %rax,0x128(%rsp)
mov    %r14d,%edi
lea    (%rdx,%r12,4),%rax
mov    %rax,0x180(%rsp)
lea    (%rsi,%r12,4),%rax
mov    %rax,0x188(%rsp)
mov    %rcx,0x40(%rsp)
lea    (%rcx,%r8,1),%eax
mov    %eax,0xc8(%rsp)
lea    0x0(%rbp,%r12,1),%rax
mov    %rax,0xf8(%rsp)
mov    %rbp,0x100(%rsp)
lea    0x0(%rbp,%r14,1),%eax
mov    %eax,0xf0(%rsp)
mov    %r11,-0x70(%rsp)
mov    %r15,0xa0(%rsp)
lea    (%r15,%r11,1),%rax
mov    %rax,0x110(%rsp)
movl   $0x8,0x98(%rsp)
xor    %eax,%eax
mov    %rax,0x90(%rsp)
mov    %r9d,0x58(%rsp)
mov    %r9d,0x88(%rsp)
mov    %r12,0x80(%rsp)
mov    %r10,%rax
mov    %r10,0x190(%rsp)
mov    %r10,0x78(%rsp)
mov    %rdi,%rax
mov    %rdi,0x168(%rsp)
mov    %rdi,0x70(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %r12,-0x80(%rsp)
jmp    17eb <boxfilter+0x6eb>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
mov    -0x50(%rsp),%r10
add    %r10d,0x98(%rsp)
add    %r10,0x70(%rsp)
add    %r10,0x90(%rsp)
add    %r10,0x78(%rsp)
add    %r10,0x80(%rsp)
add    %r10d,-0x4(%rsp)
add    %r10d,-0x8(%rsp)
add    %r10d,0x88(%rsp)
add    %r10,0x40(%rsp)
mov    0x1d8(%rsp),%eax
mov    %rcx,0x18(%rsp)
cmp    %eax,%ecx
je     1f9f <boxfilter+0xe9f>
cmpl   $0x0,-0x38(%rsp)
mov    -0x10(%rsp),%rcx
jle    1790 <boxfilter+0x690>
mov    0x18(%rsp),%rax
mov    %rax,%rbp
mov    -0x50(%rsp),%r9
imul   %r9,%rbp
mov    0x168(%rsp),%rdi
add    %rbp,%rdi
mov    %rdi,0xc0(%rsp)
lea    0x0(%rbp,%r12,1),%rdi
mov    %rdi,0xb8(%rsp)
mov    0x190(%rsp),%rdi
mov    %rbp,0x38(%rsp)
add    %rbp,%rdi
mov    %rdi,0xb0(%rsp)
mov    %rax,%rbx
imul   0x10(%rsp),%rbx
mov    0x198(%rsp),%rdi
add    %rbx,%rdi
mov    %rdi,0x28(%rsp)
mov    0xe0(%rsp),%rdi
mov    %rbx,0x150(%rsp)
add    %rbx,%rdi
mov    %rdi,0x48(%rsp)
mov    %r9d,%edi
imul   %eax,%edi
mov    %edi,-0x48(%rsp)
mov    0x40(%rsp),%r11
mov    0x88(%rsp),%eax
mov    %eax,-0x60(%rsp)
mov    -0x8(%rsp),%eax
mov    %eax,-0x18(%rsp)
mov    -0x4(%rsp),%eax
mov    %eax,%r13d
mov    0x80(%rsp),%rax
mov    0x78(%rsp),%rdi
mov    0x90(%rsp),%r14
mov    0x70(%rsp),%r10
mov    0x98(%rsp),%ebp
mov    %ebp,(%rsp)
xor    %ebp,%ebp
jmp    190e <boxfilter+0x80e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
mov    -0x10(%rsp),%rcx
add    %rcx,%r10
add    %r8d,(%rsp)
add    %rcx,%r14
mov    -0x40(%rsp),%rdi
add    %rcx,%rdi
mov    -0x58(%rsp),%rax
add    %rcx,%rax
add    %r8d,%r13d
add    %r8d,-0x18(%rsp)
add    %r8d,-0x60(%rsp)
add    %rcx,%r11
cmp    0x10(%rsp),%rbp
je     1790 <boxfilter+0x690>
mov    %rdi,-0x40(%rsp)
mov    %rax,-0x58(%rsp)
mov    %ebp,%r15d
imul   %ecx,%r15d
cmpl   $0x0,-0x68(%rsp)
mov    %rbp,-0x78(%rsp)
js     19c7 <boxfilter+0x8c7>
mov    %ebp,%r9d
imul   %r8d,%r9d
add    -0x48(%rsp),%r9d
mov    -0x68(%rsp),%rax
lea    (%r9,%rax,1),%ebp
cmp    $0x8,%r12d
jae    1bb0 <boxfilter+0xab0>
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r12b
je     1975 <boxfilter+0x875>
add    %ecx,%ebp
movslq %ebp,%rax
movss  (%rsi,%rax,4),%xmm0
add    %ecx,%r9d
movslq %r9d,%rax
movss  %xmm0,(%rdx,%rax,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xd8(%rsp),%rcx
je     19c7 <boxfilter+0x8c7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%rax,1),%rcx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
lea    (%r14,%rax,1),%rdi
movslq %edi,%rdi
movss  %xmm0,(%rdx,%rdi,4)
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
add    $0x1,%edi
movslq %edi,%rcx
movss  %xmm0,(%rdx,%rcx,4)
add    $0x2,%rax
cmp    %rax,%r12
jne    1990 <boxfilter+0x890>
cmp    0x58(%rsp),%r12d
jge    1d6d <boxfilter+0xc6d>
mov    -0x80(%rsp),%r12
mov    -0x68(%rsp),%rax
mov    %eax,%r9d
cmpl   $0x7,-0x30(%rsp)
jb     1b70 <boxfilter+0xa70>
mov    0xb8(%rsp),%rax
add    %r15d,%eax
mov    -0x30(%rsp),%rcx
add    %eax,%ecx
mov    -0x80(%rsp),%r12
mov    -0x68(%rsp),%rdi
mov    %edi,%r9d
cmp    %eax,%ecx
jl     1b70 <boxfilter+0xa70>
mov    0xb0(%rsp),%rax
add    %r15d,%eax
mov    -0x30(%rsp),%rcx
add    %eax,%ecx
mov    -0x80(%rsp),%r12
mov    -0x68(%rsp),%rdi
mov    %edi,%r9d
cmp    %eax,%ecx
jl     1b70 <boxfilter+0xa70>
mov    0x38(%rsp),%rax
add    %r15d,%eax
mov    -0x30(%rsp),%rcx
add    %eax,%ecx
mov    -0x80(%rsp),%r12
mov    -0x68(%rsp),%rdi
mov    %edi,%r9d
cmp    %eax,%ecx
jl     1b70 <boxfilter+0xa70>
mov    0xb8(%rsp),%rax
add    %r15d,%eax
mov    0x38(%rsp),%rcx
add    %r15d,%ecx
add    0xb0(%rsp),%r15d
cltq
lea    (%rdx,%rax,4),%rdi
mov    0x130(%rsp),%rbp
lea    0x0(%rbp,%rax,4),%rbp
movslq %ecx,%rax
lea    (%rsi,%rax,4),%r12
mov    0x128(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
movslq %r15d,%rbx
lea    (%rsi,%rbx,4),%r9
lea    (%rcx,%rbx,4),%rbx
cmp    %rax,%rdi
setb   %r8b
cmp    %rbp,%r12
setb   %cl
cmp    %rbx,%rdi
setb   %al
cmp    %rbp,%r9
setb   %bl
mov    -0x80(%rsp),%r12
mov    -0x68(%rsp),%rdi
mov    %edi,%r9d
test   %cl,%r8b
mov    -0x28(%rsp),%r8
jne    1b70 <boxfilter+0xa70>
mov    -0x80(%rsp),%r12
mov    -0x68(%rsp),%rcx
mov    %ecx,%r9d
and    %bl,%al
jne    1b70 <boxfilter+0xa70>
xor    %eax,%eax
mov    0x100(%rsp),%rdi
mov    -0x58(%rsp),%rbp
mov    -0x40(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rbx,%rax,1),%ecx
movslq %ecx,%rcx
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
lea    (%r14,%rax,1),%ecx
movslq %ecx,%rcx
movups (%rsi,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rsi,%rcx,4),%xmm2
subps  %xmm2,%xmm1
lea    0x0(%rbp,%rax,1),%ecx
movslq %ecx,%rcx
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
add    $0x8,%rax
cmp    %rax,%rdi
jne    1b10 <boxfilter+0xa10>
mov    0xf8(%rsp),%r12
mov    0xf0(%rsp),%r9d
cmp    %rdi,0x108(%rsp)
je     1d6d <boxfilter+0xc6d>
nopl   0x0(%rax)
mov    -0x78(%rsp),%rcx
imul   %r8d,%ecx
add    -0x48(%rsp),%ecx
mov    %ecx,%r15d
mov    -0x68(%rsp),%rbp
sub    %ebp,%r15d
mov    %r8d,%ebx
sub    %r12d,%ebx
sub    %ebp,%ebx
test   $0x1,%bl
jne    1cc0 <boxfilter+0xbc0>
mov    %r12,%rcx
jmp    1cee <boxfilter+0xbee>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
add    %r15d,%eax
mov    -0x20(%rsp),%rdi
lea    (%rax,%rdi,1),%ecx
cmp    %eax,%ecx
jl     194e <boxfilter+0x84e>
mov    %rdi,%rax
shr    $0x20,%rax
jne    194e <boxfilter+0x84e>
mov    0xc0(%rsp),%rcx
add    %r15d,%ecx
add    %ecx,%edi
cmp    %ecx,%edi
jl     194e <boxfilter+0x84e>
mov    $0x0,%ecx
test   %rax,%rax
jne    1950 <boxfilter+0x850>
mov    0x38(%rsp),%rax
add    %r15d,%eax
mov    0xc0(%rsp),%rcx
add    %r15d,%ecx
cltq
lea    (%rdx,%rax,4),%rdi
movslq %ecx,%rcx
mov    0x188(%rsp),%rbx
lea    (%rbx,%rcx,4),%rbx
cmp    %rbx,%rdi
jae    1c3e <boxfilter+0xb3e>
mov    0x180(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
lea    (%rsi,%rcx,4),%rcx
cmp    %rax,%rcx
jb     194e <boxfilter+0x84e>
mov    %rbp,0x138(%rsp)
cmpq   $0x0,0x170(%rsp)
je     1f55 <boxfilter+0xe55>
mov    0xe8(%rsp),%rax
mov    (%rsp),%ecx
mov    %ecx,%ebp
mov    %r10d,%ecx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
lea    -0x8(%rbp),%edi
movslq %edi,%rdi
movups %xmm0,(%rdx,%rdi,4)
movups %xmm1,0x10(%rdx,%rdi,4)
lea    0x8(%rcx),%edi
movslq %edi,%rdi
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
movslq %ebp,%rbp
movups %xmm0,(%rdx,%rbp,4)
movups %xmm1,0x10(%rdx,%rbp,4)
add    $0x10,%rbx
add    $0x10,%ecx
add    $0x10,%ebp
add    $0xfffffffffffffffe,%rax
jne    1c70 <boxfilter+0xb70>
jmp    1f57 <boxfilter+0xe57>
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%edi
add    %r12d,%edi
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm0
add    %r15d,%r9d
movslq %r9d,%rdi
subss  (%rsi,%rdi,4),%xmm0
add    %r12d,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rdx,%rcx,4)
mov    %r12,%rcx
add    $0x1,%rcx
mov    %r12d,%r9d
cmp    %r12d,0xc8(%rsp)
mov    0xd0(%rsp),%rax
je     1d6d <boxfilter+0xc6d>
add    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r10,%rcx,1),%edi
add    $0xffffffff,%edi
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm0
add    %r15d,%r9d
movslq %r9d,%rdi
subss  (%rsi,%rdi,4),%xmm0
lea    (%r10,%rcx,1),%edi
lea    (%r14,%rcx,1),%ebp
lea    -0x1(%r14,%rcx,1),%ebx
movslq %ebx,%rbx
movss  %xmm0,(%rdx,%rbx,4)
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm0
lea    -0x1(%r13,%rcx,1),%edi
movslq %edi,%rdi
subss  (%rsi,%rdi,4),%xmm0
movslq %ebp,%rdi
movss  %xmm0,(%rdx,%rdi,4)
lea    (%rax,%rcx,1),%edi
add    $0x2,%edi
mov    %ecx,%r9d
add    $0x2,%ecx
cmp    $0x1,%edi
jne    1d10 <boxfilter+0xc10>
cmpl   $0x0,-0x68(%rsp)
mov    0x60(%rsp),%r15
mov    -0x80(%rsp),%r12
mov    -0x78(%rsp),%rbp
jle    18d0 <boxfilter+0x7d0>
mov    %ebp,%eax
imul   %r8d,%eax
add    -0x48(%rsp),%eax
add    %r8d,%eax
add    $0xffffffff,%eax
cltq
mov    -0x70(%rsp),%rbx
cmpq   $0x8,0x50(%rsp)
jae    1de0 <boxfilter+0xce0>
lea    (%r14,%rbx,1),%ecx
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm0
lea    (%r11,%rbx,1),%edi
movslq %edi,%rdi
subss  (%rsi,%rdi,4),%xmm0
movslq %ecx,%rcx
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rbx
add    $0x1,%ecx
cmp    %r15,%rbx
jl     1db0 <boxfilter+0xcb0>
jmp    18d0 <boxfilter+0x7d0>
nopw   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rbx
cmp    $0x1,%r8d
jne    1da6 <boxfilter+0xca6>
mov    0x48(%rsp),%rcx
add    %ebp,%ecx
mov    0x30(%rsp),%rdi
add    %ecx,%edi
mov    -0x70(%rsp),%rbx
cmp    %ecx,%edi
jl     1da6 <boxfilter+0xca6>
mov    0x30(%rsp),%rcx
shr    $0x20,%rcx
mov    -0x70(%rsp),%rbx
jne    1da6 <boxfilter+0xca6>
mov    0x28(%rsp),%rdi
add    %ebp,%edi
mov    0x30(%rsp),%rbp
add    %edi,%ebp
mov    -0x70(%rsp),%rbx
cmp    %edi,%ebp
mov    -0x78(%rsp),%rbp
jl     1da6 <boxfilter+0xca6>
mov    -0x70(%rsp),%rbx
test   %rcx,%rcx
jne    1da6 <boxfilter+0xca6>
mov    0x28(%rsp),%rcx
add    %ebp,%ecx
mov    0x48(%rsp),%rdi
lea    (%rdi,%rbp,1),%edi
movslq %ecx,%rcx
mov    0x148(%rsp),%rbx
lea    (%rbx,%rcx,1),%r8
movslq %edi,%rdi
lea    (%rbx,%rdi,1),%r9
mov    0x150(%rsp),%rbx
add    %ebp,%ebx
lea    (%rsi,%rcx,4),%rcx
mov    0xa8(%rsp),%rbp
lea    0x0(%rbp,%r8,4),%r8
lea    (%rdx,%rdi,4),%rdi
mov    0x140(%rsp),%rbp
lea    0x0(%rbp,%r9,4),%rbp
movslq %ebx,%rbx
cmp    %rbp,%rcx
setb   %r9b
cmp    %r8,%rdi
lea    (%rsi,%rbx,4),%rcx
setb   %r8b
cmp    %rbp,%rcx
mov    -0x78(%rsp),%rbp
mov    0x178(%rsp),%rcx
lea    (%rcx,%rbx,4),%rbx
setb   %cl
cmp    %rbx,%rdi
setb   %dil
mov    -0x70(%rsp),%rbx
test   %r8b,%r9b
mov    -0x28(%rsp),%r8
jne    1da6 <boxfilter+0xca6>
mov    -0x70(%rsp),%rbx
and    %dil,%cl
jne    1da6 <boxfilter+0xca6>
movss  (%rsi,%rax,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0xa0(%rsp),%rcx
mov    -0x60(%rsp),%edi
mov    %edi,%ebp
mov    -0x18(%rsp),%edi
movslq %edi,%rdi
movups (%rsi,%rdi,4),%xmm1
movups 0x10(%rsi,%rdi,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,%edi
add    $0x8,%ebp
add    $0xfffffffffffffff8,%rcx
jne    1f00 <boxfilter+0xe00>
mov    0x110(%rsp),%rbx
mov    0xa0(%rsp),%rcx
cmp    %rcx,0x50(%rsp)
mov    -0x78(%rsp),%rbp
je     18d0 <boxfilter+0x7d0>
jmp    1da6 <boxfilter+0xca6>
xor    %ebx,%ebx
testb  $0x1,0x120(%rsp)
01
mov    0x138(%rsp),%rbp
je     1f86 <boxfilter+0xe86>
lea    (%rbx,%rbp,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    0x118(%rsp),%rax
mov    %rax,%rcx
cmp    %r12,%rax
je     19c7 <boxfilter+0x8c7>
jmp    1950 <boxfilter+0x850>
xor    %eax,%eax
mov    %rax,-0x60(%rsp)
mov    0x1d8(%rsp),%eax
test   %eax,%eax
jle    2b55 <boxfilter+0x1a55>
mov    -0x10(%rsp),%rax
lea    (%rdx,%rax,4),%rcx
mov    %rcx,-0x70(%rsp)
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x58(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x40(%rsp)
mov    %rax,-0x48(%rsp)
jmp    2006 <boxfilter+0xf06>
nopl   0x0(%rax,%rax,1)
mov    -0x60(%rsp),%rcx
add    $0x1,%ecx
add    %r10,-0x48(%rsp)
add    %r10,-0x40(%rsp)
mov    0x1d8(%rsp),%eax
mov    %rcx,-0x60(%rsp)
cmp    %eax,%ecx
je     21f9 <boxfilter+0x10f9>
cmpl   $0x2,-0x38(%rsp)
jl     1fe0 <boxfilter+0xee0>
mov    %r10d,%r13d
imul   -0x60(%rsp),%r13d
lea    (%r8,%r13,1),%eax
mov    %rax,-0x78(%rsp)
mov    $0x1,%r11d
xor    %r15d,%r15d
mov    -0x40(%rsp),%rbp
mov    -0x48(%rsp),%r12
jmp    205a <boxfilter+0xf5a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r11d
add    $0x1,%r15d
add    %rcx,%rbp
add    %rcx,%r12
cmp    -0x38(%rsp),%r11d
mov    -0x28(%rsp),%r8
je     1fe0 <boxfilter+0xee0>
test   %r8d,%r8d
mov    -0x10(%rsp),%rcx
jle    2040 <boxfilter+0xf40>
mov    -0x28(%rsp),%rax
cmp    $0x8,%eax
jae    2080 <boxfilter+0xf80>
xor    %r9d,%r9d
jmp    2150 <boxfilter+0x1050>
cs nopw 0x0(%rax,%rax,1)
mov    %r15d,%ebx
imul   %eax,%ebx
mov    -0x78(%rsp),%rax
lea    (%rax,%rbx,1),%r14d
mov    0x8(%rsp),%rax
lea    (%r14,%rax,1),%edi
cmp    %r14d,%edi
jl     206e <boxfilter+0xf6e>
mov    %rax,%r10
shr    $0x20,%r10
jne    20e9 <boxfilter+0xfe9>
add    %r13d,%ebx
lea    (%rbx,%rax,1),%edi
cmp    %ebx,%edi
jl     20e9 <boxfilter+0xfe9>
mov    $0x0,%r9d
test   %r10,%r10
mov    -0x50(%rsp),%r10
jne    2150 <boxfilter+0x1050>
movslq %r14d,%r10
lea    (%rdx,%r10,4),%r9
movslq %ebx,%rbx
mov    -0x70(%rsp),%rax
lea    (%rax,%rbx,4),%rdi
cmp    %rdi,%r9
jae    20f3 <boxfilter+0xff3>
lea    (%rax,%r10,4),%rdi
lea    (%rdx,%rbx,4),%rbx
cmp    %rdi,%rbx
jae    20f3 <boxfilter+0xff3>
xor    %r9d,%r9d
mov    -0x50(%rsp),%r10
jmp    2150 <boxfilter+0x1050>
mov    %ebp,%edi
mov    -0x58(%rsp),%rbx
mov    -0x28(%rsp),%r8
nop
movslq %edi,%rdi
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
lea    (%r8,%rdi,1),%eax
cltq
movups (%rdx,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rdx,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rdx,%rax,4)
movups %xmm0,0x10(%rdx,%rax,4)
add    $0x8,%edi
add    $0xfffffffffffffff8,%rbx
jne    2100 <boxfilter+0x1000>
mov    -0x58(%rsp),%rax
mov    %rax,%r9
mov    -0x10(%rsp),%rcx
cmp    %rcx,%rax
mov    -0x50(%rsp),%r10
je     2040 <boxfilter+0xf40>
xchg   %ax,%ax
mov    %r9,%rbx
test   $0x1,%cl
je     218d <boxfilter+0x108d>
lea    -0x1(%r11),%eax
mov    -0x28(%rsp),%rbx
imul   %ebx,%eax
mov    %r11d,%edi
imul   %ebx,%edi
lea    (%r9,%r13,1),%ebx
add    %ebx,%eax
cltq
movss  (%rdx,%rax,4),%xmm0
add    %ebx,%edi
movslq %edi,%rax
addss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
mov    %r9,%rbx
or     $0x1,%rbx
not    %r9
cmp    0x20(%rsp),%r9
je     2040 <boxfilter+0xf40>
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%rbp,1),%rax
cltq
movss  (%rdx,%rax,4),%xmm0
lea    (%r12,%rbx,1),%rdi
movslq %edi,%rdi
addss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x1,%eax
cltq
movss  (%rdx,%rax,4),%xmm0
add    $0x1,%edi
movslq %edi,%rax
addss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    21a0 <boxfilter+0x10a0>
jmp    2040 <boxfilter+0xf40>
mov    -0x50(%rsp),%r10
cmpb   $0x0,-0x60(%rsp)
jne    2b65 <boxfilter+0x1a65>
jmp    30da <boxfilter+0x1fda>
xor    %eax,%eax
mov    %rax,-0x60(%rsp)
mov    0x1d8(%rsp),%eax
test   %eax,%eax
jle    2b55 <boxfilter+0x1a55>
mov    -0x38(%rsp),%rcx
mov    %ecx,%r11d
mov    -0x68(%rsp),%r14
sub    %r14d,%r11d
lea    -0x1(%rcx),%edi
mov    %edi,%eax
imul   %r8d,%eax
mov    %eax,0x58(%rsp)
movslq %r11d,%r13
movslq %ecx,%r9
lea    0x1(%r13),%rbp
cmp    %r9,%rbp
cmovle %r9,%rbp
mov    %r13,%rax
not    %rax
add    %rbp,%rax
mov    %rax,(%rsp)
mov    %rdi,%rax
mov    %rdi,0xf0(%rsp)
mov    %edi,%r10d
mov    0x15c(%rsp),%edi
sub    %edi,%r10d
lea    0x0(,%r13,4),%rax
mov    %rdx,%rbx
sub    %rax,%rbx
mov    %rbx,0x150(%rsp)
mov    %rsi,%rbx
sub    %rax,%rbx
mov    %rbx,0x148(%rsp)
mov    %rbp,0xb0(%rsp)
sub    %r13,%rbp
sub    %edi,%ecx
add    $0xfffffffe,%ecx
lea    0x1(%rcx),%rdi
mov    -0x80(%rsp),%r15
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x98(%rsp)
mov    0x120(%rsp),%rbx
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
and    %rax,%rbx
mov    %rbx,0x110(%rsp)
movabs $0x1fffffff8,%r12
mov    %rdi,0x88(%rsp)
and    %rdi,%r12
mov    %rbp,0x8(%rsp)
and    $0xfffffffffffffff8,%rbp
mov    -0x20(%rsp),%rdi
lea    0x8(%rdi),%ebx
imul   %r8d,%ebx
mov    %rbx,0x108(%rsp)
mov    %r8d,%ebx
shl    $0x4,%ebx
mov    %ebx,0x100(%rsp)
mov    %r8d,%ebx
imul   %edi,%ebx
mov    %rbx,0xf8(%rsp)
mov    %r8d,%ebx
imul   %r15d,%ebx
mov    %rbx,0x80(%rsp)
lea    (%r14,%r14,1),%eax
add    $0x1,%eax
mov    %rax,%rbx
mov    %rax,0xe0(%rsp)
imul   %r8d,%eax
mov    %rax,0x78(%rsp)
mov    %r13d,%eax
imul   %r8d,%eax
mov    %eax,-0x4(%rsp)
mov    %r10,%rbx
mov    %r10,0xe8(%rsp)
mov    %r10d,%eax
imul   %r8d,%eax
mov    %eax,-0x8(%rsp)
mov    %edi,%eax
not    %eax
mov    %rax,0x38(%rsp)
lea    0x4(%rdx),%rbx
mov    %rbx,0x140(%rsp)
lea    0x4(%rsi,%rcx,4),%rbx
mov    %rbx,0x130(%rsp)
mov    %rcx,-0x58(%rsp)
lea    0x4(%rdx,%rcx,4),%rcx
mov    %rcx,0x128(%rsp)
lea    (%r12,%r15,1),%rcx
mov    %rcx,0x70(%rsp)
mov    %r12,0x40(%rsp)
lea    (%r12,%r14,1),%eax
mov    %eax,0x118(%rsp)
mov    %rbp,0xa8(%rsp)
lea    0x0(%rbp,%r13,1),%rax
mov    %rax,0x90(%rsp)
lea    0x0(,%r8,8),%eax
mov    %rax,0x28(%rsp)
lea    (%r8,%r8,1),%r12d
lea    0x1(%rdi),%eax
mov    %eax,0xc0(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %r13,-0x30(%rsp)
jmp    2426 <boxfilter+0x1326>
nopl   (%rax)
mov    0x18(%rsp),%rbx
add    $0x1,%rbx
mov    -0x50(%rsp),%rax
mov    -0x60(%rsp),%rcx
add    %eax,%ecx
mov    %rcx,-0x60(%rsp)
add    %eax,-0x4(%rsp)
add    %eax,-0x8(%rsp)
mov    0x1d8(%rsp),%ecx
mov    %rbx,0x18(%rsp)
cmp    %ecx,%ebx
je     2de2 <boxfilter+0x1ce2>
test   %r8d,%r8d
jle    23f0 <boxfilter+0x12f0>
mov    0x18(%rsp),%rcx
mov    %rcx,%rbx
imul   0x10(%rsp),%rbx
mov    0x168(%rsp),%rax
add    %rbx,%rax
mov    %rax,0x50(%rsp)
mov    -0x80(%rsp),%rax
lea    (%rbx,%rax,1),%rax
mov    %rax,0xc8(%rsp)
mov    0xe0(%rsp),%rax
lea    (%rbx,%rax,1),%rax
mov    %rax,0x48(%rsp)
mov    0xe8(%rsp),%rax
lea    (%rbx,%rax,1),%rax
mov    %rax,0xd0(%rsp)
lea    (%rbx,%r11,1),%rax
mov    %rax,0x30(%rsp)
mov    0xf0(%rsp),%rax
mov    %rbx,-0x18(%rsp)
add    %rbx,%rax
mov    %rax,0xb8(%rsp)
mov    -0x50(%rsp),%rax
imul   %ecx,%eax
mov    %rax,-0x70(%rsp)
mov    -0x8(%rsp),%eax
mov    %eax,-0x40(%rsp)
mov    -0x4(%rsp),%eax
mov    %eax,-0x48(%rsp)
mov    -0x60(%rsp),%rax
mov    %eax,-0x78(%rsp)
xor    %r15d,%r15d
jmp    24f3 <boxfilter+0x13f3>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
addl   $0x1,-0x78(%rsp)
addl   $0x1,-0x48(%rsp)
addl   $0x1,-0x40(%rsp)
cmp    -0x10(%rsp),%r15
mov    -0x20(%rsp),%rdi
je     23f0 <boxfilter+0x12f0>
test   %r14d,%r14d
js     2762 <boxfilter+0x1662>
mov    -0x70(%rsp),%rax
lea    (%rax,%r15,1),%ebx
cmpl   $0x8,-0x80(%rsp)
jae    2520 <boxfilter+0x1420>
xor    %eax,%eax
jmp    26b0 <boxfilter+0x15b0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x1,%r8d
jne    250c <boxfilter+0x140c>
mov    -0x18(%rsp),%rax
add    %r15d,%eax
lea    (%rax,%rdi,1),%ecx
cmp    %eax,%ecx
jl     250c <boxfilter+0x140c>
mov    %rdi,%rcx
shr    $0x20,%rcx
jne    250c <boxfilter+0x140c>
mov    0x50(%rsp),%rax
add    %r15d,%eax
add    %eax,%edi
cmp    %eax,%edi
jl     259f <boxfilter+0x149f>
mov    $0x0,%eax
test   %rcx,%rcx
mov    -0x20(%rsp),%rdi
jne    26b0 <boxfilter+0x15b0>
mov    -0x18(%rsp),%rax
add    %r15d,%eax
mov    0x50(%rsp),%rcx
add    %r15d,%ecx
cltq
lea    (%rsi,%rax,4),%rdi
movslq %ecx,%rcx
mov    0x180(%rsp),%rbp
lea    0x0(%rbp,%rcx,4),%rbp
cmp    %rbp,%rdi
jae    25ab <boxfilter+0x14ab>
mov    0x188(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
lea    (%rdx,%rcx,4),%rcx
cmp    %rax,%rcx
jae    25ab <boxfilter+0x14ab>
xor    %eax,%eax
mov    -0x20(%rsp),%rdi
jmp    26b0 <boxfilter+0x15b0>
mov    %ebx,0x138(%rsp)
mov    %r15,0xa0(%rsp)
cmpq   $0x0,0x170(%rsp)
je     264a <boxfilter+0x154a>
mov    0x110(%rsp),%rax
mov    -0x78(%rsp),%ecx
mov    %ecx,%ebp
xor    %ecx,%ecx
mov    0x108(%rsp),%rbx
mov    0x100(%rsp),%r13d
mov    0xf8(%rsp),%r15
mov    0x28(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
lea    (%r15,%rbp,1),%edi
movslq %edi,%rdi
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
movslq %ebp,%rbp
movups %xmm0,(%rsi,%rbp,4)
movups %xmm1,0x10(%rsi,%rbp,4)
lea    (%rbx,%rbp,1),%edi
movslq %edi,%rdi
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
lea    (%r10,%rbp,1),%edi
movslq %edi,%rdi
movups %xmm0,(%rsi,%rdi,4)
movups %xmm1,0x10(%rsi,%rdi,4)
add    $0x10,%rcx
add    %r13d,%ebp
add    $0xfffffffffffffffe,%rax
jne    2600 <boxfilter+0x1500>
jmp    264c <boxfilter+0x154c>
xor    %ecx,%ecx
testb  $0x1,0x120(%rsp)
01
mov    0xa0(%rsp),%r15
mov    0x138(%rsp),%ebx
je     268c <boxfilter+0x158c>
lea    (%rcx,%r14,1),%eax
imul   %r8d,%eax
add    %ebx,%eax
cltq
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
imul   %r8d,%ecx
add    %ebx,%ecx
movslq %ecx,%rax
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
mov    0x98(%rsp),%rcx
mov    %rcx,%rax
cmp    -0x80(%rsp),%rcx
mov    -0x20(%rsp),%rdi
je     2762 <boxfilter+0x1662>
nopw   0x0(%rax,%rax,1)
mov    %rax,%rcx
testb  $0x1,-0x80(%rsp)
je     26e3 <boxfilter+0x15e3>
lea    (%rax,%r14,1),%ecx
imul   %r8d,%ecx
add    %ebx,%ecx
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm0
mov    %eax,%ecx
imul   %r8d,%ecx
add    %ebx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rsi,%rcx,4)
mov    %rax,%rcx
or     $0x1,%rcx
not    %rax
cmp    0xd8(%rsp),%rax
je     2762 <boxfilter+0x1662>
mov    -0x80(%rsp),%rbx
sub    %rcx,%rbx
mov    %r8d,%eax
imul   %ecx,%eax
mov    -0x78(%rsp),%r10d
add    %r10d,%eax
lea    (%rdi,%rcx,1),%r13d
imul   %r8d,%r13d
add    %r10d,%r13d
lea    0x1(%rcx),%ebp
imul   %r8d,%ebp
add    %r10d,%ebp
add    0xc0(%rsp),%ecx
imul   %r8d,%ecx
add    %r10d,%ecx
nopl   0x0(%rax)
movslq %r13d,%r13
movss  (%rdx,%r13,4),%xmm0
cltq
movss  %xmm0,(%rsi,%rax,4)
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm0
movslq %ebp,%rbp
movss  %xmm0,(%rsi,%rbp,4)
add    %r12d,%eax
add    %r12d,%r13d
add    %r12d,%ebp
add    %r12d,%ecx
add    $0xfffffffffffffffe,%rbx
jne    2730 <boxfilter+0x1630>
cmp    %r11d,-0x80(%rsp)
mov    -0x30(%rsp),%r13
jge    2970 <boxfilter+0x1870>
mov    -0x80(%rsp),%rbx
mov    %r14d,%ecx
cmpl   $0x7,-0x58(%rsp)
jb     2910 <boxfilter+0x1810>
mov    -0x80(%rsp),%rbx
mov    %r14d,%ecx
cmp    $0x1,%r8d
jne    2910 <boxfilter+0x1810>
mov    0xc8(%rsp),%rax
add    %r15d,%eax
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%edi
mov    -0x80(%rsp),%rbx
mov    %r14d,%ecx
cmp    %eax,%edi
jl     2910 <boxfilter+0x1810>
mov    0x48(%rsp),%rax
add    %r15d,%eax
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%edi
mov    -0x80(%rsp),%rbx
mov    %r14d,%ecx
cmp    %eax,%edi
jl     2910 <boxfilter+0x1810>
mov    -0x18(%rsp),%rax
add    %r15d,%eax
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%edi
mov    -0x80(%rsp),%rbx
mov    %r14d,%ecx
cmp    %eax,%edi
jl     2910 <boxfilter+0x1810>
mov    0xc8(%rsp),%rax
add    %r15d,%eax
mov    -0x18(%rsp),%rcx
lea    (%rcx,%r15,1),%ecx
mov    0x48(%rsp),%rdi
lea    (%rdi,%r15,1),%edi
cltq
lea    (%rsi,%rax,4),%rbp
mov    0x130(%rsp),%rbx
lea    (%rbx,%rax,4),%rbx
movslq %ecx,%rax
lea    (%rdx,%rax,4),%r14
mov    0x128(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
movslq %edi,%rdi
cmp    %rax,%rbp
setb   %r8b
cmp    %rbx,%r14
lea    (%rcx,%rdi,4),%rax
setb   %r14b
cmp    %rax,%rbp
lea    (%rdx,%rdi,4),%rcx
setb   %al
cmp    %rbx,%rcx
setb   %dil
mov    -0x80(%rsp),%rbx
mov    -0x68(%rsp),%rcx
test   %r14b,%r8b
mov    -0x68(%rsp),%r14
mov    -0x28(%rsp),%r8
jne    2910 <boxfilter+0x1810>
mov    -0x80(%rsp),%rbx
mov    %r14d,%ecx
and    %dil,%al
jne    2910 <boxfilter+0x1810>
mov    0x40(%rsp),%rax
mov    -0x78(%rsp),%ecx
mov    0x80(%rsp),%r10
mov    0x78(%rsp),%rbp
mov    0x28(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,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    (%r10,%rcx,1),%edi
movslq %edi,%rdi
movups %xmm0,(%rsi,%rdi,4)
movups %xmm1,0x10(%rsi,%rdi,4)
add    %ebx,%ecx
add    $0xfffffffffffffff8,%rax
jne    28b0 <boxfilter+0x17b0>
mov    0x70(%rsp),%rbx
mov    0x118(%rsp),%ecx
mov    0x88(%rsp),%rax
cmp    0x40(%rsp),%rax
je     2970 <boxfilter+0x1870>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x70(%rsp),%rax
lea    (%rax,%r15,1),%edi
mov    %r8d,%eax
imul   %ebx,%eax
mov    -0x78(%rsp),%r10d
add    %r10d,%eax
mov    -0x20(%rsp),%rbp
add    %ebx,%ebp
imul   %r8d,%ebp
add    %r10d,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm0
sub    %r14d,%ecx
imul   %r8d,%ecx
add    %edi,%ecx
movslq %ecx,%rcx
subss  (%rdx,%rcx,4),%xmm0
cltq
movss  %xmm0,(%rsi,%rax,4)
add    %r8d,%eax
add    %r8d,%ebp
mov    %ebx,%ecx
add    $0x1,%ebx
cmp    %ebx,%r11d
jne    2940 <boxfilter+0x1840>
test   %r14d,%r14d
jle    24d0 <boxfilter+0x13d0>
mov    -0x70(%rsp),%rax
add    %r15d,%eax
add    0x58(%rsp),%eax
movslq %eax,%rcx
mov    %r13,%rbx
cmpq   $0x8,0x8(%rsp)
jae    29e0 <boxfilter+0x18e0>
mov    %r8d,%eax
imul   %ebx,%eax
mov    -0x78(%rsp),%edi
add    %edi,%eax
mov    0x38(%rsp),%rbp
add    %ebx,%ebp
imul   %r8d,%ebp
add    %edi,%ebp
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm0
movslq %ebp,%rbp
subss  (%rdx,%rbp,4),%xmm0
cltq
movss  %xmm0,(%rsi,%rax,4)
add    $0x1,%rbx
add    %r8d,%eax
add    %r8d,%ebp
cmp    %r9,%rbx
jl     29b0 <boxfilter+0x18b0>
jmp    24d0 <boxfilter+0x13d0>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rbx
cmp    $0x1,%r8d
jne    2993 <boxfilter+0x1893>
mov    0x30(%rsp),%rax
add    %r15d,%eax
mov    (%rsp),%rdi
add    %eax,%edi
mov    %r13,%rbx
cmp    %eax,%edi
jl     2993 <boxfilter+0x1893>
mov    (%rsp),%rax
shr    $0x20,%rax
mov    %r13,%rbx
jne    2993 <boxfilter+0x1893>
mov    0xd0(%rsp),%rdi
add    %r15d,%edi
mov    (%rsp),%rbx
lea    (%rdi,%rbx,1),%ebp
mov    %r13,%rbx
cmp    %edi,%ebp
jl     2993 <boxfilter+0x1893>
mov    %r13,%rbx
test   %rax,%rax
jne    2993 <boxfilter+0x1893>
mov    0xd0(%rsp),%rax
add    %r15d,%eax
mov    0x30(%rsp),%rdi
lea    (%rdi,%r15,1),%edi
cltq
mov    0xb0(%rsp),%rbx
lea    (%rbx,%rax,1),%r14
movslq %edi,%rdi
lea    (%rbx,%rdi,1),%r8
mov    0xb8(%rsp),%rbx
add    %r15d,%ebx
lea    (%rdx,%rax,4),%rax
mov    0x150(%rsp),%rbp
lea    0x0(%rbp,%r14,4),%r14
lea    (%rsi,%rdi,4),%rdi
mov    0x148(%rsp),%rbp
lea    0x0(%rbp,%r8,4),%rbp
movslq %ebx,%rbx
cmp    %rbp,%rax
setb   %r8b
cmp    %r14,%rdi
lea    (%rdx,%rbx,4),%rax
setb   %r14b
cmp    %rbp,%rax
mov    0x140(%rsp),%rax
lea    (%rax,%rbx,4),%rbx
setb   %al
cmp    %rbx,%rdi
setb   %dil
mov    %r13,%rbx
test   %r14b,%r8b
mov    -0x68(%rsp),%r14
mov    -0x28(%rsp),%r8
jne    2993 <boxfilter+0x1893>
mov    %r13,%rbx
and    %dil,%al
jne    2993 <boxfilter+0x1893>
movss  (%rdx,%rcx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0xa8(%rsp),%rax
mov    -0x40(%rsp),%edi
mov    %edi,%ebp
mov    -0x48(%rsp),%edi
mov    0x28(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movslq %ebp,%rbp
movups (%rdx,%rbp,4),%xmm1
movups 0x10(%rdx,%rbp,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,%ebp
add    $0xfffffffffffffff8,%rax
jne    2b00 <boxfilter+0x1a00>
mov    0x90(%rsp),%rbx
mov    0xa8(%rsp),%rax
cmp    %rax,0x8(%rsp)
je     24d0 <boxfilter+0x13d0>
jmp    2993 <boxfilter+0x1893>
xor    %eax,%eax
mov    %rax,-0x60(%rsp)
mov    0x68(%rsp),%r12
cmpb   $0x0,-0x60(%rsp)
je     30da <boxfilter+0x1fda>
cmpl   $0x0,-0x38(%rsp)
jle    30da <boxfilter+0x1fda>
mov    0x1d8(%rsp),%eax
mov    %rax,%rdx
mov    %edx,%edi
mov    -0x68(%rsp),%rcx
sub    %ecx,%edi
lea    0x1(%rcx),%r9d
lea    -0x1(%rax),%ebx
mov    %r10d,%eax
imul   %ebx,%eax
mov    %edi,-0x70(%rsp)
movslq %edi,%rdi
movslq %edx,%r15
cltq
mov    %rax,-0x40(%rsp)
movslq -0x28(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    -0x38(%rsp),%eax
mov    %rax,0x60(%rsp)
mov    %r9d,%r8d
and    $0xfffffffe,%r8d
mov    %r9,-0x38(%rsp)
imul   %r10d,%r9d
lea    (%r10,%r10,1),%r13d
mov    %r10d,%r14d
imul   %ecx,%r14d
lea    0x1(%rcx,%rcx,1),%r11d
imul   %r10d,%r11d
sub    %ecx,%ebx
sub    %ecx,%ebx
mov    %rdi,-0x58(%rsp)
mov    %edi,%eax
imul   %r10d,%eax
mov    %eax,-0x48(%rsp)
mov    %r10d,%eax
mov    %ebx,-0x30(%rsp)
imul   %ebx,%eax
mov    %eax,0x10(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
jmp    2c2c <boxfilter+0x1b2c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
cmp    0x60(%rsp),%rcx
je     30da <boxfilter+0x1fda>
cmpl   $0x0,-0x28(%rsp)
jle    2c10 <boxfilter+0x1b10>
mov    0x20(%rsp),%rax
imul   -0x60(%rsp),%rax
mov    %rax,-0x78(%rsp)
xor    %ebx,%ebx
jmp    2c60 <boxfilter+0x1b60>
nopw   0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rbx
add    $0x1,%rbx
cmp    -0x10(%rsp),%rbx
je     2c10 <boxfilter+0x1b10>
cmpl   $0x0,-0x68(%rsp)
js     2d14 <boxfilter+0x1c14>
mov    %r12,%rcx
mov    -0x78(%rsp),%rax
lea    (%rbx,%rax,1),%r10
cmpl   $0x0,-0x68(%rsp)
je     2ce0 <boxfilter+0x1be0>
xor    %r12d,%r12d
xor    %edx,%edx
mov    -0x50(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
lea    (%r14,%r12,1),%eax
cltq
add    %r10,%rax
movss  (%rsi,%rax,4),%xmm0
movslq %r12d,%r12
lea    (%r10,%r12,1),%rax
movss  %xmm0,(%rcx,%rax,4)
lea    (%r9,%r12,1),%eax
cltq
add    %r10,%rax
movss  (%rsi,%rax,4),%xmm0
lea    (%rdi,%r12,1),%eax
cltq
add    %r10,%rax
movss  %xmm0,(%rcx,%rax,4)
add    $0x2,%rdx
add    %r13d,%r12d
cmp    %rdx,%r8
jne    2c90 <boxfilter+0x1b90>
jmp    2ce2 <boxfilter+0x1be2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %edx,%edx
testb  $0x1,-0x38(%rsp)
mov    %rcx,%r12
je     2d14 <boxfilter+0x1c14>
mov    -0x68(%rsp),%rax
add    %edx,%eax
mov    -0x50(%rsp),%rcx
imul   %ecx,%eax
cltq
add    %r10,%rax
movss  (%rsi,%rax,4),%xmm0
imul   %ecx,%edx
movslq %edx,%rax
add    %r10,%rax
movss  %xmm0,(%r12,%rax,4)
mov    -0x38(%rsp),%rax
cmp    -0x70(%rsp),%eax
mov    -0x50(%rsp),%r10
jge    2d73 <boxfilter+0x1c73>
mov    -0x78(%rsp),%rax
lea    (%rbx,%rax,1),%rdx
xor    %ecx,%ecx
mov    -0x30(%rsp),%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r11,%rcx,1),%edi
movslq %edi,%rdi
add    %rdx,%rdi
movss  (%rsi,%rdi,4),%xmm0
movslq %ecx,%rcx
lea    (%rdx,%rcx,1),%rdi
subss  (%rsi,%rdi,4),%xmm0
lea    (%r9,%rcx,1),%edi
movslq %edi,%rdi
add    %rdx,%rdi
movss  %xmm0,(%r12,%rdi,4)
add    %r10d,%ecx
add    $0xffffffff,%eax
jne    2d40 <boxfilter+0x1c40>
mov    %rbx,-0x80(%rsp)
cmpl   $0x0,-0x68(%rsp)
jle    2c50 <boxfilter+0x1b50>
mov    -0x78(%rsp),%rax
mov    -0x80(%rsp),%rcx
add    %rcx,%rax
mov    -0x40(%rsp),%rcx
add    %rax,%rcx
mov    0x10(%rsp),%edx
mov    -0x48(%rsp),%edi
mov    -0x58(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rsi,%rcx,4),%xmm0
movslq %edx,%rdx
lea    (%rax,%rdx,1),%rbx
subss  (%rsi,%rbx,4),%xmm0
movslq %edi,%rdi
lea    (%rax,%rdi,1),%rbx
movss  %xmm0,(%r12,%rbx,4)
add    $0x1,%rbp
add    %r10d,%edi
add    %r10d,%edx
cmp    %r15,%rbp
jl     2db0 <boxfilter+0x1cb0>
jmp    2c50 <boxfilter+0x1b50>
mov    0x1d8(%rsp),%ecx
cmp    $0x2,%ecx
setge  %cl
mov    %rcx,-0x60(%rsp)
jl     30da <boxfilter+0x1fda>
mov    0x1d8(%rsp),%ecx
mov    %ecx,%ecx
mov    %rcx,0x58(%rsp)
mov    -0x10(%rsp),%rbp
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x40(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x48(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rdx
mov    %rcx,-0x30(%rsp)
and    %rcx,0x160(%rsp)
lea    0x30(%rsi),%rcx
mov    %rcx,0xd8(%rsp)
mov    0x60(%rsp),%rcx
lea    0x0(,%rcx,4),%rcx
mov    $0x1,%edx
mov    %rdx,-0x18(%rsp)
xor    %edx,%edx
mov    %rdx,(%rsp)
mov    %eax,0x8(%rsp)
movl   $0x0,-0x20(%rsp)
jmp    2ea3 <boxfilter+0x1da3>
nop
mov    -0x18(%rsp),%rax
add    $0x1,%rax
addl   $0x1,-0x20(%rsp)
mov    -0x50(%rsp),%r10
add    %r10d,0x8(%rsp)
mov    (%rsp),%rdx
add    %r10d,%edx
mov    %rdx,(%rsp)
mov    %rax,-0x18(%rsp)
cmp    0x58(%rsp),%rax
je     2b55 <boxfilter+0x1a55>
cmpl   $0x0,-0x38(%rsp)
jle    2e70 <boxfilter+0x1d70>
mov    -0x50(%rsp),%rbx
mov    %ebx,%eax
imul   -0x20(%rsp),%eax
lea    (%rbx,%rax,1),%edx
movslq %edx,%r8
lea    (%r8,%rbp,1),%rdx
mov    %rdx,-0x70(%rsp)
cltq
mov    %rax,-0x58(%rsp)
add    %rbp,%rax
mov    %rax,-0x78(%rsp)
movslq 0x8(%rsp),%rax
mov    0x178(%rsp),%rdx
lea    (%rdx,%rax,4),%r13
movslq (%rsp),%rdx
lea    (%rsi,%rdx,4),%r15
mov    0xd8(%rsp),%rdi
lea    (%rdi,%rax,4),%r9
lea    (%rdi,%rdx,4),%r12
mov    -0x18(%rsp),%rdx
lea    -0x1(%rdx),%eax
imul   %ebx,%eax
mov    %edx,%edi
imul   %ebx,%edi
cltq
mov    %rax,-0x80(%rsp)
movslq %edi,%r14
xor    %r10d,%r10d
jmp    2f3b <boxfilter+0x1e3b>
nopl   0x0(%rax)
add    $0x1,%r10
add    %rcx,%r9
add    %rcx,%r12
add    %rcx,%r13
add    %rcx,%r15
cmp    0x10(%rsp),%r10
je     2e70 <boxfilter+0x1d70>
cmpl   $0x0,-0x28(%rsp)
jle    2f20 <boxfilter+0x1e20>
mov    %r10,%r11
imul   0x60(%rsp),%r11
cmpl   $0x8,-0x28(%rsp)
jb     2f8e <boxfilter+0x1e8e>
lea    (%r11,%r8,1),%rax
mov    -0x78(%rsp),%rdx
lea    (%rdx,%r11,1),%rdi
lea    (%rsi,%rax,4),%rax
lea    (%rsi,%rdi,4),%rdi
cmp    %rdi,%rax
jae    3007 <boxfilter+0x1f07>
mov    -0x70(%rsp),%rax
add    %r11,%rax
mov    -0x58(%rsp),%rdx
lea    (%r11,%rdx,1),%rdi
lea    (%rsi,%rax,4),%rax
lea    (%rsi,%rdi,4),%rdi
cmp    %rax,%rdi
jae    3007 <boxfilter+0x1f07>
xor    %eax,%eax
mov    %rax,%rbx
test   $0x1,%bpl
je     2fc0 <boxfilter+0x1ec0>
add    %rax,%r11
mov    -0x80(%rsp),%rdx
lea    (%r11,%rdx,1),%rdi
movss  (%rsi,%rdi,4),%xmm0
add    %r14,%r11
addss  (%rsi,%r11,4),%xmm0
movss  %xmm0,(%rsi,%r11,4)
mov    %rax,%rbx
or     $0x1,%rbx
not    %rax
cmp    0x20(%rsp),%rax
je     2f20 <boxfilter+0x1e20>
xchg   %ax,%ax
movss  (%r15,%rbx,4),%xmm0
addss  -0x4(%r13,%rbx,4),%xmm0
movss  %xmm0,-0x4(%r13,%rbx,4)
movss  0x4(%r15,%rbx,4),%xmm0
addss  0x0(%r13,%rbx,4),%xmm0
movss  %xmm0,0x0(%r13,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%rbp
jne    2fd0 <boxfilter+0x1ed0>
jmp    2f20 <boxfilter+0x1e20>
mov    %r8,%rdx
cmpq   $0x0,-0x48(%rsp)
je     30cf <boxfilter+0x1fcf>
mov    0x160(%rsp),%r8
xor    %ebx,%ebx
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    3020 <boxfilter+0x1f20>
testb  $0x1,-0x30(%rsp)
je     30b1 <boxfilter+0x1fb1>
add    %r11,%rbx
mov    -0x80(%rsp),%rax
add    %rbx,%rax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
add    %r14,%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    -0x40(%rsp),%rdi
mov    %rdi,%rax
mov    -0x10(%rsp),%rbp
cmp    %rbp,%rdi
mov    %rdx,%r8
je     2f20 <boxfilter+0x1e20>
jmp    2f90 <boxfilter+0x1e90>
xor    %ebx,%ebx
testb  $0x1,-0x30(%rsp)
jne    3082 <boxfilter+0x1f82>
jmp    30b1 <boxfilter+0x1fb1>
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
%607 = load i32, i32* %14
%608 = icmp sgt i32 %607, 1
br i1 %608, label %609, label %793
609: ; preds = %606
store i32 0, i32* %36
br label %610
610: ; preds = %789, %609
%611 = load i32, i32* %36
%612 = load i32, i32* %13
%613 = icmp slt i32 %611, %612
br i1 %613, label %614, label %792
614: ; preds = %610
store i32 0, i32* %37
br label %615
615: ; preds = %785, %614
%616 = load i32, i32* %37
%617 = load i32, i32* %12
%618 = icmp slt i32 %616, %617
br i1 %618, label %619, label %788
619: ; preds = %615
store i32 0, i32* %38
br label %620
620: ; preds = %657, %619
%621 = load i32, i32* %38
%622 = load i32, i32* %11
%623 = add nsw i32 %622, 1
%624 = icmp slt i32 %621, %623
br i1 %624, label %625, label %660
625: ; preds = %620
%626 = load float*, float** %9
%627 = load i32, i32* %37
%628 = load i32, i32* %36
%629 = load i32, i32* %12
%630 = mul nsw i32 %628, %629
%631 = add nsw i32 %627, %630
%632 = load i32, i32* %38
%633 = load i32, i32* %11
%634 = add nsw i32 %632, %633
%635 = load i32, i32* %12
%636 = mul nsw i32 %634, %635
%637 = load i32, i32* %13
%638 = mul nsw i32 %636, %637
%639 = add nsw i32 %631, %638
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds float, float* %626, i64 %640
%642 = load float, float* %641
%643 = load float*, float** %8
%644 = load i32, i32* %37
%645 = load i32, i32* %36
%646 = load i32, i32* %12
%647 = mul nsw i32 %645, %646
%648 = add nsw i32 %644, %647
%649 = load i32, i32* %38
%650 = load i32, i32* %12
%651 = mul nsw i32 %649, %650
%652 = load i32, i32* %13
%653 = mul nsw i32 %651, %652
%654 = add nsw i32 %648, %653
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds float, float* %643, i64 %655
store float %642, float* %656
br label %657
657: ; preds = %625
%658 = load i32, i32* %38
%659 = add nsw i32 %658, 1
store i32 %659, i32* %38
br label %620
660: ; preds = %620
%661 = load i32, i32* %11
%662 = add nsw i32 %661, 1
store i32 %662, i32* %39
br label %663
663: ; preds = %720, %660
%664 = load i32, i32* %39
%665 = load i32, i32* %14
%666 = load i32, i32* %11
%667 = sub nsw i32 %665, %666
%668 = icmp slt i32 %664, %667
br i1 %668, label %669, label %723
669: ; preds = %663
%670 = load float*, float** %9
%671 = load i32, i32* %37
%672 = load i32, i32* %36
%673 = load i32, i32* %12
%674 = mul nsw i32 %672, %673
%675 = add nsw i32 %671, %674
%676 = load i32, i32* %39
%677 = load i32, i32* %11
%678 = add nsw i32 %676, %677
%679 = load i32, i32* %12
%680 = mul nsw i32 %678, %679
%681 = load i32, i32* %13
%682 = mul nsw i32 %680, %681
%683 = add nsw i32 %675, %682
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds float, float* %670, i64 %684
%686 = load float, float* %685
%687 = load float*, float** %9
%688 = load i32, i32* %37
%689 = load i32, i32* %36
%690 = load i32, i32* %12
%691 = mul nsw i32 %689, %690
%692 = add nsw i32 %688, %691
%693 = load i32, i32* %39
%694 = load i32, i32* %11
%695 = sub nsw i32 %693, %694
%696 = sub nsw i32 %695, 1
%697 = load i32, i32* %12
%698 = mul nsw i32 %696, %697
%699 = load i32, i32* %13
%700 = mul nsw i32 %698, %699
%701 = add nsw i32 %692, %700
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds float, float* %687, i64 %702
%704 = load float, float* %703
%705 = fsub float %686, %704
%706 = load float*, float** %8
%707 = load i32, i32* %37
%708 = load i32, i32* %36
%709 = load i32, i32* %12
%710 = mul nsw i32 %708, %709
%711 = add nsw i32 %707, %710
%712 = load i32, i32* %39
%713 = load i32, i32* %12
%714 = mul nsw i32 %712, %713
%715 = load i32, i32* %13
%716 = mul nsw i32 %714, %715
%717 = add nsw i32 %711, %716
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds float, float* %706, i64 %718
store float %705, float* %719
br label %720
720: ; preds = %669
%721 = load i32, i32* %39
%722 = add nsw i32 %721, 1
store i32 %722, i32* %39
br label %663
723: ; preds = %663
%724 = load i32, i32* %14
%725 = load i32, i32* %11
%726 = sub nsw i32 %724, %725
store i32 %726, i32* %40
br label %727
727: ; preds = %781, %723
%728 = load i32, i32* %40
%729 = load i32, i32* %14
%730 = icmp slt i32 %728, %729
br i1 %730, label %731, label %784
731: ; preds = %727
%732 = load float*, float** %9
%733 = load i32, i32* %37
%734 = load i32, i32* %36
%735 = load i32, i32* %12
%736 = mul nsw i32 %734, %735
%737 = add nsw i32 %733, %736
%738 = load i32, i32* %14
%739 = sub nsw i32 %738, 1
%740 = load i32, i32* %12
%741 = mul nsw i32 %739, %740
%742 = load i32, i32* %13
%743 = mul nsw i32 %741, %742
%744 = add nsw i32 %737, %743
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds float, float* %732, i64 %745
%747 = load float, float* %746
%748 = load float*, float** %9
%749 = load i32, i32* %37
%750 = load i32, i32* %36
%751 = load i32, i32* %12
%752 = mul nsw i32 %750, %751
%753 = add nsw i32 %749, %752
%754 = load i32, i32* %40
%755 = load i32, i32* %11
%756 = sub nsw i32 %754, %755
%757 = sub nsw i32 %756, 1
%758 = load i32, i32* %12
%759 = mul nsw i32 %757, %758
%760 = load i32, i32* %13
%761 = mul nsw i32 %759, %760
%762 = add nsw i32 %753, %761
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds float, float* %748, i64 %763
%765 = load float, float* %764
%766 = fsub float %747, %765
%767 = load float*, float** %8
%768 = load i32, i32* %37
%769 = load i32, i32* %36
%770 = load i32, i32* %12
%771 = mul nsw i32 %769, %770
%772 = add nsw i32 %768, %771
%773 = load i32, i32* %40
%774 = load i32, i32* %12
%775 = mul nsw i32 %773, %774
%776 = load i32, i32* %13
%777 = mul nsw i32 %775, %776
%778 = add nsw i32 %772, %777
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds float, float* %767, i64 %779
store float %766, float* %780
br label %781
781: ; preds = %731
%782 = load i32, i32* %40
%783 = add nsw i32 %782, 1
store i32 %783, i32* %40
br label %727
784: ; preds = %727
br label %785
785: ; preds = %784
%786 = load i32, i32* %37
%787 = add nsw i32 %786, 1
store i32 %787, i32* %37
br label %615
788: ; preds = %615
br label %789
789: ; preds = %788
%790 = load i32, i32* %36
%791 = add nsw i32 %790, 1
store i32 %791, i32* %36
br label %610
792: ; preds = %610
br label %793
793: ; preds = %792, %606
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 %1687
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, %1549
%1406 = phi i32 [ 0, %1016 ], [ %1552, %1549 ]
%1407 = phi i64 [ 1, %1016 ], [ %1550, %1549 ]
%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 %1549
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 %1447
1422: ; preds = %1549, %117, %168, %395, %791
%1423 = phi i1 [ false, %791 ], [ false, %395 ], [ false, %168 ], [ false, %117 ], [ %1015, %1549 ]
%1424 = icmp sgt i32 %5, 0
%1425 = and i1 %1423, %1424
br i1 %1425, label %1426, label %1687
1426: ; preds = %1422
%1427 = icmp sgt i32 %4, 0
%1428 = icmp slt i32 %3, 0
%1429 = sub i32 %6, %3
%1430 = add i32 %3, 1
%1431 = icmp slt i32 %1430, %1429
%1432 = icmp sgt i32 %3, 0
%1433 = add nsw i32 %6, -1
%1434 = mul i32 %8, %1433
%1435 = xor i32 %3, -1
%1436 = zext i32 %1430 to i64
%1437 = sext i32 %1429 to i64
%1438 = sext i32 %6 to i64
%1439 = sext i32 %1434 to i64
%1440 = sext i32 %4 to i64
%1441 = zext i32 %5 to i64
%1442 = zext i32 %4 to i64
%1443 = and i64 %1436, 1
%1444 = icmp eq i32 %3, 0
%1445 = and i64 %1436, 4294967294
%1446 = icmp eq i64 %1443, 0
br label %1577
1447: ; preds = %1414, %1553
%1448 = phi i64 [ 0, %1414 ], [ %1554, %1553 ]
%1449 = mul i64 %1448, %179
%1450 = add i64 %1449, %1410
%1451 = getelementptr float, float* %1, i64 %1450
%1452 = add i64 %1411, %1449
%1453 = getelementptr float, float* %1, i64 %1452
%1454 = add i64 %1449, %1412
%1455 = getelementptr float, float* %1, i64 %1454
%1456 = add i64 %1413, %1449
%1457 = getelementptr float, float* %1, i64 %1456
br i1 %1018, label %1458, label %1553
1458: ; preds = %1447
%1459 = mul nsw i64 %1448, %1019
br i1 %1029, label %1533, label %1460
1460: ; preds = %1458
%1461 = icmp ult float* %1451, %1457
%1462 = icmp ult float* %1455, %1453
%1463 = and i1 %1461, %1462
br i1 %1463, label %1533, label %1464
1464: ; preds = %1460
br i1 %1032, label %1510, label %1465
1465: ; preds = %1464, %1465
%1466 = phi i64 [ %1507, %1465 ], [ 0, %1464 ]
%1467 = phi i64 [ %1508, %1465 ], [ 0, %1464 ]
%1468 = add nsw i64 %1466, %1459
%1469 = add nsw i64 %1468, %1420
%1470 = getelementptr inbounds float, float* %1, i64 %1469
%1471 = bitcast float* %1470 to <4 x float>*
%1472 = load <4 x float>, <4 x float>* %1471
%1473 = getelementptr inbounds float, float* %1470, i64 4
%1474 = bitcast float* %1473 to <4 x float>*
%1475 = load <4 x float>, <4 x float>* %1474
%1476 = add nsw i64 %1468, %1421
%1477 = getelementptr inbounds float, float* %1, i64 %1476
%1478 = bitcast float* %1477 to <4 x float>*
%1479 = load <4 x float>, <4 x float>* %1478
%1480 = getelementptr inbounds float, float* %1477, i64 4
%1481 = bitcast float* %1480 to <4 x float>*
%1482 = load <4 x float>, <4 x float>* %1481
%1483 = fadd <4 x float> %1472, %1479
%1484 = fadd <4 x float> %1475, %1482
%1485 = bitcast float* %1477 to <4 x float>*
store <4 x float> %1483, <4 x float>* %1485
%1486 = bitcast float* %1480 to <4 x float>*
store <4 x float> %1484, <4 x float>* %1486
%1487 = or i64 %1466, 8
%1488 = add nsw i64 %1487, %1459
%1489 = add nsw i64 %1488, %1420
%1490 = getelementptr inbounds float, float* %1, i64 %1489
%1491 = bitcast float* %1490 to <4 x float>*
%1492 = load <4 x float>, <4 x float>* %1491
%1493 = getelementptr inbounds float, float* %1490, i64 4
%1494 = bitcast float* %1493 to <4 x float>*
%1495 = load <4 x float>, <4 x float>* %1494
%1496 = add nsw i64 %1488, %1421
%1497 = getelementptr inbounds float, float* %1, i64 %1496
%1498 = bitcast float* %1497 to <4 x float>*
%1499 = load <4 x float>, <4 x float>* %1498
%1500 = getelementptr inbounds float, float* %1497, i64 4
%1501 = bitcast float* %1500 to <4 x float>*
%1502 = load <4 x float>, <4 x float>* %1501
%1503 = fadd <4 x float> %1492, %1499
%1504 = fadd <4 x float> %1495, %1502
%1505 = bitcast float* %1497 to <4 x float>*
store <4 x float> %1503, <4 x float>* %1505
%1506 = bitcast float* %1500 to <4 x float>*
store <4 x float> %1504, <4 x float>* %1506
%1507 = add nuw i64 %1466, 16
%1508 = add i64 %1467, 2
%1509 = icmp eq i64 %1508, %1033
br i1 %1509, label %1510, label %1465
1510: ; preds = %1465, %1464
%1511 = phi i64 [ 0, %1464 ], [ %1507, %1465 ]
br i1 %1034, label %1532, label %1512
1512: ; preds = %1510
%1513 = add nsw i64 %1511, %1459
%1514 = add nsw i64 %1513, %1420
%1515 = getelementptr inbounds float, float* %1, i64 %1514
%1516 = bitcast float* %1515 to <4 x float>*
%1517 = load <4 x float>, <4 x float>* %1516
%1518 = getelementptr inbounds float, float* %1515, i64 4
%1519 = bitcast float* %1518 to <4 x float>*
%1520 = load <4 x float>, <4 x float>* %1519
%1521 = add nsw i64 %1513, %1421
%1522 = getelementptr inbounds float, float* %1, i64 %1521
%1523 = bitcast float* %1522 to <4 x float>*
%1524 = load <4 x float>, <4 x float>* %1523
%1525 = getelementptr inbounds float, float* %1522, i64 4
%1526 = bitcast float* %1525 to <4 x float>*
%1527 = load <4 x float>, <4 x float>* %1526
%1528 = fadd <4 x float> %1517, %1524
%1529 = fadd <4 x float> %1520, %1527
%1530 = bitcast float* %1522 to <4 x float>*
store <4 x float> %1528, <4 x float>* %1530
%1531 = bitcast float* %1525 to <4 x float>*
store <4 x float> %1529, <4 x float>* %1531
br label %1532
1532: ; preds = %1510, %1512
br i1 %1035, label %1553, label %1533
1533: ; preds = %1460, %1458, %1532
%1534 = phi i64 [ 0, %1460 ], [ 0, %1458 ], [ %1030, %1532 ]
%1535 = xor i64 %1534, -1
br i1 %1037, label %1546, label %1536
1536: ; preds = %1533
%1537 = add nsw i64 %1534, %1459
%1538 = add nsw i64 %1537, %1420
%1539 = getelementptr inbounds float, float* %1, i64 %1538
%1540 = load float, float* %1539
%1541 = add nsw i64 %1537, %1421
%1542 = getelementptr inbounds float, float* %1, i64 %1541
%1543 = load float, float* %1542
%1544 = fadd float %1540, %1543
store float %1544, float* %1542
%1545 = or i64 %1534, 1
br label %1546
1546: ; preds = %1536, %1533
%1547 = phi i64 [ %1534, %1533 ], [ %1545, %1536 ]
%1548 = icmp eq i64 %1535, %1038
br i1 %1548, label %1553, label %1556
1549: ; preds = %1553, %1405
%1550 = add nuw nsw i64 %1407, 1
%1551 = icmp eq i64 %1550, %1020
%1552 = add i32 %1406, 1
br i1 %1551, label %1422, label %1405
1553: ; preds = %1546, %1556, %1532, %1447
%1554 = add nuw nsw i64 %1448, 1
%1555 = icmp eq i64 %1554, %1021
br i1 %1555, label %1549, label %1447
1556: ; preds = %1546, %1556
%1557 = phi i64 [ %1575, %1556 ], [ %1547, %1546 ]
%1558 = add nsw i64 %1557, %1459
%1559 = add nsw i64 %1558, %1420
%1560 = getelementptr inbounds float, float* %1, i64 %1559
%1561 = load float, float* %1560
%1562 = add nsw i64 %1558, %1421
%1563 = getelementptr inbounds float, float* %1, i64 %1562
%1564 = load float, float* %1563
%1565 = fadd float %1561, %1564
store float %1565, float* %1563
%1566 = add nuw nsw i64 %1557, 1
%1567 = add nsw i64 %1566, %1459
%1568 = add nsw i64 %1567, %1420
%1569 = getelementptr inbounds float, float* %1, i64 %1568
%1570 = load float, float* %1569
%1571 = add nsw i64 %1567, %1421
%1572 = getelementptr inbounds float, float* %1, i64 %1571
%1573 = load float, float* %1572
%1574 = fadd float %1570, %1573
store float %1574, float* %1572
%1575 = add nuw nsw i64 %1557, 2
%1576 = icmp eq i64 %1575, %1022
br i1 %1576, label %1553, label %1556
1577: ; preds = %1426, %1585
%1578 = phi i64 [ 0, %1426 ], [ %1586, %1585 ]
br i1 %1427, label %1579, label %1585
1579: ; preds = %1577
%1580 = mul nsw i64 %1578, %1440
br label %1581
1581: ; preds = %1579, %1667
%1582 = phi i64 [ 0, %1579 ], [ %1668, %1667 ]
br i1 %1428, label %1603, label %1583
1583: ; preds = %1581
%1584 = add nsw i64 %1582, %1580
br i1 %1444, label %1588, label %1606
1585: ; preds = %1667, %1577
%1586 = add nuw nsw i64 %1578, 1
%1587 = icmp eq i64 %1586, %1441
br i1 %1587, label %1687, label %1577
1588: ; preds = %1606, %1583
%1589 = phi i64 [ 0, %1583 ], [ %1634, %1606 ]
br i1 %1446, label %1603, label %1590
1590: ; preds = %1588
%1591 = trunc i64 %1589 to i32
%1592 = add i32 %1591, %3
%1593 = mul i32 %8, %1592
%1594 = sext i32 %1593 to i64
%1595 = add nsw i64 %1584, %1594
%1596 = getelementptr inbounds float, float* %1, i64 %1595
%1597 = load float, float* %1596
%1598 = trunc i64 %1589 to i32
%1599 = mul i32 %8, %1598
%1600 = sext i32 %1599 to i64
%1601 = add nsw i64 %1584, %1600
%1602 = getelementptr inbounds float, float* %0, i64 %1601
store float %1597, float* %1602
br label %1603
1603: ; preds = %1590, %1588, %1581
br i1 %1431, label %1604, label %1637
1604: ; preds = %1603
%1605 = add nsw i64 %1582, %1580
br label %1642
1606: ; preds = %1583, %1606
%1607 = phi i64 [ %1634, %1606 ], [ 0, %1583 ]
%1608 = phi i64 [ %1635, %1606 ], [ 0, %1583 ]
%1609 = trunc i64 %1607 to i32
%1610 = add i32 %1609, %3
%1611 = mul i32 %8, %1610
%1612 = sext i32 %1611 to i64
%1613 = add nsw i64 %1584, %1612
%1614 = getelementptr inbounds float, float* %1, i64 %1613
%1615 = load float, float* %1614
%1616 = trunc i64 %1607 to i32
%1617 = mul i32 %8, %1616
%1618 = sext i32 %1617 to i64
%1619 = add nsw i64 %1584, %1618
%1620 = getelementptr inbounds float, float* %0, i64 %1619
store float %1615, float* %1620
%1621 = or i64 %1607, 1
%1622 = trunc i64 %1621 to i32
%1623 = add i32 %1622, %3
%1624 = mul i32 %8, %1623
%1625 = sext i32 %1624 to i64
%1626 = add nsw i64 %1584, %1625
%1627 = getelementptr inbounds float, float* %1, i64 %1626
%1628 = load float, float* %1627
%1629 = trunc i64 %1621 to i32
%1630 = mul i32 %8, %1629
%1631 = sext i32 %1630 to i64
%1632 = add nsw i64 %1584, %1631
%1633 = getelementptr inbounds float, float* %0, i64 %1632
store float %1628, float* %1633
%1634 = add nuw nsw i64 %1607, 2
%1635 = add i64 %1608, 2
%1636 = icmp eq i64 %1635, %1445
br i1 %1636, label %1588, label %1606
1637: ; preds = %1642, %1603
br i1 %1432, label %1638, label %1667
1638: ; preds = %1637
%1639 = add nsw i64 %1582, %1580
%1640 = add nsw i64 %1639, %1439
%1641 = getelementptr inbounds float, float* %1, i64 %1640
br label %1670
1642: ; preds = %1604, %1642
%1643 = phi i64 [ %1436, %1604 ], [ %1664, %1642 ]
%1644 = phi i32 [ %3, %1604 ], [ %1659, %1642 ]
%1645 = trunc i64 %1643 to i32
%1646 = add i32 %1645, %3
%1647 = mul i32 %8, %1646
%1648 = sext i32 %1647 to i64
%1649 = add nsw i64 %1605, %1648
%1650 = getelementptr inbounds float, float* %1, i64 %1649
%1651 = load float, float* %1650
%1652 = sub i32 %1644, %3
%1653 = mul i32 %8, %1652
%1654 = sext i32 %1653 to i64
%1655 = add nsw i64 %1605, %1654
%1656 = getelementptr inbounds float, float* %1, i64 %1655
%1657 = load float, float* %1656
%1658 = fsub float %1651, %1657
%1659 = trunc i64 %1643 to i32
%1660 = mul i32 %8, %1659
%1661 = sext i32 %1660 to i64
%1662 = add nsw i64 %1605, %1661
%1663 = getelementptr inbounds float, float* %0, i64 %1662
store float %1658, float* %1663
%1664 = add i64 %1643, 1
%1665 = trunc i64 %1664 to i32
%1666 = icmp eq i32 %1429, %1665
br i1 %1666, label %1637, label %1642
1667: ; preds = %1670, %1637
%1668 = add nuw nsw i64 %1582, 1
%1669 = icmp eq i64 %1668, %1442
br i1 %1669, label %1585, label %1581
1670: ; preds = %1638, %1670
%1671 = phi i64 [ %1437, %1638 ], [ %1685, %1670 ]
%1672 = load float, float* %1641
%1673 = trunc i64 %1671 to i32
%1674 = add i32 %1673, %1435
%1675 = mul i32 %8, %1674
%1676 = sext i32 %1675 to i64
%1677 = add nsw i64 %1639, %1676
%1678 = getelementptr inbounds float, float* %1, i64 %1677
%1679 = load float, float* %1678
%1680 = fsub float %1672, %1679
%1681 = mul i32 %8, %1673
%1682 = sext i32 %1681 to i64
%1683 = add nsw i64 %1639, %1682
%1684 = getelementptr inbounds float, float* %0, i64 %1683
store float %1680, float* %1684
%1685 = add nsw i64 %1671, 1
%1686 = icmp slt i64 %1685, %1438
br i1 %1686, label %1670, label %1667
1687: ; preds = %1585, %1014, %1422
ret void
}