void dt_masks_blur_9x9(float *const restrict src, float *const restrict out,
                       const int width, const int height, const float sigma) {
  float kernel[9][9];
  const float temp = 2.0f * sqrf(sigma);
  float sum = 0.0f;
  for (int i = -4; i <= 4; i++) {
    for (int j = -4; j <= 4; j++) {
      kernel[i + 4][j + 4] = expf(-(sqrf(i) + sqrf(j)) / temp);
      sum += kernel[i + 4][j + 4];
    }
  }
  for (int i = 0; i < 9; i++) {
    for (int j = 0; j < 9; j++)
      kernel[i][j] /= sum;
  }
  const float c42 = kernel[0][2];
  const float c41 = kernel[0][3];
  const float c40 = kernel[0][4];
  const float c33 = kernel[1][1];
  const float c32 = kernel[1][2];
  const float c31 = kernel[1][3];
  const float c30 = kernel[1][4];
  const float c22 = kernel[2][2];
  const float c21 = kernel[2][3];
  const float c20 = kernel[2][4];
  const float c11 = kernel[3][3];
  const float c10 = kernel[3][4];
  const float c00 = kernel[4][4];
  const int w1 = width;
  const int w2 = 2 * width;
  const int w3 = 3 * width;
  const int w4 = 4 * width;
  for (int row = 4; row < height - 4; row++) {
#pragma GCC ivdep
    for (int col = 4; col < width - 4; col++) {
      const int i = row * width + col;
      const float val =
          c42 * (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]) +
          c41 * (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]) +
          c40 * (src[i - w4] + src[i - 4] + src[i + 4] + src[i + w4]) +
          c33 * (src[i - w3 - 3] + src[i - w3 + 3] + src[i + w3 - 3] +
                 src[i + w3 + 3]) +
          c32 * (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]) +
          c31 * (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]) +
          c30 * (src[i - w3] + src[i - 3] + src[i + 3] + src[i + w3]) +
          c22 * (src[i - w2 - 2] + src[i - w2 + 2] + src[i + w2 - 2] +
                 src[i + w2 + 2]) +
          c21 * (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]) +
          c20 * (src[i - w2] + src[i - 2] + src[i + 2] + src[i + w2]) +
          c11 * (src[i - w1 - 1] + src[i - w1 + 1] + src[i + w1 - 1] +
                 src[i + w1 + 1]) +
          c10 * (src[i - w1] + src[i - 1] + src[i + 1] + src[i + w1]) +
          c00 * src[i];
      out[i] = fminf(1.0f, fmaxf(0.0f, val));
    }
  }
  dt_masks_extend_border(out, width, height, 4);
}


