int dt_masks_blur_fast(float *const restrict src, float *const restrict out,
                       const int width, const int height, const float sigma,
                       const float gain, const float clip) {
  float blurmat[19];
  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;
  if (sigma <= 0.0f) {
    for (int i = 0; i < width * height; i++)
      out[i] = fmaxf(0.0f, fminf(clip, gain * src[i]));
    return 0;
  } else if (sigma <= 0.8f) {
    _masks_blur_5x5_coeff(blurmat, sigma);
    for (int row = 2; row < height - 2; row++) {
      for (int col = 2, i = row * width + col; col < width - 2; col++, i++)
        out[i] = fmaxf(
            0.0f,
            fminf(clip,
                  gain * (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])));
    }
    return 2;
  } else if (sigma <= 1.5f) {
    dt_masks_blur_9x9_coeff(blurmat, sigma);
    for (int row = 4; row < height - 4; row++) {
      for (int col = 4, i = row * width + col; col < width - 4; col++, i++)
        out[i] = fmaxf(
            0.0f,
            fminf(clip,
                  gain * (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])));
    }
    return 4;
  }
  _masks_blur_13x13_coeff(blurmat, sigma);
  for (int row = 6; row < height - 6; row++) {
    for (int col = 6, i = row * width + col; col < width - 6; col++, i++)
      out[i] = fmaxf(
          0.0f,
          fminf(clip,
                gain *
                    (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])));
  }
  return 6;
}


