void dt_masks_blur_approx_weighed(float *const restrict src,
                                  float *const restrict out,
                                  float *const restrict weight, const int width,
                                  const int height) {
  float coeffs[50][20];
  for (int i = 1; i < 9; i++)
    _masks_blur_5x5_coeff(coeffs[i - 1], 0.1f * (float)(i));
  for (int i = 9; i < 16; i++)
    dt_masks_blur_9x9_coeff(coeffs[i - 1], 0.1f * (float)(i));
  for (int i = 16; i <= 50; i++)
    _masks_blur_13x13_coeff(coeffs[i - 1], 0.1f * (float)(i));
  const int w1 = width;
  const int w2 = 2 * width;
  const int w3 = 3 * width;
  const int w4 = 4 * width;
  const int w5 = 5 * width;
  const int w6 = 6 * width;
  for (int row = 6; row < height - 6; row++) {
    for (int col = 6; col < width - 6; col++) {
      const int i = row * width + col;
      const int d = MIN(50, MAX(0, ((int)(10.0f * weight[i]))));
      float *blurmat = coeffs[d - 1];
      if (d == 0)
        out[i] = src[i];
      else if (d < 9)
        out[i] = (blurmat[0] * ((src[i - w2 - 1] + src[i - w2 + 1]) +
                                (src[i - w1 - 2] + src[i - w1 + 2]) +
                                (src[i + w1 - 2] + src[i + w1 + 2]) +
                                (src[i + w2 - 1] + src[i + w2 + 1])) +
                  blurmat[1] *
                      (src[i - w2] + src[i - 2] + src[i + 2] + src[i + w2]) +
                  blurmat[2] * (src[i - w1 - 1] + src[i - w1 + 1] +
                                src[i + w1 - 1] + src[i + w1 + 1]) +
                  blurmat[3] *
                      (src[i - w1] + src[i - 1] + src[i + 1] + src[i + w1]) +
                  blurmat[4] * src[i]);
      else if (d < 16)
        out[i] =
            (blurmat[12] *
                 (src[i - w4 - 2] + src[i - w4 + 2] + src[i - w2 - 4] +
                  src[i - w2 + 4] + src[i + w2 - 4] + src[i + w2 + 4] +
                  src[i + w4 - 2] + src[i + w4 + 2]) +
             blurmat[11] *
                 (src[i - w4 - 1] + src[i - w4 + 1] + src[i - w1 - 4] +
                  src[i - w1 + 4] + src[i + w1 - 4] + src[i + w1 + 4] +
                  src[i + w4 - 1] + src[i + w4 + 1]) +
             blurmat[10] *
                 (src[i - w4] + src[i - 4] + src[i + 4] + src[i + w4]) +
             blurmat[9] * (src[i - w3 - 3] + src[i - w3 + 3] + src[i + w3 - 3] +
                           src[i + w3 + 3]) +
             blurmat[8] * (src[i - w3 - 2] + src[i - w3 + 2] + src[i - w2 - 3] +
                           src[i - w2 + 3] + src[i + w2 - 3] + src[i + w2 + 3] +
                           src[i + w3 - 2] + src[i + w3 + 2]) +
             blurmat[7] * (src[i - w3 - 1] + src[i - w3 + 1] + src[i - w1 - 3] +
                           src[i - w1 + 3] + src[i + w1 - 3] + src[i + w1 + 3] +
                           src[i + w3 - 1] + src[i + w3 + 1]) +
             blurmat[6] *
                 (src[i - w3] + src[i - 3] + src[i + 3] + src[i + w3]) +
             blurmat[5] * (src[i - w2 - 2] + src[i - w2 + 2] + src[i + w2 - 2] +
                           src[i + w2 + 2]) +
             blurmat[4] * (src[i - w2 - 1] + src[i - w2 + 1] + src[i - w1 - 2] +
                           src[i - w1 + 2] + src[i + w1 - 2] + src[i + w1 + 2] +
                           src[i + w2 - 1] + src[i + w2 + 1]) +
             blurmat[3] *
                 (src[i - w2] + src[i - 2] + src[i + 2] + src[i + w2]) +
             blurmat[2] * (src[i - w1 - 1] + src[i - w1 + 1] + src[i + w1 - 1] +
                           src[i + w1 + 1]) +
             blurmat[1] *
                 (src[i - w1] + src[i - 1] + src[i + 1] + src[i + w1]) +
             blurmat[0] * src[i]);
      else
        out[i] = (blurmat[0] *
                      (src[i - w6] + src[i - 6] + src[i + 6] + src[i + w6]) +
                  blurmat[1] * ((src[i - w5 - 3] + src[i - w5 + 3]) +
                                (src[i - w3 - 5] + src[i - w3 + 5]) +
                                (src[i + w3 - 5] + src[i + w3 + 5]) +
                                (src[i + w5 - 3] + src[i + w5 + 3])) +
                  blurmat[2] * ((src[i - w5 - 2] + src[i - w5 + 2]) +
                                (src[i - w2 - 5] + src[i - w2 + 5]) +
                                (src[i + w2 - 5] + src[i + w2 + 5]) +
                                (src[i + w5 - 2] + src[i + w5 + 2])) +
                  blurmat[3] * ((src[i - w5 - 1] + src[i - w5 + 1]) +
                                (src[i - w1 - 5] + src[i - w1 + 5]) +
                                (src[i + w1 - 5] + src[i + w1 + 5]) +
                                (src[i + w5 - 1] + src[i + w5 + 1])) +
                  blurmat[4] *
                      ((src[i - w5] + src[i - 5] + src[i + 5] + src[i + w5]) +
                       ((src[i - w4 - 3] + src[i - w4 + 3]) +
                        (src[i - w3 - 4] + src[i - w3 + 4]) +
                        (src[i + w3 - 4] + src[i + w3 + 4]) +
                        (src[i + w4 - 3] + src[i + w4 + 3]))) +
                  blurmat[5] * (src[i - w4 - 4] + src[i - w4 + 4] +
                                src[i + w4 - 4] + src[i + w4 + 4]) +
                  blurmat[6] * ((src[i - w4 - 2] + src[i - w4 + 2]) +
                                (src[i - w2 - 4] + src[i - w2 + 4]) +
                                (src[i + w2 - 4] + src[i + w2 + 4]) +
                                (src[i + w4 - 2] + src[i + w4 + 2])) +
                  blurmat[7] * ((src[i - w4 - 1] + src[i - w4 + 1]) +
                                (src[i - w1 - 4] + src[i - w1 + 4]) +
                                (src[i + w1 - 4] + src[i + w1 + 4]) +
                                (src[i + w4 - 1] + src[i + w4 + 1])) +
                  blurmat[8] *
                      (src[i - w4] + src[i - 4] + src[i + 4] + src[i + w4]) +
                  blurmat[9] * (src[i - w3 - 3] + src[i - w3 + 3] +
                                src[i + w3 - 3] + src[i + w3 + 3]) +
                  blurmat[10] * ((src[i - w3 - 2] + src[i - w3 + 2]) +
                                 (src[i - w2 - 3] + src[i - w2 + 3]) +
                                 (src[i + w2 - 3] + src[i + w2 + 3]) +
                                 (src[i + w3 - 2] + src[i + w3 + 2])) +
                  blurmat[11] * ((src[i - w3 - 1] + src[i - w3 + 1]) +
                                 (src[i - w1 - 3] + src[i - w1 + 3]) +
                                 (src[i + w1 - 3] + src[i + w1 + 3]) +
                                 (src[i + w3 - 1] + src[i + w3 + 1])) +
                  blurmat[12] *
                      (src[i - w3] + src[i - 3] + src[i + 3] + src[i + w3]) +
                  blurmat[13] * (src[i - w2 - 2] + src[i - w2 + 2] +
                                 src[i + w2 - 2] + src[i + w2 + 2]) +
                  blurmat[14] * ((src[i - w2 - 1] + src[i - w2 + 1]) +
                                 (src[i - w1 - 2] + src[i - w1 + 2]) +
                                 (src[i + w1 - 2] + src[i + w1 + 2]) +
                                 (src[i + w2 - 1] + src[i + w2 + 1])) +
                  blurmat[15] *
                      (src[i - w2] + src[i - 2] + src[i + 2] + src[i + w2]) +
                  blurmat[16] * (src[i - w1 - 1] + src[i - w1 + 1] +
                                 src[i + w1 - 1] + src[i + w1 + 1]) +
                  blurmat[17] *
                      (src[i - w1] + src[i - 1] + src[i + 1] + src[i + w1]) +
                  blurmat[18] * src[i]);
    }
  }
}


