void kern_r8_fma_n_b(double *restrict o0, double *restrict o1,
                     double *restrict o2, double *restrict o3,
                     double *restrict o4, double *restrict o5,
                     double *restrict o6, double *restrict o7, double *i0,
                     double *i1, double *i2, double *i3, double *i4, double *i5,
                     double *i6, double *i7, double *w, double *w2, long bsize,
                     long blocks) {
  long i, j;
  for (i = 0; i < blocks; i++) {
    double wr1, wi1;
    double wr2, wi2;
    double wr3, wi3;
    double wr4, wi4;
    double wr5, wi5;
    double wr6, wi6;
    double wr7, wi7;
    wr4 = w[8 * i * bsize];
    wi4 = w[8 * i * bsize + 1];
    wr2 = w[4 * i * bsize];
    wi2 = w[4 * i * bsize + 1];
    wr6 = w2[4 * i * bsize];
    wi6 = w2[4 * i * bsize + 1];
    wr1 = w[2 * i * bsize];
    wi1 = w[2 * i * bsize + 1];
    wr3 = w2[2 * i * bsize];
    wi3 = w2[2 * i * bsize + 1];
    wr5 = w[2 * i * bsize + 2 * blocks * bsize];
    wi5 = w[2 * i * bsize + 2 * blocks * bsize + 1];
    wr7 = w2[2 * i * bsize + 2 * blocks * bsize];
    wi7 = w2[2 * i * bsize + 2 * blocks * bsize + 1];
    for (j = 0; j < bsize; j++) {
      double pr2, pi2;
      double pr4, pi4;
      double pr5, pi5;
      double pr6, pi6;
      double pr7, pi7;
      double sr1, si1;
      double sr3, si3;
      double sr5, si5;
      double sr7, si7;
      double qr0, qi0;
      double qr1, qi1;
      double qr2, qi2;
      double qr3, qi3;
      double qr4, qi4;
      double qr5, qi5;
      double qr6, qi6;
      double qr7, qi7;
      double tr0, ti0;
      double tr1, ti1;
      double tr2, ti2;
      double tr3, ti3;
      double tr4, ti4;
      double tr5, ti5;
      double tr6, ti6;
      double tr7, ti7;
      pr5 = i5[2 * j] * wr4 - i5[2 * j + 1];
      pi5 = i5[2 * j + 1] * wr4 + i5[2 * j];
      pr7 = i7[2 * j] * wr4 - i7[2 * j + 1];
      pi7 = i7[2 * j + 1] * wr4 + i7[2 * j];
      pr2 = i2[2 * j] * wr2 - i2[2 * j + 1];
      pi2 = i2[2 * j + 1] * wr2 + i2[2 * j];
      pr4 = i4[2 * j] * wr4 - i4[2 * j + 1];
      pi4 = i4[2 * j + 1] * wr4 + i4[2 * j];
      pr6 = i6[2 * j] * wr6 - i6[2 * j + 1];
      pi6 = i6[2 * j + 1] * wr6 + i6[2 * j];
      sr1 = i1[2 * j] + pr5 * wi4;
      sr5 = i1[2 * j] - pr5 * wi4;
      si1 = i1[2 * j + 1] + pi5 * wi4;
      si5 = i1[2 * j + 1] - pi5 * wi4;
      sr3 = i3[2 * j] + pr7 * wi4;
      sr7 = i3[2 * j] - pr7 * wi4;
      si3 = i3[2 * j + 1] + pi7 * wi4;
      si7 = i3[2 * j + 1] - pi7 * wi4;
      qr0 = i0[2 * j] + pr4 * wi4;
      qr4 = i0[2 * j] - pr4 * wi4;
      qi0 = i0[2 * j + 1] + pi4 * wi4;
      qi4 = i0[2 * j + 1] - pi4 * wi4;
      qr2 = pr2 + pr6 * wi6;
      qr6 = pr2 - pr6 * wi6;
      qi2 = pi2 + pi6 * wi6;
      qi6 = pi2 - pi6 * wi6;
      qr1 = sr1 * wr1 - si1;
      qi1 = si1 * wr1 + sr1;
      qr3 = sr3 * wr3 - si3;
      qi3 = si3 * wr3 + sr3;
      qr5 = sr5 * wr5 - si5;
      qi5 = si5 * wr5 + sr5;
      qr7 = sr7 * wr7 - si7;
      qi7 = si7 * wr7 + sr7;
      tr0 = qr0 + qr2 * wi2;
      ti0 = qi0 + qi2 * wi2;
      tr2 = qr0 - qr2 * wi2;
      ti2 = qi0 - qi2 * wi2;
      tr4 = qr4 - qi6 * wi2;
      ti4 = qi4 + qr6 * wi2;
      tr6 = qr4 + qi6 * wi2;
      ti6 = qi4 - qr6 * wi2;
      tr1 = qr1 + qr3 * wi3;
      ti1 = qi1 + qi3 * wi3;
      tr3 = qr1 - qr3 * wi3;
      ti3 = qi1 - qi3 * wi3;
      tr5 = qr5 + qr7 * wi7;
      ti5 = qi5 + qi7 * wi7;
      tr7 = qr5 - qr7 * wi7;
      ti7 = qi5 - qi7 * wi7;
      o0[2 * j] = tr0 + tr1 * wi1;
      o0[2 * j + 1] = ti0 + ti1 * wi1;
      o4[2 * j] = tr0 - tr1 * wi1;
      o4[2 * j + 1] = ti0 - ti1 * wi1;
      o1[2 * j] = tr4 + tr5 * wi5;
      o1[2 * j + 1] = ti4 + ti5 * wi5;
      o5[2 * j] = tr4 - tr5 * wi5;
      o5[2 * j + 1] = ti4 - ti5 * wi5;
      o2[2 * j] = tr2 - ti3 * wi1;
      o2[2 * j + 1] = ti2 + tr3 * wi1;
      o6[2 * j] = tr2 + ti3 * wi1;
      o6[2 * j + 1] = ti2 - tr3 * wi1;
      o3[2 * j] = tr6 - ti7 * wi5;
      o3[2 * j + 1] = ti6 + tr7 * wi5;
      o7[2 * j] = tr6 + ti7 * wi5;
      o7[2 * j + 1] = ti6 - tr7 * wi5;
    }
    i0 += 16 * bsize;
    i1 += 16 * bsize;
    i2 += 16 * bsize;
    i3 += 16 * bsize;
    i4 += 16 * bsize;
    i5 += 16 * bsize;
    i6 += 16 * bsize;
    i7 += 16 * bsize;
    o0 += 2 * bsize;
    o1 += 2 * bsize;
    o2 += 2 * bsize;
    o3 += 2 * bsize;
    o4 += 2 * bsize;
    o5 += 2 * bsize;
    o6 += 2 * bsize;
    o7 += 2 * bsize;
  }
}


