void kern_r4_fma_u1_b(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];
    wr2 = w[4 * i];
    wi2 = w[4 * i + 1];
    wr3 = w2[2 * i];
    wi13 = w2[2 * i + 1];
    pr1 = i0[8 * i + 2] * wr1 - i0[8 * i + 3];
    pi1 = i0[8 * i + 2] + i0[8 * i + 3] * wr1;
    pr2 = i0[8 * i + 4] * wr2 - i0[8 * i + 5];
    pi2 = i0[8 * i + 4] + i0[8 * i + 5] * wr2;
    pr3 = i0[8 * i + 6] * wr3 - i0[8 * i + 7];
    pi3 = i0[8 * i + 6] + i0[8 * i + 7] * wr3;
    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;
    qr1 = pr1 + pr3 * wi13;
    qr3 = pr1 - pr3 * wi13;
    qi1 = pi1 + pi3 * wi13;
    qi3 = pi1 - pi3 * wi13;
    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_b>:
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_b+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    -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    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  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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x10(%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x20(%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x28(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x30(%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x38(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%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  -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
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
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,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0xd0(%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,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    -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
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,0x8(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1134 <kern_r4_fma_u1_b+0x34>
add    $0x58,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r4_fma_u1_b>:
push   %r15
push   %r14
push   %r12
push   %rbx
mov    0x38(%rsp),%r11
test   %r11,%r11
jle    155d <kern_r4_fma_u1_b+0x45d>
mov    %rdx,%r10
mov    0x28(%rsp),%r12
cmp    $0x3,%r11
jae    112b <kern_r4_fma_u1_b+0x2b>
xor    %r14d,%r14d
jmp    13cf <kern_r4_fma_u1_b+0x2cf>
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     13cf <kern_r4_fma_u1_b+0x2cf>
test   %dl,%dl
jne    13cf <kern_r4_fma_u1_b+0x2cf>
lea    0x8(%r10),%r15
lea    (%r10,%rax,1),%rbx
add    $0x8,%rbx
cmp    %r15,%rbx
jb     13cf <kern_r4_fma_u1_b+0x2cf>
test   %dl,%dl
jne    13cf <kern_r4_fma_u1_b+0x2cf>
lea    0x8(%rsi),%r15
lea    (%rsi,%rax,1),%rbx
add    $0x8,%rbx
cmp    %r15,%rbx
jb     13cf <kern_r4_fma_u1_b+0x2cf>
test   %dl,%dl
jne    13cf <kern_r4_fma_u1_b+0x2cf>
lea    0x8(%rcx),%rbx
add    %rcx,%rax
add    $0x8,%rax
cmp    %rbx,%rax
jb     13cf <kern_r4_fma_u1_b+0x2cf>
test   %dl,%dl
jne    13cf <kern_r4_fma_u1_b+0x2cf>
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,%xmm3
unpcklpd %xmm0,%xmm3
unpckhpd %xmm0,%xmm8
movupd (%r9,%rax,2),%xmm11
movupd 0x20(%r9,%rax,2),%xmm0
movapd %xmm11,%xmm15
unpcklpd %xmm0,%xmm15
unpckhpd %xmm0,%xmm11
movupd (%r12,%rax,1),%xmm9
movupd 0x10(%r12,%rax,1),%xmm0
movapd %xmm9,%xmm13
unpcklpd %xmm0,%xmm13
unpckhpd %xmm0,%xmm9
movupd 0x70(%r8,%rax,4),%xmm12
movupd 0x60(%r8,%rax,4),%xmm14
movupd 0x50(%r8,%rax,4),%xmm5
movupd 0x40(%r8,%rax,4),%xmm4
movupd (%r8,%rax,4),%xmm1
movupd 0x10(%r8,%rax,4),%xmm2
movupd 0x20(%r8,%rax,4),%xmm0
movupd 0x30(%r8,%rax,4),%xmm7
movapd %xmm1,%xmm10
unpcklpd %xmm4,%xmm10
unpckhpd %xmm4,%xmm1
movapd %xmm2,%xmm4
unpcklpd %xmm5,%xmm4
unpckhpd %xmm5,%xmm2
movapd %xmm0,%xmm5
unpcklpd %xmm14,%xmm5
unpckhpd %xmm14,%xmm0
movapd %xmm7,%xmm14
unpcklpd %xmm12,%xmm14
unpckhpd %xmm12,%xmm7
movapd %xmm4,%xmm12
mulpd  %xmm3,%xmm12
subpd  %xmm2,%xmm12
mulpd  %xmm3,%xmm2
addpd  %xmm4,%xmm2
movapd %xmm5,%xmm4
mulpd  %xmm15,%xmm4
subpd  %xmm0,%xmm4
mulpd  %xmm15,%xmm0
addpd  %xmm5,%xmm0
movapd %xmm14,%xmm6
mulpd  %xmm13,%xmm6
subpd  %xmm7,%xmm6
mulpd  %xmm13,%xmm7
addpd  %xmm14,%xmm7
mulpd  %xmm11,%xmm4
movapd %xmm4,%xmm13
addpd  %xmm10,%xmm13
subpd  %xmm4,%xmm10
mulpd  %xmm11,%xmm0
movapd %xmm0,%xmm5
addpd  %xmm1,%xmm5
subpd  %xmm0,%xmm1
mulpd  %xmm9,%xmm6
movapd %xmm6,%xmm0
addpd  %xmm12,%xmm0
subpd  %xmm6,%xmm12
mulpd  %xmm9,%xmm7
movapd %xmm7,%xmm4
addpd  %xmm2,%xmm4
subpd  %xmm7,%xmm2
mulpd  %xmm8,%xmm0
movapd %xmm0,%xmm6
addpd  %xmm13,%xmm6
mulpd  %xmm8,%xmm4
movapd %xmm4,%xmm7
addpd  %xmm5,%xmm7
movapd %xmm6,%xmm3
unpcklpd %xmm7,%xmm3
movhlps %xmm6,%xmm7
movups %xmm7,0x10(%rdi,%rax,1)
movupd %xmm3,(%rdi,%rax,1)
subpd  %xmm0,%xmm13
subpd  %xmm4,%xmm5
movapd %xmm13,%xmm0
unpcklpd %xmm5,%xmm0
movhlps %xmm13,%xmm5
movups %xmm5,0x10(%r10,%rax,1)
movupd %xmm0,(%r10,%rax,1)
mulpd  %xmm8,%xmm2
movapd %xmm10,%xmm0
subpd  %xmm2,%xmm0
mulpd  %xmm8,%xmm12
movapd %xmm12,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm3,%xmm4
movhlps %xmm0,%xmm3
movups %xmm3,0x10(%rsi,%rax,1)
movupd %xmm4,(%rsi,%rax,1)
addpd  %xmm10,%xmm2
subpd  %xmm12,%xmm1
movapd %xmm2,%xmm0
unpcklpd %xmm1,%xmm0
movhlps %xmm2,%xmm1
movups %xmm1,0x10(%rcx,%rax,1)
movupd %xmm0,(%rcx,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rdx
jne    11d0 <kern_r4_fma_u1_b+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    $0x5,%rax
lea    (%rax,%r9,1),%rbx
add    $0x8,%rbx
shl    $0x6,%r14
lea    (%r14,%r8,1),%rax
add    $0x30,%rax
xor    %edx,%edx
movapd 0xbe6(%rip),%xmm8
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,1),%xmm9
movupd -0x30(%rax,%rdx,4),%xmm10
movupd -0x20(%rax,%rdx,4),%xmm0
movupd -0x10(%rax,%rdx,4),%xmm7
movupd (%rax,%rdx,4),%xmm5
movapd %xmm0,%xmm6
unpckhpd %xmm0,%xmm6
xorpd  %xmm8,%xmm6
movsd  -0x8(%r15,%rdx,1),%xmm2
movsd  (%r15,%rdx,1),%xmm3
unpcklpd %xmm2,%xmm2
unpcklpd %xmm0,%xmm6
mulpd  %xmm0,%xmm2
addpd  %xmm6,%xmm2
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
xorpd  %xmm8,%xmm0
movsd  -0x8(%rbx,%rdx,2),%xmm4
movsd  (%rbx,%rdx,2),%xmm1
unpcklpd %xmm4,%xmm4
unpcklpd %xmm7,%xmm0
mulpd  %xmm7,%xmm4
addpd  %xmm0,%xmm4
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
xorpd  %xmm8,%xmm0
movsd  -0x8(%r12,%rdx,1),%xmm6
unpcklpd %xmm6,%xmm6
unpcklpd %xmm5,%xmm0
mulpd  %xmm5,%xmm6
addpd  %xmm0,%xmm6
unpcklpd %xmm1,%xmm1
mulpd  %xmm4,%xmm1
movapd %xmm1,%xmm0
addpd  %xmm10,%xmm0
subpd  %xmm1,%xmm10
movapd %xmm6,%xmm1
mulsd  %xmm9,%xmm1
movapd %xmm2,%xmm5
subsd  %xmm1,%xmm5
movapd %xmm9,%xmm1
unpcklpd %xmm9,%xmm1
mulpd  %xmm6,%xmm1
addpd  %xmm2,%xmm1
unpckhpd %xmm6,%xmm6
unpckhpd %xmm2,%xmm2
mulsd  %xmm9,%xmm6
subsd  %xmm6,%xmm2
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm1
movapd %xmm1,%xmm4
addpd  %xmm0,%xmm4
movupd %xmm4,(%rdi,%rdx,1)
subpd  %xmm1,%xmm0
movupd %xmm0,(%r10,%rdx,1)
movapd %xmm2,%xmm0
xorpd  %xmm8,%xmm0
unpcklpd %xmm5,%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm10,%xmm0
movupd %xmm0,(%rsi,%rdx,1)
xorpd  %xmm8,%xmm5
unpcklpd %xmm5,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm10,%xmm2
movupd %xmm2,(%rcx,%rdx,1)
add    $0x10,%rdx
add    $0xffffffffffffffff,%r11
jne    1420 <kern_r4_fma_u1_b+0x320>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @kern_r4_fma_u1_b(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** %15
%57 = load i64, i64* %19
%58 = mul nsw i64 4, %57
%59 = getelementptr inbounds double, double* %56, i64 %58
%60 = load double, double* %59
store double %60, double* %22
%61 = load double*, double** %15
%62 = load i64, i64* %19
%63 = mul nsw i64 4, %62
%64 = add nsw i64 %63, 1
%65 = getelementptr inbounds double, double* %61, i64 %64
%66 = load double, double* %65
store double %66, double* %23
%67 = load double*, double** %16
%68 = load i64, i64* %19
%69 = mul nsw i64 2, %68
%70 = getelementptr inbounds double, double* %67, i64 %69
%71 = load double, double* %70
store double %71, double* %24
%72 = load double*, double** %16
%73 = load i64, i64* %19
%74 = mul nsw i64 2, %73
%75 = add nsw i64 %74, 1
%76 = getelementptr inbounds double, double* %72, i64 %75
%77 = load double, double* %76
store double %77, double* %25
%78 = load double*, double** %14
%79 = load i64, i64* %19
%80 = mul nsw i64 8, %79
%81 = add nsw i64 %80, 2
%82 = getelementptr inbounds double, double* %78, i64 %81
%83 = load double, double* %82
%84 = load double, double* %20
%85 = load double*, double** %14
%86 = load i64, i64* %19
%87 = mul nsw i64 8, %86
%88 = add nsw i64 %87, 3
%89 = getelementptr inbounds double, double* %85, i64 %88
%90 = load double, double* %89
%91 = fneg double %90
%92 = call double @llvm.fmuladd.f64(double %83, double %84, double %91)
store double %92, double* %26
%93 = load double*, double** %14
%94 = load i64, i64* %19
%95 = mul nsw i64 8, %94
%96 = add nsw i64 %95, 2
%97 = getelementptr inbounds double, double* %93, i64 %96
%98 = load double, double* %97
%99 = load double*, double** %14
%100 = load i64, i64* %19
%101 = mul nsw i64 8, %100
%102 = add nsw i64 %101, 3
%103 = getelementptr inbounds double, double* %99, i64 %102
%104 = load double, double* %103
%105 = load double, double* %20
%106 = call double @llvm.fmuladd.f64(double %104, double %105, double %98)
store double %106, double* %27
%107 = load double*, double** %14
%108 = load i64, i64* %19
%109 = mul nsw i64 8, %108
%110 = add nsw i64 %109, 4
%111 = getelementptr inbounds double, double* %107, i64 %110
%112 = load double, double* %111
%113 = load double, double* %22
%114 = load double*, double** %14
%115 = load i64, i64* %19
%116 = mul nsw i64 8, %115
%117 = add nsw i64 %116, 5
%118 = getelementptr inbounds double, double* %114, i64 %117
%119 = load double, double* %118
%120 = fneg double %119
%121 = call double @llvm.fmuladd.f64(double %112, double %113, double %120)
store double %121, double* %28
%122 = load double*, double** %14
%123 = load i64, i64* %19
%124 = mul nsw i64 8, %123
%125 = add nsw i64 %124, 4
%126 = getelementptr inbounds double, double* %122, i64 %125
%127 = load double, double* %126
%128 = load double*, double** %14
%129 = load i64, i64* %19
%130 = mul nsw i64 8, %129
%131 = add nsw i64 %130, 5
%132 = getelementptr inbounds double, double* %128, i64 %131
%133 = load double, double* %132
%134 = load double, double* %22
%135 = call double @llvm.fmuladd.f64(double %133, double %134, double %127)
store double %135, double* %29
%136 = load double*, double** %14
%137 = load i64, i64* %19
%138 = mul nsw i64 8, %137
%139 = add nsw i64 %138, 6
%140 = getelementptr inbounds double, double* %136, i64 %139
%141 = load double, double* %140
%142 = load double, double* %24
%143 = load double*, double** %14
%144 = load i64, i64* %19
%145 = mul nsw i64 8, %144
%146 = add nsw i64 %145, 7
%147 = getelementptr inbounds double, double* %143, i64 %146
%148 = load double, double* %147
%149 = fneg double %148
%150 = call double @llvm.fmuladd.f64(double %141, double %142, double %149)
store double %150, double* %30
%151 = load double*, double** %14
%152 = load i64, i64* %19
%153 = mul nsw i64 8, %152
%154 = add nsw i64 %153, 6
%155 = getelementptr inbounds double, double* %151, i64 %154
%156 = load double, double* %155
%157 = load double*, double** %14
%158 = load i64, i64* %19
%159 = mul nsw i64 8, %158
%160 = add nsw i64 %159, 7
%161 = getelementptr inbounds double, double* %157, i64 %160
%162 = load double, double* %161
%163 = load double, double* %24
%164 = call double @llvm.fmuladd.f64(double %162, double %163, double %156)
store double %164, double* %31
%165 = load double*, double** %14
%166 = load i64, i64* %19
%167 = mul nsw i64 8, %166
%168 = getelementptr inbounds double, double* %165, i64 %167
%169 = load double, double* %168
%170 = load double, double* %28
%171 = load double, double* %23
%172 = call double @llvm.fmuladd.f64(double %170, double %171, double %169)
store double %172, double* %32
%173 = load double*, double** %14
%174 = load i64, i64* %19
%175 = mul nsw i64 8, %174
%176 = getelementptr inbounds double, double* %173, i64 %175
%177 = load double, double* %176
%178 = load double, double* %28
%179 = load double, double* %23
%180 = fneg double %178
%181 = call double @llvm.fmuladd.f64(double %180, double %179, double %177)
store double %181, double* %36
%182 = load double*, double** %14
%183 = load i64, i64* %19
%184 = mul nsw i64 8, %183
%185 = add nsw i64 %184, 1
%186 = getelementptr inbounds double, double* %182, i64 %185
%187 = load double, double* %186
%188 = load double, double* %29
%189 = load double, double* %23
%190 = call double @llvm.fmuladd.f64(double %188, double %189, double %187)
store double %190, double* %33
%191 = load double*, double** %14
%192 = load i64, i64* %19
%193 = mul nsw i64 8, %192
%194 = add nsw i64 %193, 1
%195 = getelementptr inbounds double, double* %191, i64 %194
%196 = load double, double* %195
%197 = load double, double* %29
%198 = load double, double* %23
%199 = fneg double %197
%200 = call double @llvm.fmuladd.f64(double %199, double %198, double %196)
store double %200, double* %37
%201 = load double, double* %26
%202 = load double, double* %30
%203 = load double, double* %25
%204 = call double @llvm.fmuladd.f64(double %202, double %203, double %201)
store double %204, double* %34
%205 = load double, double* %26
%206 = load double, double* %30
%207 = load double, double* %25
%208 = fneg double %206
%209 = call double @llvm.fmuladd.f64(double %208, double %207, double %205)
store double %209, double* %38
%210 = load double, double* %27
%211 = load double, double* %31
%212 = load double, double* %25
%213 = call double @llvm.fmuladd.f64(double %211, double %212, double %210)
store double %213, double* %35
%214 = load double, double* %27
%215 = load double, double* %31
%216 = load double, double* %25
%217 = fneg double %215
%218 = call double @llvm.fmuladd.f64(double %217, double %216, double %214)
store double %218, double* %39
%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 = fneg double %256
%259 = call double @llvm.fmuladd.f64(double %258, double %257, double %255)
%260 = load double*, double** %11
%261 = load i64, i64* %19
%262 = mul nsw i64 2, %261
%263 = getelementptr inbounds double, double* %260, i64 %262
store double %259, double* %263
%264 = load double, double* %37
%265 = load double, double* %38
%266 = load double, double* %21
%267 = call double @llvm.fmuladd.f64(double %265, double %266, double %264)
%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 = call double @llvm.fmuladd.f64(double %274, double %275, double %273)
%277 = load double*, double** %13
%278 = load i64, i64* %19
%279 = mul nsw i64 2, %278
%280 = getelementptr inbounds double, double* %277, i64 %279
store double %276, double* %280
%281 = load double, double* %37
%282 = load double, double* %38
%283 = load double, double* %21
%284 = fneg double %282
%285 = call double @llvm.fmuladd.f64(double %284, double %283, double %281)
%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_b(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 %236
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, 2
%70 = getelementptr inbounds double, double* %5, i64 %69
%71 = bitcast double* %70 to <8 x double>*
%72 = load <8 x double>, <8 x double>* %71
%73 = shufflevector <8 x double> %72, <8 x double> poison, <2 x i32> <i32 0, i32 4>
%74 = shufflevector <8 x double> %72, <8 x double> poison, <2 x i32> <i32 1, i32 5>
%75 = getelementptr inbounds double, double* %6, i64 %62
%76 = bitcast double* %75 to <4 x double>*
%77 = load <4 x double>, <4 x double>* %76
%78 = shufflevector <4 x double> %77, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%79 = shufflevector <4 x double> %77, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%80 = shl nsw i64 %61, 3
%81 = or i64 %80, 2
%82 = getelementptr inbounds double, double* %55, i64 %81
%83 = bitcast double* %82 to <16 x double>*
%84 = load <16 x double>, <16 x double>* %83
%85 = shufflevector <16 x double> %84, <16 x double> poison, <2 x i32> <i32 0, i32 8>
%86 = shufflevector <16 x double> %84, <16 x double> poison, <2 x i32> <i32 1, i32 9>
%87 = shufflevector <16 x double> %84, <16 x double> poison, <2 x i32> <i32 2, i32 10>
%88 = shufflevector <16 x double> %84, <16 x double> poison, <2 x i32> <i32 3, i32 11>
%89 = shufflevector <16 x double> %84, <16 x double> poison, <2 x i32> <i32 4, i32 12>
%90 = shufflevector <16 x double> %84, <16 x double> poison, <2 x i32> <i32 5, i32 13>
%91 = shufflevector <16 x double> %84, <16 x double> poison, <2 x i32> <i32 6, i32 14>
%92 = shufflevector <16 x double> %84, <16 x double> poison, <2 x i32> <i32 7, i32 15>
%93 = fneg <2 x double> %88
%94 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %87, <2 x double> %66, <2 x double> %93)
%95 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %88, <2 x double> %66, <2 x double> %87)
%96 = fneg <2 x double> %90
%97 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %89, <2 x double> %73, <2 x double> %96)
%98 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %90, <2 x double> %73, <2 x double> %89)
%99 = fneg <2 x double> %92
%100 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %91, <2 x double> %78, <2 x double> %99)
%101 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %92, <2 x double> %78, <2 x double> %91)
%102 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %97, <2 x double> %74, <2 x double> %85)
%103 = fneg <2 x double> %97
%104 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %103, <2 x double> %74, <2 x double> %85)
%105 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %98, <2 x double> %74, <2 x double> %86)
%106 = fneg <2 x double> %98
%107 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %106, <2 x double> %74, <2 x double> %86)
%108 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %100, <2 x double> %79, <2 x double> %94)
%109 = fneg <2 x double> %100
%110 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %109, <2 x double> %79, <2 x double> %94)
%111 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %101, <2 x double> %79, <2 x double> %95)
%112 = fneg <2 x double> %101
%113 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %112, <2 x double> %79, <2 x double> %95)
%114 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %108, <2 x double> %67, <2 x double> %102)
%115 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %111, <2 x double> %67, <2 x double> %105)
%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> %108
%120 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %119, <2 x double> %67, <2 x double> %102)
%121 = fneg <2 x double> %111
%122 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %121, <2 x double> %67, <2 x double> %105)
%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 = fneg <2 x double> %113
%127 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %126, <2 x double> %67, <2 x double> %104)
%128 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %110, <2 x double> %67, <2 x double> %107)
%129 = getelementptr inbounds double, double* %58, i64 %68
%130 = bitcast double* %129 to <4 x double>*
%131 = shufflevector <2 x double> %127, <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 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %113, <2 x double> %67, <2 x double> %104)
%133 = fneg <2 x double> %110
%134 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %133, <2 x double> %67, <2 x double> %107)
%135 = getelementptr inbounds double, double* %59, i64 %68
%136 = bitcast double* %135 to <4 x double>*
%137 = shufflevector <2 x double> %132, <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 [ %234, %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, 2
%151 = getelementptr inbounds double, double* %5, i64 %150
%152 = load double, double* %151
%153 = or i64 %150, 1
%154 = getelementptr inbounds double, double* %5, i64 %153
%155 = load double, double* %154
%156 = getelementptr inbounds double, double* %6, i64 %144
%157 = load double, double* %156
%158 = getelementptr inbounds double, double* %6, i64 %147
%159 = load double, double* %158
%160 = shl nsw i64 %143, 3
%161 = or i64 %160, 2
%162 = getelementptr inbounds double, double* %4, i64 %161
%163 = bitcast double* %162 to <2 x double>*
%164 = load <2 x double>, <2 x double>* %163
%165 = extractelement <2 x double> %164, i64 1
%166 = fneg double %165
%167 = insertelement <2 x double> poison, double %146, i64 0
%168 = shufflevector <2 x double> %167, <2 x double> poison, <2 x i32> zeroinitializer
%169 = insertelement <2 x double> poison, double %166, i64 0
%170 = shufflevector <2 x double> %169, <2 x double> %164, <2 x i32> <i32 0, i32 2>
%171 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %164, <2 x double> %168, <2 x double> %170)
%172 = or i64 %160, 4
%173 = getelementptr inbounds double, double* %4, i64 %172
%174 = bitcast double* %173 to <2 x double>*
%175 = load <2 x double>, <2 x double>* %174
%176 = extractelement <2 x double> %175, i64 1
%177 = fneg double %176
%178 = insertelement <2 x double> poison, double %152, i64 0
%179 = shufflevector <2 x double> %178, <2 x double> poison, <2 x i32> zeroinitializer
%180 = insertelement <2 x double> poison, double %177, i64 0
%181 = shufflevector <2 x double> %180, <2 x double> %175, <2 x i32> <i32 0, i32 2>
%182 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %175, <2 x double> %179, <2 x double> %181)
%183 = or i64 %160, 6
%184 = getelementptr inbounds double, double* %4, i64 %183
%185 = bitcast double* %184 to <2 x double>*
%186 = load <2 x double>, <2 x double>* %185
%187 = extractelement <2 x double> %186, i64 1
%188 = fneg double %187
%189 = insertelement <2 x double> poison, double %157, i64 0
%190 = shufflevector <2 x double> %189, <2 x double> poison, <2 x i32> zeroinitializer
%191 = insertelement <2 x double> poison, double %188, i64 0
%192 = shufflevector <2 x double> %191, <2 x double> %186, <2 x i32> <i32 0, i32 2>
%193 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %186, <2 x double> %190, <2 x double> %192)
%194 = getelementptr inbounds double, double* %4, i64 %160
%195 = bitcast double* %194 to <2 x double>*
%196 = load <2 x double>, <2 x double>* %195
%197 = insertelement <2 x double> poison, double %155, i64 0
%198 = shufflevector <2 x double> %197, <2 x double> poison, <2 x i32> zeroinitializer
%199 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %182, <2 x double> %198, <2 x double> %196)
%200 = fneg <2 x double> %182
%201 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %200, <2 x double> %198, <2 x double> %196)
%202 = extractelement <2 x double> %193, i64 0
%203 = fneg double %202
%204 = extractelement <2 x double> %171, i64 0
%205 = tail call double @llvm.fmuladd.f64(double %203, double %159, double %204)
%206 = insertelement <2 x double> poison, double %159, i64 0
%207 = shufflevector <2 x double> %206, <2 x double> poison, <2 x i32> zeroinitializer
%208 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %193, <2 x double> %207, <2 x double> %171)
%209 = extractelement <2 x double> %193, i64 1
%210 = fneg double %209
%211 = extractelement <2 x double> %171, i64 1
%212 = tail call double @llvm.fmuladd.f64(double %210, double %159, double %211)
%213 = getelementptr inbounds double, double* %0, i64 %144
%214 = insertelement <2 x double> poison, double %149, i64 0
%215 = shufflevector <2 x double> %214, <2 x double> poison, <2 x i32> zeroinitializer
%216 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %208, <2 x double> %215, <2 x double> %199)
%217 = bitcast double* %213 to <2 x double>*
store <2 x double> %216, <2 x double>* %217
%218 = getelementptr inbounds double, double* %2, i64 %144
%219 = fneg <2 x double> %208
%220 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %219, <2 x double> %215, <2 x double> %199)
%221 = bitcast double* %218 to <2 x double>*
store <2 x double> %220, <2 x double>* %221
%222 = fneg double %212
%223 = getelementptr inbounds double, double* %1, i64 %144
%224 = insertelement <2 x double> poison, double %222, i64 0
%225 = insertelement <2 x double> %224, double %205, i64 1
%226 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %225, <2 x double> %215, <2 x double> %201)
%227 = bitcast double* %223 to <2 x double>*
store <2 x double> %226, <2 x double>* %227
%228 = getelementptr inbounds double, double* %3, i64 %144
%229 = fneg double %205
%230 = insertelement <2 x double> poison, double %212, i64 0
%231 = insertelement <2 x double> %230, double %229, i64 1
%232 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %231, <2 x double> %215, <2 x double> %201)
%233 = bitcast double* %228 to <2 x double>*
store <2 x double> %232, <2 x double>* %233
%234 = add nuw nsw i64 %143, 1
%235 = icmp eq i64 %234, %8
br i1 %235, label %236, label %142
236: ; preds = %142, %9
ret void
}