void kern_r8_n_f(double *restrict o0, double *restrict o1, double *restrict o2,
                 double *restrict o3, double *restrict o4, double *restrict o5,
                 double *restrict o6, double *restrict o7, double *i0,
                 double *i1, double *i2, double *i3, double *i4, double *i5,
                 double *i6, double *i7, double *w, long bsize, long blocks) {
  long i, j;
  for (i = 0; i < blocks; i++) {
    double wr1, wi1;
    double wr2, wi2;
    double wr3, wi3;
    double wr4, wi4;
    double wr5, wi5;
    double wr6, wi6;
    double wr7, wi7;
    wr4 = w[8 * i * bsize];
    wi4 = w[8 * i * bsize + 1];
    wr2 = w[4 * i * bsize];
    wi2 = w[4 * i * bsize + 1];
    wr6 = w[12 * i * bsize];
    wi6 = w[12 * i * bsize + 1];
    wr1 = w[2 * i * bsize];
    wi1 = w[2 * i * bsize + 1];
    wr3 = w[6 * i * bsize];
    wi3 = w[6 * i * bsize + 1];
    wr5 = w[2 * i * bsize + 2 * blocks * bsize];
    wi5 = w[2 * i * bsize + 2 * blocks * bsize + 1];
    wr7 = w[6 * i * bsize + 6 * blocks * bsize];
    wi7 = w[6 * i * bsize + 6 * 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] * wi4;
      pi5 = i5[2 * j + 1] * wr4 - i5[2 * j] * wi4;
      pr7 = i7[2 * j] * wr4 + i7[2 * j + 1] * wi4;
      pi7 = i7[2 * j + 1] * wr4 - i7[2 * j] * wi4;
      pr2 = i2[2 * j] * wr2 + i2[2 * j + 1] * wi2;
      pi2 = i2[2 * j + 1] * wr2 - i2[2 * j] * wi2;
      pr4 = i4[2 * j] * wr4 + i4[2 * j + 1] * wi4;
      pi4 = i4[2 * j + 1] * wr4 - i4[2 * j] * wi4;
      pr6 = i6[2 * j] * wr6 + i6[2 * j + 1] * wi6;
      pi6 = i6[2 * j + 1] * wr6 - i6[2 * j] * wi6;
      sr1 = i1[2 * j] + pr5;
      sr5 = i1[2 * j] - pr5;
      si1 = i1[2 * j + 1] + pi5;
      si5 = i1[2 * j + 1] - pi5;
      sr3 = i3[2 * j] + pr7;
      sr7 = i3[2 * j] - pr7;
      si3 = i3[2 * j + 1] + pi7;
      si7 = i3[2 * j + 1] - pi7;
      qr0 = i0[2 * j] + pr4;
      qr4 = i0[2 * j] - pr4;
      qi0 = i0[2 * j + 1] + pi4;
      qi4 = i0[2 * j + 1] - pi4;
      qr2 = pr2 + pr6;
      qr6 = pr2 - pr6;
      qi2 = pi2 + pi6;
      qi6 = pi2 - pi6;
      qr1 = sr1 * wr1 + si1 * wi1;
      qi1 = si1 * wr1 - sr1 * wi1;
      qr3 = sr3 * wr3 + si3 * wi3;
      qi3 = si3 * wr3 - sr3 * wi3;
      qr5 = sr5 * wr5 + si5 * wi5;
      qi5 = si5 * wr5 - sr5 * wi5;
      qr7 = sr7 * wr7 + si7 * wi7;
      qi7 = si7 * wr7 - sr7 * wi7;
      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;
      o1[2 * j + 1] = ti4 + ti5;
      o5[2 * j] = tr4 - tr5;
      o5[2 * j + 1] = ti4 - ti5;
      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;
      o3[2 * j + 1] = ti6 - tr7;
      o7[2 * j] = tr6 - ti7;
      o7[2 * j + 1] = ti6 + tr7;
    }
    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_n_f>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    0x70(%rbp),%rax
jge    1ecf <kern_r8_n_f+0xdcf>
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
imul   0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
imul   0x68(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x2,%rcx
imul   0x68(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x60(%rbp),%rax
imul   $0xc,-0x38(%rbp),%rcx
imul   0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x60(%rbp),%rax
imul   $0xc,-0x38(%rbp),%rcx
imul   0x68(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x68(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x60(%rbp),%rax
imul   $0x6,-0x38(%rbp),%rcx
imul   0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x60(%rbp),%rax
imul   $0x6,-0x38(%rbp),%rcx
imul   0x68(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x68(%rbp),%rcx
mov    0x70(%rbp),%rdx
shl    $0x1,%rdx
imul   0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
imul   0x68(%rbp),%rcx
mov    0x70(%rbp),%rdx
shl    $0x1,%rdx
imul   0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x60(%rbp),%rax
imul   $0x6,-0x38(%rbp),%rcx
imul   0x68(%rbp),%rcx
imul   $0x6,0x70(%rbp),%rdx
imul   0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x60(%rbp),%rax
imul   $0x6,-0x38(%rbp),%rcx
imul   0x68(%rbp),%rcx
imul   $0x6,0x70(%rbp),%rdx
imul   0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    0x68(%rbp),%rax
jge    1d7e <kern_r8_n_f+0xc7e>
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
subsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
addsd  -0x100(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
subsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x188(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
subsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
subsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0x110(%rbp),%xmm1
ff
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm2
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x118(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x128(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x140(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
addsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
addsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
subsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
subsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
addsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
subsd  -0x1a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
subsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
addsd  -0x1a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
addsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
addsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
subsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
subsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
addsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm0
ff
addsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
subsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x238(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm0
ff
subsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
addsd  -0x1d8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1d0(%rbp),%xmm0
ff
addsd  -0x1e0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x1c8(%rbp),%xmm0
ff
subsd  -0x1d8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1d0(%rbp),%xmm0
ff
subsd  -0x1e0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x208(%rbp),%xmm0
ff
addsd  -0x218(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x210(%rbp),%xmm0
ff
addsd  -0x220(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x208(%rbp),%xmm0
ff
subsd  -0x218(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x210(%rbp),%xmm0
ff
subsd  -0x220(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x1e8(%rbp),%xmm0
ff
addsd  -0x200(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1f0(%rbp),%xmm0
ff
subsd  -0x1f8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x1e8(%rbp),%xmm0
ff
subsd  -0x200(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1f0(%rbp),%xmm0
ff
addsd  -0x1f8(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x228(%rbp),%xmm0
ff
addsd  -0x240(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x230(%rbp),%xmm0
ff
subsd  -0x238(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x228(%rbp),%xmm0
ff
subsd  -0x240(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x230(%rbp),%xmm0
ff
addsd  -0x238(%rbp),%xmm0
ff
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    1330 <kern_r8_n_f+0x230>
mov    0x68(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x20(%rbp),%rax
mov    %rax,0x20(%rbp)
mov    0x68(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x28(%rbp),%rax
mov    %rax,0x28(%rbp)
mov    0x68(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x30(%rbp),%rax
mov    %rax,0x30(%rbp)
mov    0x68(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x38(%rbp),%rax
mov    %rax,0x38(%rbp)
mov    0x68(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x40(%rbp),%rax
mov    %rax,0x40(%rbp)
mov    0x68(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x48(%rbp),%rax
mov    %rax,0x48(%rbp)
mov    0x68(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x50(%rbp),%rax
mov    %rax,0x50(%rbp)
mov    0x68(%rbp),%rax
shl    $0x4,%rax
shl    $0x3,%rax
add    0x58(%rbp),%rax
mov    %rax,0x58(%rbp)
mov    0x68(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    0x68(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    0x68(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    0x68(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    0x68(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    0x68(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    0x68(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    0x10(%rbp),%rax
mov    %rax,0x10(%rbp)
mov    0x68(%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    115f <kern_r8_n_f+0x5f>
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r8_n_f>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2a8,%rsp
mov    %r9,0x70(%rsp)
mov    %r8,0x68(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,0x58(%rsp)
mov    %rsi,0x50(%rsp)
mov    %rdi,0x48(%rsp)
cmpq   $0x0,0x340(%rsp)
jle    220c <kern_r8_n_f+0x110c>
mov    0x338(%rsp),%r8
mov    0x328(%rsp),%r11
mov    0x320(%rsp),%r9
mov    0x318(%rsp),%r14
mov    0x310(%rsp),%r10
lea    (%r8,%r8,1),%rax
lea    (%rax,%rax,2),%rdx
mov    %rax,0x1f0(%rsp)
mov    %rax,%rsi
mov    0x340(%rsp),%rax
imul   %rax,%rsi
mov    %rsi,0x200(%rsp)
mov    %rdx,0x208(%rsp)
imul   %rax,%rdx
mov    %rdx,0x1f8(%rsp)
mov    %r8,%rax
shl    $0x4,%rax
mov    %rax,0x218(%rsp)
lea    -0x1(%r8),%rax
mov    $0x10,%edx
mul    %rdx
mov    %rax,0x1e8(%rsp)
seto   -0x71(%rsp)
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x40(%rsp)
shl    $0x7,%r8
mov    %r8,0x210(%rsp)
movapd 0x1e16(%rip),%xmm14
mov    0x308(%rsp),%r12
mov    0x300(%rsp),%rbp
mov    0x2f8(%rsp),%r13
mov    0x2f0(%rsp),%r15
mov    0x2e8(%rsp),%r8
mov    0x2e0(%rsp),%rdx
lea    0x8(%r10),%rax
mov    %rax,0x78(%rsp)
xor    %ebx,%ebx
mov    0x48(%rsp),%rdi
mov    0x68(%rsp),%rsi
mov    0x50(%rsp),%rcx
mov    0x70(%rsp),%rax
mov    %rax,-0x30(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,-0x38(%rsp)
mov    %rdx,-0x40(%rsp)
mov    0x60(%rsp),%rax
mov    %rax,-0x48(%rsp)
jmp    1305 <kern_r8_n_f+0x205>
nopl   0x0(%rax)
mov    0x80(%rsp),%rbx
add    $0x1,%rbx
mov    0x210(%rsp),%rdx
mov    -0x8(%rsp),%r15
add    %rdx,%r15
mov    0x10(%rsp),%r12
add    %rdx,%r12
mov    (%rsp),%r13
add    %rdx,%r13
mov    0x20(%rsp),%r9
add    %rdx,%r9
mov    0x88(%rsp),%r10
add    %rdx,%r10
mov    0x8(%rsp),%rbp
add    %rdx,%rbp
mov    0x28(%rsp),%r11
add    %rdx,%r11
mov    0x218(%rsp),%rax
mov    -0x28(%rsp),%r8
add    %rax,%r8
add    %rax,-0x48(%rsp)
add    %rax,-0x40(%rsp)
add    %rax,-0x38(%rsp)
add    %rax,-0x30(%rsp)
mov    -0x20(%rsp),%rcx
add    %rax,%rcx
mov    -0x18(%rsp),%rsi
add    %rax,%rsi
mov    -0x10(%rsp),%rdi
add    %rax,%rdi
mov    0x18(%rsp),%r14
add    %rdx,%r14
add    %rdx,0x78(%rsp)
cmp    0x340(%rsp),%rbx
je     220c <kern_r8_n_f+0x110c>
mov    %r8,-0x28(%rsp)
mov    %rcx,-0x20(%rsp)
mov    %rsi,-0x18(%rsp)
mov    %rdi,-0x10(%rsp)
mov    %rbx,0x80(%rsp)
mov    %r15,-0x8(%rsp)
mov    %r13,(%rsp)
mov    %rbp,0x8(%rsp)
mov    %r12,0x10(%rsp)
mov    %r10,0x88(%rsp)
mov    %r14,0x18(%rsp)
mov    %r9,0x20(%rsp)
mov    %r11,0x28(%rsp)
cmpq   $0x0,0x338(%rsp)
jle    1260 <kern_r8_n_f+0x160>
mov    0x80(%rsp),%rbp
mov    %rbp,%rax
mov    0x338(%rsp),%rsi
imul   %rsi,%rax
mov    %rax,%rcx
shl    $0x6,%rcx
mov    %rax,%rdx
shl    $0x5,%rdx
mov    0x330(%rsp),%rdi
movsd  (%rdi,%rcx,1),%xmm2
movsd  0x8(%rdi,%rcx,1),%xmm7
lea    (%rax,%rax,2),%rcx
shl    $0x5,%rcx
movsd  (%rdi,%rdx,1),%xmm4
movsd  0x8(%rdi,%rdx,1),%xmm5
mov    0x208(%rsp),%rdx
imul   %rbp,%rdx
movsd  (%rdi,%rcx,1),%xmm12
movsd  0x8(%rdi,%rcx,1),%xmm10
mov    0x200(%rsp),%rcx
lea    (%rcx,%rax,2),%rcx
shl    $0x4,%rax
movsd  (%rdi,%rax,1),%xmm0
movsd  0x8(%rdi,%rax,1),%xmm1
lea    0x0(,%rdx,8),%rax
or     $0x8,%rax
movsd  (%rdi,%rax,1),%xmm11
movsd  (%rdi,%rcx,8),%xmm8
lea    0x0(,%rcx,8),%rax
or     $0x8,%rax
movsd  (%rdi,%rax,1),%xmm6
movsd  (%rdi,%rdx,8),%xmm9
mov    0x1f8(%rsp),%rax
add    %rdx,%rax
movsd  (%rdi,%rax,8),%xmm3
lea    0x0(,%rax,8),%rax
or     $0x8,%rax
movsd  (%rdi,%rax,1),%xmm13
cmp    $0x1,%rsi
movapd %xmm0,0x100(%rsp)
movaps %xmm1,0xf0(%rsp)
movapd %xmm11,0xe0(%rsp)
movapd %xmm8,0xd0(%rsp)
movapd %xmm6,0xc0(%rsp)
movaps %xmm9,0xb0(%rsp)
movapd %xmm3,0xa0(%rsp)
movaps %xmm13,0x90(%rsp)
jne    1a30 <kern_r8_n_f+0x930>
xor    %r12d,%r12d
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
movapd %xmm0,0x1b0(%rsp)
movapd %xmm7,%xmm0
unpcklpd %xmm10,%xmm0
movapd %xmm0,0x1a0(%rsp)
unpcklpd %xmm7,%xmm10
movapd %xmm2,%xmm0
unpcklpd %xmm12,%xmm0
movapd %xmm0,0x190(%rsp)
unpcklpd %xmm2,%xmm12
unpcklpd %xmm2,%xmm2
movapd %xmm2,0x180(%rsp)
unpcklpd %xmm5,%xmm5
unpcklpd %xmm4,%xmm4
movaps 0xf0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0xf0(%rsp)
movaps 0x100(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x100(%rsp)
movaps 0xe0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0xe0(%rsp)
movaps 0xb0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0xb0(%rsp)
movaps 0xc0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0xc0(%rsp)
movaps 0xd0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0xd0(%rsp)
movaps 0x90(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x90(%rsp)
movaps 0xa0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0xa0(%rsp)
mov    0x338(%rsp),%rax
sub    %r12,%rax
mov    %rax,0x170(%rsp)
shl    $0x4,%r12
mov    -0x38(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    -0x30(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    -0x20(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    -0x18(%rsp),%rax
mov    %rax,0x160(%rsp)
mov    -0x10(%rsp),%rax
mov    %rax,0x150(%rsp)
mov    -0x8(%rsp),%rax
mov    %rax,0x140(%rsp)
mov    0x10(%rsp),%rax
mov    %rax,0x130(%rsp)
mov    (%rsp),%r8
mov    0x20(%rsp),%r11
mov    0x78(%rsp),%r14
mov    0x8(%rsp),%rbp
mov    0x28(%rsp),%rdi
mov    0x18(%rsp),%rbx
mov    -0x40(%rsp),%rax
mov    %rax,0x120(%rsp)
mov    -0x48(%rsp),%rax
mov    %rax,0x110(%rsp)
mov    -0x28(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,0x1d0(%rsp)
movupd (%rbx,%r12,1),%xmm2
movapd %xmm2,%xmm0
xorpd  %xmm14,%xmm0
movapd %xmm2,%xmm1
shufpd $0x1,%xmm0,%xmm1
movapd 0x1b0(%rsp),%xmm6
mulpd  %xmm6,%xmm1
movapd 0x180(%rsp),%xmm7
mulpd  %xmm7,%xmm2
addpd  %xmm1,%xmm2
mov    %rdi,0x1c0(%rsp)
movupd (%rdi,%r12,1),%xmm3
movapd %xmm3,%xmm0
xorpd  %xmm14,%xmm0
movapd %xmm3,%xmm1
shufpd $0x1,%xmm0,%xmm1
mulpd  %xmm6,%xmm1
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movupd 0x0(%rbp,%r12,1),%xmm13
movapd %xmm13,%xmm0
xorpd  %xmm14,%xmm0
movapd %xmm13,%xmm1
shufpd $0x1,%xmm0,%xmm1
movapd %xmm5,%xmm0
shufpd $0x1,%xmm5,%xmm0
mulpd  %xmm1,%xmm0
mulpd  %xmm4,%xmm13
addpd  %xmm0,%xmm13
movsd  (%r11,%r12,1),%xmm0
movsd  0x8(%r11,%r12,1),%xmm1
movapd %xmm4,%xmm8
movsd  -0x8(%r14,%r12,1),%xmm4
movapd %xmm5,%xmm9
movsd  (%r14,%r12,1),%xmm5
movapd %xmm5,%xmm6
unpcklpd %xmm1,%xmm6
mulpd  0x1a0(%rsp),%xmm6
movapd %xmm4,%xmm7
unpcklpd %xmm0,%xmm7
mulpd  0x190(%rsp),%xmm7
addpd  %xmm6,%xmm7
unpcklpd %xmm4,%xmm0
mulpd  %xmm10,%xmm0
unpcklpd %xmm5,%xmm1
mulpd  %xmm12,%xmm1
subpd  %xmm0,%xmm1
movapd %xmm10,%xmm11
movapd %xmm12,%xmm10
movupd (%r8,%r12,1),%xmm12
movapd %xmm2,%xmm4
addpd  %xmm12,%xmm4
movapd %xmm4,%xmm15
xorpd  %xmm14,%xmm15
shufpd $0x2,%xmm4,%xmm15
movapd %xmm4,%xmm6
shufpd $0x1,%xmm4,%xmm6
mulpd  0x100(%rsp),%xmm6
subpd  %xmm2,%xmm12
mov    0x130(%rsp),%rsi
movupd (%rsi,%r12,1),%xmm4
movapd %xmm3,%xmm5
addpd  %xmm4,%xmm5
subpd  %xmm3,%xmm4
mov    0x140(%rsp),%r13
movupd 0x0(%r13,%r12,1),%xmm0
movapd %xmm1,%xmm3
movsd  %xmm7,%xmm3
addpd  %xmm0,%xmm3
movapd %xmm0,%xmm2
unpcklpd %xmm13,%xmm2
subpd  %xmm7,%xmm2
shufpd $0x1,%xmm1,%xmm7
addpd  %xmm13,%xmm7
unpckhpd %xmm0,%xmm13
movapd %xmm5,%xmm0
xorpd  %xmm14,%xmm0
shufpd $0x2,%xmm5,%xmm0
shufpd $0x1,%xmm5,%xmm5
mulpd  0xb0(%rsp),%xmm5
subpd  %xmm1,%xmm13
mulpd  0xf0(%rsp),%xmm15
addpd  %xmm6,%xmm15
mulpd  0xe0(%rsp),%xmm0
addpd  %xmm5,%xmm0
movapd %xmm12,%xmm1
xorpd  %xmm14,%xmm1
movapd %xmm12,%xmm5
shufpd $0x1,%xmm1,%xmm5
mulpd  0xc0(%rsp),%xmm5
mulpd  0xd0(%rsp),%xmm12
addpd  %xmm5,%xmm12
movapd %xmm4,%xmm1
xorpd  %xmm14,%xmm1
movapd %xmm4,%xmm5
shufpd $0x1,%xmm1,%xmm5
mulpd  0x90(%rsp),%xmm5
mulpd  0xa0(%rsp),%xmm4
addpd  %xmm5,%xmm4
movapd %xmm13,%xmm14
addpd  %xmm2,%xmm14
movapd %xmm13,%xmm6
subpd  %xmm2,%xmm6
subpd  %xmm13,%xmm2
movapd %xmm15,%xmm1
unpckhpd %xmm7,%xmm1
movapd %xmm0,%xmm5
unpckhpd %xmm3,%xmm5
addpd  %xmm1,%xmm5
movapd %xmm3,%xmm1
subpd  %xmm7,%xmm1
unpcklpd %xmm15,%xmm7
unpcklpd %xmm0,%xmm3
addpd  %xmm7,%xmm3
subpd  %xmm0,%xmm15
movapd %xmm12,%xmm0
addpd  %xmm4,%xmm0
subpd  %xmm4,%xmm12
movapd %xmm3,%xmm4
addpd  %xmm5,%xmm4
mov    0x150(%rsp),%rcx
movupd %xmm4,(%rcx,%r12,1)
movapd %xmm5,%xmm4
movsd  %xmm3,%xmm4
movsd  %xmm5,%xmm3
movapd %xmm9,%xmm5
subpd  %xmm3,%xmm4
mov    0x160(%rsp),%r10
movupd %xmm4,(%r10,%r12,1)
movapd %xmm8,%xmm4
movapd %xmm6,%xmm3
movsd  %xmm14,%xmm3
shufpd $0x2,%xmm14,%xmm2
addpd  %xmm0,%xmm14
addpd  %xmm0,%xmm6
movsd  %xmm14,%xmm6
movapd 0x1709(%rip),%xmm14
mov    0x30(%rsp),%rdx
movupd %xmm6,(%rdx,%r12,1)
subpd  %xmm0,%xmm3
mov    -0x70(%rsp),%r15
movupd %xmm3,(%r15,%r12,1)
movapd %xmm1,%xmm0
addpd  %xmm15,%xmm0
subpd  %xmm15,%xmm1
movapd %xmm1,%xmm3
movsd  %xmm0,%xmm3
mov    -0x60(%rsp),%r9
movupd %xmm3,(%r9,%r12,1)
shufpd $0x2,%xmm0,%xmm1
shufpd $0x1,%xmm12,%xmm12
mov    0x120(%rsp),%rdi
movupd %xmm1,(%rdi,%r12,1)
movapd %xmm2,%xmm0
addpd  %xmm12,%xmm0
subpd  %xmm12,%xmm2
movapd %xmm10,%xmm12
movapd %xmm11,%xmm10
movapd %xmm2,%xmm1
movsd  %xmm0,%xmm1
mov    0x110(%rsp),%rbx
movupd %xmm1,(%rbx,%r12,1)
shufpd $0x2,%xmm0,%xmm2
movupd %xmm2,(%rax,%r12,1)
add    $0x10,%rax
add    $0x10,%rbx
mov    %rbx,0x110(%rsp)
add    $0x10,%rdi
mov    %rdi,0x120(%rsp)
mov    0x1d0(%rsp),%rbx
add    $0x10,%rbx
mov    0x1c0(%rsp),%rdi
add    $0x10,%rdi
add    $0x10,%rbp
add    $0x10,%r14
add    $0x10,%r11
add    $0x10,%r8
add    $0x10,%rsi
mov    %rsi,0x130(%rsp)
add    $0x10,%r13
mov    %r13,0x140(%rsp)
add    $0x10,%rcx
mov    %rcx,0x150(%rsp)
add    $0x10,%r10
mov    %r10,0x160(%rsp)
add    $0x10,%rdx
mov    %rdx,0x30(%rsp)
add    $0x10,%r15
mov    %r15,-0x70(%rsp)
add    $0x10,%r9
mov    %r9,-0x60(%rsp)
addq   $0xffffffffffffffff,0x170(%rsp)
jne    1620 <kern_r8_n_f+0x520>
jmp    1260 <kern_r8_n_f+0x160>
nopw   0x0(%rax,%rax,1)
mov    0x1f0(%rsp),%rax
imul   %rbp,%rax
shl    $0x3,%rax
or     $0x8,%rax
mov    0x48(%rsp),%rcx
add    %rax,%rcx
mov    0x68(%rsp),%rdx
lea    (%rdx,%rax,1),%rdx
mov    0x50(%rsp),%rsi
add    %rax,%rsi
mov    0x70(%rsp),%rdi
add    %rax,%rdi
mov    0x58(%rsp),%rbp
lea    0x0(%rbp,%rax,1),%r8
mov    0x2e0(%rsp),%rbp
lea    (%rax,%rbp,1),%r11
mov    0x60(%rsp),%rbx
lea    (%rbx,%rax,1),%r10
add    0x2e8(%rsp),%rax
mov    0x1e8(%rsp),%rbp
lea    (%rcx,%rbp,1),%rbx
cmp    %rcx,%rbx
setb   %r14b
mov    -0x71(%rsp),%bl
or     %bl,%r14b
lea    (%rdx,%rbp,1),%rcx
cmp    %rdx,%rcx
setb   %cl
lea    (%rsi,%rbp,1),%rdx
cmp    %rsi,%rdx
setb   %dl
lea    (%rdi,%rbp,1),%rsi
cmp    %rdi,%rsi
setb   %r9b
lea    (%r8,%rbp,1),%rsi
cmp    %r8,%rsi
setb   %r8b
lea    (%r11,%rbp,1),%rsi
cmp    %r11,%rsi
setb   %dil
lea    (%r10,%rbp,1),%rsi
cmp    %r10,%rsi
setb   %sil
add    %rax,%rbp
cmp    %rax,%rbp
setb   %al
test   %r14b,%r14b
jne    147d <kern_r8_n_f+0x37d>
or     %bl,%cl
jne    147d <kern_r8_n_f+0x37d>
or     %bl,%dl
jne    147d <kern_r8_n_f+0x37d>
or     %bl,%r9b
jne    147d <kern_r8_n_f+0x37d>
or     %bl,%r8b
jne    147d <kern_r8_n_f+0x37d>
or     %bl,%dil
jne    147d <kern_r8_n_f+0x37d>
or     %bl,%sil
jne    147d <kern_r8_n_f+0x37d>
or     %bl,%al
mov    $0x0,%r12d
jne    1480 <kern_r8_n_f+0x380>
movapd %xmm7,0x220(%rsp)
unpcklpd %xmm7,%xmm7
movapd %xmm7,0x150(%rsp)
movapd %xmm2,0x230(%rsp)
unpcklpd %xmm2,%xmm2
movapd %xmm2,0x140(%rsp)
movapd %xmm5,0x260(%rsp)
unpcklpd %xmm5,%xmm5
movapd %xmm5,0x130(%rsp)
movapd %xmm4,0x270(%rsp)
unpcklpd %xmm4,%xmm4
movapd %xmm4,0x120(%rsp)
movapd %xmm10,0x240(%rsp)
unpcklpd %xmm10,%xmm10
movapd %xmm10,0x110(%rsp)
movapd %xmm12,0x250(%rsp)
unpcklpd %xmm12,%xmm12
movapd %xmm12,0x1d0(%rsp)
movaps 0xf0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x1c0(%rsp)
movaps 0x100(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x1b0(%rsp)
movaps 0xe0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x1a0(%rsp)
movaps 0xb0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0xc0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0xd0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x170(%rsp)
movaps 0x90(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x290(%rsp)
movaps 0xa0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x280(%rsp)
mov    0x40(%rsp),%rbx
xor    %edi,%edi
mov    0x8(%rsp),%r15
mov    (%rsp),%r12
mov    -0x8(%rsp),%r13
mov    -0x10(%rsp),%r14
mov    -0x18(%rsp),%rbp
mov    -0x20(%rsp),%rax
mov    -0x30(%rsp),%rcx
mov    -0x38(%rsp),%rdx
mov    -0x40(%rsp),%r8
mov    -0x48(%rsp),%r9
mov    -0x28(%rsp),%r10
nopl   0x0(%rax)
mov    0x18(%rsp),%rsi
movupd (%rsi,%rdi,1),%xmm2
movupd 0x10(%rsi,%rdi,1),%xmm0
movapd %xmm2,%xmm11
unpcklpd %xmm0,%xmm11
unpckhpd %xmm0,%xmm2
movapd 0x150(%rsp),%xmm4
movapd %xmm4,%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm4,%xmm1
mulpd  %xmm11,%xmm1
movapd 0x140(%rsp),%xmm7
mulpd  %xmm7,%xmm11
addpd  %xmm0,%xmm11
mulpd  %xmm7,%xmm2
subpd  %xmm1,%xmm2
mov    0x28(%rsp),%r11
movupd (%r11,%rdi,1),%xmm3
movupd 0x10(%r11,%rdi,1),%xmm0
movapd %xmm3,%xmm10
unpcklpd %xmm0,%xmm10
unpckhpd %xmm0,%xmm3
movapd %xmm4,%xmm0
mulpd  %xmm3,%xmm0
movapd %xmm4,%xmm1
mulpd  %xmm10,%xmm1
mulpd  %xmm7,%xmm10
addpd  %xmm0,%xmm10
mulpd  %xmm7,%xmm3
subpd  %xmm1,%xmm3
movupd (%r15,%rdi,1),%xmm14
movupd 0x10(%r15,%rdi,1),%xmm0
movapd %xmm14,%xmm6
unpcklpd %xmm0,%xmm6
unpckhpd %xmm0,%xmm14
movapd 0x130(%rsp),%xmm1
movapd %xmm1,%xmm0
mulpd  %xmm14,%xmm0
mulpd  %xmm6,%xmm1
movapd 0x120(%rsp),%xmm5
mulpd  %xmm5,%xmm6
addpd  %xmm0,%xmm6
movapd %xmm6,-0x60(%rsp)
mulpd  %xmm5,%xmm14
subpd  %xmm1,%xmm14
mov    0x88(%rsp),%rsi
movupd (%rsi,%rdi,1),%xmm5
movupd 0x10(%rsi,%rdi,1),%xmm0
movapd %xmm5,%xmm15
unpcklpd %xmm0,%xmm15
unpckhpd %xmm0,%xmm5
movapd %xmm4,%xmm0
mulpd  %xmm5,%xmm0
movapd %xmm4,%xmm1
mulpd  %xmm15,%xmm1
mulpd  %xmm7,%xmm15
addpd  %xmm0,%xmm15
mulpd  %xmm7,%xmm5
subpd  %xmm1,%xmm5
mov    0x20(%rsp),%rsi
movupd (%rsi,%rdi,1),%xmm1
movupd 0x10(%rsi,%rdi,1),%xmm4
movapd %xmm1,%xmm0
unpcklpd %xmm4,%xmm0
unpckhpd %xmm4,%xmm1
movapd 0x110(%rsp),%xmm7
movapd %xmm7,%xmm4
mulpd  %xmm1,%xmm4
mulpd  %xmm0,%xmm7
movapd 0x1d0(%rsp),%xmm6
mulpd  %xmm6,%xmm0
addpd  %xmm4,%xmm0
mulpd  %xmm6,%xmm1
subpd  %xmm7,%xmm1
movupd (%r12,%rdi,1),%xmm8
movupd 0x10(%r12,%rdi,1),%xmm4
movapd %xmm8,%xmm9
unpcklpd %xmm4,%xmm9
unpckhpd %xmm4,%xmm8
movapd %xmm11,%xmm4
addpd  %xmm9,%xmm4
subpd  %xmm11,%xmm9
movapd %xmm2,%xmm6
addpd  %xmm8,%xmm6
movapd %xmm6,-0x70(%rsp)
subpd  %xmm2,%xmm8
mov    0x10(%rsp),%rsi
movupd (%rsi,%rdi,1),%xmm2
movupd 0x10(%rsi,%rdi,1),%xmm7
movapd %xmm2,%xmm6
unpcklpd %xmm7,%xmm6
unpckhpd %xmm7,%xmm2
movapd %xmm10,%xmm7
addpd  %xmm6,%xmm7
subpd  %xmm10,%xmm6
movapd %xmm3,%xmm10
addpd  %xmm2,%xmm10
subpd  %xmm3,%xmm2
movupd 0x0(%r13,%rdi,1),%xmm11
movupd 0x10(%r13,%rdi,1),%xmm13
movapd %xmm11,%xmm12
unpcklpd %xmm13,%xmm12
unpckhpd %xmm13,%xmm11
movapd %xmm15,%xmm13
addpd  %xmm12,%xmm13
subpd  %xmm15,%xmm12
movapd %xmm5,%xmm3
addpd  %xmm11,%xmm3
movapd %xmm3,0x30(%rsp)
subpd  %xmm5,%xmm11
movapd -0x60(%rsp),%xmm3
movapd %xmm3,%xmm5
addpd  %xmm0,%xmm5
movapd %xmm5,0x160(%rsp)
subpd  %xmm0,%xmm3
movapd %xmm3,-0x60(%rsp)
movapd %xmm14,%xmm15
addpd  %xmm1,%xmm15
subpd  %xmm1,%xmm14
movapd 0x1c0(%rsp),%xmm5
movapd %xmm5,%xmm1
movapd -0x70(%rsp),%xmm0
mulpd  %xmm0,%xmm1
mulpd  %xmm4,%xmm5
movapd 0x1b0(%rsp),%xmm3
mulpd  %xmm3,%xmm4
addpd  %xmm1,%xmm4
mulpd  %xmm3,%xmm0
subpd  %xmm5,%xmm0
movapd %xmm0,-0x70(%rsp)
movapd 0x1a0(%rsp),%xmm5
movapd %xmm5,%xmm1
mulpd  %xmm10,%xmm1
mulpd  %xmm7,%xmm5
movapd 0x190(%rsp),%xmm3
mulpd  %xmm3,%xmm7
addpd  %xmm1,%xmm7
mulpd  %xmm3,%xmm10
subpd  %xmm5,%xmm10
movapd 0x180(%rsp),%xmm5
movapd %xmm5,%xmm1
mulpd  %xmm8,%xmm1
mulpd  %xmm9,%xmm5
movapd 0x170(%rsp),%xmm3
mulpd  %xmm3,%xmm9
addpd  %xmm1,%xmm9
mulpd  %xmm3,%xmm8
subpd  %xmm5,%xmm8
movapd 0x290(%rsp),%xmm5
movapd %xmm5,%xmm1
mulpd  %xmm2,%xmm1
mulpd  %xmm6,%xmm5
movapd 0x280(%rsp),%xmm3
mulpd  %xmm3,%xmm6
addpd  %xmm1,%xmm6
mulpd  %xmm3,%xmm2
subpd  %xmm5,%xmm2
movapd 0x160(%rsp),%xmm0
movapd %xmm0,%xmm5
addpd  %xmm13,%xmm5
subpd  %xmm0,%xmm13
movapd %xmm15,%xmm1
movapd 0x30(%rsp),%xmm3
addpd  %xmm3,%xmm1
subpd  %xmm15,%xmm3
movapd %xmm3,0x30(%rsp)
movapd %xmm14,%xmm15
addpd  %xmm12,%xmm15
subpd  %xmm14,%xmm12
movapd %xmm11,%xmm3
movapd -0x60(%rsp),%xmm0
subpd  %xmm0,%xmm3
addpd  %xmm11,%xmm0
movapd %xmm0,-0x60(%rsp)
movapd %xmm4,%xmm14
addpd  %xmm7,%xmm14
subpd  %xmm7,%xmm4
movapd -0x70(%rsp),%xmm0
movapd %xmm0,%xmm11
addpd  %xmm10,%xmm11
subpd  %xmm10,%xmm0
movapd %xmm0,-0x70(%rsp)
movapd %xmm9,%xmm10
addpd  %xmm6,%xmm10
subpd  %xmm6,%xmm9
movapd %xmm8,%xmm6
addpd  %xmm2,%xmm6
subpd  %xmm2,%xmm8
movapd %xmm5,%xmm2
addpd  %xmm14,%xmm2
movapd %xmm11,%xmm7
addpd  %xmm1,%xmm7
movapd %xmm2,%xmm0
unpcklpd %xmm7,%xmm0
movhlps %xmm2,%xmm7
movups %xmm7,0x10(%r14,%rdi,1)
movupd %xmm0,(%r14,%rdi,1)
subpd  %xmm14,%xmm5
subpd  %xmm11,%xmm1
movapd %xmm5,%xmm0
unpcklpd %xmm1,%xmm0
movhlps %xmm5,%xmm1
movups %xmm1,0x10(%rbp,%rdi,1)
movupd %xmm0,0x0(%rbp,%rdi,1)
movapd %xmm15,%xmm0
addpd  %xmm10,%xmm0
movapd %xmm6,%xmm1
addpd  %xmm3,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rax,%rdi,1)
movupd %xmm2,(%rax,%rdi,1)
subpd  %xmm10,%xmm15
subpd  %xmm6,%xmm3
movapd %xmm15,%xmm0
unpcklpd %xmm3,%xmm0
movhlps %xmm15,%xmm3
movups %xmm3,0x10(%rcx,%rdi,1)
movupd %xmm0,(%rcx,%rdi,1)
movapd %xmm13,%xmm0
movapd -0x70(%rsp),%xmm5
addpd  %xmm5,%xmm0
movapd 0x30(%rsp),%xmm3
movapd %xmm3,%xmm1
subpd  %xmm4,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rdx,%rdi,1)
movupd %xmm2,(%rdx,%rdi,1)
subpd  %xmm5,%xmm13
addpd  %xmm3,%xmm4
movapd %xmm13,%xmm0
unpcklpd %xmm4,%xmm0
movhlps %xmm13,%xmm4
movups %xmm4,0x10(%r8,%rdi,1)
movupd %xmm0,(%r8,%rdi,1)
movapd %xmm12,%xmm0
addpd  %xmm8,%xmm0
movapd -0x60(%rsp),%xmm3
movapd %xmm3,%xmm1
subpd  %xmm9,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%r9,%rdi,1)
movupd %xmm2,(%r9,%rdi,1)
subpd  %xmm8,%xmm12
addpd  %xmm3,%xmm9
movapd %xmm12,%xmm0
unpcklpd %xmm9,%xmm0
movhlps %xmm12,%xmm9
movups %xmm9,0x10(%r10,%rdi,1)
movupd %xmm0,(%r10,%rdi,1)
add    $0x20,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1ca0 <kern_r8_n_f+0xba0>
mov    0x40(%rsp),%rax
mov    %rax,%r12
cmp    0x338(%rsp),%rax
movapd 0xe37(%rip),%xmm14
movapd 0x270(%rsp),%xmm4
movapd 0x260(%rsp),%xmm5
movapd 0x250(%rsp),%xmm12
movapd 0x240(%rsp),%xmm10
movapd 0x230(%rsp),%xmm2
movapd 0x220(%rsp),%xmm7
je     1260 <kern_r8_n_f+0x160>
jmp    1480 <kern_r8_n_f+0x380>
add    $0x2a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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