void kern_r4_fma_o_b(double *restrict o0, double *restrict o1,
                     double *restrict o2, double *restrict o3, double *i0,
                     double *i1, double *i2, double *i3, double *w, 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] + i1[2 * j + 1] * wr1;
      pr2 = i2[2 * j] * wr2 - i2[2 * j + 1];
      pi2 = i2[2 * j] + i2[2 * j + 1] * wr2;
      pr3 = i3[2 * j] * wr3 - i3[2 * j + 1];
      pi3 = i3[2 * j] + i3[2 * j + 1] * wr3;
      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_b>:
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_b+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
subsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
subsd  -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_b+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_b+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_b+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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
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
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,(%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    -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
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
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,0x8(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    14f3 <kern_r4_fma_o_b+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_b+0x326>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r4_fma_o_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdx,-0x60(%rsp)
mov    %rsi,-0x68(%rsp)
mov    %rdi,-0x70(%rsp)
mov    0xf8(%rsp),%r11
mov    0xf0(%rsp),%r10
cmpq   $0x0,0x110(%rsp)
jle    137e <kern_r4_fma_o_b+0x27e>
mov    0x110(%rsp),%rbp
cmp    $0x1,%rbp
jne    1155 <kern_r4_fma_o_b+0x55>
xor    %r14d,%r14d
jmp    12ae <kern_r4_fma_o_b+0x1ae>
mov    %rbp,%r14
and    $0xfffffffffffffffe,%r14
xor    %edx,%edx
mov    %r14,%rdi
mov    -0x60(%rsp),%rax
mov    -0x68(%rsp),%rsi
mov    -0x70(%rsp),%rbx
movupd (%r8,%rdx,1),%xmm3
movupd 0x10(%r8,%rdx,1),%xmm2
movapd %xmm3,%xmm8
unpcklpd %xmm2,%xmm8
unpckhpd %xmm2,%xmm3
movupd (%r10,%rdx,1),%xmm2
movupd 0x10(%r10,%rdx,1),%xmm0
movapd %xmm2,%xmm5
unpcklpd %xmm0,%xmm5
unpckhpd %xmm0,%xmm2
movapd %xmm8,%xmm4
addpd  %xmm5,%xmm4
subpd  %xmm5,%xmm8
movapd %xmm3,%xmm0
addpd  %xmm2,%xmm0
subpd  %xmm2,%xmm3
movupd (%r9,%rdx,1),%xmm2
movupd 0x10(%r9,%rdx,1),%xmm6
movapd %xmm2,%xmm9
unpcklpd %xmm6,%xmm9
unpckhpd %xmm6,%xmm2
movupd (%r11,%rdx,1),%xmm6
movupd 0x10(%r11,%rdx,1),%xmm7
movapd %xmm6,%xmm1
unpcklpd %xmm7,%xmm1
unpckhpd %xmm7,%xmm6
movapd %xmm9,%xmm10
addpd  %xmm1,%xmm10
subpd  %xmm1,%xmm9
movapd %xmm2,%xmm1
addpd  %xmm6,%xmm1
subpd  %xmm6,%xmm2
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 %xmm8,%xmm0
subpd  %xmm2,%xmm0
movapd %xmm3,%xmm1
addpd  %xmm9,%xmm1
movapd %xmm0,%xmm4
unpcklpd %xmm1,%xmm4
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rsi,%rdx,1)
movupd %xmm4,(%rsi,%rdx,1)
addpd  %xmm8,%xmm2
subpd  %xmm9,%xmm3
movapd %xmm2,%xmm0
unpcklpd %xmm3,%xmm0
movhlps %xmm2,%xmm3
movups %xmm3,0x10(%rcx,%rdx,1)
movupd %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1170 <kern_r4_fma_o_b+0x70>
cmp    %rbp,%r14
je     137e <kern_r4_fma_o_b+0x27e>
mov    0x110(%rsp),%r15
sub    %r14,%r15
shl    $0x4,%r14
mov    %rcx,%r12
mov    -0x68(%rsp),%r13
mov    -0x60(%rsp),%rbx
mov    -0x70(%rsp),%rbp
mov    %r11,%rsi
mov    %r9,%rax
mov    %r10,%rdx
mov    %r8,%rdi
nopl   0x0(%rax,%rax,1)
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
subpd  %xmm1,%xmm2
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd  %xmm2,%xmm0
movupd %xmm0,0x0(%r13,%r14,1)
shufpd $0x2,%xmm2,%xmm1
movupd %xmm1,(%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_b+0x1e0>
mov    %rcx,-0x20(%rsp)
cmpq   $0x2,0x118(%rsp)
jl     19dd <kern_r4_fma_o_b+0x8dd>
mov    0x110(%rsp),%r12
lea    0x0(,%r12,8),%r14
lea    (%r12,%r12,1),%rdx
lea    -0x1(%r12),%rax
mov    %rdx,-0x8(%rsp)
or     $0x1,%rdx
mov    %rdx,-0x10(%rsp)
mov    $0x10,%edx
mul    %rdx
mov    %rax,%rdx
seto   -0x71(%rsp)
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x28(%rsp)
lea    (%r8,%r14,8),%rdi
mov    %r12,%rax
shl    $0x6,%rax
mov    %rax,0x8(%rsp)
lea    (%r11,%r14,8),%rbp
lea    (%r10,%r14,8),%rbx
shl    $0x4,%r12
mov    -0x20(%rsp),%rax
lea    (%rax,%r12,1),%rcx
mov    -0x68(%rsp),%rax
lea    (%rax,%r12,1),%rsi
lea    (%r9,%r14,8),%r15
mov    -0x60(%rsp),%rax
lea    (%rax,%r12,1),%r8
add    -0x70(%rsp),%r12
movapd 0xbe2(%rip),%xmm15
mov    %rdx,-0x18(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,(%rsp)
mov    $0x1,%eax
mov    %rax,-0x58(%rsp)
xor    %r11d,%r11d
jmp    149d <kern_r4_fma_o_b+0x39d>
nopw   0x0(%rax,%rax,1)
mov    -0x58(%rsp),%r9
add    $0x1,%r9
add    $0x1,%rcx
mov    %rcx,%r11
mov    -0x30(%rsp),%rdi
mov    0x8(%rsp),%rax
add    %rax,%rdi
mov    -0x38(%rsp),%rbp
add    %rax,%rbp
mov    -0x40(%rsp),%rbx
add    %rax,%rbx
mov    (%rsp),%rdx
mov    -0x48(%rsp),%rcx
add    %rdx,%rcx
mov    -0x50(%rsp),%rsi
add    %rdx,%rsi
add    %rdx,%r8
add    %rdx,%r12
add    %rax,%r15
mov    %r9,-0x58(%rsp)
cmp    0x118(%rsp),%r9
je     19dd <kern_r4_fma_o_b+0x8dd>
mov    %rsi,-0x50(%rsp)
mov    %rcx,-0x48(%rsp)
mov    %rbx,-0x40(%rsp)
mov    %rbp,-0x38(%rsp)
mov    %rdi,-0x30(%rsp)
cmpq   $0x0,0x110(%rsp)
mov    %r11,%rcx
jle    1440 <kern_r4_fma_o_b+0x340>
mov    -0x58(%rsp),%rax
mov    0x110(%rsp),%rdi
imul   %rdi,%rax
mov    %rax,%rdx
shl    $0x4,%rdx
shl    $0x5,%rax
mov    0x100(%rsp),%rbp
movsd  0x0(%rbp,%rdx,1),%xmm8
movsd  0x8(%rbp,%rdx,1),%xmm14
movsd  0x0(%rbp,%rax,1),%xmm10
movsd  0x8(%rbp,%rax,1),%xmm9
mov    0x108(%rsp),%rax
movsd  (%rax,%rdx,1),%xmm11
movsd  0x8(%rax,%rdx,1),%xmm1
cmp    $0x1,%rdi
jne    16b0 <kern_r4_fma_o_b+0x5b0>
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    0x110(%rsp),%r9
sub    %rdi,%r9
shl    $0x4,%rdi
mov    -0x48(%rsp),%rax
mov    -0x50(%rsp),%r14
mov    %r8,%rbp
mov    %r12,%r13
mov    -0x30(%rsp),%r11
mov    -0x38(%rsp),%r10
mov    -0x40(%rsp),%rbx
mov    %r15,%rdx
nopw   0x0(%rax,%rax,1)
movupd (%rdx,%rdi,1),%xmm3
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
xorpd  %xmm15,%xmm0
unpcklpd %xmm3,%xmm0
mulpd  %xmm8,%xmm3
addpd  %xmm0,%xmm3
movupd (%rbx,%rdi,1),%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
xorpd  %xmm15,%xmm2
unpcklpd %xmm0,%xmm2
mulpd  %xmm10,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm9,%xmm0
movupd (%r10,%rdi,1),%xmm2
movapd %xmm2,%xmm4
unpckhpd %xmm2,%xmm4
xorpd  %xmm15,%xmm4
unpcklpd %xmm2,%xmm4
mulpd  %xmm11,%xmm2
addpd  %xmm4,%xmm2
movupd (%r11,%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,0x0(%r13,%rdi,1)
subpd  %xmm0,%xmm6
movupd %xmm6,0x0(%rbp,%rdi,1)
movapd %xmm3,%xmm0
xorpd  %xmm15,%xmm0
unpcklpd %xmm5,%xmm0
mulpd  %xmm14,%xmm0
addpd  %xmm4,%xmm0
movupd %xmm0,(%r14,%rdi,1)
xorpd  %xmm15,%xmm5
unpcklpd %xmm5,%xmm3
mulpd  %xmm14,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rax,%rdi,1)
add    $0x10,%rdx
add    $0x10,%rbx
add    $0x10,%r10
add    $0x10,%r11
add    $0x10,%r13
add    $0x10,%rbp
add    $0x10,%r14
add    $0x10,%rax
add    $0xffffffffffffffff,%r9
jne    1580 <kern_r4_fma_o_b+0x480>
jmp    1440 <kern_r4_fma_o_b+0x340>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x8(%rsp),%rax
imul   %rcx,%rax
add    -0x10(%rsp),%rax
mov    -0x70(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    -0x60(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
mov    -0x68(%rsp),%rbp
lea    0x0(%rbp,%rax,8),%rbp
mov    -0x20(%rsp),%rbx
lea    (%rbx,%rax,8),%r9
mov    -0x18(%rsp),%rax
lea    (%rdx,%rax,1),%rbx
cmp    %rdx,%rbx
setb   %dl
mov    -0x71(%rsp),%r10b
or     %r10b,%dl
lea    (%rdi,%rax,1),%rbx
cmp    %rdi,%rbx
setb   %bl
lea    (%rax,%rbp,1),%rdi
cmp    %rbp,%rdi
setb   %dil
lea    (%r9,%rax,1),%rbp
cmp    %r9,%rbp
setb   %al
test   %dl,%dl
jne    1526 <kern_r4_fma_o_b+0x426>
or     %r10b,%bl
jne    1526 <kern_r4_fma_o_b+0x426>
or     %r10b,%dil
jne    1526 <kern_r4_fma_o_b+0x426>
or     %r10b,%al
mov    $0x0,%edi
jne    1528 <kern_r4_fma_o_b+0x428>
movapd %xmm8,0x50(%rsp)
unpcklpd %xmm8,%xmm8
movapd %xmm8,0xa0(%rsp)
movapd %xmm10,0x40(%rsp)
unpcklpd %xmm10,%xmm10
movapd %xmm10,0x90(%rsp)
movapd %xmm11,0x20(%rsp)
unpcklpd %xmm11,%xmm11
movapd %xmm11,0x80(%rsp)
movapd %xmm9,0x30(%rsp)
unpcklpd %xmm9,%xmm9
movapd %xmm9,0x70(%rsp)
movapd %xmm1,0x10(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x60(%rsp)
movapd %xmm14,%xmm13
unpcklpd %xmm14,%xmm13
mov    -0x28(%rsp),%rdi
xor    %eax,%eax
mov    -0x30(%rsp),%rdx
mov    -0x38(%rsp),%rbp
mov    -0x40(%rsp),%rbx
mov    -0x48(%rsp),%rsi
mov    -0x50(%rsp),%rcx
movupd (%r15,%rax,1),%xmm3
movupd 0x10(%r15,%rax,1),%xmm1
movapd %xmm3,%xmm4
unpcklpd %xmm1,%xmm4
unpckhpd %xmm1,%xmm3
movapd %xmm4,%xmm5
movapd 0xa0(%rsp),%xmm0
mulpd  %xmm0,%xmm5
subpd  %xmm3,%xmm5
mulpd  %xmm0,%xmm3
addpd  %xmm4,%xmm3
movupd (%rbx,%rax,1),%xmm9
movupd 0x10(%rbx,%rax,1),%xmm1
movapd %xmm9,%xmm4
unpcklpd %xmm1,%xmm4
unpckhpd %xmm1,%xmm9
movapd %xmm4,%xmm1
movapd 0x90(%rsp),%xmm0
mulpd  %xmm0,%xmm1
subpd  %xmm9,%xmm1
mulpd  %xmm0,%xmm9
addpd  %xmm4,%xmm9
movupd 0x0(%rbp,%rax,1),%xmm10
movupd 0x10(%rbp,%rax,1),%xmm4
movapd %xmm10,%xmm0
unpcklpd %xmm4,%xmm0
unpckhpd %xmm4,%xmm10
movapd %xmm0,%xmm6
movapd 0x80(%rsp),%xmm2
mulpd  %xmm2,%xmm6
subpd  %xmm10,%xmm6
mulpd  %xmm2,%xmm10
addpd  %xmm0,%xmm10
movupd (%rdx,%rax,1),%xmm4
movupd 0x10(%rdx,%rax,1),%xmm0
movapd %xmm4,%xmm8
unpcklpd %xmm0,%xmm8
unpckhpd %xmm0,%xmm4
movapd 0x70(%rsp),%xmm0
mulpd  %xmm0,%xmm1
movapd %xmm1,%xmm11
addpd  %xmm8,%xmm11
subpd  %xmm1,%xmm8
mulpd  %xmm0,%xmm9
movapd %xmm9,%xmm12
addpd  %xmm4,%xmm12
subpd  %xmm9,%xmm4
movapd 0x60(%rsp),%xmm1
mulpd  %xmm1,%xmm6
movapd %xmm6,%xmm0
addpd  %xmm5,%xmm0
subpd  %xmm6,%xmm5
mulpd  %xmm1,%xmm10
movapd %xmm10,%xmm7
addpd  %xmm3,%xmm7
subpd  %xmm10,%xmm3
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(%r12,%rax,1)
movupd %xmm2,(%r12,%rax,1)
subpd  %xmm0,%xmm11
subpd  %xmm7,%xmm12
movapd %xmm11,%xmm0
unpcklpd %xmm12,%xmm0
movhlps %xmm11,%xmm12
movups %xmm12,0x10(%r8,%rax,1)
movupd %xmm0,(%r8,%rax,1)
mulpd  %xmm13,%xmm3
movapd %xmm8,%xmm0
subpd  %xmm3,%xmm0
mulpd  %xmm13,%xmm5
movapd %xmm5,%xmm1
addpd  %xmm4,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rcx,%rax,1)
movupd %xmm2,(%rcx,%rax,1)
addpd  %xmm8,%xmm3
subpd  %xmm5,%xmm4
movapd %xmm3,%xmm0
unpcklpd %xmm4,%xmm0
movhlps %xmm3,%xmm4
movups %xmm4,0x10(%rsi,%rax,1)
movupd %xmm0,(%rsi,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rdi
jne    17d0 <kern_r4_fma_o_b+0x6d0>
mov    -0x28(%rsp),%rax
mov    %rax,%rdi
cmp    0x110(%rsp),%rax
mov    %r11,%rcx
movapd 0x50(%rsp),%xmm8
movapd 0x40(%rsp),%xmm10
movapd 0x30(%rsp),%xmm9
movapd 0x20(%rsp),%xmm11
movapd 0x10(%rsp),%xmm1
je     1440 <kern_r4_fma_o_b+0x340>
jmp    1528 <kern_r4_fma_o_b+0x428>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @kern_r4_fma_o_b(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 = fsub 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 = fadd 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 = fadd 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 = fsub 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 = fneg double %318
%320 = call double @llvm.fmuladd.f64(double %311, double %312, double %319)
store double %320, double* %41
%321 = load double*, double** %18
%322 = load i64, i64* %26
%323 = mul nsw i64 2, %322
%324 = getelementptr inbounds double, double* %321, i64 %323
%325 = load double, double* %324
%326 = load double*, double** %18
%327 = load i64, i64* %26
%328 = mul nsw i64 2, %327
%329 = add nsw i64 %328, 1
%330 = getelementptr inbounds double, double* %326, i64 %329
%331 = load double, double* %330
%332 = load double, double* %35
%333 = call double @llvm.fmuladd.f64(double %331, double %332, double %325)
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 = fneg double %345
%347 = call double @llvm.fmuladd.f64(double %338, double %339, double %346)
store double %347, double* %43
%348 = load double*, double** %19
%349 = load i64, i64* %26
%350 = mul nsw i64 2, %349
%351 = getelementptr inbounds double, double* %348, i64 %350
%352 = load double, double* %351
%353 = load double*, double** %19
%354 = load i64, i64* %26
%355 = mul nsw i64 2, %354
%356 = add nsw i64 %355, 1
%357 = getelementptr inbounds double, double* %353, i64 %356
%358 = load double, double* %357
%359 = load double, double* %37
%360 = call double @llvm.fmuladd.f64(double %358, double %359, double %352)
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 = fneg double %372
%374 = call double @llvm.fmuladd.f64(double %365, double %366, double %373)
store double %374, double* %45
%375 = load double*, double** %20
%376 = load i64, i64* %26
%377 = mul nsw i64 2, %376
%378 = getelementptr inbounds double, double* %375, i64 %377
%379 = load double, double* %378
%380 = load double*, double** %20
%381 = load i64, i64* %26
%382 = mul nsw i64 2, %381
%383 = add nsw i64 %382, 1
%384 = getelementptr inbounds double, double* %380, i64 %383
%385 = load double, double* %384
%386 = load double, double* %39
%387 = call double @llvm.fmuladd.f64(double %385, double %386, double %379)
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 = fneg double %479
%482 = call double @llvm.fmuladd.f64(double %481, double %480, double %478)
%483 = load double*, double** %14
%484 = load i64, i64* %26
%485 = mul nsw i64 2, %484
%486 = getelementptr inbounds double, double* %483, i64 %485
store double %482, double* %486
%487 = load double, double* %52
%488 = load double, double* %53
%489 = load double, double* %36
%490 = call double @llvm.fmuladd.f64(double %488, double %489, double %487)
%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 = call double @llvm.fmuladd.f64(double %497, double %498, double %496)
%500 = load double*, double** %16
%501 = load i64, i64* %26
%502 = mul nsw i64 2, %501
%503 = getelementptr inbounds double, double* %500, i64 %502
store double %499, double* %503
%504 = load double, double* %52
%505 = load double, double* %53
%506 = load double, double* %36
%507 = fneg double %505
%508 = call double @llvm.fmuladd.f64(double %507, double %506, double %504)
%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_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, 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 = fsub <2 x double> %36, %53
%65 = fadd <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 = fadd <2 x double> %36, %53
%70 = fsub <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 = fsub <2 x double> %90, %99
%108 = fadd <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 %373
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, %369
%140 = phi i64 [ 0, %120 ], [ %372, %369 ]
%141 = phi double* [ %7, %120 ], [ %167, %369 ]
%142 = phi double* [ %6, %120 ], [ %166, %369 ]
%143 = phi double* [ %5, %120 ], [ %165, %369 ]
%144 = phi double* [ %4, %120 ], [ %164, %369 ]
%145 = phi double* [ %3, %120 ], [ %163, %369 ]
%146 = phi double* [ %2, %120 ], [ %162, %369 ]
%147 = phi double* [ %1, %120 ], [ %161, %369 ]
%148 = phi double* [ %0, %120 ], [ %160, %369 ]
%149 = phi i64 [ 1, %120 ], [ %370, %369 ]
%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 %369
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 = fneg <2 x double> %227
%230 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %226, <2 x double> %205, <2 x double> %229)
%231 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %227, <2 x double> %205, <2 x double> %226)
%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 = fneg <2 x double> %236
%238 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %235, <2 x double> %207, <2 x double> %237)
%239 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %236, <2 x double> %207, <2 x double> %235)
%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 = fneg <2 x double> %244
%246 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %243, <2 x double> %209, <2 x double> %245)
%247 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %244, <2 x double> %209, <2 x double> %243)
%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> %238, <2 x double> %211, <2 x double> %251)
%254 = fneg <2 x double> %238
%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> %246, <2 x double> %213, <2 x double> %230)
%260 = fneg <2 x double> %246
%261 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %260, <2 x double> %213, <2 x double> %230)
%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 = fneg <2 x double> %264
%278 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %277, <2 x double> %215, <2 x double> %255)
%279 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %261, <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> %278, <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 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %264, <2 x double> %215, <2 x double> %255)
%284 = fneg <2 x double> %261
%285 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %284, <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> %283, <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 %369, 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 [ %367, %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 1
%313 = fneg double %312
%314 = insertelement <2 x double> poison, double %313, i64 0
%315 = shufflevector <2 x double> %314, <2 x double> %311, <2 x i32> <i32 0, i32 2>
%316 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %311, <2 x double> %295, <2 x double> %315)
%317 = getelementptr inbounds double, double* %166, i64 %308
%318 = bitcast double* %317 to <2 x double>*
%319 = load <2 x double>, <2 x double>* %318
%320 = extractelement <2 x double> %319, i64 1
%321 = fneg double %320
%322 = insertelement <2 x double> poison, double %321, i64 0
%323 = shufflevector <2 x double> %322, <2 x double> %319, <2 x i32> <i32 0, i32 2>
%324 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %319, <2 x double> %297, <2 x double> %323)
%325 = getelementptr inbounds double, double* %167, i64 %308
%326 = bitcast double* %325 to <2 x double>*
%327 = load <2 x double>, <2 x double>* %326
%328 = extractelement <2 x double> %327, i64 1
%329 = fneg double %328
%330 = insertelement <2 x double> poison, double %329, i64 0
%331 = shufflevector <2 x double> %330, <2 x double> %327, <2 x i32> <i32 0, i32 2>
%332 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %327, <2 x double> %299, <2 x double> %331)
%333 = getelementptr inbounds double, double* %164, i64 %308
%334 = bitcast double* %333 to <2 x double>*
%335 = load <2 x double>, <2 x double>* %334
%336 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %324, <2 x double> %301, <2 x double> %335)
%337 = fneg <2 x double> %324
%338 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %337, <2 x double> %301, <2 x double> %335)
%339 = extractelement <2 x double> %332, i64 0
%340 = fneg double %339
%341 = extractelement <2 x double> %316, i64 0
%342 = tail call double @llvm.fmuladd.f64(double %340, double %185, double %341)
%343 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %332, <2 x double> %303, <2 x double> %316)
%344 = extractelement <2 x double> %332, i64 1
%345 = fneg double %344
%346 = extractelement <2 x double> %316, i64 1
%347 = tail call double @llvm.fmuladd.f64(double %345, double %185, double %346)
%348 = getelementptr inbounds double, double* %160, i64 %308
%349 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %343, <2 x double> %305, <2 x double> %336)
%350 = bitcast double* %348 to <2 x double>*
store <2 x double> %349, <2 x double>* %350
%351 = getelementptr inbounds double, double* %162, i64 %308
%352 = fneg <2 x double> %343
%353 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %352, <2 x double> %305, <2 x double> %336)
%354 = bitcast double* %351 to <2 x double>*
store <2 x double> %353, <2 x double>* %354
%355 = fneg double %347
%356 = getelementptr inbounds double, double* %161, i64 %308
%357 = insertelement <2 x double> poison, double %355, i64 0
%358 = insertelement <2 x double> %357, double %342, i64 1
%359 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %358, <2 x double> %305, <2 x double> %338)
%360 = bitcast double* %356 to <2 x double>*
store <2 x double> %359, <2 x double>* %360
%361 = getelementptr inbounds double, double* %163, i64 %308
%362 = fneg double %342
%363 = insertelement <2 x double> poison, double %347, i64 0
%364 = insertelement <2 x double> %363, double %362, i64 1
%365 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %364, <2 x double> %305, <2 x double> %338)
%366 = bitcast double* %361 to <2 x double>*
store <2 x double> %365, <2 x double>* %366
%367 = add nuw nsw i64 %307, 1
%368 = icmp eq i64 %367, %10
br i1 %368, label %369, label %306
369: ; preds = %306, %291, %139
%370 = add nuw nsw i64 %149, 1
%371 = icmp eq i64 %370, %11
%372 = add i64 %140, 1
br i1 %371, label %373, label %139
373: ; preds = %369, %116
ret void
}