x86 assembly (clang, -O0):
<kern_r8_fma_n_b>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
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,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    0x78(%rbp),%rax
jge    2347 <kern_r8_fma_n_b+0x1247>
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
mov    0x78(%rbp),%rdx
shl    $0x1,%rdx
imul   0x70(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
mov    0x78(%rbp),%rdx
shl    $0x1,%rdx
imul   0x70(%rbp),%rdx
add    %rdx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
mov    0x78(%rbp),%rdx
shl    $0x1,%rdx
imul   0x70(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
mov    0x78(%rbp),%rdx
shl    $0x1,%rdx
imul   0x70(%rbp),%rdx
add    %rdx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    0x70(%rbp),%rax
jge    21f6 <kern_r8_fma_n_b+0x10f6>
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x48(%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    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x58(%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,-0xf8(%rbp)
ff
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
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  0x8(%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x40(%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    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    0x50(%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,-0xe8(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xe8(%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,-0x1a8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xf0(%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,-0x1b0(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0x110(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x140(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x148(%rbp),%xmm1
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x170(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x148(%rbp),%xmm1
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x170(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x188(%rbp),%xmm1
ff
movsd  -0x1b0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x190(%rbp),%xmm1
ff
movsd  -0x1a8(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x188(%rbp),%xmm1
ff
movsd  -0x1b0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0x190(%rbp),%xmm1
ff
movsd  -0x1a8(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x158(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x160(%rbp),%xmm1
ff
movsd  -0x180(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x158(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x160(%rbp),%xmm1
ff
movsd  -0x180(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x198(%rbp),%xmm1
ff
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm1
ff
movsd  -0x1c0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x198(%rbp),%xmm1
ff
movsd  -0x1b8(%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,-0x238(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm1
ff
movsd  -0x1c0(%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,-0x240(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm1
ff
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1d0(%rbp),%xmm1
ff
movsd  -0x1e0(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x1c8(%rbp),%xmm1
ff
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1d0(%rbp),%xmm1
ff
movsd  -0x1e0(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x208(%rbp),%xmm1
ff
movsd  -0x218(%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  -0x210(%rbp),%xmm1
ff
movsd  -0x220(%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  -0x208(%rbp),%xmm1
ff
movsd  -0x218(%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    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x210(%rbp),%xmm1
ff
movsd  -0x220(%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    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x1e8(%rbp),%xmm1
ff
movsd  -0x200(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1f0(%rbp),%xmm1
ff
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x1e8(%rbp),%xmm1
ff
movsd  -0x200(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1f0(%rbp),%xmm1
ff
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x228(%rbp),%xmm1
ff
movsd  -0x240(%rbp),%xmm0
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  -0x230(%rbp),%xmm1
ff
movsd  -0x238(%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)
movsd  -0x228(%rbp),%xmm1
ff
movsd  -0x240(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x230(%rbp),%xmm1
ff
movsd  -0x238(%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)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    134c <kern_r8_fma_n_b+0x24c>
mov    0x70(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x20(%rbp),%rax
mov    %rax,0x20(%rbp)
mov    0x70(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x28(%rbp),%rax
mov    %rax,0x28(%rbp)
mov    0x70(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x30(%rbp),%rax
mov    %rax,0x30(%rbp)
mov    0x70(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x38(%rbp),%rax
mov    %rax,0x38(%rbp)
mov    0x70(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x40(%rbp),%rax
mov    %rax,0x40(%rbp)
mov    0x70(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x48(%rbp),%rax
mov    %rax,0x48(%rbp)
mov    0x70(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x50(%rbp),%rax
mov    %rax,0x50(%rbp)
mov    0x70(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x58(%rbp),%rax
mov    %rax,0x58(%rbp)
mov    0x70(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    0x70(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    0x70(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    0x70(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    0x70(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    0x70(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    0x70(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    0x10(%rbp),%rax
mov    %rax,0x10(%rbp)
mov    0x70(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1163 <kern_r8_fma_n_b+0x63>
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r8_fma_n_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x288,%rsp
mov    %r9,0x80(%rsp)
mov    %r8,0x78(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rdx,0x68(%rsp)
mov    %rsi,0x60(%rsp)
mov    %rdi,0x58(%rsp)
cmpq   $0x0,0x328(%rsp)
jle    21fa <kern_r8_fma_n_b+0x10fa>
mov    0x320(%rsp),%r8
mov    0x308(%rsp),%r14
mov    0x300(%rsp),%r10
mov    0x2f8(%rsp),%r12
mov    0x2f0(%rsp),%r11
mov    0x2e8(%rsp),%r9
lea    (%r8,%r8,1),%rax
mov    %rax,0x1d0(%rsp)
imul   0x328(%rsp),%rax
mov    %rax,0x1d8(%rsp)
mov    %r8,%rax
shl    $0x4,%rax
mov    %rax,0x1e8(%rsp)
lea    -0x1(%r8),%rax
mov    $0x10,%edx
mul    %rdx
mov    %rax,0x1c8(%rsp)
seto   -0x71(%rsp)
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x50(%rsp)
shl    $0x7,%r8
mov    %r8,0x1e0(%rsp)
movapd 0x1e2a(%rip),%xmm0
mov    0x2e0(%rsp),%rsi
mov    0x2d8(%rsp),%r15
mov    0x2d0(%rsp),%r8
mov    0x2c0(%rsp),%rdx
xor    %r13d,%r13d
mov    0x58(%rsp),%rcx
mov    0x78(%rsp),%rbp
mov    0x60(%rsp),%rbx
mov    0x80(%rsp),%rdi
mov    0x68(%rsp),%rax
mov    %rax,-0x48(%rsp)
mov    %rdx,-0x50(%rsp)
mov    0x70(%rsp),%rax
mov    %rax,-0x58(%rsp)
mov    0x2c8(%rsp),%rax
mov    %rax,-0x60(%rsp)
jmp    12dd <kern_r8_fma_n_b+0x1dd>
nopl   0x0(%rax,%rax,1)
mov    0x88(%rsp),%r13
add    $0x1,%r13
mov    0x1e0(%rsp),%rdx
mov    -0x20(%rsp),%r8
add    %rdx,%r8
mov    -0x8(%rsp),%r9
add    %rdx,%r9
mov    -0x18(%rsp),%r15
add    %rdx,%r15
mov    0x10(%rsp),%r10
add    %rdx,%r10
mov    (%rsp),%r11
add    %rdx,%r11
mov    -0x10(%rsp),%rsi
add    %rdx,%rsi
mov    0x18(%rsp),%r14
add    %rdx,%r14
mov    0x1e8(%rsp),%rax
add    %rax,-0x60(%rsp)
add    %rax,-0x58(%rsp)
add    %rax,-0x50(%rsp)
add    %rax,-0x48(%rsp)
mov    -0x40(%rsp),%rdi
add    %rax,%rdi
mov    -0x38(%rsp),%rbx
add    %rax,%rbx
mov    -0x30(%rsp),%rbp
add    %rax,%rbp
mov    -0x28(%rsp),%rcx
add    %rax,%rcx
mov    0x8(%rsp),%r12
add    %rdx,%r12
cmp    0x328(%rsp),%r13
je     21fa <kern_r8_fma_n_b+0x10fa>
mov    %rdi,-0x40(%rsp)
mov    %rbx,-0x38(%rsp)
mov    %rbp,-0x30(%rsp)
mov    %rcx,-0x28(%rsp)
mov    %r13,0x88(%rsp)
mov    %r8,-0x20(%rsp)
mov    %r15,-0x18(%rsp)
mov    %rsi,-0x10(%rsp)
mov    %r9,-0x8(%rsp)
mov    %r11,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %r14,0x18(%rsp)
cmpq   $0x0,0x320(%rsp)
jle    1240 <kern_r8_fma_n_b+0x140>
mov    0x88(%rsp),%rbp
mov    %rbp,%rax
mov    0x320(%rsp),%r8
imul   %r8,%rax
mov    %rax,%rcx
shl    $0x6,%rcx
mov    %rax,%rdx
shl    $0x5,%rdx
mov    0x1d8(%rsp),%rsi
lea    (%rsi,%rax,2),%rsi
shl    $0x4,%rax
lea    0x0(,%rsi,8),%rdi
or     $0x8,%rdi
mov    0x310(%rsp),%rbx
movsd  (%rbx,%rcx,1),%xmm5
movsd  0x8(%rbx,%rcx,1),%xmm13
movsd  (%rbx,%rdx,1),%xmm11
movsd  0x8(%rbx,%rdx,1),%xmm12
mov    0x318(%rsp),%rcx
movsd  (%rcx,%rdx,1),%xmm6
movsd  0x8(%rcx,%rdx,1),%xmm15
movsd  (%rbx,%rax,1),%xmm2
movsd  0x8(%rbx,%rax,1),%xmm9
movsd  (%rcx,%rax,1),%xmm10
movsd  0x8(%rcx,%rax,1),%xmm7
movsd  (%rbx,%rsi,8),%xmm8
movsd  (%rbx,%rdi,1),%xmm4
movsd  (%rcx,%rsi,8),%xmm3
movsd  (%rcx,%rdi,1),%xmm1
cmp    $0x1,%r8
movapd %xmm15,0x210(%rsp)
movapd %xmm7,0x200(%rsp)
movapd %xmm1,0x1f0(%rsp)
movapd %xmm12,0xd0(%rsp)
movapd %xmm2,0xc0(%rsp)
movaps %xmm10,0xb0(%rsp)
movapd %xmm8,0xa0(%rsp)
movapd %xmm3,0x90(%rsp)
jne    1a00 <kern_r8_fma_n_b+0x900>
xor    %r10d,%r10d
unpcklpd %xmm5,%xmm5
unpcklpd %xmm11,%xmm11
unpcklpd %xmm6,%xmm6
unpcklpd %xmm13,%xmm13
movapd %xmm15,%xmm2
unpcklpd %xmm15,%xmm2
movapd %xmm2,0x180(%rsp)
movaps 0xc0(%rsp),%xmm2
movlhps %xmm2,%xmm2
movaps %xmm2,0xc0(%rsp)
movaps 0xb0(%rsp),%xmm2
movlhps %xmm2,%xmm2
movaps %xmm2,0xb0(%rsp)
movaps 0xa0(%rsp),%xmm2
movlhps %xmm2,%xmm2
movaps %xmm2,0xa0(%rsp)
movaps 0x90(%rsp),%xmm2
movlhps %xmm2,%xmm2
movaps %xmm2,0x90(%rsp)
movaps 0xd0(%rsp),%xmm2
movlhps %xmm2,%xmm2
movaps %xmm2,0xd0(%rsp)
unpcklpd %xmm7,%xmm7
movapd %xmm7,0x170(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x160(%rsp)
unpcklpd %xmm9,%xmm9
unpcklpd %xmm4,%xmm4
mov    0x320(%rsp),%rax
sub    %r10,%rax
mov    %rax,0x150(%rsp)
shl    $0x4,%r10
mov    -0x60(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    -0x58(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    -0x50(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    -0x48(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    -0x40(%rsp),%rax
mov    %rax,0x140(%rsp)
mov    -0x38(%rsp),%rax
mov    %rax,0x130(%rsp)
mov    -0x30(%rsp),%rax
mov    %rax,0x120(%rsp)
mov    -0x28(%rsp),%rax
mov    %rax,0x110(%rsp)
mov    -0x20(%rsp),%rax
mov    %rax,0x100(%rsp)
mov    -0x8(%rsp),%rax
mov    %rax,0xf0(%rsp)
mov    -0x18(%rsp),%rax
mov    %rax,0xe0(%rsp)
mov    0x10(%rsp),%rbp
mov    (%rsp),%r13
mov    -0x10(%rsp),%r9
mov    0x18(%rsp),%rcx
mov    0x8(%rsp),%rdi
movapd %xmm6,0x1a0(%rsp)
movapd %xmm5,0x1b0(%rsp)
movapd %xmm4,0x190(%rsp)
xchg   %ax,%ax
movupd (%rdi,%r10,1),%xmm10
movapd %xmm10,%xmm2
unpckhpd %xmm10,%xmm2
xorpd  %xmm0,%xmm2
unpcklpd %xmm10,%xmm2
movupd (%rcx,%r10,1),%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
xorpd  0x1a31(%rip),%xmm0
mulpd  %xmm5,%xmm10
unpcklpd %xmm1,%xmm0
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm1
movupd (%r9,%r10,1),%xmm14
movapd %xmm14,%xmm3
unpckhpd %xmm14,%xmm3
xorpd  0x1a08(%rip),%xmm3
unpcklpd %xmm14,%xmm3
mulpd  %xmm11,%xmm14
movupd 0x0(%r13,%r10,1),%xmm0
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
xorpd  0x19e7(%rip),%xmm4
addpd  %xmm2,%xmm10
unpcklpd %xmm0,%xmm4
mulpd  %xmm5,%xmm0
movupd 0x0(%rbp,%r10,1),%xmm5
movapd %xmm5,%xmm2
addpd  %xmm3,%xmm14
unpckhpd %xmm5,%xmm2
xorpd  0x19be(%rip),%xmm2
unpcklpd %xmm5,%xmm2
addpd  %xmm4,%xmm0
mulpd  %xmm6,%xmm5
addpd  %xmm2,%xmm5
mov    0xe0(%rsp),%rbx
movupd (%rbx,%r10,1),%xmm2
mulpd  %xmm13,%xmm10
movapd %xmm10,%xmm6
addpd  %xmm2,%xmm6
mov    0xf0(%rsp),%rax
movupd (%rax,%r10,1),%xmm4
mulpd  %xmm13,%xmm1
movapd %xmm1,%xmm7
addpd  %xmm4,%xmm7
subpd  %xmm1,%xmm4
mov    0x100(%rsp),%rax
movupd (%rax,%r10,1),%xmm12
mulpd  %xmm13,%xmm0
subpd  %xmm10,%xmm2
movapd %xmm0,%xmm10
addpd  %xmm12,%xmm10
subpd  %xmm0,%xmm12
movapd %xmm5,%xmm0
mulsd  %xmm15,%xmm0
movapd %xmm9,%xmm8
movapd %xmm13,%xmm9
movapd %xmm14,%xmm13
movapd %xmm5,%xmm1
subsd  %xmm0,%xmm13
mulpd  0x180(%rsp),%xmm1
addpd  %xmm14,%xmm1
unpckhpd %xmm5,%xmm5
unpckhpd %xmm14,%xmm14
mulsd  %xmm15,%xmm5
subsd  %xmm5,%xmm14
movapd %xmm6,%xmm3
unpckhpd %xmm6,%xmm3
movapd %xmm7,%xmm0
xorpd  0x18f6(%rip),%xmm3
unpckhpd %xmm7,%xmm0
xorpd  0x18ea(%rip),%xmm0
unpcklpd %xmm7,%xmm0
mulpd  0xb0(%rsp),%xmm7
addpd  %xmm0,%xmm7
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
xorpd  0x18c9(%rip),%xmm0
unpcklpd %xmm6,%xmm3
unpcklpd %xmm4,%xmm0
mulpd  0x90(%rsp),%xmm4
movapd 0xd0(%rsp),%xmm5
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm4
movapd %xmm1,%xmm15
addpd  %xmm10,%xmm15
subpd  %xmm1,%xmm10
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
mulpd  0xc0(%rsp),%xmm6
xorpd  0x187f(%rip),%xmm0
unpcklpd %xmm2,%xmm0
mulpd  0xa0(%rsp),%xmm2
addpd  %xmm3,%xmm6
movapd %xmm14,%xmm1
xorpd  0x1861(%rip),%xmm1
unpcklpd %xmm13,%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm2
xorpd  0x184b(%rip),%xmm13
unpcklpd %xmm13,%xmm14
movapd %xmm9,%xmm13
movapd %xmm8,%xmm9
movapd 0x200(%rsp),%xmm8
mulpd  %xmm5,%xmm14
addpd  %xmm12,%xmm1
addpd  %xmm12,%xmm14
movapd 0x1f0(%rsp),%xmm12
movapd %xmm7,%xmm0
mulpd  0x170(%rsp),%xmm0
movapd %xmm7,%xmm3
mulsd  %xmm8,%xmm3
movapd %xmm6,%xmm5
addpd  %xmm6,%xmm0
subsd  %xmm3,%xmm5
unpckhpd %xmm7,%xmm7
mulsd  %xmm8,%xmm7
unpckhpd %xmm6,%xmm6
subsd  %xmm7,%xmm6
movapd %xmm4,%xmm7
mulsd  %xmm12,%xmm7
movapd %xmm2,%xmm3
subsd  %xmm7,%xmm3
movapd %xmm4,%xmm7
mulpd  0x160(%rsp),%xmm7
addpd  %xmm2,%xmm7
unpckhpd %xmm4,%xmm4
mulsd  %xmm12,%xmm4
unpckhpd %xmm2,%xmm2
subsd  %xmm4,%xmm2
mulpd  %xmm9,%xmm0
movapd %xmm0,%xmm4
addpd  %xmm15,%xmm4
mov    0x110(%rsp),%rsi
movupd %xmm4,(%rsi,%r10,1)
movapd 0x190(%rsp),%xmm4
subpd  %xmm0,%xmm15
mov    0x120(%rsp),%r8
movupd %xmm15,(%r8,%r10,1)
movapd 0x210(%rsp),%xmm15
mulpd  %xmm4,%xmm7
movapd %xmm7,%xmm0
addpd  %xmm1,%xmm0
mov    0x130(%rsp),%r15
movupd %xmm0,(%r15,%r10,1)
subpd  %xmm7,%xmm1
mov    0x140(%rsp),%rdx
movupd %xmm1,(%rdx,%r10,1)
movapd %xmm6,%xmm0
xorpd  0x1739(%rip),%xmm0
unpcklpd %xmm5,%xmm0
xorpd  0x172d(%rip),%xmm5
unpcklpd %xmm5,%xmm6
movapd 0x1b0(%rsp),%xmm5
mulpd  %xmm9,%xmm0
addpd  %xmm10,%xmm0
mulpd  %xmm9,%xmm6
addpd  %xmm10,%xmm6
mov    0x40(%rsp),%r12
movupd %xmm0,(%r12,%r10,1)
movapd %xmm2,%xmm0
xorpd  0x16f5(%rip),%xmm0
unpcklpd %xmm3,%xmm0
mulpd  %xmm4,%xmm0
addpd  %xmm14,%xmm0
mov    0x30(%rsp),%r11
movupd %xmm0,(%r11,%r10,1)
movapd 0x16d5(%rip),%xmm0
xorpd  %xmm0,%xmm3
unpcklpd %xmm3,%xmm2
mov    0x20(%rsp),%r14
movupd %xmm6,(%r14,%r10,1)
movapd 0x1a0(%rsp),%xmm6
mulpd  %xmm4,%xmm2
addpd  %xmm14,%xmm2
mov    -0x70(%rsp),%rax
movupd %xmm2,(%rax,%r10,1)
add    $0x10,%rdi
add    $0x10,%rcx
add    $0x10,%r9
add    $0x10,%r13
add    $0x10,%rbp
add    $0x10,%rbx
mov    %rbx,0xe0(%rsp)
addq   $0x10,0xf0(%rsp)
addq   $0x10,0x100(%rsp)
add    $0x10,%rsi
mov    %rsi,0x110(%rsp)
add    $0x10,%r8
mov    %r8,0x120(%rsp)
add    $0x10,%r15
mov    %r15,0x130(%rsp)
add    $0x10,%rdx
mov    %rdx,0x140(%rsp)
add    $0x10,%r12
mov    %r12,0x40(%rsp)
add    $0x10,%r14
mov    %r14,0x20(%rsp)
add    $0x10,%r11
mov    %r11,0x30(%rsp)
add    $0x10,%rax
mov    %rax,-0x70(%rsp)
addq   $0xffffffffffffffff,0x150(%rsp)
jne    15a0 <kern_r8_fma_n_b+0x4a0>
jmp    1240 <kern_r8_fma_n_b+0x140>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x1d0(%rsp),%rax
imul   %rbp,%rax
shl    $0x3,%rax
or     $0x8,%rax
mov    0x58(%rsp),%rcx
add    %rax,%rcx
mov    0x78(%rsp),%rdx
lea    (%rdx,%rax,1),%rdx
mov    0x60(%rsp),%rsi
add    %rax,%rsi
mov    0x80(%rsp),%rdi
add    %rax,%rdi
mov    0x68(%rsp),%rbp
lea    0x0(%rbp,%rax,1),%r8
mov    0x2c0(%rsp),%rbp
lea    (%rax,%rbp,1),%r11
mov    0x70(%rsp),%rbx
lea    (%rbx,%rax,1),%r10
add    0x2c8(%rsp),%rax
mov    0x1c8(%rsp),%rbp
lea    (%rcx,%rbp,1),%rbx
cmp    %rcx,%rbx
setb   %r14b
mov    -0x71(%rsp),%bl
or     %bl,%r14b
lea    (%rdx,%rbp,1),%rcx
cmp    %rdx,%rcx
setb   %cl
lea    (%rsi,%rbp,1),%rdx
cmp    %rsi,%rdx
setb   %dl
lea    (%rdi,%rbp,1),%rsi
cmp    %rdi,%rsi
setb   %r9b
lea    (%r8,%rbp,1),%rsi
cmp    %r8,%rsi
setb   %r8b
lea    (%r11,%rbp,1),%rsi
cmp    %r11,%rsi
setb   %dil
lea    (%r10,%rbp,1),%rsi
cmp    %r10,%rsi
setb   %sil
add    %rax,%rbp
cmp    %rax,%rbp
setb   %al
test   %r14b,%r14b
jne    1427 <kern_r8_fma_n_b+0x327>
or     %bl,%cl
jne    1427 <kern_r8_fma_n_b+0x327>
or     %bl,%dl
jne    1427 <kern_r8_fma_n_b+0x327>
or     %bl,%r9b
jne    1427 <kern_r8_fma_n_b+0x327>
or     %bl,%r8b
jne    1427 <kern_r8_fma_n_b+0x327>
or     %bl,%dil
jne    1427 <kern_r8_fma_n_b+0x327>
or     %bl,%sil
jne    1427 <kern_r8_fma_n_b+0x327>
or     %bl,%al
mov    $0x0,%r10d
jne    142a <kern_r8_fma_n_b+0x32a>
movapd %xmm5,0x1b0(%rsp)
unpcklpd %xmm5,%xmm5
movapd %xmm5,0x130(%rsp)
movapd %xmm11,0x230(%rsp)
unpcklpd %xmm11,%xmm11
movapd %xmm11,0x120(%rsp)
movapd %xmm6,0x1a0(%rsp)
unpcklpd %xmm6,%xmm6
movapd %xmm6,0x110(%rsp)
movapd %xmm13,0x240(%rsp)
unpcklpd %xmm13,%xmm13
movapd %xmm13,0x100(%rsp)
unpcklpd %xmm15,%xmm15
movapd %xmm15,0xf0(%rsp)
movaps 0xc0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0xe0(%rsp)
movaps 0xb0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0xa0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x170(%rsp)
movaps 0x90(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x160(%rsp)
movaps 0xd0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x150(%rsp)
unpcklpd %xmm7,%xmm7
movapd %xmm7,0x270(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0x260(%rsp)
movapd %xmm9,0x220(%rsp)
unpcklpd %xmm9,%xmm9
movapd %xmm9,0x40(%rsp)
movapd %xmm4,0x190(%rsp)
unpcklpd %xmm4,%xmm4
movapd %xmm4,0x250(%rsp)
mov    0x50(%rsp),%rbx
xor    %ecx,%ecx
mov    -0x10(%rsp),%r15
mov    -0x18(%rsp),%r12
mov    -0x20(%rsp),%r13
mov    -0x28(%rsp),%r14
mov    -0x30(%rsp),%rbp
mov    -0x38(%rsp),%rax
mov    -0x40(%rsp),%rdx
mov    -0x48(%rsp),%rsi
mov    -0x50(%rsp),%r8
mov    -0x58(%rsp),%r9
mov    -0x60(%rsp),%r10
nopl   (%rax)
mov    0x8(%rsp),%rdi
movupd (%rdi,%rcx,1),%xmm3
movupd 0x10(%rdi,%rcx,1),%xmm0
movapd %xmm3,%xmm1
unpcklpd %xmm0,%xmm1
unpckhpd %xmm0,%xmm3
movapd %xmm1,%xmm10
movapd 0x130(%rsp),%xmm7
mulpd  %xmm7,%xmm10
subpd  %xmm3,%xmm10
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
mov    0x18(%rsp),%r11
movupd (%r11,%rcx,1),%xmm4
movupd 0x10(%r11,%rcx,1),%xmm0
movapd %xmm4,%xmm5
unpcklpd %xmm0,%xmm5
unpckhpd %xmm0,%xmm4
movapd %xmm5,%xmm14
mulpd  %xmm7,%xmm14
subpd  %xmm4,%xmm14
mulpd  %xmm7,%xmm4
addpd  %xmm5,%xmm4
movupd (%r15,%rcx,1),%xmm1
movupd 0x10(%r15,%rcx,1),%xmm0
movapd %xmm1,%xmm5
unpcklpd %xmm0,%xmm5
unpckhpd %xmm0,%xmm1
movapd %xmm5,%xmm8
movapd 0x120(%rsp),%xmm0
mulpd  %xmm0,%xmm8
subpd  %xmm1,%xmm8
mulpd  %xmm0,%xmm1
addpd  %xmm5,%xmm1
movapd %xmm1,-0x70(%rsp)
mov    (%rsp),%rdi
movupd (%rdi,%rcx,1),%xmm5
movupd 0x10(%rdi,%rcx,1),%xmm0
movapd %xmm5,%xmm6
unpcklpd %xmm0,%xmm6
unpckhpd %xmm0,%xmm5
movapd %xmm6,%xmm0
mulpd  %xmm7,%xmm0
subpd  %xmm5,%xmm0
mulpd  %xmm7,%xmm5
addpd  %xmm6,%xmm5
mov    0x10(%rsp),%rdi
movupd (%rdi,%rcx,1),%xmm7
movupd 0x10(%rdi,%rcx,1),%xmm6
movapd %xmm7,%xmm1
unpcklpd %xmm6,%xmm1
unpckhpd %xmm6,%xmm7
movapd %xmm1,%xmm12
movapd 0x110(%rsp),%xmm6
mulpd  %xmm6,%xmm12
subpd  %xmm7,%xmm12
mulpd  %xmm6,%xmm7
addpd  %xmm1,%xmm7
movupd (%r12,%rcx,1),%xmm13
movupd 0x10(%r12,%rcx,1),%xmm1
movapd %xmm13,%xmm9
unpcklpd %xmm1,%xmm9
unpckhpd %xmm1,%xmm13
movapd 0x100(%rsp),%xmm2
mulpd  %xmm2,%xmm10
movapd %xmm10,%xmm1
addpd  %xmm9,%xmm1
movapd %xmm1,0x140(%rsp)
subpd  %xmm10,%xmm9
mulpd  %xmm2,%xmm3
movapd %xmm3,%xmm15
addpd  %xmm13,%xmm15
subpd  %xmm3,%xmm13
mov    -0x8(%rsp),%rdi
movupd (%rdi,%rcx,1),%xmm10
movupd 0x10(%rdi,%rcx,1),%xmm1
movapd %xmm10,%xmm11
unpcklpd %xmm1,%xmm11
unpckhpd %xmm1,%xmm10
mulpd  %xmm2,%xmm14
movapd %xmm14,%xmm1
addpd  %xmm11,%xmm1
subpd  %xmm14,%xmm11
mulpd  %xmm2,%xmm4
movapd %xmm4,%xmm3
addpd  %xmm10,%xmm3
subpd  %xmm4,%xmm10
movupd 0x0(%r13,%rcx,1),%xmm6
movupd 0x10(%r13,%rcx,1),%xmm4
movapd %xmm6,%xmm14
unpcklpd %xmm4,%xmm14
unpckhpd %xmm4,%xmm6
mulpd  %xmm2,%xmm0
movapd %xmm0,%xmm4
addpd  %xmm14,%xmm4
movapd %xmm4,0x20(%rsp)
subpd  %xmm0,%xmm14
mulpd  %xmm2,%xmm5
movapd %xmm5,%xmm0
addpd  %xmm6,%xmm0
movapd %xmm0,0x30(%rsp)
subpd  %xmm5,%xmm6
movapd 0xf0(%rsp),%xmm0
mulpd  %xmm0,%xmm12
movapd %xmm12,%xmm5
addpd  %xmm8,%xmm5
subpd  %xmm12,%xmm8
mulpd  %xmm0,%xmm7
movapd %xmm7,%xmm0
movapd -0x70(%rsp),%xmm2
addpd  %xmm2,%xmm0
subpd  %xmm7,%xmm2
movapd %xmm2,-0x70(%rsp)
movapd 0x140(%rsp),%xmm4
movapd %xmm4,%xmm7
movapd 0xe0(%rsp),%xmm2
mulpd  %xmm2,%xmm7
subpd  %xmm15,%xmm7
mulpd  %xmm2,%xmm15
addpd  %xmm4,%xmm15
movapd %xmm1,%xmm4
movapd 0x180(%rsp),%xmm2
mulpd  %xmm2,%xmm4
subpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm9,%xmm12
movapd 0x170(%rsp),%xmm1
mulpd  %xmm1,%xmm12
subpd  %xmm13,%xmm12
mulpd  %xmm1,%xmm13
addpd  %xmm9,%xmm13
movapd %xmm11,%xmm2
movapd 0x160(%rsp),%xmm1
mulpd  %xmm1,%xmm2
subpd  %xmm10,%xmm2
mulpd  %xmm1,%xmm10
addpd  %xmm11,%xmm10
movapd 0x150(%rsp),%xmm1
mulpd  %xmm1,%xmm5
movapd %xmm5,%xmm11
movapd 0x20(%rsp),%xmm9
addpd  %xmm9,%xmm11
subpd  %xmm5,%xmm9
movapd %xmm9,0x20(%rsp)
mulpd  %xmm1,%xmm0
movapd %xmm0,%xmm5
movapd 0x30(%rsp),%xmm9
addpd  %xmm9,%xmm5
subpd  %xmm0,%xmm9
movapd %xmm9,0x30(%rsp)
movapd -0x70(%rsp),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm14,%xmm9
subpd  %xmm0,%xmm9
addpd  %xmm14,%xmm0
movapd %xmm0,-0x70(%rsp)
mulpd  %xmm1,%xmm8
movapd %xmm8,%xmm14
addpd  %xmm6,%xmm14
subpd  %xmm8,%xmm6
movapd 0x270(%rsp),%xmm0
mulpd  %xmm0,%xmm4
movapd %xmm4,%xmm8
addpd  %xmm7,%xmm8
subpd  %xmm4,%xmm7
mulpd  %xmm0,%xmm3
movapd %xmm3,%xmm4
addpd  %xmm15,%xmm4
subpd  %xmm3,%xmm15
movapd 0x260(%rsp),%xmm0
mulpd  %xmm0,%xmm2
movapd %xmm2,%xmm3
addpd  %xmm12,%xmm3
subpd  %xmm2,%xmm12
mulpd  %xmm0,%xmm10
movapd %xmm10,%xmm2
addpd  %xmm13,%xmm2
subpd  %xmm10,%xmm13
movapd 0x40(%rsp),%xmm0
mulpd  %xmm0,%xmm8
movapd %xmm8,%xmm10
addpd  %xmm11,%xmm10
mulpd  %xmm0,%xmm4
movapd %xmm4,%xmm0
addpd  %xmm5,%xmm0
movapd %xmm10,%xmm1
unpcklpd %xmm0,%xmm1
movhlps %xmm10,%xmm0
movups %xmm0,0x10(%r14,%rcx,1)
movupd %xmm1,(%r14,%rcx,1)
subpd  %xmm8,%xmm11
subpd  %xmm4,%xmm5
movapd %xmm11,%xmm0
unpcklpd %xmm5,%xmm0
movhlps %xmm11,%xmm5
movups %xmm5,0x10(%rbp,%rcx,1)
movupd %xmm0,0x0(%rbp,%rcx,1)
movapd 0x250(%rsp),%xmm5
mulpd  %xmm5,%xmm3
movapd %xmm3,%xmm0
addpd  %xmm9,%xmm0
mulpd  %xmm5,%xmm2
movapd %xmm2,%xmm1
addpd  %xmm14,%xmm1
movapd %xmm0,%xmm4
unpcklpd %xmm1,%xmm4
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rax,%rcx,1)
movupd %xmm4,(%rax,%rcx,1)
subpd  %xmm3,%xmm9
subpd  %xmm2,%xmm14
movapd %xmm9,%xmm0
unpcklpd %xmm14,%xmm0
movhlps %xmm9,%xmm14
movups %xmm14,0x10(%rdx,%rcx,1)
movupd %xmm0,(%rdx,%rcx,1)
movapd 0x40(%rsp),%xmm1
mulpd  %xmm1,%xmm15
movapd 0x20(%rsp),%xmm3
movapd %xmm3,%xmm0
subpd  %xmm15,%xmm0
mulpd  %xmm1,%xmm7
movapd %xmm7,%xmm1
movapd 0x30(%rsp),%xmm4
addpd  %xmm4,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rsi,%rcx,1)
movupd %xmm2,(%rsi,%rcx,1)
addpd  %xmm3,%xmm15
movapd %xmm4,%xmm1
subpd  %xmm7,%xmm1
movapd %xmm15,%xmm0
unpcklpd %xmm1,%xmm0
movhlps %xmm15,%xmm1
movups %xmm1,0x10(%r8,%rcx,1)
movupd %xmm0,(%r8,%rcx,1)
mulpd  %xmm5,%xmm13
movapd -0x70(%rsp),%xmm3
movapd %xmm3,%xmm0
subpd  %xmm13,%xmm0
mulpd  %xmm5,%xmm12
movapd %xmm12,%xmm1
addpd  %xmm6,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%r9,%rcx,1)
movupd %xmm2,(%r9,%rcx,1)
addpd  %xmm3,%xmm13
subpd  %xmm12,%xmm6
movapd %xmm13,%xmm0
unpcklpd %xmm6,%xmm0
movhlps %xmm13,%xmm6
movups %xmm6,0x10(%r10,%rcx,1)
movupd %xmm0,(%r10,%rcx,1)
add    $0x20,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1c60 <kern_r8_fma_n_b+0xb60>
mov    0x50(%rsp),%rax
mov    %rax,%r10
cmp    0x320(%rsp),%rax
movapd 0xe66(%rip),%xmm0
movapd 0x1b0(%rsp),%xmm5
movapd 0x240(%rsp),%xmm13
movapd 0x230(%rsp),%xmm11
movapd 0x1a0(%rsp),%xmm6
movapd 0x210(%rsp),%xmm15
movapd 0x220(%rsp),%xmm9
movapd 0x200(%rsp),%xmm7
movapd 0x190(%rsp),%xmm4
movapd 0x1f0(%rsp),%xmm1
je     1240 <kern_r8_fma_n_b+0x140>
jmp    142a <kern_r8_fma_n_b+0x32a>
add    $0x288,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @kern_r8_fma_n_b(double* noalias %0, double* noalias %1, double* noalias %2, double* noalias %3, double* noalias %4, double* noalias %5, double* noalias %6, double* noalias %7, double* %8, double* %9, double* %10, double* %11, double* %12, double* %13, double* %14, double* %15, double* %16, double* %17, i64 %18, i64 %19) {
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
%35 = alloca double*
%36 = alloca double*
%37 = alloca double*
%38 = alloca double*
%39 = alloca i64
%40 = alloca i64
%41 = alloca i64
%42 = alloca i64
%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
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
%68 = alloca double
%69 = alloca double
%70 = alloca double
%71 = alloca double
%72 = alloca double
%73 = alloca double
%74 = alloca double
%75 = alloca double
%76 = alloca double
%77 = alloca double
%78 = alloca double
%79 = alloca double
%80 = alloca double
%81 = alloca double
%82 = alloca double
%83 = alloca double
%84 = alloca double
%85 = alloca double
%86 = alloca double
%87 = alloca double
%88 = alloca double
%89 = alloca double
%90 = alloca double
%91 = alloca double
%92 = alloca double
%93 = alloca double
%94 = alloca double
%95 = alloca double
%96 = alloca double
%97 = alloca double
%98 = alloca double
%99 = alloca double
%100 = alloca double
%101 = alloca double
%102 = alloca double
%103 = alloca double
%104 = alloca double
%105 = alloca double
%106 = alloca double
store double* %0, double** %21
store double* %1, double** %22
store double* %2, double** %23
store double* %3, double** %24
store double* %4, double** %25
store double* %5, double** %26
store double* %6, double** %27
store double* %7, double** %28
store double* %8, double** %29
store double* %9, double** %30
store double* %10, double** %31
store double* %11, double** %32
store double* %12, double** %33
store double* %13, double** %34
store double* %14, double** %35
store double* %15, double** %36
store double* %16, double** %37
store double* %17, double** %38
store i64 %18, i64* %39
store i64 %19, i64* %40
store i64 0, i64* %41
br label %107
107: ; preds = %823, %20
%108 = load i64, i64* %41
%109 = load i64, i64* %40
%110 = icmp slt i64 %108, %109
br i1 %110, label %111, label %826
111: ; preds = %107
%112 = load double*, double** %37
%113 = load i64, i64* %41
%114 = mul nsw i64 8, %113
%115 = load i64, i64* %39
%116 = mul nsw i64 %114, %115
%117 = getelementptr inbounds double, double* %112, i64 %116
%118 = load double, double* %117
store double %118, double* %49
%119 = load double*, double** %37
%120 = load i64, i64* %41
%121 = mul nsw i64 8, %120
%122 = load i64, i64* %39
%123 = mul nsw i64 %121, %122
%124 = add nsw i64 %123, 1
%125 = getelementptr inbounds double, double* %119, i64 %124
%126 = load double, double* %125
store double %126, double* %50
%127 = load double*, double** %37
%128 = load i64, i64* %41
%129 = mul nsw i64 4, %128
%130 = load i64, i64* %39
%131 = mul nsw i64 %129, %130
%132 = getelementptr inbounds double, double* %127, i64 %131
%133 = load double, double* %132
store double %133, double* %45
%134 = load double*, double** %37
%135 = load i64, i64* %41
%136 = mul nsw i64 4, %135
%137 = load i64, i64* %39
%138 = mul nsw i64 %136, %137
%139 = add nsw i64 %138, 1
%140 = getelementptr inbounds double, double* %134, i64 %139
%141 = load double, double* %140
store double %141, double* %46
%142 = load double*, double** %38
%143 = load i64, i64* %41
%144 = mul nsw i64 4, %143
%145 = load i64, i64* %39
%146 = mul nsw i64 %144, %145
%147 = getelementptr inbounds double, double* %142, i64 %146
%148 = load double, double* %147
store double %148, double* %53
%149 = load double*, double** %38
%150 = load i64, i64* %41
%151 = mul nsw i64 4, %150
%152 = load i64, i64* %39
%153 = mul nsw i64 %151, %152
%154 = add nsw i64 %153, 1
%155 = getelementptr inbounds double, double* %149, i64 %154
%156 = load double, double* %155
store double %156, double* %54
%157 = load double*, double** %37
%158 = load i64, i64* %41
%159 = mul nsw i64 2, %158
%160 = load i64, i64* %39
%161 = mul nsw i64 %159, %160
%162 = getelementptr inbounds double, double* %157, i64 %161
%163 = load double, double* %162
store double %163, double* %43
%164 = load double*, double** %37
%165 = load i64, i64* %41
%166 = mul nsw i64 2, %165
%167 = load i64, i64* %39
%168 = mul nsw i64 %166, %167
%169 = add nsw i64 %168, 1
%170 = getelementptr inbounds double, double* %164, i64 %169
%171 = load double, double* %170
store double %171, double* %44
%172 = load double*, double** %38
%173 = load i64, i64* %41
%174 = mul nsw i64 2, %173
%175 = load i64, i64* %39
%176 = mul nsw i64 %174, %175
%177 = getelementptr inbounds double, double* %172, i64 %176
%178 = load double, double* %177
store double %178, double* %47
%179 = load double*, double** %38
%180 = load i64, i64* %41
%181 = mul nsw i64 2, %180
%182 = load i64, i64* %39
%183 = mul nsw i64 %181, %182
%184 = add nsw i64 %183, 1
%185 = getelementptr inbounds double, double* %179, i64 %184
%186 = load double, double* %185
store double %186, double* %48
%187 = load double*, double** %37
%188 = load i64, i64* %41
%189 = mul nsw i64 2, %188
%190 = load i64, i64* %39
%191 = mul nsw i64 %189, %190
%192 = load i64, i64* %40
%193 = mul nsw i64 2, %192
%194 = load i64, i64* %39
%195 = mul nsw i64 %193, %194
%196 = add nsw i64 %191, %195
%197 = getelementptr inbounds double, double* %187, i64 %196
%198 = load double, double* %197
store double %198, double* %51
%199 = load double*, double** %37
%200 = load i64, i64* %41
%201 = mul nsw i64 2, %200
%202 = load i64, i64* %39
%203 = mul nsw i64 %201, %202
%204 = load i64, i64* %40
%205 = mul nsw i64 2, %204
%206 = load i64, i64* %39
%207 = mul nsw i64 %205, %206
%208 = add nsw i64 %203, %207
%209 = add nsw i64 %208, 1
%210 = getelementptr inbounds double, double* %199, i64 %209
%211 = load double, double* %210
store double %211, double* %52
%212 = load double*, double** %38
%213 = load i64, i64* %41
%214 = mul nsw i64 2, %213
%215 = load i64, i64* %39
%216 = mul nsw i64 %214, %215
%217 = load i64, i64* %40
%218 = mul nsw i64 2, %217
%219 = load i64, i64* %39
%220 = mul nsw i64 %218, %219
%221 = add nsw i64 %216, %220
%222 = getelementptr inbounds double, double* %212, i64 %221
%223 = load double, double* %222
store double %223, double* %55
%224 = load double*, double** %38
%225 = load i64, i64* %41
%226 = mul nsw i64 2, %225
%227 = load i64, i64* %39
%228 = mul nsw i64 %226, %227
%229 = load i64, i64* %40
%230 = mul nsw i64 2, %229
%231 = load i64, i64* %39
%232 = mul nsw i64 %230, %231
%233 = add nsw i64 %228, %232
%234 = add nsw i64 %233, 1
%235 = getelementptr inbounds double, double* %224, i64 %234
%236 = load double, double* %235
store double %236, double* %56
store i64 0, i64* %42
br label %237
237: ; preds = %755, %111
%238 = load i64, i64* %42
%239 = load i64, i64* %39
%240 = icmp slt i64 %238, %239
br i1 %240, label %241, label %758
241: ; preds = %237
%242 = load double*, double** %34
%243 = load i64, i64* %42
%244 = mul nsw i64 2, %243
%245 = getelementptr inbounds double, double* %242, i64 %244
%246 = load double, double* %245
%247 = load double, double* %49
%248 = load double*, double** %34
%249 = load i64, i64* %42
%250 = mul nsw i64 2, %249
%251 = add nsw i64 %250, 1
%252 = getelementptr inbounds double, double* %248, i64 %251
%253 = load double, double* %252
%254 = fneg double %253
%255 = call double @llvm.fmuladd.f64(double %246, double %247, double %254)
store double %255, double* %61
%256 = load double*, double** %34
%257 = load i64, i64* %42
%258 = mul nsw i64 2, %257
%259 = add nsw i64 %258, 1
%260 = getelementptr inbounds double, double* %256, i64 %259
%261 = load double, double* %260
%262 = load double, double* %49
%263 = load double*, double** %34
%264 = load i64, i64* %42
%265 = mul nsw i64 2, %264
%266 = getelementptr inbounds double, double* %263, i64 %265
%267 = load double, double* %266
%268 = call double @llvm.fmuladd.f64(double %261, double %262, double %267)
store double %268, double* %62
%269 = load double*, double** %36
%270 = load i64, i64* %42
%271 = mul nsw i64 2, %270
%272 = getelementptr inbounds double, double* %269, i64 %271
%273 = load double, double* %272
%274 = load double, double* %49
%275 = load double*, double** %36
%276 = load i64, i64* %42
%277 = mul nsw i64 2, %276
%278 = add nsw i64 %277, 1
%279 = getelementptr inbounds double, double* %275, i64 %278
%280 = load double, double* %279
%281 = fneg double %280
%282 = call double @llvm.fmuladd.f64(double %273, double %274, double %281)
store double %282, double* %65
%283 = load double*, double** %36
%284 = load i64, i64* %42
%285 = mul nsw i64 2, %284
%286 = add nsw i64 %285, 1
%287 = getelementptr inbounds double, double* %283, i64 %286
%288 = load double, double* %287
%289 = load double, double* %49
%290 = load double*, double** %36
%291 = load i64, i64* %42
%292 = mul nsw i64 2, %291
%293 = getelementptr inbounds double, double* %290, i64 %292
%294 = load double, double* %293
%295 = call double @llvm.fmuladd.f64(double %288, double %289, double %294)
store double %295, double* %66
%296 = load double*, double** %31
%297 = load i64, i64* %42
%298 = mul nsw i64 2, %297
%299 = getelementptr inbounds double, double* %296, i64 %298
%300 = load double, double* %299
%301 = load double, double* %45
%302 = load double*, double** %31
%303 = load i64, i64* %42
%304 = mul nsw i64 2, %303
%305 = add nsw i64 %304, 1
%306 = getelementptr inbounds double, double* %302, i64 %305
%307 = load double, double* %306
%308 = fneg double %307
%309 = call double @llvm.fmuladd.f64(double %300, double %301, double %308)
store double %309, double* %57
%310 = load double*, double** %31
%311 = load i64, i64* %42
%312 = mul nsw i64 2, %311
%313 = add nsw i64 %312, 1
%314 = getelementptr inbounds double, double* %310, i64 %313
%315 = load double, double* %314
%316 = load double, double* %45
%317 = load double*, double** %31
%318 = load i64, i64* %42
%319 = mul nsw i64 2, %318
%320 = getelementptr inbounds double, double* %317, i64 %319
%321 = load double, double* %320
%322 = call double @llvm.fmuladd.f64(double %315, double %316, double %321)
store double %322, double* %58
%323 = load double*, double** %33
%324 = load i64, i64* %42
%325 = mul nsw i64 2, %324
%326 = getelementptr inbounds double, double* %323, i64 %325
%327 = load double, double* %326
%328 = load double, double* %49
%329 = load double*, double** %33
%330 = load i64, i64* %42
%331 = mul nsw i64 2, %330
%332 = add nsw i64 %331, 1
%333 = getelementptr inbounds double, double* %329, i64 %332
%334 = load double, double* %333
%335 = fneg double %334
%336 = call double @llvm.fmuladd.f64(double %327, double %328, double %335)
store double %336, double* %59
%337 = load double*, double** %33
%338 = load i64, i64* %42
%339 = mul nsw i64 2, %338
%340 = add nsw i64 %339, 1
%341 = getelementptr inbounds double, double* %337, i64 %340
%342 = load double, double* %341
%343 = load double, double* %49
%344 = load double*, double** %33
%345 = load i64, i64* %42
%346 = mul nsw i64 2, %345
%347 = getelementptr inbounds double, double* %344, i64 %346
%348 = load double, double* %347
%349 = call double @llvm.fmuladd.f64(double %342, double %343, double %348)
store double %349, double* %60
%350 = load double*, double** %35
%351 = load i64, i64* %42
%352 = mul nsw i64 2, %351
%353 = getelementptr inbounds double, double* %350, i64 %352
%354 = load double, double* %353
%355 = load double, double* %53
%356 = load double*, double** %35
%357 = load i64, i64* %42
%358 = mul nsw i64 2, %357
%359 = add nsw i64 %358, 1
%360 = getelementptr inbounds double, double* %356, i64 %359
%361 = load double, double* %360
%362 = fneg double %361
%363 = call double @llvm.fmuladd.f64(double %354, double %355, double %362)
store double %363, double* %63
%364 = load double*, double** %35
%365 = load i64, i64* %42
%366 = mul nsw i64 2, %365
%367 = add nsw i64 %366, 1
%368 = getelementptr inbounds double, double* %364, i64 %367
%369 = load double, double* %368
%370 = load double, double* %53
%371 = load double*, double** %35
%372 = load i64, i64* %42
%373 = mul nsw i64 2, %372
%374 = getelementptr inbounds double, double* %371, i64 %373
%375 = load double, double* %374
%376 = call double @llvm.fmuladd.f64(double %369, double %370, double %375)
store double %376, double* %64
%377 = load double*, double** %30
%378 = load i64, i64* %42
%379 = mul nsw i64 2, %378
%380 = getelementptr inbounds double, double* %377, i64 %379
%381 = load double, double* %380
%382 = load double, double* %61
%383 = load double, double* %50
%384 = call double @llvm.fmuladd.f64(double %382, double %383, double %381)
store double %384, double* %67
%385 = load double*, double** %30
%386 = load i64, i64* %42
%387 = mul nsw i64 2, %386
%388 = getelementptr inbounds double, double* %385, i64 %387
%389 = load double, double* %388
%390 = load double, double* %61
%391 = load double, double* %50
%392 = fneg double %390
%393 = call double @llvm.fmuladd.f64(double %392, double %391, double %389)
store double %393, double* %71
%394 = load double*, double** %30
%395 = load i64, i64* %42
%396 = mul nsw i64 2, %395
%397 = add nsw i64 %396, 1
%398 = getelementptr inbounds double, double* %394, i64 %397
%399 = load double, double* %398
%400 = load double, double* %62
%401 = load double, double* %50
%402 = call double @llvm.fmuladd.f64(double %400, double %401, double %399)
store double %402, double* %68
%403 = load double*, double** %30
%404 = load i64, i64* %42
%405 = mul nsw i64 2, %404
%406 = add nsw i64 %405, 1
%407 = getelementptr inbounds double, double* %403, i64 %406
%408 = load double, double* %407
%409 = load double, double* %62
%410 = load double, double* %50
%411 = fneg double %409
%412 = call double @llvm.fmuladd.f64(double %411, double %410, double %408)
store double %412, double* %72
%413 = load double*, double** %32
%414 = load i64, i64* %42
%415 = mul nsw i64 2, %414
%416 = getelementptr inbounds double, double* %413, i64 %415
%417 = load double, double* %416
%418 = load double, double* %65
%419 = load double, double* %50
%420 = call double @llvm.fmuladd.f64(double %418, double %419, double %417)
store double %420, double* %69
%421 = load double*, double** %32
%422 = load i64, i64* %42
%423 = mul nsw i64 2, %422
%424 = getelementptr inbounds double, double* %421, i64 %423
%425 = load double, double* %424
%426 = load double, double* %65
%427 = load double, double* %50
%428 = fneg double %426
%429 = call double @llvm.fmuladd.f64(double %428, double %427, double %425)
store double %429, double* %73
%430 = load double*, double** %32
%431 = load i64, i64* %42
%432 = mul nsw i64 2, %431
%433 = add nsw i64 %432, 1
%434 = getelementptr inbounds double, double* %430, i64 %433
%435 = load double, double* %434
%436 = load double, double* %66
%437 = load double, double* %50
%438 = call double @llvm.fmuladd.f64(double %436, double %437, double %435)
store double %438, double* %70
%439 = load double*, double** %32
%440 = load i64, i64* %42
%441 = mul nsw i64 2, %440
%442 = add nsw i64 %441, 1
%443 = getelementptr inbounds double, double* %439, i64 %442
%444 = load double, double* %443
%445 = load double, double* %66
%446 = load double, double* %50
%447 = fneg double %445
%448 = call double @llvm.fmuladd.f64(double %447, double %446, double %444)
store double %448, double* %74
%449 = load double*, double** %29
%450 = load i64, i64* %42
%451 = mul nsw i64 2, %450
%452 = getelementptr inbounds double, double* %449, i64 %451
%453 = load double, double* %452
%454 = load double, double* %59
%455 = load double, double* %50
%456 = call double @llvm.fmuladd.f64(double %454, double %455, double %453)
store double %456, double* %75
%457 = load double*, double** %29
%458 = load i64, i64* %42
%459 = mul nsw i64 2, %458
%460 = getelementptr inbounds double, double* %457, i64 %459
%461 = load double, double* %460
%462 = load double, double* %59
%463 = load double, double* %50
%464 = fneg double %462
%465 = call double @llvm.fmuladd.f64(double %464, double %463, double %461)
store double %465, double* %83
%466 = load double*, double** %29
%467 = load i64, i64* %42
%468 = mul nsw i64 2, %467
%469 = add nsw i64 %468, 1
%470 = getelementptr inbounds double, double* %466, i64 %469
%471 = load double, double* %470
%472 = load double, double* %60
%473 = load double, double* %50
%474 = call double @llvm.fmuladd.f64(double %472, double %473, double %471)
store double %474, double* %76
%475 = load double*, double** %29
%476 = load i64, i64* %42
%477 = mul nsw i64 2, %476
%478 = add nsw i64 %477, 1
%479 = getelementptr inbounds double, double* %475, i64 %478
%480 = load double, double* %479
%481 = load double, double* %60
%482 = load double, double* %50
%483 = fneg double %481
%484 = call double @llvm.fmuladd.f64(double %483, double %482, double %480)
store double %484, double* %84
%485 = load double, double* %57
%486 = load double, double* %63
%487 = load double, double* %54
%488 = call double @llvm.fmuladd.f64(double %486, double %487, double %485)
store double %488, double* %79
%489 = load double, double* %57
%490 = load double, double* %63
%491 = load double, double* %54
%492 = fneg double %490
%493 = call double @llvm.fmuladd.f64(double %492, double %491, double %489)
store double %493, double* %87
%494 = load double, double* %58
%495 = load double, double* %64
%496 = load double, double* %54
%497 = call double @llvm.fmuladd.f64(double %495, double %496, double %494)
store double %497, double* %80
%498 = load double, double* %58
%499 = load double, double* %64
%500 = load double, double* %54
%501 = fneg double %499
%502 = call double @llvm.fmuladd.f64(double %501, double %500, double %498)
store double %502, double* %88
%503 = load double, double* %67
%504 = load double, double* %43
%505 = load double, double* %68
%506 = fneg double %505
%507 = call double @llvm.fmuladd.f64(double %503, double %504, double %506)
store double %507, double* %77
%508 = load double, double* %68
%509 = load double, double* %43
%510 = load double, double* %67
%511 = call double @llvm.fmuladd.f64(double %508, double %509, double %510)
store double %511, double* %78
%512 = load double, double* %69
%513 = load double, double* %47
%514 = load double, double* %70
%515 = fneg double %514
%516 = call double @llvm.fmuladd.f64(double %512, double %513, double %515)
store double %516, double* %81
%517 = load double, double* %70
%518 = load double, double* %47
%519 = load double, double* %69
%520 = call double @llvm.fmuladd.f64(double %517, double %518, double %519)
store double %520, double* %82
%521 = load double, double* %71
%522 = load double, double* %51
%523 = load double, double* %72
%524 = fneg double %523
%525 = call double @llvm.fmuladd.f64(double %521, double %522, double %524)
store double %525, double* %85
%526 = load double, double* %72
%527 = load double, double* %51
%528 = load double, double* %71
%529 = call double @llvm.fmuladd.f64(double %526, double %527, double %528)
store double %529, double* %86
%530 = load double, double* %73
%531 = load double, double* %55
%532 = load double, double* %74
%533 = fneg double %532
%534 = call double @llvm.fmuladd.f64(double %530, double %531, double %533)
store double %534, double* %89
%535 = load double, double* %74
%536 = load double, double* %55
%537 = load double, double* %73
%538 = call double @llvm.fmuladd.f64(double %535, double %536, double %537)
store double %538, double* %90
%539 = load double, double* %75
%540 = load double, double* %79
%541 = load double, double* %46
%542 = call double @llvm.fmuladd.f64(double %540, double %541, double %539)
store double %542, double* %91
%543 = load double, double* %76
%544 = load double, double* %80
%545 = load double, double* %46
%546 = call double @llvm.fmuladd.f64(double %544, double %545, double %543)
store double %546, double* %92
%547 = load double, double* %75
%548 = load double, double* %79
%549 = load double, double* %46
%550 = fneg double %548
%551 = call double @llvm.fmuladd.f64(double %550, double %549, double %547)
store double %551, double* %95
%552 = load double, double* %76
%553 = load double, double* %80
%554 = load double, double* %46
%555 = fneg double %553
%556 = call double @llvm.fmuladd.f64(double %555, double %554, double %552)
store double %556, double* %96
%557 = load double, double* %83
%558 = load double, double* %88
%559 = load double, double* %46
%560 = fneg double %558
%561 = call double @llvm.fmuladd.f64(double %560, double %559, double %557)
store double %561, double* %99
%562 = load double, double* %84
%563 = load double, double* %87
%564 = load double, double* %46
%565 = call double @llvm.fmuladd.f64(double %563, double %564, double %562)
store double %565, double* %100
%566 = load double, double* %83
%567 = load double, double* %88
%568 = load double, double* %46
%569 = call double @llvm.fmuladd.f64(double %567, double %568, double %566)
store double %569, double* %103
%570 = load double, double* %84
%571 = load double, double* %87
%572 = load double, double* %46
%573 = fneg double %571
%574 = call double @llvm.fmuladd.f64(double %573, double %572, double %570)
store double %574, double* %104
%575 = load double, double* %77
%576 = load double, double* %81
%577 = load double, double* %48
%578 = call double @llvm.fmuladd.f64(double %576, double %577, double %575)
store double %578, double* %93
%579 = load double, double* %78
%580 = load double, double* %82
%581 = load double, double* %48
%582 = call double @llvm.fmuladd.f64(double %580, double %581, double %579)
store double %582, double* %94
%583 = load double, double* %77
%584 = load double, double* %81
%585 = load double, double* %48
%586 = fneg double %584
%587 = call double @llvm.fmuladd.f64(double %586, double %585, double %583)
store double %587, double* %97
%588 = load double, double* %78
%589 = load double, double* %82
%590 = load double, double* %48
%591 = fneg double %589
%592 = call double @llvm.fmuladd.f64(double %591, double %590, double %588)
store double %592, double* %98
%593 = load double, double* %85
%594 = load double, double* %89
%595 = load double, double* %56
%596 = call double @llvm.fmuladd.f64(double %594, double %595, double %593)
store double %596, double* %101
%597 = load double, double* %86
%598 = load double, double* %90
%599 = load double, double* %56
%600 = call double @llvm.fmuladd.f64(double %598, double %599, double %597)
store double %600, double* %102
%601 = load double, double* %85
%602 = load double, double* %89
%603 = load double, double* %56
%604 = fneg double %602
%605 = call double @llvm.fmuladd.f64(double %604, double %603, double %601)
store double %605, double* %105
%606 = load double, double* %86
%607 = load double, double* %90
%608 = load double, double* %56
%609 = fneg double %607
%610 = call double @llvm.fmuladd.f64(double %609, double %608, double %606)
store double %610, double* %106
%611 = load double, double* %91
%612 = load double, double* %93
%613 = load double, double* %44
%614 = call double @llvm.fmuladd.f64(double %612, double %613, double %611)
%615 = load double*, double** %21
%616 = load i64, i64* %42
%617 = mul nsw i64 2, %616
%618 = getelementptr inbounds double, double* %615, i64 %617
store double %614, double* %618
%619 = load double, double* %92
%620 = load double, double* %94
%621 = load double, double* %44
%622 = call double @llvm.fmuladd.f64(double %620, double %621, double %619)
%623 = load double*, double** %21
%624 = load i64, i64* %42
%625 = mul nsw i64 2, %624
%626 = add nsw i64 %625, 1
%627 = getelementptr inbounds double, double* %623, i64 %626
store double %622, double* %627
%628 = load double, double* %91
%629 = load double, double* %93
%630 = load double, double* %44
%631 = fneg double %629
%632 = call double @llvm.fmuladd.f64(double %631, double %630, double %628)
%633 = load double*, double** %25
%634 = load i64, i64* %42
%635 = mul nsw i64 2, %634
%636 = getelementptr inbounds double, double* %633, i64 %635
store double %632, double* %636
%637 = load double, double* %92
%638 = load double, double* %94
%639 = load double, double* %44
%640 = fneg double %638
%641 = call double @llvm.fmuladd.f64(double %640, double %639, double %637)
%642 = load double*, double** %25
%643 = load i64, i64* %42
%644 = mul nsw i64 2, %643
%645 = add nsw i64 %644, 1
%646 = getelementptr inbounds double, double* %642, i64 %645
store double %641, double* %646
%647 = load double, double* %99
%648 = load double, double* %101
%649 = load double, double* %52
%650 = call double @llvm.fmuladd.f64(double %648, double %649, double %647)
%651 = load double*, double** %22
%652 = load i64, i64* %42
%653 = mul nsw i64 2, %652
%654 = getelementptr inbounds double, double* %651, i64 %653
store double %650, double* %654
%655 = load double, double* %100
%656 = load double, double* %102
%657 = load double, double* %52
%658 = call double @llvm.fmuladd.f64(double %656, double %657, double %655)
%659 = load double*, double** %22
%660 = load i64, i64* %42
%661 = mul nsw i64 2, %660
%662 = add nsw i64 %661, 1
%663 = getelementptr inbounds double, double* %659, i64 %662
store double %658, double* %663
%664 = load double, double* %99
%665 = load double, double* %101
%666 = load double, double* %52
%667 = fneg double %665
%668 = call double @llvm.fmuladd.f64(double %667, double %666, double %664)
%669 = load double*, double** %26
%670 = load i64, i64* %42
%671 = mul nsw i64 2, %670
%672 = getelementptr inbounds double, double* %669, i64 %671
store double %668, double* %672
%673 = load double, double* %100
%674 = load double, double* %102
%675 = load double, double* %52
%676 = fneg double %674
%677 = call double @llvm.fmuladd.f64(double %676, double %675, double %673)
%678 = load double*, double** %26
%679 = load i64, i64* %42
%680 = mul nsw i64 2, %679
%681 = add nsw i64 %680, 1
%682 = getelementptr inbounds double, double* %678, i64 %681
store double %677, double* %682
%683 = load double, double* %95
%684 = load double, double* %98
%685 = load double, double* %44
%686 = fneg double %684
%687 = call double @llvm.fmuladd.f64(double %686, double %685, double %683)
%688 = load double*, double** %23
%689 = load i64, i64* %42
%690 = mul nsw i64 2, %689
%691 = getelementptr inbounds double, double* %688, i64 %690
store double %687, double* %691
%692 = load double, double* %96
%693 = load double, double* %97
%694 = load double, double* %44
%695 = call double @llvm.fmuladd.f64(double %693, double %694, double %692)
%696 = load double*, double** %23
%697 = load i64, i64* %42
%698 = mul nsw i64 2, %697
%699 = add nsw i64 %698, 1
%700 = getelementptr inbounds double, double* %696, i64 %699
store double %695, double* %700
%701 = load double, double* %95
%702 = load double, double* %98
%703 = load double, double* %44
%704 = call double @llvm.fmuladd.f64(double %702, double %703, double %701)
%705 = load double*, double** %27
%706 = load i64, i64* %42
%707 = mul nsw i64 2, %706
%708 = getelementptr inbounds double, double* %705, i64 %707
store double %704, double* %708
%709 = load double, double* %96
%710 = load double, double* %97
%711 = load double, double* %44
%712 = fneg double %710
%713 = call double @llvm.fmuladd.f64(double %712, double %711, double %709)
%714 = load double*, double** %27
%715 = load i64, i64* %42
%716 = mul nsw i64 2, %715
%717 = add nsw i64 %716, 1
%718 = getelementptr inbounds double, double* %714, i64 %717
store double %713, double* %718
%719 = load double, double* %103
%720 = load double, double* %106
%721 = load double, double* %52
%722 = fneg double %720
%723 = call double @llvm.fmuladd.f64(double %722, double %721, double %719)
%724 = load double*, double** %24
%725 = load i64, i64* %42
%726 = mul nsw i64 2, %725
%727 = getelementptr inbounds double, double* %724, i64 %726
store double %723, double* %727
%728 = load double, double* %104
%729 = load double, double* %105
%730 = load double, double* %52
%731 = call double @llvm.fmuladd.f64(double %729, double %730, double %728)
%732 = load double*, double** %24
%733 = load i64, i64* %42
%734 = mul nsw i64 2, %733
%735 = add nsw i64 %734, 1
%736 = getelementptr inbounds double, double* %732, i64 %735
store double %731, double* %736
%737 = load double, double* %103
%738 = load double, double* %106
%739 = load double, double* %52
%740 = call double @llvm.fmuladd.f64(double %738, double %739, double %737)
%741 = load double*, double** %28
%742 = load i64, i64* %42
%743 = mul nsw i64 2, %742
%744 = getelementptr inbounds double, double* %741, i64 %743
store double %740, double* %744
%745 = load double, double* %104
%746 = load double, double* %105
%747 = load double, double* %52
%748 = fneg double %746
%749 = call double @llvm.fmuladd.f64(double %748, double %747, double %745)
%750 = load double*, double** %28
%751 = load i64, i64* %42
%752 = mul nsw i64 2, %751
%753 = add nsw i64 %752, 1
%754 = getelementptr inbounds double, double* %750, i64 %753
store double %749, double* %754
br label %755
755: ; preds = %241
%756 = load i64, i64* %42
%757 = add nsw i64 %756, 1
store i64 %757, i64* %42
br label %237
758: ; preds = %237
%759 = load i64, i64* %39
%760 = mul nsw i64 16, %759
%761 = load double*, double** %29
%762 = getelementptr inbounds double, double* %761, i64 %760
store double* %762, double** %29
%763 = load i64, i64* %39
%764 = mul nsw i64 16, %763
%765 = load double*, double** %30
%766 = getelementptr inbounds double, double* %765, i64 %764
store double* %766, double** %30
%767 = load i64, i64* %39
%768 = mul nsw i64 16, %767
%769 = load double*, double** %31
%770 = getelementptr inbounds double, double* %769, i64 %768
store double* %770, double** %31
%771 = load i64, i64* %39
%772 = mul nsw i64 16, %771
%773 = load double*, double** %32
%774 = getelementptr inbounds double, double* %773, i64 %772
store double* %774, double** %32
%775 = load i64, i64* %39
%776 = mul nsw i64 16, %775
%777 = load double*, double** %33
%778 = getelementptr inbounds double, double* %777, i64 %776
store double* %778, double** %33
%779 = load i64, i64* %39
%780 = mul nsw i64 16, %779
%781 = load double*, double** %34
%782 = getelementptr inbounds double, double* %781, i64 %780
store double* %782, double** %34
%783 = load i64, i64* %39
%784 = mul nsw i64 16, %783
%785 = load double*, double** %35
%786 = getelementptr inbounds double, double* %785, i64 %784
store double* %786, double** %35
%787 = load i64, i64* %39
%788 = mul nsw i64 16, %787
%789 = load double*, double** %36
%790 = getelementptr inbounds double, double* %789, i64 %788
store double* %790, double** %36
%791 = load i64, i64* %39
%792 = mul nsw i64 2, %791
%793 = load double*, double** %21
%794 = getelementptr inbounds double, double* %793, i64 %792
store double* %794, double** %21
%795 = load i64, i64* %39
%796 = mul nsw i64 2, %795
%797 = load double*, double** %22
%798 = getelementptr inbounds double, double* %797, i64 %796
store double* %798, double** %22
%799 = load i64, i64* %39
%800 = mul nsw i64 2, %799
%801 = load double*, double** %23
%802 = getelementptr inbounds double, double* %801, i64 %800
store double* %802, double** %23
%803 = load i64, i64* %39
%804 = mul nsw i64 2, %803
%805 = load double*, double** %24
%806 = getelementptr inbounds double, double* %805, i64 %804
store double* %806, double** %24
%807 = load i64, i64* %39
%808 = mul nsw i64 2, %807
%809 = load double*, double** %25
%810 = getelementptr inbounds double, double* %809, i64 %808
store double* %810, double** %25
%811 = load i64, i64* %39
%812 = mul nsw i64 2, %811
%813 = load double*, double** %26
%814 = getelementptr inbounds double, double* %813, i64 %812
store double* %814, double** %26
%815 = load i64, i64* %39
%816 = mul nsw i64 2, %815
%817 = load double*, double** %27
%818 = getelementptr inbounds double, double* %817, i64 %816
store double* %818, double** %27
%819 = load i64, i64* %39
%820 = mul nsw i64 2, %819
%821 = load double*, double** %28
%822 = getelementptr inbounds double, double* %821, i64 %820
store double* %822, double** %28
br label %823
823: ; preds = %758
%824 = load i64, i64* %41
%825 = add nsw i64 %824, 1
store i64 %825, i64* %41
br label %107
826: ; preds = %107
ret void
}

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