x86 assembly (clang, -O0):
<dt_masks_blur_fast>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
movss  %xmm1,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x88(%rbp)
imul   $0x3,-0x1c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x90(%rbp)
imul   $0x5,-0x1c(%rbp),%eax
mov    %eax,-0x94(%rbp)
imul   $0x6,-0x1c(%rbp),%eax
mov    %eax,-0x98(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x24(%rbp),%xmm0
jb     1232 <dt_masks_blur_fast+0x102>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    1226 <dt_masks_blur_fast+0xf6>
movss  -0x2c(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordss %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minss  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
xorps  %xmm1,%xmm1
maxss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    11ae <dt_masks_blur_fast+0x7e>
movl   $0x0,-0x4(%rbp)
jmp    2bef <dt_masks_blur_fast+0x1abf>
movss  0x1dc6(%rip),%xmm0
ucomiss -0x24(%rbp),%xmm0
jb     1586 <dt_masks_blur_fast+0x456>
lea    -0x80(%rbp),%rdi
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1040 <_masks_blur_5x5_coeff@plt>
movl   $0x2,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    157a <dt_masks_blur_fast+0x44a>
movl   $0x2,-0xa4(%rbp)
mov    -0xa0(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1561 <dt_masks_blur_fast+0x431>
movss  -0x2c(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
addss  %xmm0,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
addss  %xmm0,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
addss  %xmm0,%xmm4
movss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xa8(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm0,%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordss %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minss  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
xorps  %xmm1,%xmm1
maxss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1296 <dt_masks_blur_fast+0x166>
jmp    1566 <dt_masks_blur_fast+0x436>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1262 <dt_masks_blur_fast+0x132>
movl   $0x2,-0x4(%rbp)
jmp    2bef <dt_masks_blur_fast+0x1abf>
movss  0x1a76(%rip),%xmm0
ucomiss -0x24(%rbp),%xmm0
jb     1e22 <dt_masks_blur_fast+0xcf2>
lea    -0x80(%rbp),%rdi
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1050 <dt_masks_blur_9x9_coeff@plt>
movl   $0x4,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    1e16 <dt_masks_blur_fast+0xce6>
movl   $0x4,-0xb0(%rbp)
mov    -0xac(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0xb0(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb0(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    1dfd <dt_masks_blur_fast+0xccd>
movss  -0x2c(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x90(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x90(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x90(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x90(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x90(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x8c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x8c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x64(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x8c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x6c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x7c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm0,%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordss %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minss  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
xorps  %xmm1,%xmm1
maxss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    15ea <dt_masks_blur_fast+0x4ba>
jmp    1e02 <dt_masks_blur_fast+0xcd2>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    15b6 <dt_masks_blur_fast+0x486>
movl   $0x4,-0x4(%rbp)
jmp    2bef <dt_masks_blur_fast+0x1abf>
jmp    1e27 <dt_masks_blur_fast+0xcf7>
jmp    1e2c <dt_masks_blur_fast+0xcfc>
lea    -0x80(%rbp),%rdi
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1030 <_masks_blur_13x13_coeff@plt>
movl   $0x6,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x6,%ecx
cmp    %ecx,%eax
jge    2be8 <dt_masks_blur_fast+0x1ab8>
movl   $0x6,-0xbc(%rbp)
mov    -0xb8(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0xbc(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x6,%ecx
cmp    %ecx,%eax
jge    2bcf <dt_masks_blur_fast+0x1a9f>
movss  -0x2c(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    $0x6,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
movss  -0x7c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x94(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x94(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm6
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm6
addss  %xmm6,%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm6
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm6
addss  %xmm6,%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x94(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm6
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x94(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm6
addss  %xmm6,%xmm5
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x94(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x94(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x94(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x94(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x94(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x94(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x94(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x94(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x90(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm6
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm6
addss  %xmm6,%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm6
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm6
addss  %xmm6,%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x90(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm6
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x90(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm6
addss  %xmm6,%xmm5
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x6c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x90(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x90(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x90(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x90(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x90(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x90(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x64(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x90(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x90(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x4c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
addss  %xmm5,%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    -0x10(%rbp),%rax
mov    -0xc0(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm0,%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordss %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minss  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
xorps  %xmm1,%xmm1
maxss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1e7e <dt_masks_blur_fast+0xd4e>
jmp    2bd4 <dt_masks_blur_fast+0x1aa4>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1e4a <dt_masks_blur_fast+0xd1a>
movl   $0x6,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dt_masks_blur_fast>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x438,%rsp
xorps  %xmm3,%xmm3
ucomiss %xmm0,%xmm3
jae    215b <dt_masks_blur_fast+0x102b>
lea    (%rdx,%rdx,1),%r12d
movss  0x2ea7(%rip),%xmm3
ucomiss %xmm0,%xmm3
movaps %xmm2,0xb0(%rsp)
movaps %xmm1,0x170(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rdi,(%rsp)
mov    %rdx,0x18(%rsp)
jae    2178 <dt_masks_blur_fast+0x1048>
lea    (%rdx,%rdx,2),%ebx
lea    0x0(,%rdx,4),%r15d
movss  0x2e71(%rip),%xmm1
ucomiss %xmm0,%xmm1
cvtss2sd %xmm0,%xmm0
lea    0x60(%rsp),%rdi
mov    $0x1,%al
mov    %ecx,%ebp
jae    2725 <dt_masks_blur_fast+0x15f5>
call   1030 <_masks_blur_13x13_coeff@plt>
mov    (%rsp),%rcx
movaps 0x170(%rsp),%xmm8
movaps 0xb0(%rsp),%xmm7
mov    $0x6,%eax
cmp    $0xd,%ebp
jl     31bd <dt_masks_blur_fast+0x208d>
mov    %ebp,%edx
mov    0x18(%rsp),%rsi
lea    (%rsi,%rsi,4),%eax
lea    (%r12,%r12,2),%edi
add    $0xfffffffa,%edx
movss  0x60(%rsp),%xmm3
movss  0x64(%rsp),%xmm2
movss  0x68(%rsp),%xmm0
movss  0x6c(%rsp),%xmm1
movss  0x70(%rsp),%xmm4
movss  0x74(%rsp),%xmm5
movss  0x78(%rsp),%xmm9
movaps %xmm9,0x160(%rsp)
movss  0x7c(%rsp),%xmm10
movaps %xmm10,0x150(%rsp)
movslq %r15d,%r8
movslq %esi,%r9
movslq %r12d,%r10
movslq %eax,%rbp
movslq %ebx,%r11
mov    %rsi,%rbx
movslq %edi,%rax
add    $0x6,%edi
mov    %edi,0x48(%rsp)
add    $0xfffffff3,%esi
mov    %rax,0x230(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rdi,0x220(%rsp)
mov    %rbp,0x250(%rsp)
lea    0x0(,%rbp,4),%rax
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rdi,0x210(%rsp)
mov    %r11,0x240(%rsp)
lea    0x0(,%r11,4),%rax
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rdi,0x200(%rsp)
mov    %r10,0x260(%rsp)
lea    0x0(,%r10,4),%rax
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rdi,0x1f0(%rsp)
mov    %r9,0x38(%rsp)
lea    0x0(,%r9,4),%rax
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rdi,0x1e0(%rsp)
mov    %r8,0x40(%rsp)
lea    0x0(,%r8,4),%rax
sub    %rax,%rcx
mov    %rcx,0x1d0(%rsp)
mov    %rsi,0x2f0(%rsp)
lea    0x1(%rsi),%rax
mov    %rax,0x338(%rsp)
and    $0xfffffffffffffffc,%rax
movaps %xmm2,%xmm6
shufps $0x0,%xmm2,%xmm6
movaps %xmm6,0xd0(%rsp)
movaps %xmm3,%xmm6
shufps $0x0,%xmm3,%xmm6
movaps %xmm6,0x2e0(%rsp)
movaps %xmm0,0x1c0(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x2d0(%rsp)
movaps %xmm1,0x370(%rsp)
shufps $0x0,%xmm1,%xmm1
movaps %xmm1,0x2c0(%rsp)
movaps %xmm4,0x360(%rsp)
shufps $0x0,%xmm4,%xmm4
movaps %xmm4,0x2b0(%rsp)
movaps %xmm5,0x350(%rsp)
movaps %xmm5,%xmm12
shufps $0x0,%xmm5,%xmm12
movaps %xmm9,%xmm14
shufps $0x0,%xmm9,%xmm14
movaps %xmm10,%xmm9
shufps $0x0,%xmm10,%xmm9
movss  0x80(%rsp),%xmm0
movaps %xmm0,0x1b0(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x2a0(%rsp)
movss  0x84(%rsp),%xmm0
movaps %xmm0,0x1a0(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x290(%rsp)
movss  0x88(%rsp),%xmm0
movaps %xmm0,0x190(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x280(%rsp)
movss  0x8c(%rsp),%xmm0
movaps %xmm0,0x140(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x270(%rsp)
movss  0x90(%rsp),%xmm0
movaps %xmm0,0x130(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x400(%rsp)
movss  0x94(%rsp),%xmm0
movaps %xmm0,0x120(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x3f0(%rsp)
movss  0x98(%rsp),%xmm0
movaps %xmm0,0x110(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x3e0(%rsp)
movss  0x9c(%rsp),%xmm0
movaps %xmm0,0x100(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x3d0(%rsp)
movss  0xa0(%rsp),%xmm0
movaps %xmm0,0xf0(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x3c0(%rsp)
movss  0xa4(%rsp),%xmm0
movaps %xmm0,0x180(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x3b0(%rsp)
movss  0xa8(%rsp),%xmm0
movaps %xmm0,0xe0(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x3a0(%rsp)
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
movaps %xmm0,0x390(%rsp)
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
movaps %xmm0,0x380(%rsp)
mov    %rax,0x330(%rsp)
lea    0x6(%rax),%eax
mov    %eax,0xc8(%rsp)
lea    -0x6(%rbx),%eax
mov    %eax,0xcc(%rsp)
mov    $0x6,%eax
mov    %edx,0xc(%rsp)
movaps %xmm2,0x420(%rsp)
movaps %xmm3,0x410(%rsp)
movaps %xmm9,0x320(%rsp)
movaps %xmm12,0x310(%rsp)
movaps %xmm14,0x300(%rsp)
movaps 0x3d0(%rsp),%xmm9
movaps 0x3c0(%rsp),%xmm12
movaps 0x3b0(%rsp),%xmm14
jmp    157f <dt_masks_blur_fast+0x44f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xc0(%rsp),%eax
add    $0x1,%eax
mov    0x18(%rsp),%rbx
add    %ebx,0x48(%rsp)
mov    0xc(%rsp),%edx
cmp    %edx,%eax
je     31b1 <dt_masks_blur_fast+0x2081>
mov    %eax,0xc0(%rsp)
cmp    $0xd,%ebx
jl     1560 <dt_masks_blur_fast+0x430>
movslq 0x48(%rsp),%r13
mov    $0x6,%eax
cmpl   $0x3,0x2f0(%rsp)
03
jae    15d0 <dt_masks_blur_fast+0x4a0>
movaps 0x1c0(%rsp),%xmm13
movaps 0x370(%rsp),%xmm11
movaps 0x360(%rsp),%xmm15
movaps 0x350(%rsp),%xmm10
jmp    1bed <dt_masks_blur_fast+0xabd>
nopl   0x0(%rax,%rax,1)
mov    0x230(%rsp),%rax
add    %r13,%rax
mov    0x240(%rsp),%rcx
lea    (%rcx,%r13,1),%rdx
mov    0x250(%rsp),%rcx
lea    (%rcx,%r13,1),%rbp
mov    0x260(%rsp),%rcx
lea    (%rcx,%r13,1),%rbx
mov    0x38(%rsp),%rcx
lea    (%rcx,%r13,1),%r12
mov    0x40(%rsp),%rcx
lea    (%rcx,%r13,1),%rcx
mov    %rcx,0x20(%rsp)
mov    0x220(%rsp),%rcx
lea    (%rcx,%r13,4),%rcx
mov    %rcx,0x340(%rsp)
mov    (%rsp),%r11
lea    (%r11,%r13,4),%rsi
lea    (%r11,%rax,4),%rax
mov    %rax,0x50(%rsp)
mov    0x210(%rsp),%rax
lea    (%rax,%r13,4),%rcx
mov    0x200(%rsp),%rax
lea    (%rax,%r13,4),%r10
lea    (%r11,%rdx,4),%r8
lea    (%r11,%rbp,4),%r9
mov    0x1f0(%rsp),%rax
lea    (%rax,%r13,4),%r15
mov    %r13,%rdi
lea    (%r11,%rbx,4),%r13
mov    0x1e0(%rsp),%rax
lea    (%rax,%rdi,4),%r14
lea    (%r11,%r12,4),%rax
mov    0x1d0(%rsp),%rdx
lea    (%rdx,%rdi,4),%r12
mov    0x20(%rsp),%rdx
lea    (%r11,%rdx,4),%r11
mov    0x10(%rsp),%rdx
lea    (%rdx,%rdi,4),%rdx
mov    %rdx,0x20(%rsp)
mov    0x330(%rsp),%rbp
add    %rbp,%rdi
mov    %rdi,0x348(%rsp)
mov    0x340(%rsp),%rdi
xor    %edx,%edx
movaps 0x400(%rsp),%xmm15
movaps 0x3f0(%rsp),%xmm10
movaps 0x3e0(%rsp),%xmm2
movaps 0x3a0(%rsp),%xmm3
movaps 0x390(%rsp),%xmm11
movaps 0x380(%rsp),%xmm13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%rdx,4),%xmm4
movups -0x18(%rsi,%rdx,4),%xmm5
addps  %xmm4,%xmm5
movups -0x14(%rsi,%rdx,4),%xmm7
movups 0x18(%rsi,%rdx,4),%xmm4
addps  %xmm5,%xmm4
mov    0x50(%rsp),%rbx
movups (%rbx,%rdx,4),%xmm6
addps  %xmm4,%xmm6
mulps  0x2e0(%rsp),%xmm6
movups 0xc(%rcx,%rdx,4),%xmm4
movups -0xc(%rcx,%rdx,4),%xmm5
addps  %xmm4,%xmm5
movups (%rcx,%rdx,4),%xmm4
addps  %xmm7,%xmm4
movups 0x14(%r10,%rdx,4),%xmm7
movups -0x14(%r10,%rdx,4),%xmm8
addps  %xmm7,%xmm8
addps  %xmm5,%xmm8
movups 0x14(%r8,%rdx,4),%xmm5
movups -0x14(%r8,%rdx,4),%xmm7
addps  %xmm5,%xmm7
addps  %xmm8,%xmm7
movups 0xc(%r9,%rdx,4),%xmm0
movups -0xc(%r9,%rdx,4),%xmm5
addps  %xmm0,%xmm5
movups -0x8(%rcx,%rdx,4),%xmm0
addps  %xmm7,%xmm5
mulps  0xd0(%rsp),%xmm5
addps  %xmm6,%xmm5
movups 0x8(%rcx,%rdx,4),%xmm6
addps  %xmm0,%xmm6
movups 0x14(%r15,%rdx,4),%xmm0
movups -0x14(%r15,%rdx,4),%xmm7
addps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movups 0x14(%r13,%rdx,4),%xmm0
movups -0x14(%r13,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups -0x8(%r9,%rdx,4),%xmm0
addps  %xmm7,%xmm1
movups 0x8(%r9,%rdx,4),%xmm6
addps  %xmm0,%xmm6
movups -0x4(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm6
mulps  0x2d0(%rsp),%xmm6
addps  %xmm5,%xmm6
movups 0x4(%rcx,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups 0x14(%r14,%rdx,4),%xmm0
movups -0x14(%r14,%rdx,4),%xmm5
addps  %xmm0,%xmm5
addps  %xmm1,%xmm5
movups 0x14(%rax,%rdx,4),%xmm0
movups -0x14(%rax,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups -0x4(%r9,%rdx,4),%xmm0
addps  %xmm5,%xmm1
movups 0x4(%r9,%rdx,4),%xmm5
addps  %xmm0,%xmm5
movups -0x10(%r10,%rdx,4),%xmm0
addps  %xmm1,%xmm5
movups (%r9,%rdx,4),%xmm1
mulps  0x2c0(%rsp),%xmm5
addps  %xmm6,%xmm5
movups 0x14(%rsi,%rdx,4),%xmm6
addps  %xmm4,%xmm6
addps  %xmm1,%xmm6
movups 0xc(%r12,%rdx,4),%xmm1
movups -0xc(%r12,%rdx,4),%xmm4
addps  %xmm1,%xmm4
movups 0x10(%r10,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups -0x10(%r8,%rdx,4),%xmm0
addps  %xmm4,%xmm1
movups 0x10(%r8,%rdx,4),%xmm4
addps  %xmm0,%xmm4
addps  %xmm1,%xmm4
movups 0xc(%r11,%rdx,4),%xmm0
movups -0xc(%r11,%rdx,4),%xmm1
addps  %xmm0,%xmm1
addps  %xmm4,%xmm1
movups -0x10(%r15,%rdx,4),%xmm0
addps  %xmm6,%xmm1
movups -0x10(%r12,%rdx,4),%xmm4
mulps  0x2b0(%rsp),%xmm1
addps  %xmm5,%xmm1
movups 0x10(%r12,%rdx,4),%xmm5
addps  %xmm4,%xmm5
movups -0x10(%r11,%rdx,4),%xmm4
addps  %xmm4,%xmm5
movups 0x10(%r11,%rdx,4),%xmm4
addps  %xmm5,%xmm4
movups -0x8(%r12,%rdx,4),%xmm5
mulps  0x310(%rsp),%xmm4
addps  %xmm1,%xmm4
movups 0x8(%r12,%rdx,4),%xmm1
addps  %xmm5,%xmm1
movups 0x10(%r15,%rdx,4),%xmm5
addps  %xmm0,%xmm5
movups -0x10(%r13,%rdx,4),%xmm0
addps  %xmm1,%xmm5
movups 0x10(%r13,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups -0x8(%r11,%rdx,4),%xmm0
addps  %xmm5,%xmm1
movups 0x8(%r11,%rdx,4),%xmm5
addps  %xmm0,%xmm5
movups -0x10(%r14,%rdx,4),%xmm0
addps  %xmm1,%xmm5
movups -0x4(%r12,%rdx,4),%xmm1
mulps  0x300(%rsp),%xmm5
addps  %xmm4,%xmm5
movups 0x4(%r12,%rdx,4),%xmm4
addps  %xmm1,%xmm4
movups 0x10(%r14,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups -0x10(%rax,%rdx,4),%xmm0
addps  %xmm4,%xmm1
movups 0x10(%rax,%rdx,4),%xmm4
addps  %xmm0,%xmm4
movups -0x4(%r11,%rdx,4),%xmm0
addps  %xmm1,%xmm4
movups 0x4(%r11,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups -0x10(%rsi,%rdx,4),%xmm0
addps  %xmm4,%xmm1
movups -0xc(%r10,%rdx,4),%xmm4
mulps  0x320(%rsp),%xmm1
addps  %xmm5,%xmm1
movups (%r12,%rdx,4),%xmm5
addps  %xmm0,%xmm5
movups 0x10(%rsi,%rdx,4),%xmm0
addps  %xmm5,%xmm0
movups (%r11,%rdx,4),%xmm5
addps  %xmm0,%xmm5
movups -0x8(%r10,%rdx,4),%xmm0
mulps  0x2a0(%rsp),%xmm5
addps  %xmm1,%xmm5
movups 0xc(%r10,%rdx,4),%xmm1
addps  %xmm4,%xmm1
movups -0xc(%r8,%rdx,4),%xmm4
addps  %xmm4,%xmm1
movups 0xc(%r8,%rdx,4),%xmm4
addps  %xmm1,%xmm4
movups -0xc(%r15,%rdx,4),%xmm1
mulps  0x290(%rsp),%xmm4
addps  %xmm5,%xmm4
movups 0x8(%r10,%rdx,4),%xmm5
addps  %xmm0,%xmm5
movups 0xc(%r15,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups -0xc(%r13,%rdx,4),%xmm1
addps  %xmm5,%xmm0
movups 0xc(%r13,%rdx,4),%xmm5
addps  %xmm1,%xmm5
movups -0x8(%r8,%rdx,4),%xmm1
addps  %xmm0,%xmm5
movups 0x8(%r8,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups -0xc(%r14,%rdx,4),%xmm1
addps  %xmm5,%xmm0
mulps  0x280(%rsp),%xmm0
addps  %xmm4,%xmm0
movups -0x4(%r10,%rdx,4),%xmm4
movups 0x4(%r10,%rdx,4),%xmm5
addps  %xmm4,%xmm5
movups 0xc(%r14,%rdx,4),%xmm4
addps  %xmm1,%xmm4
movups -0xc(%rax,%rdx,4),%xmm1
addps  %xmm5,%xmm4
movups 0xc(%rax,%rdx,4),%xmm5
addps  %xmm1,%xmm5
addps  %xmm4,%xmm5
movups -0x4(%r8,%rdx,4),%xmm1
movups 0x4(%r8,%rdx,4),%xmm4
addps  %xmm1,%xmm4
movups -0xc(%rsi,%rdx,4),%xmm1
addps  %xmm5,%xmm4
movups -0x8(%r15,%rdx,4),%xmm5
mulps  0x270(%rsp),%xmm4
addps  %xmm0,%xmm4
movups (%r10,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups 0xc(%rsi,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups (%r8,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups -0x8(%r13,%rdx,4),%xmm1
mulps  %xmm15,%xmm0
addps  %xmm4,%xmm0
movups 0x8(%r15,%rdx,4),%xmm4
addps  %xmm5,%xmm4
movups -0x8(%r14,%rdx,4),%xmm5
addps  %xmm1,%xmm4
movups 0x8(%r13,%rdx,4),%xmm1
addps  %xmm4,%xmm1
mulps  %xmm10,%xmm1
addps  %xmm0,%xmm1
movups -0x4(%r15,%rdx,4),%xmm0
movups 0x4(%r15,%rdx,4),%xmm4
addps  %xmm0,%xmm4
movups 0x8(%r14,%rdx,4),%xmm0
addps  %xmm5,%xmm0
movups -0x8(%rax,%rdx,4),%xmm5
addps  %xmm4,%xmm0
movups 0x8(%rax,%rdx,4),%xmm4
addps  %xmm5,%xmm4
addps  %xmm0,%xmm4
movups -0x4(%r13,%rdx,4),%xmm0
movups 0x4(%r13,%rdx,4),%xmm5
addps  %xmm0,%xmm5
addps  %xmm4,%xmm5
mulps  %xmm2,%xmm5
addps  %xmm1,%xmm5
movups (%r15,%rdx,4),%xmm0
movups -0x8(%rsi,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups 0x8(%rsi,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x0(%r13,%rdx,4),%xmm1
addps  %xmm0,%xmm1
mulps  %xmm9,%xmm1
addps  %xmm5,%xmm1
movups -0x4(%r14,%rdx,4),%xmm0
movups 0x4(%r14,%rdx,4),%xmm4
addps  %xmm0,%xmm4
movups -0x4(%rax,%rdx,4),%xmm0
addps  %xmm4,%xmm0
movups 0x4(%rax,%rdx,4),%xmm4
addps  %xmm0,%xmm4
mulps  %xmm12,%xmm4
addps  %xmm1,%xmm4
movups (%r14,%rdx,4),%xmm0
movups -0x4(%rsi,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups 0x4(%rsi,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups (%rax,%rdx,4),%xmm1
addps  %xmm0,%xmm1
mulps  %xmm14,%xmm1
addps  %xmm4,%xmm1
movups (%rsi,%rdx,4),%xmm0
mulps  %xmm3,%xmm0
addps  %xmm1,%xmm0
mulps  %xmm11,%xmm0
movaps %xmm13,%xmm1
cmpunordps %xmm13,%xmm1
movaps %xmm0,%xmm4
andps  %xmm1,%xmm4
minps  %xmm13,%xmm0
andnps %xmm0,%xmm1
orps   %xmm4,%xmm1
xorps  %xmm0,%xmm0
maxps  %xmm1,%xmm0
cmpordps %xmm1,%xmm1
andps  %xmm0,%xmm1
mov    0x20(%rsp),%rbx
movups %xmm1,(%rbx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    1700 <dt_masks_blur_fast+0x5d0>
mov    0xc8(%rsp),%eax
cmp    %rbp,0x338(%rsp)
movaps 0xb0(%rsp),%xmm7
movaps 0x170(%rsp),%xmm8
movaps 0x410(%rsp),%xmm3
movaps 0x420(%rsp),%xmm2
movaps 0x1c0(%rsp),%xmm13
movaps 0x370(%rsp),%xmm11
movaps 0x360(%rsp),%xmm15
movaps 0x350(%rsp),%xmm10
mov    0x348(%rsp),%r13
je     1560 <dt_masks_blur_fast+0x430>
mov    0xcc(%rsp),%ecx
mov    %ecx,%r10d
sub    %eax,%r10d
mov    0x220(%rsp),%rax
lea    (%rax,%r13,4),%rax
mov    %rax,0x50(%rsp)
mov    (%rsp),%r8
lea    (%r8,%r13,4),%rdx
mov    0x230(%rsp),%rax
add    %r13,%rax
lea    (%r8,%rax,4),%rax
mov    %rax,0x20(%rsp)
mov    0x210(%rsp),%rax
lea    (%rax,%r13,4),%r11
mov    0x200(%rsp),%rax
lea    (%rax,%r13,4),%r9
mov    0x240(%rsp),%rax
lea    (%rax,%r13,1),%rax
lea    (%r8,%rax,4),%rbp
mov    0x250(%rsp),%rax
lea    (%rax,%r13,1),%rax
lea    (%r8,%rax,4),%r14
mov    0x1f0(%rsp),%rax
lea    (%rax,%r13,4),%rsi
mov    0x260(%rsp),%rax
lea    (%rax,%r13,1),%rax
lea    (%r8,%rax,4),%rax
mov    0x1e0(%rsp),%rcx
lea    (%rcx,%r13,4),%rdi
mov    0x38(%rsp),%rcx
add    %r13,%rcx
lea    (%r8,%rcx,4),%rcx
mov    0x1d0(%rsp),%rbx
lea    (%rbx,%r13,4),%r15
mov    0x40(%rsp),%rbx
add    %r13,%rbx
lea    (%r8,%rbx,4),%r12
mov    0x10(%rsp),%rbx
lea    (%rbx,%r13,4),%r13
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rbx
movss  (%rbx,%r8,4),%xmm5
addss  -0x18(%rdx,%r8,4),%xmm5
addss  0x18(%rdx,%r8,4),%xmm5
mov    0x20(%rsp),%rbx
addss  (%rbx,%r8,4),%xmm5
movss  -0xc(%r11,%r8,4),%xmm0
addss  0xc(%r11,%r8,4),%xmm0
movss  -0x8(%r11,%r8,4),%xmm1
movss  -0x14(%r9,%r8,4),%xmm4
addss  0x14(%r9,%r8,4),%xmm4
addss  %xmm0,%xmm4
movss  -0x14(%rbp,%r8,4),%xmm0
addss  0x14(%rbp,%r8,4),%xmm0
addss  %xmm4,%xmm0
movss  -0xc(%r14,%r8,4),%xmm6
addss  0xc(%r14,%r8,4),%xmm6
addss  %xmm0,%xmm6
movss  -0x10(%r9,%r8,4),%xmm4
mulss  %xmm2,%xmm6
mulss  %xmm3,%xmm5
addss  %xmm6,%xmm5
addss  0x8(%r11,%r8,4),%xmm1
movss  -0x14(%rsi,%r8,4),%xmm0
addss  0x14(%rsi,%r8,4),%xmm0
addss  %xmm1,%xmm0
movss  -0x14(%rax,%r8,4),%xmm1
addss  0x14(%rax,%r8,4),%xmm1
addss  %xmm0,%xmm1
movss  -0x8(%r14,%r8,4),%xmm0
addss  0x8(%r14,%r8,4),%xmm0
addss  %xmm1,%xmm0
mulss  %xmm13,%xmm0
addss  %xmm5,%xmm0
movss  -0x4(%r11,%r8,4),%xmm1
addss  0x4(%r11,%r8,4),%xmm1
movss  -0x14(%rdi,%r8,4),%xmm5
addss  0x14(%rdi,%r8,4),%xmm5
addss  %xmm1,%xmm5
movss  -0x14(%rcx,%r8,4),%xmm1
addss  0x14(%rcx,%r8,4),%xmm1
addss  %xmm5,%xmm1
movss  -0x4(%r14,%r8,4),%xmm5
addss  0x4(%r14,%r8,4),%xmm5
addss  %xmm1,%xmm5
movss  -0x10(%rbp,%r8,4),%xmm1
mulss  %xmm11,%xmm5
addss  %xmm0,%xmm5
movss  -0xc(%r15,%r8,4),%xmm0
addss  0xc(%r15,%r8,4),%xmm0
addss  0x10(%r9,%r8,4),%xmm4
addss  %xmm0,%xmm4
movss  -0x10(%rsi,%r8,4),%xmm6
addss  0x10(%rbp,%r8,4),%xmm1
addss  %xmm4,%xmm1
movss  -0xc(%r12,%r8,4),%xmm0
addss  0xc(%r12,%r8,4),%xmm0
addss  %xmm1,%xmm0
movss  (%r11,%r8,4),%xmm1
addss  -0x14(%rdx,%r8,4),%xmm1
addss  0x14(%rdx,%r8,4),%xmm1
addss  (%r14,%r8,4),%xmm1
addss  %xmm1,%xmm0
movss  -0x10(%r15,%r8,4),%xmm1
mulss  %xmm15,%xmm0
addss  %xmm5,%xmm0
addss  0x10(%r15,%r8,4),%xmm1
addss  -0x10(%r12,%r8,4),%xmm1
movss  -0x10(%rax,%r8,4),%xmm4
addss  0x10(%r12,%r8,4),%xmm1
mulss  %xmm10,%xmm1
addss  %xmm0,%xmm1
movss  -0x8(%r15,%r8,4),%xmm0
addss  0x8(%r15,%r8,4),%xmm0
addss  0x10(%rsi,%r8,4),%xmm6
addss  %xmm0,%xmm6
movss  -0x10(%rdi,%r8,4),%xmm0
addss  0x10(%rax,%r8,4),%xmm4
addss  %xmm6,%xmm4
movss  -0x8(%r12,%r8,4),%xmm5
addss  0x8(%r12,%r8,4),%xmm5
addss  %xmm4,%xmm5
mulss  0x160(%rsp),%xmm5
addss  %xmm1,%xmm5
movss  -0x4(%r15,%r8,4),%xmm1
addss  0x4(%r15,%r8,4),%xmm1
movss  -0x10(%rcx,%r8,4),%xmm4
addss  0x10(%rdi,%r8,4),%xmm0
addss  %xmm1,%xmm0
addss  0x10(%rcx,%r8,4),%xmm4
addss  %xmm0,%xmm4
movss  -0x4(%r12,%r8,4),%xmm0
addss  0x4(%r12,%r8,4),%xmm0
addss  %xmm4,%xmm0
mulss  0x150(%rsp),%xmm0
addss  %xmm5,%xmm0
movss  (%r15,%r8,4),%xmm1
addss  -0x10(%rdx,%r8,4),%xmm1
addss  0x10(%rdx,%r8,4),%xmm1
addss  (%r12,%r8,4),%xmm1
mulss  0x1b0(%rsp),%xmm1
movss  -0xc(%r9,%r8,4),%xmm4
addss  0xc(%r9,%r8,4),%xmm4
addss  -0xc(%rbp,%r8,4),%xmm4
addss  0xc(%rbp,%r8,4),%xmm4
addss  %xmm0,%xmm1
movss  -0x8(%r9,%r8,4),%xmm0
addss  0x8(%r9,%r8,4),%xmm0
mulss  0x1a0(%rsp),%xmm4
movss  -0xc(%rsi,%r8,4),%xmm5
addss  0xc(%rsi,%r8,4),%xmm5
addss  %xmm1,%xmm4
movss  -0xc(%rax,%r8,4),%xmm1
addss  0xc(%rax,%r8,4),%xmm1
addss  %xmm0,%xmm5
movss  -0x8(%rbp,%r8,4),%xmm0
addss  0x8(%rbp,%r8,4),%xmm0
addss  %xmm5,%xmm1
addss  %xmm1,%xmm0
mulss  0x190(%rsp),%xmm0
addss  %xmm4,%xmm0
movss  -0x4(%r9,%r8,4),%xmm1
addss  0x4(%r9,%r8,4),%xmm1
movss  -0xc(%rdi,%r8,4),%xmm4
addss  0xc(%rdi,%r8,4),%xmm4
addss  %xmm1,%xmm4
movss  -0xc(%rcx,%r8,4),%xmm1
addss  0xc(%rcx,%r8,4),%xmm1
addss  %xmm4,%xmm1
movss  -0x4(%rbp,%r8,4),%xmm5
addss  0x4(%rbp,%r8,4),%xmm5
addss  %xmm1,%xmm5
mulss  0x140(%rsp),%xmm5
addss  %xmm0,%xmm5
movss  (%r9,%r8,4),%xmm0
addss  -0xc(%rdx,%r8,4),%xmm0
addss  0xc(%rdx,%r8,4),%xmm0
addss  0x0(%rbp,%r8,4),%xmm0
mulss  0x130(%rsp),%xmm0
movss  -0x8(%rsi,%r8,4),%xmm4
addss  0x8(%rsi,%r8,4),%xmm4
addss  -0x8(%rax,%r8,4),%xmm4
addss  0x8(%rax,%r8,4),%xmm4
addss  %xmm5,%xmm0
movss  -0x4(%rsi,%r8,4),%xmm1
addss  0x4(%rsi,%r8,4),%xmm1
mulss  0x120(%rsp),%xmm4
movss  -0x8(%rdi,%r8,4),%xmm5
addss  0x8(%rdi,%r8,4),%xmm5
addss  %xmm0,%xmm4
movss  -0x8(%rcx,%r8,4),%xmm0
addss  0x8(%rcx,%r8,4),%xmm0
addss  %xmm1,%xmm5
movss  -0x4(%rax,%r8,4),%xmm1
addss  0x4(%rax,%r8,4),%xmm1
addss  %xmm5,%xmm0
addss  %xmm0,%xmm1
mulss  0x110(%rsp),%xmm1
movss  (%rsi,%r8,4),%xmm0
addss  -0x8(%rdx,%r8,4),%xmm0
addss  0x8(%rdx,%r8,4),%xmm0
addss  %xmm4,%xmm1
addss  (%rax,%r8,4),%xmm0
mulss  0x100(%rsp),%xmm0
addss  %xmm1,%xmm0
movss  -0x4(%rdi,%r8,4),%xmm1
addss  0x4(%rdi,%r8,4),%xmm1
addss  -0x4(%rcx,%r8,4),%xmm1
addss  0x4(%rcx,%r8,4),%xmm1
mulss  0xf0(%rsp),%xmm1
movss  (%rdi,%r8,4),%xmm4
addss  -0x4(%rdx,%r8,4),%xmm4
addss  0x4(%rdx,%r8,4),%xmm4
addss  (%rcx,%r8,4),%xmm4
addss  %xmm0,%xmm1
mulss  0x180(%rsp),%xmm4
addss  %xmm1,%xmm4
movss  (%rdx,%r8,4),%xmm0
mulss  0xe0(%rsp),%xmm0
addss  %xmm4,%xmm0
mulss  %xmm8,%xmm0
movaps %xmm7,%xmm1
cmpunordss %xmm7,%xmm1
movaps %xmm1,%xmm4
andps  %xmm0,%xmm4
minss  %xmm7,%xmm0
andnps %xmm0,%xmm1
xorps  %xmm0,%xmm0
orps   %xmm4,%xmm1
maxss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%r8,4)
add    $0x1,%r8
cmp    %r8d,%r10d
jne    1cc0 <dt_masks_blur_fast+0xb90>
jmp    1560 <dt_masks_blur_fast+0x430>
imul   %edx,%ecx
test   %ecx,%ecx
jle    271e <dt_masks_blur_fast+0x15ee>
mov    %ecx,%ebp
cmp    $0x8,%ecx
jae    264b <dt_masks_blur_fast+0x151b>
xor    %edx,%edx
jmp    26dc <dt_masks_blur_fast+0x15ac>
cvtss2sd %xmm0,%xmm0
lea    0x60(%rsp),%rdi
mov    $0x1,%al
mov    %ecx,%ebx
call   1040 <_masks_blur_5x5_coeff@plt>
mov    (%rsp),%r9
mov    0x10(%rsp),%r10
movaps 0x170(%rsp),%xmm8
movaps 0xb0(%rsp),%xmm3
mov    $0x2,%eax
cmp    $0x5,%ebx
jl     31bd <dt_masks_blur_fast+0x208d>
mov    %ebx,%r11d
add    $0xfffffffe,%r11d
movss  0x60(%rsp),%xmm9
movss  0x64(%rsp),%xmm4
movss  0x68(%rsp),%xmm10
movss  0x6c(%rsp),%xmm11
movss  0x70(%rsp),%xmm15
movslq %r12d,%rax
add    $0x2,%r12d
mov    0x18(%rsp),%rcx
movslq %ecx,%rdx
lea    -0x5(%rcx),%esi
mov    %rsi,0x1b0(%rsp)
lea    0x1(%rsi),%r13
mov    %r13,0x190(%rsp)
and    $0xfffffffffffffffc,%r13
lea    0x2(%r13),%esi
mov    %esi,0xd0(%rsp)
movaps %xmm4,%xmm13
shufps $0x0,%xmm4,%xmm13
movaps %xmm9,%xmm12
shufps $0x0,%xmm9,%xmm12
movaps %xmm10,%xmm14
shufps $0x0,%xmm10,%xmm14
movaps %xmm11,%xmm0
shufps $0x0,%xmm11,%xmm0
movaps %xmm0,0x110(%rsp)
movaps %xmm15,%xmm5
shufps $0x0,%xmm15,%xmm5
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
movaps %xmm0,0xf0(%rsp)
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
movaps %xmm0,0xe0(%rsp)
mov    %rax,0x20(%rsp)
lea    0x0(,%rax,4),%rax
mov    %r9,%rsi
sub    %rax,%rsi
mov    %rsi,0x150(%rsp)
mov    %rdx,0x160(%rsp)
lea    0x0(,%rdx,4),%rax
mov    %r9,%r14
sub    %rax,%r14
lea    -0x2(%rcx),%eax
mov    %eax,0x1a0(%rsp)
mov    $0x2,%r15d
movaps %xmm10,0x140(%rsp)
movaps %xmm11,0x130(%rsp)
movaps %xmm15,0x120(%rsp)
movaps %xmm4,0x100(%rsp)
movaps %xmm9,0x180(%rsp)
movaps %xmm5,0x50(%rsp)
movaps 0x110(%rsp),%xmm5
jmp    2305 <dt_masks_blur_fast+0x11d5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15d
mov    0x18(%rsp),%rcx
add    %ecx,%r12d
cmp    %r11d,%r15d
je     31aa <dt_masks_blur_fast+0x207a>
cmp    $0x5,%ecx
jl     22f0 <dt_masks_blur_fast+0x11c0>
movslq %r12d,%rdx
movss  (%r9,%rdx,4),%xmm6
mov    $0x2,%eax
cmpl   $0x3,0x1b0(%rsp)
03
jb     2511 <dt_masks_blur_fast+0x13e1>
mov    %r11d,%ebp
mov    0x160(%rsp),%rax
lea    (%rax,%rdx,1),%rsi
mov    0x20(%rsp),%rax
lea    (%rax,%rdx,1),%rdi
mov    0x150(%rsp),%rax
lea    (%rax,%rdx,4),%rax
lea    (%r14,%rdx,4),%rcx
lea    (%r9,%rsi,4),%rbx
lea    (%r9,%rdi,4),%r8
lea    (%r9,%rdx,4),%r9
lea    (%r10,%rdx,4),%r10
add    %r13,%rdx
shufps $0x0,%xmm6,%xmm6
xor    %r11d,%r11d
movaps 0xf0(%rsp),%xmm4
movaps 0xe0(%rsp),%xmm9
nopl   0x0(%rax)
movaps %xmm6,%xmm7
movups -0x4(%rax,%r11,4),%xmm0
movups (%rax,%r11,4),%xmm6
movups 0x4(%rax,%r11,4),%xmm1
addps  %xmm0,%xmm1
movups 0x8(%rcx,%r11,4),%xmm0
movups -0x8(%rcx,%r11,4),%xmm2
addps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups -0x4(%rcx,%r11,4),%xmm0
movups (%rcx,%r11,4),%xmm8
movups 0x4(%rcx,%r11,4),%xmm1
addps  %xmm0,%xmm1
movups 0x8(%rbx,%r11,4),%xmm0
movups -0x8(%rbx,%r11,4),%xmm3
addps  %xmm0,%xmm3
addps  %xmm2,%xmm3
movups -0x4(%rbx,%r11,4),%xmm2
addps  %xmm1,%xmm2
movups (%rbx,%r11,4),%xmm0
movups 0x4(%rbx,%r11,4),%xmm1
addps  %xmm2,%xmm1
mulps  %xmm14,%xmm1
movups -0x4(%r8,%r11,4),%xmm2
movaps %xmm13,%xmm10
movups (%r8,%r11,4),%xmm13
movaps %xmm14,%xmm15
movups 0x4(%r8,%r11,4),%xmm14
addps  %xmm2,%xmm14
addps  %xmm3,%xmm14
mulps  %xmm12,%xmm14
movups -0x8(%r9,%r11,4),%xmm2
addps  %xmm6,%xmm2
movaps %xmm12,%xmm11
movups -0x4(%r9,%r11,4),%xmm12
addps  %xmm8,%xmm12
movups 0x4(%r9,%r11,4),%xmm6
movups 0x8(%r9,%r11,4),%xmm3
addps  %xmm2,%xmm3
addps  %xmm13,%xmm3
movaps %xmm10,%xmm13
mulps  %xmm10,%xmm3
addps  %xmm14,%xmm3
movaps %xmm15,%xmm14
addps  %xmm1,%xmm3
shufps $0x3,%xmm6,%xmm7
shufps $0x98,%xmm6,%xmm7
mulps  0x50(%rsp),%xmm7
addps  %xmm6,%xmm12
addps  %xmm0,%xmm12
mulps  %xmm5,%xmm12
addps  %xmm3,%xmm12
addps  %xmm7,%xmm12
mulps  %xmm4,%xmm12
movaps %xmm9,%xmm0
cmpunordps %xmm9,%xmm0
movaps %xmm12,%xmm1
andps  %xmm0,%xmm1
minps  %xmm9,%xmm12
andnps %xmm12,%xmm0
movaps %xmm11,%xmm12
orps   %xmm1,%xmm0
xorps  %xmm1,%xmm1
maxps  %xmm0,%xmm1
cmpordps %xmm0,%xmm0
andps  %xmm1,%xmm0
movups %xmm0,(%r10,%r11,4)
add    $0x4,%r11
cmp    %r11,%r13
jne    2380 <dt_masks_blur_fast+0x1250>
cmp    %r13,0x190(%rsp)
movaps 0xb0(%rsp),%xmm3
movaps 0x170(%rsp),%xmm8
mov    0x10(%rsp),%r10
mov    (%rsp),%r9
mov    %ebp,%r11d
movaps 0x180(%rsp),%xmm9
movaps 0x100(%rsp),%xmm4
movaps 0x140(%rsp),%xmm10
movaps 0x130(%rsp),%xmm11
movaps 0x120(%rsp),%xmm15
je     22f0 <dt_masks_blur_fast+0x11c0>
shufps $0xff,%xmm6,%xmm6
mov    0xd0(%rsp),%eax
mov    0x1a0(%rsp),%ecx
mov    %ecx,%r8d
sub    %eax,%r8d
mov    0x150(%rsp),%rax
lea    (%rax,%rdx,4),%rcx
lea    (%r14,%rdx,4),%rbx
mov    0x160(%rsp),%rax
add    %rdx,%rax
lea    (%r9,%rax,4),%rbp
mov    0x20(%rsp),%rax
add    %rdx,%rax
lea    (%r9,%rax,4),%rsi
lea    (%r9,%rdx,4),%rdi
lea    (%r10,%rdx,4),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rcx,%rax,4),%xmm0
addss  0x4(%rcx,%rax,4),%xmm0
movss  (%rcx,%rax,4),%xmm7
movss  -0x8(%rbx,%rax,4),%xmm1
addss  0x8(%rbx,%rax,4),%xmm1
addss  %xmm0,%xmm1
movss  -0x8(%rbp,%rax,4),%xmm2
addss  0x8(%rbp,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rsi,%rax,4),%xmm1
addss  0x4(%rsi,%rax,4),%xmm1
movss  -0x4(%rbx,%rax,4),%xmm0
addss  %xmm2,%xmm1
addss  -0x8(%rdi,%rax,4),%xmm7
addss  0x8(%rdi,%rax,4),%xmm7
addss  (%rsi,%rax,4),%xmm7
mulss  %xmm4,%xmm7
mulss  %xmm9,%xmm1
addss  0x4(%rbx,%rax,4),%xmm0
addss  -0x4(%rbp,%rax,4),%xmm0
addss  0x4(%rbp,%rax,4),%xmm0
addss  %xmm7,%xmm1
mulss  %xmm10,%xmm0
addss  %xmm1,%xmm0
movss  (%rbx,%rax,4),%xmm1
addss  -0x4(%rdi,%rax,4),%xmm1
movss  0x4(%rdi,%rax,4),%xmm7
addss  %xmm7,%xmm1
addss  0x0(%rbp,%rax,4),%xmm1
mulss  %xmm11,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm15,%xmm6
addss  %xmm1,%xmm6
mulss  %xmm8,%xmm6
movaps %xmm3,%xmm0
cmpunordss %xmm3,%xmm0
movaps %xmm0,%xmm1
andps  %xmm6,%xmm1
minss  %xmm3,%xmm6
andnps %xmm6,%xmm0
orps   %xmm1,%xmm0
xorps  %xmm1,%xmm1
maxss  %xmm1,%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%rax
movaps %xmm7,%xmm6
cmp    %eax,%r8d
jne    2560 <dt_masks_blur_fast+0x1430>
jmp    22f0 <dt_masks_blur_fast+0x11c0>
mov    %ebp,%edx
and    $0xfffffff8,%edx
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
movaps %xmm2,%xmm0
shufps $0x0,%xmm2,%xmm0
xor    %eax,%eax
movaps %xmm0,%xmm7
cmpunordps %xmm0,%xmm7
nopl   0x0(%rax)
movups (%rdi,%rax,4),%xmm3
movups 0x10(%rdi,%rax,4),%xmm4
mulps  %xmm8,%xmm3
mulps  %xmm8,%xmm4
movaps %xmm3,%xmm5
andps  %xmm7,%xmm5
minps  %xmm0,%xmm3
movaps %xmm7,%xmm6
andnps %xmm3,%xmm6
orps   %xmm5,%xmm6
movaps %xmm4,%xmm3
andps  %xmm7,%xmm3
minps  %xmm0,%xmm4
movaps %xmm7,%xmm5
andnps %xmm4,%xmm5
orps   %xmm3,%xmm5
xorps  %xmm3,%xmm3
maxps  %xmm6,%xmm3
cmpordps %xmm6,%xmm6
andps  %xmm3,%xmm6
xorps  %xmm3,%xmm3
maxps  %xmm5,%xmm3
cmpordps %xmm5,%xmm5
andps  %xmm3,%xmm5
movups %xmm6,(%rsi,%rax,4)
movups %xmm5,0x10(%rsi,%rax,4)
add    $0x8,%rax
cmp    %rax,%rdx
jne    2670 <dt_masks_blur_fast+0x1540>
xor    %eax,%eax
cmp    %rbp,%rdx
je     31bd <dt_masks_blur_fast+0x208d>
movaps %xmm2,%xmm0
cmpunordss %xmm2,%xmm0
xorps  %xmm6,%xmm6
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%rdx,4),%xmm5
mulss  %xmm1,%xmm5
movaps %xmm0,%xmm3
andps  %xmm5,%xmm3
minss  %xmm2,%xmm5
movaps %xmm0,%xmm4
andnps %xmm5,%xmm4
orps   %xmm3,%xmm4
maxss  %xmm6,%xmm4
movss  %xmm4,(%rsi,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    26f0 <dt_masks_blur_fast+0x15c0>
xor    %eax,%eax
jmp    31bd <dt_masks_blur_fast+0x208d>
call   1050 <dt_masks_blur_9x9_coeff@plt>
mov    (%rsp),%rcx
movaps 0x170(%rsp),%xmm8
movaps 0xb0(%rsp),%xmm15
mov    $0x4,%eax
cmp    $0x9,%ebp
jl     31bd <dt_masks_blur_fast+0x208d>
mov    %ebp,%edx
add    $0xfffffffc,%edx
movss  0x90(%rsp),%xmm7
movss  0x8c(%rsp),%xmm0
movss  0x88(%rsp),%xmm6
movss  0x84(%rsp),%xmm3
movss  0x80(%rsp),%xmm1
movss  0x7c(%rsp),%xmm2
movss  0x78(%rsp),%xmm4
movss  0x74(%rsp),%xmm5
movslq %ebx,%r13
mov    0x18(%rsp),%rsi
movslq %esi,%rax
movslq %r15d,%rdi
add    $0x4,%r15d
movslq %r12d,%rbp
mov    %rax,%r12
lea    -0x9(%rsi),%eax
mov    %rax,0x180(%rsp)
add    $0x1,%rax
mov    %rax,0x48(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rsp)
add    $0x4,%eax
mov    %eax,0x38(%rsp)
movaps %xmm0,0x280(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x160(%rsp)
movaps %xmm7,0x290(%rsp)
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
movaps %xmm0,0x150(%rsp)
movaps %xmm6,0xe0(%rsp)
movaps %xmm6,%xmm0
shufps $0x0,%xmm6,%xmm0
movaps %xmm0,0x260(%rsp)
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
movaps %xmm0,0x250(%rsp)
movaps %xmm1,0x20(%rsp)
shufps $0x0,%xmm1,%xmm1
movaps %xmm1,0x240(%rsp)
movaps %xmm2,0xd0(%rsp)
shufps $0x0,%xmm2,%xmm2
movaps %xmm2,0x230(%rsp)
movaps %xmm4,0x2e0(%rsp)
shufps $0x0,%xmm4,%xmm4
movaps %xmm4,0x220(%rsp)
movaps %xmm5,0x2d0(%rsp)
shufps $0x0,%xmm5,%xmm5
movaps %xmm5,0x1b0(%rsp)
movaps %xmm8,%xmm0
movss  0x70(%rsp),%xmm1
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
movaps %xmm2,0x1a0(%rsp)
movss  0x6c(%rsp),%xmm2
movaps %xmm2,0x2c0(%rsp)
shufps $0x0,%xmm2,%xmm2
movaps %xmm2,0x200(%rsp)
movss  0x68(%rsp),%xmm2
movaps %xmm2,0x2b0(%rsp)
shufps $0x0,%xmm2,%xmm2
movaps %xmm2,0x1f0(%rsp)
movss  0x64(%rsp),%xmm2
movaps %xmm2,0x2a0(%rsp)
shufps $0x0,%xmm2,%xmm2
movaps %xmm2,0x1e0(%rsp)
movss  0x60(%rsp),%xmm2
movaps %xmm2,0x270(%rsp)
shufps $0x0,%xmm2,%xmm2
movaps %xmm2,0x1d0(%rsp)
shufps $0x0,%xmm8,%xmm0
movaps %xmm0,0x2f0(%rsp)
movaps %xmm15,%xmm0
shufps $0x0,%xmm15,%xmm0
movaps %xmm0,0x1c0(%rsp)
mov    %rdi,0x140(%rsp)
lea    0x0(,%rdi,4),%rax
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rdi,0x120(%rsp)
mov    %rbp,0x130(%rsp)
lea    0x0(,%rbp,4),%rax
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rdi,0x110(%rsp)
lea    0x0(,%r12,4),%rax
mov    %rcx,%rdi
sub    %rax,%rdi
mov    %rdi,0x100(%rsp)
lea    0x0(,%r13,4),%rax
sub    %rax,%rcx
mov    %rcx,0xf0(%rsp)
lea    -0x4(%rsi),%eax
mov    %eax,0x310(%rsp)
mov    $0x4,%eax
movaps %xmm3,0x50(%rsp)
mov    %edx,0xc(%rsp)
mov    %r13,0x300(%rsp)
mov    %r12,0xc0(%rsp)
movaps %xmm1,0x210(%rsp)
jmp    29d2 <dt_masks_blur_fast+0x18a2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps %xmm8,%xmm1
mov    0x190(%rsp),%eax
add    $0x1,%eax
mov    0x18(%rsp),%rsi
add    %esi,%r15d
mov    0xc(%rsp),%edx
cmp    %edx,%eax
je     31b8 <dt_masks_blur_fast+0x2088>
mov    %eax,0x190(%rsp)
cmp    $0x9,%esi
movaps %xmm1,%xmm8
jl     29b0 <dt_masks_blur_fast+0x1880>
movslq %r15d,%r9
mov    $0x4,%eax
cmpl   $0x3,0x180(%rsp)
03
jae    2a60 <dt_masks_blur_fast+0x1930>
movaps 0xb0(%rsp),%xmm4
movaps 0xd0(%rsp),%xmm12
movaps 0x2e0(%rsp),%xmm14
movaps 0x2d0(%rsp),%xmm10
movaps 0x2c0(%rsp),%xmm9
movaps 0x2b0(%rsp),%xmm13
movaps 0x2a0(%rsp),%xmm11
movaps 0x270(%rsp),%xmm15
movaps 0x290(%rsp),%xmm6
movaps 0xe0(%rsp),%xmm5
movaps 0x280(%rsp),%xmm7
movaps %xmm1,%xmm8
jmp    2ec4 <dt_masks_blur_fast+0x1d94>
nopl   0x0(%rax)
mov    %r15d,0x320(%rsp)
mov    0x130(%rsp),%rax
add    %r9,%rax
mov    0x140(%rsp),%rcx
lea    (%rcx,%r9,1),%rcx
lea    (%r12,%r9,1),%rdi
lea    0x0(%r13,%r9,1),%r8
mov    0x120(%rsp),%rdx
lea    (%rdx,%r9,4),%rdx
mov    0x110(%rsp),%rsi
lea    (%rsi,%r9,4),%rsi
mov    (%rsp),%rbx
lea    (%rbx,%rax,4),%rax
lea    (%rbx,%rcx,4),%rcx
mov    0x100(%rsp),%rbp
lea    0x0(%rbp,%r9,4),%r11
lea    (%rbx,%rdi,4),%r14
lea    (%rbx,%r9,4),%r15
mov    0xf0(%rsp),%rdi
lea    (%rdi,%r9,4),%r12
lea    (%rbx,%r8,4),%r13
mov    0x10(%rsp),%rdi
lea    (%rdi,%r9,4),%r10
mov    0x40(%rsp),%rdi
add    %rdi,%r9
xor    %r8d,%r8d
movaps 0x260(%rsp),%xmm12
movaps 0x250(%rsp),%xmm14
movaps 0x240(%rsp),%xmm4
movaps 0x230(%rsp),%xmm5
movaps 0x220(%rsp),%xmm9
movaps 0x200(%rsp),%xmm15
movaps 0x1f0(%rsp),%xmm13
movaps 0x1e0(%rsp),%xmm6
movaps 0x1d0(%rsp),%xmm8
movaps 0x2f0(%rsp),%xmm7
movaps 0x1c0(%rsp),%xmm10
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x8(%rdx,%r8,4),%xmm0
movups -0x8(%rdx,%r8,4),%xmm2
addps  %xmm0,%xmm2
movups -0x4(%rdx,%r8,4),%xmm3
movups (%rdx,%r8,4),%xmm0
movups 0x4(%rdx,%r8,4),%xmm1
addps  %xmm3,%xmm1
movups -0x10(%rsi,%r8,4),%xmm3
addps  %xmm2,%xmm3
movups 0x10(%rsi,%r8,4),%xmm2
addps  %xmm3,%xmm2
movups -0x10(%rax,%r8,4),%xmm3
addps  %xmm2,%xmm3
movups 0x10(%rax,%r8,4),%xmm2
addps  %xmm3,%xmm2
movups -0x8(%rcx,%r8,4),%xmm3
addps  %xmm2,%xmm3
movups 0x8(%rcx,%r8,4),%xmm2
addps  %xmm3,%xmm2
movups -0x10(%r11,%r8,4),%xmm3
addps  %xmm1,%xmm3
movups 0x10(%r11,%r8,4),%xmm1
addps  %xmm3,%xmm1
movups -0x10(%r14,%r8,4),%xmm3
addps  %xmm1,%xmm3
movups 0x10(%r14,%r8,4),%xmm1
addps  %xmm3,%xmm1
movups -0x4(%rcx,%r8,4),%xmm3
addps  %xmm3,%xmm1
movups 0x4(%rcx,%r8,4),%xmm3
addps  %xmm3,%xmm1
movups (%rcx,%r8,4),%xmm3
mulps  0x150(%rsp),%xmm2
mulps  0x160(%rsp),%xmm1
addps  %xmm2,%xmm1
movups -0x10(%r15,%r8,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r15,%r8,4),%xmm0
addps  %xmm2,%xmm0
movups -0xc(%r15,%r8,4),%xmm2
addps  %xmm3,%xmm0
mulps  %xmm12,%xmm0
addps  %xmm1,%xmm0
movups 0xc(%r12,%r8,4),%xmm1
movups -0xc(%r12,%r8,4),%xmm3
addps  %xmm1,%xmm3
movups (%r12,%r8,4),%xmm11
addps  %xmm2,%xmm11
movups -0xc(%r13,%r8,4),%xmm1
addps  %xmm3,%xmm1
movups 0xc(%r13,%r8,4),%xmm2
addps  %xmm1,%xmm2
movups -0x8(%r12,%r8,4),%xmm1
mulps  %xmm14,%xmm2
addps  %xmm0,%xmm2
movups 0x8(%r12,%r8,4),%xmm0
addps  %xmm1,%xmm0
movups -0xc(%rsi,%r8,4),%xmm1
addps  %xmm1,%xmm0
movups 0xc(%rsi,%r8,4),%xmm1
addps  %xmm0,%xmm1
movups -0xc(%rax,%r8,4),%xmm0
addps  %xmm0,%xmm1
movups 0xc(%rax,%r8,4),%xmm0
addps  %xmm1,%xmm0
movups -0x8(%r13,%r8,4),%xmm1
addps  %xmm1,%xmm0
movups 0x8(%r13,%r8,4),%xmm1
addps  %xmm0,%xmm1
movups -0x4(%r12,%r8,4),%xmm0
mulps  %xmm4,%xmm1
addps  %xmm2,%xmm1
movups 0x4(%r12,%r8,4),%xmm2
addps  %xmm0,%xmm2
movups -0xc(%r11,%r8,4),%xmm0
addps  %xmm0,%xmm2
movups 0xc(%r11,%r8,4),%xmm0
addps  %xmm2,%xmm0
movups -0xc(%r14,%r8,4),%xmm2
addps  %xmm2,%xmm0
movups 0xc(%r14,%r8,4),%xmm2
addps  %xmm0,%xmm2
movups -0x4(%r13,%r8,4),%xmm0
addps  %xmm0,%xmm2
movups 0x4(%r13,%r8,4),%xmm0
addps  %xmm2,%xmm0
mulps  %xmm5,%xmm0
addps  %xmm1,%xmm0
movups 0xc(%r15,%r8,4),%xmm1
addps  %xmm11,%xmm1
movups 0x0(%r13,%r8,4),%xmm2
addps  %xmm2,%xmm1
movups -0x8(%rsi,%r8,4),%xmm2
mulps  %xmm9,%xmm1
addps  %xmm0,%xmm1
movups 0x8(%rsi,%r8,4),%xmm0
addps  %xmm2,%xmm0
movups -0x8(%rax,%r8,4),%xmm2
addps  %xmm2,%xmm0
movups 0x8(%rax,%r8,4),%xmm2
addps  %xmm0,%xmm2
movups -0x4(%rsi,%r8,4),%xmm0
mulps  0x1b0(%rsp),%xmm2
addps  %xmm1,%xmm2
movups 0x4(%rsi,%r8,4),%xmm1
addps  %xmm0,%xmm1
movups -0x8(%r11,%r8,4),%xmm0
addps  %xmm0,%xmm1
movups 0x8(%r11,%r8,4),%xmm0
addps  %xmm1,%xmm0
movups -0x8(%r14,%r8,4),%xmm1
addps  %xmm1,%xmm0
movups 0x8(%r14,%r8,4),%xmm1
addps  %xmm0,%xmm1
movups -0x4(%rax,%r8,4),%xmm0
addps  %xmm0,%xmm1
movups 0x4(%rax,%r8,4),%xmm0
addps  %xmm1,%xmm0
movups -0x8(%r15,%r8,4),%xmm1
mulps  0x1a0(%rsp),%xmm0
addps  %xmm2,%xmm0
movups (%rsi,%r8,4),%xmm2
addps  %xmm1,%xmm2
movups 0x8(%r15,%r8,4),%xmm1
addps  %xmm2,%xmm1
movups (%rax,%r8,4),%xmm2
addps  %xmm1,%xmm2
movups -0x4(%r11,%r8,4),%xmm1
mulps  %xmm15,%xmm2
addps  %xmm0,%xmm2
movups 0x4(%r11,%r8,4),%xmm0
addps  %xmm1,%xmm0
movups -0x4(%r14,%r8,4),%xmm1
addps  %xmm1,%xmm0
movups 0x4(%r14,%r8,4),%xmm1
addps  %xmm0,%xmm1
movups -0x4(%r15,%r8,4),%xmm0
mulps  %xmm13,%xmm1
addps  %xmm2,%xmm1
movups (%r11,%r8,4),%xmm2
addps  %xmm0,%xmm2
movups 0x4(%r15,%r8,4),%xmm0
addps  %xmm2,%xmm0
movups (%r14,%r8,4),%xmm2
addps  %xmm0,%xmm2
mulps  %xmm6,%xmm2
addps  %xmm1,%xmm2
movups (%r15,%r8,4),%xmm0
mulps  %xmm8,%xmm0
addps  %xmm2,%xmm0
mulps  %xmm7,%xmm0
movaps %xmm10,%xmm1
cmpunordps %xmm10,%xmm1
movaps %xmm0,%xmm2
andps  %xmm1,%xmm2
minps  %xmm10,%xmm0
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
xorps  %xmm0,%xmm0
maxps  %xmm1,%xmm0
cmpordps %xmm1,%xmm1
andps  %xmm0,%xmm1
movups %xmm1,(%r10,%r8,4)
add    $0x4,%r8
cmp    %r8,%rdi
jne    2b50 <dt_masks_blur_fast+0x1a20>
mov    0x38(%rsp),%eax
cmp    %rdi,0x48(%rsp)
movaps 0xb0(%rsp),%xmm4
mov    0x320(%rsp),%r15d
movaps 0x290(%rsp),%xmm6
movaps 0x280(%rsp),%xmm7
movaps 0xe0(%rsp),%xmm5
movaps 0x50(%rsp),%xmm3
movaps 0xd0(%rsp),%xmm12
movaps 0x2e0(%rsp),%xmm14
movaps 0x2d0(%rsp),%xmm10
mov    0x300(%rsp),%r13
mov    0xc0(%rsp),%r12
movaps 0x210(%rsp),%xmm8
movaps 0x2c0(%rsp),%xmm9
movaps 0x2b0(%rsp),%xmm13
movaps 0x2a0(%rsp),%xmm11
movaps 0x270(%rsp),%xmm15
je     29b0 <dt_masks_blur_fast+0x1880>
mov    0x310(%rsp),%ecx
mov    %ecx,%r8d
sub    %eax,%r8d
mov    0x120(%rsp),%rax
lea    (%rax,%r9,4),%r10
mov    0x110(%rsp),%rax
lea    (%rax,%r9,4),%rdx
mov    0x130(%rsp),%rax
add    %r9,%rax
mov    (%rsp),%rbp
lea    0x0(%rbp,%rax,4),%rsi
mov    0x140(%rsp),%rax
lea    (%rax,%r9,1),%rax
lea    0x0(%rbp,%rax,4),%r11
mov    0x100(%rsp),%rax
lea    (%rax,%r9,4),%rdi
lea    (%r12,%r9,1),%rax
lea    0x0(%rbp,%rax,4),%rbx
lea    0x0(%rbp,%r9,4),%rax
mov    0xf0(%rsp),%rcx
lea    (%rcx,%r9,4),%r14
lea    0x0(%r13,%r9,1),%rcx
lea    0x0(%rbp,%rcx,4),%rbp
mov    0x10(%rsp),%rcx
lea    (%rcx,%r9,4),%r9
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  -0x8(%r10,%rcx,4),%xmm0
movss  -0x4(%r10,%rcx,4),%xmm1
addss  0x8(%r10,%rcx,4),%xmm0
addss  -0x10(%rdx,%rcx,4),%xmm0
addss  0x10(%rdx,%rcx,4),%xmm0
addss  -0x10(%rsi,%rcx,4),%xmm0
addss  0x10(%rsi,%rcx,4),%xmm0
addss  -0x8(%r11,%rcx,4),%xmm0
addss  0x8(%r11,%rcx,4),%xmm0
addss  0x4(%r10,%rcx,4),%xmm1
addss  -0x10(%rdi,%rcx,4),%xmm1
addss  0x10(%rdi,%rcx,4),%xmm1
addss  -0x10(%rbx,%rcx,4),%xmm1
addss  0x10(%rbx,%rcx,4),%xmm1
addss  -0x4(%r11,%rcx,4),%xmm1
addss  0x4(%r11,%rcx,4),%xmm1
mulss  %xmm7,%xmm1
mulss  %xmm6,%xmm0
addss  %xmm1,%xmm0
movss  (%r10,%rcx,4),%xmm2
addss  -0x10(%rax,%rcx,4),%xmm2
addss  0x10(%rax,%rcx,4),%xmm2
addss  (%r11,%rcx,4),%xmm2
mulss  %xmm5,%xmm2
addss  %xmm0,%xmm2
movss  -0xc(%r14,%rcx,4),%xmm1
movss  -0x8(%r14,%rcx,4),%xmm0
addss  0xc(%r14,%rcx,4),%xmm1
addss  -0xc(%rbp,%rcx,4),%xmm1
addss  0xc(%rbp,%rcx,4),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
addss  0x8(%r14,%rcx,4),%xmm0
addss  -0xc(%rdx,%rcx,4),%xmm0
addss  0xc(%rdx,%rcx,4),%xmm0
addss  -0xc(%rsi,%rcx,4),%xmm0
addss  0xc(%rsi,%rcx,4),%xmm0
addss  -0x8(%rbp,%rcx,4),%xmm0
addss  0x8(%rbp,%rcx,4),%xmm0
mulss  0x20(%rsp),%xmm0
movss  -0x4(%r14,%rcx,4),%xmm2
addss  0x4(%r14,%rcx,4),%xmm2
addss  -0xc(%rdi,%rcx,4),%xmm2
addss  0xc(%rdi,%rcx,4),%xmm2
addss  -0xc(%rbx,%rcx,4),%xmm2
addss  0xc(%rbx,%rcx,4),%xmm2
addss  -0x4(%rbp,%rcx,4),%xmm2
addss  %xmm1,%xmm0
addss  0x4(%rbp,%rcx,4),%xmm2
mulss  %xmm12,%xmm2
addss  %xmm0,%xmm2
movss  (%r14,%rcx,4),%xmm3
addss  -0xc(%rax,%rcx,4),%xmm3
addss  0xc(%rax,%rcx,4),%xmm3
addss  0x0(%rbp,%rcx,4),%xmm3
mulss  %xmm14,%xmm3
addss  %xmm2,%xmm3
movss  -0x8(%rdx,%rcx,4),%xmm1
movss  -0x4(%rdx,%rcx,4),%xmm0
addss  0x8(%rdx,%rcx,4),%xmm1
addss  -0x8(%rsi,%rcx,4),%xmm1
addss  0x8(%rsi,%rcx,4),%xmm1
mulss  %xmm10,%xmm1
addss  %xmm3,%xmm1
movaps 0x50(%rsp),%xmm3
addss  0x4(%rdx,%rcx,4),%xmm0
addss  -0x8(%rdi,%rcx,4),%xmm0
addss  0x8(%rdi,%rcx,4),%xmm0
addss  -0x8(%rbx,%rcx,4),%xmm0
addss  0x8(%rbx,%rcx,4),%xmm0
addss  -0x4(%rsi,%rcx,4),%xmm0
addss  0x4(%rsi,%rcx,4),%xmm0
mulss  %xmm8,%xmm0
movss  (%rdx,%rcx,4),%xmm2
addss  -0x8(%rax,%rcx,4),%xmm2
addss  0x8(%rax,%rcx,4),%xmm2
addss  %xmm1,%xmm0
addss  (%rsi,%rcx,4),%xmm2
mulss  %xmm9,%xmm2
addss  %xmm0,%xmm2
movss  -0x4(%rdi,%rcx,4),%xmm0
addss  0x4(%rdi,%rcx,4),%xmm0
addss  -0x4(%rbx,%rcx,4),%xmm0
addss  0x4(%rbx,%rcx,4),%xmm0
movss  (%rdi,%rcx,4),%xmm1
mulss  %xmm13,%xmm0
addss  -0x4(%rax,%rcx,4),%xmm1
addss  0x4(%rax,%rcx,4),%xmm1
addss  (%rbx,%rcx,4),%xmm1
addss  %xmm2,%xmm0
mulss  %xmm11,%xmm1
addss  %xmm0,%xmm1
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm15,%xmm0
addss  %xmm1,%xmm0
mulss  0x170(%rsp),%xmm0
movaps %xmm4,%xmm1
cmpunordss %xmm4,%xmm1
movaps %xmm1,%xmm2
andps  %xmm0,%xmm2
minss  %xmm4,%xmm0
andnps %xmm0,%xmm1
xorps  %xmm0,%xmm0
orps   %xmm2,%xmm1
maxss  %xmm0,%xmm1
movss  %xmm1,(%r9,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%r8d
jne    2f50 <dt_masks_blur_fast+0x1e20>
jmp    29b0 <dt_masks_blur_fast+0x1880>
mov    $0x2,%eax
jmp    31bd <dt_masks_blur_fast+0x208d>
mov    $0x6,%eax
jmp    31bd <dt_masks_blur_fast+0x208d>
mov    $0x4,%eax
add    $0x438,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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