void kern_r8_fma_o_b(double *restrict o0, double *restrict o1,
                     double *restrict o2, double *restrict o3,
                     double *restrict o4, double *restrict o5,
                     double *restrict o6, double *restrict o7, double *i0,
                     double *i1, double *i2, double *i3, double *i4, double *i5,
                     double *i6, double *i7, double *w, double *w2, long bsize,
                     long blocks) {
  long i, j;
  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_b>:
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_b+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
subsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  -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
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -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
subsd  -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
addsd  -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
addsd  -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
subsd  -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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x158(%rbp),%xmm1
ff
movsd  -0x160(%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,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    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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    117f <kern_r8_fma_o_b+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_b+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_b+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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%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
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%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
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%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
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%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
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%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
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
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
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
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
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
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
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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
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
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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
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
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
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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
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
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  -0x318(%rbp),%xmm1
ff
movsd  -0x320(%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,0x8(%rax,%rcx,8)
movsd  -0x310(%rbp),%xmm1
ff
movsd  -0x328(%rbp),%xmm0
movsd  -0x178(%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  -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    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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x358(%rbp),%xmm1
ff
movsd  -0x360(%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,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    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
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1c42 <kern_r8_fma_o_b+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_b+0x941>
add    $0x2e8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r8_fma_o_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2a8,%rsp
mov    %r9,-0x18(%rsp)
mov    %r8,-0x28(%rsp)
mov    %rcx,-0x40(%rsp)
mov    %rdx,-0x38(%rsp)
mov    %rsi,-0x30(%rsp)
mov    %rdi,-0x20(%rsp)
mov    0x348(%rsp),%rax
mov    0x340(%rsp),%rcx
imul   %rcx,%rax
mov    %rax,0x38(%rsp)
test   %rcx,%rcx
jle    14a8 <kern_r8_fma_o_b+0x3a8>
mov    0x38(%rsp),%rax
shl    $0x4,%rax
mov    0x330(%rsp),%rcx
movsd  0x8(%rcx,%rax,1),%xmm13
mov    0x340(%rsp),%rax
cmp    $0x1,%rax
jne    2649 <kern_r8_fma_o_b+0x1549>
xor    %r9d,%r9d
unpcklpd %xmm13,%xmm13
mov    0x340(%rsp),%rax
sub    %r9,%rax
mov    %rax,0x120(%rsp)
shl    $0x4,%r9
movapd 0x1e5d(%rip),%xmm8
mov    0x2e8(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    -0x40(%rsp),%rax
mov    %rax,-0x50(%rsp)
mov    0x2e0(%rsp),%rsi
mov    %rsi,-0x60(%rsp)
mov    -0x38(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    -0x18(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    -0x30(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    -0x28(%rsp),%rax
mov    %rax,(%rsp)
mov    -0x20(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x320(%rsp),%r10
mov    %r10,0x70(%rsp)
mov    0x300(%rsp),%r15
mov    %r15,0x60(%rsp)
mov    0x310(%rsp),%r14
mov    %r14,0x50(%rsp)
mov    0x2f0(%rsp),%r13
mov    %r13,0x40(%rsp)
mov    0x328(%rsp),%r12
mov    0x308(%rsp),%rax
mov    0x318(%rsp),%rdx
mov    0x2f8(%rsp),%rbp
nop
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,%xmm5
subpd  %xmm1,%xmm5
addpd  %xmm1,%xmm10
mov    0x40(%rsp),%rbx
movupd (%rbx,%r9,1),%xmm1
mov    0x50(%rsp),%r15
movupd (%r15,%r9,1),%xmm2
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm2,%xmm1
mov    0x60(%rsp),%rcx
movupd (%rcx,%r9,1),%xmm2
mov    0x70(%rsp),%rcx
movupd (%rcx,%r9,1),%xmm4
movapd %xmm2,%xmm11
addpd  %xmm4,%xmm11
subpd  %xmm4,%xmm2
shufpd $0x1,%xmm2,%xmm2
unpcklpd %xmm0,%xmm4
movapd %xmm0,%xmm7
unpckhpd %xmm0,%xmm7
addpd  %xmm0,%xmm4
subpd  %xmm7,%xmm0
shufpd $0x2,%xmm4,%xmm0
movapd %xmm5,%xmm4
xorpd  %xmm8,%xmm4
unpcklpd %xmm5,%xmm4
unpckhpd %xmm5,%xmm5
subpd  %xmm5,%xmm4
movapd %xmm3,%xmm5
addpd  %xmm11,%xmm5
movapd %xmm1,%xmm7
subpd  %xmm2,%xmm7
addpd  %xmm1,%xmm2
movapd %xmm2,%xmm12
movsd  %xmm7,%xmm12
shufpd $0x2,%xmm7,%xmm2
movapd %xmm3,%xmm7
unpcklpd %xmm9,%xmm7
movhlps %xmm9,%xmm3
addpd  %xmm10,%xmm9
movapd %xmm11,%xmm6
unpcklpd %xmm10,%xmm6
subpd  %xmm6,%xmm7
movhlps %xmm10,%xmm11
subpd  %xmm11,%xmm3
movapd %xmm0,%xmm6
addpd  %xmm4,%xmm6
subpd  %xmm4,%xmm0
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
movapd %xmm9,%xmm1
addpd  %xmm5,%xmm1
mov    0x80(%rsp),%r14
movupd %xmm1,(%r14,%r9,1)
subpd  %xmm9,%xmm5
mov    (%rsp),%r10
movupd %xmm5,(%r10,%r9,1)
mulpd  %xmm13,%xmm6
movapd %xmm6,%xmm1
addpd  %xmm12,%xmm1
mov    0x10(%rsp),%r13
movupd %xmm1,0x0(%r13,%r9,1)
subpd  %xmm6,%xmm12
mov    0x20(%rsp),%r8
movupd %xmm12,(%r8,%r9,1)
movapd %xmm7,%xmm1
subpd  %xmm3,%xmm1
movapd %xmm7,%xmm5
addpd  %xmm3,%xmm5
shufpd $0x2,%xmm5,%xmm1
mov    -0x10(%rsp),%r11
movupd %xmm1,(%r11,%r9,1)
subpd  %xmm7,%xmm3
movsd  %xmm5,%xmm3
mov    -0x60(%rsp),%rcx
movupd %xmm3,(%rcx,%r9,1)
xorpd  %xmm8,%xmm4
unpcklpd %xmm0,%xmm4
mulpd  %xmm13,%xmm4
addpd  %xmm2,%xmm4
mov    -0x50(%rsp),%rdi
movupd %xmm4,(%rdi,%r9,1)
movapd %xmm0,%xmm1
xorpd  %xmm8,%xmm1
shufpd $0x1,%xmm1,%xmm0
mulpd  %xmm13,%xmm0
addpd  %xmm2,%xmm0
mov    -0x70(%rsp),%rsi
movupd %xmm0,(%rsi,%r9,1)
add    $0x10,%rbp
add    $0x10,%rdx
add    $0x10,%rax
add    $0x10,%r12
add    $0x10,%rbx
mov    %rbx,0x40(%rsp)
add    $0x10,%r15
mov    %r15,0x50(%rsp)
addq   $0x10,0x60(%rsp)
addq   $0x10,0x70(%rsp)
add    $0x10,%r14
mov    %r14,0x80(%rsp)
add    $0x10,%r10
mov    %r10,(%rsp)
add    $0x10,%r13
mov    %r13,0x10(%rsp)
add    $0x10,%r8
mov    %r8,0x20(%rsp)
add    $0x10,%r11
mov    %r11,-0x10(%rsp)
add    $0x10,%rcx
mov    %rcx,-0x60(%rsp)
add    $0x10,%rdi
mov    %rdi,-0x50(%rsp)
add    $0x10,%rsi
mov    %rsi,-0x70(%rsp)
addq   $0xffffffffffffffff,0x120(%rsp)
jne    1250 <kern_r8_fma_o_b+0x150>
cmpq   $0x2,0x348(%rsp)
jl     2637 <kern_r8_fma_o_b+0x1537>
mov    0x38(%rsp),%rax
add    %rax,%rax
mov    %rax,0x38(%rsp)
mov    0x340(%rsp),%rsi
mov    %rsi,%r8
shl    $0x4,%r8
lea    (%rsi,%rsi,1),%rcx
lea    -0x1(%rsi),%rax
mov    %rcx,0x1f8(%rsp)
or     $0x1,%rcx
mov    %rcx,0x1f0(%rsp)
mov    $0x10,%ecx
mul    %rcx
mov    %rax,0x1e8(%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,0x200(%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 0x1a79(%rip),%xmm0
mov    0x2e8(%rsp),%rax
lea    (%rax,%r8,1),%rbx
mov    -0x40(%rsp),%rax
lea    (%rax,%r8,1),%rdi
mov    0x2e0(%rsp),%rax
lea    (%rax,%r8,1),%rcx
mov    -0x38(%rsp),%rax
lea    (%rax,%r8,1),%rsi
mov    -0x18(%rsp),%rax
lea    (%rax,%r8,1),%rax
mov    %rax,0xa8(%rsp)
mov    -0x30(%rsp),%rax
lea    (%rax,%r8,1),%rax
mov    %rax,0xa0(%rsp)
mov    -0x28(%rsp),%rax
add    %r8,%rax
mov    %rax,0x98(%rsp)
mov    -0x20(%rsp),%rax
mov    %r8,0x208(%rsp)
add    %r8,%rax
mov    $0x1,%edx
mov    %rdx,0xb0(%rsp)
xor    %edx,%edx
mov    %rdx,0x138(%rsp)
jmp    16f2 <kern_r8_fma_o_b+0x5f2>
nop
mov    0xb0(%rsp),%r8
add    $0x1,%r8
addq   $0x1,0x138(%rsp)
mov    0x118(%rsp),%r9
mov    0x200(%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    0x208(%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     2637 <kern_r8_fma_o_b+0x1537>
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    1610 <kern_r8_fma_o_b+0x510>
mov    0xb0(%rsp),%rax
mov    0x340(%rsp),%rbp
imul   %rbp,%rax
mov    %rax,%rcx
shl    $0x6,%rcx
mov    %rax,%rdx
shl    $0x5,%rdx
mov    0x38(%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),%xmm5
movsd  0x8(%rbx,%rcx,1),%xmm13
movsd  (%rbx,%rdx,1),%xmm11
movsd  0x8(%rbx,%rdx,1),%xmm8
mov    0x338(%rsp),%rcx
movsd  (%rcx,%rdx,1),%xmm6
movsd  0x8(%rcx,%rdx,1),%xmm15
movsd  (%rbx,%rax,1),%xmm12
movsd  0x8(%rbx,%rax,1),%xmm9
movsd  (%rcx,%rax,1),%xmm10
movsd  0x8(%rcx,%rax,1),%xmm7
movsd  (%rbx,%rsi,8),%xmm1
movsd  (%rbx,%rdi,1),%xmm4
movsd  (%rcx,%rsi,8),%xmm3
movsd  (%rcx,%rdi,1),%xmm2
cmp    $0x1,%rbp
movapd %xmm15,0x230(%rsp)
movapd %xmm7,0x220(%rsp)
movaps %xmm2,0x210(%rsp)
movapd %xmm8,0x40(%rsp)
movapd %xmm12,0x120(%rsp)
movaps %xmm10,0x160(%rsp)
movaps %xmm1,0x150(%rsp)
movapd %xmm3,0x140(%rsp)
jne    1e20 <kern_r8_fma_o_b+0xd20>
xor    %r9d,%r9d
unpcklpd %xmm5,%xmm5
unpcklpd %xmm11,%xmm11
unpcklpd %xmm6,%xmm6
unpcklpd %xmm13,%xmm13
movapd %xmm15,%xmm1
unpcklpd %xmm15,%xmm1
movapd %xmm1,0x1a0(%rsp)
movaps 0x120(%rsp),%xmm1
movlhps %xmm1,%xmm1
movaps %xmm1,0x120(%rsp)
movaps 0x160(%rsp),%xmm1
movlhps %xmm1,%xmm1
movaps %xmm1,0x160(%rsp)
movaps 0x150(%rsp),%xmm1
movlhps %xmm1,%xmm1
movaps %xmm1,0x150(%rsp)
movaps 0x140(%rsp),%xmm1
movlhps %xmm1,%xmm1
movaps %xmm1,0x140(%rsp)
movaps 0x40(%rsp),%xmm1
movlhps %xmm1,%xmm1
movaps %xmm1,0x40(%rsp)
unpcklpd %xmm7,%xmm7
movapd %xmm7,0x190(%rsp)
movlhps %xmm2,%xmm2
movaps %xmm2,0x180(%rsp)
unpcklpd %xmm9,%xmm9
unpcklpd %xmm4,%xmm4
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,-0x50(%rsp)
mov    0xc8(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    0xc0(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    0xa8(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    0xa0(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0x98(%rsp),%rax
mov    %rax,(%rsp)
mov    0xb8(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x118(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x108(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x100(%rsp),%r15
mov    0xf8(%rsp),%rdi
mov    0xf0(%rsp),%rcx
mov    0xe8(%rsp),%rbx
mov    0xe0(%rsp),%r10
movapd %xmm6,0x1c0(%rsp)
movapd %xmm5,0x1d0(%rsp)
movapd %xmm4,0x1b0(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r10,%r9,1),%xmm10
movapd %xmm10,%xmm2
unpckhpd %xmm10,%xmm2
xorpd  %xmm0,%xmm2
unpcklpd %xmm10,%xmm2
movupd (%rbx,%r9,1),%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
xorpd  0x15e1(%rip),%xmm0
mulpd  %xmm5,%xmm10
unpcklpd %xmm1,%xmm0
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm1
movupd (%rcx,%r9,1),%xmm14
movapd %xmm14,%xmm3
unpckhpd %xmm14,%xmm3
xorpd  0x15b8(%rip),%xmm3
unpcklpd %xmm14,%xmm3
mulpd  %xmm11,%xmm14
movupd (%rdi,%r9,1),%xmm0
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
xorpd  0x1598(%rip),%xmm4
addpd  %xmm2,%xmm10
unpcklpd %xmm0,%xmm4
mulpd  %xmm5,%xmm0
movupd (%r15,%r9,1),%xmm5
movapd %xmm5,%xmm2
addpd  %xmm3,%xmm14
unpckhpd %xmm5,%xmm2
xorpd  0x1570(%rip),%xmm2
unpcklpd %xmm5,%xmm2
addpd  %xmm4,%xmm0
mulpd  %xmm6,%xmm5
addpd  %xmm2,%xmm5
mov    0x50(%rsp),%rbp
movupd 0x0(%rbp,%r9,1),%xmm2
mulpd  %xmm13,%xmm10
movapd %xmm10,%xmm6
addpd  %xmm2,%xmm6
mov    0x60(%rsp),%rax
movupd (%rax,%r9,1),%xmm4
mulpd  %xmm13,%xmm1
movapd %xmm1,%xmm7
addpd  %xmm4,%xmm7
subpd  %xmm1,%xmm4
mov    0x70(%rsp),%rax
movupd (%rax,%r9,1),%xmm12
mulpd  %xmm13,%xmm0
subpd  %xmm10,%xmm2
movapd %xmm0,%xmm10
addpd  %xmm12,%xmm10
subpd  %xmm0,%xmm12
movapd %xmm5,%xmm0
mulsd  %xmm15,%xmm0
movapd %xmm9,%xmm8
movapd %xmm13,%xmm9
movapd %xmm14,%xmm13
movapd %xmm5,%xmm1
subsd  %xmm0,%xmm13
mulpd  0x1a0(%rsp),%xmm1
addpd  %xmm14,%xmm1
unpckhpd %xmm5,%xmm5
unpckhpd %xmm14,%xmm14
mulsd  %xmm15,%xmm5
subsd  %xmm5,%xmm14
movapd %xmm6,%xmm3
unpckhpd %xmm6,%xmm3
movapd %xmm7,%xmm0
xorpd  0x14b0(%rip),%xmm3
unpckhpd %xmm7,%xmm0
xorpd  0x14a4(%rip),%xmm0
unpcklpd %xmm7,%xmm0
mulpd  0x160(%rsp),%xmm7
addpd  %xmm0,%xmm7
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
xorpd  0x1483(%rip),%xmm0
unpcklpd %xmm6,%xmm3
unpcklpd %xmm4,%xmm0
mulpd  0x140(%rsp),%xmm4
movapd 0x40(%rsp),%xmm5
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm4
movapd %xmm1,%xmm15
addpd  %xmm10,%xmm15
subpd  %xmm1,%xmm10
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
mulpd  0x120(%rsp),%xmm6
xorpd  0x143c(%rip),%xmm0
unpcklpd %xmm2,%xmm0
mulpd  0x150(%rsp),%xmm2
addpd  %xmm3,%xmm6
movapd %xmm14,%xmm1
xorpd  0x141e(%rip),%xmm1
unpcklpd %xmm13,%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm2
xorpd  0x1408(%rip),%xmm13
unpcklpd %xmm13,%xmm14
movapd %xmm9,%xmm13
movapd %xmm8,%xmm9
movapd 0x220(%rsp),%xmm8
mulpd  %xmm5,%xmm14
addpd  %xmm12,%xmm1
addpd  %xmm12,%xmm14
movapd 0x210(%rsp),%xmm12
movapd %xmm7,%xmm0
mulpd  0x190(%rsp),%xmm0
movapd %xmm7,%xmm3
mulsd  %xmm8,%xmm3
movapd %xmm6,%xmm5
addpd  %xmm6,%xmm0
subsd  %xmm3,%xmm5
unpckhpd %xmm7,%xmm7
mulsd  %xmm8,%xmm7
unpckhpd %xmm6,%xmm6
subsd  %xmm7,%xmm6
movapd %xmm4,%xmm7
mulsd  %xmm12,%xmm7
movapd %xmm2,%xmm3
subsd  %xmm7,%xmm3
movapd %xmm4,%xmm7
mulpd  0x180(%rsp),%xmm7
addpd  %xmm2,%xmm7
unpckhpd %xmm4,%xmm4
mulsd  %xmm12,%xmm4
unpckhpd %xmm2,%xmm2
subsd  %xmm4,%xmm2
mulpd  %xmm9,%xmm0
movapd %xmm0,%xmm4
addpd  %xmm15,%xmm4
mov    0x80(%rsp),%r11
movupd %xmm4,(%r11,%r9,1)
movapd 0x1b0(%rsp),%xmm4
subpd  %xmm0,%xmm15
mov    (%rsp),%r8
movupd %xmm15,(%r8,%r9,1)
movaps 0x230(%rsp),%xmm15
mulpd  %xmm4,%xmm7
movapd %xmm7,%xmm0
addpd  %xmm1,%xmm0
mov    0x10(%rsp),%r13
movupd %xmm0,0x0(%r13,%r9,1)
subpd  %xmm7,%xmm1
mov    0x20(%rsp),%r12
movupd %xmm1,(%r12,%r9,1)
movapd %xmm6,%xmm0
xorpd  0x1300(%rip),%xmm0
unpcklpd %xmm5,%xmm0
xorpd  0x12f4(%rip),%xmm5
unpcklpd %xmm5,%xmm6
movapd 0x1d0(%rsp),%xmm5
mulpd  %xmm9,%xmm0
addpd  %xmm10,%xmm0
mulpd  %xmm9,%xmm6
addpd  %xmm10,%xmm6
mov    -0x10(%rsp),%rax
movupd %xmm0,(%rax,%r9,1)
movapd %xmm2,%xmm0
xorpd  0x12bc(%rip),%xmm0
unpcklpd %xmm3,%xmm0
mulpd  %xmm4,%xmm0
addpd  %xmm14,%xmm0
mov    -0x50(%rsp),%rdx
movupd %xmm0,(%rdx,%r9,1)
movapd 0x129c(%rip),%xmm0
xorpd  %xmm0,%xmm3
unpcklpd %xmm3,%xmm2
mov    -0x60(%rsp),%r14
movupd %xmm6,(%r14,%r9,1)
movapd 0x1c0(%rsp),%xmm6
mulpd  %xmm4,%xmm2
addpd  %xmm14,%xmm2
mov    -0x70(%rsp),%rsi
movupd %xmm2,(%rsi,%r9,1)
add    $0x10,%r10
add    $0x10,%rbx
add    $0x10,%rcx
add    $0x10,%rdi
add    $0x10,%r15
add    $0x10,%rbp
mov    %rbp,0x50(%rsp)
addq   $0x10,0x60(%rsp)
addq   $0x10,0x70(%rsp)
add    $0x10,%r11
mov    %r11,0x80(%rsp)
add    $0x10,%r8
mov    %r8,(%rsp)
add    $0x10,%r13
mov    %r13,0x10(%rsp)
add    $0x10,%r12
mov    %r12,0x20(%rsp)
add    $0x10,%rax
mov    %rax,-0x10(%rsp)
add    $0x10,%r14
mov    %r14,-0x60(%rsp)
add    $0x10,%rdx
mov    %rdx,-0x50(%rsp)
add    $0x10,%rsi
mov    %rsi,-0x70(%rsp)
addq   $0xffffffffffffffff,0x170(%rsp)
jne    19f0 <kern_r8_fma_o_b+0x8f0>
jmp    1610 <kern_r8_fma_o_b+0x510>
nopl   0x0(%rax,%rax,1)
mov    0x1f8(%rsp),%rax
imul   0x138(%rsp),%rax
add    0x1f0(%rsp),%rax
mov    -0x20(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    -0x28(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    -0x30(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
mov    -0x18(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
mov    0x1e8(%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    -0x38(%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    -0x40(%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    1856 <kern_r8_fma_o_b+0x756>
or     %cl,%r10b
jne    1856 <kern_r8_fma_o_b+0x756>
or     %cl,%dl
jne    1856 <kern_r8_fma_o_b+0x756>
or     %cl,%r9b
jne    1856 <kern_r8_fma_o_b+0x756>
or     %cl,%r8b
jne    1856 <kern_r8_fma_o_b+0x756>
or     %cl,%dil
jne    1856 <kern_r8_fma_o_b+0x756>
or     %cl,%al
jne    1856 <kern_r8_fma_o_b+0x756>
or     %cl,%sil
mov    $0x0,%r9d
jne    1859 <kern_r8_fma_o_b+0x759>
movapd %xmm5,0x1d0(%rsp)
unpcklpd %xmm5,%xmm5
movapd %xmm5,0x10(%rsp)
movapd %xmm11,0x250(%rsp)
unpcklpd %xmm11,%xmm11
movapd %xmm11,(%rsp)
movapd %xmm6,0x1c0(%rsp)
unpcklpd %xmm6,%xmm6
movapd %xmm6,0x80(%rsp)
movapd %xmm13,0x260(%rsp)
unpcklpd %xmm13,%xmm13
movapd %xmm13,0x70(%rsp)
unpcklpd %xmm15,%xmm15
movapd %xmm15,0x60(%rsp)
movaps 0x120(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0x160(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x1a0(%rsp)
movaps 0x150(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0x140(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0x40(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x170(%rsp)
unpcklpd %xmm7,%xmm7
movapd %xmm7,0x290(%rsp)
movlhps %xmm2,%xmm2
movaps %xmm2,0x280(%rsp)
movapd %xmm9,0x240(%rsp)
unpcklpd %xmm9,%xmm9
movapd %xmm9,-0x10(%rsp)
movapd %xmm4,0x1b0(%rsp)
unpcklpd %xmm4,%xmm4
movapd %xmm4,0x270(%rsp)
mov    0x130(%rsp),%rdi
xor    %ebx,%ebx
mov    0xf0(%rsp),%r15
mov    0xe8(%rsp),%r12
mov    0xe0(%rsp),%r13
mov    0xd8(%rsp),%r14
mov    0xd0(%rsp),%rbp
mov    0xc8(%rsp),%rax
mov    0xc0(%rsp),%rcx
mov    0xa8(%rsp),%rdx
mov    0xa0(%rsp),%r8
mov    0x98(%rsp),%r9
mov    0xb8(%rsp),%r10
nopw   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rbx,1),%xmm3
movupd 0x10(%r13,%rbx,1),%xmm0
movapd %xmm3,%xmm1
unpcklpd %xmm0,%xmm1
unpckhpd %xmm0,%xmm3
movapd %xmm1,%xmm10
movapd 0x10(%rsp),%xmm7
mulpd  %xmm7,%xmm10
subpd  %xmm3,%xmm10
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movupd (%r12,%rbx,1),%xmm4
movupd 0x10(%r12,%rbx,1),%xmm0
movapd %xmm4,%xmm5
unpcklpd %xmm0,%xmm5
unpckhpd %xmm0,%xmm4
movapd %xmm5,%xmm14
mulpd  %xmm7,%xmm14
subpd  %xmm4,%xmm14
mulpd  %xmm7,%xmm4
addpd  %xmm5,%xmm4
movupd (%r15,%rbx,1),%xmm1
movupd 0x10(%r15,%rbx,1),%xmm0
movapd %xmm1,%xmm5
unpcklpd %xmm0,%xmm5
unpckhpd %xmm0,%xmm1
movapd %xmm5,%xmm8
movapd (%rsp),%xmm0
mulpd  %xmm0,%xmm8
subpd  %xmm1,%xmm8
mulpd  %xmm0,%xmm1
addpd  %xmm5,%xmm1
movapd %xmm1,-0x70(%rsp)
mov    0xf8(%rsp),%rsi
movupd (%rsi,%rbx,1),%xmm5
movupd 0x10(%rsi,%rbx,1),%xmm0
movapd %xmm5,%xmm6
unpcklpd %xmm0,%xmm6
unpckhpd %xmm0,%xmm5
movapd %xmm6,%xmm0
mulpd  %xmm7,%xmm0
subpd  %xmm5,%xmm0
mulpd  %xmm7,%xmm5
addpd  %xmm6,%xmm5
mov    0x100(%rsp),%rsi
movupd (%rsi,%rbx,1),%xmm7
movupd 0x10(%rsi,%rbx,1),%xmm6
movapd %xmm7,%xmm1
unpcklpd %xmm6,%xmm1
unpckhpd %xmm6,%xmm7
movapd %xmm1,%xmm12
movapd 0x80(%rsp),%xmm6
mulpd  %xmm6,%xmm12
subpd  %xmm7,%xmm12
mulpd  %xmm6,%xmm7
addpd  %xmm1,%xmm7
mov    0x108(%rsp),%rsi
movupd (%rsi,%rbx,1),%xmm13
movupd 0x10(%rsi,%rbx,1),%xmm1
movapd %xmm13,%xmm9
unpcklpd %xmm1,%xmm9
unpckhpd %xmm1,%xmm13
movapd 0x70(%rsp),%xmm2
mulpd  %xmm2,%xmm10
movapd %xmm10,%xmm1
addpd  %xmm9,%xmm1
movapd %xmm1,0x20(%rsp)
subpd  %xmm10,%xmm9
mulpd  %xmm2,%xmm3
movapd %xmm3,%xmm15
addpd  %xmm13,%xmm15
subpd  %xmm3,%xmm13
mov    0x110(%rsp),%rsi
movupd (%rsi,%rbx,1),%xmm10
movupd 0x10(%rsi,%rbx,1),%xmm1
movapd %xmm10,%xmm11
unpcklpd %xmm1,%xmm11
unpckhpd %xmm1,%xmm10
mulpd  %xmm2,%xmm14
movapd %xmm14,%xmm1
addpd  %xmm11,%xmm1
subpd  %xmm14,%xmm11
mulpd  %xmm2,%xmm4
movapd %xmm4,%xmm3
addpd  %xmm10,%xmm3
subpd  %xmm4,%xmm10
mov    0x118(%rsp),%r11
movupd (%r11,%rbx,1),%xmm6
movupd 0x10(%r11,%rbx,1),%xmm4
movapd %xmm6,%xmm14
unpcklpd %xmm4,%xmm14
unpckhpd %xmm4,%xmm6
mulpd  %xmm2,%xmm0
movapd %xmm0,%xmm4
addpd  %xmm14,%xmm4
movapd %xmm4,-0x60(%rsp)
subpd  %xmm0,%xmm14
mulpd  %xmm2,%xmm5
movapd %xmm5,%xmm0
addpd  %xmm6,%xmm0
movapd %xmm0,-0x50(%rsp)
subpd  %xmm5,%xmm6
movapd 0x60(%rsp),%xmm0
mulpd  %xmm0,%xmm12
movapd %xmm12,%xmm5
addpd  %xmm8,%xmm5
subpd  %xmm12,%xmm8
mulpd  %xmm0,%xmm7
movapd %xmm7,%xmm0
movapd -0x70(%rsp),%xmm2
addpd  %xmm2,%xmm0
subpd  %xmm7,%xmm2
movapd %xmm2,-0x70(%rsp)
movapd 0x20(%rsp),%xmm4
movapd %xmm4,%xmm7
movapd 0x50(%rsp),%xmm2
mulpd  %xmm2,%xmm7
subpd  %xmm15,%xmm7
mulpd  %xmm2,%xmm15
addpd  %xmm4,%xmm15
movapd %xmm1,%xmm4
movapd 0x1a0(%rsp),%xmm2
mulpd  %xmm2,%xmm4
subpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm9,%xmm12
movapd 0x190(%rsp),%xmm1
mulpd  %xmm1,%xmm12
subpd  %xmm13,%xmm12
mulpd  %xmm1,%xmm13
addpd  %xmm9,%xmm13
movapd %xmm11,%xmm2
movapd 0x180(%rsp),%xmm1
mulpd  %xmm1,%xmm2
subpd  %xmm10,%xmm2
mulpd  %xmm1,%xmm10
addpd  %xmm11,%xmm10
movapd 0x170(%rsp),%xmm1
mulpd  %xmm1,%xmm5
movapd %xmm5,%xmm11
movapd -0x60(%rsp),%xmm9
addpd  %xmm9,%xmm11
subpd  %xmm5,%xmm9
movapd %xmm9,-0x60(%rsp)
mulpd  %xmm1,%xmm0
movapd %xmm0,%xmm5
movapd -0x50(%rsp),%xmm9
addpd  %xmm9,%xmm5
subpd  %xmm0,%xmm9
movapd %xmm9,-0x50(%rsp)
movapd -0x70(%rsp),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm14,%xmm9
subpd  %xmm0,%xmm9
addpd  %xmm14,%xmm0
movapd %xmm0,-0x70(%rsp)
mulpd  %xmm1,%xmm8
movapd %xmm8,%xmm14
addpd  %xmm6,%xmm14
subpd  %xmm8,%xmm6
movapd 0x290(%rsp),%xmm0
mulpd  %xmm0,%xmm4
movapd %xmm4,%xmm8
addpd  %xmm7,%xmm8
subpd  %xmm4,%xmm7
mulpd  %xmm0,%xmm3
movapd %xmm3,%xmm4
addpd  %xmm15,%xmm4
subpd  %xmm3,%xmm15
movapd 0x280(%rsp),%xmm0
mulpd  %xmm0,%xmm2
movapd %xmm2,%xmm3
addpd  %xmm12,%xmm3
subpd  %xmm2,%xmm12
mulpd  %xmm0,%xmm10
movapd %xmm10,%xmm2
addpd  %xmm13,%xmm2
subpd  %xmm10,%xmm13
movapd -0x10(%rsp),%xmm0
mulpd  %xmm0,%xmm8
movapd %xmm8,%xmm10
addpd  %xmm11,%xmm10
mulpd  %xmm0,%xmm4
movapd %xmm4,%xmm0
addpd  %xmm5,%xmm0
movapd %xmm10,%xmm1
unpcklpd %xmm0,%xmm1
movhlps %xmm10,%xmm0
movups %xmm0,0x10(%r10,%rbx,1)
movupd %xmm1,(%r10,%rbx,1)
subpd  %xmm8,%xmm11
subpd  %xmm4,%xmm5
movapd %xmm11,%xmm0
unpcklpd %xmm5,%xmm0
movhlps %xmm11,%xmm5
movups %xmm5,0x10(%r9,%rbx,1)
movupd %xmm0,(%r9,%rbx,1)
movapd 0x270(%rsp),%xmm5
mulpd  %xmm5,%xmm3
movapd %xmm3,%xmm0
addpd  %xmm9,%xmm0
mulpd  %xmm5,%xmm2
movapd %xmm2,%xmm1
addpd  %xmm14,%xmm1
movapd %xmm0,%xmm4
unpcklpd %xmm1,%xmm4
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%r8,%rbx,1)
movupd %xmm4,(%r8,%rbx,1)
subpd  %xmm3,%xmm9
subpd  %xmm2,%xmm14
movapd %xmm9,%xmm0
unpcklpd %xmm14,%xmm0
movhlps %xmm9,%xmm14
movups %xmm14,0x10(%rdx,%rbx,1)
movupd %xmm0,(%rdx,%rbx,1)
movapd -0x10(%rsp),%xmm1
mulpd  %xmm1,%xmm15
movapd -0x60(%rsp),%xmm3
movapd %xmm3,%xmm0
subpd  %xmm15,%xmm0
mulpd  %xmm1,%xmm7
movapd %xmm7,%xmm1
movapd -0x50(%rsp),%xmm4
addpd  %xmm4,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rcx,%rbx,1)
movupd %xmm2,(%rcx,%rbx,1)
addpd  %xmm3,%xmm15
movapd %xmm4,%xmm1
subpd  %xmm7,%xmm1
movapd %xmm15,%xmm0
unpcklpd %xmm1,%xmm0
movhlps %xmm15,%xmm1
movups %xmm1,0x10(%rax,%rbx,1)
movupd %xmm0,(%rax,%rbx,1)
mulpd  %xmm5,%xmm13
movapd -0x70(%rsp),%xmm3
movapd %xmm3,%xmm0
subpd  %xmm13,%xmm0
mulpd  %xmm5,%xmm12
movapd %xmm12,%xmm1
addpd  %xmm6,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rbp,%rbx,1)
movupd %xmm2,0x0(%rbp,%rbx,1)
addpd  %xmm3,%xmm13
subpd  %xmm12,%xmm6
movapd %xmm13,%xmm0
unpcklpd %xmm6,%xmm0
movhlps %xmm13,%xmm6
movups %xmm6,0x10(%r14,%rbx,1)
movupd %xmm0,(%r14,%rbx,1)
add    $0x20,%rbx
add    $0xfffffffffffffffe,%rdi
jne    20a0 <kern_r8_fma_o_b+0xfa0>
mov    0x130(%rsp),%rax
mov    %rax,%r9
cmp    0x340(%rsp),%rax
movapd 0xa28(%rip),%xmm0
movapd 0x1d0(%rsp),%xmm5
movapd 0x260(%rsp),%xmm13
movapd 0x250(%rsp),%xmm11
movapd 0x1c0(%rsp),%xmm6
movapd 0x230(%rsp),%xmm15
movapd 0x240(%rsp),%xmm9
movapd 0x220(%rsp),%xmm7
movapd 0x1b0(%rsp),%xmm4
movaps 0x210(%rsp),%xmm2
je     1610 <kern_r8_fma_o_b+0x510>
jmp    1859 <kern_r8_fma_o_b+0x759>
add    $0x2a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0xffffffffffffffff,%rax
mov    -0x20(%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_b+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_b+0x7b>
mov    -0x28(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_b+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_b+0x7b>
mov    -0x30(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_b+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_b+0x7b>
mov    -0x18(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_b+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_b+0x7b>
mov    -0x38(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_b+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_b+0x7b>
mov    0x2e0(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_b+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_b+0x7b>
mov    -0x40(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     117b <kern_r8_fma_o_b+0x7b>
test   %cl,%cl
jne    117b <kern_r8_fma_o_b+0x7b>
mov    0x2e8(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rsi,%rax
add    $0x8,%rax
cmp    %rdx,%rax
jb     117b <kern_r8_fma_o_b+0x7b>
test   %cl,%cl
mov    $0x0,%r9d
jne    117e <kern_r8_fma_o_b+0x7e>
mov    0x340(%rsp),%rbp
and    $0xfffffffffffffffe,%rbp
movapd %xmm13,0x10(%rsp)
unpcklpd %xmm13,%xmm13
movapd %xmm13,0x20(%rsp)
xor    %eax,%eax
mov    %rbp,(%rsp)
mov    -0x28(%rsp),%r8
mov    -0x40(%rsp),%rsi
mov    -0x38(%rsp),%rdi
mov    -0x30(%rsp),%rbx
mov    -0x20(%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,%rax,1)
movupd (%r11,%rax,1),%xmm15
movupd 0x10(%r11,%rax,1),%xmm1
movapd %xmm15,%xmm8
unpcklpd %xmm1,%xmm8
unpckhpd %xmm1,%xmm15
mov    0x318(%rsp),%rdx
movupd (%rdx,%rax,1),%xmm1
movupd 0x10(%rdx,%rax,1),%xmm2
movapd %xmm1,%xmm4
unpcklpd %xmm2,%xmm4
unpckhpd %xmm2,%xmm1
movapd %xmm8,%xmm14
addpd  %xmm4,%xmm14
subpd  %xmm4,%xmm8
movapd %xmm15,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,-0x70(%rsp)
subpd  %xmm1,%xmm15
movupd (%r9,%rax,1),%xmm5
movupd 0x10(%r9,%rax,1),%xmm2
movapd %xmm5,%xmm3
unpcklpd %xmm2,%xmm3
unpckhpd %xmm2,%xmm5
mov    0x328(%rsp),%rdx
movupd (%rdx,%rax,1),%xmm2
movupd 0x10(%rdx,%rax,1),%xmm4
movapd %xmm2,%xmm6
unpcklpd %xmm4,%xmm6
unpckhpd %xmm4,%xmm2
movapd %xmm3,%xmm0
addpd  %xmm6,%xmm0
movapd %xmm0,-0x60(%rsp)
subpd  %xmm6,%xmm3
movapd %xmm5,%xmm0
addpd  %xmm2,%xmm0
movapd %xmm0,-0x50(%rsp)
subpd  %xmm2,%xmm5
movupd (%r14,%rax,1),%xmm2
movupd 0x10(%r14,%rax,1),%xmm6
movapd %xmm2,%xmm4
unpcklpd %xmm6,%xmm4
unpckhpd %xmm6,%xmm2
movupd 0x0(%r13,%rax,1),%xmm6
movupd 0x10(%r13,%rax,1),%xmm7
movapd %xmm6,%xmm0
unpcklpd %xmm7,%xmm0
unpckhpd %xmm7,%xmm6
movapd %xmm4,%xmm13
addpd  %xmm0,%xmm13
subpd  %xmm0,%xmm4
movapd %xmm2,%xmm9
addpd  %xmm6,%xmm9
subpd  %xmm6,%xmm2
movupd (%r10,%rax,1),%xmm12
movupd 0x10(%r10,%rax,1),%xmm0
movapd %xmm12,%xmm7
unpcklpd %xmm0,%xmm7
unpckhpd %xmm0,%xmm12
movupd (%r12,%rax,1),%xmm0
movupd 0x10(%r12,%rax,1),%xmm11
movapd %xmm0,%xmm6
unpcklpd %xmm11,%xmm6
unpckhpd %xmm11,%xmm0
movapd %xmm7,%xmm1
addpd  %xmm6,%xmm1
subpd  %xmm6,%xmm7
movapd %xmm12,%xmm10
addpd  %xmm0,%xmm10
subpd  %xmm0,%xmm12
movapd %xmm8,%xmm11
subpd  %xmm15,%xmm11
addpd  %xmm8,%xmm15
movapd %xmm3,%xmm6
xorpd  0x6ab(%rip),%xmm6
subpd  %xmm5,%xmm6
subpd  %xmm5,%xmm3
movapd %xmm13,%xmm5
addpd  %xmm1,%xmm5
subpd  %xmm1,%xmm13
movapd %xmm13,-0x10(%rsp)
movapd %xmm9,%xmm8
addpd  %xmm10,%xmm8
subpd  %xmm10,%xmm9
movapd %xmm4,%xmm10
subpd  %xmm12,%xmm10
addpd  %xmm4,%xmm12
movapd %xmm2,%xmm4
addpd  %xmm7,%xmm4
subpd  %xmm7,%xmm2
movapd %xmm14,%xmm1
movapd -0x60(%rsp),%xmm0
addpd  %xmm0,%xmm1
subpd  %xmm0,%xmm14
movapd %xmm14,-0x60(%rsp)
movapd -0x70(%rsp),%xmm0
movapd %xmm0,%xmm14
movapd -0x50(%rsp),%xmm7
addpd  %xmm7,%xmm14
subpd  %xmm7,%xmm0
movapd %xmm0,-0x70(%rsp)
movapd %xmm11,%xmm13
addpd  %xmm6,%xmm13
subpd  %xmm6,%xmm11
movapd %xmm15,%xmm7
addpd  %xmm3,%xmm7
subpd  %xmm3,%xmm15
movapd %xmm1,%xmm3
addpd  %xmm5,%xmm3
movapd %xmm14,%xmm6
addpd  %xmm8,%xmm6
movapd %xmm3,%xmm0
unpcklpd %xmm6,%xmm0
movhlps %xmm3,%xmm6
movups %xmm6,0x10(%rcx,%rax,1)
movupd %xmm0,(%rcx,%rax,1)
subpd  %xmm1,%xmm5
subpd  %xmm14,%xmm8
movapd %xmm5,%xmm0
unpcklpd %xmm8,%xmm0
movhlps %xmm5,%xmm8
movups %xmm8,0x10(%r8,%rax,1)
movupd %xmm0,(%r8,%rax,1)
movapd 0x20(%rsp),%xmm5
mulpd  %xmm5,%xmm13
movapd %xmm13,%xmm0
addpd  %xmm10,%xmm0
mulpd  %xmm5,%xmm7
movapd %xmm7,%xmm1
addpd  %xmm4,%xmm1
movapd %xmm0,%xmm3
unpcklpd %xmm1,%xmm3
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rbx,%rax,1)
movupd %xmm3,(%rbx,%rax,1)
subpd  %xmm13,%xmm10
subpd  %xmm7,%xmm4
movapd %xmm10,%xmm0
unpcklpd %xmm4,%xmm0
movhlps %xmm10,%xmm4
mov    -0x18(%rsp),%rdx
movups %xmm4,0x10(%rdx,%rax,1)
movupd %xmm0,(%rdx,%rax,1)
movapd -0x10(%rsp),%xmm4
movapd %xmm4,%xmm0
movapd -0x70(%rsp),%xmm7
subpd  %xmm7,%xmm0
movapd -0x60(%rsp),%xmm6
movapd %xmm6,%xmm1
addpd  %xmm9,%xmm1
movapd %xmm0,%xmm3
unpcklpd %xmm1,%xmm3
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rdi,%rax,1)
movupd %xmm3,(%rdi,%rax,1)
movapd %xmm7,%xmm1
addpd  %xmm4,%xmm1
subpd  %xmm6,%xmm9
movapd %xmm1,%xmm0
unpcklpd %xmm9,%xmm0
movhlps %xmm1,%xmm9
mov    0x2e0(%rsp),%rdx
movups %xmm9,0x10(%rdx,%rax,1)
movupd %xmm0,(%rdx,%rax,1)
mulpd  %xmm5,%xmm15
movapd %xmm12,%xmm0
subpd  %xmm15,%xmm0
mulpd  %xmm5,%xmm11
movapd %xmm11,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm0,%xmm3
unpcklpd %xmm1,%xmm3
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rsi,%rax,1)
movupd %xmm3,(%rsi,%rax,1)
addpd  %xmm12,%xmm15
subpd  %xmm11,%xmm2
movapd %xmm15,%xmm0
unpcklpd %xmm2,%xmm0
movhlps %xmm15,%xmm2
mov    0x2e8(%rsp),%r15
movups %xmm2,0x10(%r15,%rax,1)
movupd %xmm0,(%r15,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rbp
jne    27e0 <kern_r8_fma_o_b+0x16e0>
mov    (%rsp),%r9
cmp    0x340(%rsp),%r9
movapd 0x10(%rsp),%xmm13
jne    117e <kern_r8_fma_o_b+0x7e>
jmp    14a8 <kern_r8_fma_o_b+0x3a8>

LLVM IR (-O0):
define void @kern_r8_fma_o_b(double* noalias %0, double* noalias %1, double* noalias %2, double* noalias %3, double* noalias %4, double* noalias %5, double* noalias %6, double* noalias %7, double* %8, double* %9, double* %10, double* %11, double* %12, double* %13, double* %14, double* %15, double* %16, double* %17, i64 %18, i64 %19) {
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
%35 = alloca double*
%36 = alloca double*
%37 = alloca double*
%38 = alloca double*
%39 = alloca i64
%40 = alloca i64
%41 = alloca i64
%42 = alloca i64
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
%68 = alloca double
%69 = alloca double
%70 = alloca double
%71 = alloca double
%72 = alloca double
%73 = alloca double
%74 = alloca double
%75 = alloca double
%76 = alloca double
%77 = alloca double
%78 = alloca double
%79 = alloca double
%80 = alloca double
%81 = alloca double
%82 = alloca double
%83 = alloca double
%84 = alloca double
%85 = alloca double
%86 = alloca double
%87 = alloca double
%88 = alloca double
%89 = alloca double
%90 = alloca double
%91 = alloca double
%92 = alloca double
%93 = alloca double
%94 = alloca double
%95 = alloca double
%96 = alloca double
%97 = alloca double
%98 = alloca double
%99 = alloca double
%100 = alloca double
%101 = alloca double
%102 = alloca double
%103 = alloca double
%104 = alloca double
%105 = alloca double
%106 = alloca double
%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 = fsub double %349, %350
store double %351, double* %58
%352 = load double, double* %45
%353 = load double, double* %44
%354 = fadd double %352, %353
store double %354, double* %59
%355 = load double, double* %46
%356 = fneg double %355
%357 = load double, double* %47
%358 = fsub double %356, %357
store double %358, double* %62
%359 = load double, double* %47
%360 = fneg double %359
%361 = load double, double* %46
%362 = fadd 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 = fsub double %375, %376
store double %377, double* %72
%378 = load double, double* %57
%379 = load double, double* %60
%380 = fadd double %378, %379
store double %380, double* %73
%381 = load double, double* %56
%382 = load double, double* %61
%383 = fadd double %381, %382
store double %383, double* %76
%384 = load double, double* %57
%385 = load double, double* %60
%386 = fsub 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 = fsub 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 = fadd 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 = fadd 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 = fsub 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 = fneg double %508
%511 = call double @llvm.fmuladd.f64(double %510, double %509, double %507)
%512 = load double*, double** %24
%513 = load i64, i64* %42
%514 = mul nsw i64 2, %513
%515 = getelementptr inbounds double, double* %512, i64 %514
store double %511, double* %515
%516 = load double, double* %77
%517 = load double, double* %78
%518 = load double, double* %43
%519 = call double @llvm.fmuladd.f64(double %517, double %518, double %516)
%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 = call double @llvm.fmuladd.f64(double %526, double %527, double %525)
%529 = load double*, double** %28
%530 = load i64, i64* %42
%531 = mul nsw i64 2, %530
%532 = getelementptr inbounds double, double* %529, i64 %531
store double %528, double* %532
%533 = load double, double* %77
%534 = load double, double* %78
%535 = load double, double* %43
%536 = fneg double %534
%537 = call double @llvm.fmuladd.f64(double %536, double %535, double %533)
%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 = fneg double %757
%759 = call double @llvm.fmuladd.f64(double %750, double %751, double %758)
store double %759, double* %98
%760 = load double*, double** %34
%761 = load i64, i64* %42
%762 = mul nsw i64 2, %761
%763 = add nsw i64 %762, 1
%764 = getelementptr inbounds double, double* %760, i64 %763
%765 = load double, double* %764
%766 = load double, double* %86
%767 = load double*, double** %34
%768 = load i64, i64* %42
%769 = mul nsw i64 2, %768
%770 = getelementptr inbounds double, double* %767, i64 %769
%771 = load double, double* %770
%772 = call double @llvm.fmuladd.f64(double %765, double %766, 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 = fneg double %784
%786 = call double @llvm.fmuladd.f64(double %777, double %778, double %785)
store double %786, double* %102
%787 = load double*, double** %36
%788 = load i64, i64* %42
%789 = mul nsw i64 2, %788
%790 = add nsw i64 %789, 1
%791 = getelementptr inbounds double, double* %787, i64 %790
%792 = load double, double* %791
%793 = load double, double* %86
%794 = load double*, double** %36
%795 = load i64, i64* %42
%796 = mul nsw i64 2, %795
%797 = getelementptr inbounds double, double* %794, i64 %796
%798 = load double, double* %797
%799 = call double @llvm.fmuladd.f64(double %792, double %793, 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 = fneg double %811
%813 = call double @llvm.fmuladd.f64(double %804, double %805, double %812)
store double %813, double* %94
%814 = load double*, double** %31
%815 = load i64, i64* %42
%816 = mul nsw i64 2, %815
%817 = add nsw i64 %816, 1
%818 = getelementptr inbounds double, double* %814, i64 %817
%819 = load double, double* %818
%820 = load double, double* %82
%821 = load double*, double** %31
%822 = load i64, i64* %42
%823 = mul nsw i64 2, %822
%824 = getelementptr inbounds double, double* %821, i64 %823
%825 = load double, double* %824
%826 = call double @llvm.fmuladd.f64(double %819, double %820, 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 = fneg double %838
%840 = call double @llvm.fmuladd.f64(double %831, double %832, double %839)
store double %840, double* %96
%841 = load double*, double** %33
%842 = load i64, i64* %42
%843 = mul nsw i64 2, %842
%844 = add nsw i64 %843, 1
%845 = getelementptr inbounds double, double* %841, i64 %844
%846 = load double, double* %845
%847 = load double, double* %86
%848 = load double*, double** %33
%849 = load i64, i64* %42
%850 = mul nsw i64 2, %849
%851 = getelementptr inbounds double, double* %848, i64 %850
%852 = load double, double* %851
%853 = call double @llvm.fmuladd.f64(double %846, double %847, 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 = fneg double %865
%867 = call double @llvm.fmuladd.f64(double %858, double %859, double %866)
store double %867, double* %100
%868 = load double*, double** %35
%869 = load i64, i64* %42
%870 = mul nsw i64 2, %869
%871 = add nsw i64 %870, 1
%872 = getelementptr inbounds double, double* %868, i64 %871
%873 = load double, double* %872
%874 = load double, double* %90
%875 = load double*, double** %35
%876 = load i64, i64* %42
%877 = mul nsw i64 2, %876
%878 = getelementptr inbounds double, double* %875, i64 %877
%879 = load double, double* %878
%880 = call double @llvm.fmuladd.f64(double %873, double %874, 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 = fneg double %1009
%1011 = call double @llvm.fmuladd.f64(double %1007, double %1008, double %1010)
store double %1011, double* %114
%1012 = load double, double* %105
%1013 = load double, double* %80
%1014 = load double, double* %104
%1015 = call double @llvm.fmuladd.f64(double %1012, double %1013, double %1014)
store double %1015, double* %115
%1016 = load double, double* %106
%1017 = load double, double* %84
%1018 = load double, double* %107
%1019 = fneg double %1018
%1020 = call double @llvm.fmuladd.f64(double %1016, double %1017, double %1019)
store double %1020, double* %118
%1021 = load double, double* %107
%1022 = load double, double* %84
%1023 = load double, double* %106
%1024 = call double @llvm.fmuladd.f64(double %1021, double %1022, double %1023)
store double %1024, double* %119
%1025 = load double, double* %108
%1026 = load double, double* %88
%1027 = load double, double* %109
%1028 = fneg double %1027
%1029 = call double @llvm.fmuladd.f64(double %1025, double %1026, double %1028)
store double %1029, double* %122
%1030 = load double, double* %109
%1031 = load double, double* %88
%1032 = load double, double* %108
%1033 = call double @llvm.fmuladd.f64(double %1030, double %1031, double %1032)
store double %1033, double* %123
%1034 = load double, double* %110
%1035 = load double, double* %92
%1036 = load double, double* %111
%1037 = fneg double %1036
%1038 = call double @llvm.fmuladd.f64(double %1034, double %1035, double %1037)
store double %1038, double* %126
%1039 = load double, double* %111
%1040 = load double, double* %92
%1041 = load double, double* %110
%1042 = call double @llvm.fmuladd.f64(double %1039, double %1040, 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 = fneg double %1062
%1065 = call double @llvm.fmuladd.f64(double %1064, double %1063, double %1061)
store double %1065, double* %136
%1066 = load double, double* %121
%1067 = load double, double* %124
%1068 = load double, double* %83
%1069 = call double @llvm.fmuladd.f64(double %1067, double %1068, double %1066)
store double %1069, double* %137
%1070 = load double, double* %120
%1071 = load double, double* %125
%1072 = load double, double* %83
%1073 = call double @llvm.fmuladd.f64(double %1071, double %1072, double %1070)
store double %1073, double* %140
%1074 = load double, double* %121
%1075 = load double, double* %124
%1076 = load double, double* %83
%1077 = fneg double %1075
%1078 = call double @llvm.fmuladd.f64(double %1077, double %1076, double %1074)
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 = fneg double %1188
%1191 = call double @llvm.fmuladd.f64(double %1190, double %1189, double %1187)
%1192 = load double*, double** %23
%1193 = load i64, i64* %42
%1194 = mul nsw i64 2, %1193
%1195 = getelementptr inbounds double, double* %1192, i64 %1194
store double %1191, double* %1195
%1196 = load double, double* %133
%1197 = load double, double* %134
%1198 = load double, double* %81
%1199 = call double @llvm.fmuladd.f64(double %1197, double %1198, double %1196)
%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 = call double @llvm.fmuladd.f64(double %1206, double %1207, double %1205)
%1209 = load double*, double** %27
%1210 = load i64, i64* %42
%1211 = mul nsw i64 2, %1210
%1212 = getelementptr inbounds double, double* %1209, i64 %1211
store double %1208, double* %1212
%1213 = load double, double* %133
%1214 = load double, double* %134
%1215 = load double, double* %81
%1216 = fneg double %1214
%1217 = call double @llvm.fmuladd.f64(double %1216, double %1215, double %1213)
%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 = fneg double %1224
%1227 = call double @llvm.fmuladd.f64(double %1226, double %1225, double %1223)
%1228 = load double*, double** %24
%1229 = load i64, i64* %42
%1230 = mul nsw i64 2, %1229
%1231 = getelementptr inbounds double, double* %1228, i64 %1230
store double %1227, double* %1231
%1232 = load double, double* %141
%1233 = load double, double* %142
%1234 = load double, double* %89
%1235 = call double @llvm.fmuladd.f64(double %1233, double %1234, double %1232)
%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 = call double @llvm.fmuladd.f64(double %1242, double %1243, double %1241)
%1245 = load double*, double** %28
%1246 = load i64, i64* %42
%1247 = mul nsw i64 2, %1246
%1248 = getelementptr inbounds double, double* %1245, i64 %1247
store double %1244, double* %1248
%1249 = load double, double* %141
%1250 = load double, double* %142
%1251 = load double, double* %89
%1252 = fneg double %1250
%1253 = call double @llvm.fmuladd.f64(double %1252, double %1251, double %1249)
%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_b(double* noalias nocapture writeonly %0, double* noalias nocapture writeonly %1, double* noalias nocapture writeonly %2, double* noalias nocapture writeonly %3, double* noalias nocapture writeonly %4, double* noalias nocapture writeonly %5, double* noalias nocapture writeonly %6, double* noalias nocapture writeonly %7, double* nocapture %8, double* nocapture %9, double* nocapture %10, double* nocapture %11, double* nocapture %12, double* nocapture %13, double* nocapture %14, double* nocapture %15, double* nocapture %16, double* nocapture %17, i64 %18, i64 %19) {
%21 = 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 = fsub <2 x double> %128, %131
%175 = fadd <2 x double> %128, %131
%176 = fneg <2 x double> %143
%177 = fsub <2 x double> %176, %145
%178 = fsub <2 x double> %143, %145
%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 = fsub <2 x double> %157, %173
%184 = fadd <2 x double> %159, %171
%185 = fadd <2 x double> %157, %173
%186 = fsub <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, %177
%192 = fadd <2 x double> %175, %178
%193 = fsub <2 x double> %174, %177
%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 = fsub <2 x double> %181, %190
%218 = fadd <2 x double> %189, %182
%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 = fadd <2 x double> %190, %181
%223 = fsub <2 x double> %182, %189
%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 = fneg <2 x double> %194
%228 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %227, <2 x double> %105, <2 x double> %185)
%229 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %193, <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> %228, <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 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %194, <2 x double> %105, <2 x double> %185)
%234 = fneg <2 x double> %193
%235 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %234, <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> %233, <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 = extractelement <2 x double> %265, i64 0
%267 = fadd <2 x double> %262, %264
%268 = fsub <2 x double> %262, %264
%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> %256, <2 x double> undef, <2 x i32> zeroinitializer
%287 = shufflevector <2 x double> %258, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%288 = fsub <2 x double> %286, %287
%289 = fadd <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 %266
%292 = insertelement <2 x double> poison, double %291, i64 0
%293 = shufflevector <2 x double> %292, <2 x double> %265, <2 x i32> <i32 0, i32 2>
%294 = shufflevector <2 x double> %268, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%295 = fsub <2 x double> %293, %294
%296 = fadd <2 x double> %275, %283
%297 = fsub <2 x double> %276, %285
%298 = fadd <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, %267
%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> %267, <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> %267, <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 = fsub <2 x double> %304, %307
%328 = fadd <2 x double> %304, %307
%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 = fadd <2 x double> %307, %304
%333 = fsub <2 x double> %307, %304
%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 = fneg double %312
%337 = getelementptr inbounds double, double* %3, i64 %249
%338 = insertelement <2 x double> poison, double %336, i64 0
%339 = shufflevector <2 x double> %338, <2 x double> %309, <2 x i32> <i32 0, i32 2>
%340 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %339, <2 x double> %246, <2 x double> %300)
%341 = bitcast double* %337 to <2 x double>*
store <2 x double> %340, <2 x double>* %341
%342 = getelementptr inbounds double, double* %7, i64 %249
%343 = fneg double %310
%344 = insertelement <2 x double> poison, double %312, i64 0
%345 = insertelement <2 x double> %344, double %343, i64 1
%346 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %345, <2 x double> %246, <2 x double> %300)
%347 = bitcast double* %342 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 %910
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, %906
%386 = phi i64 [ 0, %354 ], [ %909, %906 ]
%387 = phi double* [ %15, %354 ], [ %437, %906 ]
%388 = phi double* [ %14, %354 ], [ %436, %906 ]
%389 = phi double* [ %13, %354 ], [ %435, %906 ]
%390 = phi double* [ %12, %354 ], [ %434, %906 ]
%391 = phi double* [ %11, %354 ], [ %433, %906 ]
%392 = phi double* [ %10, %354 ], [ %432, %906 ]
%393 = phi double* [ %9, %354 ], [ %431, %906 ]
%394 = phi double* [ %8, %354 ], [ %430, %906 ]
%395 = phi double* [ %7, %354 ], [ %429, %906 ]
%396 = phi double* [ %6, %354 ], [ %428, %906 ]
%397 = phi double* [ %5, %354 ], [ %427, %906 ]
%398 = phi double* [ %4, %354 ], [ %426, %906 ]
%399 = phi double* [ %3, %354 ], [ %425, %906 ]
%400 = phi double* [ %2, %354 ], [ %424, %906 ]
%401 = phi double* [ %1, %354 ], [ %423, %906 ]
%402 = phi double* [ %0, %354 ], [ %422, %906 ]
%403 = phi i64 [ 1, %354 ], [ %907, %906 ]
%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 %906
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 = fneg <2 x double> %554
%557 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %553, <2 x double> %512, <2 x double> %556)
%558 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %554, <2 x double> %512, <2 x double> %553)
%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 = fneg <2 x double> %563
%565 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %562, <2 x double> %512, <2 x double> %564)
%566 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %563, <2 x double> %512, <2 x double> %562)
%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 = fneg <2 x double> %571
%573 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %570, <2 x double> %514, <2 x double> %572)
%574 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %571, <2 x double> %514, <2 x double> %570)
%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 = fneg <2 x double> %579
%581 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %578, <2 x double> %512, <2 x double> %580)
%582 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %579, <2 x double> %512, <2 x double> %578)
%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 = fneg <2 x double> %587
%589 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %586, <2 x double> %516, <2 x double> %588)
%590 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %587, <2 x double> %516, <2 x double> %586)
%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> %557, <2 x double> %518, <2 x double> %594)
%597 = fneg <2 x double> %557
%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> %565, <2 x double> %518, <2 x double> %605)
%608 = fneg <2 x double> %565
%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> %581, <2 x double> %518, <2 x double> %616)
%619 = fneg <2 x double> %581
%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> %589, <2 x double> %520, <2 x double> %573)
%625 = fneg <2 x double> %589
%626 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %625, <2 x double> %520, <2 x double> %573)
%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 = fneg <2 x double> %599
%631 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %596, <2 x double> %522, <2 x double> %630)
%632 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %599, <2 x double> %522, <2 x double> %596)
%633 = fneg <2 x double> %610
%634 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %607, <2 x double> %524, <2 x double> %633)
%635 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %610, <2 x double> %524, <2 x double> %607)
%636 = fneg <2 x double> %601
%637 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %598, <2 x double> %526, <2 x double> %636)
%638 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %601, <2 x double> %526, <2 x double> %598)
%639 = fneg <2 x double> %612
%640 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %609, <2 x double> %528, <2 x double> %639)
%641 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %612, <2 x double> %528, <2 x double> %609)
%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 = fneg <2 x double> %629
%649 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %648, <2 x double> %530, <2 x double> %620)
%650 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %626, <2 x double> %530, <2 x double> %623)
%651 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %629, <2 x double> %530, <2 x double> %620)
%652 = fneg <2 x double> %626
%653 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %652, <2 x double> %530, <2 x double> %623)
%654 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %634, <2 x double> %532, <2 x double> %631)
%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> %634
%657 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %656, <2 x double> %532, <2 x double> %631)
%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> %640, <2 x double> %534, <2 x double> %637)
%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> %640
%663 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %662, <2 x double> %534, <2 x double> %637)
%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> %649)
%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> %649)
%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 = fneg <2 x double> %659
%691 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %690, <2 x double> %536, <2 x double> %645)
%692 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %657, <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> %691, <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 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %659, <2 x double> %536, <2 x double> %645)
%697 = fneg <2 x double> %657
%698 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %697, <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> %696, <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 = fneg <2 x double> %665
%703 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %702, <2 x double> %538, <2 x double> %651)
%704 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %663, <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> %703, <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 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %665, <2 x double> %538, <2 x double> %651)
%709 = fneg <2 x double> %663
%710 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %709, <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> %708, <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 %906, 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 [ %904, %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 1
%754 = fneg double %753
%755 = insertelement <2 x double> poison, double %754, i64 0
%756 = shufflevector <2 x double> %755, <2 x double> %752, <2 x i32> <i32 0, i32 2>
%757 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %752, <2 x double> %720, <2 x double> %756)
%758 = getelementptr inbounds double, double* %437, i64 %749
%759 = bitcast double* %758 to <2 x double>*
%760 = load <2 x double>, <2 x double>* %759
%761 = extractelement <2 x double> %760, i64 1
%762 = fneg double %761
%763 = insertelement <2 x double> poison, double %762, i64 0
%764 = shufflevector <2 x double> %763, <2 x double> %760, <2 x i32> <i32 0, i32 2>
%765 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %760, <2 x double> %720, <2 x double> %764)
%766 = getelementptr inbounds double, double* %432, i64 %749
%767 = bitcast double* %766 to <2 x double>*
%768 = load <2 x double>, <2 x double>* %767
%769 = extractelement <2 x double> %768, i64 1
%770 = fneg double %769
%771 = insertelement <2 x double> poison, double %770, i64 0
%772 = shufflevector <2 x double> %771, <2 x double> %768, <2 x i32> <i32 0, i32 2>
%773 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %768, <2 x double> %722, <2 x double> %772)
%774 = getelementptr inbounds double, double* %434, i64 %749
%775 = bitcast double* %774 to <2 x double>*
%776 = load <2 x double>, <2 x double>* %775
%777 = extractelement <2 x double> %776, i64 1
%778 = fneg double %777
%779 = insertelement <2 x double> poison, double %778, i64 0
%780 = shufflevector <2 x double> %779, <2 x double> %776, <2 x i32> <i32 0, i32 2>
%781 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %776, <2 x double> %720, <2 x double> %780)
%782 = getelementptr inbounds double, double* %436, i64 %749
%783 = bitcast double* %782 to <2 x double>*
%784 = load <2 x double>, <2 x double>* %783
%785 = extractelement <2 x double> %784, i64 1
%786 = fneg double %785
%787 = insertelement <2 x double> poison, double %786, i64 0
%788 = shufflevector <2 x double> %787, <2 x double> %784, <2 x i32> <i32 0, i32 2>
%789 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %784, <2 x double> %724, <2 x double> %788)
%790 = getelementptr inbounds double, double* %431, i64 %749
%791 = bitcast double* %790 to <2 x double>*
%792 = load <2 x double>, <2 x double>* %791
%793 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %757, <2 x double> %726, <2 x double> %792)
%794 = fneg <2 x double> %757
%795 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %794, <2 x double> %726, <2 x double> %792)
%796 = getelementptr inbounds double, double* %433, i64 %749
%797 = bitcast double* %796 to <2 x double>*
%798 = load <2 x double>, <2 x double>* %797
%799 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %765, <2 x double> %726, <2 x double> %798)
%800 = fneg <2 x double> %765
%801 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %800, <2 x double> %726, <2 x double> %798)
%802 = getelementptr inbounds double, double* %430, i64 %749
%803 = bitcast double* %802 to <2 x double>*
%804 = load <2 x double>, <2 x double>* %803
%805 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %781, <2 x double> %726, <2 x double> %804)
%806 = fneg <2 x double> %781
%807 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %806, <2 x double> %726, <2 x double> %804)
%808 = extractelement <2 x double> %789, i64 0
%809 = fneg double %808
%810 = extractelement <2 x double> %773, i64 0
%811 = tail call double @llvm.fmuladd.f64(double %809, double %455, double %810)
%812 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %789, <2 x double> %728, <2 x double> %773)
%813 = extractelement <2 x double> %789, i64 1
%814 = fneg double %813
%815 = extractelement <2 x double> %773, i64 1
%816 = tail call double @llvm.fmuladd.f64(double %814, double %455, double %815)
%817 = extractelement <2 x double> %793, i64 1
%818 = fneg double %817
%819 = insertelement <2 x double> poison, double %818, i64 0
%820 = shufflevector <2 x double> %819, <2 x double> %793, <2 x i32> <i32 0, i32 2>
%821 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %793, <2 x double> %730, <2 x double> %820)
%822 = extractelement <2 x double> %799, i64 1
%823 = fneg double %822
%824 = insertelement <2 x double> poison, double %823, i64 0
%825 = shufflevector <2 x double> %824, <2 x double> %799, <2 x i32> <i32 0, i32 2>
%826 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %799, <2 x double> %732, <2 x double> %825)
%827 = extractelement <2 x double> %795, i64 1
%828 = fneg double %827
%829 = insertelement <2 x double> poison, double %828, i64 0
%830 = shufflevector <2 x double> %829, <2 x double> %795, <2 x i32> <i32 0, i32 2>
%831 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %795, <2 x double> %734, <2 x double> %830)
%832 = extractelement <2 x double> %801, i64 1
%833 = fneg double %832
%834 = insertelement <2 x double> poison, double %833, i64 0
%835 = shufflevector <2 x double> %834, <2 x double> %801, <2 x i32> <i32 0, i32 2>
%836 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %801, <2 x double> %736, <2 x double> %835)
%837 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %812, <2 x double> %738, <2 x double> %805)
%838 = fneg <2 x double> %812
%839 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %838, <2 x double> %738, <2 x double> %805)
%840 = fneg double %816
%841 = insertelement <2 x double> poison, double %840, i64 0
%842 = insertelement <2 x double> %841, double %811, i64 1
%843 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %842, <2 x double> %738, <2 x double> %807)
%844 = fneg double %811
%845 = insertelement <2 x double> poison, double %816, i64 0
%846 = insertelement <2 x double> %845, double %844, i64 1
%847 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %846, <2 x double> %738, <2 x double> %807)
%848 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %826, <2 x double> %740, <2 x double> %821)
%849 = extractelement <2 x double> %826, i64 0
%850 = fneg double %849
%851 = extractelement <2 x double> %821, i64 0
%852 = tail call double @llvm.fmuladd.f64(double %850, double %466, double %851)
%853 = extractelement <2 x double> %826, i64 1
%854 = fneg double %853
%855 = extractelement <2 x double> %821, i64 1
%856 = tail call double @llvm.fmuladd.f64(double %854, double %466, double %855)
%857 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %836, <2 x double> %742, <2 x double> %831)
%858 = extractelement <2 x double> %836, i64 0
%859 = fneg double %858
%860 = extractelement <2 x double> %831, i64 0
%861 = tail call double @llvm.fmuladd.f64(double %859, double %476, double %860)
%862 = extractelement <2 x double> %836, i64 1
%863 = fneg double %862
%864 = extractelement <2 x double> %831, i64 1
%865 = tail call double @llvm.fmuladd.f64(double %863, double %476, double %864)
%866 = getelementptr inbounds double, double* %422, i64 %749
%867 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %848, <2 x double> %744, <2 x double> %837)
%868 = bitcast double* %866 to <2 x double>*
store <2 x double> %867, <2 x double>* %868
%869 = getelementptr inbounds double, double* %426, i64 %749
%870 = fneg <2 x double> %848
%871 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %870, <2 x double> %744, <2 x double> %837)
%872 = bitcast double* %869 to <2 x double>*
store <2 x double> %871, <2 x double>* %872
%873 = getelementptr inbounds double, double* %423, i64 %749
%874 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %857, <2 x double> %746, <2 x double> %843)
%875 = bitcast double* %873 to <2 x double>*
store <2 x double> %874, <2 x double>* %875
%876 = getelementptr inbounds double, double* %427, i64 %749
%877 = fneg <2 x double> %857
%878 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %877, <2 x double> %746, <2 x double> %843)
%879 = bitcast double* %876 to <2 x double>*
store <2 x double> %878, <2 x double>* %879
%880 = fneg double %856
%881 = getelementptr inbounds double, double* %424, i64 %749
%882 = insertelement <2 x double> poison, double %880, i64 0
%883 = insertelement <2 x double> %882, double %852, i64 1
%884 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %883, <2 x double> %744, <2 x double> %839)
%885 = bitcast double* %881 to <2 x double>*
store <2 x double> %884, <2 x double>* %885
%886 = getelementptr inbounds double, double* %428, i64 %749
%887 = fneg double %852
%888 = insertelement <2 x double> poison, double %856, i64 0
%889 = insertelement <2 x double> %888, double %887, i64 1
%890 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %889, <2 x double> %744, <2 x double> %839)
%891 = bitcast double* %886 to <2 x double>*
store <2 x double> %890, <2 x double>* %891
%892 = fneg double %865
%893 = getelementptr inbounds double, double* %425, i64 %749
%894 = insertelement <2 x double> poison, double %892, i64 0
%895 = insertelement <2 x double> %894, double %861, i64 1
%896 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %895, <2 x double> %746, <2 x double> %847)
%897 = bitcast double* %893 to <2 x double>*
store <2 x double> %896, <2 x double>* %897
%898 = getelementptr inbounds double, double* %429, i64 %749
%899 = fneg double %861
%900 = insertelement <2 x double> poison, double %865, i64 0
%901 = insertelement <2 x double> %900, double %899, i64 1
%902 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %901, <2 x double> %746, <2 x double> %847)
%903 = bitcast double* %898 to <2 x double>*
store <2 x double> %902, <2 x double>* %903
%904 = add nuw nsw i64 %748, 1
%905 = icmp eq i64 %904, %18
br i1 %905, label %906, label %747
906: ; preds = %747, %716, %385
%907 = add nuw nsw i64 %403, 1
%908 = icmp eq i64 %907, %19
%909 = add i64 %386, 1
br i1 %908, label %910, label %385
910: ; preds = %906, %350
ret void
}