void kern_r8_fma_o_f(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;
  double w5;
  w5 = w[2 * blocks * bsize + 1];
  for (j = 0; j < bsize; j++) {
    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;
    qr1 = i1[2 * j] + i5[2 * j];
    sr5 = i1[2 * j] - i5[2 * j];
    qi1 = i1[2 * j + 1] + i5[2 * j + 1];
    si5 = i1[2 * j + 1] - i5[2 * j + 1];
    qr3 = i3[2 * j] + i7[2 * j];
    sr7 = i3[2 * j] - i7[2 * j];
    qi3 = i3[2 * j + 1] + i7[2 * j + 1];
    si7 = i3[2 * j + 1] - i7[2 * j + 1];
    qr0 = i0[2 * j] + i4[2 * j];
    qr4 = i0[2 * j] - i4[2 * j];
    qi0 = i0[2 * j + 1] + i4[2 * j + 1];
    qi4 = i0[2 * j + 1] - i4[2 * j + 1];
    qr2 = i2[2 * j] + i6[2 * j];
    qr6 = i2[2 * j] - i6[2 * j];
    qi2 = i2[2 * j + 1] + i6[2 * j + 1];
    qi6 = i2[2 * j + 1] - i6[2 * j + 1];
    qr5 = sr5 + si5;
    qi5 = si5 - sr5;
    qr7 = -sr7 + si7;
    qi7 = -si7 - sr7;
    tr0 = qr0 + qr2;
    ti0 = qi0 + qi2;
    tr2 = qr0 - qr2;
    ti2 = qi0 - qi2;
    tr4 = qr4 + qi6;
    ti4 = qi4 - qr6;
    tr6 = qr4 - qi6;
    ti6 = qi4 + qr6;
    tr1 = qr1 + qr3;
    ti1 = qi1 + qi3;
    tr3 = qr1 - qr3;
    ti3 = qi1 - qi3;
    tr5 = qr5 + qr7;
    ti5 = qi5 + qi7;
    tr7 = qr5 - qr7;
    ti7 = qi5 - qi7;
    o0[2 * j] = tr0 + tr1;
    o0[2 * j + 1] = ti0 + ti1;
    o4[2 * j] = tr0 - tr1;
    o4[2 * j + 1] = ti0 - ti1;
    o1[2 * j] = tr4 + tr5 * w5;
    o1[2 * j + 1] = ti4 + ti5 * w5;
    o5[2 * j] = tr4 - tr5 * w5;
    o5[2 * j + 1] = ti4 - ti5 * w5;
    o2[2 * j] = tr2 + ti3;
    o2[2 * j + 1] = ti2 - tr3;
    o6[2 * j] = tr2 - ti3;
    o6[2 * j + 1] = ti2 + tr3;
    o3[2 * j] = tr6 + ti7 * w5;
    o3[2 * j + 1] = ti6 - tr7 * w5;
    o7[2 * j] = tr6 - ti7 * w5;
    o7[2 * j + 1] = ti6 + tr7 * w5;
  }
  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;
  for (i = 1; 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_o_f>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2e8,%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)
mov    0x60(%rbp),%rax
mov    0x78(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    0x70(%rbp),%rax
jge    18f9 <kern_r8_fma_o_f+0x7f9>
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
addsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
subsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
subsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
subsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf8(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0xf0(%rbp),%xmm0
ff
subsd  -0x100(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xf8(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm1
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0x48(%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  -0x138(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm1
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
addsd  -0x128(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x118(%rbp),%xmm0
ff
subsd  -0x120(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
subsd  -0x128(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x118(%rbp),%xmm0
ff
addsd  -0x120(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x158(%rbp),%xmm1
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x158(%rbp),%xmm1
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  -0x48(%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)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    117f <kern_r8_fma_o_f+0x7f>
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)
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    0x78(%rbp),%rax
jge    2cc1 <kern_r8_fma_o_f+0x1bc1>
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c0(%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,-0x1c8(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
mov    0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x70(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x198(%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  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%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,-0x1b8(%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,-0x1d0(%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,-0x1d8(%rbp)
ff
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    0x70(%rbp),%rax
jge    2b70 <kern_r8_fma_o_f+0x1a70>
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x1a0(%rbp),%xmm2
ff
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x1a0(%rbp),%xmm2
ff
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x1a0(%rbp),%xmm2
ff
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x1a0(%rbp),%xmm2
ff
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x180(%rbp),%xmm2
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x180(%rbp),%xmm2
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x1a0(%rbp),%xmm2
ff
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x1a0(%rbp),%xmm2
ff
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x1c0(%rbp),%xmm2
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x1c0(%rbp),%xmm2
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x200(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x200(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x208(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x208(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x258(%rbp)
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x220(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x220(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x228(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x228(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x268(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  -0x1a8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
movsd  -0x1e0(%rbp),%xmm1
ff
movsd  -0x210(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x1e0(%rbp),%xmm1
ff
movsd  -0x210(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm1
ff
movsd  -0x218(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm1
ff
movsd  -0x218(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
movsd  -0x170(%rbp),%xmm2
ff
movsd  -0x238(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x238(%rbp),%xmm0
ff
movsd  -0x170(%rbp),%xmm2
ff
movsd  -0x230(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0x240(%rbp),%xmm0
ff
movsd  -0x190(%rbp),%xmm2
ff
movsd  -0x248(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
movsd  -0x190(%rbp),%xmm2
ff
movsd  -0x240(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
movsd  -0x250(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x258(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
movsd  -0x258(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x250(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
movsd  -0x260(%rbp),%xmm0
ff
movsd  -0x1d0(%rbp),%xmm2
ff
movsd  -0x268(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
movsd  -0x268(%rbp),%xmm0
ff
movsd  -0x1d0(%rbp),%xmm2
ff
movsd  -0x260(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
movsd  -0x270(%rbp),%xmm1
ff
movsd  -0x290(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2f0(%rbp)
ff
movsd  -0x278(%rbp),%xmm1
ff
movsd  -0x298(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2f8(%rbp)
ff
movsd  -0x270(%rbp),%xmm1
ff
movsd  -0x290(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
movsd  -0x278(%rbp),%xmm1
ff
movsd  -0x298(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
movsd  -0x2b0(%rbp),%xmm1
ff
movsd  -0x2d8(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x330(%rbp)
ff
movsd  -0x2b8(%rbp),%xmm1
ff
movsd  -0x2d0(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x338(%rbp)
ff
movsd  -0x2b0(%rbp),%xmm1
ff
movsd  -0x2d8(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x350(%rbp)
ff
movsd  -0x2b8(%rbp),%xmm1
ff
movsd  -0x2d0(%rbp),%xmm0
ff
movsd  -0x188(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x358(%rbp)
ff
movsd  -0x280(%rbp),%xmm1
ff
movsd  -0x2a0(%rbp),%xmm0
ff
movsd  -0x198(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x300(%rbp)
ff
movsd  -0x288(%rbp),%xmm1
ff
movsd  -0x2a8(%rbp),%xmm0
ff
movsd  -0x198(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
movsd  -0x280(%rbp),%xmm1
ff
movsd  -0x2a0(%rbp),%xmm0
ff
movsd  -0x198(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x320(%rbp)
ff
movsd  -0x288(%rbp),%xmm1
ff
movsd  -0x2a8(%rbp),%xmm0
ff
movsd  -0x198(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x328(%rbp)
ff
movsd  -0x2c0(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm0
ff
movsd  -0x1d8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x340(%rbp)
ff
movsd  -0x2c8(%rbp),%xmm1
ff
movsd  -0x2e8(%rbp),%xmm0
ff
movsd  -0x1d8(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x348(%rbp)
ff
movsd  -0x2c0(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm0
ff
movsd  -0x1d8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x360(%rbp)
ff
movsd  -0x2c8(%rbp),%xmm1
ff
movsd  -0x2e8(%rbp),%xmm0
ff
movsd  -0x1d8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x368(%rbp)
ff
movsd  -0x2f0(%rbp),%xmm1
ff
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x178(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x2f8(%rbp),%xmm1
ff
movsd  -0x308(%rbp),%xmm0
ff
movsd  -0x178(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x2f0(%rbp),%xmm1
ff
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x178(%rbp),%xmm2
ff
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  -0x2f8(%rbp),%xmm1
ff
movsd  -0x308(%rbp),%xmm0
ff
movsd  -0x178(%rbp),%xmm2
ff
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  -0x330(%rbp),%xmm1
ff
movsd  -0x340(%rbp),%xmm0
ff
movsd  -0x1b8(%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  -0x338(%rbp),%xmm1
ff
movsd  -0x348(%rbp),%xmm0
ff
movsd  -0x1b8(%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  -0x330(%rbp),%xmm1
ff
movsd  -0x340(%rbp),%xmm0
ff
movsd  -0x1b8(%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  -0x338(%rbp),%xmm1
ff
movsd  -0x348(%rbp),%xmm0
ff
movsd  -0x1b8(%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  -0x310(%rbp),%xmm1
ff
movsd  -0x328(%rbp),%xmm0
ff
movsd  -0x178(%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  -0x318(%rbp),%xmm1
ff
movsd  -0x320(%rbp),%xmm0
ff
movsd  -0x178(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x310(%rbp),%xmm1
ff
movsd  -0x328(%rbp),%xmm0
movsd  -0x178(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x318(%rbp),%xmm1
ff
movsd  -0x320(%rbp),%xmm0
ff
movsd  -0x178(%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  -0x350(%rbp),%xmm1
ff
movsd  -0x368(%rbp),%xmm0
ff
movsd  -0x1b8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x358(%rbp),%xmm1
ff
movsd  -0x360(%rbp),%xmm0
ff
movsd  -0x1b8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x350(%rbp),%xmm1
ff
movsd  -0x368(%rbp),%xmm0
ff
movsd  -0x1b8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x358(%rbp),%xmm1
ff
movsd  -0x360(%rbp),%xmm0
ff
movsd  -0x1b8(%rbp),%xmm2
ff
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    1c42 <kern_r8_fma_o_f+0xb42>
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    1a41 <kern_r8_fma_o_f+0x941>
add    $0x2e8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r8_fma_o_f>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2a8,%rsp
mov    %r9,-0x8(%rsp)
mov    %r8,-0x18(%rsp)
mov    %rcx,-0x30(%rsp)
mov    %rdx,-0x28(%rsp)
mov    %rsi,-0x20(%rsp)
mov    %rdi,-0x10(%rsp)
mov    0x348(%rsp),%rax
mov    0x340(%rsp),%rcx
imul   %rcx,%rax
mov    %rax,0x48(%rsp)
test   %rcx,%rcx
jle    14b1 <kern_r8_fma_o_f+0x3b1>
mov    0x48(%rsp),%rax
shl    $0x4,%rax
mov    0x330(%rsp),%rcx
movsd  0x8(%rcx,%rax,1),%xmm13
mov    0x340(%rsp),%rax
cmp    $0x1,%rax
jne    265a <kern_r8_fma_o_f+0x155a>
xor    %r9d,%r9d
movlhps %xmm13,%xmm13
mov    0x340(%rsp),%rax
sub    %r9,%rax
mov    %rax,0x120(%rsp)
shl    $0x4,%r9
movapd 0x1e5e(%rip),%xmm8
mov    0x2e8(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    -0x30(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    0x2e0(%rsp),%rsi
mov    %rsi,-0x40(%rsp)
mov    -0x28(%rsp),%rax
mov    %rax,-0x50(%rsp)
mov    -0x8(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    -0x20(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    -0x18(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    -0x10(%rsp),%rax
mov    %rax,(%rsp)
mov    0x320(%rsp),%r10
mov    %r10,0x80(%rsp)
mov    0x300(%rsp),%r15
mov    %r15,0x70(%rsp)
mov    0x310(%rsp),%r14
mov    %r14,0x60(%rsp)
mov    0x2f0(%rsp),%r13
mov    %r13,0x50(%rsp)
mov    0x328(%rsp),%r12
mov    0x308(%rsp),%rax
mov    0x318(%rsp),%rdx
mov    0x2f8(%rsp),%rbp
xchg   %ax,%ax
movupd 0x0(%rbp,%r9,1),%xmm9
movupd (%rdx,%r9,1),%xmm1
movapd %xmm9,%xmm0
subpd  %xmm1,%xmm0
addpd  %xmm1,%xmm9
movupd (%rax,%r9,1),%xmm10
movupd (%r12,%r9,1),%xmm1
movapd %xmm10,%xmm2
subpd  %xmm1,%xmm2
addpd  %xmm1,%xmm10
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
mov    0x50(%rsp),%rbx
movupd (%rbx,%r9,1),%xmm12
mov    0x60(%rsp),%r15
movupd (%r15,%r9,1),%xmm4
movapd %xmm12,%xmm1
addpd  %xmm4,%xmm1
subpd  %xmm4,%xmm12
mov    0x70(%rsp),%rcx
movupd (%rcx,%r9,1),%xmm7
mov    0x80(%rsp),%rcx
movupd (%rcx,%r9,1),%xmm4
movapd %xmm7,%xmm6
addpd  %xmm4,%xmm6
subpd  %xmm4,%xmm7
shufpd $0x1,%xmm7,%xmm7
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
unpcklpd %xmm0,%xmm11
addpd  %xmm0,%xmm4
subpd  %xmm11,%xmm0
movsd  %xmm4,%xmm0
xorpd  %xmm8,%xmm3
movapd %xmm2,%xmm4
shufpd $0x1,%xmm3,%xmm4
unpcklpd %xmm2,%xmm2
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm3
addpd  %xmm6,%xmm3
movapd %xmm12,%xmm5
addpd  %xmm7,%xmm5
subpd  %xmm7,%xmm12
movapd %xmm12,%xmm2
movsd  %xmm5,%xmm2
shufpd $0x2,%xmm5,%xmm12
movapd %xmm1,%xmm7
unpcklpd %xmm9,%xmm7
movhlps %xmm9,%xmm1
addpd  %xmm10,%xmm9
movapd %xmm6,%xmm5
unpcklpd %xmm10,%xmm5
subpd  %xmm5,%xmm7
movhlps %xmm10,%xmm6
subpd  %xmm6,%xmm1
movapd %xmm0,%xmm5
addpd  %xmm4,%xmm5
subpd  %xmm4,%xmm0
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
movapd %xmm9,%xmm6
addpd  %xmm3,%xmm6
mov    (%rsp),%r14
movupd %xmm6,(%r14,%r9,1)
subpd  %xmm9,%xmm3
mov    0x10(%rsp),%r10
movupd %xmm3,(%r10,%r9,1)
mulpd  %xmm13,%xmm5
movapd %xmm5,%xmm3
addpd  %xmm2,%xmm3
mov    0x20(%rsp),%r13
movupd %xmm3,0x0(%r13,%r9,1)
subpd  %xmm5,%xmm2
mov    0x30(%rsp),%r8
movupd %xmm2,(%r8,%r9,1)
movapd %xmm1,%xmm2
addpd  %xmm7,%xmm2
movapd %xmm1,%xmm3
subpd  %xmm7,%xmm3
movsd  %xmm2,%xmm3
mov    -0x50(%rsp),%r11
movupd %xmm3,(%r11,%r9,1)
subpd  %xmm1,%xmm7
shufpd $0x2,%xmm2,%xmm7
mov    -0x40(%rsp),%rcx
movupd %xmm7,(%rcx,%r9,1)
movapd %xmm0,%xmm1
xorpd  %xmm8,%xmm4
unpcklpd %xmm0,%xmm4
xorpd  %xmm8,%xmm0
shufpd $0x1,%xmm0,%xmm1
mulpd  %xmm13,%xmm1
addpd  %xmm12,%xmm1
mov    -0x60(%rsp),%rdi
movupd %xmm1,(%rdi,%r9,1)
mulpd  %xmm13,%xmm4
addpd  %xmm12,%xmm4
mov    -0x70(%rsp),%rsi
movupd %xmm4,(%rsi,%r9,1)
add    $0x10,%rbp
add    $0x10,%rdx
add    $0x10,%rax
add    $0x10,%r12
add    $0x10,%rbx
mov    %rbx,0x50(%rsp)
add    $0x10,%r15
mov    %r15,0x60(%rsp)
addq   $0x10,0x70(%rsp)
addq   $0x10,0x80(%rsp)
add    $0x10,%r14
mov    %r14,(%rsp)
add    $0x10,%r10
mov    %r10,0x10(%rsp)
add    $0x10,%r13
mov    %r13,0x20(%rsp)
add    $0x10,%r8
mov    %r8,0x30(%rsp)
add    $0x10,%r11
mov    %r11,-0x50(%rsp)
add    $0x10,%rcx
mov    %rcx,-0x40(%rsp)
add    $0x10,%rdi
mov    %rdi,-0x60(%rsp)
add    $0x10,%rsi
mov    %rsi,-0x70(%rsp)
addq   $0xffffffffffffffff,0x120(%rsp)
jne    1250 <kern_r8_fma_o_f+0x150>
cmpq   $0x2,0x348(%rsp)
jl     2648 <kern_r8_fma_o_f+0x1548>
mov    0x48(%rsp),%rax
add    %rax,%rax
mov    %rax,0x48(%rsp)
mov    0x340(%rsp),%rsi
mov    %rsi,%r8
shl    $0x4,%r8
lea    (%rsi,%rsi,1),%rcx
lea    -0x1(%rsi),%rax
mov    %rcx,0x218(%rsp)
or     $0x1,%rcx
mov    %rcx,0x210(%rsp)
mov    $0x10,%ecx
mul    %rcx
mov    %rax,0x208(%rsp)
seto   -0x71(%rsp)
mov    %rsi,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x130(%rsp)
mov    0x2f0(%rsp),%rax
lea    (%rax,%r8,8),%r9
shl    $0x7,%rsi
mov    %rsi,0x220(%rsp)
mov    0x308(%rsp),%rax
lea    (%rax,%r8,8),%r10
mov    0x2f8(%rsp),%rax
lea    (%rax,%r8,8),%r11
mov    0x320(%rsp),%rax
lea    (%rax,%r8,8),%r14
mov    0x310(%rsp),%rax
lea    (%rax,%r8,8),%r15
mov    0x300(%rsp),%rax
lea    (%rax,%r8,8),%r12
mov    0x328(%rsp),%rax
lea    (%rax,%r8,8),%r13
mov    0x318(%rsp),%rax
lea    (%rax,%r8,8),%rbp
movapd 0x1a70(%rip),%xmm4
mov    0x2e8(%rsp),%rax
lea    (%rax,%r8,1),%rbx
mov    -0x30(%rsp),%rax
lea    (%rax,%r8,1),%rdi
mov    0x2e0(%rsp),%rax
lea    (%rax,%r8,1),%rcx
mov    -0x28(%rsp),%rax
lea    (%rax,%r8,1),%rsi
mov    -0x8(%rsp),%rax
lea    (%rax,%r8,1),%rax
mov    %rax,0xa8(%rsp)
mov    -0x20(%rsp),%rax
lea    (%rax,%r8,1),%rax
mov    %rax,0xa0(%rsp)
mov    -0x18(%rsp),%rax
add    %r8,%rax
mov    %rax,0x98(%rsp)
mov    -0x10(%rsp),%rax
mov    %r8,0x228(%rsp)
add    %r8,%rax
mov    $0x1,%edx
mov    %rdx,0xb0(%rsp)
xor    %edx,%edx
mov    %rdx,0x138(%rsp)
jmp    1702 <kern_r8_fma_o_f+0x602>
nopl   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%r8
add    $0x1,%r8
addq   $0x1,0x138(%rsp)
mov    0x118(%rsp),%r9
mov    0x220(%rsp),%rdx
add    %rdx,%r9
mov    0x110(%rsp),%r10
add    %rdx,%r10
mov    0x108(%rsp),%r11
add    %rdx,%r11
mov    0x100(%rsp),%r14
add    %rdx,%r14
mov    0xf8(%rsp),%r15
add    %rdx,%r15
mov    0xf0(%rsp),%r12
add    %rdx,%r12
mov    0xe8(%rsp),%r13
add    %rdx,%r13
mov    0x228(%rsp),%rbp
mov    0xd8(%rsp),%rbx
add    %rbp,%rbx
mov    0xd0(%rsp),%rdi
add    %rbp,%rdi
mov    0xc8(%rsp),%rcx
add    %rbp,%rcx
mov    0xc0(%rsp),%rsi
add    %rbp,%rsi
add    %rbp,0xa8(%rsp)
add    %rbp,0xa0(%rsp)
add    %rbp,0x98(%rsp)
mov    0xb8(%rsp),%rax
add    %rbp,%rax
mov    0xe0(%rsp),%rbp
add    %rdx,%rbp
mov    %r8,0xb0(%rsp)
cmp    0x348(%rsp),%r8
je     2648 <kern_r8_fma_o_f+0x1548>
mov    %rax,0xb8(%rsp)
mov    %rsi,0xc0(%rsp)
mov    %rcx,0xc8(%rsp)
mov    %rdi,0xd0(%rsp)
mov    %rbx,0xd8(%rsp)
mov    %rbp,0xe0(%rsp)
mov    %r13,0xe8(%rsp)
mov    %r12,0xf0(%rsp)
mov    %r15,0xf8(%rsp)
mov    %r14,0x100(%rsp)
mov    %r11,0x108(%rsp)
mov    %r10,0x110(%rsp)
mov    %r9,0x118(%rsp)
cmpq   $0x0,0x340(%rsp)
jle    1620 <kern_r8_fma_o_f+0x520>
mov    0xb0(%rsp),%rax
mov    0x340(%rsp),%rbp
imul   %rbp,%rax
mov    %rax,%rcx
shl    $0x6,%rcx
mov    %rax,%rdx
shl    $0x5,%rdx
mov    0x48(%rsp),%rsi
lea    (%rsi,%rax,2),%rsi
shl    $0x4,%rax
lea    0x0(,%rsi,8),%rdi
or     $0x8,%rdi
mov    0x330(%rsp),%rbx
movsd  (%rbx,%rcx,1),%xmm6
movsd  0x8(%rbx,%rcx,1),%xmm10
movsd  (%rbx,%rdx,1),%xmm11
movsd  0x8(%rbx,%rdx,1),%xmm12
mov    0x338(%rsp),%rcx
movsd  (%rcx,%rdx,1),%xmm8
movsd  0x8(%rcx,%rdx,1),%xmm1
movsd  (%rbx,%rax,1),%xmm9
movsd  0x8(%rbx,%rax,1),%xmm13
movsd  (%rcx,%rax,1),%xmm3
movsd  0x8(%rcx,%rax,1),%xmm5
movsd  (%rbx,%rsi,8),%xmm2
movsd  (%rbx,%rdi,1),%xmm7
movsd  (%rcx,%rsi,8),%xmm0
movsd  (%rcx,%rdi,1),%xmm14
cmp    $0x1,%rbp
movaps %xmm12,0x50(%rsp)
movaps %xmm1,0x1f0(%rsp)
movaps %xmm9,0x120(%rsp)
movapd %xmm3,0x160(%rsp)
movapd %xmm5,0x1e0(%rsp)
movapd %xmm2,0x150(%rsp)
movapd %xmm0,0x140(%rsp)
movapd %xmm14,0x1d0(%rsp)
jne    1e30 <kern_r8_fma_o_f+0xd30>
xor    %r9d,%r9d
unpcklpd %xmm6,%xmm6
unpcklpd %xmm11,%xmm11
unpcklpd %xmm8,%xmm8
unpcklpd %xmm10,%xmm10
movaps 0x1f0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x1a0(%rsp)
movaps 0x120(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0x160(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x160(%rsp)
movaps 0x150(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x150(%rsp)
movaps 0x140(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x140(%rsp)
movaps 0x50(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0x1e0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0x1d0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
unpcklpd %xmm13,%xmm13
unpcklpd %xmm7,%xmm7
mov    0x340(%rsp),%rax
sub    %r9,%rax
mov    %rax,0x170(%rsp)
shl    $0x4,%r9
mov    0xd8(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    0xd0(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    0xc8(%rsp),%rax
mov    %rax,-0x40(%rsp)
mov    0xc0(%rsp),%rax
mov    %rax,-0x50(%rsp)
mov    0xa8(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0xa0(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    0x98(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0xb8(%rsp),%rax
mov    %rax,(%rsp)
mov    0x118(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0x108(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x100(%rsp),%rcx
mov    0xf8(%rsp),%rdi
mov    0xf0(%rsp),%r15
mov    0xe8(%rsp),%rbx
mov    0xe0(%rsp),%r10
movapd %xmm8,0x1c0(%rsp)
movapd %xmm7,0x1b0(%rsp)
nopl   0x0(%rax)
movupd (%r10,%r9,1),%xmm5
movapd %xmm5,%xmm0
movupd (%rbx,%r9,1),%xmm1
xorpd  %xmm4,%xmm0
movapd %xmm5,%xmm2
movapd %xmm1,%xmm3
xorpd  %xmm4,%xmm3
movapd %xmm1,%xmm4
shufpd $0x1,%xmm3,%xmm4
mulpd  %xmm6,%xmm1
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm1
movupd (%r15,%r9,1),%xmm14
movapd %xmm14,%xmm3
xorpd  0x15b8(%rip),%xmm3
movapd %xmm14,%xmm4
shufpd $0x1,%xmm0,%xmm2
shufpd $0x1,%xmm3,%xmm4
mulpd  %xmm11,%xmm14
movupd (%rdi,%r9,1),%xmm0
movapd %xmm0,%xmm3
addpd  %xmm2,%xmm5
xorpd  0x158e(%rip),%xmm3
movapd %xmm0,%xmm2
shufpd $0x1,%xmm3,%xmm2
mulpd  %xmm6,%xmm0
addpd  %xmm4,%xmm14
movupd (%rcx,%r9,1),%xmm7
movapd %xmm7,%xmm3
xorpd  0x156a(%rip),%xmm3
movapd %xmm7,%xmm4
shufpd $0x1,%xmm3,%xmm4
addpd  %xmm2,%xmm0
mulpd  %xmm8,%xmm7
addpd  %xmm4,%xmm7
mov    0x60(%rsp),%rbp
movupd 0x0(%rbp,%r9,1),%xmm2
mulpd  %xmm10,%xmm5
movapd %xmm6,%xmm8
movapd %xmm5,%xmm6
addpd  %xmm2,%xmm6
mov    0x70(%rsp),%rax
movupd (%rax,%r9,1),%xmm15
mulpd  %xmm10,%xmm1
movapd %xmm1,%xmm4
addpd  %xmm15,%xmm4
subpd  %xmm1,%xmm15
mov    0x80(%rsp),%rax
movupd (%rax,%r9,1),%xmm12
mulpd  %xmm10,%xmm0
subpd  %xmm5,%xmm2
movapd %xmm10,%xmm9
movapd %xmm0,%xmm10
addpd  %xmm12,%xmm10
subpd  %xmm0,%xmm12
movapd %xmm7,%xmm0
movapd 0x1f0(%rsp),%xmm1
mulsd  %xmm1,%xmm0
movapd %xmm13,%xmm3
movapd %xmm14,%xmm13
movapd %xmm7,%xmm5
subsd  %xmm0,%xmm13
mulpd  0x1a0(%rsp),%xmm5
addpd  %xmm14,%xmm5
unpckhpd %xmm7,%xmm7
unpckhpd %xmm14,%xmm14
mulsd  %xmm1,%xmm7
subsd  %xmm7,%xmm14
movapd %xmm6,%xmm0
xorpd  0x149d(%rip),%xmm0
movapd %xmm6,%xmm1
shufpd $0x1,%xmm0,%xmm1
mulpd  0x120(%rsp),%xmm6
movapd %xmm4,%xmm0
xorpd  0x147f(%rip),%xmm0
movapd %xmm4,%xmm7
shufpd $0x1,%xmm0,%xmm7
addpd  %xmm1,%xmm6
mulpd  0x160(%rsp),%xmm4
movapd %xmm2,%xmm0
xorpd  0x145d(%rip),%xmm0
movapd %xmm2,%xmm1
shufpd $0x1,%xmm0,%xmm1
movapd %xmm15,%xmm0
addpd  %xmm7,%xmm4
xorpd  0x1443(%rip),%xmm0
movapd %xmm15,%xmm7
shufpd $0x1,%xmm0,%xmm7
mulpd  0x150(%rsp),%xmm2
addpd  %xmm1,%xmm2
mulpd  0x140(%rsp),%xmm15
addpd  %xmm7,%xmm15
movapd 0x50(%rsp),%xmm0
mulpd  %xmm0,%xmm5
movapd %xmm5,%xmm7
movapd %xmm14,%xmm1
addpd  %xmm10,%xmm7
xorpd  0x13fc(%rip),%xmm14
unpcklpd %xmm13,%xmm14
xorpd  0x13ee(%rip),%xmm13
subpd  %xmm5,%xmm10
unpcklpd %xmm13,%xmm1
movapd %xmm3,%xmm13
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm14
addpd  %xmm12,%xmm1
addpd  %xmm12,%xmm14
movapd %xmm4,%xmm5
mulpd  0x190(%rsp),%xmm5
movapd %xmm4,%xmm3
movapd 0x1e0(%rsp),%xmm0
mulsd  %xmm0,%xmm3
movapd %xmm6,%xmm12
addpd  %xmm6,%xmm5
subsd  %xmm3,%xmm12
unpckhpd %xmm4,%xmm4
mulsd  %xmm0,%xmm4
unpckhpd %xmm6,%xmm6
subsd  %xmm4,%xmm6
movapd %xmm15,%xmm4
movapd 0x1d0(%rsp),%xmm0
mulsd  %xmm0,%xmm4
movapd %xmm2,%xmm3
subsd  %xmm4,%xmm3
movapd %xmm15,%xmm4
mulpd  0x180(%rsp),%xmm4
addpd  %xmm2,%xmm4
unpckhpd %xmm15,%xmm15
mulsd  %xmm0,%xmm15
unpckhpd %xmm2,%xmm2
subsd  %xmm15,%xmm2
mulpd  %xmm13,%xmm5
movapd %xmm5,%xmm0
addpd  %xmm7,%xmm0
mov    (%rsp),%r11
movupd %xmm0,(%r11,%r9,1)
subpd  %xmm5,%xmm7
mov    0x10(%rsp),%r8
movupd %xmm7,(%r8,%r9,1)
movapd 0x1b0(%rsp),%xmm7
mulpd  %xmm7,%xmm4
movapd %xmm4,%xmm0
addpd  %xmm1,%xmm0
mov    0x20(%rsp),%r13
movupd %xmm0,0x0(%r13,%r9,1)
subpd  %xmm4,%xmm1
movapd 0x12fe(%rip),%xmm4
mov    0x30(%rsp),%r12
movupd %xmm1,(%r12,%r9,1)
movapd %xmm6,%xmm0
xorpd  %xmm4,%xmm6
unpcklpd %xmm12,%xmm6
xorpd  %xmm4,%xmm12
unpcklpd %xmm12,%xmm0
mulpd  %xmm13,%xmm0
addpd  %xmm10,%xmm0
mulpd  %xmm13,%xmm6
addpd  %xmm10,%xmm6
movapd %xmm9,%xmm10
mov    -0x50(%rsp),%rax
movupd %xmm0,(%rax,%r9,1)
mov    -0x40(%rsp),%r14
movupd %xmm6,(%r14,%r9,1)
movapd %xmm8,%xmm6
movaps 0x1c0(%rsp),%xmm8
movapd %xmm2,%xmm0
xorpd  %xmm4,%xmm2
unpcklpd %xmm3,%xmm2
xorpd  %xmm4,%xmm3
unpcklpd %xmm3,%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm14,%xmm0
mov    -0x60(%rsp),%rdx
movupd %xmm0,(%rdx,%r9,1)
mulpd  %xmm7,%xmm2
addpd  %xmm14,%xmm2
mov    -0x70(%rsp),%rsi
movupd %xmm2,(%rsi,%r9,1)
add    $0x10,%r10
add    $0x10,%rbx
add    $0x10,%r15
add    $0x10,%rdi
add    $0x10,%rcx
add    $0x10,%rbp
mov    %rbp,0x60(%rsp)
addq   $0x10,0x70(%rsp)
addq   $0x10,0x80(%rsp)
add    $0x10,%r11
mov    %r11,(%rsp)
add    $0x10,%r8
mov    %r8,0x10(%rsp)
add    $0x10,%r13
mov    %r13,0x20(%rsp)
add    $0x10,%r12
mov    %r12,0x30(%rsp)
add    $0x10,%rax
mov    %rax,-0x50(%rsp)
add    $0x10,%r14
mov    %r14,-0x40(%rsp)
add    $0x10,%rdx
mov    %rdx,-0x60(%rsp)
add    $0x10,%rsi
mov    %rsi,-0x70(%rsp)
addq   $0xffffffffffffffff,0x170(%rsp)
jne    1a00 <kern_r8_fma_o_f+0x900>
jmp    1620 <kern_r8_fma_o_f+0x520>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x218(%rsp),%rax
imul   0x138(%rsp),%rax
add    0x210(%rsp),%rax
mov    -0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    -0x18(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    -0x20(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
mov    -0x8(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
mov    0x208(%rsp),%rbx
lea    (%rcx,%rbx,1),%rbp
cmp    %rcx,%rbp
setb   %r11b
mov    -0x71(%rsp),%cl
or     %cl,%r11b
lea    (%rdx,%rbx,1),%rbp
cmp    %rdx,%rbp
mov    -0x28(%rsp),%rdx
lea    (%rdx,%rax,8),%rbp
setb   %r10b
lea    (%rsi,%rbx,1),%rdx
cmp    %rsi,%rdx
setb   %dl
lea    (%rdi,%rbx,1),%rsi
cmp    %rdi,%rsi
mov    0x2e0(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
setb   %r9b
lea    (%rbx,%rbp,1),%rdi
cmp    %rbp,%rdi
setb   %r8b
lea    (%rsi,%rbx,1),%rdi
cmp    %rsi,%rdi
mov    -0x30(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
setb   %dil
lea    (%rsi,%rbx,1),%rbp
cmp    %rsi,%rbp
mov    0x2e8(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
setb   %al
lea    (%rsi,%rbx,1),%rbp
cmp    %rsi,%rbp
setb   %sil
test   %r11b,%r11b
jne    1865 <kern_r8_fma_o_f+0x765>
or     %cl,%r10b
jne    1865 <kern_r8_fma_o_f+0x765>
or     %cl,%dl
jne    1865 <kern_r8_fma_o_f+0x765>
or     %cl,%r9b
jne    1865 <kern_r8_fma_o_f+0x765>
or     %cl,%r8b
jne    1865 <kern_r8_fma_o_f+0x765>
or     %cl,%dil
jne    1865 <kern_r8_fma_o_f+0x765>
or     %cl,%al
jne    1865 <kern_r8_fma_o_f+0x765>
or     %cl,%sil
mov    $0x0,%r9d
jne    1868 <kern_r8_fma_o_f+0x768>
movapd %xmm6,0x260(%rsp)
unpcklpd %xmm6,%xmm6
movapd %xmm6,0x30(%rsp)
movapd %xmm11,0x240(%rsp)
unpcklpd %xmm11,%xmm11
movapd %xmm11,0x20(%rsp)
movapd %xmm8,0x1c0(%rsp)
unpcklpd %xmm8,%xmm8
movapd %xmm8,0x10(%rsp)
movapd %xmm10,0x250(%rsp)
unpcklpd %xmm10,%xmm10
movapd %xmm10,(%rsp)
movaps 0x1f0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0x120(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0x160(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0x150(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x1a0(%rsp)
movaps 0x140(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0x50(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0x1e0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x170(%rsp)
movaps 0x1d0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x290(%rsp)
movapd %xmm13,0x230(%rsp)
unpcklpd %xmm13,%xmm13
movapd %xmm13,0x280(%rsp)
movapd %xmm7,0x1b0(%rsp)
unpcklpd %xmm7,%xmm7
movapd %xmm7,0x270(%rsp)
mov    0x130(%rsp),%rcx
xor    %edi,%edi
mov    0xf0(%rsp),%r15
mov    0xe8(%rsp),%r12
mov    0xe0(%rsp),%r13
mov    0xd8(%rsp),%r14
mov    0xd0(%rsp),%rbx
mov    0xc8(%rsp),%rax
mov    0xc0(%rsp),%rdx
mov    0xa8(%rsp),%rsi
mov    0xa0(%rsp),%r8
mov    0x98(%rsp),%r9
mov    0xb8(%rsp),%r10
nopl   0x0(%rax)
movupd 0x0(%r13,%rdi,1),%xmm4
movupd 0x10(%r13,%rdi,1),%xmm0
movapd %xmm4,%xmm1
unpcklpd %xmm0,%xmm1
unpckhpd %xmm0,%xmm4
movapd %xmm1,%xmm10
movapd 0x30(%rsp),%xmm5
mulpd  %xmm5,%xmm10
addpd  %xmm4,%xmm10
mulpd  %xmm5,%xmm4
subpd  %xmm1,%xmm4
movupd (%r12,%rdi,1),%xmm3
movupd 0x10(%r12,%rdi,1),%xmm1
movapd %xmm3,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm3
movapd %xmm2,%xmm8
mulpd  %xmm5,%xmm8
addpd  %xmm3,%xmm8
mulpd  %xmm5,%xmm3
subpd  %xmm2,%xmm3
movupd (%r15,%rdi,1),%xmm11
movupd 0x10(%r15,%rdi,1),%xmm1
movapd %xmm11,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm11
movapd %xmm2,%xmm6
movapd 0x20(%rsp),%xmm1
mulpd  %xmm1,%xmm6
addpd  %xmm11,%xmm6
movapd %xmm6,-0x70(%rsp)
mulpd  %xmm1,%xmm11
subpd  %xmm2,%xmm11
mov    0xf8(%rsp),%rbp
movupd 0x0(%rbp,%rdi,1),%xmm7
movupd 0x10(%rbp,%rdi,1),%xmm1
movapd %xmm7,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm7
movapd %xmm2,%xmm9
mulpd  %xmm5,%xmm9
addpd  %xmm7,%xmm9
mulpd  %xmm5,%xmm7
subpd  %xmm2,%xmm7
mov    0x100(%rsp),%rbp
movupd 0x0(%rbp,%rdi,1),%xmm2
movupd 0x10(%rbp,%rdi,1),%xmm1
movapd %xmm2,%xmm5
unpcklpd %xmm1,%xmm5
unpckhpd %xmm1,%xmm2
movapd %xmm5,%xmm1
movapd 0x10(%rsp),%xmm6
mulpd  %xmm6,%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm6,%xmm2
subpd  %xmm5,%xmm2
mov    0x108(%rsp),%rbp
movupd 0x0(%rbp,%rdi,1),%xmm6
movupd 0x10(%rbp,%rdi,1),%xmm5
movapd %xmm6,%xmm13
unpcklpd %xmm5,%xmm13
unpckhpd %xmm5,%xmm6
movapd (%rsp),%xmm5
mulpd  %xmm5,%xmm10
movapd %xmm10,%xmm0
addpd  %xmm13,%xmm0
movapd %xmm0,-0x50(%rsp)
subpd  %xmm10,%xmm13
mulpd  %xmm5,%xmm4
movapd %xmm4,%xmm15
addpd  %xmm6,%xmm15
subpd  %xmm4,%xmm6
mov    0x110(%rsp),%rbp
movupd 0x0(%rbp,%rdi,1),%xmm10
movupd 0x10(%rbp,%rdi,1),%xmm0
movapd %xmm10,%xmm12
unpcklpd %xmm0,%xmm12
unpckhpd %xmm0,%xmm10
mulpd  %xmm5,%xmm8
movapd %xmm8,%xmm0
addpd  %xmm12,%xmm0
subpd  %xmm8,%xmm12
mulpd  %xmm5,%xmm3
movapd %xmm3,%xmm8
addpd  %xmm10,%xmm8
subpd  %xmm3,%xmm10
mov    0x118(%rsp),%r11
movupd (%r11,%rdi,1),%xmm14
movupd 0x10(%r11,%rdi,1),%xmm3
movapd %xmm14,%xmm4
unpcklpd %xmm3,%xmm4
unpckhpd %xmm3,%xmm14
mulpd  %xmm5,%xmm9
movapd %xmm9,%xmm3
addpd  %xmm4,%xmm3
movapd %xmm3,-0x40(%rsp)
subpd  %xmm9,%xmm4
movapd %xmm4,-0x60(%rsp)
mulpd  %xmm5,%xmm7
movapd %xmm7,%xmm4
addpd  %xmm14,%xmm4
subpd  %xmm7,%xmm14
movapd 0x80(%rsp),%xmm3
mulpd  %xmm3,%xmm1
movapd %xmm1,%xmm5
movapd -0x70(%rsp),%xmm7
addpd  %xmm7,%xmm5
subpd  %xmm1,%xmm7
movapd %xmm7,-0x70(%rsp)
mulpd  %xmm3,%xmm2
movapd %xmm2,%xmm3
addpd  %xmm11,%xmm3
subpd  %xmm2,%xmm11
movapd -0x50(%rsp),%xmm2
movapd %xmm2,%xmm7
movapd 0x70(%rsp),%xmm1
mulpd  %xmm1,%xmm7
addpd  %xmm15,%xmm7
mulpd  %xmm1,%xmm15
subpd  %xmm2,%xmm15
movapd %xmm0,%xmm1
movapd 0x60(%rsp),%xmm2
mulpd  %xmm2,%xmm1
addpd  %xmm8,%xmm1
mulpd  %xmm2,%xmm8
subpd  %xmm0,%xmm8
movapd %xmm13,%xmm9
movapd 0x1a0(%rsp),%xmm0
mulpd  %xmm0,%xmm9
addpd  %xmm6,%xmm9
mulpd  %xmm0,%xmm6
subpd  %xmm13,%xmm6
movapd %xmm12,%xmm0
movapd 0x190(%rsp),%xmm2
mulpd  %xmm2,%xmm0
addpd  %xmm10,%xmm0
mulpd  %xmm2,%xmm10
subpd  %xmm12,%xmm10
movapd 0x180(%rsp),%xmm2
mulpd  %xmm2,%xmm5
movapd %xmm5,%xmm13
movapd -0x40(%rsp),%xmm12
addpd  %xmm12,%xmm13
subpd  %xmm5,%xmm12
movapd %xmm12,-0x40(%rsp)
mulpd  %xmm2,%xmm3
movapd %xmm3,%xmm5
addpd  %xmm4,%xmm5
subpd  %xmm3,%xmm4
movapd %xmm4,-0x50(%rsp)
mulpd  %xmm2,%xmm11
movapd %xmm11,%xmm12
movapd -0x60(%rsp),%xmm3
addpd  %xmm3,%xmm12
subpd  %xmm11,%xmm3
movapd %xmm3,-0x60(%rsp)
movapd -0x70(%rsp),%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm14,%xmm11
subpd  %xmm3,%xmm11
addpd  %xmm14,%xmm3
movapd %xmm3,-0x70(%rsp)
movapd 0x170(%rsp),%xmm2
mulpd  %xmm2,%xmm1
movapd %xmm1,%xmm3
addpd  %xmm7,%xmm3
subpd  %xmm1,%xmm7
mulpd  %xmm2,%xmm8
movapd %xmm8,%xmm1
addpd  %xmm15,%xmm1
subpd  %xmm8,%xmm15
movapd 0x290(%rsp),%xmm2
mulpd  %xmm2,%xmm0
movapd %xmm0,%xmm14
addpd  %xmm9,%xmm14
subpd  %xmm0,%xmm9
mulpd  %xmm2,%xmm10
movapd %xmm10,%xmm0
addpd  %xmm6,%xmm0
subpd  %xmm10,%xmm6
movapd 0x280(%rsp),%xmm8
mulpd  %xmm8,%xmm3
movapd %xmm3,%xmm4
addpd  %xmm13,%xmm4
mulpd  %xmm8,%xmm1
movapd %xmm1,%xmm2
addpd  %xmm5,%xmm2
movapd %xmm4,%xmm10
unpcklpd %xmm2,%xmm10
movhlps %xmm4,%xmm2
movups %xmm2,0x10(%r10,%rdi,1)
movupd %xmm10,(%r10,%rdi,1)
subpd  %xmm3,%xmm13
subpd  %xmm1,%xmm5
movapd %xmm13,%xmm1
unpcklpd %xmm5,%xmm1
movhlps %xmm13,%xmm5
movups %xmm5,0x10(%r9,%rdi,1)
movupd %xmm1,(%r9,%rdi,1)
movapd 0x270(%rsp),%xmm4
mulpd  %xmm4,%xmm14
movapd %xmm14,%xmm1
addpd  %xmm12,%xmm1
mulpd  %xmm4,%xmm0
movapd %xmm0,%xmm2
addpd  %xmm11,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm2,%xmm3
movhlps %xmm1,%xmm2
movups %xmm2,0x10(%r8,%rdi,1)
movupd %xmm3,(%r8,%rdi,1)
subpd  %xmm14,%xmm12
subpd  %xmm0,%xmm11
movapd %xmm12,%xmm0
unpcklpd %xmm11,%xmm0
movhlps %xmm12,%xmm11
movups %xmm11,0x10(%rsi,%rdi,1)
movupd %xmm0,(%rsi,%rdi,1)
mulpd  %xmm8,%xmm15
movapd %xmm15,%xmm0
movapd -0x40(%rsp),%xmm3
addpd  %xmm3,%xmm0
mulpd  %xmm8,%xmm7
movapd -0x50(%rsp),%xmm5
movapd %xmm5,%xmm1
subpd  %xmm7,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rdx,%rdi,1)
movupd %xmm2,(%rdx,%rdi,1)
movapd %xmm3,%xmm1
subpd  %xmm15,%xmm1
addpd  %xmm5,%xmm7
movapd %xmm1,%xmm0
unpcklpd %xmm7,%xmm0
movhlps %xmm1,%xmm7
movups %xmm7,0x10(%rax,%rdi,1)
movupd %xmm0,(%rax,%rdi,1)
mulpd  %xmm4,%xmm6
movapd %xmm6,%xmm0
movapd -0x60(%rsp),%xmm3
addpd  %xmm3,%xmm0
mulpd  %xmm4,%xmm9
movapd -0x70(%rsp),%xmm4
movapd %xmm4,%xmm1
subpd  %xmm9,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rbx,%rdi,1)
movupd %xmm2,(%rbx,%rdi,1)
movapd %xmm3,%xmm1
subpd  %xmm6,%xmm1
addpd  %xmm4,%xmm9
movapd %xmm1,%xmm0
unpcklpd %xmm9,%xmm0
movhlps %xmm1,%xmm9
movups %xmm9,0x10(%r14,%rdi,1)
movupd %xmm0,(%r14,%rdi,1)
add    $0x20,%rdi
add    $0xfffffffffffffffe,%rcx
jne    20c0 <kern_r8_fma_o_f+0xfc0>
mov    0x130(%rsp),%rax
mov    %rax,%r9
cmp    0x340(%rsp),%rax
movapd 0x9fd(%rip),%xmm4
movapd 0x260(%rsp),%xmm6
movapd 0x250(%rsp),%xmm10
movapd 0x240(%rsp),%xmm11
movapd 0x1c0(%rsp),%xmm8
movapd 0x230(%rsp),%xmm13
movapd 0x1b0(%rsp),%xmm7
je     1620 <kern_r8_fma_o_f+0x520>
jmp    1868 <kern_r8_fma_o_f+0x768>
add    $0x2a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0xffffffffffffffff,%rax
mov    -0x10(%rsp),%rdi
lea    0x8(%rdi),%rsi
mov    $0x10,%ecx
mul    %rcx
seto   %cl
lea    (%rdi,%rax,1),%rdx
add    $0x8,%rdx
cmp    %rsi,%rdx
jb     117b <kern_r8_fma_o_f+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_f+0x7b>
mov    -0x18(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_f+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_f+0x7b>
mov    -0x20(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_f+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_f+0x7b>
mov    -0x8(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_f+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_f+0x7b>
mov    -0x28(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_f+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_f+0x7b>
mov    0x2e0(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_f+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_f+0x7b>
mov    -0x30(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_f+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_f+0x7b>
mov    0x2e8(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rsi,%rax
add    $0x8,%rax
cmp    %rdx,%rax
jb     117b <kern_r8_fma_o_f+0x7b>
test   %cl,%cl
mov    $0x0,%r9d
jne    117e <kern_r8_fma_o_f+0x7e>
mov    0x340(%rsp),%rbp
and    $0xfffffffffffffffe,%rbp
movaps %xmm13,0x10(%rsp)
movlhps %xmm13,%xmm13
movaps %xmm13,0x20(%rsp)
xor    %eax,%eax
mov    %rbp,(%rsp)
mov    -0x18(%rsp),%r8
mov    -0x30(%rsp),%rsi
mov    -0x28(%rsp),%rdi
mov    -0x20(%rsp),%rbx
mov    -0x10(%rsp),%rcx
mov    0x320(%rsp),%r12
mov    0x310(%rsp),%r13
mov    0x308(%rsp),%r9
mov    0x300(%rsp),%r10
mov    0x2f8(%rsp),%r11
mov    0x2f0(%rsp),%r14
nopl   0x0(%rax)
movupd (%r11,%rax,1),%xmm10
movupd 0x10(%r11,%rax,1),%xmm0
movapd %xmm10,%xmm8
unpcklpd %xmm0,%xmm8
unpckhpd %xmm0,%xmm10
mov    0x318(%rsp),%rdx
movupd (%rdx,%rax,1),%xmm0
movupd 0x10(%rdx,%rax,1),%xmm1
movapd %xmm0,%xmm4
unpcklpd %xmm1,%xmm4
unpckhpd %xmm1,%xmm0
movapd %xmm8,%xmm1
addpd  %xmm4,%xmm1
movapd %xmm1,-0x60(%rsp)
subpd  %xmm4,%xmm8
movapd %xmm10,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,-0x70(%rsp)
subpd  %xmm0,%xmm10
movupd (%r9,%rax,1),%xmm6
movupd 0x10(%r9,%rax,1),%xmm0
movapd %xmm6,%xmm12
unpcklpd %xmm0,%xmm12
unpckhpd %xmm0,%xmm6
mov    0x328(%rsp),%rdx
movupd (%rdx,%rax,1),%xmm0
movupd 0x10(%rdx,%rax,1),%xmm1
movapd %xmm0,%xmm5
unpcklpd %xmm1,%xmm5
unpckhpd %xmm1,%xmm0
movapd %xmm12,%xmm1
addpd  %xmm5,%xmm1
movapd %xmm1,-0x50(%rsp)
subpd  %xmm5,%xmm12
movapd %xmm6,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,-0x40(%rsp)
subpd  %xmm0,%xmm6
movupd (%r14,%rax,1),%xmm5
movupd 0x10(%r14,%rax,1),%xmm0
movapd %xmm5,%xmm11
unpcklpd %xmm0,%xmm11
unpckhpd %xmm0,%xmm5
movupd 0x0(%r13,%rax,1),%xmm0
movupd 0x10(%r13,%rax,1),%xmm1
movapd %xmm0,%xmm7
unpcklpd %xmm1,%xmm7
unpckhpd %xmm1,%xmm0
movapd %xmm11,%xmm13
addpd  %xmm7,%xmm13
subpd  %xmm7,%xmm11
movapd %xmm5,%xmm15
addpd  %xmm0,%xmm15
subpd  %xmm0,%xmm5
movupd (%r10,%rax,1),%xmm7
movupd 0x10(%r10,%rax,1),%xmm0
movapd %xmm7,%xmm14
unpcklpd %xmm0,%xmm14
unpckhpd %xmm0,%xmm7
movupd (%r12,%rax,1),%xmm0
movupd 0x10(%r12,%rax,1),%xmm1
movapd %xmm0,%xmm3
unpcklpd %xmm1,%xmm3
unpckhpd %xmm1,%xmm0
movapd %xmm14,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm14
movapd %xmm7,%xmm3
addpd  %xmm0,%xmm3
subpd  %xmm0,%xmm7
movapd %xmm8,%xmm9
addpd  %xmm10,%xmm9
subpd  %xmm8,%xmm10
movapd %xmm6,%xmm2
subpd  %xmm12,%xmm2
xorpd  0x68d(%rip),%xmm6
subpd  %xmm12,%xmm6
movapd %xmm13,%xmm8
addpd  %xmm4,%xmm8
subpd  %xmm4,%xmm13
movapd %xmm15,%xmm12
addpd  %xmm3,%xmm12
subpd  %xmm3,%xmm15
movapd %xmm15,0x30(%rsp)
movapd %xmm11,%xmm3
addpd  %xmm7,%xmm3
subpd  %xmm7,%xmm11
movapd %xmm5,%xmm4
subpd  %xmm14,%xmm4
addpd  %xmm5,%xmm14
movapd -0x60(%rsp),%xmm0
movapd %xmm0,%xmm15
movapd -0x50(%rsp),%xmm1
addpd  %xmm1,%xmm15
subpd  %xmm1,%xmm0
movapd %xmm0,-0x60(%rsp)
movapd -0x70(%rsp),%xmm0
movapd %xmm0,%xmm1
movapd -0x40(%rsp),%xmm5
addpd  %xmm5,%xmm1
subpd  %xmm5,%xmm0
movapd %xmm0,-0x70(%rsp)
movapd %xmm9,%xmm5
addpd  %xmm2,%xmm5
subpd  %xmm2,%xmm9
movapd %xmm10,%xmm7
addpd  %xmm6,%xmm7
subpd  %xmm6,%xmm10
movapd %xmm15,%xmm2
addpd  %xmm8,%xmm2
movapd %xmm1,%xmm6
addpd  %xmm12,%xmm6
movapd %xmm2,%xmm0
unpcklpd %xmm6,%xmm0
movhlps %xmm2,%xmm6
movups %xmm6,0x10(%rcx,%rax,1)
movupd %xmm0,(%rcx,%rax,1)
subpd  %xmm15,%xmm8
subpd  %xmm1,%xmm12
movapd %xmm8,%xmm0
unpcklpd %xmm12,%xmm0
movhlps %xmm8,%xmm12
movups %xmm12,0x10(%r8,%rax,1)
movupd %xmm0,(%r8,%rax,1)
movapd 0x20(%rsp),%xmm6
mulpd  %xmm6,%xmm5
movapd %xmm5,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm6,%xmm7
movapd %xmm7,%xmm1
addpd  %xmm4,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rbx,%rax,1)
movupd %xmm2,(%rbx,%rax,1)
subpd  %xmm5,%xmm3
subpd  %xmm7,%xmm4
movapd %xmm3,%xmm0
unpcklpd %xmm4,%xmm0
movhlps %xmm3,%xmm4
mov    -0x8(%rsp),%rdx
movups %xmm4,0x10(%rdx,%rax,1)
movupd %xmm0,(%rdx,%rax,1)
movapd -0x70(%rsp),%xmm5
movapd %xmm5,%xmm0
addpd  %xmm13,%xmm0
movapd 0x30(%rsp),%xmm3
movapd %xmm3,%xmm1
movapd -0x60(%rsp),%xmm4
subpd  %xmm4,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rdi,%rax,1)
movupd %xmm2,(%rdi,%rax,1)
subpd  %xmm5,%xmm13
movapd %xmm4,%xmm1
addpd  %xmm3,%xmm1
movapd %xmm13,%xmm0
unpcklpd %xmm1,%xmm0
movhlps %xmm13,%xmm1
mov    0x2e0(%rsp),%rdx
movups %xmm1,0x10(%rdx,%rax,1)
movupd %xmm0,(%rdx,%rax,1)
mulpd  %xmm6,%xmm10
movapd %xmm10,%xmm0
addpd  %xmm11,%xmm0
mulpd  %xmm6,%xmm9
movapd %xmm14,%xmm1
subpd  %xmm9,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rsi,%rax,1)
movupd %xmm2,(%rsi,%rax,1)
subpd  %xmm10,%xmm11
addpd  %xmm14,%xmm9
movapd %xmm11,%xmm0
unpcklpd %xmm9,%xmm0
movhlps %xmm11,%xmm9
mov    0x2e8(%rsp),%r15
movups %xmm9,0x10(%r15,%rax,1)
movupd %xmm0,(%r15,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rbp
jne    27f0 <kern_r8_fma_o_f+0x16f0>
mov    (%rsp),%r9
cmp    0x340(%rsp),%r9
movaps 0x10(%rsp),%xmm13
jne    117e <kern_r8_fma_o_f+0x7e>
jmp    14b1 <kern_r8_fma_o_f+0x3b1>

LLVM IR (-O0):
define void @kern_r8_fma_o_f(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
%107 = alloca double
%108 = alloca double
%109 = alloca double
%110 = alloca double
%111 = alloca double
%112 = alloca double
%113 = alloca double
%114 = alloca double
%115 = alloca double
%116 = alloca double
%117 = alloca double
%118 = alloca double
%119 = alloca double
%120 = alloca double
%121 = alloca double
%122 = alloca double
%123 = alloca double
%124 = alloca double
%125 = alloca double
%126 = alloca double
%127 = alloca double
%128 = alloca double
%129 = alloca double
%130 = alloca double
%131 = alloca double
%132 = alloca double
%133 = alloca double
%134 = alloca double
%135 = alloca double
%136 = alloca double
%137 = alloca double
%138 = alloca double
%139 = alloca double
%140 = alloca double
%141 = alloca double
%142 = alloca double
%143 = 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
%144 = load double*, double** %37
%145 = load i64, i64* %40
%146 = mul nsw i64 2, %145
%147 = load i64, i64* %39
%148 = mul nsw i64 %146, %147
%149 = add nsw i64 %148, 1
%150 = getelementptr inbounds double, double* %144, i64 %149
%151 = load double, double* %150
store double %151, double* %43
store i64 0, i64* %42
br label %152
152: ; preds = %543, %20
%153 = load i64, i64* %42
%154 = load i64, i64* %39
%155 = icmp slt i64 %153, %154
br i1 %155, label %156, label %546
156: ; preds = %152
%157 = load double*, double** %30
%158 = load i64, i64* %42
%159 = mul nsw i64 2, %158
%160 = getelementptr inbounds double, double* %157, i64 %159
%161 = load double, double* %160
%162 = load double*, double** %34
%163 = load i64, i64* %42
%164 = mul nsw i64 2, %163
%165 = getelementptr inbounds double, double* %162, i64 %164
%166 = load double, double* %165
%167 = fadd double %161, %166
store double %167, double* %50
%168 = load double*, double** %30
%169 = load i64, i64* %42
%170 = mul nsw i64 2, %169
%171 = getelementptr inbounds double, double* %168, i64 %170
%172 = load double, double* %171
%173 = load double*, double** %34
%174 = load i64, i64* %42
%175 = mul nsw i64 2, %174
%176 = getelementptr inbounds double, double* %173, i64 %175
%177 = load double, double* %176
%178 = fsub double %172, %177
store double %178, double* %44
%179 = load double*, double** %30
%180 = load i64, i64* %42
%181 = mul nsw i64 2, %180
%182 = add nsw i64 %181, 1
%183 = getelementptr inbounds double, double* %179, i64 %182
%184 = load double, double* %183
%185 = load double*, double** %34
%186 = load i64, i64* %42
%187 = mul nsw i64 2, %186
%188 = add nsw i64 %187, 1
%189 = getelementptr inbounds double, double* %185, i64 %188
%190 = load double, double* %189
%191 = fadd double %184, %190
store double %191, double* %51
%192 = load double*, double** %30
%193 = load i64, i64* %42
%194 = mul nsw i64 2, %193
%195 = add nsw i64 %194, 1
%196 = getelementptr inbounds double, double* %192, i64 %195
%197 = load double, double* %196
%198 = load double*, double** %34
%199 = load i64, i64* %42
%200 = mul nsw i64 2, %199
%201 = add nsw i64 %200, 1
%202 = getelementptr inbounds double, double* %198, i64 %201
%203 = load double, double* %202
%204 = fsub double %197, %203
store double %204, double* %45
%205 = load double*, double** %32
%206 = load i64, i64* %42
%207 = mul nsw i64 2, %206
%208 = getelementptr inbounds double, double* %205, i64 %207
%209 = load double, double* %208
%210 = load double*, double** %36
%211 = load i64, i64* %42
%212 = mul nsw i64 2, %211
%213 = getelementptr inbounds double, double* %210, i64 %212
%214 = load double, double* %213
%215 = fadd double %209, %214
store double %215, double* %54
%216 = load double*, double** %32
%217 = load i64, i64* %42
%218 = mul nsw i64 2, %217
%219 = getelementptr inbounds double, double* %216, i64 %218
%220 = load double, double* %219
%221 = load double*, double** %36
%222 = load i64, i64* %42
%223 = mul nsw i64 2, %222
%224 = getelementptr inbounds double, double* %221, i64 %223
%225 = load double, double* %224
%226 = fsub double %220, %225
store double %226, double* %46
%227 = load double*, double** %32
%228 = load i64, i64* %42
%229 = mul nsw i64 2, %228
%230 = add nsw i64 %229, 1
%231 = getelementptr inbounds double, double* %227, i64 %230
%232 = load double, double* %231
%233 = load double*, double** %36
%234 = load i64, i64* %42
%235 = mul nsw i64 2, %234
%236 = add nsw i64 %235, 1
%237 = getelementptr inbounds double, double* %233, i64 %236
%238 = load double, double* %237
%239 = fadd double %232, %238
store double %239, double* %55
%240 = load double*, double** %32
%241 = load i64, i64* %42
%242 = mul nsw i64 2, %241
%243 = add nsw i64 %242, 1
%244 = getelementptr inbounds double, double* %240, i64 %243
%245 = load double, double* %244
%246 = load double*, double** %36
%247 = load i64, i64* %42
%248 = mul nsw i64 2, %247
%249 = add nsw i64 %248, 1
%250 = getelementptr inbounds double, double* %246, i64 %249
%251 = load double, double* %250
%252 = fsub double %245, %251
store double %252, double* %47
%253 = load double*, double** %29
%254 = load i64, i64* %42
%255 = mul nsw i64 2, %254
%256 = getelementptr inbounds double, double* %253, i64 %255
%257 = load double, double* %256
%258 = load double*, double** %33
%259 = load i64, i64* %42
%260 = mul nsw i64 2, %259
%261 = getelementptr inbounds double, double* %258, i64 %260
%262 = load double, double* %261
%263 = fadd double %257, %262
store double %263, double* %48
%264 = load double*, double** %29
%265 = load i64, i64* %42
%266 = mul nsw i64 2, %265
%267 = getelementptr inbounds double, double* %264, i64 %266
%268 = load double, double* %267
%269 = load double*, double** %33
%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 = fsub double %268, %273
store double %274, double* %56
%275 = load double*, double** %29
%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 = load double*, double** %33
%282 = load i64, i64* %42
%283 = mul nsw i64 2, %282
%284 = add nsw i64 %283, 1
%285 = getelementptr inbounds double, double* %281, i64 %284
%286 = load double, double* %285
%287 = fadd double %280, %286
store double %287, double* %49
%288 = load double*, double** %29
%289 = load i64, i64* %42
%290 = mul nsw i64 2, %289
%291 = add nsw i64 %290, 1
%292 = getelementptr inbounds double, double* %288, i64 %291
%293 = load double, double* %292
%294 = load double*, double** %33
%295 = load i64, i64* %42
%296 = mul nsw i64 2, %295
%297 = add nsw i64 %296, 1
%298 = getelementptr inbounds double, double* %294, i64 %297
%299 = load double, double* %298
%300 = fsub double %293, %299
store double %300, double* %57
%301 = load double*, double** %31
%302 = load i64, i64* %42
%303 = mul nsw i64 2, %302
%304 = getelementptr inbounds double, double* %301, i64 %303
%305 = load double, double* %304
%306 = load double*, double** %35
%307 = load i64, i64* %42
%308 = mul nsw i64 2, %307
%309 = getelementptr inbounds double, double* %306, i64 %308
%310 = load double, double* %309
%311 = fadd double %305, %310
store double %311, double* %52
%312 = load double*, double** %31
%313 = load i64, i64* %42
%314 = mul nsw i64 2, %313
%315 = getelementptr inbounds double, double* %312, i64 %314
%316 = load double, double* %315
%317 = load double*, double** %35
%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 = fsub double %316, %321
store double %322, double* %60
%323 = load double*, double** %31
%324 = load i64, i64* %42
%325 = mul nsw i64 2, %324
%326 = add nsw i64 %325, 1
%327 = getelementptr inbounds double, double* %323, i64 %326
%328 = load double, double* %327
%329 = load double*, double** %35
%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 = fadd double %328, %334
store double %335, double* %53
%336 = load double*, double** %31
%337 = load i64, i64* %42
%338 = mul nsw i64 2, %337
%339 = add nsw i64 %338, 1
%340 = getelementptr inbounds double, double* %336, i64 %339
%341 = load double, double* %340
%342 = load double*, double** %35
%343 = load i64, i64* %42
%344 = mul nsw i64 2, %343
%345 = add nsw i64 %344, 1
%346 = getelementptr inbounds double, double* %342, i64 %345
%347 = load double, double* %346
%348 = fsub double %341, %347
store double %348, double* %61
%349 = load double, double* %44
%350 = load double, double* %45
%351 = fadd double %349, %350
store double %351, double* %58
%352 = load double, double* %45
%353 = load double, double* %44
%354 = fsub double %352, %353
store double %354, double* %59
%355 = load double, double* %46
%356 = fneg double %355
%357 = load double, double* %47
%358 = fadd double %356, %357
store double %358, double* %62
%359 = load double, double* %47
%360 = fneg double %359
%361 = load double, double* %46
%362 = fsub double %360, %361
store double %362, double* %63
%363 = load double, double* %48
%364 = load double, double* %52
%365 = fadd double %363, %364
store double %365, double* %64
%366 = load double, double* %49
%367 = load double, double* %53
%368 = fadd double %366, %367
store double %368, double* %65
%369 = load double, double* %48
%370 = load double, double* %52
%371 = fsub double %369, %370
store double %371, double* %68
%372 = load double, double* %49
%373 = load double, double* %53
%374 = fsub double %372, %373
store double %374, double* %69
%375 = load double, double* %56
%376 = load double, double* %61
%377 = fadd double %375, %376
store double %377, double* %72
%378 = load double, double* %57
%379 = load double, double* %60
%380 = fsub double %378, %379
store double %380, double* %73
%381 = load double, double* %56
%382 = load double, double* %61
%383 = fsub double %381, %382
store double %383, double* %76
%384 = load double, double* %57
%385 = load double, double* %60
%386 = fadd double %384, %385
store double %386, double* %77
%387 = load double, double* %50
%388 = load double, double* %54
%389 = fadd double %387, %388
store double %389, double* %66
%390 = load double, double* %51
%391 = load double, double* %55
%392 = fadd double %390, %391
store double %392, double* %67
%393 = load double, double* %50
%394 = load double, double* %54
%395 = fsub double %393, %394
store double %395, double* %70
%396 = load double, double* %51
%397 = load double, double* %55
%398 = fsub double %396, %397
store double %398, double* %71
%399 = load double, double* %58
%400 = load double, double* %62
%401 = fadd double %399, %400
store double %401, double* %74
%402 = load double, double* %59
%403 = load double, double* %63
%404 = fadd double %402, %403
store double %404, double* %75
%405 = load double, double* %58
%406 = load double, double* %62
%407 = fsub double %405, %406
store double %407, double* %78
%408 = load double, double* %59
%409 = load double, double* %63
%410 = fsub double %408, %409
store double %410, double* %79
%411 = load double, double* %64
%412 = load double, double* %66
%413 = fadd double %411, %412
%414 = load double*, double** %21
%415 = load i64, i64* %42
%416 = mul nsw i64 2, %415
%417 = getelementptr inbounds double, double* %414, i64 %416
store double %413, double* %417
%418 = load double, double* %65
%419 = load double, double* %67
%420 = fadd double %418, %419
%421 = load double*, double** %21
%422 = load i64, i64* %42
%423 = mul nsw i64 2, %422
%424 = add nsw i64 %423, 1
%425 = getelementptr inbounds double, double* %421, i64 %424
store double %420, double* %425
%426 = load double, double* %64
%427 = load double, double* %66
%428 = fsub double %426, %427
%429 = load double*, double** %25
%430 = load i64, i64* %42
%431 = mul nsw i64 2, %430
%432 = getelementptr inbounds double, double* %429, i64 %431
store double %428, double* %432
%433 = load double, double* %65
%434 = load double, double* %67
%435 = fsub double %433, %434
%436 = load double*, double** %25
%437 = load i64, i64* %42
%438 = mul nsw i64 2, %437
%439 = add nsw i64 %438, 1
%440 = getelementptr inbounds double, double* %436, i64 %439
store double %435, double* %440
%441 = load double, double* %72
%442 = load double, double* %74
%443 = load double, double* %43
%444 = call double @llvm.fmuladd.f64(double %442, double %443, double %441)
%445 = load double*, double** %22
%446 = load i64, i64* %42
%447 = mul nsw i64 2, %446
%448 = getelementptr inbounds double, double* %445, i64 %447
store double %444, double* %448
%449 = load double, double* %73
%450 = load double, double* %75
%451 = load double, double* %43
%452 = call double @llvm.fmuladd.f64(double %450, double %451, double %449)
%453 = load double*, double** %22
%454 = load i64, i64* %42
%455 = mul nsw i64 2, %454
%456 = add nsw i64 %455, 1
%457 = getelementptr inbounds double, double* %453, i64 %456
store double %452, double* %457
%458 = load double, double* %72
%459 = load double, double* %74
%460 = load double, double* %43
%461 = fneg double %459
%462 = call double @llvm.fmuladd.f64(double %461, double %460, double %458)
%463 = load double*, double** %26
%464 = load i64, i64* %42
%465 = mul nsw i64 2, %464
%466 = getelementptr inbounds double, double* %463, i64 %465
store double %462, double* %466
%467 = load double, double* %73
%468 = load double, double* %75
%469 = load double, double* %43
%470 = fneg double %468
%471 = call double @llvm.fmuladd.f64(double %470, double %469, double %467)
%472 = load double*, double** %26
%473 = load i64, i64* %42
%474 = mul nsw i64 2, %473
%475 = add nsw i64 %474, 1
%476 = getelementptr inbounds double, double* %472, i64 %475
store double %471, double* %476
%477 = load double, double* %68
%478 = load double, double* %71
%479 = fadd double %477, %478
%480 = load double*, double** %23
%481 = load i64, i64* %42
%482 = mul nsw i64 2, %481
%483 = getelementptr inbounds double, double* %480, i64 %482
store double %479, double* %483
%484 = load double, double* %69
%485 = load double, double* %70
%486 = fsub double %484, %485
%487 = load double*, double** %23
%488 = load i64, i64* %42
%489 = mul nsw i64 2, %488
%490 = add nsw i64 %489, 1
%491 = getelementptr inbounds double, double* %487, i64 %490
store double %486, double* %491
%492 = load double, double* %68
%493 = load double, double* %71
%494 = fsub double %492, %493
%495 = load double*, double** %27
%496 = load i64, i64* %42
%497 = mul nsw i64 2, %496
%498 = getelementptr inbounds double, double* %495, i64 %497
store double %494, double* %498
%499 = load double, double* %69
%500 = load double, double* %70
%501 = fadd double %499, %500
%502 = load double*, double** %27
%503 = load i64, i64* %42
%504 = mul nsw i64 2, %503
%505 = add nsw i64 %504, 1
%506 = getelementptr inbounds double, double* %502, i64 %505
store double %501, double* %506
%507 = load double, double* %76
%508 = load double, double* %79
%509 = load double, double* %43
%510 = call double @llvm.fmuladd.f64(double %508, double %509, double %507)
%511 = load double*, double** %24
%512 = load i64, i64* %42
%513 = mul nsw i64 2, %512
%514 = getelementptr inbounds double, double* %511, i64 %513
store double %510, double* %514
%515 = load double, double* %77
%516 = load double, double* %78
%517 = load double, double* %43
%518 = fneg double %516
%519 = call double @llvm.fmuladd.f64(double %518, double %517, double %515)
%520 = load double*, double** %24
%521 = load i64, i64* %42
%522 = mul nsw i64 2, %521
%523 = add nsw i64 %522, 1
%524 = getelementptr inbounds double, double* %520, i64 %523
store double %519, double* %524
%525 = load double, double* %76
%526 = load double, double* %79
%527 = load double, double* %43
%528 = fneg double %526
%529 = call double @llvm.fmuladd.f64(double %528, double %527, double %525)
%530 = load double*, double** %28
%531 = load i64, i64* %42
%532 = mul nsw i64 2, %531
%533 = getelementptr inbounds double, double* %530, i64 %532
store double %529, double* %533
%534 = load double, double* %77
%535 = load double, double* %78
%536 = load double, double* %43
%537 = call double @llvm.fmuladd.f64(double %535, double %536, double %534)
%538 = load double*, double** %28
%539 = load i64, i64* %42
%540 = mul nsw i64 2, %539
%541 = add nsw i64 %540, 1
%542 = getelementptr inbounds double, double* %538, i64 %541
store double %537, double* %542
br label %543
543: ; preds = %156
%544 = load i64, i64* %42
%545 = add nsw i64 %544, 1
store i64 %545, i64* %42
br label %152
546: ; preds = %152
%547 = load i64, i64* %39
%548 = mul nsw i64 16, %547
%549 = load double*, double** %29
%550 = getelementptr inbounds double, double* %549, i64 %548
store double* %550, double** %29
%551 = load i64, i64* %39
%552 = mul nsw i64 16, %551
%553 = load double*, double** %30
%554 = getelementptr inbounds double, double* %553, i64 %552
store double* %554, double** %30
%555 = load i64, i64* %39
%556 = mul nsw i64 16, %555
%557 = load double*, double** %31
%558 = getelementptr inbounds double, double* %557, i64 %556
store double* %558, double** %31
%559 = load i64, i64* %39
%560 = mul nsw i64 16, %559
%561 = load double*, double** %32
%562 = getelementptr inbounds double, double* %561, i64 %560
store double* %562, double** %32
%563 = load i64, i64* %39
%564 = mul nsw i64 16, %563
%565 = load double*, double** %33
%566 = getelementptr inbounds double, double* %565, i64 %564
store double* %566, double** %33
%567 = load i64, i64* %39
%568 = mul nsw i64 16, %567
%569 = load double*, double** %34
%570 = getelementptr inbounds double, double* %569, i64 %568
store double* %570, double** %34
%571 = load i64, i64* %39
%572 = mul nsw i64 16, %571
%573 = load double*, double** %35
%574 = getelementptr inbounds double, double* %573, i64 %572
store double* %574, double** %35
%575 = load i64, i64* %39
%576 = mul nsw i64 16, %575
%577 = load double*, double** %36
%578 = getelementptr inbounds double, double* %577, i64 %576
store double* %578, double** %36
%579 = load i64, i64* %39
%580 = mul nsw i64 2, %579
%581 = load double*, double** %21
%582 = getelementptr inbounds double, double* %581, i64 %580
store double* %582, double** %21
%583 = load i64, i64* %39
%584 = mul nsw i64 2, %583
%585 = load double*, double** %22
%586 = getelementptr inbounds double, double* %585, i64 %584
store double* %586, double** %22
%587 = load i64, i64* %39
%588 = mul nsw i64 2, %587
%589 = load double*, double** %23
%590 = getelementptr inbounds double, double* %589, i64 %588
store double* %590, double** %23
%591 = load i64, i64* %39
%592 = mul nsw i64 2, %591
%593 = load double*, double** %24
%594 = getelementptr inbounds double, double* %593, i64 %592
store double* %594, double** %24
%595 = load i64, i64* %39
%596 = mul nsw i64 2, %595
%597 = load double*, double** %25
%598 = getelementptr inbounds double, double* %597, i64 %596
store double* %598, double** %25
%599 = load i64, i64* %39
%600 = mul nsw i64 2, %599
%601 = load double*, double** %26
%602 = getelementptr inbounds double, double* %601, i64 %600
store double* %602, double** %26
%603 = load i64, i64* %39
%604 = mul nsw i64 2, %603
%605 = load double*, double** %27
%606 = getelementptr inbounds double, double* %605, i64 %604
store double* %606, double** %27
%607 = load i64, i64* %39
%608 = mul nsw i64 2, %607
%609 = load double*, double** %28
%610 = getelementptr inbounds double, double* %609, i64 %608
store double* %610, double** %28
store i64 1, i64* %41
br label %611
611: ; preds = %1327, %546
%612 = load i64, i64* %41
%613 = load i64, i64* %40
%614 = icmp slt i64 %612, %613
br i1 %614, label %615, label %1330
615: ; preds = %611
%616 = load double*, double** %37
%617 = load i64, i64* %41
%618 = mul nsw i64 8, %617
%619 = load i64, i64* %39
%620 = mul nsw i64 %618, %619
%621 = getelementptr inbounds double, double* %616, i64 %620
%622 = load double, double* %621
store double %622, double* %86
%623 = load double*, double** %37
%624 = load i64, i64* %41
%625 = mul nsw i64 8, %624
%626 = load i64, i64* %39
%627 = mul nsw i64 %625, %626
%628 = add nsw i64 %627, 1
%629 = getelementptr inbounds double, double* %623, i64 %628
%630 = load double, double* %629
store double %630, double* %87
%631 = load double*, double** %37
%632 = load i64, i64* %41
%633 = mul nsw i64 4, %632
%634 = load i64, i64* %39
%635 = mul nsw i64 %633, %634
%636 = getelementptr inbounds double, double* %631, i64 %635
%637 = load double, double* %636
store double %637, double* %82
%638 = load double*, double** %37
%639 = load i64, i64* %41
%640 = mul nsw i64 4, %639
%641 = load i64, i64* %39
%642 = mul nsw i64 %640, %641
%643 = add nsw i64 %642, 1
%644 = getelementptr inbounds double, double* %638, i64 %643
%645 = load double, double* %644
store double %645, double* %83
%646 = load double*, double** %38
%647 = load i64, i64* %41
%648 = mul nsw i64 4, %647
%649 = load i64, i64* %39
%650 = mul nsw i64 %648, %649
%651 = getelementptr inbounds double, double* %646, i64 %650
%652 = load double, double* %651
store double %652, double* %90
%653 = load double*, double** %38
%654 = load i64, i64* %41
%655 = mul nsw i64 4, %654
%656 = load i64, i64* %39
%657 = mul nsw i64 %655, %656
%658 = add nsw i64 %657, 1
%659 = getelementptr inbounds double, double* %653, i64 %658
%660 = load double, double* %659
store double %660, double* %91
%661 = load double*, double** %37
%662 = load i64, i64* %41
%663 = mul nsw i64 2, %662
%664 = load i64, i64* %39
%665 = mul nsw i64 %663, %664
%666 = getelementptr inbounds double, double* %661, i64 %665
%667 = load double, double* %666
store double %667, double* %80
%668 = load double*, double** %37
%669 = load i64, i64* %41
%670 = mul nsw i64 2, %669
%671 = load i64, i64* %39
%672 = mul nsw i64 %670, %671
%673 = add nsw i64 %672, 1
%674 = getelementptr inbounds double, double* %668, i64 %673
%675 = load double, double* %674
store double %675, double* %81
%676 = load double*, double** %38
%677 = load i64, i64* %41
%678 = mul nsw i64 2, %677
%679 = load i64, i64* %39
%680 = mul nsw i64 %678, %679
%681 = getelementptr inbounds double, double* %676, i64 %680
%682 = load double, double* %681
store double %682, double* %84
%683 = load double*, double** %38
%684 = load i64, i64* %41
%685 = mul nsw i64 2, %684
%686 = load i64, i64* %39
%687 = mul nsw i64 %685, %686
%688 = add nsw i64 %687, 1
%689 = getelementptr inbounds double, double* %683, i64 %688
%690 = load double, double* %689
store double %690, double* %85
%691 = load double*, double** %37
%692 = load i64, i64* %41
%693 = mul nsw i64 2, %692
%694 = load i64, i64* %39
%695 = mul nsw i64 %693, %694
%696 = load i64, i64* %40
%697 = mul nsw i64 2, %696
%698 = load i64, i64* %39
%699 = mul nsw i64 %697, %698
%700 = add nsw i64 %695, %699
%701 = getelementptr inbounds double, double* %691, i64 %700
%702 = load double, double* %701
store double %702, double* %88
%703 = load double*, double** %37
%704 = load i64, i64* %41
%705 = mul nsw i64 2, %704
%706 = load i64, i64* %39
%707 = mul nsw i64 %705, %706
%708 = load i64, i64* %40
%709 = mul nsw i64 2, %708
%710 = load i64, i64* %39
%711 = mul nsw i64 %709, %710
%712 = add nsw i64 %707, %711
%713 = add nsw i64 %712, 1
%714 = getelementptr inbounds double, double* %703, i64 %713
%715 = load double, double* %714
store double %715, double* %89
%716 = load double*, double** %38
%717 = load i64, i64* %41
%718 = mul nsw i64 2, %717
%719 = load i64, i64* %39
%720 = mul nsw i64 %718, %719
%721 = load i64, i64* %40
%722 = mul nsw i64 2, %721
%723 = load i64, i64* %39
%724 = mul nsw i64 %722, %723
%725 = add nsw i64 %720, %724
%726 = getelementptr inbounds double, double* %716, i64 %725
%727 = load double, double* %726
store double %727, double* %92
%728 = load double*, double** %38
%729 = load i64, i64* %41
%730 = mul nsw i64 2, %729
%731 = load i64, i64* %39
%732 = mul nsw i64 %730, %731
%733 = load i64, i64* %40
%734 = mul nsw i64 2, %733
%735 = load i64, i64* %39
%736 = mul nsw i64 %734, %735
%737 = add nsw i64 %732, %736
%738 = add nsw i64 %737, 1
%739 = getelementptr inbounds double, double* %728, i64 %738
%740 = load double, double* %739
store double %740, double* %93
store i64 0, i64* %42
br label %741
741: ; preds = %1259, %615
%742 = load i64, i64* %42
%743 = load i64, i64* %39
%744 = icmp slt i64 %742, %743
br i1 %744, label %745, label %1262
745: ; preds = %741
%746 = load double*, double** %34
%747 = load i64, i64* %42
%748 = mul nsw i64 2, %747
%749 = getelementptr inbounds double, double* %746, i64 %748
%750 = load double, double* %749
%751 = load double, double* %86
%752 = load double*, double** %34
%753 = load i64, i64* %42
%754 = mul nsw i64 2, %753
%755 = add nsw i64 %754, 1
%756 = getelementptr inbounds double, double* %752, i64 %755
%757 = load double, double* %756
%758 = call double @llvm.fmuladd.f64(double %750, double %751, double %757)
store double %758, double* %98
%759 = load double*, double** %34
%760 = load i64, i64* %42
%761 = mul nsw i64 2, %760
%762 = add nsw i64 %761, 1
%763 = getelementptr inbounds double, double* %759, i64 %762
%764 = load double, double* %763
%765 = load double, double* %86
%766 = load double*, double** %34
%767 = load i64, i64* %42
%768 = mul nsw i64 2, %767
%769 = getelementptr inbounds double, double* %766, i64 %768
%770 = load double, double* %769
%771 = fneg double %770
%772 = call double @llvm.fmuladd.f64(double %764, double %765, double %771)
store double %772, double* %99
%773 = load double*, double** %36
%774 = load i64, i64* %42
%775 = mul nsw i64 2, %774
%776 = getelementptr inbounds double, double* %773, i64 %775
%777 = load double, double* %776
%778 = load double, double* %86
%779 = load double*, double** %36
%780 = load i64, i64* %42
%781 = mul nsw i64 2, %780
%782 = add nsw i64 %781, 1
%783 = getelementptr inbounds double, double* %779, i64 %782
%784 = load double, double* %783
%785 = call double @llvm.fmuladd.f64(double %777, double %778, double %784)
store double %785, double* %102
%786 = load double*, double** %36
%787 = load i64, i64* %42
%788 = mul nsw i64 2, %787
%789 = add nsw i64 %788, 1
%790 = getelementptr inbounds double, double* %786, i64 %789
%791 = load double, double* %790
%792 = load double, double* %86
%793 = load double*, double** %36
%794 = load i64, i64* %42
%795 = mul nsw i64 2, %794
%796 = getelementptr inbounds double, double* %793, i64 %795
%797 = load double, double* %796
%798 = fneg double %797
%799 = call double @llvm.fmuladd.f64(double %791, double %792, double %798)
store double %799, double* %103
%800 = load double*, double** %31
%801 = load i64, i64* %42
%802 = mul nsw i64 2, %801
%803 = getelementptr inbounds double, double* %800, i64 %802
%804 = load double, double* %803
%805 = load double, double* %82
%806 = load double*, double** %31
%807 = load i64, i64* %42
%808 = mul nsw i64 2, %807
%809 = add nsw i64 %808, 1
%810 = getelementptr inbounds double, double* %806, i64 %809
%811 = load double, double* %810
%812 = call double @llvm.fmuladd.f64(double %804, double %805, double %811)
store double %812, double* %94
%813 = load double*, double** %31
%814 = load i64, i64* %42
%815 = mul nsw i64 2, %814
%816 = add nsw i64 %815, 1
%817 = getelementptr inbounds double, double* %813, i64 %816
%818 = load double, double* %817
%819 = load double, double* %82
%820 = load double*, double** %31
%821 = load i64, i64* %42
%822 = mul nsw i64 2, %821
%823 = getelementptr inbounds double, double* %820, i64 %822
%824 = load double, double* %823
%825 = fneg double %824
%826 = call double @llvm.fmuladd.f64(double %818, double %819, double %825)
store double %826, double* %95
%827 = load double*, double** %33
%828 = load i64, i64* %42
%829 = mul nsw i64 2, %828
%830 = getelementptr inbounds double, double* %827, i64 %829
%831 = load double, double* %830
%832 = load double, double* %86
%833 = load double*, double** %33
%834 = load i64, i64* %42
%835 = mul nsw i64 2, %834
%836 = add nsw i64 %835, 1
%837 = getelementptr inbounds double, double* %833, i64 %836
%838 = load double, double* %837
%839 = call double @llvm.fmuladd.f64(double %831, double %832, double %838)
store double %839, double* %96
%840 = load double*, double** %33
%841 = load i64, i64* %42
%842 = mul nsw i64 2, %841
%843 = add nsw i64 %842, 1
%844 = getelementptr inbounds double, double* %840, i64 %843
%845 = load double, double* %844
%846 = load double, double* %86
%847 = load double*, double** %33
%848 = load i64, i64* %42
%849 = mul nsw i64 2, %848
%850 = getelementptr inbounds double, double* %847, i64 %849
%851 = load double, double* %850
%852 = fneg double %851
%853 = call double @llvm.fmuladd.f64(double %845, double %846, double %852)
store double %853, double* %97
%854 = load double*, double** %35
%855 = load i64, i64* %42
%856 = mul nsw i64 2, %855
%857 = getelementptr inbounds double, double* %854, i64 %856
%858 = load double, double* %857
%859 = load double, double* %90
%860 = load double*, double** %35
%861 = load i64, i64* %42
%862 = mul nsw i64 2, %861
%863 = add nsw i64 %862, 1
%864 = getelementptr inbounds double, double* %860, i64 %863
%865 = load double, double* %864
%866 = call double @llvm.fmuladd.f64(double %858, double %859, double %865)
store double %866, double* %100
%867 = load double*, double** %35
%868 = load i64, i64* %42
%869 = mul nsw i64 2, %868
%870 = add nsw i64 %869, 1
%871 = getelementptr inbounds double, double* %867, i64 %870
%872 = load double, double* %871
%873 = load double, double* %90
%874 = load double*, double** %35
%875 = load i64, i64* %42
%876 = mul nsw i64 2, %875
%877 = getelementptr inbounds double, double* %874, i64 %876
%878 = load double, double* %877
%879 = fneg double %878
%880 = call double @llvm.fmuladd.f64(double %872, double %873, double %879)
store double %880, double* %101
%881 = load double*, double** %30
%882 = load i64, i64* %42
%883 = mul nsw i64 2, %882
%884 = getelementptr inbounds double, double* %881, i64 %883
%885 = load double, double* %884
%886 = load double, double* %98
%887 = load double, double* %87
%888 = call double @llvm.fmuladd.f64(double %886, double %887, double %885)
store double %888, double* %104
%889 = load double*, double** %30
%890 = load i64, i64* %42
%891 = mul nsw i64 2, %890
%892 = getelementptr inbounds double, double* %889, i64 %891
%893 = load double, double* %892
%894 = load double, double* %98
%895 = load double, double* %87
%896 = fneg double %894
%897 = call double @llvm.fmuladd.f64(double %896, double %895, double %893)
store double %897, double* %108
%898 = load double*, double** %30
%899 = load i64, i64* %42
%900 = mul nsw i64 2, %899
%901 = add nsw i64 %900, 1
%902 = getelementptr inbounds double, double* %898, i64 %901
%903 = load double, double* %902
%904 = load double, double* %99
%905 = load double, double* %87
%906 = call double @llvm.fmuladd.f64(double %904, double %905, double %903)
store double %906, double* %105
%907 = load double*, double** %30
%908 = load i64, i64* %42
%909 = mul nsw i64 2, %908
%910 = add nsw i64 %909, 1
%911 = getelementptr inbounds double, double* %907, i64 %910
%912 = load double, double* %911
%913 = load double, double* %99
%914 = load double, double* %87
%915 = fneg double %913
%916 = call double @llvm.fmuladd.f64(double %915, double %914, double %912)
store double %916, double* %109
%917 = load double*, double** %32
%918 = load i64, i64* %42
%919 = mul nsw i64 2, %918
%920 = getelementptr inbounds double, double* %917, i64 %919
%921 = load double, double* %920
%922 = load double, double* %102
%923 = load double, double* %87
%924 = call double @llvm.fmuladd.f64(double %922, double %923, double %921)
store double %924, double* %106
%925 = load double*, double** %32
%926 = load i64, i64* %42
%927 = mul nsw i64 2, %926
%928 = getelementptr inbounds double, double* %925, i64 %927
%929 = load double, double* %928
%930 = load double, double* %102
%931 = load double, double* %87
%932 = fneg double %930
%933 = call double @llvm.fmuladd.f64(double %932, double %931, double %929)
store double %933, double* %110
%934 = load double*, double** %32
%935 = load i64, i64* %42
%936 = mul nsw i64 2, %935
%937 = add nsw i64 %936, 1
%938 = getelementptr inbounds double, double* %934, i64 %937
%939 = load double, double* %938
%940 = load double, double* %103
%941 = load double, double* %87
%942 = call double @llvm.fmuladd.f64(double %940, double %941, double %939)
store double %942, double* %107
%943 = load double*, double** %32
%944 = load i64, i64* %42
%945 = mul nsw i64 2, %944
%946 = add nsw i64 %945, 1
%947 = getelementptr inbounds double, double* %943, i64 %946
%948 = load double, double* %947
%949 = load double, double* %103
%950 = load double, double* %87
%951 = fneg double %949
%952 = call double @llvm.fmuladd.f64(double %951, double %950, double %948)
store double %952, double* %111
%953 = load double*, double** %29
%954 = load i64, i64* %42
%955 = mul nsw i64 2, %954
%956 = getelementptr inbounds double, double* %953, i64 %955
%957 = load double, double* %956
%958 = load double, double* %96
%959 = load double, double* %87
%960 = call double @llvm.fmuladd.f64(double %958, double %959, double %957)
store double %960, double* %112
%961 = load double*, double** %29
%962 = load i64, i64* %42
%963 = mul nsw i64 2, %962
%964 = getelementptr inbounds double, double* %961, i64 %963
%965 = load double, double* %964
%966 = load double, double* %96
%967 = load double, double* %87
%968 = fneg double %966
%969 = call double @llvm.fmuladd.f64(double %968, double %967, double %965)
store double %969, double* %120
%970 = load double*, double** %29
%971 = load i64, i64* %42
%972 = mul nsw i64 2, %971
%973 = add nsw i64 %972, 1
%974 = getelementptr inbounds double, double* %970, i64 %973
%975 = load double, double* %974
%976 = load double, double* %97
%977 = load double, double* %87
%978 = call double @llvm.fmuladd.f64(double %976, double %977, double %975)
store double %978, double* %113
%979 = load double*, double** %29
%980 = load i64, i64* %42
%981 = mul nsw i64 2, %980
%982 = add nsw i64 %981, 1
%983 = getelementptr inbounds double, double* %979, i64 %982
%984 = load double, double* %983
%985 = load double, double* %97
%986 = load double, double* %87
%987 = fneg double %985
%988 = call double @llvm.fmuladd.f64(double %987, double %986, double %984)
store double %988, double* %121
%989 = load double, double* %94
%990 = load double, double* %100
%991 = load double, double* %91
%992 = call double @llvm.fmuladd.f64(double %990, double %991, double %989)
store double %992, double* %116
%993 = load double, double* %94
%994 = load double, double* %100
%995 = load double, double* %91
%996 = fneg double %994
%997 = call double @llvm.fmuladd.f64(double %996, double %995, double %993)
store double %997, double* %124
%998 = load double, double* %95
%999 = load double, double* %101
%1000 = load double, double* %91
%1001 = call double @llvm.fmuladd.f64(double %999, double %1000, double %998)
store double %1001, double* %117
%1002 = load double, double* %95
%1003 = load double, double* %101
%1004 = load double, double* %91
%1005 = fneg double %1003
%1006 = call double @llvm.fmuladd.f64(double %1005, double %1004, double %1002)
store double %1006, double* %125
%1007 = load double, double* %104
%1008 = load double, double* %80
%1009 = load double, double* %105
%1010 = call double @llvm.fmuladd.f64(double %1007, double %1008, double %1009)
store double %1010, double* %114
%1011 = load double, double* %105
%1012 = load double, double* %80
%1013 = load double, double* %104
%1014 = fneg double %1013
%1015 = call double @llvm.fmuladd.f64(double %1011, double %1012, double %1014)
store double %1015, double* %115
%1016 = load double, double* %106
%1017 = load double, double* %84
%1018 = load double, double* %107
%1019 = call double @llvm.fmuladd.f64(double %1016, double %1017, double %1018)
store double %1019, double* %118
%1020 = load double, double* %107
%1021 = load double, double* %84
%1022 = load double, double* %106
%1023 = fneg double %1022
%1024 = call double @llvm.fmuladd.f64(double %1020, double %1021, double %1023)
store double %1024, double* %119
%1025 = load double, double* %108
%1026 = load double, double* %88
%1027 = load double, double* %109
%1028 = call double @llvm.fmuladd.f64(double %1025, double %1026, double %1027)
store double %1028, double* %122
%1029 = load double, double* %109
%1030 = load double, double* %88
%1031 = load double, double* %108
%1032 = fneg double %1031
%1033 = call double @llvm.fmuladd.f64(double %1029, double %1030, double %1032)
store double %1033, double* %123
%1034 = load double, double* %110
%1035 = load double, double* %92
%1036 = load double, double* %111
%1037 = call double @llvm.fmuladd.f64(double %1034, double %1035, double %1036)
store double %1037, double* %126
%1038 = load double, double* %111
%1039 = load double, double* %92
%1040 = load double, double* %110
%1041 = fneg double %1040
%1042 = call double @llvm.fmuladd.f64(double %1038, double %1039, double %1041)
store double %1042, double* %127
%1043 = load double, double* %112
%1044 = load double, double* %116
%1045 = load double, double* %83
%1046 = call double @llvm.fmuladd.f64(double %1044, double %1045, double %1043)
store double %1046, double* %128
%1047 = load double, double* %113
%1048 = load double, double* %117
%1049 = load double, double* %83
%1050 = call double @llvm.fmuladd.f64(double %1048, double %1049, double %1047)
store double %1050, double* %129
%1051 = load double, double* %112
%1052 = load double, double* %116
%1053 = load double, double* %83
%1054 = fneg double %1052
%1055 = call double @llvm.fmuladd.f64(double %1054, double %1053, double %1051)
store double %1055, double* %132
%1056 = load double, double* %113
%1057 = load double, double* %117
%1058 = load double, double* %83
%1059 = fneg double %1057
%1060 = call double @llvm.fmuladd.f64(double %1059, double %1058, double %1056)
store double %1060, double* %133
%1061 = load double, double* %120
%1062 = load double, double* %125
%1063 = load double, double* %83
%1064 = call double @llvm.fmuladd.f64(double %1062, double %1063, double %1061)
store double %1064, double* %136
%1065 = load double, double* %121
%1066 = load double, double* %124
%1067 = load double, double* %83
%1068 = fneg double %1066
%1069 = call double @llvm.fmuladd.f64(double %1068, double %1067, double %1065)
store double %1069, double* %137
%1070 = load double, double* %120
%1071 = load double, double* %125
%1072 = load double, double* %83
%1073 = fneg double %1071
%1074 = call double @llvm.fmuladd.f64(double %1073, double %1072, double %1070)
store double %1074, double* %140
%1075 = load double, double* %121
%1076 = load double, double* %124
%1077 = load double, double* %83
%1078 = call double @llvm.fmuladd.f64(double %1076, double %1077, double %1075)
store double %1078, double* %141
%1079 = load double, double* %114
%1080 = load double, double* %118
%1081 = load double, double* %85
%1082 = call double @llvm.fmuladd.f64(double %1080, double %1081, double %1079)
store double %1082, double* %130
%1083 = load double, double* %115
%1084 = load double, double* %119
%1085 = load double, double* %85
%1086 = call double @llvm.fmuladd.f64(double %1084, double %1085, double %1083)
store double %1086, double* %131
%1087 = load double, double* %114
%1088 = load double, double* %118
%1089 = load double, double* %85
%1090 = fneg double %1088
%1091 = call double @llvm.fmuladd.f64(double %1090, double %1089, double %1087)
store double %1091, double* %134
%1092 = load double, double* %115
%1093 = load double, double* %119
%1094 = load double, double* %85
%1095 = fneg double %1093
%1096 = call double @llvm.fmuladd.f64(double %1095, double %1094, double %1092)
store double %1096, double* %135
%1097 = load double, double* %122
%1098 = load double, double* %126
%1099 = load double, double* %93
%1100 = call double @llvm.fmuladd.f64(double %1098, double %1099, double %1097)
store double %1100, double* %138
%1101 = load double, double* %123
%1102 = load double, double* %127
%1103 = load double, double* %93
%1104 = call double @llvm.fmuladd.f64(double %1102, double %1103, double %1101)
store double %1104, double* %139
%1105 = load double, double* %122
%1106 = load double, double* %126
%1107 = load double, double* %93
%1108 = fneg double %1106
%1109 = call double @llvm.fmuladd.f64(double %1108, double %1107, double %1105)
store double %1109, double* %142
%1110 = load double, double* %123
%1111 = load double, double* %127
%1112 = load double, double* %93
%1113 = fneg double %1111
%1114 = call double @llvm.fmuladd.f64(double %1113, double %1112, double %1110)
store double %1114, double* %143
%1115 = load double, double* %128
%1116 = load double, double* %130
%1117 = load double, double* %81
%1118 = call double @llvm.fmuladd.f64(double %1116, double %1117, double %1115)
%1119 = load double*, double** %21
%1120 = load i64, i64* %42
%1121 = mul nsw i64 2, %1120
%1122 = getelementptr inbounds double, double* %1119, i64 %1121
store double %1118, double* %1122
%1123 = load double, double* %129
%1124 = load double, double* %131
%1125 = load double, double* %81
%1126 = call double @llvm.fmuladd.f64(double %1124, double %1125, double %1123)
%1127 = load double*, double** %21
%1128 = load i64, i64* %42
%1129 = mul nsw i64 2, %1128
%1130 = add nsw i64 %1129, 1
%1131 = getelementptr inbounds double, double* %1127, i64 %1130
store double %1126, double* %1131
%1132 = load double, double* %128
%1133 = load double, double* %130
%1134 = load double, double* %81
%1135 = fneg double %1133
%1136 = call double @llvm.fmuladd.f64(double %1135, double %1134, double %1132)
%1137 = load double*, double** %25
%1138 = load i64, i64* %42
%1139 = mul nsw i64 2, %1138
%1140 = getelementptr inbounds double, double* %1137, i64 %1139
store double %1136, double* %1140
%1141 = load double, double* %129
%1142 = load double, double* %131
%1143 = load double, double* %81
%1144 = fneg double %1142
%1145 = call double @llvm.fmuladd.f64(double %1144, double %1143, double %1141)
%1146 = load double*, double** %25
%1147 = load i64, i64* %42
%1148 = mul nsw i64 2, %1147
%1149 = add nsw i64 %1148, 1
%1150 = getelementptr inbounds double, double* %1146, i64 %1149
store double %1145, double* %1150
%1151 = load double, double* %136
%1152 = load double, double* %138
%1153 = load double, double* %89
%1154 = call double @llvm.fmuladd.f64(double %1152, double %1153, double %1151)
%1155 = load double*, double** %22
%1156 = load i64, i64* %42
%1157 = mul nsw i64 2, %1156
%1158 = getelementptr inbounds double, double* %1155, i64 %1157
store double %1154, double* %1158
%1159 = load double, double* %137
%1160 = load double, double* %139
%1161 = load double, double* %89
%1162 = call double @llvm.fmuladd.f64(double %1160, double %1161, double %1159)
%1163 = load double*, double** %22
%1164 = load i64, i64* %42
%1165 = mul nsw i64 2, %1164
%1166 = add nsw i64 %1165, 1
%1167 = getelementptr inbounds double, double* %1163, i64 %1166
store double %1162, double* %1167
%1168 = load double, double* %136
%1169 = load double, double* %138
%1170 = load double, double* %89
%1171 = fneg double %1169
%1172 = call double @llvm.fmuladd.f64(double %1171, double %1170, double %1168)
%1173 = load double*, double** %26
%1174 = load i64, i64* %42
%1175 = mul nsw i64 2, %1174
%1176 = getelementptr inbounds double, double* %1173, i64 %1175
store double %1172, double* %1176
%1177 = load double, double* %137
%1178 = load double, double* %139
%1179 = load double, double* %89
%1180 = fneg double %1178
%1181 = call double @llvm.fmuladd.f64(double %1180, double %1179, double %1177)
%1182 = load double*, double** %26
%1183 = load i64, i64* %42
%1184 = mul nsw i64 2, %1183
%1185 = add nsw i64 %1184, 1
%1186 = getelementptr inbounds double, double* %1182, i64 %1185
store double %1181, double* %1186
%1187 = load double, double* %132
%1188 = load double, double* %135
%1189 = load double, double* %81
%1190 = call double @llvm.fmuladd.f64(double %1188, double %1189, double %1187)
%1191 = load double*, double** %23
%1192 = load i64, i64* %42
%1193 = mul nsw i64 2, %1192
%1194 = getelementptr inbounds double, double* %1191, i64 %1193
store double %1190, double* %1194
%1195 = load double, double* %133
%1196 = load double, double* %134
%1197 = load double, double* %81
%1198 = fneg double %1196
%1199 = call double @llvm.fmuladd.f64(double %1198, double %1197, double %1195)
%1200 = load double*, double** %23
%1201 = load i64, i64* %42
%1202 = mul nsw i64 2, %1201
%1203 = add nsw i64 %1202, 1
%1204 = getelementptr inbounds double, double* %1200, i64 %1203
store double %1199, double* %1204
%1205 = load double, double* %132
%1206 = load double, double* %135
%1207 = load double, double* %81
%1208 = fneg double %1206
%1209 = call double @llvm.fmuladd.f64(double %1208, double %1207, double %1205)
%1210 = load double*, double** %27
%1211 = load i64, i64* %42
%1212 = mul nsw i64 2, %1211
%1213 = getelementptr inbounds double, double* %1210, i64 %1212
store double %1209, double* %1213
%1214 = load double, double* %133
%1215 = load double, double* %134
%1216 = load double, double* %81
%1217 = call double @llvm.fmuladd.f64(double %1215, double %1216, double %1214)
%1218 = load double*, double** %27
%1219 = load i64, i64* %42
%1220 = mul nsw i64 2, %1219
%1221 = add nsw i64 %1220, 1
%1222 = getelementptr inbounds double, double* %1218, i64 %1221
store double %1217, double* %1222
%1223 = load double, double* %140
%1224 = load double, double* %143
%1225 = load double, double* %89
%1226 = call double @llvm.fmuladd.f64(double %1224, double %1225, double %1223)
%1227 = load double*, double** %24
%1228 = load i64, i64* %42
%1229 = mul nsw i64 2, %1228
%1230 = getelementptr inbounds double, double* %1227, i64 %1229
store double %1226, double* %1230
%1231 = load double, double* %141
%1232 = load double, double* %142
%1233 = load double, double* %89
%1234 = fneg double %1232
%1235 = call double @llvm.fmuladd.f64(double %1234, double %1233, double %1231)
%1236 = load double*, double** %24
%1237 = load i64, i64* %42
%1238 = mul nsw i64 2, %1237
%1239 = add nsw i64 %1238, 1
%1240 = getelementptr inbounds double, double* %1236, i64 %1239
store double %1235, double* %1240
%1241 = load double, double* %140
%1242 = load double, double* %143
%1243 = load double, double* %89
%1244 = fneg double %1242
%1245 = call double @llvm.fmuladd.f64(double %1244, double %1243, double %1241)
%1246 = load double*, double** %28
%1247 = load i64, i64* %42
%1248 = mul nsw i64 2, %1247
%1249 = getelementptr inbounds double, double* %1246, i64 %1248
store double %1245, double* %1249
%1250 = load double, double* %141
%1251 = load double, double* %142
%1252 = load double, double* %89
%1253 = call double @llvm.fmuladd.f64(double %1251, double %1252, double %1250)
%1254 = load double*, double** %28
%1255 = load i64, i64* %42
%1256 = mul nsw i64 2, %1255
%1257 = add nsw i64 %1256, 1
%1258 = getelementptr inbounds double, double* %1254, i64 %1257
store double %1253, double* %1258
br label %1259
1259: ; preds = %745
%1260 = load i64, i64* %42
%1261 = add nsw i64 %1260, 1
store i64 %1261, i64* %42
br label %741
1262: ; preds = %741
%1263 = load i64, i64* %39
%1264 = mul nsw i64 16, %1263
%1265 = load double*, double** %29
%1266 = getelementptr inbounds double, double* %1265, i64 %1264
store double* %1266, double** %29
%1267 = load i64, i64* %39
%1268 = mul nsw i64 16, %1267
%1269 = load double*, double** %30
%1270 = getelementptr inbounds double, double* %1269, i64 %1268
store double* %1270, double** %30
%1271 = load i64, i64* %39
%1272 = mul nsw i64 16, %1271
%1273 = load double*, double** %31
%1274 = getelementptr inbounds double, double* %1273, i64 %1272
store double* %1274, double** %31
%1275 = load i64, i64* %39
%1276 = mul nsw i64 16, %1275
%1277 = load double*, double** %32
%1278 = getelementptr inbounds double, double* %1277, i64 %1276
store double* %1278, double** %32
%1279 = load i64, i64* %39
%1280 = mul nsw i64 16, %1279
%1281 = load double*, double** %33
%1282 = getelementptr inbounds double, double* %1281, i64 %1280
store double* %1282, double** %33
%1283 = load i64, i64* %39
%1284 = mul nsw i64 16, %1283
%1285 = load double*, double** %34
%1286 = getelementptr inbounds double, double* %1285, i64 %1284
store double* %1286, double** %34
%1287 = load i64, i64* %39
%1288 = mul nsw i64 16, %1287
%1289 = load double*, double** %35
%1290 = getelementptr inbounds double, double* %1289, i64 %1288
store double* %1290, double** %35
%1291 = load i64, i64* %39
%1292 = mul nsw i64 16, %1291
%1293 = load double*, double** %36
%1294 = getelementptr inbounds double, double* %1293, i64 %1292
store double* %1294, double** %36
%1295 = load i64, i64* %39
%1296 = mul nsw i64 2, %1295
%1297 = load double*, double** %21
%1298 = getelementptr inbounds double, double* %1297, i64 %1296
store double* %1298, double** %21
%1299 = load i64, i64* %39
%1300 = mul nsw i64 2, %1299
%1301 = load double*, double** %22
%1302 = getelementptr inbounds double, double* %1301, i64 %1300
store double* %1302, double** %22
%1303 = load i64, i64* %39
%1304 = mul nsw i64 2, %1303
%1305 = load double*, double** %23
%1306 = getelementptr inbounds double, double* %1305, i64 %1304
store double* %1306, double** %23
%1307 = load i64, i64* %39
%1308 = mul nsw i64 2, %1307
%1309 = load double*, double** %24
%1310 = getelementptr inbounds double, double* %1309, i64 %1308
store double* %1310, double** %24
%1311 = load i64, i64* %39
%1312 = mul nsw i64 2, %1311
%1313 = load double*, double** %25
%1314 = getelementptr inbounds double, double* %1313, i64 %1312
store double* %1314, double** %25
%1315 = load i64, i64* %39
%1316 = mul nsw i64 2, %1315
%1317 = load double*, double** %26
%1318 = getelementptr inbounds double, double* %1317, i64 %1316
store double* %1318, double** %26
%1319 = load i64, i64* %39
%1320 = mul nsw i64 2, %1319
%1321 = load double*, double** %27
%1322 = getelementptr inbounds double, double* %1321, i64 %1320
store double* %1322, double** %27
%1323 = load i64, i64* %39
%1324 = mul nsw i64 2, %1323
%1325 = load double*, double** %28
%1326 = getelementptr inbounds double, double* %1325, i64 %1324
store double* %1326, double** %28
br label %1327
1327: ; preds = %1262
%1328 = load i64, i64* %41
%1329 = add nsw i64 %1328, 1
store i64 %1329, i64* %41
br label %611
1330: ; preds = %611
ret void
}

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