#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ dt_masks_blur_9x9_coeff(float *, float const);
int /*<<< orphan*/ dt_masks_extend_border(float *const, int const, int const,
                                          int);
int /*<<< orphan*/ fmaxf(float, float);
float fminf(float, int /*<<< orphan*/);
void dt_masks_blur_9x9(float *const restrict src, float *const restrict out,
                       const int width, const int height, const float sigma) {
  float blurmat[13];
  dt_masks_blur_9x9_coeff(blurmat, sigma);
  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++) {
    for (int col = 4; col < width - 4; col++) {
      const int i = row * width + col;
      out[i] = fminf(
          1.0f, fmaxf(0.0f, (blurmat[12] * (src[i - w4 - 2] + src[i - w4 + 2] +
                                            src[i - w2 - 4] + src[i - w2 + 4] +
                                            src[i + w2 - 4] + src[i + w2 + 4] +
                                            src[i + w4 - 2] + src[i + w4 + 2]) +
                             blurmat[11] * (src[i - w4 - 1] + src[i - w4 + 1] +
                                            src[i - w1 - 4] + src[i - w1 + 4] +
                                            src[i + w1 - 4] + src[i + w1 + 4] +
                                            src[i + w4 - 1] + src[i + w4 + 1]) +
                             blurmat[10] * (src[i - w4] + src[i - 4] +
                                            src[i + 4] + src[i + w4]) +
                             blurmat[9] * (src[i - w3 - 3] + src[i - w3 + 3] +
                                           src[i + w3 - 3] + src[i + w3 + 3]) +
                             blurmat[8] * (src[i - w3 - 2] + src[i - w3 + 2] +
                                           src[i - w2 - 3] + src[i - w2 + 3] +
                                           src[i + w2 - 3] + src[i + w2 + 3] +
                                           src[i + w3 - 2] + src[i + w3 + 2]) +
                             blurmat[7] * (src[i - w3 - 1] + src[i - w3 + 1] +
                                           src[i - w1 - 3] + src[i - w1 + 3] +
                                           src[i + w1 - 3] + src[i + w1 + 3] +
                                           src[i + w3 - 1] + src[i + w3 + 1]) +
                             blurmat[6] * (src[i - w3] + src[i - 3] +
                                           src[i + 3] + src[i + w3]) +
                             blurmat[5] * (src[i - w2 - 2] + src[i - w2 + 2] +
                                           src[i + w2 - 2] + src[i + w2 + 2]) +
                             blurmat[4] * (src[i - w2 - 1] + src[i - w2 + 1] +
                                           src[i - w1 - 2] + src[i - w1 + 2] +
                                           src[i + w1 - 2] + src[i + w1 + 2] +
                                           src[i + w2 - 1] + src[i + w2 + 1]) +
                             blurmat[3] * (src[i - w2] + src[i - 2] +
                                           src[i + 2] + src[i + w2]) +
                             blurmat[2] * (src[i - w1 - 1] + src[i - w1 + 1] +
                                           src[i + w1 - 1] + src[i + w1 + 1]) +
                             blurmat[1] * (src[i - w1] + src[i - 1] +
                                           src[i + 1] + src[i + w1]) +
                             blurmat[0] * src[i])));
    }
  }
  dt_masks_extend_border(out, width, height, 4);
}


