void kern_r4_fma_u1_f(double *restrict o0, double *restrict o1,
                      double *restrict o2, double *restrict o3,
                      const double *i0, const double *w, const double *w2,
                      long bsize, long blocks) {
  long i;
  for (i = 0; i < blocks; i++) {
    double wr1, wi1;
    double wr2, wi2;
    double wr3, wi13;
    double pr1, pi1;
    double pr2, pi2;
    double pr3, pi3;
    double qr0, qi0;
    double qr1, qi1;
    double qr2, qi2;
    double qr3, qi3;
    wr1 = w[2 * i];
    wi1 = w[2 * i + 1];
    pr1 = i0[8 * i + 2] * wr1 + i0[8 * i + 3];
    pi1 = i0[8 * i + 3] * wr1 - i0[8 * i + 2];
    wr3 = w2[2 * i];
    wi13 = w2[2 * i + 1];
    pr3 = i0[8 * i + 6] * wr3 + i0[8 * i + 7];
    pi3 = i0[8 * i + 7] * wr3 - i0[8 * i + 6];
    wr2 = w[4 * i];
    wi2 = w[4 * i + 1];
    pr2 = i0[8 * i + 4] * wr2 + i0[8 * i + 5];
    pi2 = i0[8 * i + 5] * wr2 - i0[8 * i + 4];
    qr1 = pr1 + pr3 * wi13;
    qr3 = pr1 - pr3 * wi13;
    qi1 = pi1 + pi3 * wi13;
    qi3 = pi1 - pi3 * wi13;
    qr0 = i0[8 * i] + pr2 * wi2;
    qr2 = i0[8 * i] - pr2 * wi2;
    qi0 = i0[8 * i + 1] + pi2 * wi2;
    qi2 = i0[8 * i + 1] - pi2 * wi2;
    o0[2 * i] = qr0 + qr1 * wi1;
    o0[2 * i + 1] = qi0 + qi1 * wi1;
    o2[2 * i] = qr0 - qr1 * wi1;
    o2[2 * i + 1] = qi0 - qi1 * wi1;
    o1[2 * i] = qr2 + qi3 * wi1;
    o1[2 * i + 1] = qi2 - qr3 * wi1;
    o3[2 * i] = qr2 - qi3 * wi1;
    o3[2 * i + 1] = qi2 + qr3 * wi1;
  }
}


