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


x86 assembly (clang, -O0):
<kern_r4_fma_o_f>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
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,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    0x30(%rbp),%rax
jge    137e <kern_r4_fma_o_f+0x27e>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x48(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1143 <kern_r4_fma_o_f+0x43>
mov    0x30(%rbp),%rax
shl    $0x3,%rax
shl    $0x3,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    0x30(%rbp),%rax
shl    $0x3,%rax
shl    $0x3,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    0x30(%rbp),%rax
shl    $0x3,%rax
shl    $0x3,%rax
add    0x10(%rbp),%rax
mov    %rax,0x10(%rbp)
mov    0x30(%rbp),%rax
shl    $0x3,%rax
shl    $0x3,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    0x30(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    0x30(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    0x30(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    0x30(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    0x38(%rbp),%rax
jge    1b14 <kern_r4_fma_o_f+0xa14>
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x30(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    0x30(%rbp),%rax
jge    1a63 <kern_r4_fma_o_f+0x963>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xe8(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    14f3 <kern_r4_fma_o_f+0x3f3>
mov    0x30(%rbp),%rax
shl    $0x3,%rax
shl    $0x3,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    0x30(%rbp),%rax
shl    $0x3,%rax
shl    $0x3,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    0x30(%rbp),%rax
shl    $0x3,%rax
shl    $0x3,%rax
add    0x10(%rbp),%rax
mov    %rax,0x10(%rbp)
mov    0x30(%rbp),%rax
shl    $0x3,%rax
shl    $0x3,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    0x30(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    0x30(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    0x30(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    0x30(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1426 <kern_r4_fma_o_f+0x326>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r4_fma_o_f>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %rdx,-0x68(%rsp)
mov    %rsi,-0x70(%rsp)
mov    %rdi,-0x78(%rsp)
mov    0xe8(%rsp),%r11
mov    0xe0(%rsp),%r10
cmpq   $0x0,0x100(%rsp)
jle    137e <kern_r4_fma_o_f+0x27e>
mov    0x100(%rsp),%rbp
cmp    $0x1,%rbp
jne    1155 <kern_r4_fma_o_f+0x55>
xor    %r14d,%r14d
jmp    12b0 <kern_r4_fma_o_f+0x1b0>
mov    %rbp,%r14
and    $0xfffffffffffffffe,%r14
xor    %edx,%edx
mov    %r14,%rdi
mov    -0x68(%rsp),%rax
mov    -0x70(%rsp),%rsi
mov    -0x78(%rsp),%rbx
movupd (%r8,%rdx,1),%xmm8
movupd 0x10(%r8,%rdx,1),%xmm2
movapd %xmm8,%xmm9
unpcklpd %xmm2,%xmm9
unpckhpd %xmm2,%xmm8
movupd (%r10,%rdx,1),%xmm2
movupd 0x10(%r10,%rdx,1),%xmm3
movapd %xmm2,%xmm5
unpcklpd %xmm3,%xmm5
unpckhpd %xmm3,%xmm2
movapd %xmm9,%xmm4
addpd  %xmm5,%xmm4
subpd  %xmm5,%xmm9
movapd %xmm8,%xmm0
addpd  %xmm2,%xmm0
subpd  %xmm2,%xmm8
movupd (%r9,%rdx,1),%xmm3
movupd 0x10(%r9,%rdx,1),%xmm6
movapd %xmm3,%xmm2
unpcklpd %xmm6,%xmm2
unpckhpd %xmm6,%xmm3
movupd (%r11,%rdx,1),%xmm6
movupd 0x10(%r11,%rdx,1),%xmm7
movapd %xmm6,%xmm1
unpcklpd %xmm7,%xmm1
unpckhpd %xmm7,%xmm6
movapd %xmm2,%xmm10
addpd  %xmm1,%xmm10
subpd  %xmm1,%xmm2
movapd %xmm3,%xmm1
addpd  %xmm6,%xmm1
subpd  %xmm6,%xmm3
movapd %xmm4,%xmm6
addpd  %xmm10,%xmm6
movapd %xmm0,%xmm5
addpd  %xmm1,%xmm5
movapd %xmm6,%xmm7
unpcklpd %xmm5,%xmm7
movhlps %xmm6,%xmm5
movups %xmm5,0x10(%rbx,%rdx,1)
movupd %xmm7,(%rbx,%rdx,1)
subpd  %xmm10,%xmm4
subpd  %xmm1,%xmm0
movapd %xmm4,%xmm1
unpcklpd %xmm0,%xmm1
movhlps %xmm4,%xmm0
movups %xmm0,0x10(%rax,%rdx,1)
movupd %xmm1,(%rax,%rdx,1)
movapd %xmm9,%xmm0
addpd  %xmm3,%xmm0
movapd %xmm8,%xmm1
subpd  %xmm2,%xmm1
movapd %xmm0,%xmm4
unpcklpd %xmm1,%xmm4
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rsi,%rdx,1)
movupd %xmm4,(%rsi,%rdx,1)
subpd  %xmm3,%xmm9
addpd  %xmm8,%xmm2
movapd %xmm9,%xmm0
unpcklpd %xmm2,%xmm0
movhlps %xmm9,%xmm2
movups %xmm2,0x10(%rcx,%rdx,1)
movupd %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1170 <kern_r4_fma_o_f+0x70>
cmp    %rbp,%r14
je     137e <kern_r4_fma_o_f+0x27e>
mov    0x100(%rsp),%r15
sub    %r14,%r15
shl    $0x4,%r14
mov    %rcx,%r12
mov    -0x70(%rsp),%r13
mov    -0x68(%rsp),%rbx
mov    -0x78(%rsp),%rbp
mov    %r11,%rsi
mov    %r9,%rax
mov    %r10,%rdx
mov    %r8,%rdi
nopl   (%rax)
movupd (%rdi,%r14,1),%xmm0
movupd (%rdx,%r14,1),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
movupd (%rax,%r14,1),%xmm1
movupd (%rsi,%r14,1),%xmm3
movapd %xmm1,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,0x0(%rbp,%r14,1)
subpd  %xmm4,%xmm2
movupd %xmm2,(%rbx,%r14,1)
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
movapd %xmm0,%xmm1
movsd  %xmm2,%xmm1
movupd %xmm1,0x0(%r13,%r14,1)
shufpd $0x2,%xmm2,%xmm0
movupd %xmm0,(%r12,%r14,1)
add    $0x10,%rdi
add    $0x10,%rdx
add    $0x10,%rax
add    $0x10,%rsi
add    $0x10,%rbp
add    $0x10,%rbx
add    $0x10,%r13
add    $0x10,%r12
add    $0xffffffffffffffff,%r15
jne    12e0 <kern_r4_fma_o_f+0x1e0>
mov    %rcx,-0x38(%rsp)
cmpq   $0x2,0x108(%rsp)
jl     19ad <kern_r4_fma_o_f+0x8ad>
mov    0x100(%rsp),%r13
lea    0x0(,%r13,8),%rcx
mov    %r13,%rdx
add    %r13,%rdx
lea    -0x1(%r13),%rax
mov    %rdx,-0x18(%rsp)
or     $0x1,%rdx
mov    %rdx,-0x20(%rsp)
mov    $0x10,%edx
mul    %rdx
mov    %rax,%rdx
seto   -0x79(%rsp)
mov    %r13,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x40(%rsp)
lea    (%r8,%rcx,8),%rsi
mov    %r13,%rax
shl    $0x6,%rax
mov    %rax,-0x8(%rsp)
lea    (%r11,%rcx,8),%rdi
lea    (%r10,%rcx,8),%rbp
shl    $0x4,%r13
mov    -0x38(%rsp),%rax
lea    (%rax,%r13,1),%r12
mov    -0x70(%rsp),%rax
lea    (%rax,%r13,1),%r14
lea    (%r9,%rcx,8),%r10
mov    -0x68(%rsp),%rax
lea    (%rax,%r13,1),%r8
add    -0x78(%rsp),%r13
movapd 0xbe1(%rip),%xmm15
mov    %rdx,-0x28(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,-0x10(%rsp)
mov    $0x1,%eax
mov    %rax,-0x60(%rsp)
xor    %eax,%eax
mov    %rax,-0x30(%rsp)
jmp    1493 <kern_r4_fma_o_f+0x393>
mov    -0x60(%rsp),%rdx
add    $0x1,%rdx
addq   $0x1,-0x30(%rsp)
mov    -0x48(%rsp),%rsi
mov    -0x8(%rsp),%rax
add    %rax,%rsi
mov    -0x50(%rsp),%rdi
add    %rax,%rdi
mov    -0x58(%rsp),%rbp
add    %rax,%rbp
mov    -0x10(%rsp),%rcx
add    %rcx,%r12
add    %rcx,%r14
add    %rcx,%r8
add    %rcx,%r13
add    %rax,%r10
mov    %rdx,-0x60(%rsp)
cmp    0x108(%rsp),%rdx
je     19ad <kern_r4_fma_o_f+0x8ad>
mov    %rbp,-0x58(%rsp)
mov    %rdi,-0x50(%rsp)
mov    %rsi,-0x48(%rsp)
cmpq   $0x0,0x100(%rsp)
jle    1440 <kern_r4_fma_o_f+0x340>
mov    -0x60(%rsp),%rax
mov    0x100(%rsp),%rdx
imul   %rdx,%rax
mov    %rax,%rcx
shl    $0x4,%rcx
shl    $0x5,%rax
mov    0xf0(%rsp),%rsi
movsd  (%rsi,%rcx,1),%xmm8
movsd  0x8(%rsi,%rcx,1),%xmm14
movsd  (%rsi,%rax,1),%xmm10
movsd  0x8(%rsi,%rax,1),%xmm9
mov    0xf8(%rsp),%rax
movsd  (%rax,%rcx,1),%xmm11
movsd  0x8(%rax,%rcx,1),%xmm1
cmp    $0x1,%rdx
jne    1690 <kern_r4_fma_o_f+0x590>
xor    %edi,%edi
unpcklpd %xmm8,%xmm8
unpcklpd %xmm10,%xmm10
unpcklpd %xmm11,%xmm11
unpcklpd %xmm9,%xmm9
movapd %xmm1,%xmm7
unpcklpd %xmm1,%xmm7
unpcklpd %xmm14,%xmm14
mov    0x100(%rsp),%r9
sub    %rdi,%r9
shl    $0x4,%rdi
mov    %r12,%rcx
mov    %r14,%rsi
mov    %r8,%rbp
mov    %r13,%rbx
mov    -0x48(%rsp),%rdx
mov    -0x50(%rsp),%rax
mov    -0x58(%rsp),%r15
mov    %r10,%r11
nopl   0x0(%rax)
movupd (%r11,%rdi,1),%xmm3
movapd %xmm3,%xmm0
xorpd  %xmm15,%xmm0
movapd %xmm3,%xmm2
shufpd $0x1,%xmm0,%xmm2
mulpd  %xmm8,%xmm3
addpd  %xmm2,%xmm3
movupd (%r15,%rdi,1),%xmm0
movapd %xmm0,%xmm2
xorpd  %xmm15,%xmm2
movapd %xmm0,%xmm4
shufpd $0x1,%xmm2,%xmm4
mulpd  %xmm10,%xmm0
addpd  %xmm4,%xmm0
mulpd  %xmm9,%xmm0
movupd (%rax,%rdi,1),%xmm2
movapd %xmm2,%xmm4
xorpd  %xmm15,%xmm4
movapd %xmm2,%xmm5
shufpd $0x1,%xmm4,%xmm5
mulpd  %xmm11,%xmm2
addpd  %xmm5,%xmm2
movupd (%rdx,%rdi,1),%xmm4
movapd %xmm0,%xmm6
addpd  %xmm4,%xmm6
subpd  %xmm0,%xmm4
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm3,%xmm5
subsd  %xmm0,%xmm5
movapd %xmm2,%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm3,%xmm0
unpckhpd %xmm2,%xmm2
unpckhpd %xmm3,%xmm3
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm3
mulpd  %xmm14,%xmm0
movapd %xmm0,%xmm2
addpd  %xmm6,%xmm2
movupd %xmm2,(%rbx,%rdi,1)
subpd  %xmm0,%xmm6
movupd %xmm6,0x0(%rbp,%rdi,1)
movapd %xmm3,%xmm0
xorpd  %xmm15,%xmm3
unpcklpd %xmm5,%xmm3
xorpd  %xmm15,%xmm5
unpcklpd %xmm5,%xmm0
mulpd  %xmm14,%xmm0
addpd  %xmm4,%xmm0
movupd %xmm0,(%rsi,%rdi,1)
mulpd  %xmm14,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rcx,%rdi,1)
add    $0x10,%r11
add    $0x10,%r15
add    $0x10,%rax
add    $0x10,%rdx
add    $0x10,%rbx
add    $0x10,%rbp
add    $0x10,%rsi
add    $0x10,%rcx
add    $0xffffffffffffffff,%r9
jne    1560 <kern_r4_fma_o_f+0x460>
jmp    1440 <kern_r4_fma_o_f+0x340>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x18(%rsp),%rax
imul   -0x30(%rsp),%rax
add    -0x20(%rsp),%rax
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    -0x68(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    -0x70(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
mov    -0x38(%rsp),%rdi
lea    (%rdi,%rax,8),%r9
mov    -0x28(%rsp),%rbp
lea    (%rcx,%rbp,1),%rdi
cmp    %rcx,%rdi
setb   %bl
mov    -0x79(%rsp),%al
or     %al,%bl
lea    (%rdx,%rbp,1),%rcx
cmp    %rdx,%rcx
setb   %dl
lea    (%rsi,%rbp,1),%rcx
cmp    %rsi,%rcx
setb   %cl
lea    (%r9,%rbp,1),%rsi
cmp    %r9,%rsi
setb   %sil
test   %bl,%bl
jne    1509 <kern_r4_fma_o_f+0x409>
or     %al,%dl
jne    1509 <kern_r4_fma_o_f+0x409>
or     %al,%cl
jne    1509 <kern_r4_fma_o_f+0x409>
or     %al,%sil
mov    $0x0,%edi
jne    150b <kern_r4_fma_o_f+0x40b>
movapd %xmm8,0x40(%rsp)
unpcklpd %xmm8,%xmm8
movapd %xmm8,0x90(%rsp)
movapd %xmm10,0x30(%rsp)
unpcklpd %xmm10,%xmm10
movapd %xmm10,0x80(%rsp)
movapd %xmm11,0x10(%rsp)
unpcklpd %xmm11,%xmm11
movapd %xmm11,0x70(%rsp)
movapd %xmm9,0x20(%rsp)
unpcklpd %xmm9,%xmm9
movapd %xmm9,0x60(%rsp)
movapd %xmm1,(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x50(%rsp)
movapd %xmm14,%xmm13
unpcklpd %xmm14,%xmm13
mov    -0x40(%rsp),%rdi
xor    %r9d,%r9d
mov    -0x48(%rsp),%rax
mov    -0x50(%rsp),%rcx
mov    -0x58(%rsp),%rdx
movupd (%r10,%r9,1),%xmm5
movupd 0x10(%r10,%r9,1),%xmm1
movapd %xmm5,%xmm4
unpcklpd %xmm1,%xmm4
unpckhpd %xmm1,%xmm5
movapd %xmm4,%xmm3
movapd 0x90(%rsp),%xmm0
mulpd  %xmm0,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm0,%xmm5
subpd  %xmm4,%xmm5
movupd (%rdx,%r9,1),%xmm9
movupd 0x10(%rdx,%r9,1),%xmm1
movapd %xmm9,%xmm4
unpcklpd %xmm1,%xmm4
unpckhpd %xmm1,%xmm9
movapd %xmm4,%xmm1
movapd 0x80(%rsp),%xmm0
mulpd  %xmm0,%xmm1
addpd  %xmm9,%xmm1
mulpd  %xmm0,%xmm9
subpd  %xmm4,%xmm9
movupd (%rcx,%r9,1),%xmm10
movupd 0x10(%rcx,%r9,1),%xmm4
movapd %xmm10,%xmm0
unpcklpd %xmm4,%xmm0
unpckhpd %xmm4,%xmm10
movapd %xmm0,%xmm6
movapd 0x70(%rsp),%xmm2
mulpd  %xmm2,%xmm6
addpd  %xmm10,%xmm6
mulpd  %xmm2,%xmm10
subpd  %xmm0,%xmm10
movupd (%rax,%r9,1),%xmm8
movupd 0x10(%rax,%r9,1),%xmm0
movapd %xmm8,%xmm4
unpcklpd %xmm0,%xmm4
unpckhpd %xmm0,%xmm8
movapd 0x60(%rsp),%xmm0
mulpd  %xmm0,%xmm1
movapd %xmm1,%xmm11
addpd  %xmm4,%xmm11
subpd  %xmm1,%xmm4
mulpd  %xmm0,%xmm9
movapd %xmm9,%xmm12
addpd  %xmm8,%xmm12
subpd  %xmm9,%xmm8
movapd 0x50(%rsp),%xmm1
mulpd  %xmm1,%xmm6
movapd %xmm6,%xmm0
addpd  %xmm3,%xmm0
subpd  %xmm6,%xmm3
mulpd  %xmm1,%xmm10
movapd %xmm10,%xmm7
addpd  %xmm5,%xmm7
subpd  %xmm10,%xmm5
mulpd  %xmm13,%xmm0
movapd %xmm0,%xmm6
addpd  %xmm11,%xmm6
mulpd  %xmm13,%xmm7
movapd %xmm7,%xmm1
addpd  %xmm12,%xmm1
movapd %xmm6,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm6,%xmm1
movups %xmm1,0x10(%r13,%r9,1)
movupd %xmm2,0x0(%r13,%r9,1)
subpd  %xmm0,%xmm11
subpd  %xmm7,%xmm12
movapd %xmm11,%xmm0
unpcklpd %xmm12,%xmm0
movhlps %xmm11,%xmm12
movups %xmm12,0x10(%r8,%r9,1)
movupd %xmm0,(%r8,%r9,1)
mulpd  %xmm13,%xmm5
movapd %xmm5,%xmm0
addpd  %xmm4,%xmm0
mulpd  %xmm13,%xmm3
movapd %xmm8,%xmm1
subpd  %xmm3,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%r14,%r9,1)
movupd %xmm2,(%r14,%r9,1)
subpd  %xmm5,%xmm4
addpd  %xmm8,%xmm3
movapd %xmm4,%xmm0
unpcklpd %xmm3,%xmm0
movhlps %xmm4,%xmm3
movups %xmm3,0x10(%r12,%r9,1)
movupd %xmm0,(%r12,%r9,1)
add    $0x20,%r9
add    $0xfffffffffffffffe,%rdi
jne    17a0 <kern_r4_fma_o_f+0x6a0>
mov    -0x40(%rsp),%rax
mov    %rax,%rdi
cmp    0x100(%rsp),%rax
movapd 0x40(%rsp),%xmm8
movapd 0x30(%rsp),%xmm10
movapd 0x20(%rsp),%xmm9
movapd 0x10(%rsp),%xmm11
movapd (%rsp),%xmm1
je     1440 <kern_r4_fma_o_f+0x340>
jmp    150b <kern_r4_fma_o_f+0x40b>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @kern_r4_fma_o_f(double* noalias %0, double* noalias %1, double* noalias %2, double* noalias %3, double* %4, double* %5, double* %6, double* %7, double* %8, double* %9, i64 %10, i64 %11) {
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca double*
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%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
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
store double* %0, double** %13
store double* %1, double** %14
store double* %2, double** %15
store double* %3, double** %16
store double* %4, double** %17
store double* %5, double** %18
store double* %6, double** %19
store double* %7, double** %20
store double* %8, double** %21
store double* %9, double** %22
store i64 %10, i64* %23
store i64 %11, i64* %24
store i64 0, i64* %26
br label %55
55: ; preds = %216, %12
%56 = load i64, i64* %26
%57 = load i64, i64* %23
%58 = icmp slt i64 %56, %57
br i1 %58, label %59, label %219
59: ; preds = %55
%60 = load double*, double** %17
%61 = load i64, i64* %26
%62 = mul nsw i64 2, %61
%63 = getelementptr inbounds double, double* %60, i64 %62
%64 = load double, double* %63
%65 = load double*, double** %19
%66 = load i64, i64* %26
%67 = mul nsw i64 2, %66
%68 = getelementptr inbounds double, double* %65, i64 %67
%69 = load double, double* %68
%70 = fadd double %64, %69
store double %70, double* %27
%71 = load double*, double** %17
%72 = load i64, i64* %26
%73 = mul nsw i64 2, %72
%74 = getelementptr inbounds double, double* %71, i64 %73
%75 = load double, double* %74
%76 = load double*, double** %19
%77 = load i64, i64* %26
%78 = mul nsw i64 2, %77
%79 = getelementptr inbounds double, double* %76, i64 %78
%80 = load double, double* %79
%81 = fsub double %75, %80
store double %81, double* %31
%82 = load double*, double** %17
%83 = load i64, i64* %26
%84 = mul nsw i64 2, %83
%85 = add nsw i64 %84, 1
%86 = getelementptr inbounds double, double* %82, i64 %85
%87 = load double, double* %86
%88 = load double*, double** %19
%89 = load i64, i64* %26
%90 = mul nsw i64 2, %89
%91 = add nsw i64 %90, 1
%92 = getelementptr inbounds double, double* %88, i64 %91
%93 = load double, double* %92
%94 = fadd double %87, %93
store double %94, double* %28
%95 = load double*, double** %17
%96 = load i64, i64* %26
%97 = mul nsw i64 2, %96
%98 = add nsw i64 %97, 1
%99 = getelementptr inbounds double, double* %95, i64 %98
%100 = load double, double* %99
%101 = load double*, double** %19
%102 = load i64, i64* %26
%103 = mul nsw i64 2, %102
%104 = add nsw i64 %103, 1
%105 = getelementptr inbounds double, double* %101, i64 %104
%106 = load double, double* %105
%107 = fsub double %100, %106
store double %107, double* %32
%108 = load double*, double** %18
%109 = load i64, i64* %26
%110 = mul nsw i64 2, %109
%111 = getelementptr inbounds double, double* %108, i64 %110
%112 = load double, double* %111
%113 = load double*, double** %20
%114 = load i64, i64* %26
%115 = mul nsw i64 2, %114
%116 = getelementptr inbounds double, double* %113, i64 %115
%117 = load double, double* %116
%118 = fadd double %112, %117
store double %118, double* %29
%119 = load double*, double** %18
%120 = load i64, i64* %26
%121 = mul nsw i64 2, %120
%122 = getelementptr inbounds double, double* %119, i64 %121
%123 = load double, double* %122
%124 = load double*, double** %20
%125 = load i64, i64* %26
%126 = mul nsw i64 2, %125
%127 = getelementptr inbounds double, double* %124, i64 %126
%128 = load double, double* %127
%129 = fsub double %123, %128
store double %129, double* %33
%130 = load double*, double** %18
%131 = load i64, i64* %26
%132 = mul nsw i64 2, %131
%133 = add nsw i64 %132, 1
%134 = getelementptr inbounds double, double* %130, i64 %133
%135 = load double, double* %134
%136 = load double*, double** %20
%137 = load i64, i64* %26
%138 = mul nsw i64 2, %137
%139 = add nsw i64 %138, 1
%140 = getelementptr inbounds double, double* %136, i64 %139
%141 = load double, double* %140
%142 = fadd double %135, %141
store double %142, double* %30
%143 = load double*, double** %18
%144 = load i64, i64* %26
%145 = mul nsw i64 2, %144
%146 = add nsw i64 %145, 1
%147 = getelementptr inbounds double, double* %143, i64 %146
%148 = load double, double* %147
%149 = load double*, double** %20
%150 = load i64, i64* %26
%151 = mul nsw i64 2, %150
%152 = add nsw i64 %151, 1
%153 = getelementptr inbounds double, double* %149, i64 %152
%154 = load double, double* %153
%155 = fsub double %148, %154
store double %155, double* %34
%156 = load double, double* %27
%157 = load double, double* %29
%158 = fadd double %156, %157
%159 = load double*, double** %13
%160 = load i64, i64* %26
%161 = mul nsw i64 2, %160
%162 = getelementptr inbounds double, double* %159, i64 %161
store double %158, double* %162
%163 = load double, double* %28
%164 = load double, double* %30
%165 = fadd double %163, %164
%166 = load double*, double** %13
%167 = load i64, i64* %26
%168 = mul nsw i64 2, %167
%169 = add nsw i64 %168, 1
%170 = getelementptr inbounds double, double* %166, i64 %169
store double %165, double* %170
%171 = load double, double* %27
%172 = load double, double* %29
%173 = fsub double %171, %172
%174 = load double*, double** %15
%175 = load i64, i64* %26
%176 = mul nsw i64 2, %175
%177 = getelementptr inbounds double, double* %174, i64 %176
store double %173, double* %177
%178 = load double, double* %28
%179 = load double, double* %30
%180 = fsub double %178, %179
%181 = load double*, double** %15
%182 = load i64, i64* %26
%183 = mul nsw i64 2, %182
%184 = add nsw i64 %183, 1
%185 = getelementptr inbounds double, double* %181, i64 %184
store double %180, double* %185
%186 = load double, double* %31
%187 = load double, double* %34
%188 = fadd double %186, %187
%189 = load double*, double** %14
%190 = load i64, i64* %26
%191 = mul nsw i64 2, %190
%192 = getelementptr inbounds double, double* %189, i64 %191
store double %188, double* %192
%193 = load double, double* %32
%194 = load double, double* %33
%195 = fsub double %193, %194
%196 = load double*, double** %14
%197 = load i64, i64* %26
%198 = mul nsw i64 2, %197
%199 = add nsw i64 %198, 1
%200 = getelementptr inbounds double, double* %196, i64 %199
store double %195, double* %200
%201 = load double, double* %31
%202 = load double, double* %34
%203 = fsub double %201, %202
%204 = load double*, double** %16
%205 = load i64, i64* %26
%206 = mul nsw i64 2, %205
%207 = getelementptr inbounds double, double* %204, i64 %206
store double %203, double* %207
%208 = load double, double* %32
%209 = load double, double* %33
%210 = fadd double %208, %209
%211 = load double*, double** %16
%212 = load i64, i64* %26
%213 = mul nsw i64 2, %212
%214 = add nsw i64 %213, 1
%215 = getelementptr inbounds double, double* %211, i64 %214
store double %210, double* %215
br label %216
216: ; preds = %59
%217 = load i64, i64* %26
%218 = add nsw i64 %217, 1
store i64 %218, i64* %26
br label %55
219: ; preds = %55
%220 = load i64, i64* %23
%221 = mul nsw i64 8, %220
%222 = load double*, double** %17
%223 = getelementptr inbounds double, double* %222, i64 %221
store double* %223, double** %17
%224 = load i64, i64* %23
%225 = mul nsw i64 8, %224
%226 = load double*, double** %18
%227 = getelementptr inbounds double, double* %226, i64 %225
store double* %227, double** %18
%228 = load i64, i64* %23
%229 = mul nsw i64 8, %228
%230 = load double*, double** %19
%231 = getelementptr inbounds double, double* %230, i64 %229
store double* %231, double** %19
%232 = load i64, i64* %23
%233 = mul nsw i64 8, %232
%234 = load double*, double** %20
%235 = getelementptr inbounds double, double* %234, i64 %233
store double* %235, double** %20
%236 = load i64, i64* %23
%237 = mul nsw i64 2, %236
%238 = load double*, double** %13
%239 = getelementptr inbounds double, double* %238, i64 %237
store double* %239, double** %13
%240 = load i64, i64* %23
%241 = mul nsw i64 2, %240
%242 = load double*, double** %14
%243 = getelementptr inbounds double, double* %242, i64 %241
store double* %243, double** %14
%244 = load i64, i64* %23
%245 = mul nsw i64 2, %244
%246 = load double*, double** %15
%247 = getelementptr inbounds double, double* %246, i64 %245
store double* %247, double** %15
%248 = load i64, i64* %23
%249 = mul nsw i64 2, %248
%250 = load double*, double** %16
%251 = getelementptr inbounds double, double* %250, i64 %249
store double* %251, double** %16
store i64 1, i64* %25
br label %252
252: ; preds = %550, %219
%253 = load i64, i64* %25
%254 = load i64, i64* %24
%255 = icmp slt i64 %253, %254
br i1 %255, label %256, label %553
256: ; preds = %252
%257 = load double*, double** %21
%258 = load i64, i64* %25
%259 = mul nsw i64 2, %258
%260 = load i64, i64* %23
%261 = mul nsw i64 %259, %260
%262 = getelementptr inbounds double, double* %257, i64 %261
%263 = load double, double* %262
store double %263, double* %35
%264 = load double*, double** %21
%265 = load i64, i64* %25
%266 = mul nsw i64 2, %265
%267 = load i64, i64* %23
%268 = mul nsw i64 %266, %267
%269 = add nsw i64 %268, 1
%270 = getelementptr inbounds double, double* %264, i64 %269
%271 = load double, double* %270
store double %271, double* %36
%272 = load double*, double** %21
%273 = load i64, i64* %25
%274 = mul nsw i64 4, %273
%275 = load i64, i64* %23
%276 = mul nsw i64 %274, %275
%277 = getelementptr inbounds double, double* %272, i64 %276
%278 = load double, double* %277
store double %278, double* %37
%279 = load double*, double** %21
%280 = load i64, i64* %25
%281 = mul nsw i64 4, %280
%282 = load i64, i64* %23
%283 = mul nsw i64 %281, %282
%284 = add nsw i64 %283, 1
%285 = getelementptr inbounds double, double* %279, i64 %284
%286 = load double, double* %285
store double %286, double* %38
%287 = load double*, double** %22
%288 = load i64, i64* %25
%289 = mul nsw i64 2, %288
%290 = load i64, i64* %23
%291 = mul nsw i64 %289, %290
%292 = getelementptr inbounds double, double* %287, i64 %291
%293 = load double, double* %292
store double %293, double* %39
%294 = load double*, double** %22
%295 = load i64, i64* %25
%296 = mul nsw i64 2, %295
%297 = load i64, i64* %23
%298 = mul nsw i64 %296, %297
%299 = add nsw i64 %298, 1
%300 = getelementptr inbounds double, double* %294, i64 %299
%301 = load double, double* %300
store double %301, double* %40
store i64 0, i64* %26
br label %302
302: ; preds = %514, %256
%303 = load i64, i64* %26
%304 = load i64, i64* %23
%305 = icmp slt i64 %303, %304
br i1 %305, label %306, label %517
306: ; preds = %302
%307 = load double*, double** %18
%308 = load i64, i64* %26
%309 = mul nsw i64 2, %308
%310 = getelementptr inbounds double, double* %307, i64 %309
%311 = load double, double* %310
%312 = load double, double* %35
%313 = load double*, double** %18
%314 = load i64, i64* %26
%315 = mul nsw i64 2, %314
%316 = add nsw i64 %315, 1
%317 = getelementptr inbounds double, double* %313, i64 %316
%318 = load double, double* %317
%319 = call double @llvm.fmuladd.f64(double %311, double %312, double %318)
store double %319, double* %41
%320 = load double*, double** %18
%321 = load i64, i64* %26
%322 = mul nsw i64 2, %321
%323 = add nsw i64 %322, 1
%324 = getelementptr inbounds double, double* %320, i64 %323
%325 = load double, double* %324
%326 = load double, double* %35
%327 = load double*, double** %18
%328 = load i64, i64* %26
%329 = mul nsw i64 2, %328
%330 = getelementptr inbounds double, double* %327, i64 %329
%331 = load double, double* %330
%332 = fneg double %331
%333 = call double @llvm.fmuladd.f64(double %325, double %326, double %332)
store double %333, double* %42
%334 = load double*, double** %19
%335 = load i64, i64* %26
%336 = mul nsw i64 2, %335
%337 = getelementptr inbounds double, double* %334, i64 %336
%338 = load double, double* %337
%339 = load double, double* %37
%340 = load double*, double** %19
%341 = load i64, i64* %26
%342 = mul nsw i64 2, %341
%343 = add nsw i64 %342, 1
%344 = getelementptr inbounds double, double* %340, i64 %343
%345 = load double, double* %344
%346 = call double @llvm.fmuladd.f64(double %338, double %339, double %345)
store double %346, double* %43
%347 = load double*, double** %19
%348 = load i64, i64* %26
%349 = mul nsw i64 2, %348
%350 = add nsw i64 %349, 1
%351 = getelementptr inbounds double, double* %347, i64 %350
%352 = load double, double* %351
%353 = load double, double* %37
%354 = load double*, double** %19
%355 = load i64, i64* %26
%356 = mul nsw i64 2, %355
%357 = getelementptr inbounds double, double* %354, i64 %356
%358 = load double, double* %357
%359 = fneg double %358
%360 = call double @llvm.fmuladd.f64(double %352, double %353, double %359)
store double %360, double* %44
%361 = load double*, double** %20
%362 = load i64, i64* %26
%363 = mul nsw i64 2, %362
%364 = getelementptr inbounds double, double* %361, i64 %363
%365 = load double, double* %364
%366 = load double, double* %39
%367 = load double*, double** %20
%368 = load i64, i64* %26
%369 = mul nsw i64 2, %368
%370 = add nsw i64 %369, 1
%371 = getelementptr inbounds double, double* %367, i64 %370
%372 = load double, double* %371
%373 = call double @llvm.fmuladd.f64(double %365, double %366, double %372)
store double %373, double* %45
%374 = load double*, double** %20
%375 = load i64, i64* %26
%376 = mul nsw i64 2, %375
%377 = add nsw i64 %376, 1
%378 = getelementptr inbounds double, double* %374, i64 %377
%379 = load double, double* %378
%380 = load double, double* %39
%381 = load double*, double** %20
%382 = load i64, i64* %26
%383 = mul nsw i64 2, %382
%384 = getelementptr inbounds double, double* %381, i64 %383
%385 = load double, double* %384
%386 = fneg double %385
%387 = call double @llvm.fmuladd.f64(double %379, double %380, double %386)
store double %387, double* %46
%388 = load double*, double** %17
%389 = load i64, i64* %26
%390 = mul nsw i64 2, %389
%391 = getelementptr inbounds double, double* %388, i64 %390
%392 = load double, double* %391
%393 = load double, double* %43
%394 = load double, double* %38
%395 = call double @llvm.fmuladd.f64(double %393, double %394, double %392)
store double %395, double* %47
%396 = load double*, double** %17
%397 = load i64, i64* %26
%398 = mul nsw i64 2, %397
%399 = getelementptr inbounds double, double* %396, i64 %398
%400 = load double, double* %399
%401 = load double, double* %43
%402 = load double, double* %38
%403 = fneg double %401
%404 = call double @llvm.fmuladd.f64(double %403, double %402, double %400)
store double %404, double* %51
%405 = load double*, double** %17
%406 = load i64, i64* %26
%407 = mul nsw i64 2, %406
%408 = add nsw i64 %407, 1
%409 = getelementptr inbounds double, double* %405, i64 %408
%410 = load double, double* %409
%411 = load double, double* %44
%412 = load double, double* %38
%413 = call double @llvm.fmuladd.f64(double %411, double %412, double %410)
store double %413, double* %48
%414 = load double*, double** %17
%415 = load i64, i64* %26
%416 = mul nsw i64 2, %415
%417 = add nsw i64 %416, 1
%418 = getelementptr inbounds double, double* %414, i64 %417
%419 = load double, double* %418
%420 = load double, double* %44
%421 = load double, double* %38
%422 = fneg double %420
%423 = call double @llvm.fmuladd.f64(double %422, double %421, double %419)
store double %423, double* %52
%424 = load double, double* %41
%425 = load double, double* %45
%426 = load double, double* %40
%427 = call double @llvm.fmuladd.f64(double %425, double %426, double %424)
store double %427, double* %49
%428 = load double, double* %41
%429 = load double, double* %45
%430 = load double, double* %40
%431 = fneg double %429
%432 = call double @llvm.fmuladd.f64(double %431, double %430, double %428)
store double %432, double* %53
%433 = load double, double* %42
%434 = load double, double* %46
%435 = load double, double* %40
%436 = call double @llvm.fmuladd.f64(double %434, double %435, double %433)
store double %436, double* %50
%437 = load double, double* %42
%438 = load double, double* %46
%439 = load double, double* %40
%440 = fneg double %438
%441 = call double @llvm.fmuladd.f64(double %440, double %439, double %437)
store double %441, double* %54
%442 = load double, double* %47
%443 = load double, double* %49
%444 = load double, double* %36
%445 = call double @llvm.fmuladd.f64(double %443, double %444, double %442)
%446 = load double*, double** %13
%447 = load i64, i64* %26
%448 = mul nsw i64 2, %447
%449 = getelementptr inbounds double, double* %446, i64 %448
store double %445, double* %449
%450 = load double, double* %48
%451 = load double, double* %50
%452 = load double, double* %36
%453 = call double @llvm.fmuladd.f64(double %451, double %452, double %450)
%454 = load double*, double** %13
%455 = load i64, i64* %26
%456 = mul nsw i64 2, %455
%457 = add nsw i64 %456, 1
%458 = getelementptr inbounds double, double* %454, i64 %457
store double %453, double* %458
%459 = load double, double* %47
%460 = load double, double* %49
%461 = load double, double* %36
%462 = fneg double %460
%463 = call double @llvm.fmuladd.f64(double %462, double %461, double %459)
%464 = load double*, double** %15
%465 = load i64, i64* %26
%466 = mul nsw i64 2, %465
%467 = getelementptr inbounds double, double* %464, i64 %466
store double %463, double* %467
%468 = load double, double* %48
%469 = load double, double* %50
%470 = load double, double* %36
%471 = fneg double %469
%472 = call double @llvm.fmuladd.f64(double %471, double %470, double %468)
%473 = load double*, double** %15
%474 = load i64, i64* %26
%475 = mul nsw i64 2, %474
%476 = add nsw i64 %475, 1
%477 = getelementptr inbounds double, double* %473, i64 %476
store double %472, double* %477
%478 = load double, double* %51
%479 = load double, double* %54
%480 = load double, double* %36
%481 = call double @llvm.fmuladd.f64(double %479, double %480, double %478)
%482 = load double*, double** %14
%483 = load i64, i64* %26
%484 = mul nsw i64 2, %483
%485 = getelementptr inbounds double, double* %482, i64 %484
store double %481, double* %485
%486 = load double, double* %52
%487 = load double, double* %53
%488 = load double, double* %36
%489 = fneg double %487
%490 = call double @llvm.fmuladd.f64(double %489, double %488, double %486)
%491 = load double*, double** %14
%492 = load i64, i64* %26
%493 = mul nsw i64 2, %492
%494 = add nsw i64 %493, 1
%495 = getelementptr inbounds double, double* %491, i64 %494
store double %490, double* %495
%496 = load double, double* %51
%497 = load double, double* %54
%498 = load double, double* %36
%499 = fneg double %497
%500 = call double @llvm.fmuladd.f64(double %499, double %498, double %496)
%501 = load double*, double** %16
%502 = load i64, i64* %26
%503 = mul nsw i64 2, %502
%504 = getelementptr inbounds double, double* %501, i64 %503
store double %500, double* %504
%505 = load double, double* %52
%506 = load double, double* %53
%507 = load double, double* %36
%508 = call double @llvm.fmuladd.f64(double %506, double %507, double %505)
%509 = load double*, double** %16
%510 = load i64, i64* %26
%511 = mul nsw i64 2, %510
%512 = add nsw i64 %511, 1
%513 = getelementptr inbounds double, double* %509, i64 %512
store double %508, double* %513
br label %514
514: ; preds = %306
%515 = load i64, i64* %26
%516 = add nsw i64 %515, 1
store i64 %516, i64* %26
br label %302
517: ; preds = %302
%518 = load i64, i64* %23
%519 = mul nsw i64 8, %518
%520 = load double*, double** %17
%521 = getelementptr inbounds double, double* %520, i64 %519
store double* %521, double** %17
%522 = load i64, i64* %23
%523 = mul nsw i64 8, %522
%524 = load double*, double** %18
%525 = getelementptr inbounds double, double* %524, i64 %523
store double* %525, double** %18
%526 = load i64, i64* %23
%527 = mul nsw i64 8, %526
%528 = load double*, double** %19
%529 = getelementptr inbounds double, double* %528, i64 %527
store double* %529, double** %19
%530 = load i64, i64* %23
%531 = mul nsw i64 8, %530
%532 = load double*, double** %20
%533 = getelementptr inbounds double, double* %532, i64 %531
store double* %533, double** %20
%534 = load i64, i64* %23
%535 = mul nsw i64 2, %534
%536 = load double*, double** %13
%537 = getelementptr inbounds double, double* %536, i64 %535
store double* %537, double** %13
%538 = load i64, i64* %23
%539 = mul nsw i64 2, %538
%540 = load double*, double** %14
%541 = getelementptr inbounds double, double* %540, i64 %539
store double* %541, double** %14
%542 = load i64, i64* %23
%543 = mul nsw i64 2, %542
%544 = load double*, double** %15
%545 = getelementptr inbounds double, double* %544, i64 %543
store double* %545, double** %15
%546 = load i64, i64* %23
%547 = mul nsw i64 2, %546
%548 = load double*, double** %16
%549 = getelementptr inbounds double, double* %548, i64 %547
store double* %549, double** %16
br label %550
550: ; preds = %517
%551 = load i64, i64* %25
%552 = add nsw i64 %551, 1
store i64 %552, i64* %25
br label %252
553: ; preds = %252
ret void
}

LLVM IR (-O2):
define void @kern_r4_fma_o_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, double* nocapture %7, double* nocapture %8, double* nocapture %9, i64 %10, i64 %11) {
%13 = icmp sgt i64 %10, 0
br i1 %13, label %14, label %116
14: ; preds = %12
%15 = icmp eq i64 %10, 1
br i1 %15, label %78, label %16
16: ; preds = %14
%17 = and i64 %10, -2
%18 = getelementptr inbounds double, double* %0, i64 -1
%19 = getelementptr inbounds double, double* %2, i64 -1
%20 = getelementptr inbounds double, double* %1, i64 -1
%21 = getelementptr inbounds double, double* %3, i64 -1
br label %22
22: ; preds = %22, %16
%23 = phi i64 [ 0, %16 ], [ %74, %22 ]
%24 = shl nuw nsw i64 %23, 1
%25 = getelementptr inbounds double, double* %4, i64 %24
%26 = bitcast double* %25 to <4 x double>*
%27 = load <4 x double>, <4 x double>* %26
%28 = shufflevector <4 x double> %27, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%29 = shufflevector <4 x double> %27, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%30 = getelementptr inbounds double, double* %6, i64 %24
%31 = bitcast double* %30 to <4 x double>*
%32 = load <4 x double>, <4 x double>* %31
%33 = shufflevector <4 x double> %32, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%34 = shufflevector <4 x double> %32, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%35 = fadd <2 x double> %28, %33
%36 = fsub <2 x double> %28, %33
%37 = or i64 %24, 1
%38 = fadd <2 x double> %29, %34
%39 = fsub <2 x double> %29, %34
%40 = getelementptr inbounds double, double* %5, i64 %24
%41 = bitcast double* %40 to <4 x double>*
%42 = load <4 x double>, <4 x double>* %41
%43 = shufflevector <4 x double> %42, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%44 = shufflevector <4 x double> %42, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%45 = getelementptr inbounds double, double* %7, i64 %24
%46 = bitcast double* %45 to <4 x double>*
%47 = load <4 x double>, <4 x double>* %46
%48 = shufflevector <4 x double> %47, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%49 = shufflevector <4 x double> %47, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%50 = fadd <2 x double> %43, %48
%51 = fsub <2 x double> %43, %48
%52 = fadd <2 x double> %44, %49
%53 = fsub <2 x double> %44, %49
%54 = fadd <2 x double> %35, %50
%55 = fadd <2 x double> %38, %52
%56 = getelementptr inbounds double, double* %18, i64 %37
%57 = bitcast double* %56 to <4 x double>*
%58 = shufflevector <2 x double> %54, <2 x double> %55, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %58, <4 x double>* %57
%59 = fsub <2 x double> %35, %50
%60 = fsub <2 x double> %38, %52
%61 = getelementptr inbounds double, double* %19, i64 %37
%62 = bitcast double* %61 to <4 x double>*
%63 = shufflevector <2 x double> %59, <2 x double> %60, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %63, <4 x double>* %62
%64 = fadd <2 x double> %36, %53
%65 = fsub <2 x double> %39, %51
%66 = getelementptr inbounds double, double* %20, i64 %37
%67 = bitcast double* %66 to <4 x double>*
%68 = shufflevector <2 x double> %64, <2 x double> %65, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %68, <4 x double>* %67
%69 = fsub <2 x double> %36, %53
%70 = fadd <2 x double> %39, %51
%71 = getelementptr inbounds double, double* %21, i64 %37
%72 = bitcast double* %71 to <4 x double>*
%73 = shufflevector <2 x double> %69, <2 x double> %70, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %73, <4 x double>* %72
%74 = add nuw i64 %23, 2
%75 = icmp eq i64 %74, %17
br i1 %75, label %76, label %22
76: ; preds = %22
%77 = icmp eq i64 %17, %10
br i1 %77, label %116, label %78
78: ; preds = %14, %76
%79 = phi i64 [ 0, %14 ], [ %17, %76 ]
br label %80
80: ; preds = %78, %80
%81 = phi i64 [ %114, %80 ], [ %79, %78 ]
%82 = shl nuw nsw i64 %81, 1
%83 = getelementptr inbounds double, double* %4, i64 %82
%84 = getelementptr inbounds double, double* %6, i64 %82
%85 = bitcast double* %83 to <2 x double>*
%86 = load <2 x double>, <2 x double>* %85
%87 = bitcast double* %84 to <2 x double>*
%88 = load <2 x double>, <2 x double>* %87
%89 = fadd <2 x double> %86, %88
%90 = fsub <2 x double> %86, %88
%91 = getelementptr inbounds double, double* %5, i64 %82
%92 = getelementptr inbounds double, double* %7, i64 %82
%93 = bitcast double* %91 to <2 x double>*
%94 = load <2 x double>, <2 x double>* %93
%95 = bitcast double* %92 to <2 x double>*
%96 = load <2 x double>, <2 x double>* %95
%97 = fadd <2 x double> %94, %96
%98 = fsub <2 x double> %94, %96
%99 = shufflevector <2 x double> %98, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%100 = getelementptr inbounds double, double* %0, i64 %82
%101 = fadd <2 x double> %89, %97
%102 = bitcast double* %100 to <2 x double>*
store <2 x double> %101, <2 x double>* %102
%103 = getelementptr inbounds double, double* %2, i64 %82
%104 = fsub <2 x double> %89, %97
%105 = bitcast double* %103 to <2 x double>*
store <2 x double> %104, <2 x double>* %105
%106 = getelementptr inbounds double, double* %1, i64 %82
%107 = fadd <2 x double> %90, %99
%108 = fsub <2 x double> %90, %99
%109 = shufflevector <2 x double> %107, <2 x double> %108, <2 x i32> <i32 0, i32 3>
%110 = bitcast double* %106 to <2 x double>*
store <2 x double> %109, <2 x double>* %110
%111 = getelementptr inbounds double, double* %3, i64 %82
%112 = shufflevector <2 x double> %108, <2 x double> %107, <2 x i32> <i32 0, i32 3>
%113 = bitcast double* %111 to <2 x double>*
store <2 x double> %112, <2 x double>* %113
%114 = add nuw nsw i64 %81, 1
%115 = icmp eq i64 %114, %10
br i1 %115, label %116, label %80
116: ; preds = %80, %76, %12
%117 = shl nsw i64 %10, 3
%118 = shl i64 %10, 1
%119 = icmp sgt i64 %11, 1
br i1 %119, label %120, label %376
120: ; preds = %116
%121 = add i64 %10, -1
%122 = or i64 %118, 1
%123 = shl i64 %10, 1
%124 = icmp eq i64 %10, 1
%125 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %121, i64 16)
%126 = extractvalue { i64, i1 } %125, 0
%127 = extractvalue { i64, i1 } %125, 1
%128 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %121, i64 16)
%129 = extractvalue { i64, i1 } %128, 0
%130 = extractvalue { i64, i1 } %128, 1
%131 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %121, i64 16)
%132 = extractvalue { i64, i1 } %131, 0
%133 = extractvalue { i64, i1 } %131, 1
%134 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %121, i64 16)
%135 = extractvalue { i64, i1 } %134, 0
%136 = extractvalue { i64, i1 } %134, 1
%137 = and i64 %10, -2
%138 = icmp eq i64 %137, %10
br label %139
139: ; preds = %120, %372
%140 = phi i64 [ 0, %120 ], [ %375, %372 ]
%141 = phi double* [ %7, %120 ], [ %167, %372 ]
%142 = phi double* [ %6, %120 ], [ %166, %372 ]
%143 = phi double* [ %5, %120 ], [ %165, %372 ]
%144 = phi double* [ %4, %120 ], [ %164, %372 ]
%145 = phi double* [ %3, %120 ], [ %163, %372 ]
%146 = phi double* [ %2, %120 ], [ %162, %372 ]
%147 = phi double* [ %1, %120 ], [ %161, %372 ]
%148 = phi double* [ %0, %120 ], [ %160, %372 ]
%149 = phi i64 [ 1, %120 ], [ %373, %372 ]
%150 = mul i64 %123, %140
%151 = add i64 %122, %150
%152 = getelementptr double, double* %0, i64 %151
%153 = bitcast double* %152 to i8*
%154 = getelementptr double, double* %2, i64 %151
%155 = bitcast double* %154 to i8*
%156 = getelementptr double, double* %1, i64 %151
%157 = bitcast double* %156 to i8*
%158 = getelementptr double, double* %3, i64 %151
%159 = bitcast double* %158 to i8*
%160 = getelementptr inbounds double, double* %148, i64 %118
%161 = getelementptr inbounds double, double* %147, i64 %118
%162 = getelementptr inbounds double, double* %146, i64 %118
%163 = getelementptr inbounds double, double* %145, i64 %118
%164 = getelementptr inbounds double, double* %144, i64 %117
%165 = getelementptr inbounds double, double* %143, i64 %117
%166 = getelementptr inbounds double, double* %142, i64 %117
%167 = getelementptr inbounds double, double* %141, i64 %117
%168 = shl nuw nsw i64 %149, 1
%169 = mul nsw i64 %168, %10
%170 = getelementptr inbounds double, double* %8, i64 %169
%171 = load double, double* %170
%172 = or i64 %169, 1
%173 = getelementptr inbounds double, double* %8, i64 %172
%174 = load double, double* %173
%175 = shl nsw i64 %149, 2
%176 = mul nsw i64 %175, %10
%177 = getelementptr inbounds double, double* %8, i64 %176
%178 = load double, double* %177
%179 = or i64 %176, 1
%180 = getelementptr inbounds double, double* %8, i64 %179
%181 = load double, double* %180
%182 = getelementptr inbounds double, double* %9, i64 %169
%183 = load double, double* %182
%184 = getelementptr inbounds double, double* %9, i64 %172
%185 = load double, double* %184
br i1 %13, label %186, label %372
186: ; preds = %139
br i1 %124, label %292, label %187
187: ; preds = %186
%188 = getelementptr i8, i8* %153, i64 %126
%189 = icmp ult i8* %188, %153
%190 = or i1 %189, %127
%191 = getelementptr i8, i8* %155, i64 %129
%192 = icmp ult i8* %191, %155
%193 = or i1 %192, %130
%194 = getelementptr i8, i8* %157, i64 %132
%195 = icmp ult i8* %194, %157
%196 = or i1 %195, %133
%197 = getelementptr i8, i8* %159, i64 %135
%198 = icmp ult i8* %197, %159
%199 = or i1 %198, %136
%200 = or i1 %190, %193
%201 = or i1 %200, %196
%202 = or i1 %201, %199
br i1 %202, label %292, label %203
203: ; preds = %187
%204 = insertelement <2 x double> poison, double %171, i64 0
%205 = shufflevector <2 x double> %204, <2 x double> poison, <2 x i32> zeroinitializer
%206 = insertelement <2 x double> poison, double %178, i64 0
%207 = shufflevector <2 x double> %206, <2 x double> poison, <2 x i32> zeroinitializer
%208 = insertelement <2 x double> poison, double %183, i64 0
%209 = shufflevector <2 x double> %208, <2 x double> poison, <2 x i32> zeroinitializer
%210 = insertelement <2 x double> poison, double %181, i64 0
%211 = shufflevector <2 x double> %210, <2 x double> poison, <2 x i32> zeroinitializer
%212 = insertelement <2 x double> poison, double %185, i64 0
%213 = shufflevector <2 x double> %212, <2 x double> poison, <2 x i32> zeroinitializer
%214 = insertelement <2 x double> poison, double %174, i64 0
%215 = shufflevector <2 x double> %214, <2 x double> poison, <2 x i32> zeroinitializer
%216 = getelementptr inbounds double, double* %160, i64 -1
%217 = getelementptr inbounds double, double* %162, i64 -1
%218 = getelementptr inbounds double, double* %161, i64 -1
%219 = getelementptr inbounds double, double* %163, i64 -1
br label %220
220: ; preds = %220, %203
%221 = phi i64 [ 0, %203 ], [ %289, %220 ]
%222 = shl nuw nsw i64 %221, 1
%223 = getelementptr inbounds double, double* %165, i64 %222
%224 = bitcast double* %223 to <4 x double>*
%225 = load <4 x double>, <4 x double>* %224
%226 = shufflevector <4 x double> %225, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%227 = shufflevector <4 x double> %225, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%228 = or i64 %222, 1
%229 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %226, <2 x double> %205, <2 x double> %227)
%230 = fneg <2 x double> %226
%231 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %227, <2 x double> %205, <2 x double> %230)
%232 = getelementptr inbounds double, double* %166, i64 %222
%233 = bitcast double* %232 to <4 x double>*
%234 = load <4 x double>, <4 x double>* %233
%235 = shufflevector <4 x double> %234, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%236 = shufflevector <4 x double> %234, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%237 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %235, <2 x double> %207, <2 x double> %236)
%238 = fneg <2 x double> %235
%239 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %236, <2 x double> %207, <2 x double> %238)
%240 = getelementptr inbounds double, double* %167, i64 %222
%241 = bitcast double* %240 to <4 x double>*
%242 = load <4 x double>, <4 x double>* %241
%243 = shufflevector <4 x double> %242, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%244 = shufflevector <4 x double> %242, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%245 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %243, <2 x double> %209, <2 x double> %244)
%246 = fneg <2 x double> %243
%247 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %244, <2 x double> %209, <2 x double> %246)
%248 = getelementptr inbounds double, double* %164, i64 %222
%249 = bitcast double* %248 to <4 x double>*
%250 = load <4 x double>, <4 x double>* %249
%251 = shufflevector <4 x double> %250, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%252 = shufflevector <4 x double> %250, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%253 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %237, <2 x double> %211, <2 x double> %251)
%254 = fneg <2 x double> %237
%255 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %254, <2 x double> %211, <2 x double> %251)
%256 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %239, <2 x double> %211, <2 x double> %252)
%257 = fneg <2 x double> %239
%258 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %257, <2 x double> %211, <2 x double> %252)
%259 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %245, <2 x double> %213, <2 x double> %229)
%260 = fneg <2 x double> %245
%261 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %260, <2 x double> %213, <2 x double> %229)
%262 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %247, <2 x double> %213, <2 x double> %231)
%263 = fneg <2 x double> %247
%264 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %263, <2 x double> %213, <2 x double> %231)
%265 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %259, <2 x double> %215, <2 x double> %253)
%266 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %262, <2 x double> %215, <2 x double> %256)
%267 = getelementptr inbounds double, double* %216, i64 %228
%268 = bitcast double* %267 to <4 x double>*
%269 = shufflevector <2 x double> %265, <2 x double> %266, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %269, <4 x double>* %268
%270 = fneg <2 x double> %259
%271 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %270, <2 x double> %215, <2 x double> %253)
%272 = fneg <2 x double> %262
%273 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %272, <2 x double> %215, <2 x double> %256)
%274 = getelementptr inbounds double, double* %217, i64 %228
%275 = bitcast double* %274 to <4 x double>*
%276 = shufflevector <2 x double> %271, <2 x double> %273, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %276, <4 x double>* %275
%277 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %264, <2 x double> %215, <2 x double> %255)
%278 = fneg <2 x double> %261
%279 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %278, <2 x double> %215, <2 x double> %258)
%280 = getelementptr inbounds double, double* %218, i64 %228
%281 = bitcast double* %280 to <4 x double>*
%282 = shufflevector <2 x double> %277, <2 x double> %279, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %282, <4 x double>* %281
%283 = fneg <2 x double> %264
%284 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %283, <2 x double> %215, <2 x double> %255)
%285 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %261, <2 x double> %215, <2 x double> %258)
%286 = getelementptr inbounds double, double* %219, i64 %228
%287 = bitcast double* %286 to <4 x double>*
%288 = shufflevector <2 x double> %284, <2 x double> %285, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %288, <4 x double>* %287
%289 = add nuw i64 %221, 2
%290 = icmp eq i64 %289, %137
br i1 %290, label %291, label %220
291: ; preds = %220
br i1 %138, label %372, label %292
292: ; preds = %187, %186, %291
%293 = phi i64 [ 0, %187 ], [ 0, %186 ], [ %137, %291 ]
%294 = insertelement <2 x double> poison, double %171, i64 0
%295 = shufflevector <2 x double> %294, <2 x double> poison, <2 x i32> zeroinitializer
%296 = insertelement <2 x double> poison, double %178, i64 0
%297 = shufflevector <2 x double> %296, <2 x double> poison, <2 x i32> zeroinitializer
%298 = insertelement <2 x double> poison, double %183, i64 0
%299 = shufflevector <2 x double> %298, <2 x double> poison, <2 x i32> zeroinitializer
%300 = insertelement <2 x double> poison, double %181, i64 0
%301 = shufflevector <2 x double> %300, <2 x double> poison, <2 x i32> zeroinitializer
%302 = insertelement <2 x double> poison, double %185, i64 0
%303 = shufflevector <2 x double> %302, <2 x double> poison, <2 x i32> zeroinitializer
%304 = insertelement <2 x double> poison, double %174, i64 0
%305 = shufflevector <2 x double> %304, <2 x double> poison, <2 x i32> zeroinitializer
br label %306
306: ; preds = %292, %306
%307 = phi i64 [ %370, %306 ], [ %293, %292 ]
%308 = shl nuw nsw i64 %307, 1
%309 = getelementptr inbounds double, double* %165, i64 %308
%310 = bitcast double* %309 to <2 x double>*
%311 = load <2 x double>, <2 x double>* %310
%312 = extractelement <2 x double> %311, i64 0
%313 = fneg double %312
%314 = extractelement <2 x double> %311, i64 1
%315 = insertelement <2 x double> poison, double %314, i64 0
%316 = insertelement <2 x double> %315, double %313, i64 1
%317 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %311, <2 x double> %295, <2 x double> %316)
%318 = getelementptr inbounds double, double* %166, i64 %308
%319 = bitcast double* %318 to <2 x double>*
%320 = load <2 x double>, <2 x double>* %319
%321 = extractelement <2 x double> %320, i64 0
%322 = fneg double %321
%323 = extractelement <2 x double> %320, i64 1
%324 = insertelement <2 x double> poison, double %323, i64 0
%325 = insertelement <2 x double> %324, double %322, i64 1
%326 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %320, <2 x double> %297, <2 x double> %325)
%327 = getelementptr inbounds double, double* %167, i64 %308
%328 = bitcast double* %327 to <2 x double>*
%329 = load <2 x double>, <2 x double>* %328
%330 = extractelement <2 x double> %329, i64 0
%331 = fneg double %330
%332 = extractelement <2 x double> %329, i64 1
%333 = insertelement <2 x double> poison, double %332, i64 0
%334 = insertelement <2 x double> %333, double %331, i64 1
%335 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %329, <2 x double> %299, <2 x double> %334)
%336 = getelementptr inbounds double, double* %164, i64 %308
%337 = bitcast double* %336 to <2 x double>*
%338 = load <2 x double>, <2 x double>* %337
%339 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %326, <2 x double> %301, <2 x double> %338)
%340 = fneg <2 x double> %326
%341 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %340, <2 x double> %301, <2 x double> %338)
%342 = extractelement <2 x double> %335, i64 0
%343 = fneg double %342
%344 = extractelement <2 x double> %317, i64 0
%345 = tail call double @llvm.fmuladd.f64(double %343, double %185, double %344)
%346 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %335, <2 x double> %303, <2 x double> %317)
%347 = extractelement <2 x double> %335, i64 1
%348 = fneg double %347
%349 = extractelement <2 x double> %317, i64 1
%350 = tail call double @llvm.fmuladd.f64(double %348, double %185, double %349)
%351 = getelementptr inbounds double, double* %160, i64 %308
%352 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %346, <2 x double> %305, <2 x double> %339)
%353 = bitcast double* %351 to <2 x double>*
store <2 x double> %352, <2 x double>* %353
%354 = getelementptr inbounds double, double* %162, i64 %308
%355 = fneg <2 x double> %346
%356 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %355, <2 x double> %305, <2 x double> %339)
%357 = bitcast double* %354 to <2 x double>*
store <2 x double> %356, <2 x double>* %357
%358 = getelementptr inbounds double, double* %161, i64 %308
%359 = fneg double %345
%360 = insertelement <2 x double> poison, double %350, i64 0
%361 = insertelement <2 x double> %360, double %359, i64 1
%362 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %361, <2 x double> %305, <2 x double> %341)
%363 = bitcast double* %358 to <2 x double>*
store <2 x double> %362, <2 x double>* %363
%364 = fneg double %350
%365 = getelementptr inbounds double, double* %163, i64 %308
%366 = insertelement <2 x double> poison, double %364, i64 0
%367 = insertelement <2 x double> %366, double %345, i64 1
%368 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %367, <2 x double> %305, <2 x double> %341)
%369 = bitcast double* %365 to <2 x double>*
store <2 x double> %368, <2 x double>* %369
%370 = add nuw nsw i64 %307, 1
%371 = icmp eq i64 %370, %10
br i1 %371, label %372, label %306
372: ; preds = %306, %291, %139
%373 = add nuw nsw i64 %149, 1
%374 = icmp eq i64 %373, %11
%375 = add i64 %140, 1
br i1 %374, label %376, label %139
376: ; preds = %372, %116
ret void
}