x86 assembly (clang, -O0):
<dt_masks_blur_9x9>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
lea    -0x50(%rbp),%rdi
movss  -0x1c(%rbp),%xmm0
call   1050 <dt_masks_blur_9x9_coeff@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x58(%rbp)
imul   $0x3,-0x14(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x60(%rbp)
movl   $0x4,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    1820 <dt_masks_blur_9x9+0x6e0>
movl   $0x4,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    180d <dt_masks_blur_9x9+0x6cd>
mov    -0x64(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x60(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x60(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x58(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x58(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x60(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x60(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x5c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x58(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x58(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x5c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x58(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x48(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
call   1040 <fmaxf@plt>
mov    %eax,%edi
movss  0x813(%rip),%xmm0
call   1030 <fminf@plt>
mov    -0x10(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    11a7 <dt_masks_blur_9x9+0x67>
jmp    1812 <dt_masks_blur_9x9+0x6d2>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    118f <dt_masks_blur_9x9+0x4f>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    $0x4,%ecx
call   1060 <dt_masks_extend_border@plt>
add    $0x70,%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    $0x98,%rsp
mov    %ecx,%ebx
mov    %rdx,(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rdi,%r12
lea    0x20(%rsp),%rdi
call   1050 <dt_masks_blur_9x9_coeff@plt>
mov    %rbx,0x18(%rsp)
cmp    $0x9,%ebx
jl     155c <dt_masks_blur_9x9+0x41c>
mov    0x18(%rsp),%rax
add    $0xfffffffc,%eax
mov    %rax,0x60(%rsp)
mov    (%rsp),%rax
lea    0x0(,%rax,4),%ecx
lea    (%rax,%rax,2),%edx
lea    (%rax,%rax,1),%esi
lea    -0x4(%rax),%edi
mov    %rdi,0x8(%rsp)
movslq %edx,%r14
movslq %eax,%rdi
movslq %ecx,%rcx
movslq %esi,%rdx
lea    0x0(,%rdi,4),%rsi
lea    (%rdx,%rdi,4),%r9
lea    (%rcx,%rdi,4),%r10
lea    (%rdi,%rdi,2),%r11
lea    (%rdi,%rdi,4),%r15
lea    (%r14,%rdi,4),%r8
shl    $0x4,%rdi
mov    %rsi,%rbp
sub    %rcx,%rbp
mov    %rsi,%rcx
sub    %rdx,%rcx
mov    %rsi,0x58(%rsp)
mov    %rsi,%rbx
sub    %r14,%rbx
lea    (%r12,%rdi,1),%rsi
mov    %r12,%rax
lea    (%r12,%rbp,4),%r12
add    $0x18,%r12
lea    0x20(%rax,%rcx,4),%r13
lea    0x20(%rax,%r9,4),%rbp
lea    0x18(%rax,%r10,4),%r14
lea    0x20(%rax,%r11,4),%rdx
lea    0x20(%rax,%r15,4),%r15
lea    0x1c(%rax,%rbx,4),%r9
lea    0x1c(%rax,%r8,4),%r10
mov    0x10(%rsp),%rax
lea    0x10(%rdi,%rax,1),%rdi
mov    0x8(%rsp),%rax
lea    -0x10(,%rax,4),%rax
ff
mov    $0x4,%r8d
jmp    1277 <dt_masks_blur_9x9+0x137>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x68(%rsp),%r8
add    $0x1,%r8
mov    0x58(%rsp),%rbx
add    %rbx,%rsi
add    %rbx,%r12
add    %rbx,%r13
add    %rbx,%rbp
add    %rbx,%r14
add    %rbx,%rdx
add    %rbx,%r15
add    %rbx,%r9
add    %rbx,%r10
add    %rbx,%rdi
cmp    0x60(%rsp),%r8
je     155c <dt_masks_blur_9x9+0x41c>
mov    %r8,0x68(%rsp)
cmpl   $0x9,(%rsp)
jl     1240 <dt_masks_blur_9x9+0x100>
xor    %ebx,%ebx
mov    %rsi,0x8(%rsp)
mov    %r12,0x90(%rsp)
mov    %r13,0x88(%rsp)
mov    %rbp,0x80(%rsp)
mov    %r14,0x78(%rsp)
mov    %rdx,0x70(%rsp)
nopl   0x0(%rax,%rax,1)
movss  -0x10(%r12,%rbx,1),%xmm0
movss  -0xc(%r12,%rbx,1),%xmm1
addss  (%r12,%rbx,1),%xmm0
addss  -0x20(%r13,%rbx,1),%xmm0
addss  0x0(%r13,%rbx,1),%xmm0
addss  -0x20(%rbp,%rbx,1),%xmm0
addss  0x0(%rbp,%rbx,1),%xmm0
addss  -0x10(%r14,%rbx,1),%xmm0
addss  (%r14,%rbx,1),%xmm0
addss  -0x4(%r12,%rbx,1),%xmm1
addss  -0x20(%rdx,%rbx,1),%xmm1
addss  (%rdx,%rbx,1),%xmm1
addss  -0x20(%r15,%rbx,1),%xmm1
addss  (%r15,%rbx,1),%xmm1
addss  -0xc(%r14,%rbx,1),%xmm1
addss  -0x4(%r14,%rbx,1),%xmm1
mulss  0x4c(%rsp),%xmm1
mulss  0x50(%rsp),%xmm0
movss  -0x8(%r12,%rbx,1),%xmm2
addss  (%rsi,%rbx,1),%xmm2
addss  0x20(%rsi,%rbx,1),%xmm2
addss  -0x8(%r14,%rbx,1),%xmm2
mulss  0x48(%rsp),%xmm2
addss  %xmm1,%xmm0
addss  %xmm0,%xmm2
movss  -0x18(%r9,%rbx,1),%xmm1
movss  -0x14(%r9,%rbx,1),%xmm0
addss  (%r9,%rbx,1),%xmm1
addss  -0x18(%r10,%rbx,1),%xmm1
addss  (%r10,%rbx,1),%xmm1
mulss  0x44(%rsp),%xmm1
addss  -0x4(%r9,%rbx,1),%xmm0
addss  -0x1c(%r13,%rbx,1),%xmm0
addss  -0x4(%r13,%rbx,1),%xmm0
addss  -0x1c(%rbp,%rbx,1),%xmm0
addss  -0x4(%rbp,%rbx,1),%xmm0
addss  -0x14(%r10,%rbx,1),%xmm0
addss  -0x4(%r10,%rbx,1),%xmm0
mulss  0x40(%rsp),%xmm0
addss  %xmm2,%xmm1
movss  -0x10(%r9,%rbx,1),%xmm2
addss  -0x8(%r9,%rbx,1),%xmm2
addss  -0x1c(%rdx,%rbx,1),%xmm2
addss  -0x4(%rdx,%rbx,1),%xmm2
addss  -0x1c(%r15,%rbx,1),%xmm2
addss  -0x4(%r15,%rbx,1),%xmm2
addss  -0x10(%r10,%rbx,1),%xmm2
addss  -0x8(%r10,%rbx,1),%xmm2
addss  %xmm1,%xmm0
mulss  0x3c(%rsp),%xmm2
movss  -0xc(%r9,%rbx,1),%xmm1
addss  0x4(%rsi,%rbx,1),%xmm1
addss  0x1c(%rsi,%rbx,1),%xmm1
addss  -0xc(%r10,%rbx,1),%xmm1
mulss  0x38(%rsp),%xmm1
addss  %xmm0,%xmm2
addss  %xmm2,%xmm1
movss  -0x18(%r13,%rbx,1),%xmm2
movss  -0x14(%r13,%rbx,1),%xmm0
addss  -0x8(%r13,%rbx,1),%xmm2
addss  -0x18(%rbp,%rbx,1),%xmm2
addss  -0x8(%rbp,%rbx,1),%xmm2
mulss  0x34(%rsp),%xmm2
addss  -0xc(%r13,%rbx,1),%xmm0
addss  -0x18(%rdx,%rbx,1),%xmm0
addss  -0x8(%rdx,%rbx,1),%xmm0
addss  -0x18(%r15,%rbx,1),%xmm0
addss  -0x8(%r15,%rbx,1),%xmm0
addss  -0x14(%rbp,%rbx,1),%xmm0
addss  -0xc(%rbp,%rbx,1),%xmm0
mulss  0x30(%rsp),%xmm0
addss  %xmm1,%xmm2
movss  -0x10(%r13,%rbx,1),%xmm1
addss  0x8(%rsi,%rbx,1),%xmm1
addss  0x18(%rsi,%rbx,1),%xmm1
addss  -0x10(%rbp,%rbx,1),%xmm1
addss  %xmm2,%xmm0
mulss  0x2c(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  -0x14(%rdx,%rbx,1),%xmm0
movss  -0x10(%rdx,%rbx,1),%xmm2
addss  -0xc(%rdx,%rbx,1),%xmm0
addss  -0x14(%r15,%rbx,1),%xmm0
addss  -0xc(%r15,%rbx,1),%xmm0
mulss  0x28(%rsp),%xmm0
addss  0xc(%rsi,%rbx,1),%xmm2
addss  0x14(%rsi,%rbx,1),%xmm2
addss  -0x10(%r15,%rbx,1),%xmm2
addss  %xmm1,%xmm0
mulss  0x24(%rsp),%xmm2
addss  %xmm0,%xmm2
movss  0x20(%rsp),%xmm1
mulss  0x10(%rsi,%rbx,1),%xmm1
addss  %xmm2,%xmm1
xorps  %xmm0,%xmm0
mov    %r9,%r12
mov    %r10,%r13
mov    %rdi,%rbp
mov    %rax,%r14
call   1040 <fmaxf@plt>
movss  0xaf5(%rip),%xmm0
mov    %eax,%edi
call   1030 <fminf@plt>
mov    %r14,%rax
mov    %rbp,%rdi
mov    %r13,%r10
mov    %r12,%r9
mov    0x70(%rsp),%rdx
mov    0x78(%rsp),%r14
mov    0x80(%rsp),%rbp
mov    0x88(%rsp),%r13
mov    0x90(%rsp),%r12
mov    0x8(%rsp),%rsi
movss  %xmm0,(%rdi,%rbx,1)
add    $0x4,%rbx
cmp    %rbx,%rax
jne    12b0 <dt_masks_blur_9x9+0x170>
jmp    1240 <dt_masks_blur_9x9+0x100>
mov    0x10(%rsp),%rdi
mov    (%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    $0x4,%ecx
call   1060 <dt_masks_extend_border@plt>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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