x86 assembly (clang, -O0):
<kern_r4_fma_u1_f>:
push   %rbp
mov    %rsp,%rbp
sub    $0x58,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    0x20(%rbp),%rax
jge    16d4 <kern_r4_fma_u1_f+0x5d4>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x10(%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x30(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x38(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x38(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x30(%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x28(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x28(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x20(%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1134 <kern_r4_fma_u1_f+0x34>
add    $0x58,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r4_fma_u1_f>:
push   %r15
push   %r14
push   %r12
push   %rbx
mov    0x38(%rsp),%r11
test   %r11,%r11
jle    1554 <kern_r4_fma_u1_f+0x454>
mov    %rdx,%r10
mov    0x28(%rsp),%r12
cmp    $0x3,%r11
jae    112b <kern_r4_fma_u1_f+0x2b>
xor    %r14d,%r14d
jmp    13ca <kern_r4_fma_u1_f+0x2ca>
lea    -0x1(%r11),%rax
lea    0x8(%rdi),%r15
mov    $0x10,%edx
mul    %rdx
seto   %dl
lea    (%rdi,%rax,1),%rbx
add    $0x8,%rbx
xor    %r14d,%r14d
cmp    %r15,%rbx
jb     13ca <kern_r4_fma_u1_f+0x2ca>
test   %dl,%dl
jne    13ca <kern_r4_fma_u1_f+0x2ca>
lea    0x8(%r10),%r15
lea    (%r10,%rax,1),%rbx
add    $0x8,%rbx
cmp    %r15,%rbx
jb     13ca <kern_r4_fma_u1_f+0x2ca>
test   %dl,%dl
jne    13ca <kern_r4_fma_u1_f+0x2ca>
lea    0x8(%rsi),%r15
lea    (%rsi,%rax,1),%rbx
add    $0x8,%rbx
cmp    %r15,%rbx
jb     13ca <kern_r4_fma_u1_f+0x2ca>
test   %dl,%dl
jne    13ca <kern_r4_fma_u1_f+0x2ca>
lea    0x8(%rcx),%rbx
add    %rcx,%rax
add    $0x8,%rax
cmp    %rbx,%rax
jb     13ca <kern_r4_fma_u1_f+0x2ca>
test   %dl,%dl
jne    13ca <kern_r4_fma_u1_f+0x2ca>
mov    %r11d,%eax
and    $0x1,%eax
test   %rax,%rax
mov    $0x2,%edx
cmovne %rax,%rdx
mov    %r11,%r14
sub    %rdx,%r14
xor    %eax,%eax
mov    %r14,%rdx
nopl   (%rax)
movupd (%r9,%rax,1),%xmm8
movupd 0x10(%r9,%rax,1),%xmm0
movapd %xmm8,%xmm1
unpcklpd %xmm0,%xmm1
unpckhpd %xmm0,%xmm8
movupd 0x70(%r8,%rax,4),%xmm11
movupd 0x60(%r8,%rax,4),%xmm6
movupd 0x50(%r8,%rax,4),%xmm7
movupd 0x40(%r8,%rax,4),%xmm4
movupd (%r8,%rax,4),%xmm9
movupd 0x10(%r8,%rax,4),%xmm14
movupd 0x20(%r8,%rax,4),%xmm13
movupd 0x30(%r8,%rax,4),%xmm2
movapd %xmm9,%xmm12
unpcklpd %xmm4,%xmm12
unpckhpd %xmm4,%xmm9
movapd %xmm14,%xmm3
unpcklpd %xmm7,%xmm3
unpckhpd %xmm7,%xmm14
movapd %xmm13,%xmm10
unpcklpd %xmm6,%xmm10
unpckhpd %xmm6,%xmm13
movapd %xmm2,%xmm6
unpcklpd %xmm11,%xmm6
unpckhpd %xmm11,%xmm2
movapd %xmm3,%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm14,%xmm4
mulpd  %xmm1,%xmm14
subpd  %xmm3,%xmm14
movupd (%r12,%rax,1),%xmm1
movupd 0x10(%r12,%rax,1),%xmm3
movapd %xmm1,%xmm7
unpcklpd %xmm3,%xmm7
unpckhpd %xmm3,%xmm1
movapd %xmm6,%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm7
subpd  %xmm6,%xmm7
movupd (%r9,%rax,2),%xmm11
movupd 0x20(%r9,%rax,2),%xmm5
movapd %xmm11,%xmm2
unpcklpd %xmm5,%xmm2
unpckhpd %xmm5,%xmm11
movapd %xmm10,%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm13,%xmm6
mulpd  %xmm13,%xmm2
subpd  %xmm10,%xmm2
mulpd  %xmm1,%xmm3
movapd %xmm3,%xmm5
addpd  %xmm4,%xmm5
subpd  %xmm3,%xmm4
mulpd  %xmm1,%xmm7
movapd %xmm7,%xmm1
addpd  %xmm14,%xmm1
subpd  %xmm7,%xmm14
mulpd  %xmm11,%xmm6
movapd %xmm6,%xmm3
addpd  %xmm12,%xmm3
subpd  %xmm6,%xmm12
mulpd  %xmm11,%xmm2
movapd %xmm2,%xmm6
addpd  %xmm9,%xmm6
subpd  %xmm2,%xmm9
mulpd  %xmm8,%xmm5
movapd %xmm5,%xmm2
addpd  %xmm3,%xmm2
mulpd  %xmm8,%xmm1
movapd %xmm1,%xmm7
addpd  %xmm6,%xmm7
movapd %xmm2,%xmm0
unpcklpd %xmm7,%xmm0
movhlps %xmm2,%xmm7
movups %xmm7,0x10(%rdi,%rax,1)
movupd %xmm0,(%rdi,%rax,1)
subpd  %xmm5,%xmm3
subpd  %xmm1,%xmm6
movapd %xmm3,%xmm0
unpcklpd %xmm6,%xmm0
movhlps %xmm3,%xmm6
movups %xmm6,0x10(%r10,%rax,1)
movupd %xmm0,(%r10,%rax,1)
mulpd  %xmm8,%xmm14
movapd %xmm14,%xmm0
addpd  %xmm12,%xmm0
mulpd  %xmm8,%xmm4
movapd %xmm9,%xmm1
subpd  %xmm4,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rsi,%rax,1)
movupd %xmm2,(%rsi,%rax,1)
subpd  %xmm14,%xmm12
addpd  %xmm9,%xmm4
movapd %xmm12,%xmm0
unpcklpd %xmm4,%xmm0
movhlps %xmm12,%xmm4
movups %xmm4,0x10(%rcx,%rax,1)
movupd %xmm0,(%rcx,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rdx
jne    11d0 <kern_r4_fma_u1_f+0xd0>
sub    %r14,%r11
mov    %r14,%rax
shl    $0x4,%rax
lea    (%r9,%rax,1),%r15
add    $0x8,%r15
add    %rax,%r12
add    $0x8,%r12
add    %rax,%rdi
add    %rax,%r10
add    %rax,%rsi
add    %rax,%rcx
mov    %r14,%rax
shl    $0x6,%rax
lea    (%rax,%r8,1),%rbx
add    $0x30,%rbx
shl    $0x5,%r14
lea    (%r14,%r9,1),%rax
add    $0x8,%rax
xor    %edx,%edx
movapd 0xbeb(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%rbx,%rdx,4),%xmm9
movupd -0x20(%rbx,%rdx,4),%xmm3
movupd -0x10(%rbx,%rdx,4),%xmm4
movupd (%rbx,%rdx,4),%xmm0
movsd  -0x8(%r15,%rdx,1),%xmm2
unpcklpd %xmm2,%xmm2
movapd %xmm3,%xmm5
mulpd  %xmm3,%xmm2
movapd %xmm3,%xmm6
xorpd  %xmm8,%xmm6
movsd  (%r15,%rdx,1),%xmm3
shufpd $0x1,%xmm6,%xmm5
addpd  %xmm5,%xmm2
movsd  (%r12,%rdx,1),%xmm5
movsd  -0x8(%r12,%rdx,1),%xmm6
unpcklpd %xmm6,%xmm6
movapd %xmm0,%xmm7
mulpd  %xmm0,%xmm6
xorpd  %xmm8,%xmm0
shufpd $0x1,%xmm0,%xmm7
addpd  %xmm7,%xmm6
movsd  -0x8(%rax,%rdx,2),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm4,%xmm7
mulpd  %xmm4,%xmm0
xorpd  %xmm8,%xmm4
movsd  (%rax,%rdx,2),%xmm1
shufpd $0x1,%xmm4,%xmm7
addpd  %xmm7,%xmm0
movapd %xmm6,%xmm7
mulsd  %xmm5,%xmm7
movapd %xmm2,%xmm4
subsd  %xmm7,%xmm4
movapd %xmm5,%xmm7
unpcklpd %xmm5,%xmm7
mulpd  %xmm6,%xmm7
addpd  %xmm2,%xmm7
unpckhpd %xmm6,%xmm6
unpckhpd %xmm2,%xmm2
mulsd  %xmm5,%xmm6
subsd  %xmm6,%xmm2
unpcklpd %xmm1,%xmm1
mulpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
addpd  %xmm9,%xmm0
subpd  %xmm1,%xmm9
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm7
movapd %xmm7,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rdi,%rdx,1)
subpd  %xmm7,%xmm0
movupd %xmm0,(%r10,%rdx,1)
movapd %xmm2,%xmm0
xorpd  %xmm8,%xmm2
unpcklpd %xmm4,%xmm2
xorpd  %xmm8,%xmm4
unpcklpd %xmm4,%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm9,%xmm0
movupd %xmm0,(%rsi,%rdx,1)
mulpd  %xmm3,%xmm2
addpd  %xmm9,%xmm2
movupd %xmm2,(%rcx,%rdx,1)
add    $0x10,%rdx
add    $0xffffffffffffffff,%r11
jne    1420 <kern_r4_fma_u1_f+0x320>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @kern_r4_fma_u1_f(double* noalias %0, double* noalias %1, double* noalias %2, double* noalias %3, double* %4, double* %5, double* %6, i64 %7, i64 %8) {
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca double
store double* %0, double** %10
store double* %1, double** %11
store double* %2, double** %12
store double* %3, double** %13
store double* %4, double** %14
store double* %5, double** %15
store double* %6, double** %16
store i64 %7, i64* %17
store i64 %8, i64* %18
store i64 0, i64* %19
br label %40
40: ; preds = %291, %9
%41 = load i64, i64* %19
%42 = load i64, i64* %18
%43 = icmp slt i64 %41, %42
br i1 %43, label %44, label %294
44: ; preds = %40
%45 = load double*, double** %15
%46 = load i64, i64* %19
%47 = mul nsw i64 2, %46
%48 = getelementptr inbounds double, double* %45, i64 %47
%49 = load double, double* %48
store double %49, double* %20
%50 = load double*, double** %15
%51 = load i64, i64* %19
%52 = mul nsw i64 2, %51
%53 = add nsw i64 %52, 1
%54 = getelementptr inbounds double, double* %50, i64 %53
%55 = load double, double* %54
store double %55, double* %21
%56 = load double*, double** %14
%57 = load i64, i64* %19
%58 = mul nsw i64 8, %57
%59 = add nsw i64 %58, 2
%60 = getelementptr inbounds double, double* %56, i64 %59
%61 = load double, double* %60
%62 = load double, double* %20
%63 = load double*, double** %14
%64 = load i64, i64* %19
%65 = mul nsw i64 8, %64
%66 = add nsw i64 %65, 3
%67 = getelementptr inbounds double, double* %63, i64 %66
%68 = load double, double* %67
%69 = call double @llvm.fmuladd.f64(double %61, double %62, double %68)
store double %69, double* %26
%70 = load double*, double** %14
%71 = load i64, i64* %19
%72 = mul nsw i64 8, %71
%73 = add nsw i64 %72, 3
%74 = getelementptr inbounds double, double* %70, i64 %73
%75 = load double, double* %74
%76 = load double, double* %20
%77 = load double*, double** %14
%78 = load i64, i64* %19
%79 = mul nsw i64 8, %78
%80 = add nsw i64 %79, 2
%81 = getelementptr inbounds double, double* %77, i64 %80
%82 = load double, double* %81
%83 = fneg double %82
%84 = call double @llvm.fmuladd.f64(double %75, double %76, double %83)
store double %84, double* %27
%85 = load double*, double** %16
%86 = load i64, i64* %19
%87 = mul nsw i64 2, %86
%88 = getelementptr inbounds double, double* %85, i64 %87
%89 = load double, double* %88
store double %89, double* %24
%90 = load double*, double** %16
%91 = load i64, i64* %19
%92 = mul nsw i64 2, %91
%93 = add nsw i64 %92, 1
%94 = getelementptr inbounds double, double* %90, i64 %93
%95 = load double, double* %94
store double %95, double* %25
%96 = load double*, double** %14
%97 = load i64, i64* %19
%98 = mul nsw i64 8, %97
%99 = add nsw i64 %98, 6
%100 = getelementptr inbounds double, double* %96, i64 %99
%101 = load double, double* %100
%102 = load double, double* %24
%103 = load double*, double** %14
%104 = load i64, i64* %19
%105 = mul nsw i64 8, %104
%106 = add nsw i64 %105, 7
%107 = getelementptr inbounds double, double* %103, i64 %106
%108 = load double, double* %107
%109 = call double @llvm.fmuladd.f64(double %101, double %102, double %108)
store double %109, double* %30
%110 = load double*, double** %14
%111 = load i64, i64* %19
%112 = mul nsw i64 8, %111
%113 = add nsw i64 %112, 7
%114 = getelementptr inbounds double, double* %110, i64 %113
%115 = load double, double* %114
%116 = load double, double* %24
%117 = load double*, double** %14
%118 = load i64, i64* %19
%119 = mul nsw i64 8, %118
%120 = add nsw i64 %119, 6
%121 = getelementptr inbounds double, double* %117, i64 %120
%122 = load double, double* %121
%123 = fneg double %122
%124 = call double @llvm.fmuladd.f64(double %115, double %116, double %123)
store double %124, double* %31
%125 = load double*, double** %15
%126 = load i64, i64* %19
%127 = mul nsw i64 4, %126
%128 = getelementptr inbounds double, double* %125, i64 %127
%129 = load double, double* %128
store double %129, double* %22
%130 = load double*, double** %15
%131 = load i64, i64* %19
%132 = mul nsw i64 4, %131
%133 = add nsw i64 %132, 1
%134 = getelementptr inbounds double, double* %130, i64 %133
%135 = load double, double* %134
store double %135, double* %23
%136 = load double*, double** %14
%137 = load i64, i64* %19
%138 = mul nsw i64 8, %137
%139 = add nsw i64 %138, 4
%140 = getelementptr inbounds double, double* %136, i64 %139
%141 = load double, double* %140
%142 = load double, double* %22
%143 = load double*, double** %14
%144 = load i64, i64* %19
%145 = mul nsw i64 8, %144
%146 = add nsw i64 %145, 5
%147 = getelementptr inbounds double, double* %143, i64 %146
%148 = load double, double* %147
%149 = call double @llvm.fmuladd.f64(double %141, double %142, double %148)
store double %149, double* %28
%150 = load double*, double** %14
%151 = load i64, i64* %19
%152 = mul nsw i64 8, %151
%153 = add nsw i64 %152, 5
%154 = getelementptr inbounds double, double* %150, i64 %153
%155 = load double, double* %154
%156 = load double, double* %22
%157 = load double*, double** %14
%158 = load i64, i64* %19
%159 = mul nsw i64 8, %158
%160 = add nsw i64 %159, 4
%161 = getelementptr inbounds double, double* %157, i64 %160
%162 = load double, double* %161
%163 = fneg double %162
%164 = call double @llvm.fmuladd.f64(double %155, double %156, double %163)
store double %164, double* %29
%165 = load double, double* %26
%166 = load double, double* %30
%167 = load double, double* %25
%168 = call double @llvm.fmuladd.f64(double %166, double %167, double %165)
store double %168, double* %34
%169 = load double, double* %26
%170 = load double, double* %30
%171 = load double, double* %25
%172 = fneg double %170
%173 = call double @llvm.fmuladd.f64(double %172, double %171, double %169)
store double %173, double* %38
%174 = load double, double* %27
%175 = load double, double* %31
%176 = load double, double* %25
%177 = call double @llvm.fmuladd.f64(double %175, double %176, double %174)
store double %177, double* %35
%178 = load double, double* %27
%179 = load double, double* %31
%180 = load double, double* %25
%181 = fneg double %179
%182 = call double @llvm.fmuladd.f64(double %181, double %180, double %178)
store double %182, double* %39
%183 = load double*, double** %14
%184 = load i64, i64* %19
%185 = mul nsw i64 8, %184
%186 = getelementptr inbounds double, double* %183, i64 %185
%187 = load double, double* %186
%188 = load double, double* %28
%189 = load double, double* %23
%190 = call double @llvm.fmuladd.f64(double %188, double %189, double %187)
store double %190, double* %32
%191 = load double*, double** %14
%192 = load i64, i64* %19
%193 = mul nsw i64 8, %192
%194 = getelementptr inbounds double, double* %191, i64 %193
%195 = load double, double* %194
%196 = load double, double* %28
%197 = load double, double* %23
%198 = fneg double %196
%199 = call double @llvm.fmuladd.f64(double %198, double %197, double %195)
store double %199, double* %36
%200 = load double*, double** %14
%201 = load i64, i64* %19
%202 = mul nsw i64 8, %201
%203 = add nsw i64 %202, 1
%204 = getelementptr inbounds double, double* %200, i64 %203
%205 = load double, double* %204
%206 = load double, double* %29
%207 = load double, double* %23
%208 = call double @llvm.fmuladd.f64(double %206, double %207, double %205)
store double %208, double* %33
%209 = load double*, double** %14
%210 = load i64, i64* %19
%211 = mul nsw i64 8, %210
%212 = add nsw i64 %211, 1
%213 = getelementptr inbounds double, double* %209, i64 %212
%214 = load double, double* %213
%215 = load double, double* %29
%216 = load double, double* %23
%217 = fneg double %215
%218 = call double @llvm.fmuladd.f64(double %217, double %216, double %214)
store double %218, double* %37
%219 = load double, double* %32
%220 = load double, double* %34
%221 = load double, double* %21
%222 = call double @llvm.fmuladd.f64(double %220, double %221, double %219)
%223 = load double*, double** %10
%224 = load i64, i64* %19
%225 = mul nsw i64 2, %224
%226 = getelementptr inbounds double, double* %223, i64 %225
store double %222, double* %226
%227 = load double, double* %33
%228 = load double, double* %35
%229 = load double, double* %21
%230 = call double @llvm.fmuladd.f64(double %228, double %229, double %227)
%231 = load double*, double** %10
%232 = load i64, i64* %19
%233 = mul nsw i64 2, %232
%234 = add nsw i64 %233, 1
%235 = getelementptr inbounds double, double* %231, i64 %234
store double %230, double* %235
%236 = load double, double* %32
%237 = load double, double* %34
%238 = load double, double* %21
%239 = fneg double %237
%240 = call double @llvm.fmuladd.f64(double %239, double %238, double %236)
%241 = load double*, double** %12
%242 = load i64, i64* %19
%243 = mul nsw i64 2, %242
%244 = getelementptr inbounds double, double* %241, i64 %243
store double %240, double* %244
%245 = load double, double* %33
%246 = load double, double* %35
%247 = load double, double* %21
%248 = fneg double %246
%249 = call double @llvm.fmuladd.f64(double %248, double %247, double %245)
%250 = load double*, double** %12
%251 = load i64, i64* %19
%252 = mul nsw i64 2, %251
%253 = add nsw i64 %252, 1
%254 = getelementptr inbounds double, double* %250, i64 %253
store double %249, double* %254
%255 = load double, double* %36
%256 = load double, double* %39
%257 = load double, double* %21
%258 = call double @llvm.fmuladd.f64(double %256, double %257, double %255)
%259 = load double*, double** %11
%260 = load i64, i64* %19
%261 = mul nsw i64 2, %260
%262 = getelementptr inbounds double, double* %259, i64 %261
store double %258, double* %262
%263 = load double, double* %37
%264 = load double, double* %38
%265 = load double, double* %21
%266 = fneg double %264
%267 = call double @llvm.fmuladd.f64(double %266, double %265, double %263)
%268 = load double*, double** %11
%269 = load i64, i64* %19
%270 = mul nsw i64 2, %269
%271 = add nsw i64 %270, 1
%272 = getelementptr inbounds double, double* %268, i64 %271
store double %267, double* %272
%273 = load double, double* %36
%274 = load double, double* %39
%275 = load double, double* %21
%276 = fneg double %274
%277 = call double @llvm.fmuladd.f64(double %276, double %275, double %273)
%278 = load double*, double** %13
%279 = load i64, i64* %19
%280 = mul nsw i64 2, %279
%281 = getelementptr inbounds double, double* %278, i64 %280
store double %277, double* %281
%282 = load double, double* %37
%283 = load double, double* %38
%284 = load double, double* %21
%285 = call double @llvm.fmuladd.f64(double %283, double %284, double %282)
%286 = load double*, double** %13
%287 = load i64, i64* %19
%288 = mul nsw i64 2, %287
%289 = add nsw i64 %288, 1
%290 = getelementptr inbounds double, double* %286, i64 %289
store double %285, double* %290
br label %291
291: ; preds = %44
%292 = load i64, i64* %19
%293 = add nsw i64 %292, 1
store i64 %293, i64* %19
br label %40
294: ; preds = %40
ret void
}

LLVM IR (-O2):
define void @kern_r4_fma_u1_f(double* noalias nocapture writeonly %0, double* noalias nocapture writeonly %1, double* noalias nocapture writeonly %2, double* noalias nocapture writeonly %3, double* nocapture %4, double* nocapture %5, double* nocapture %6, i64 %7, i64 %8) {
%10 = icmp sgt i64 %8, 0
br i1 %10, label %11, label %239
11: ; preds = %9
%12 = icmp ult i64 %8, 3
br i1 %12, label %140, label %13
13: ; preds = %11
%14 = add i64 %8, -1
%15 = getelementptr double, double* %0, i64 1
%16 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %14, i64 16)
%17 = extractvalue { i64, i1 } %16, 0
%18 = extractvalue { i64, i1 } %16, 1
%19 = bitcast double* %15 to i8*
%20 = getelementptr i8, i8* %19, i64 %17
%21 = icmp ult i8* %20, %19
%22 = or i1 %21, %18
%23 = getelementptr double, double* %2, i64 1
%24 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %14, i64 16)
%25 = extractvalue { i64, i1 } %24, 0
%26 = extractvalue { i64, i1 } %24, 1
%27 = bitcast double* %23 to i8*
%28 = getelementptr i8, i8* %27, i64 %25
%29 = icmp ult i8* %28, %27
%30 = or i1 %29, %26
%31 = getelementptr double, double* %1, i64 1
%32 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %14, i64 16)
%33 = extractvalue { i64, i1 } %32, 0
%34 = extractvalue { i64, i1 } %32, 1
%35 = bitcast double* %31 to i8*
%36 = getelementptr i8, i8* %35, i64 %33
%37 = icmp ult i8* %36, %35
%38 = or i1 %37, %34
%39 = getelementptr double, double* %3, i64 1
%40 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %14, i64 16)
%41 = extractvalue { i64, i1 } %40, 0
%42 = extractvalue { i64, i1 } %40, 1
%43 = bitcast double* %39 to i8*
%44 = getelementptr i8, i8* %43, i64 %41
%45 = icmp ult i8* %44, %43
%46 = or i1 %45, %42
%47 = or i1 %22, %30
%48 = or i1 %47, %38
%49 = or i1 %48, %46
br i1 %49, label %140, label %50
50: ; preds = %13
%51 = and i64 %8, 1
%52 = icmp eq i64 %51, 0
%53 = select i1 %52, i64 2, i64 %51
%54 = sub i64 %8, %53
%55 = getelementptr inbounds double, double* %4, i64 -2
%56 = getelementptr inbounds double, double* %0, i64 -1
%57 = getelementptr inbounds double, double* %2, i64 -1
%58 = getelementptr inbounds double, double* %1, i64 -1
%59 = getelementptr inbounds double, double* %3, i64 -1
br label %60
60: ; preds = %60, %50
%61 = phi i64 [ 0, %50 ], [ %138, %60 ]
%62 = shl nuw nsw i64 %61, 1
%63 = getelementptr inbounds double, double* %5, i64 %62
%64 = bitcast double* %63 to <4 x double>*
%65 = load <4 x double>, <4 x double>* %64
%66 = shufflevector <4 x double> %65, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%67 = shufflevector <4 x double> %65, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%68 = or i64 %62, 1
%69 = shl nsw i64 %61, 3
%70 = or i64 %69, 2
%71 = getelementptr inbounds double, double* %55, i64 %70
%72 = bitcast double* %71 to <16 x double>*
%73 = load <16 x double>, <16 x double>* %72
%74 = shufflevector <16 x double> %73, <16 x double> poison, <2 x i32> <i32 0, i32 8>
%75 = shufflevector <16 x double> %73, <16 x double> poison, <2 x i32> <i32 1, i32 9>
%76 = shufflevector <16 x double> %73, <16 x double> poison, <2 x i32> <i32 2, i32 10>
%77 = shufflevector <16 x double> %73, <16 x double> poison, <2 x i32> <i32 3, i32 11>
%78 = shufflevector <16 x double> %73, <16 x double> poison, <2 x i32> <i32 4, i32 12>
%79 = shufflevector <16 x double> %73, <16 x double> poison, <2 x i32> <i32 5, i32 13>
%80 = shufflevector <16 x double> %73, <16 x double> poison, <2 x i32> <i32 6, i32 14>
%81 = shufflevector <16 x double> %73, <16 x double> poison, <2 x i32> <i32 7, i32 15>
%82 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %76, <2 x double> %66, <2 x double> %77)
%83 = fneg <2 x double> %76
%84 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %77, <2 x double> %66, <2 x double> %83)
%85 = getelementptr inbounds double, double* %6, i64 %62
%86 = bitcast double* %85 to <4 x double>*
%87 = load <4 x double>, <4 x double>* %86
%88 = shufflevector <4 x double> %87, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%89 = shufflevector <4 x double> %87, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%90 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %80, <2 x double> %88, <2 x double> %81)
%91 = fneg <2 x double> %80
%92 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %81, <2 x double> %88, <2 x double> %91)
%93 = shl nsw i64 %61, 2
%94 = getelementptr inbounds double, double* %5, i64 %93
%95 = bitcast double* %94 to <8 x double>*
%96 = load <8 x double>, <8 x double>* %95
%97 = shufflevector <8 x double> %96, <8 x double> poison, <2 x i32> <i32 0, i32 4>
%98 = shufflevector <8 x double> %96, <8 x double> poison, <2 x i32> <i32 1, i32 5>
%99 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %78, <2 x double> %97, <2 x double> %79)
%100 = fneg <2 x double> %78
%101 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %79, <2 x double> %97, <2 x double> %100)
%102 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %90, <2 x double> %89, <2 x double> %82)
%103 = fneg <2 x double> %90
%104 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %103, <2 x double> %89, <2 x double> %82)
%105 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %92, <2 x double> %89, <2 x double> %84)
%106 = fneg <2 x double> %92
%107 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %106, <2 x double> %89, <2 x double> %84)
%108 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> %98, <2 x double> %74)
%109 = fneg <2 x double> %99
%110 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %109, <2 x double> %98, <2 x double> %74)
%111 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %101, <2 x double> %98, <2 x double> %75)
%112 = fneg <2 x double> %101
%113 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %112, <2 x double> %98, <2 x double> %75)
%114 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %102, <2 x double> %67, <2 x double> %108)
%115 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %105, <2 x double> %67, <2 x double> %111)
%116 = getelementptr inbounds double, double* %56, i64 %68
%117 = bitcast double* %116 to <4 x double>*
%118 = shufflevector <2 x double> %114, <2 x double> %115, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %118, <4 x double>* %117
%119 = fneg <2 x double> %102
%120 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %119, <2 x double> %67, <2 x double> %108)
%121 = fneg <2 x double> %105
%122 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %121, <2 x double> %67, <2 x double> %111)
%123 = getelementptr inbounds double, double* %57, i64 %68
%124 = bitcast double* %123 to <4 x double>*
%125 = shufflevector <2 x double> %120, <2 x double> %122, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %125, <4 x double>* %124
%126 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %107, <2 x double> %67, <2 x double> %110)
%127 = fneg <2 x double> %104
%128 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %127, <2 x double> %67, <2 x double> %113)
%129 = getelementptr inbounds double, double* %58, i64 %68
%130 = bitcast double* %129 to <4 x double>*
%131 = shufflevector <2 x double> %126, <2 x double> %128, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %131, <4 x double>* %130
%132 = fneg <2 x double> %107
%133 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %132, <2 x double> %67, <2 x double> %110)
%134 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %104, <2 x double> %67, <2 x double> %113)
%135 = getelementptr inbounds double, double* %59, i64 %68
%136 = bitcast double* %135 to <4 x double>*
%137 = shufflevector <2 x double> %133, <2 x double> %134, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %137, <4 x double>* %136
%138 = add nuw i64 %61, 2
%139 = icmp eq i64 %138, %54
br i1 %139, label %140, label %60
140: ; preds = %60, %13, %11
%141 = phi i64 [ 0, %13 ], [ 0, %11 ], [ %54, %60 ]
br label %142
142: ; preds = %140, %142
%143 = phi i64 [ %237, %142 ], [ %141, %140 ]
%144 = shl nuw nsw i64 %143, 1
%145 = getelementptr inbounds double, double* %5, i64 %144
%146 = load double, double* %145
%147 = or i64 %144, 1
%148 = getelementptr inbounds double, double* %5, i64 %147
%149 = load double, double* %148
%150 = shl nsw i64 %143, 3
%151 = or i64 %150, 2
%152 = getelementptr inbounds double, double* %4, i64 %151
%153 = bitcast double* %152 to <2 x double>*
%154 = load <2 x double>, <2 x double>* %153
%155 = extractelement <2 x double> %154, i64 0
%156 = fneg double %155
%157 = insertelement <2 x double> poison, double %146, i64 0
%158 = shufflevector <2 x double> %157, <2 x double> poison, <2 x i32> zeroinitializer
%159 = extractelement <2 x double> %154, i64 1
%160 = insertelement <2 x double> poison, double %159, i64 0
%161 = insertelement <2 x double> %160, double %156, i64 1
%162 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %154, <2 x double> %158, <2 x double> %161)
%163 = getelementptr inbounds double, double* %6, i64 %144
%164 = load double, double* %163
%165 = getelementptr inbounds double, double* %6, i64 %147
%166 = load double, double* %165
%167 = or i64 %150, 6
%168 = getelementptr inbounds double, double* %4, i64 %167
%169 = bitcast double* %168 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = extractelement <2 x double> %170, i64 0
%172 = fneg double %171
%173 = insertelement <2 x double> poison, double %164, i64 0
%174 = shufflevector <2 x double> %173, <2 x double> poison, <2 x i32> zeroinitializer
%175 = extractelement <2 x double> %170, i64 1
%176 = insertelement <2 x double> poison, double %175, i64 0
%177 = insertelement <2 x double> %176, double %172, i64 1
%178 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %170, <2 x double> %174, <2 x double> %177)
%179 = shl nsw i64 %143, 2
%180 = getelementptr inbounds double, double* %5, i64 %179
%181 = load double, double* %180
%182 = or i64 %179, 1
%183 = getelementptr inbounds double, double* %5, i64 %182
%184 = load double, double* %183
%185 = or i64 %150, 4
%186 = getelementptr inbounds double, double* %4, i64 %185
%187 = bitcast double* %186 to <2 x double>*
%188 = load <2 x double>, <2 x double>* %187
%189 = extractelement <2 x double> %188, i64 0
%190 = fneg double %189
%191 = insertelement <2 x double> poison, double %181, i64 0
%192 = shufflevector <2 x double> %191, <2 x double> poison, <2 x i32> zeroinitializer
%193 = extractelement <2 x double> %188, i64 1
%194 = insertelement <2 x double> poison, double %193, i64 0
%195 = insertelement <2 x double> %194, double %190, i64 1
%196 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %188, <2 x double> %192, <2 x double> %195)
%197 = extractelement <2 x double> %178, i64 0
%198 = fneg double %197
%199 = extractelement <2 x double> %162, i64 0
%200 = tail call double @llvm.fmuladd.f64(double %198, double %166, double %199)
%201 = insertelement <2 x double> poison, double %166, i64 0
%202 = shufflevector <2 x double> %201, <2 x double> poison, <2 x i32> zeroinitializer
%203 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %178, <2 x double> %202, <2 x double> %162)
%204 = extractelement <2 x double> %178, i64 1
%205 = fneg double %204
%206 = extractelement <2 x double> %162, i64 1
%207 = tail call double @llvm.fmuladd.f64(double %205, double %166, double %206)
%208 = getelementptr inbounds double, double* %4, i64 %150
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = insertelement <2 x double> poison, double %184, i64 0
%212 = shufflevector <2 x double> %211, <2 x double> poison, <2 x i32> zeroinitializer
%213 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %196, <2 x double> %212, <2 x double> %210)
%214 = fneg <2 x double> %196
%215 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %214, <2 x double> %212, <2 x double> %210)
%216 = getelementptr inbounds double, double* %0, i64 %144
%217 = insertelement <2 x double> poison, double %149, i64 0
%218 = shufflevector <2 x double> %217, <2 x double> poison, <2 x i32> zeroinitializer
%219 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %203, <2 x double> %218, <2 x double> %213)
%220 = bitcast double* %216 to <2 x double>*
store <2 x double> %219, <2 x double>* %220
%221 = getelementptr inbounds double, double* %2, i64 %144
%222 = fneg <2 x double> %203
%223 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %222, <2 x double> %218, <2 x double> %213)
%224 = bitcast double* %221 to <2 x double>*
store <2 x double> %223, <2 x double>* %224
%225 = getelementptr inbounds double, double* %1, i64 %144
%226 = fneg double %200
%227 = insertelement <2 x double> poison, double %207, i64 0
%228 = insertelement <2 x double> %227, double %226, i64 1
%229 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %228, <2 x double> %218, <2 x double> %215)
%230 = bitcast double* %225 to <2 x double>*
store <2 x double> %229, <2 x double>* %230
%231 = fneg double %207
%232 = getelementptr inbounds double, double* %3, i64 %144
%233 = insertelement <2 x double> poison, double %231, i64 0
%234 = insertelement <2 x double> %233, double %200, i64 1
%235 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %234, <2 x double> %218, <2 x double> %215)
%236 = bitcast double* %232 to <2 x double>*
store <2 x double> %235, <2 x double>* %236
%237 = add nuw nsw i64 %143, 1
%238 = icmp eq i64 %237, %8
br i1 %238, label %239, label %142
239: ; preds = %142, %9
ret void
}