x86 assembly (clang, -O0):
<dt_masks_blur_9x9>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1040 <sqrf@plt>
cvtsi2ss %eax,%xmm1
movss  0xe96(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x164(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x168(%rbp)
ff
movl   $0xfffffffc,-0x16c(%rbp)
ff ff ff
cmpl   $0x4,-0x16c(%rbp)
jg     127f <dt_masks_blur_9x9+0x14f>
movl   $0xfffffffc,-0x170(%rbp)
ff ff ff
cmpl   $0x4,-0x170(%rbp)
jg     1266 <dt_masks_blur_9x9+0x136>
mov    -0x16c(%rbp),%edi
mov    $0x0,%al
call   1040 <sqrf@plt>
mov    %eax,-0x1d0(%rbp)
mov    -0x170(%rbp),%edi
mov    $0x0,%al
call   1040 <sqrf@plt>
mov    -0x1d0(%rbp),%ecx
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
divss  -0x164(%rbp),%xmm0
ff
call   1030 <expf@plt>
mov    -0x16c(%rbp),%eax
add    $0x4,%eax
movslq %eax,%rcx
lea    -0x160(%rbp),%rax
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
mov    -0x170(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x16c(%rbp),%eax
add    $0x4,%eax
movslq %eax,%rcx
lea    -0x160(%rbp),%rax
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
mov    -0x170(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x168(%rbp),%xmm0
ff
movss  %xmm0,-0x168(%rbp)
ff
mov    -0x170(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x170(%rbp)
jmp    11a2 <dt_masks_blur_9x9+0x72>
jmp    126b <dt_masks_blur_9x9+0x13b>
mov    -0x16c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x16c(%rbp)
jmp    118b <dt_masks_blur_9x9+0x5b>
movl   $0x0,-0x174(%rbp)
cmpl   $0x9,-0x174(%rbp)
jge    130c <dt_masks_blur_9x9+0x1dc>
movl   $0x0,-0x178(%rbp)
cmpl   $0x9,-0x178(%rbp)
jge    12f3 <dt_masks_blur_9x9+0x1c3>
movss  -0x168(%rbp),%xmm1
ff
movslq -0x174(%rbp),%rcx
lea    -0x160(%rbp),%rax
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x178(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x178(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x178(%rbp)
jmp    12a0 <dt_masks_blur_9x9+0x170>
jmp    12f8 <dt_masks_blur_9x9+0x1c8>
mov    -0x174(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x174(%rbp)
jmp    1289 <dt_masks_blur_9x9+0x159>
movss  -0x158(%rbp),%xmm0
ff
movss  %xmm0,-0x17c(%rbp)
ff
movss  -0x154(%rbp),%xmm0
ff
movss  %xmm0,-0x180(%rbp)
ff
movss  -0x150(%rbp),%xmm0
ff
movss  %xmm0,-0x184(%rbp)
ff
movss  -0x138(%rbp),%xmm0
ff
movss  %xmm0,-0x188(%rbp)
ff
movss  -0x134(%rbp),%xmm0
ff
movss  %xmm0,-0x18c(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
movss  %xmm0,-0x190(%rbp)
ff
movss  -0x12c(%rbp),%xmm0
ff
movss  %xmm0,-0x194(%rbp)
ff
movss  -0x110(%rbp),%xmm0
ff
movss  %xmm0,-0x198(%rbp)
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  %xmm0,-0x19c(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
movss  %xmm0,-0x1a0(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  %xmm0,-0x1a4(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0x1a8(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0x1ac(%rbp)
ff
mov    -0x14(%rbp),%eax
mov    %eax,-0x1b0(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x1b4(%rbp)
imul   $0x3,-0x14(%rbp),%eax
mov    %eax,-0x1b8(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x1bc(%rbp)
movl   $0x4,-0x1c0(%rbp)
mov    -0x1c0(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    1c79 <dt_masks_blur_9x9+0xb49>
movl   $0x4,-0x1c4(%rbp)
mov    -0x1c4(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    1c60 <dt_masks_blur_9x9+0xb30>
mov    -0x1c0(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x1c4(%rbp),%eax
mov    %eax,-0x1c8(%rbp)
movss  -0x17c(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1bc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1bc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b4(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b4(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1bc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1bc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
movss  -0x180(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1bc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1bc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b0(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b0(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b0(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b0(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1bc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1bc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x184(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1bc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1bc(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x188(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b8(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b8(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b8(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b8(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18c(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b4(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b4(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x190(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b0(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b0(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x194(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b8(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b8(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x198(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x19c(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b0(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1a0(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1a4(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1a8(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    -0x1b0(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c8(%rbp),%ecx
add    -0x1b0(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1ac(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1cc(%rbp)
ff
movss  -0x1cc(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
maxss  %xmm1,%xmm0
movss  0x3cc(%rip),%xmm1
minss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
jmp    142f <dt_masks_blur_9x9+0x2ff>
jmp    1c65 <dt_masks_blur_9x9+0xb35>
mov    -0x1c0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c0(%rbp)
jmp    1411 <dt_masks_blur_9x9+0x2e1>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    $0x4,%ecx
mov    $0x0,%al
call   1050 <dt_masks_extend_border@plt>
add    $0x1d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dt_masks_blur_9x9>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3d8,%rsp
mov    %ecx,%r12d
mov    %rdx,0x10(%rsp)
mov    %rsi,0x8(%rsp)
mov    %rdi,0x30(%rsp)
cvtss2sd %xmm0,%xmm0
mov    $0x1,%al
call   1040 <sqrf@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
addss  %xmm0,%xmm0
movss  %xmm0,0x20(%rsp)
xorps  %xmm3,%xmm3
mov    $0xfffffffffffffffc,%r15
lea    0x290(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps %xmm3,0xc0(%rsp)
mov    %r15d,%edi
xor    %eax,%eax
call   1040 <sqrf@plt>
mov    %eax,%ebp
lea    -0x4(%rbx),%edi
xor    %eax,%eax
call   1040 <sqrf@plt>
add    %ebp,%eax
neg    %eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  0x20(%rsp),%xmm0
call   1030 <expf@plt>
movaps 0xc0(%rsp),%xmm3
movss  %xmm0,(%r14,%rbx,4)
addss  %xmm0,%xmm3
add    $0x1,%rbx
cmp    $0x9,%rbx
jne    11a0 <dt_masks_blur_9x9+0x70>
add    $0x1,%r15
add    $0x24,%r14
cmp    $0x5,%r15
jne    1190 <dt_masks_blur_9x9+0x60>
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
mov    $0x20,%eax
nopw   0x0(%rax,%rax,1)
movups 0x270(%rsp,%rax,1),%xmm1
movups 0x280(%rsp,%rax,1),%xmm2
divps  %xmm0,%xmm1
movups %xmm1,0x270(%rsp,%rax,1)
divps  %xmm0,%xmm2
movups %xmm2,0x280(%rsp,%rax,1)
movss  0x290(%rsp,%rax,1),%xmm1
divss  %xmm3,%xmm1
movss  %xmm1,0x290(%rsp,%rax,1)
add    $0x24,%rax
cmp    $0x164,%rax
jne    1210 <dt_masks_blur_9x9+0xe0>
mov    %r12,0x28(%rsp)
cmp    $0x9,%r12d
jl     1da2 <dt_masks_blur_9x9+0xc72>
movss  0x298(%rsp),%xmm2
movss  0x29c(%rsp),%xmm11
movss  0x2a0(%rsp),%xmm1
movss  0x2b8(%rsp),%xmm8
movss  0x2bc(%rsp),%xmm10
movss  0x2c0(%rsp),%xmm12
movss  0x2c4(%rsp),%xmm14
movss  0x2e0(%rsp),%xmm9
mov    0x10(%rsp),%rsi
lea    0x0(,%rsi,4),%eax
lea    (%rsi,%rsi,2),%ecx
lea    (%rsi,%rsi,1),%edx
lea    -0x4(%rsi),%edi
movslq %ecx,%r10
movslq %esi,%r12
movslq %eax,%rsi
movslq %edx,%rbx
mov    %rdi,0xe0(%rsp)
lea    -0x4(%rdi),%r9
mov    %r9,0x38(%rsp)
and    $0xfffffffffffffffc,%r9
movaps %xmm11,%xmm0
shufps $0x0,%xmm11,%xmm0
movaps %xmm0,0x270(%rsp)
movaps %xmm2,%xmm0
shufps $0x0,%xmm2,%xmm0
movaps %xmm0,0x260(%rsp)
movaps %xmm1,%xmm13
movaps %xmm1,%xmm0
shufps $0x0,%xmm1,%xmm0
movaps %xmm0,0x250(%rsp)
movaps %xmm8,%xmm3
shufps $0x0,%xmm8,%xmm8
movaps %xmm8,0x170(%rsp)
movaps %xmm10,%xmm15
shufps $0x0,%xmm10,%xmm10
movaps %xmm10,0x160(%rsp)
movaps %xmm12,%xmm8
shufps $0x0,%xmm12,%xmm12
movaps %xmm12,0x150(%rsp)
movaps %xmm14,%xmm10
shufps $0x0,%xmm14,%xmm14
movaps %xmm14,0x140(%rsp)
movaps %xmm9,%xmm12
shufps $0x0,%xmm9,%xmm9
movss  0x2e4(%rsp),%xmm0
movaps %xmm0,0x130(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x1f0(%rsp)
movss  0x2e8(%rsp),%xmm0
movaps %xmm0,0x120(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x1d0(%rsp)
movss  0x308(%rsp),%xmm0
movaps %xmm0,0x110(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x1b0(%rsp)
movss  0x30c(%rsp),%xmm0
movaps %xmm0,0x100(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x190(%rsp)
movss  0x330(%rsp),%xmm0
movaps %xmm0,0x280(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
lea    0x0(,%r12,4),%r11
mov    %r11,0x40(%rsp)
mov    %r12,%r15
shl    $0x4,%r15
lea    (%r10,%r12,4),%rdx
mov    0x30(%rsp),%rcx
lea    (%rcx,%rdx,4),%r13
add    $0x1c,%r13
mov    %r11,%r14
sub    %r10,%r14
lea    (%r12,%r12,4),%rdx
lea    (%rcx,%rdx,4),%rdx
add    $0x20,%rdx
lea    (%r12,%r12,2),%rdi
lea    0x20(%rcx,%rdi,4),%rbp
lea    (%rsi,%r12,4),%rdi
mov    %rdi,0x18(%rsp)
mov    %r11,%rdi
sub    %rsi,%rdi
lea    (%rbx,%r12,4),%rsi
lea    (%rcx,%rsi,4),%r8
add    $0x20,%r8
sub    %rbx,%r11
lea    (%r10,%r12,4),%rax
add    $0xfffffffffffffffd,%rax
mov    %rax,0x70(%rsp)
lea    (%rcx,%r14,4),%rax
add    $0x1c,%rax
mov    %rax,0x48(%rsp)
add    $0xfffffffffffffffd,%r14
mov    %r14,0x88(%rsp)
lea    (%rcx,%rdi,4),%rsi
add    $0x18,%rsi
or     $0x2,%rdi
mov    %rdi,0x80(%rsp)
lea    (%rbx,%r12,4),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x68(%rsp)
lea    (%rcx,%r11,4),%r10
add    $0x20,%r10
add    $0xfffffffffffffffc,%r11
mov    %r11,0x78(%rsp)
mov    0x28(%rsp),%rax
add    $0xfffffffc,%eax
mov    %rax,0xe8(%rsp)
mov    %r9,0xd8(%rsp)
lea    0x4(%r9),%rax
mov    %rax,0xd0(%rsp)
lea    (%rcx,%r15,1),%r9
mov    0x8(%rsp),%rax
mov    %r15,0x90(%rsp)
lea    0x10(%r15,%rax,1),%r11
mov    0x18(%rsp),%rax
lea    0x18(%rcx,%rax,4),%rbx
lea    -0x4(%r12,%r12,4),%rax
mov    %rax,0x60(%rsp)
mov    %r12,0xf0(%rsp)
lea    -0x4(%r12,%r12,2),%rax
mov    %rax,0x58(%rsp)
mov    $0x4,%edi
mov    0x40(%rsp),%rax
mov    %rax,0x50(%rsp)
movaps %xmm2,0x240(%rsp)
movaps %xmm8,0x230(%rsp)
movaps %xmm10,0x220(%rsp)
movaps %xmm12,0x210(%rsp)
movaps %xmm3,0x200(%rsp)
movaps %xmm15,0x1e0(%rsp)
movaps %xmm11,0x1c0(%rsp)
movaps %xmm1,0x1a0(%rsp)
jmp    161a <dt_masks_blur_9x9+0x4ea>
nop
mov    0xf8(%rsp),%rdi
add    $0x1,%rdi
mov    0x40(%rsp),%rcx
add    %rcx,%r9
mov    0xa8(%rsp),%r11
add    %rcx,%r11
mov    0xb8(%rsp),%r13
add    %rcx,%r13
add    %rcx,0x48(%rsp)
mov    0x98(%rsp),%rdx
add    %rcx,%rdx
add    %rcx,%rbp
mov    0xa0(%rsp),%rbx
add    %rcx,%rbx
add    %rcx,%r8
add    %rcx,%r10
mov    0xb0(%rsp),%rsi
add    %rcx,%rsi
mov    0xf0(%rsp),%rax
add    %rax,0x50(%rsp)
add    %rax,0x70(%rsp)
add    %rax,0x88(%rsp)
add    %rcx,0x90(%rsp)
add    %rax,0x60(%rsp)
add    %rax,0x58(%rsp)
add    %rax,0x18(%rsp)
add    %rax,0x80(%rsp)
add    %rax,0x68(%rsp)
add    %rax,0x78(%rsp)
cmp    0xe8(%rsp),%rdi
je     1da2 <dt_masks_blur_9x9+0xc72>
mov    %rdx,0x98(%rsp)
mov    %rdi,0xf8(%rsp)
mov    %rbx,0xa0(%rsp)
mov    %r11,0xa8(%rsp)
mov    %rsi,0xb0(%rsp)
mov    %r13,0xb8(%rsp)
cmpl   $0x9,0x10(%rsp)
movaps 0x130(%rsp),%xmm14
movaps 0x120(%rsp),%xmm6
movaps 0x110(%rsp),%xmm4
movaps 0x100(%rsp),%xmm5
jl     1570 <dt_masks_blur_9x9+0x440>
mov    $0x4,%r12d
cmpq   $0x4,0x38(%rsp)
jb     1a71 <dt_masks_blur_9x9+0x941>
xor    %r15d,%r15d
mov    0xd8(%rsp),%r11
movaps 0x170(%rsp),%xmm10
movaps 0x160(%rsp),%xmm12
movaps 0x150(%rsp),%xmm14
movaps 0x140(%rsp),%xmm8
movaps 0x1f0(%rsp),%xmm6
movaps 0x1d0(%rsp),%xmm4
movaps 0x1b0(%rsp),%xmm5
movaps 0x190(%rsp),%xmm7
movaps 0x180(%rsp),%xmm13
mov    0xb8(%rsp),%rcx
mov    0x48(%rsp),%rsi
mov    0xb0(%rsp),%rdi
mov    0xa8(%rsp),%rbx
mov    0xa0(%rsp),%rax
movaps 0x8f3(%rip),%xmm11
mov    0x98(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rdi,%r15,4),%xmm0
movups -0x10(%rdi,%r15,4),%xmm2
addps  %xmm0,%xmm2
movups -0xc(%rdi,%r15,4),%xmm3
movups -0x8(%rdi,%r15,4),%xmm0
movups -0x4(%rdi,%r15,4),%xmm1
addps  %xmm3,%xmm1
movups -0x20(%r10,%r15,4),%xmm3
addps  %xmm2,%xmm3
movups (%r10,%r15,4),%xmm2
addps  %xmm3,%xmm2
movups -0x20(%r8,%r15,4),%xmm3
addps  %xmm2,%xmm3
movups (%r8,%r15,4),%xmm2
addps  %xmm3,%xmm2
movups -0x10(%rax,%r15,4),%xmm3
addps  %xmm2,%xmm3
movups (%rax,%r15,4),%xmm2
addps  %xmm3,%xmm2
movups -0x20(%rbp,%r15,4),%xmm3
addps  %xmm1,%xmm3
movups 0x0(%rbp,%r15,4),%xmm1
addps  %xmm3,%xmm1
movups -0x20(%rdx,%r15,4),%xmm3
addps  %xmm1,%xmm3
movups (%rdx,%r15,4),%xmm1
addps  %xmm3,%xmm1
movups -0xc(%rax,%r15,4),%xmm3
addps  %xmm3,%xmm1
movups -0x4(%rax,%r15,4),%xmm3
addps  %xmm3,%xmm1
movups -0x8(%rax,%r15,4),%xmm3
mulps  0x260(%rsp),%xmm2
mulps  0x270(%rsp),%xmm1
addps  %xmm2,%xmm1
movups (%r9,%r15,4),%xmm2
addps  %xmm0,%xmm2
movups 0x20(%r9,%r15,4),%xmm0
addps  %xmm2,%xmm0
movups 0x4(%r9,%r15,4),%xmm2
addps  %xmm3,%xmm0
mulps  0x250(%rsp),%xmm0
addps  %xmm1,%xmm0
movups (%rsi,%r15,4),%xmm1
movups -0x18(%rsi,%r15,4),%xmm3
addps  %xmm1,%xmm3
movups -0xc(%rsi,%r15,4),%xmm15
addps  %xmm2,%xmm15
movups -0x18(%rcx,%r15,4),%xmm1
addps  %xmm3,%xmm1
movups (%rcx,%r15,4),%xmm2
addps  %xmm1,%xmm2
movups -0x14(%rsi,%r15,4),%xmm1
mulps  %xmm10,%xmm2
addps  %xmm0,%xmm2
movups -0x4(%rsi,%r15,4),%xmm0
addps  %xmm1,%xmm0
movups -0x1c(%r10,%r15,4),%xmm1
addps  %xmm1,%xmm0
movups -0x4(%r10,%r15,4),%xmm1
addps  %xmm0,%xmm1
movups -0x1c(%r8,%r15,4),%xmm0
addps  %xmm0,%xmm1
movups -0x4(%r8,%r15,4),%xmm0
addps  %xmm1,%xmm0
movups -0x14(%rcx,%r15,4),%xmm1
addps  %xmm1,%xmm0
movups -0x4(%rcx,%r15,4),%xmm1
addps  %xmm0,%xmm1
movups -0x10(%rsi,%r15,4),%xmm0
mulps  %xmm12,%xmm1
addps  %xmm2,%xmm1
movups -0x8(%rsi,%r15,4),%xmm2
addps  %xmm0,%xmm2
movups -0x1c(%rbp,%r15,4),%xmm0
addps  %xmm0,%xmm2
movups -0x4(%rbp,%r15,4),%xmm0
addps  %xmm2,%xmm0
movups -0x1c(%rdx,%r15,4),%xmm2
addps  %xmm2,%xmm0
movups -0x4(%rdx,%r15,4),%xmm2
addps  %xmm0,%xmm2
movups -0x10(%rcx,%r15,4),%xmm0
addps  %xmm0,%xmm2
movups -0x8(%rcx,%r15,4),%xmm0
addps  %xmm2,%xmm0
mulps  %xmm14,%xmm0
addps  %xmm1,%xmm0
movups 0x1c(%r9,%r15,4),%xmm1
addps  %xmm15,%xmm1
movups -0xc(%rcx,%r15,4),%xmm2
addps  %xmm2,%xmm1
movups -0x18(%r10,%r15,4),%xmm2
mulps  %xmm8,%xmm1
addps  %xmm0,%xmm1
movups -0x8(%r10,%r15,4),%xmm0
addps  %xmm2,%xmm0
movups -0x18(%r8,%r15,4),%xmm2
addps  %xmm2,%xmm0
movups -0x8(%r8,%r15,4),%xmm2
addps  %xmm0,%xmm2
movups -0x14(%r10,%r15,4),%xmm0
mulps  %xmm9,%xmm2
addps  %xmm1,%xmm2
movups -0xc(%r10,%r15,4),%xmm1
addps  %xmm0,%xmm1
movups -0x18(%rbp,%r15,4),%xmm0
addps  %xmm0,%xmm1
movups -0x8(%rbp,%r15,4),%xmm0
addps  %xmm1,%xmm0
movups -0x18(%rdx,%r15,4),%xmm1
addps  %xmm1,%xmm0
movups -0x8(%rdx,%r15,4),%xmm1
addps  %xmm0,%xmm1
movups -0x14(%r8,%r15,4),%xmm0
addps  %xmm0,%xmm1
movups -0xc(%r8,%r15,4),%xmm0
addps  %xmm1,%xmm0
movups 0x8(%r9,%r15,4),%xmm1
mulps  %xmm6,%xmm0
addps  %xmm2,%xmm0
movups -0x10(%r10,%r15,4),%xmm2
addps  %xmm1,%xmm2
movups 0x18(%r9,%r15,4),%xmm1
addps  %xmm2,%xmm1
movups -0x10(%r8,%r15,4),%xmm2
addps  %xmm1,%xmm2
movups -0x14(%rbp,%r15,4),%xmm1
mulps  %xmm4,%xmm2
addps  %xmm0,%xmm2
movups -0xc(%rbp,%r15,4),%xmm0
addps  %xmm1,%xmm0
movups -0x14(%rdx,%r15,4),%xmm1
addps  %xmm1,%xmm0
movups -0xc(%rdx,%r15,4),%xmm1
addps  %xmm0,%xmm1
movups 0xc(%r9,%r15,4),%xmm0
mulps  %xmm5,%xmm1
addps  %xmm2,%xmm1
movups -0x10(%rbp,%r15,4),%xmm2
addps  %xmm0,%xmm2
movups 0x14(%r9,%r15,4),%xmm0
addps  %xmm2,%xmm0
movups -0x10(%rdx,%r15,4),%xmm2
addps  %xmm0,%xmm2
mulps  %xmm7,%xmm2
addps  %xmm1,%xmm2
movups 0x10(%r9,%r15,4),%xmm0
mulps  %xmm13,%xmm0
addps  %xmm2,%xmm0
xorps  %xmm1,%xmm1
maxps  %xmm0,%xmm1
cmpordps %xmm0,%xmm0
andps  %xmm1,%xmm0
movaps %xmm11,%xmm1
minps  %xmm0,%xmm1
cmpunordps %xmm0,%xmm0
movaps %xmm11,%xmm2
andps  %xmm0,%xmm2
andnps %xmm1,%xmm0
orps   %xmm2,%xmm0
movups %xmm0,(%rbx,%r15,4)
add    $0x4,%r15
cmp    %r15,%r11
jne    1720 <dt_masks_blur_9x9+0x5f0>
mov    0xd0(%rsp),%r12
cmp    %r11,0x38(%rsp)
movaps 0x240(%rsp),%xmm2
movaps 0x1c0(%rsp),%xmm11
movaps 0x1a0(%rsp),%xmm13
movaps 0x200(%rsp),%xmm3
movaps 0x1e0(%rsp),%xmm15
movaps 0x230(%rsp),%xmm8
movaps 0x220(%rsp),%xmm10
movaps 0x210(%rsp),%xmm12
movaps 0x130(%rsp),%xmm14
movaps 0x120(%rsp),%xmm6
movaps 0x110(%rsp),%xmm4
movaps 0x100(%rsp),%xmm5
je     1570 <dt_masks_blur_9x9+0x440>
mov    0xe0(%rsp),%rax
sub    %r12,%rax
mov    %rax,0xc0(%rsp)
mov    0x50(%rsp),%rax
add    %r12,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,0x20(%rsp)
mov    0x70(%rsp),%rax
add    %r12,%rax
mov    0x30(%rsp),%rdx
lea    (%rdx,%rax,4),%rdi
mov    0x88(%rsp),%rax
add    %r12,%rax
lea    (%rdx,%rax,4),%rax
lea    (%rdx,%r12,4),%rcx
add    0x90(%rsp),%rcx
mov    0x60(%rsp),%rsi
add    %r12,%rsi
lea    (%rdx,%rsi,4),%r14
mov    0x58(%rsp),%rsi
lea    (%r12,%rsi,1),%rsi
lea    (%rdx,%rsi,4),%r15
mov    0x18(%rsp),%rsi
add    %r12,%rsi
lea    (%rdx,%rsi,4),%rsi
mov    0x80(%rsp),%rbx
add    %r12,%rbx
lea    (%rdx,%rbx,4),%r13
mov    0x68(%rsp),%rbx
add    %r12,%rbx
lea    (%rdx,%rbx,4),%r11
add    0x78(%rsp),%r12
lea    (%rdx,%r12,4),%rbx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x10(%r13,%r12,4),%xmm0
movss  -0xc(%r13,%r12,4),%xmm1
addss  0x0(%r13,%r12,4),%xmm0
addss  (%rbx,%r12,4),%xmm0
addss  0x20(%rbx,%r12,4),%xmm0
addss  (%r11,%r12,4),%xmm0
addss  0x20(%r11,%r12,4),%xmm0
addss  -0x8(%rsi,%r12,4),%xmm0
addss  0x8(%rsi,%r12,4),%xmm0
addss  -0x4(%r13,%r12,4),%xmm1
addss  (%r15,%r12,4),%xmm1
addss  0x20(%r15,%r12,4),%xmm1
addss  (%r14,%r12,4),%xmm1
addss  0x20(%r14,%r12,4),%xmm1
addss  -0x4(%rsi,%r12,4),%xmm1
addss  0x4(%rsi,%r12,4),%xmm1
mulss  %xmm11,%xmm1
mulss  %xmm2,%xmm0
movaps %xmm2,%xmm7
movss  -0x8(%r13,%r12,4),%xmm2
addss  -0x10(%rcx,%r12,4),%xmm2
addss  0x10(%rcx,%r12,4),%xmm2
addss  (%rsi,%r12,4),%xmm2
addss  %xmm1,%xmm0
mulss  %xmm13,%xmm2
addss  %xmm0,%xmm2
movss  (%rax,%r12,4),%xmm1
addss  0x18(%rax,%r12,4),%xmm1
addss  (%rdi,%r12,4),%xmm1
movss  0x4(%rax,%r12,4),%xmm0
addss  0x18(%rdi,%r12,4),%xmm1
mulss  %xmm3,%xmm1
addss  0x14(%rax,%r12,4),%xmm0
addss  0x4(%rbx,%r12,4),%xmm0
addss  0x1c(%rbx,%r12,4),%xmm0
addss  0x4(%r11,%r12,4),%xmm0
addss  0x1c(%r11,%r12,4),%xmm0
addss  0x4(%rdi,%r12,4),%xmm0
addss  %xmm2,%xmm1
addss  0x14(%rdi,%r12,4),%xmm0
mulss  %xmm15,%xmm0
addss  %xmm1,%xmm0
movss  0x8(%rax,%r12,4),%xmm2
addss  0x10(%rax,%r12,4),%xmm2
addss  0x4(%r15,%r12,4),%xmm2
addss  0x1c(%r15,%r12,4),%xmm2
addss  0x4(%r14,%r12,4),%xmm2
addss  0x1c(%r14,%r12,4),%xmm2
addss  0x8(%rdi,%r12,4),%xmm2
addss  0x10(%rdi,%r12,4),%xmm2
mulss  %xmm8,%xmm2
movss  0xc(%rax,%r12,4),%xmm1
addss  -0xc(%rcx,%r12,4),%xmm1
addss  0xc(%rcx,%r12,4),%xmm1
addss  0xc(%rdi,%r12,4),%xmm1
addss  %xmm0,%xmm2
mulss  %xmm10,%xmm1
addss  %xmm2,%xmm1
movss  0x8(%rbx,%r12,4),%xmm2
addss  0x18(%rbx,%r12,4),%xmm2
addss  0x8(%r11,%r12,4),%xmm2
movss  0xc(%rbx,%r12,4),%xmm0
addss  0x18(%r11,%r12,4),%xmm2
mulss  %xmm12,%xmm2
addss  0x14(%rbx,%r12,4),%xmm0
addss  0x8(%r15,%r12,4),%xmm0
addss  0x18(%r15,%r12,4),%xmm0
addss  0x8(%r14,%r12,4),%xmm0
addss  0x18(%r14,%r12,4),%xmm0
addss  0xc(%r11,%r12,4),%xmm0
addss  %xmm1,%xmm2
addss  0x14(%r11,%r12,4),%xmm0
mulss  %xmm14,%xmm0
addss  %xmm2,%xmm0
movss  0x10(%rbx,%r12,4),%xmm1
addss  -0x8(%rcx,%r12,4),%xmm1
addss  0x8(%rcx,%r12,4),%xmm1
addss  0x10(%r11,%r12,4),%xmm1
mulss  %xmm6,%xmm1
movss  0xc(%r15,%r12,4),%xmm2
addss  0x14(%r15,%r12,4),%xmm2
addss  0xc(%r14,%r12,4),%xmm2
addss  0x14(%r14,%r12,4),%xmm2
addss  %xmm0,%xmm1
mulss  %xmm4,%xmm2
addss  %xmm1,%xmm2
movss  0x10(%r15,%r12,4),%xmm0
addss  -0x4(%rcx,%r12,4),%xmm0
addss  0x4(%rcx,%r12,4),%xmm0
addss  0x10(%r14,%r12,4),%xmm0
mulss  %xmm5,%xmm0
addss  %xmm2,%xmm0
movaps %xmm7,%xmm2
movss  (%rcx,%r12,4),%xmm1
mulss  0x280(%rsp),%xmm1
addss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
maxss  %xmm0,%xmm1
minss  0x290(%rip),%xmm1
mov    0x20(%rsp),%rdx
movss  %xmm1,(%rdx,%r12,4)
add    $0x1,%r12
cmp    %r12,0xc0(%rsp)
jne    1b20 <dt_masks_blur_9x9+0x9f0>
jmp    1570 <dt_masks_blur_9x9+0x440>
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    $0x4,%ecx
xor    %eax,%eax
add    $0x3d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <dt_masks_extend_border@plt>

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

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