x86 assembly (clang, -O0):
<dt_masks_blur_approx_weighed>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1000,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movl   $0x1,-0xfc4(%rbp)
cmpl   $0x9,-0xfc4(%rbp)
jge    11d1 <dt_masks_blur_approx_weighed+0x81>
mov    -0xfc4(%rbp),%eax
sub    $0x1,%eax
cltq
lea    -0xfc0(%rbp),%rdi
imul   $0x50,%rax,%rax
add    %rax,%rdi
cvtsi2ssl -0xfc4(%rbp),%xmm1
ff
movss  0x1e56(%rip),%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1060 <_masks_blur_5x5_coeff@plt>
mov    -0xfc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc4(%rbp)
jmp    1178 <dt_masks_blur_approx_weighed+0x28>
movl   $0x9,-0xfc8(%rbp)
cmpl   $0x10,-0xfc8(%rbp)
jge    1234 <dt_masks_blur_approx_weighed+0xe4>
mov    -0xfc8(%rbp),%eax
sub    $0x1,%eax
cltq
lea    -0xfc0(%rbp),%rdi
imul   $0x50,%rax,%rax
add    %rax,%rdi
cvtsi2ssl -0xfc8(%rbp),%xmm1
ff
movss  0x1df3(%rip),%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1070 <dt_masks_blur_9x9_coeff@plt>
mov    -0xfc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc8(%rbp)
jmp    11db <dt_masks_blur_approx_weighed+0x8b>
movl   $0x10,-0xfcc(%rbp)
cmpl   $0x32,-0xfcc(%rbp)
jg     1297 <dt_masks_blur_approx_weighed+0x147>
mov    -0xfcc(%rbp),%eax
sub    $0x1,%eax
cltq
lea    -0xfc0(%rbp),%rdi
imul   $0x50,%rax,%rax
add    %rax,%rdi
cvtsi2ssl -0xfcc(%rbp),%xmm1
ff
movss  0x1d90(%rip),%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1040 <_masks_blur_13x13_coeff@plt>
mov    -0xfcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfcc(%rbp)
jmp    123e <dt_masks_blur_approx_weighed+0xee>
mov    -0x1c(%rbp),%eax
mov    %eax,-0xfd0(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xfd4(%rbp)
imul   $0x3,-0x1c(%rbp),%eax
mov    %eax,-0xfd8(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0xfdc(%rbp)
imul   $0x5,-0x1c(%rbp),%eax
mov    %eax,-0xfe0(%rbp)
imul   $0x6,-0x1c(%rbp),%eax
mov    %eax,-0xfe4(%rbp)
movl   $0x6,-0xfe8(%rbp)
mov    -0xfe8(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x6,%ecx
cmp    %ecx,%eax
jge    2c05 <dt_masks_blur_approx_weighed+0x1ab5>
movl   $0x6,-0xfec(%rbp)
mov    -0xfec(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x6,%ecx
cmp    %ecx,%eax
jge    2bec <dt_masks_blur_approx_weighed+0x1a9c>
mov    -0xfe8(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0xfec(%rbp),%eax
mov    %eax,-0xff0(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xff0(%rbp),%rcx
movss  0x1cc5(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%esi
xor    %edi,%edi
mov    $0x0,%al
call   1050 <MAX@plt>
mov    %eax,%esi
mov    $0x32,%edi
mov    $0x0,%al
call   1030 <MIN@plt>
mov    %eax,-0xff4(%rbp)
mov    -0xff4(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0xfc0(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x1000(%rbp)
cmpl   $0x0,-0xff4(%rbp)
jne    13b4 <dt_masks_blur_approx_weighed+0x264>
mov    -0x8(%rbp),%rax
movslq -0xff0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xff0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    2bd3 <dt_masks_blur_approx_weighed+0x1a83>
cmpl   $0x9,-0xff4(%rbp)
jge    1649 <dt_masks_blur_approx_weighed+0x4f9>
mov    -0x1000(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
addss  %xmm0,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
addss  %xmm0,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
addss  %xmm0,%xmm2
mov    -0x1000(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xff0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0xff0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    2bce <dt_masks_blur_approx_weighed+0x1a7e>
cmpl   $0x10,-0xff4(%rbp)
jge    1e5e <dt_masks_blur_approx_weighed+0xd0e>
mov    -0x1000(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x1000(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xff0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0xff0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    2bc9 <dt_masks_blur_approx_weighed+0x1a79>
mov    -0x1000(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfe4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x6,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfe4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x1000(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfe0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfe0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
addss  %xmm4,%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
addss  %xmm4,%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfe0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfe0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfe0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfe0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfe0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfe0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfe0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfe0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfe0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfe0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfe0(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfe0(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
addss  %xmm4,%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
addss  %xmm4,%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
addss  %xmm4,%xmm3
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfdc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfdc(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd8(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd8(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x3c(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x40(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x1000(%rbp),%rax
movss  0x44(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    -0xfd0(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xff0(%rbp),%ecx
add    -0xfd0(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x1000(%rbp),%rax
movss  0x48(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xff0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0xff0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    2bce <dt_masks_blur_approx_weighed+0x1a7e>
jmp    2bd3 <dt_masks_blur_approx_weighed+0x1a83>
jmp    2bd8 <dt_masks_blur_approx_weighed+0x1a88>
mov    -0xfec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfec(%rbp)
jmp    12fe <dt_masks_blur_approx_weighed+0x1ae>
jmp    2bf1 <dt_masks_blur_approx_weighed+0x1aa1>
mov    -0xfe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfe8(%rbp)
jmp    12e0 <dt_masks_blur_approx_weighed+0x190>
add    $0x1000,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dt_masks_blur_approx_weighed>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1018,%rsp
mov    %r8,0x8(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,0x68(%rsp)
mov    %rsi,0x60(%rsp)
mov    %rdi,%rbx
lea    0x70(%rsp),%rdi
movsd  0xe7b(%rip),%xmm0
mov    $0x1,%al
call   1060 <_masks_blur_5x5_coeff@plt>
lea    0xc0(%rsp),%rdi
movsd  0xe6c(%rip),%xmm0
mov    $0x1,%al
call   1060 <_masks_blur_5x5_coeff@plt>
lea    0x110(%rsp),%rdi
movsd  0xe5d(%rip),%xmm0
mov    $0x1,%al
call   1060 <_masks_blur_5x5_coeff@plt>
lea    0x160(%rsp),%rdi
movsd  0xe4e(%rip),%xmm0
mov    $0x1,%al
call   1060 <_masks_blur_5x5_coeff@plt>
lea    0x1b0(%rsp),%rdi
movsd  0xe3f(%rip),%xmm0
mov    $0x1,%al
call   1060 <_masks_blur_5x5_coeff@plt>
lea    0x200(%rsp),%rdi
movsd  0xe30(%rip),%xmm0
mov    $0x1,%al
call   1060 <_masks_blur_5x5_coeff@plt>
lea    0x250(%rsp),%rdi
movsd  0xe21(%rip),%xmm0
mov    $0x1,%al
call   1060 <_masks_blur_5x5_coeff@plt>
lea    0x2a0(%rsp),%rdi
movsd  0xe12(%rip),%xmm0
mov    $0x1,%al
call   1060 <_masks_blur_5x5_coeff@plt>
lea    0x2f0(%rsp),%rdi
movsd  0xe03(%rip),%xmm0
mov    $0x1,%al
call   1070 <dt_masks_blur_9x9_coeff@plt>
lea    0x340(%rsp),%rdi
movsd  0xdf4(%rip),%xmm0
mov    $0x1,%al
call   1070 <dt_masks_blur_9x9_coeff@plt>
lea    0x390(%rsp),%rdi
movsd  0xde5(%rip),%xmm0
mov    $0x1,%al
call   1070 <dt_masks_blur_9x9_coeff@plt>
lea    0x3e0(%rsp),%rdi
movsd  0xdd6(%rip),%xmm0
mov    $0x1,%al
call   1070 <dt_masks_blur_9x9_coeff@plt>
lea    0x430(%rsp),%rdi
movsd  0xdc7(%rip),%xmm0
mov    $0x1,%al
call   1070 <dt_masks_blur_9x9_coeff@plt>
lea    0x480(%rsp),%rdi
movsd  0xdb8(%rip),%xmm0
mov    $0x1,%al
call   1070 <dt_masks_blur_9x9_coeff@plt>
lea    0x4d0(%rsp),%rdi
movsd  0xda9(%rip),%xmm0
mov    $0x1,%al
call   1070 <dt_masks_blur_9x9_coeff@plt>
lea    0x520(%rsp),%r14
mov    $0xffffffffffffffdd,%rbp
nopl   (%rax)
lea    0x33(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0xd86(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1040 <_masks_blur_13x13_coeff@plt>
add    $0x50,%r14
inc    %rbp
jne    12e0 <dt_masks_blur_approx_weighed+0x190>
cmpl   $0xd,0x8(%rsp)
jl     1c44 <dt_masks_blur_approx_weighed+0xaf4>
mov    0x8(%rsp),%rax
add    $0xfffffffa,%eax
mov    %rax,0x8(%rsp)
mov    0x30(%rsp),%rbp
lea    0x0(%rbp,%rbp,1),%eax
lea    (%rax,%rax,2),%r8d
lea    0x0(%rbp,%rbp,4),%edx
lea    0x0(,%rbp,4),%esi
lea    0x0(%rbp,%rbp,2),%edi
lea    -0x6(%rbp),%ecx
mov    %rcx,0x58(%rsp)
movslq %esi,%rcx
mov    %rcx,0x40(%rsp)
movslq %ebp,%r15
movslq %eax,%r14
movslq %edx,%rax
mov    %rax,0x50(%rsp)
movslq %edi,%rax
mov    %rax,0x38(%rsp)
movslq %r8d,%rax
mov    %rax,0x48(%rsp)
mov    $0x6,%eax
mov    %rax,0x10(%rsp)
jmp    1399 <dt_masks_blur_approx_weighed+0x249>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x10(%rsp)
cmp    0x8(%rsp),%rax
je     1c44 <dt_masks_blur_approx_weighed+0xaf4>
cmpl   $0xd,0x30(%rsp)
jl     1380 <dt_masks_blur_approx_weighed+0x230>
mov    0x10(%rsp),%r12
imul   %r15,%r12
mov    $0x6,%r13d
jmp    13da <dt_masks_blur_approx_weighed+0x28a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rbp,4),%xmm0
mov    0x60(%rsp),%rax
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%r13
cmp    0x58(%rsp),%r13
je     1380 <dt_masks_blur_approx_weighed+0x230>
lea    (%r12,%r13,1),%rbp
mov    0x68(%rsp),%rax
movss  (%rax,%rbp,4),%xmm0
mulss  0xc8c(%rip),%xmm0
cvttss2si %xmm0,%esi
xor    %edi,%edi
xor    %eax,%eax
call   1050 <MAX@plt>
mov    $0x32,%edi
mov    %eax,%esi
xor    %eax,%eax
call   1030 <MIN@plt>
mov    %eax,%ecx
sub    $0x1,%ecx
jb     13c0 <dt_masks_blur_approx_weighed+0x270>
movslq %ecx,%rcx
lea    (%rcx,%rcx,4),%rcx
shl    $0x4,%rcx
lea    (%rsp,%rcx,1),%r8
add    $0x70,%r8
cmp    $0x8,%eax
jg     1500 <dt_masks_blur_approx_weighed+0x3b0>
mov    %rbp,%rax
sub    %r14,%rax
movss  -0x4(%rbx,%rax,4),%xmm1
movss  (%rbx,%rax,4),%xmm0
addss  0x4(%rbx,%rax,4),%xmm1
mov    %rbp,%rax
sub    %r15,%rax
movss  -0x8(%rbx,%rax,4),%xmm2
addss  0x8(%rbx,%rax,4),%xmm2
addss  %xmm1,%xmm2
lea    (%r15,%rbp,1),%rdx
movss  -0x8(%rbx,%rdx,4),%xmm3
addss  0x8(%rbx,%rdx,4),%xmm3
addss  %xmm2,%xmm3
lea    0x0(%rbp,%r14,1),%rsi
movss  -0x4(%rbx,%rsi,4),%xmm2
addss  0x4(%rbx,%rsi,4),%xmm2
movss  -0x4(%rbx,%rax,4),%xmm1
addss  %xmm3,%xmm2
addss  -0x8(%rbx,%rbp,4),%xmm0
addss  0x8(%rbx,%rbp,4),%xmm0
addss  (%rbx,%rsi,4),%xmm0
mulss  0x74(%rsp,%rcx,1),%xmm0
mulss  (%r8),%xmm2
addss  0x4(%rbx,%rax,4),%xmm1
addss  -0x4(%rbx,%rdx,4),%xmm1
addss  0x4(%rbx,%rdx,4),%xmm1
mulss  0x78(%rsp,%rcx,1),%xmm1
addss  %xmm0,%xmm2
movss  (%rbx,%rax,4),%xmm3
addss  -0x4(%rbx,%rbp,4),%xmm3
addss  0x4(%rbx,%rbp,4),%xmm3
addss  (%rbx,%rdx,4),%xmm3
addss  %xmm2,%xmm1
mulss  0x7c(%rsp,%rcx,1),%xmm3
addss  %xmm1,%xmm3
movss  0x80(%rsp,%rcx,1),%xmm0
mulss  (%rbx,%rbp,4),%xmm0
addss  %xmm3,%xmm0
jmp    13c5 <dt_masks_blur_approx_weighed+0x275>
nopl   (%rax)
cmp    $0xf,%eax
ja     177f <dt_masks_blur_approx_weighed+0x62f>
mov    %rbp,%rax
mov    0x40(%rsp),%rdx
sub    %rdx,%rax
movss  -0x8(%rbx,%rax,4),%xmm0
addss  0x8(%rbx,%rax,4),%xmm0
mov    %rbp,%rsi
sub    %r14,%rsi
addss  -0x10(%rbx,%rsi,4),%xmm0
addss  0x10(%rbx,%rsi,4),%xmm0
lea    (%r14,%rbp,1),%r10
addss  -0x10(%rbx,%r10,4),%xmm0
addss  0x10(%rbx,%r10,4),%xmm0
movss  -0x4(%rbx,%rax,4),%xmm1
lea    0x0(%rbp,%rdx,1),%rdi
addss  -0x8(%rbx,%rdi,4),%xmm0
addss  0x8(%rbx,%rdi,4),%xmm0
addss  0x4(%rbx,%rax,4),%xmm1
mov    %rbp,%rdx
sub    %r15,%rdx
addss  -0x10(%rbx,%rdx,4),%xmm1
addss  0x10(%rbx,%rdx,4),%xmm1
lea    (%r15,%rbp,1),%r9
addss  -0x10(%rbx,%r9,4),%xmm1
addss  0x10(%rbx,%r9,4),%xmm1
addss  -0x4(%rbx,%rdi,4),%xmm1
addss  0x4(%rbx,%rdi,4),%xmm1
mulss  0x9c(%rsp,%rcx,1),%xmm1
mulss  0xa0(%rsp,%rcx,1),%xmm0
movss  (%rbx,%rax,4),%xmm2
addss  -0x10(%rbx,%rbp,4),%xmm2
addss  0x10(%rbx,%rbp,4),%xmm2
addss  (%rbx,%rdi,4),%xmm2
addss  %xmm1,%xmm0
mulss  0x98(%rsp,%rcx,1),%xmm2
addss  %xmm0,%xmm2
mov    %rbp,%rax
mov    0x38(%rsp),%rdi
sub    %rdi,%rax
movss  -0xc(%rbx,%rax,4),%xmm1
addss  0xc(%rbx,%rax,4),%xmm1
movss  -0x8(%rbx,%rax,4),%xmm0
add    %rbp,%rdi
addss  -0xc(%rbx,%rdi,4),%xmm1
addss  0xc(%rbx,%rdi,4),%xmm1
mulss  0x94(%rsp,%rcx,1),%xmm1
addss  0x8(%rbx,%rax,4),%xmm0
addss  -0xc(%rbx,%rsi,4),%xmm0
addss  0xc(%rbx,%rsi,4),%xmm0
addss  -0xc(%rbx,%r10,4),%xmm0
addss  0xc(%rbx,%r10,4),%xmm0
addss  -0x8(%rbx,%rdi,4),%xmm0
addss  0x8(%rbx,%rdi,4),%xmm0
mulss  0x90(%rsp,%rcx,1),%xmm0
addss  %xmm2,%xmm1
movss  -0x4(%rbx,%rax,4),%xmm2
addss  0x4(%rbx,%rax,4),%xmm2
addss  -0xc(%rbx,%rdx,4),%xmm2
addss  0xc(%rbx,%rdx,4),%xmm2
addss  -0xc(%rbx,%r9,4),%xmm2
addss  0xc(%rbx,%r9,4),%xmm2
addss  -0x4(%rbx,%rdi,4),%xmm2
addss  0x4(%rbx,%rdi,4),%xmm2
addss  %xmm1,%xmm0
mulss  0x8c(%rsp,%rcx,1),%xmm2
movss  (%rbx,%rax,4),%xmm1
addss  -0xc(%rbx,%rbp,4),%xmm1
addss  0xc(%rbx,%rbp,4),%xmm1
addss  (%rbx,%rdi,4),%xmm1
mulss  0x88(%rsp,%rcx,1),%xmm1
addss  %xmm0,%xmm2
addss  %xmm2,%xmm1
movss  -0x8(%rbx,%rsi,4),%xmm2
movss  -0x4(%rbx,%rsi,4),%xmm0
addss  0x8(%rbx,%rsi,4),%xmm2
addss  -0x8(%rbx,%r10,4),%xmm2
addss  0x8(%rbx,%r10,4),%xmm2
mulss  0x84(%rsp,%rcx,1),%xmm2
addss  0x4(%rbx,%rsi,4),%xmm0
addss  -0x8(%rbx,%rdx,4),%xmm0
addss  0x8(%rbx,%rdx,4),%xmm0
addss  -0x8(%rbx,%r9,4),%xmm0
addss  0x8(%rbx,%r9,4),%xmm0
addss  -0x4(%rbx,%r10,4),%xmm0
addss  0x4(%rbx,%r10,4),%xmm0
mulss  0x80(%rsp,%rcx,1),%xmm0
addss  %xmm1,%xmm2
movss  (%rbx,%rsi,4),%xmm1
addss  -0x8(%rbx,%rbp,4),%xmm1
addss  0x8(%rbx,%rbp,4),%xmm1
addss  (%rbx,%r10,4),%xmm1
addss  %xmm2,%xmm0
mulss  0x7c(%rsp,%rcx,1),%xmm1
addss  %xmm0,%xmm1
movss  -0x4(%rbx,%rdx,4),%xmm0
movss  (%rbx,%rdx,4),%xmm2
addss  0x4(%rbx,%rdx,4),%xmm0
addss  -0x4(%rbx,%r9,4),%xmm0
addss  0x4(%rbx,%r9,4),%xmm0
mulss  0x78(%rsp,%rcx,1),%xmm0
addss  -0x4(%rbx,%rbp,4),%xmm2
addss  0x4(%rbx,%rbp,4),%xmm2
addss  (%rbx,%r9,4),%xmm2
addss  %xmm1,%xmm0
mulss  0x74(%rsp,%rcx,1),%xmm2
addss  %xmm0,%xmm2
movss  (%r8),%xmm0
mulss  (%rbx,%rbp,4),%xmm0
addss  %xmm2,%xmm0
jmp    13c5 <dt_masks_blur_approx_weighed+0x275>
mov    %rbp,%rax
mov    0x48(%rsp),%rdx
sub    %rdx,%rax
movss  (%rbx,%rax,4),%xmm1
addss  -0x18(%rbx,%rbp,4),%xmm1
addss  0x18(%rbx,%rbp,4),%xmm1
lea    (%rdx,%rbp,1),%rax
addss  (%rbx,%rax,4),%xmm1
mov    %rbp,%rdx
mov    0x50(%rsp),%rax
sub    %rax,%rdx
movss  -0xc(%rbx,%rdx,4),%xmm2
movss  -0x8(%rbx,%rdx,4),%xmm0
addss  0xc(%rbx,%rdx,4),%xmm2
mov    %rbp,%rsi
mov    0x38(%rsp),%rdi
sub    %rdi,%rsi
movss  -0x14(%rbx,%rsi,4),%xmm3
addss  0x14(%rbx,%rsi,4),%xmm3
addss  %xmm2,%xmm3
lea    (%rdi,%rbp,1),%r9
movss  -0x14(%rbx,%r9,4),%xmm2
addss  0x14(%rbx,%r9,4),%xmm2
addss  %xmm3,%xmm2
lea    0x0(%rbp,%rax,1),%rdi
movss  -0xc(%rbx,%rdi,4),%xmm5
addss  0xc(%rbx,%rdi,4),%xmm5
movss  -0x8(%rbx,%rdi,4),%xmm12
addss  %xmm2,%xmm5
mulss  0x74(%rsp,%rcx,1),%xmm5
mulss  (%r8),%xmm1
addss  0x8(%rbx,%rdx,4),%xmm0
mov    %rbp,%rax
sub    %r14,%rax
movss  -0x14(%rbx,%rax,4),%xmm2
addss  0x14(%rbx,%rax,4),%xmm2
lea    (%r14,%rbp,1),%r8
movss  -0x14(%rbx,%r8,4),%xmm3
addss  0x14(%rbx,%r8,4),%xmm3
addss  %xmm0,%xmm2
addss  %xmm2,%xmm3
addss  0x8(%rbx,%rdi,4),%xmm12
addss  %xmm3,%xmm12
mulss  0x78(%rsp,%rcx,1),%xmm12
movss  -0x4(%rbx,%rdx,4),%xmm0
addss  0x4(%rbx,%rdx,4),%xmm0
movss  (%rbx,%rdx,4),%xmm10
mov    %rbp,%rdx
sub    %r15,%rdx
movss  -0x14(%rbx,%rdx,4),%xmm3
addss  0x14(%rbx,%rdx,4),%xmm3
movss  -0x4(%rbx,%rdi,4),%xmm6
addss  0x4(%rbx,%rdi,4),%xmm6
addss  -0x14(%rbx,%rbp,4),%xmm10
addss  0x14(%rbx,%rbp,4),%xmm10
addss  (%rbx,%rdi,4),%xmm10
mov    %rbp,%rdi
mov    0x40(%rsp),%r10
sub    %r10,%rdi
movss  -0x10(%rbx,%rdi,4),%xmm15
movss  -0xc(%rbx,%rdi,4),%xmm2
addss  0xc(%rbx,%rdi,4),%xmm2
movss  %xmm2,0x2c(%rsp)
addss  0x10(%rbx,%rdi,4),%xmm15
movss  -0x8(%rbx,%rdi,4),%xmm2
addss  0x8(%rbx,%rdi,4),%xmm2
movss  %xmm2,0x28(%rsp)
movss  -0x4(%rbx,%rdi,4),%xmm14
addss  0x4(%rbx,%rdi,4),%xmm14
movss  (%rbx,%rdi,4),%xmm9
lea    0x0(%rbp,%r10,1),%rdi
movss  -0xc(%rbx,%rdi,4),%xmm8
movss  -0x8(%rbx,%rdi,4),%xmm13
addss  0xc(%rbx,%rdi,4),%xmm8
addss  -0x10(%rbx,%rdi,4),%xmm15
addss  0x10(%rbx,%rdi,4),%xmm15
addss  0x8(%rbx,%rdi,4),%xmm13
movss  -0x10(%rbx,%rsi,4),%xmm4
movss  -0x4(%rbx,%rdi,4),%xmm11
addss  0x4(%rbx,%rdi,4),%xmm11
addss  -0x10(%rbx,%rbp,4),%xmm9
addss  0x10(%rbx,%rbp,4),%xmm9
addss  %xmm0,%xmm3
addss  (%rbx,%rdi,4),%xmm9
lea    0x0(%rbp,%r15,1),%rdi
movss  -0x14(%rbx,%rdi,4),%xmm0
addss  0x14(%rbx,%rdi,4),%xmm0
addss  %xmm3,%xmm0
movss  -0x10(%rbx,%r9,4),%xmm2
addss  %xmm0,%xmm6
mulss  0x7c(%rsp,%rcx,1),%xmm6
movaps %xmm6,%xmm0
addss  0x10(%rbx,%rsi,4),%xmm4
addss  0x10(%rbx,%r9,4),%xmm2
movss  -0xc(%rbx,%rsi,4),%xmm6
addss  0xc(%rbx,%rsi,4),%xmm6
addss  -0xc(%rbx,%r9,4),%xmm6
addss  0xc(%rbx,%r9,4),%xmm6
movss  -0x8(%rbx,%rsi,4),%xmm3
addss  0x8(%rbx,%rsi,4),%xmm3
movss  %xmm3,0x20(%rsp)
addss  %xmm5,%xmm1
movss  -0x8(%rbx,%r9,4),%xmm7
addss  0x8(%rbx,%r9,4),%xmm7
addss  %xmm1,%xmm12
movss  -0x4(%rbx,%rsi,4),%xmm1
addss  0x4(%rbx,%rsi,4),%xmm1
movss  %xmm1,0x1c(%rsp)
addss  %xmm12,%xmm0
movss  %xmm0,0x24(%rsp)
movss  -0x4(%rbx,%r9,4),%xmm12
addss  0x4(%rbx,%r9,4),%xmm12
addss  0x2c(%rsp),%xmm4
movss  (%rbx,%rsi,4),%xmm3
addss  -0xc(%rbx,%rbp,4),%xmm3
addss  0xc(%rbx,%rbp,4),%xmm3
addss  (%rbx,%r9,4),%xmm3
addss  %xmm4,%xmm2
movss  -0x10(%rbx,%rax,4),%xmm0
addss  0x10(%rbx,%rax,4),%xmm0
addss  %xmm2,%xmm8
movss  -0x10(%rbx,%r8,4),%xmm2
addss  0x10(%rbx,%r8,4),%xmm2
addss  %xmm10,%xmm8
movss  -0x10(%rbx,%rdx,4),%xmm4
addss  0x10(%rbx,%rdx,4),%xmm4
addss  0x28(%rsp),%xmm0
movss  -0x10(%rbx,%rdi,4),%xmm1
addss  0x10(%rbx,%rdi,4),%xmm1
addss  %xmm0,%xmm2
movss  -0xc(%rbx,%rax,4),%xmm0
addss  0xc(%rbx,%rax,4),%xmm0
addss  %xmm2,%xmm13
movss  -0xc(%rbx,%r8,4),%xmm5
addss  0xc(%rbx,%r8,4),%xmm5
addss  %xmm14,%xmm4
movss  -0x8(%rbx,%rax,4),%xmm10
addss  0x8(%rbx,%rax,4),%xmm10
addss  -0x8(%rbx,%r8,4),%xmm10
addss  0x8(%rbx,%r8,4),%xmm10
addss  %xmm4,%xmm1
movss  -0x4(%rbx,%rax,4),%xmm14
addss  0x4(%rbx,%rax,4),%xmm14
addss  %xmm1,%xmm11
movss  -0x4(%rbx,%r8,4),%xmm4
addss  0x4(%rbx,%r8,4),%xmm4
addss  0x20(%rsp),%xmm0
movss  (%rbx,%rax,4),%xmm2
addss  -0x8(%rbx,%rbp,4),%xmm2
addss  0x8(%rbx,%rbp,4),%xmm2
addss  (%rbx,%r8,4),%xmm2
addss  %xmm0,%xmm5
movss  -0xc(%rbx,%rdx,4),%xmm0
addss  0xc(%rbx,%rdx,4),%xmm0
addss  %xmm5,%xmm7
movss  -0xc(%rbx,%rdi,4),%xmm1
addss  0xc(%rbx,%rdi,4),%xmm1
addss  0x1c(%rsp),%xmm0
movss  -0x8(%rbx,%rdx,4),%xmm5
addss  0x8(%rbx,%rdx,4),%xmm5
addss  %xmm0,%xmm1
movss  -0x8(%rbx,%rdi,4),%xmm0
addss  0x8(%rbx,%rdi,4),%xmm0
addss  %xmm1,%xmm12
movss  -0x4(%rbx,%rdx,4),%xmm1
addss  0x4(%rbx,%rdx,4),%xmm1
addss  -0x4(%rbx,%rdi,4),%xmm1
addss  0x4(%rbx,%rdi,4),%xmm1
addss  %xmm14,%xmm5
movss  (%rbx,%rdx,4),%xmm14
addss  -0x4(%rbx,%rbp,4),%xmm14
addss  0x4(%rbx,%rbp,4),%xmm14
addss  (%rbx,%rdi,4),%xmm14
mulss  0x80(%rsp,%rcx,1),%xmm8
mulss  0x84(%rsp,%rcx,1),%xmm15
mulss  0x88(%rsp,%rcx,1),%xmm13
mulss  0x8c(%rsp,%rcx,1),%xmm11
mulss  0x90(%rsp,%rcx,1),%xmm9
mulss  0x94(%rsp,%rcx,1),%xmm6
mulss  0x98(%rsp,%rcx,1),%xmm7
mulss  0x9c(%rsp,%rcx,1),%xmm12
mulss  0xa0(%rsp,%rcx,1),%xmm3
mulss  0xa4(%rsp,%rcx,1),%xmm10
addss  %xmm5,%xmm0
addss  %xmm0,%xmm4
mulss  0xa8(%rsp,%rcx,1),%xmm4
mulss  0xac(%rsp,%rcx,1),%xmm2
mulss  0xb0(%rsp,%rcx,1),%xmm1
mulss  0xb4(%rsp,%rcx,1),%xmm14
movss  0xb8(%rsp,%rcx,1),%xmm0
addss  0x24(%rsp),%xmm8
addss  %xmm8,%xmm15
addss  %xmm15,%xmm13
addss  %xmm13,%xmm11
addss  %xmm11,%xmm9
addss  %xmm9,%xmm6
addss  %xmm6,%xmm7
addss  %xmm7,%xmm12
addss  %xmm12,%xmm3
addss  %xmm3,%xmm10
addss  %xmm10,%xmm4
addss  %xmm4,%xmm2
addss  %xmm2,%xmm1
addss  %xmm1,%xmm14
mulss  (%rbx,%rbp,4),%xmm0
addss  %xmm14,%xmm0
jmp    13c5 <dt_masks_blur_approx_weighed+0x275>
add    $0x1018,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @dt_masks_blur_approx_weighed(float* noalias %0, float* noalias nocapture writeonly %1, float* noalias nocapture %2, i32 %3, i32 %4) {
%6 = alloca [50 x [20 x float]]
%7 = bitcast [50 x [20 x float]]* %6 to i8*
%8 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 0, i64 0
%9 = call i32 (float*, double, ...) bitcast (i32 (...)* @_masks_blur_5x5_coeff to i32 (float*, double, ...)*)(float* %8, double 0x3FB99999A0000000)
%10 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 1, i64 0
%11 = call i32 (float*, double, ...) bitcast (i32 (...)* @_masks_blur_5x5_coeff to i32 (float*, double, ...)*)(float* %10, double 0x3FC99999A0000000)
%12 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 2, i64 0
%13 = call i32 (float*, double, ...) bitcast (i32 (...)* @_masks_blur_5x5_coeff to i32 (float*, double, ...)*)(float* %12, double 0x3FD3333340000000)
%14 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 3, i64 0
%15 = call i32 (float*, double, ...) bitcast (i32 (...)* @_masks_blur_5x5_coeff to i32 (float*, double, ...)*)(float* %14, double 0x3FD99999A0000000)
%16 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 4, i64 0
%17 = call i32 (float*, double, ...) bitcast (i32 (...)* @_masks_blur_5x5_coeff to i32 (float*, double, ...)*)(float* %16, double 5.000000e-01)
%18 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 5, i64 0
%19 = call i32 (float*, double, ...) bitcast (i32 (...)* @_masks_blur_5x5_coeff to i32 (float*, double, ...)*)(float* %18, double 0x3FE3333340000000)
%20 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 6, i64 0
%21 = call i32 (float*, double, ...) bitcast (i32 (...)* @_masks_blur_5x5_coeff to i32 (float*, double, ...)*)(float* %20, double 0x3FE6666660000000)
%22 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 7, i64 0
%23 = call i32 (float*, double, ...) bitcast (i32 (...)* @_masks_blur_5x5_coeff to i32 (float*, double, ...)*)(float* %22, double 0x3FE99999A0000000)
%24 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 8, i64 0
%25 = call i32 (float*, double, ...) bitcast (i32 (...)* @dt_masks_blur_9x9_coeff to i32 (float*, double, ...)*)(float* %24, double 0x3FECCCCCE0000000)
%26 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 9, i64 0
%27 = call i32 (float*, double, ...) bitcast (i32 (...)* @dt_masks_blur_9x9_coeff to i32 (float*, double, ...)*)(float* %26, double 1.000000e+00)
%28 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 10, i64 0
%29 = call i32 (float*, double, ...) bitcast (i32 (...)* @dt_masks_blur_9x9_coeff to i32 (float*, double, ...)*)(float* %28, double 0x3FF19999A0000000)
%30 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 11, i64 0
%31 = call i32 (float*, double, ...) bitcast (i32 (...)* @dt_masks_blur_9x9_coeff to i32 (float*, double, ...)*)(float* %30, double 0x3FF3333340000000)
%32 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 12, i64 0
%33 = call i32 (float*, double, ...) bitcast (i32 (...)* @dt_masks_blur_9x9_coeff to i32 (float*, double, ...)*)(float* %32, double 0x3FF4CCCCE0000000)
%34 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 13, i64 0
%35 = call i32 (float*, double, ...) bitcast (i32 (...)* @dt_masks_blur_9x9_coeff to i32 (float*, double, ...)*)(float* %34, double 0x3FF6666660000000)
%36 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 14, i64 0
%37 = call i32 (float*, double, ...) bitcast (i32 (...)* @dt_masks_blur_9x9_coeff to i32 (float*, double, ...)*)(float* %36, double 1.500000e+00)
br label %57
38: ; preds = %57
%39 = icmp sgt i32 %4, 12
br i1 %39, label %40, label %72
40: ; preds = %38
%41 = add nsw i32 %4, -6
%42 = mul nsw i32 %3, 6
%43 = mul nsw i32 %3, 5
%44 = shl nsw i32 %3, 2
%45 = mul nsw i32 %3, 3
%46 = shl nsw i32 %3, 1
%47 = add i32 %3, -6
%48 = icmp sgt i32 %3, 12
%49 = sext i32 %44 to i64
%50 = sext i32 %3 to i64
%51 = sext i32 %46 to i64
%52 = sext i32 %43 to i64
%53 = sext i32 %45 to i64
%54 = sext i32 %42 to i64
%55 = zext i32 %41 to i64
%56 = zext i32 %47 to i64
br label %68
57: ; preds = %5, %57
%58 = phi i64 [ 16, %5 ], [ %66, %57 ]
%59 = add nsw i64 %58, -1
%60 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %59, i64 0
%61 = trunc i64 %58 to i32
%62 = sitofp i32 %61 to float
%63 = fmul float %62, 0x3FB99999A0000000
%64 = fpext float %63 to double
%65 = call i32 (float*, double, ...) bitcast (i32 (...)* @_masks_blur_13x13_coeff to i32 (float*, double, ...)*)(float* %60, double %64)
%66 = add nuw nsw i64 %58, 1
%67 = icmp eq i64 %66, 51
br i1 %67, label %38, label %57
68: ; preds = %40, %73
%69 = phi i64 [ 6, %40 ], [ %74, %73 ]
br i1 %48, label %70, label %73
70: ; preds = %68
%71 = mul nsw i64 %69, %50
br label %76
72: ; preds = %73, %38
ret void
73: ; preds = %979, %68
%74 = add nuw nsw i64 %69, 1
%75 = icmp eq i64 %74, %55
br i1 %75, label %72, label %68
76: ; preds = %70, %979
%77 = phi i64 [ 6, %70 ], [ %982, %979 ]
%78 = add nsw i64 %77, %71
%79 = getelementptr inbounds float, float* %2, i64 %78
%80 = load float, float* %79
%81 = fmul float %80, 1.000000e+01
%82 = fptosi float %81 to i32
%83 = call i32 (i32, i32, ...) bitcast (i32 (...)* @MAX to i32 (i32, i32, ...)*)(i32 0, i32 %82)
%84 = call i32 (i32, i32, ...) bitcast (i32 (...)* @MIN to i32 (i32, i32, ...)*)(i32 50, i32 %83)
%85 = add nsw i32 %84, -1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 0
%88 = icmp eq i32 %84, 0
br i1 %88, label %89, label %92
89: ; preds = %76
%90 = getelementptr inbounds float, float* %0, i64 %78
%91 = load float, float* %90
br label %979
92: ; preds = %76
%93 = icmp slt i32 %84, 9
br i1 %93, label %94, label %187
94: ; preds = %92
%95 = load float, float* %87
%96 = sub nsw i64 %78, %51
%97 = add nsw i64 %96, -1
%98 = getelementptr inbounds float, float* %0, i64 %97
%99 = load float, float* %98
%100 = add nsw i64 %96, 1
%101 = getelementptr inbounds float, float* %0, i64 %100
%102 = load float, float* %101
%103 = fadd float %99, %102
%104 = sub nsw i64 %78, %50
%105 = add nsw i64 %104, -2
%106 = getelementptr inbounds float, float* %0, i64 %105
%107 = load float, float* %106
%108 = add nsw i64 %104, 2
%109 = getelementptr inbounds float, float* %0, i64 %108
%110 = load float, float* %109
%111 = fadd float %107, %110
%112 = fadd float %103, %111
%113 = add nsw i64 %78, %50
%114 = add nsw i64 %113, -2
%115 = getelementptr inbounds float, float* %0, i64 %114
%116 = load float, float* %115
%117 = add nsw i64 %113, 2
%118 = getelementptr inbounds float, float* %0, i64 %117
%119 = load float, float* %118
%120 = fadd float %116, %119
%121 = fadd float %112, %120
%122 = add nsw i64 %78, %51
%123 = add nsw i64 %122, -1
%124 = getelementptr inbounds float, float* %0, i64 %123
%125 = load float, float* %124
%126 = add nsw i64 %122, 1
%127 = getelementptr inbounds float, float* %0, i64 %126
%128 = load float, float* %127
%129 = fadd float %125, %128
%130 = fadd float %121, %129
%131 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 1
%132 = load float, float* %131
%133 = getelementptr inbounds float, float* %0, i64 %96
%134 = load float, float* %133
%135 = add nsw i64 %78, -2
%136 = getelementptr inbounds float, float* %0, i64 %135
%137 = load float, float* %136
%138 = fadd float %134, %137
%139 = add nsw i64 %78, 2
%140 = getelementptr inbounds float, float* %0, i64 %139
%141 = load float, float* %140
%142 = fadd float %138, %141
%143 = getelementptr inbounds float, float* %0, i64 %122
%144 = load float, float* %143
%145 = fadd float %142, %144
%146 = fmul float %132, %145
%147 = call float @llvm.fmuladd.f32(float %95, float %130, float %146)
%148 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 2
%149 = load float, float* %148
%150 = add nsw i64 %104, -1
%151 = getelementptr inbounds float, float* %0, i64 %150
%152 = load float, float* %151
%153 = add nsw i64 %104, 1
%154 = getelementptr inbounds float, float* %0, i64 %153
%155 = load float, float* %154
%156 = fadd float %152, %155
%157 = add nsw i64 %113, -1
%158 = getelementptr inbounds float, float* %0, i64 %157
%159 = load float, float* %158
%160 = fadd float %156, %159
%161 = add nsw i64 %113, 1
%162 = getelementptr inbounds float, float* %0, i64 %161
%163 = load float, float* %162
%164 = fadd float %160, %163
%165 = call float @llvm.fmuladd.f32(float %149, float %164, float %147)
%166 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 3
%167 = load float, float* %166
%168 = getelementptr inbounds float, float* %0, i64 %104
%169 = load float, float* %168
%170 = add nsw i64 %78, -1
%171 = getelementptr inbounds float, float* %0, i64 %170
%172 = load float, float* %171
%173 = fadd float %169, %172
%174 = add nsw i64 %78, 1
%175 = getelementptr inbounds float, float* %0, i64 %174
%176 = load float, float* %175
%177 = fadd float %173, %176
%178 = getelementptr inbounds float, float* %0, i64 %113
%179 = load float, float* %178
%180 = fadd float %177, %179
%181 = call float @llvm.fmuladd.f32(float %167, float %180, float %165)
%182 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 4
%183 = load float, float* %182
%184 = getelementptr inbounds float, float* %0, i64 %78
%185 = load float, float* %184
%186 = call float @llvm.fmuladd.f32(float %183, float %185, float %181)
br label %979
187: ; preds = %92
%188 = icmp ult i32 %84, 16
br i1 %188, label %189, label %490
189: ; preds = %187
%190 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 12
%191 = load float, float* %190
%192 = sub nsw i64 %78, %49
%193 = add nsw i64 %192, -2
%194 = getelementptr inbounds float, float* %0, i64 %193
%195 = load float, float* %194
%196 = add nsw i64 %192, 2
%197 = getelementptr inbounds float, float* %0, i64 %196
%198 = load float, float* %197
%199 = fadd float %195, %198
%200 = sub nsw i64 %78, %51
%201 = add nsw i64 %200, -4
%202 = getelementptr inbounds float, float* %0, i64 %201
%203 = load float, float* %202
%204 = fadd float %199, %203
%205 = add nsw i64 %200, 4
%206 = getelementptr inbounds float, float* %0, i64 %205
%207 = load float, float* %206
%208 = fadd float %204, %207
%209 = add nsw i64 %78, %51
%210 = add nsw i64 %209, -4
%211 = getelementptr inbounds float, float* %0, i64 %210
%212 = load float, float* %211
%213 = fadd float %208, %212
%214 = add nsw i64 %209, 4
%215 = getelementptr inbounds float, float* %0, i64 %214
%216 = load float, float* %215
%217 = fadd float %213, %216
%218 = add nsw i64 %78, %49
%219 = add nsw i64 %218, -2
%220 = getelementptr inbounds float, float* %0, i64 %219
%221 = load float, float* %220
%222 = fadd float %217, %221
%223 = add nsw i64 %218, 2
%224 = getelementptr inbounds float, float* %0, i64 %223
%225 = load float, float* %224
%226 = fadd float %222, %225
%227 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 11
%228 = load float, float* %227
%229 = add nsw i64 %192, -1
%230 = getelementptr inbounds float, float* %0, i64 %229
%231 = load float, float* %230
%232 = add nsw i64 %192, 1
%233 = getelementptr inbounds float, float* %0, i64 %232
%234 = load float, float* %233
%235 = fadd float %231, %234
%236 = sub nsw i64 %78, %50
%237 = add nsw i64 %236, -4
%238 = getelementptr inbounds float, float* %0, i64 %237
%239 = load float, float* %238
%240 = fadd float %235, %239
%241 = add nsw i64 %236, 4
%242 = getelementptr inbounds float, float* %0, i64 %241
%243 = load float, float* %242
%244 = fadd float %240, %243
%245 = add nsw i64 %78, %50
%246 = add nsw i64 %245, -4
%247 = getelementptr inbounds float, float* %0, i64 %246
%248 = load float, float* %247
%249 = fadd float %244, %248
%250 = add nsw i64 %245, 4
%251 = getelementptr inbounds float, float* %0, i64 %250
%252 = load float, float* %251
%253 = fadd float %249, %252
%254 = add nsw i64 %218, -1
%255 = getelementptr inbounds float, float* %0, i64 %254
%256 = load float, float* %255
%257 = fadd float %253, %256
%258 = add nsw i64 %218, 1
%259 = getelementptr inbounds float, float* %0, i64 %258
%260 = load float, float* %259
%261 = fadd float %257, %260
%262 = fmul float %228, %261
%263 = call float @llvm.fmuladd.f32(float %191, float %226, float %262)
%264 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 10
%265 = load float, float* %264
%266 = getelementptr inbounds float, float* %0, i64 %192
%267 = load float, float* %266
%268 = add nsw i64 %78, -4
%269 = getelementptr inbounds float, float* %0, i64 %268
%270 = load float, float* %269
%271 = fadd float %267, %270
%272 = add nsw i64 %78, 4
%273 = getelementptr inbounds float, float* %0, i64 %272
%274 = load float, float* %273
%275 = fadd float %271, %274
%276 = getelementptr inbounds float, float* %0, i64 %218
%277 = load float, float* %276
%278 = fadd float %275, %277
%279 = call float @llvm.fmuladd.f32(float %265, float %278, float %263)
%280 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 9
%281 = load float, float* %280
%282 = sub nsw i64 %78, %53
%283 = add nsw i64 %282, -3
%284 = getelementptr inbounds float, float* %0, i64 %283
%285 = load float, float* %284
%286 = add nsw i64 %282, 3
%287 = getelementptr inbounds float, float* %0, i64 %286
%288 = load float, float* %287
%289 = fadd float %285, %288
%290 = add nsw i64 %78, %53
%291 = add nsw i64 %290, -3
%292 = getelementptr inbounds float, float* %0, i64 %291
%293 = load float, float* %292
%294 = fadd float %289, %293
%295 = add nsw i64 %290, 3
%296 = getelementptr inbounds float, float* %0, i64 %295
%297 = load float, float* %296
%298 = fadd float %294, %297
%299 = call float @llvm.fmuladd.f32(float %281, float %298, float %279)
%300 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 8
%301 = load float, float* %300
%302 = add nsw i64 %282, -2
%303 = getelementptr inbounds float, float* %0, i64 %302
%304 = load float, float* %303
%305 = add nsw i64 %282, 2
%306 = getelementptr inbounds float, float* %0, i64 %305
%307 = load float, float* %306
%308 = fadd float %304, %307
%309 = add nsw i64 %200, -3
%310 = getelementptr inbounds float, float* %0, i64 %309
%311 = load float, float* %310
%312 = fadd float %308, %311
%313 = add nsw i64 %200, 3
%314 = getelementptr inbounds float, float* %0, i64 %313
%315 = load float, float* %314
%316 = fadd float %312, %315
%317 = add nsw i64 %209, -3
%318 = getelementptr inbounds float, float* %0, i64 %317
%319 = load float, float* %318
%320 = fadd float %316, %319
%321 = add nsw i64 %209, 3
%322 = getelementptr inbounds float, float* %0, i64 %321
%323 = load float, float* %322
%324 = fadd float %320, %323
%325 = add nsw i64 %290, -2
%326 = getelementptr inbounds float, float* %0, i64 %325
%327 = load float, float* %326
%328 = fadd float %324, %327
%329 = add nsw i64 %290, 2
%330 = getelementptr inbounds float, float* %0, i64 %329
%331 = load float, float* %330
%332 = fadd float %328, %331
%333 = call float @llvm.fmuladd.f32(float %301, float %332, float %299)
%334 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 7
%335 = load float, float* %334
%336 = add nsw i64 %282, -1
%337 = getelementptr inbounds float, float* %0, i64 %336
%338 = load float, float* %337
%339 = add nsw i64 %282, 1
%340 = getelementptr inbounds float, float* %0, i64 %339
%341 = load float, float* %340
%342 = fadd float %338, %341
%343 = add nsw i64 %236, -3
%344 = getelementptr inbounds float, float* %0, i64 %343
%345 = load float, float* %344
%346 = fadd float %342, %345
%347 = add nsw i64 %236, 3
%348 = getelementptr inbounds float, float* %0, i64 %347
%349 = load float, float* %348
%350 = fadd float %346, %349
%351 = add nsw i64 %245, -3
%352 = getelementptr inbounds float, float* %0, i64 %351
%353 = load float, float* %352
%354 = fadd float %350, %353
%355 = add nsw i64 %245, 3
%356 = getelementptr inbounds float, float* %0, i64 %355
%357 = load float, float* %356
%358 = fadd float %354, %357
%359 = add nsw i64 %290, -1
%360 = getelementptr inbounds float, float* %0, i64 %359
%361 = load float, float* %360
%362 = fadd float %358, %361
%363 = add nsw i64 %290, 1
%364 = getelementptr inbounds float, float* %0, i64 %363
%365 = load float, float* %364
%366 = fadd float %362, %365
%367 = call float @llvm.fmuladd.f32(float %335, float %366, float %333)
%368 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 6
%369 = load float, float* %368
%370 = getelementptr inbounds float, float* %0, i64 %282
%371 = load float, float* %370
%372 = add nsw i64 %78, -3
%373 = getelementptr inbounds float, float* %0, i64 %372
%374 = load float, float* %373
%375 = fadd float %371, %374
%376 = add nsw i64 %78, 3
%377 = getelementptr inbounds float, float* %0, i64 %376
%378 = load float, float* %377
%379 = fadd float %375, %378
%380 = getelementptr inbounds float, float* %0, i64 %290
%381 = load float, float* %380
%382 = fadd float %379, %381
%383 = call float @llvm.fmuladd.f32(float %369, float %382, float %367)
%384 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 5
%385 = load float, float* %384
%386 = add nsw i64 %200, -2
%387 = getelementptr inbounds float, float* %0, i64 %386
%388 = load float, float* %387
%389 = add nsw i64 %200, 2
%390 = getelementptr inbounds float, float* %0, i64 %389
%391 = load float, float* %390
%392 = fadd float %388, %391
%393 = add nsw i64 %209, -2
%394 = getelementptr inbounds float, float* %0, i64 %393
%395 = load float, float* %394
%396 = fadd float %392, %395
%397 = add nsw i64 %209, 2
%398 = getelementptr inbounds float, float* %0, i64 %397
%399 = load float, float* %398
%400 = fadd float %396, %399
%401 = call float @llvm.fmuladd.f32(float %385, float %400, float %383)
%402 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 4
%403 = load float, float* %402
%404 = add nsw i64 %200, -1
%405 = getelementptr inbounds float, float* %0, i64 %404
%406 = load float, float* %405
%407 = add nsw i64 %200, 1
%408 = getelementptr inbounds float, float* %0, i64 %407
%409 = load float, float* %408
%410 = fadd float %406, %409
%411 = add nsw i64 %236, -2
%412 = getelementptr inbounds float, float* %0, i64 %411
%413 = load float, float* %412
%414 = fadd float %410, %413
%415 = add nsw i64 %236, 2
%416 = getelementptr inbounds float, float* %0, i64 %415
%417 = load float, float* %416
%418 = fadd float %414, %417
%419 = add nsw i64 %245, -2
%420 = getelementptr inbounds float, float* %0, i64 %419
%421 = load float, float* %420
%422 = fadd float %418, %421
%423 = add nsw i64 %245, 2
%424 = getelementptr inbounds float, float* %0, i64 %423
%425 = load float, float* %424
%426 = fadd float %422, %425
%427 = add nsw i64 %209, -1
%428 = getelementptr inbounds float, float* %0, i64 %427
%429 = load float, float* %428
%430 = fadd float %426, %429
%431 = add nsw i64 %209, 1
%432 = getelementptr inbounds float, float* %0, i64 %431
%433 = load float, float* %432
%434 = fadd float %430, %433
%435 = call float @llvm.fmuladd.f32(float %403, float %434, float %401)
%436 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 3
%437 = load float, float* %436
%438 = getelementptr inbounds float, float* %0, i64 %200
%439 = load float, float* %438
%440 = add nsw i64 %78, -2
%441 = getelementptr inbounds float, float* %0, i64 %440
%442 = load float, float* %441
%443 = fadd float %439, %442
%444 = add nsw i64 %78, 2
%445 = getelementptr inbounds float, float* %0, i64 %444
%446 = load float, float* %445
%447 = fadd float %443, %446
%448 = getelementptr inbounds float, float* %0, i64 %209
%449 = load float, float* %448
%450 = fadd float %447, %449
%451 = call float @llvm.fmuladd.f32(float %437, float %450, float %435)
%452 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 2
%453 = load float, float* %452
%454 = add nsw i64 %236, -1
%455 = getelementptr inbounds float, float* %0, i64 %454
%456 = load float, float* %455
%457 = add nsw i64 %236, 1
%458 = getelementptr inbounds float, float* %0, i64 %457
%459 = load float, float* %458
%460 = fadd float %456, %459
%461 = add nsw i64 %245, -1
%462 = getelementptr inbounds float, float* %0, i64 %461
%463 = load float, float* %462
%464 = fadd float %460, %463
%465 = add nsw i64 %245, 1
%466 = getelementptr inbounds float, float* %0, i64 %465
%467 = load float, float* %466
%468 = fadd float %464, %467
%469 = call float @llvm.fmuladd.f32(float %453, float %468, float %451)
%470 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 1
%471 = load float, float* %470
%472 = getelementptr inbounds float, float* %0, i64 %236
%473 = load float, float* %472
%474 = add nsw i64 %78, -1
%475 = getelementptr inbounds float, float* %0, i64 %474
%476 = load float, float* %475
%477 = fadd float %473, %476
%478 = add nsw i64 %78, 1
%479 = getelementptr inbounds float, float* %0, i64 %478
%480 = load float, float* %479
%481 = fadd float %477, %480
%482 = getelementptr inbounds float, float* %0, i64 %245
%483 = load float, float* %482
%484 = fadd float %481, %483
%485 = call float @llvm.fmuladd.f32(float %471, float %484, float %469)
%486 = load float, float* %87
%487 = getelementptr inbounds float, float* %0, i64 %78
%488 = load float, float* %487
%489 = call float @llvm.fmuladd.f32(float %486, float %488, float %485)
br label %979
490: ; preds = %187
%491 = load float, float* %87
%492 = sub nsw i64 %78, %54
%493 = getelementptr inbounds float, float* %0, i64 %492
%494 = load float, float* %493
%495 = add nsw i64 %78, -6
%496 = getelementptr inbounds float, float* %0, i64 %495
%497 = load float, float* %496
%498 = fadd float %494, %497
%499 = add nsw i64 %78, 6
%500 = getelementptr inbounds float, float* %0, i64 %499
%501 = load float, float* %500
%502 = fadd float %498, %501
%503 = add nsw i64 %78, %54
%504 = getelementptr inbounds float, float* %0, i64 %503
%505 = load float, float* %504
%506 = fadd float %502, %505
%507 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 1
%508 = load float, float* %507
%509 = sub nsw i64 %78, %52
%510 = add nsw i64 %509, -3
%511 = getelementptr inbounds float, float* %0, i64 %510
%512 = load float, float* %511
%513 = add nsw i64 %509, 3
%514 = getelementptr inbounds float, float* %0, i64 %513
%515 = load float, float* %514
%516 = fadd float %512, %515
%517 = sub nsw i64 %78, %53
%518 = add nsw i64 %517, -5
%519 = getelementptr inbounds float, float* %0, i64 %518
%520 = load float, float* %519
%521 = add nsw i64 %517, 5
%522 = getelementptr inbounds float, float* %0, i64 %521
%523 = load float, float* %522
%524 = fadd float %520, %523
%525 = fadd float %516, %524
%526 = add nsw i64 %78, %53
%527 = add nsw i64 %526, -5
%528 = getelementptr inbounds float, float* %0, i64 %527
%529 = load float, float* %528
%530 = add nsw i64 %526, 5
%531 = getelementptr inbounds float, float* %0, i64 %530
%532 = load float, float* %531
%533 = fadd float %529, %532
%534 = fadd float %525, %533
%535 = add nsw i64 %78, %52
%536 = add nsw i64 %535, -3
%537 = getelementptr inbounds float, float* %0, i64 %536
%538 = load float, float* %537
%539 = add nsw i64 %535, 3
%540 = getelementptr inbounds float, float* %0, i64 %539
%541 = load float, float* %540
%542 = fadd float %538, %541
%543 = fadd float %534, %542
%544 = fmul float %508, %543
%545 = call float @llvm.fmuladd.f32(float %491, float %506, float %544)
%546 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 2
%547 = load float, float* %546
%548 = add nsw i64 %509, -2
%549 = getelementptr inbounds float, float* %0, i64 %548
%550 = load float, float* %549
%551 = add nsw i64 %509, 2
%552 = getelementptr inbounds float, float* %0, i64 %551
%553 = load float, float* %552
%554 = fadd float %550, %553
%555 = sub nsw i64 %78, %51
%556 = add nsw i64 %555, -5
%557 = getelementptr inbounds float, float* %0, i64 %556
%558 = load float, float* %557
%559 = add nsw i64 %555, 5
%560 = getelementptr inbounds float, float* %0, i64 %559
%561 = load float, float* %560
%562 = fadd float %558, %561
%563 = fadd float %554, %562
%564 = add nsw i64 %78, %51
%565 = add nsw i64 %564, -5
%566 = getelementptr inbounds float, float* %0, i64 %565
%567 = load float, float* %566
%568 = add nsw i64 %564, 5
%569 = getelementptr inbounds float, float* %0, i64 %568
%570 = load float, float* %569
%571 = fadd float %567, %570
%572 = fadd float %563, %571
%573 = add nsw i64 %535, -2
%574 = getelementptr inbounds float, float* %0, i64 %573
%575 = load float, float* %574
%576 = add nsw i64 %535, 2
%577 = getelementptr inbounds float, float* %0, i64 %576
%578 = load float, float* %577
%579 = fadd float %575, %578
%580 = fadd float %572, %579
%581 = call float @llvm.fmuladd.f32(float %547, float %580, float %545)
%582 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 3
%583 = load float, float* %582
%584 = add nsw i64 %509, -1
%585 = getelementptr inbounds float, float* %0, i64 %584
%586 = load float, float* %585
%587 = add nsw i64 %509, 1
%588 = getelementptr inbounds float, float* %0, i64 %587
%589 = load float, float* %588
%590 = fadd float %586, %589
%591 = sub nsw i64 %78, %50
%592 = add nsw i64 %591, -5
%593 = getelementptr inbounds float, float* %0, i64 %592
%594 = load float, float* %593
%595 = add nsw i64 %591, 5
%596 = getelementptr inbounds float, float* %0, i64 %595
%597 = load float, float* %596
%598 = fadd float %594, %597
%599 = fadd float %590, %598
%600 = add nsw i64 %78, %50
%601 = add nsw i64 %600, -5
%602 = getelementptr inbounds float, float* %0, i64 %601
%603 = load float, float* %602
%604 = add nsw i64 %600, 5
%605 = getelementptr inbounds float, float* %0, i64 %604
%606 = load float, float* %605
%607 = fadd float %603, %606
%608 = fadd float %599, %607
%609 = add nsw i64 %535, -1
%610 = getelementptr inbounds float, float* %0, i64 %609
%611 = load float, float* %610
%612 = add nsw i64 %535, 1
%613 = getelementptr inbounds float, float* %0, i64 %612
%614 = load float, float* %613
%615 = fadd float %611, %614
%616 = fadd float %608, %615
%617 = call float @llvm.fmuladd.f32(float %583, float %616, float %581)
%618 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 4
%619 = load float, float* %618
%620 = getelementptr inbounds float, float* %0, i64 %509
%621 = load float, float* %620
%622 = add nsw i64 %78, -5
%623 = getelementptr inbounds float, float* %0, i64 %622
%624 = load float, float* %623
%625 = fadd float %621, %624
%626 = add nsw i64 %78, 5
%627 = getelementptr inbounds float, float* %0, i64 %626
%628 = load float, float* %627
%629 = fadd float %625, %628
%630 = getelementptr inbounds float, float* %0, i64 %535
%631 = load float, float* %630
%632 = fadd float %629, %631
%633 = sub nsw i64 %78, %49
%634 = add nsw i64 %633, -3
%635 = getelementptr inbounds float, float* %0, i64 %634
%636 = load float, float* %635
%637 = add nsw i64 %633, 3
%638 = getelementptr inbounds float, float* %0, i64 %637
%639 = load float, float* %638
%640 = fadd float %636, %639
%641 = add nsw i64 %517, -4
%642 = getelementptr inbounds float, float* %0, i64 %641
%643 = load float, float* %642
%644 = add nsw i64 %517, 4
%645 = getelementptr inbounds float, float* %0, i64 %644
%646 = load float, float* %645
%647 = fadd float %643, %646
%648 = fadd float %640, %647
%649 = add nsw i64 %526, -4
%650 = getelementptr inbounds float, float* %0, i64 %649
%651 = load float, float* %650
%652 = add nsw i64 %526, 4
%653 = getelementptr inbounds float, float* %0, i64 %652
%654 = load float, float* %653
%655 = fadd float %651, %654
%656 = fadd float %648, %655
%657 = add nsw i64 %78, %49
%658 = add nsw i64 %657, -3
%659 = getelementptr inbounds float, float* %0, i64 %658
%660 = load float, float* %659
%661 = add nsw i64 %657, 3
%662 = getelementptr inbounds float, float* %0, i64 %661
%663 = load float, float* %662
%664 = fadd float %660, %663
%665 = fadd float %656, %664
%666 = fadd float %632, %665
%667 = call float @llvm.fmuladd.f32(float %619, float %666, float %617)
%668 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 5
%669 = load float, float* %668
%670 = add nsw i64 %633, -4
%671 = getelementptr inbounds float, float* %0, i64 %670
%672 = load float, float* %671
%673 = add nsw i64 %633, 4
%674 = getelementptr inbounds float, float* %0, i64 %673
%675 = load float, float* %674
%676 = fadd float %672, %675
%677 = add nsw i64 %657, -4
%678 = getelementptr inbounds float, float* %0, i64 %677
%679 = load float, float* %678
%680 = fadd float %676, %679
%681 = add nsw i64 %657, 4
%682 = getelementptr inbounds float, float* %0, i64 %681
%683 = load float, float* %682
%684 = fadd float %680, %683
%685 = call float @llvm.fmuladd.f32(float %669, float %684, float %667)
%686 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 6
%687 = load float, float* %686
%688 = add nsw i64 %633, -2
%689 = getelementptr inbounds float, float* %0, i64 %688
%690 = load float, float* %689
%691 = add nsw i64 %633, 2
%692 = getelementptr inbounds float, float* %0, i64 %691
%693 = load float, float* %692
%694 = fadd float %690, %693
%695 = add nsw i64 %555, -4
%696 = getelementptr inbounds float, float* %0, i64 %695
%697 = load float, float* %696
%698 = add nsw i64 %555, 4
%699 = getelementptr inbounds float, float* %0, i64 %698
%700 = load float, float* %699
%701 = fadd float %697, %700
%702 = fadd float %694, %701
%703 = add nsw i64 %564, -4
%704 = getelementptr inbounds float, float* %0, i64 %703
%705 = load float, float* %704
%706 = add nsw i64 %564, 4
%707 = getelementptr inbounds float, float* %0, i64 %706
%708 = load float, float* %707
%709 = fadd float %705, %708
%710 = fadd float %702, %709
%711 = add nsw i64 %657, -2
%712 = getelementptr inbounds float, float* %0, i64 %711
%713 = load float, float* %712
%714 = add nsw i64 %657, 2
%715 = getelementptr inbounds float, float* %0, i64 %714
%716 = load float, float* %715
%717 = fadd float %713, %716
%718 = fadd float %710, %717
%719 = call float @llvm.fmuladd.f32(float %687, float %718, float %685)
%720 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 7
%721 = load float, float* %720
%722 = add nsw i64 %633, -1
%723 = getelementptr inbounds float, float* %0, i64 %722
%724 = load float, float* %723
%725 = add nsw i64 %633, 1
%726 = getelementptr inbounds float, float* %0, i64 %725
%727 = load float, float* %726
%728 = fadd float %724, %727
%729 = add nsw i64 %591, -4
%730 = getelementptr inbounds float, float* %0, i64 %729
%731 = load float, float* %730
%732 = add nsw i64 %591, 4
%733 = getelementptr inbounds float, float* %0, i64 %732
%734 = load float, float* %733
%735 = fadd float %731, %734
%736 = fadd float %728, %735
%737 = add nsw i64 %600, -4
%738 = getelementptr inbounds float, float* %0, i64 %737
%739 = load float, float* %738
%740 = add nsw i64 %600, 4
%741 = getelementptr inbounds float, float* %0, i64 %740
%742 = load float, float* %741
%743 = fadd float %739, %742
%744 = fadd float %736, %743
%745 = add nsw i64 %657, -1
%746 = getelementptr inbounds float, float* %0, i64 %745
%747 = load float, float* %746
%748 = add nsw i64 %657, 1
%749 = getelementptr inbounds float, float* %0, i64 %748
%750 = load float, float* %749
%751 = fadd float %747, %750
%752 = fadd float %744, %751
%753 = call float @llvm.fmuladd.f32(float %721, float %752, float %719)
%754 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 8
%755 = load float, float* %754
%756 = getelementptr inbounds float, float* %0, i64 %633
%757 = load float, float* %756
%758 = add nsw i64 %78, -4
%759 = getelementptr inbounds float, float* %0, i64 %758
%760 = load float, float* %759
%761 = fadd float %757, %760
%762 = add nsw i64 %78, 4
%763 = getelementptr inbounds float, float* %0, i64 %762
%764 = load float, float* %763
%765 = fadd float %761, %764
%766 = getelementptr inbounds float, float* %0, i64 %657
%767 = load float, float* %766
%768 = fadd float %765, %767
%769 = call float @llvm.fmuladd.f32(float %755, float %768, float %753)
%770 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 9
%771 = load float, float* %770
%772 = add nsw i64 %517, -3
%773 = getelementptr inbounds float, float* %0, i64 %772
%774 = load float, float* %773
%775 = add nsw i64 %517, 3
%776 = getelementptr inbounds float, float* %0, i64 %775
%777 = load float, float* %776
%778 = fadd float %774, %777
%779 = add nsw i64 %526, -3
%780 = getelementptr inbounds float, float* %0, i64 %779
%781 = load float, float* %780
%782 = fadd float %778, %781
%783 = add nsw i64 %526, 3
%784 = getelementptr inbounds float, float* %0, i64 %783
%785 = load float, float* %784
%786 = fadd float %782, %785
%787 = call float @llvm.fmuladd.f32(float %771, float %786, float %769)
%788 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 10
%789 = load float, float* %788
%790 = add nsw i64 %517, -2
%791 = getelementptr inbounds float, float* %0, i64 %790
%792 = load float, float* %791
%793 = add nsw i64 %517, 2
%794 = getelementptr inbounds float, float* %0, i64 %793
%795 = load float, float* %794
%796 = fadd float %792, %795
%797 = add nsw i64 %555, -3
%798 = getelementptr inbounds float, float* %0, i64 %797
%799 = load float, float* %798
%800 = add nsw i64 %555, 3
%801 = getelementptr inbounds float, float* %0, i64 %800
%802 = load float, float* %801
%803 = fadd float %799, %802
%804 = fadd float %796, %803
%805 = add nsw i64 %564, -3
%806 = getelementptr inbounds float, float* %0, i64 %805
%807 = load float, float* %806
%808 = add nsw i64 %564, 3
%809 = getelementptr inbounds float, float* %0, i64 %808
%810 = load float, float* %809
%811 = fadd float %807, %810
%812 = fadd float %804, %811
%813 = add nsw i64 %526, -2
%814 = getelementptr inbounds float, float* %0, i64 %813
%815 = load float, float* %814
%816 = add nsw i64 %526, 2
%817 = getelementptr inbounds float, float* %0, i64 %816
%818 = load float, float* %817
%819 = fadd float %815, %818
%820 = fadd float %812, %819
%821 = call float @llvm.fmuladd.f32(float %789, float %820, float %787)
%822 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 11
%823 = load float, float* %822
%824 = add nsw i64 %517, -1
%825 = getelementptr inbounds float, float* %0, i64 %824
%826 = load float, float* %825
%827 = add nsw i64 %517, 1
%828 = getelementptr inbounds float, float* %0, i64 %827
%829 = load float, float* %828
%830 = fadd float %826, %829
%831 = add nsw i64 %591, -3
%832 = getelementptr inbounds float, float* %0, i64 %831
%833 = load float, float* %832
%834 = add nsw i64 %591, 3
%835 = getelementptr inbounds float, float* %0, i64 %834
%836 = load float, float* %835
%837 = fadd float %833, %836
%838 = fadd float %830, %837
%839 = add nsw i64 %600, -3
%840 = getelementptr inbounds float, float* %0, i64 %839
%841 = load float, float* %840
%842 = add nsw i64 %600, 3
%843 = getelementptr inbounds float, float* %0, i64 %842
%844 = load float, float* %843
%845 = fadd float %841, %844
%846 = fadd float %838, %845
%847 = add nsw i64 %526, -1
%848 = getelementptr inbounds float, float* %0, i64 %847
%849 = load float, float* %848
%850 = add nsw i64 %526, 1
%851 = getelementptr inbounds float, float* %0, i64 %850
%852 = load float, float* %851
%853 = fadd float %849, %852
%854 = fadd float %846, %853
%855 = call float @llvm.fmuladd.f32(float %823, float %854, float %821)
%856 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 12
%857 = load float, float* %856
%858 = getelementptr inbounds float, float* %0, i64 %517
%859 = load float, float* %858
%860 = add nsw i64 %78, -3
%861 = getelementptr inbounds float, float* %0, i64 %860
%862 = load float, float* %861
%863 = fadd float %859, %862
%864 = add nsw i64 %78, 3
%865 = getelementptr inbounds float, float* %0, i64 %864
%866 = load float, float* %865
%867 = fadd float %863, %866
%868 = getelementptr inbounds float, float* %0, i64 %526
%869 = load float, float* %868
%870 = fadd float %867, %869
%871 = call float @llvm.fmuladd.f32(float %857, float %870, float %855)
%872 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 13
%873 = load float, float* %872
%874 = add nsw i64 %555, -2
%875 = getelementptr inbounds float, float* %0, i64 %874
%876 = load float, float* %875
%877 = add nsw i64 %555, 2
%878 = getelementptr inbounds float, float* %0, i64 %877
%879 = load float, float* %878
%880 = fadd float %876, %879
%881 = add nsw i64 %564, -2
%882 = getelementptr inbounds float, float* %0, i64 %881
%883 = load float, float* %882
%884 = fadd float %880, %883
%885 = add nsw i64 %564, 2
%886 = getelementptr inbounds float, float* %0, i64 %885
%887 = load float, float* %886
%888 = fadd float %884, %887
%889 = call float @llvm.fmuladd.f32(float %873, float %888, float %871)
%890 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 14
%891 = load float, float* %890
%892 = add nsw i64 %555, -1
%893 = getelementptr inbounds float, float* %0, i64 %892
%894 = load float, float* %893
%895 = add nsw i64 %555, 1
%896 = getelementptr inbounds float, float* %0, i64 %895
%897 = load float, float* %896
%898 = fadd float %894, %897
%899 = add nsw i64 %591, -2
%900 = getelementptr inbounds float, float* %0, i64 %899
%901 = load float, float* %900
%902 = add nsw i64 %591, 2
%903 = getelementptr inbounds float, float* %0, i64 %902
%904 = load float, float* %903
%905 = fadd float %901, %904
%906 = fadd float %898, %905
%907 = add nsw i64 %600, -2
%908 = getelementptr inbounds float, float* %0, i64 %907
%909 = load float, float* %908
%910 = add nsw i64 %600, 2
%911 = getelementptr inbounds float, float* %0, i64 %910
%912 = load float, float* %911
%913 = fadd float %909, %912
%914 = fadd float %906, %913
%915 = add nsw i64 %564, -1
%916 = getelementptr inbounds float, float* %0, i64 %915
%917 = load float, float* %916
%918 = add nsw i64 %564, 1
%919 = getelementptr inbounds float, float* %0, i64 %918
%920 = load float, float* %919
%921 = fadd float %917, %920
%922 = fadd float %914, %921
%923 = call float @llvm.fmuladd.f32(float %891, float %922, float %889)
%924 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 15
%925 = load float, float* %924
%926 = getelementptr inbounds float, float* %0, i64 %555
%927 = load float, float* %926
%928 = add nsw i64 %78, -2
%929 = getelementptr inbounds float, float* %0, i64 %928
%930 = load float, float* %929
%931 = fadd float %927, %930
%932 = add nsw i64 %78, 2
%933 = getelementptr inbounds float, float* %0, i64 %932
%934 = load float, float* %933
%935 = fadd float %931, %934
%936 = getelementptr inbounds float, float* %0, i64 %564
%937 = load float, float* %936
%938 = fadd float %935, %937
%939 = call float @llvm.fmuladd.f32(float %925, float %938, float %923)
%940 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 16
%941 = load float, float* %940
%942 = add nsw i64 %591, -1
%943 = getelementptr inbounds float, float* %0, i64 %942
%944 = load float, float* %943
%945 = add nsw i64 %591, 1
%946 = getelementptr inbounds float, float* %0, i64 %945
%947 = load float, float* %946
%948 = fadd float %944, %947
%949 = add nsw i64 %600, -1
%950 = getelementptr inbounds float, float* %0, i64 %949
%951 = load float, float* %950
%952 = fadd float %948, %951
%953 = add nsw i64 %600, 1
%954 = getelementptr inbounds float, float* %0, i64 %953
%955 = load float, float* %954
%956 = fadd float %952, %955
%957 = call float @llvm.fmuladd.f32(float %941, float %956, float %939)
%958 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 17
%959 = load float, float* %958
%960 = getelementptr inbounds float, float* %0, i64 %591
%961 = load float, float* %960
%962 = add nsw i64 %78, -1
%963 = getelementptr inbounds float, float* %0, i64 %962
%964 = load float, float* %963
%965 = fadd float %961, %964
%966 = add nsw i64 %78, 1
%967 = getelementptr inbounds float, float* %0, i64 %966
%968 = load float, float* %967
%969 = fadd float %965, %968
%970 = getelementptr inbounds float, float* %0, i64 %600
%971 = load float, float* %970
%972 = fadd float %969, %971
%973 = call float @llvm.fmuladd.f32(float %959, float %972, float %957)
%974 = getelementptr inbounds [50 x [20 x float]], [50 x [20 x float]]* %6, i64 0, i64 %86, i64 18
%975 = load float, float* %974
%976 = getelementptr inbounds float, float* %0, i64 %78
%977 = load float, float* %976
%978 = call float @llvm.fmuladd.f32(float %975, float %977, float %973)
br label %979
979: ; preds = %94, %490, %189, %89
%980 = phi float [ %186, %94 ], [ %978, %490 ], [ %489, %189 ], [ %91, %89 ]
%981 = getelementptr inbounds float, float* %1, i64 %78
store float %980, float* %981
%982 = add nuw nsw i64 %77, 1
%983 = icmp eq i64 %982, %56
br i1 %983, label %73, label %76
}