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

x86 assembly (clang, -O2):
<kern_r8_o_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2a8,%rsp
mov    %r9,-0x18(%rsp)
mov    %r8,-0x28(%rsp)
mov    %rcx,-0x40(%rsp)
mov    %rdx,-0x38(%rsp)
mov    %rsi,-0x30(%rsp)
mov    %rdi,-0x20(%rsp)
mov    0x338(%rsp),%rax
lea    (%rax,%rax,1),%rcx
mov    %rcx,0xf8(%rsp)
imul   0x340(%rsp),%rcx
mov    %rcx,0x100(%rsp)
test   %rax,%rax
jle    149e <kern_r8_o_b+0x39e>
mov    0x330(%rsp),%rax
mov    0x100(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm14
mov    0x338(%rsp),%rax
cmp    $0x1,%rax
jne    25e2 <kern_r8_o_b+0x14e2>
xor    %edi,%edi
unpcklpd %xmm14,%xmm14
mov    0x338(%rsp),%rax
sub    %rdi,%rax
mov    %rax,0xb0(%rsp)
shl    $0x4,%rdi
mov    -0x40(%rsp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rsp)
mov    0x2e8(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0xd0(%rsp)
movapd 0x1e32(%rip),%xmm8
mov    0x2e0(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    -0x38(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    -0x18(%rsp),%rax
mov    %rax,-0x50(%rsp)
mov    -0x30(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    -0x28(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    -0x20(%rsp),%rax
mov    %rax,(%rsp)
mov    0x320(%rsp),%rsi
mov    0x300(%rsp),%rcx
mov    0x310(%rsp),%r12
mov    0x2f0(%rsp),%r13
mov    0x328(%rsp),%r15
mov    0x308(%rsp),%rax
mov    0x318(%rsp),%rdx
mov    0x2f8(%rsp),%rbp
nopl   0x0(%rax)
movupd 0x0(%rbp,%rdi,1),%xmm2
movupd (%rdx,%rdi,1),%xmm0
movapd %xmm2,%xmm9
addpd  %xmm0,%xmm9
subpd  %xmm0,%xmm2
movupd (%rax,%rdi,1),%xmm0
movupd (%r15,%rdi,1),%xmm1
movapd %xmm0,%xmm11
addpd  %xmm1,%xmm11
subpd  %xmm1,%xmm0
movupd 0x0(%r13,%rdi,1),%xmm4
movupd (%r12,%rdi,1),%xmm1
movapd %xmm4,%xmm3
addpd  %xmm1,%xmm3
subpd  %xmm1,%xmm4
mov    %rcx,0xc0(%rsp)
movupd (%rcx,%rdi,1),%xmm6
mov    %rsi,0xe0(%rsp)
movupd (%rsi,%rdi,1),%xmm1
movapd %xmm6,%xmm10
addpd  %xmm1,%xmm10
subpd  %xmm1,%xmm6
shufpd $0x1,%xmm6,%xmm6
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
xorpd  %xmm8,%xmm1
unpcklpd %xmm2,%xmm1
mulpd  %xmm14,%xmm1
mulpd  %xmm14,%xmm2
addpd  %xmm1,%xmm2
movapd %xmm0,%xmm1
xorpd  %xmm8,%xmm1
shufpd $0x1,%xmm0,%xmm1
mulpd  %xmm14,%xmm1
mulpd  %xmm14,%xmm0
subpd  %xmm0,%xmm1
movapd %xmm3,%xmm13
addpd  %xmm10,%xmm13
movapd %xmm4,%xmm7
subpd  %xmm6,%xmm7
addpd  %xmm4,%xmm6
movapd %xmm3,%xmm4
unpcklpd %xmm9,%xmm4
movapd %xmm10,%xmm5
unpcklpd %xmm11,%xmm5
subpd  %xmm5,%xmm4
movapd %xmm2,%xmm12
subpd  %xmm1,%xmm2
movapd %xmm2,%xmm5
unpckhpd %xmm2,%xmm5
movapd %xmm6,%xmm0
subsd  %xmm5,%xmm0
addsd  %xmm6,%xmm5
movsd  %xmm7,%xmm6
unpckhpd %xmm7,%xmm7
movhlps %xmm9,%xmm3
addpd  %xmm11,%xmm9
movhlps %xmm11,%xmm10
subpd  %xmm10,%xmm3
addpd  %xmm1,%xmm12
movapd %xmm9,%xmm1
addpd  %xmm13,%xmm1
mov    (%rsp),%r10
movupd %xmm1,(%r10,%rdi,1)
subpd  %xmm9,%xmm13
mov    0x10(%rsp),%r9
movupd %xmm13,(%r9,%rdi,1)
movapd %xmm12,%xmm1
addpd  %xmm6,%xmm1
mov    0x20(%rsp),%r8
movupd %xmm1,(%r8,%rdi,1)
subpd  %xmm12,%xmm6
mov    -0x50(%rsp),%r14
movupd %xmm6,(%r14,%rdi,1)
movapd %xmm4,%xmm1
subpd  %xmm3,%xmm1
movapd %xmm4,%xmm6
addpd  %xmm3,%xmm6
shufpd $0x2,%xmm6,%xmm1
mov    -0x70(%rsp),%r11
movupd %xmm1,(%r11,%rdi,1)
subpd  %xmm4,%xmm3
movsd  %xmm6,%xmm3
mov    -0x60(%rsp),%rbx
movupd %xmm3,(%rbx,%rdi,1)
mov    -0x10(%rsp),%rsi
movsd  %xmm0,-0x8(%rsi,%rdi,1)
movapd %xmm2,%xmm0
addsd  %xmm7,%xmm0
movsd  %xmm0,(%rsi,%rdi,1)
mov    0xd0(%rsp),%rcx
movsd  %xmm5,-0x8(%rcx,%rdi,1)
subsd  %xmm2,%xmm7
movsd  %xmm7,(%rcx,%rdi,1)
add    $0x10,%rsi
mov    %rsi,-0x10(%rsp)
add    $0x10,%rcx
mov    %rcx,0xd0(%rsp)
add    $0x10,%rbp
add    $0x10,%rdx
add    $0x10,%rax
add    $0x10,%r15
add    $0x10,%r13
add    $0x10,%r12
mov    0xc0(%rsp),%rcx
add    $0x10,%rcx
mov    0xe0(%rsp),%rsi
add    $0x10,%rsi
add    $0x10,%r10
mov    %r10,(%rsp)
add    $0x10,%r9
mov    %r9,0x10(%rsp)
add    $0x10,%r8
mov    %r8,0x20(%rsp)
add    $0x10,%r14
mov    %r14,-0x50(%rsp)
add    $0x10,%r11
mov    %r11,-0x70(%rsp)
add    $0x10,%rbx
mov    %rbx,-0x60(%rsp)
addq   $0xffffffffffffffff,0xb0(%rsp)
jne    1250 <kern_r8_o_b+0x150>
cmpq   $0x2,0x340(%rsp)
jl     25d0 <kern_r8_o_b+0x14d0>
mov    0x338(%rsp),%rsi
mov    %rsi,%r8
shl    $0x4,%r8
mov    0xf8(%rsp),%rcx
lea    (%rcx,%rcx,2),%rax
mov    %rax,0x1e8(%rsp)
imul   0x340(%rsp),%rax
mov    %rax,0x1e0(%rsp)
lea    -0x1(%rsi),%rax
or     $0x1,%rcx
mov    %rcx,0x1d8(%rsp)
mov    $0x10,%ecx
mul    %rcx
mov    %rax,0x1d0(%rsp)
seto   -0x71(%rsp)
mov    %rsi,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xf0(%rsp)
mov    0x2f0(%rsp),%rax
lea    (%rax,%r8,8),%r9
shl    $0x7,%rsi
mov    %rsi,0x1f0(%rsp)
mov    0x308(%rsp),%rax
lea    (%rax,%r8,8),%r10
mov    0x2f8(%rsp),%rax
lea    (%rax,%r8,8),%r11
mov    0x320(%rsp),%rax
lea    (%rax,%r8,8),%r14
mov    0x300(%rsp),%rax
lea    (%rax,%r8,8),%r15
mov    0x328(%rsp),%rax
lea    (%rax,%r8,8),%r12
mov    0x318(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    0x310(%rsp),%rax
lea    (%rax,%r8,8),%r13
lea    0x8(%rax,%r8,8),%rax
mov    %rax,0x110(%rsp)
movapd 0x1a6a(%rip),%xmm2
mov    0x2e8(%rsp),%rax
lea    (%rax,%r8,1),%rbx
mov    -0x40(%rsp),%rax
lea    (%rax,%r8,1),%rdi
mov    0x2e0(%rsp),%rax
lea    (%rax,%r8,1),%rcx
mov    -0x38(%rsp),%rax
lea    (%rax,%r8,1),%rbp
mov    -0x18(%rsp),%rax
lea    (%rax,%r8,1),%rax
mov    %rax,0x40(%rsp)
mov    -0x30(%rsp),%rax
lea    (%rax,%r8,1),%rax
mov    %rax,0x38(%rsp)
mov    -0x28(%rsp),%rax
add    %r8,%rax
mov    %rax,0x30(%rsp)
mov    -0x20(%rsp),%rax
mov    %r8,0x1f8(%rsp)
add    %r8,%rax
mov    $0x1,%edx
mov    %rdx,0x48(%rsp)
xor    %edx,%edx
mov    %rdx,0x108(%rsp)
jmp    16ec <kern_r8_o_b+0x5ec>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x48(%rsp),%r8
add    $0x1,%r8
addq   $0x1,0x108(%rsp)
mov    0xa8(%rsp),%r9
mov    0x1f0(%rsp),%rdx
add    %rdx,%r9
mov    0xa0(%rsp),%r10
add    %rdx,%r10
mov    0x98(%rsp),%r11
add    %rdx,%r11
mov    0x90(%rsp),%r14
add    %rdx,%r14
mov    0x118(%rsp),%r13
add    %rdx,%r13
mov    0x88(%rsp),%r15
add    %rdx,%r15
mov    0x80(%rsp),%r12
add    %rdx,%r12
mov    0x1f8(%rsp),%rax
mov    0x70(%rsp),%rbx
add    %rax,%rbx
mov    0x68(%rsp),%rdi
add    %rax,%rdi
mov    0x60(%rsp),%rcx
add    %rax,%rcx
mov    0x58(%rsp),%rbp
add    %rax,%rbp
add    %rax,0x40(%rsp)
add    %rax,0x38(%rsp)
add    %rax,0x30(%rsp)
mov    0x50(%rsp),%rsi
add    %rax,%rsi
mov    %rsi,%rax
mov    0x78(%rsp),%rsi
add    %rdx,%rsi
add    %rdx,0x110(%rsp)
mov    %r8,0x48(%rsp)
cmp    0x340(%rsp),%r8
je     25d0 <kern_r8_o_b+0x14d0>
mov    %rax,0x50(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdi,0x68(%rsp)
mov    %rbx,0x70(%rsp)
mov    %r13,0x118(%rsp)
mov    %rsi,0x78(%rsp)
mov    %r12,0x80(%rsp)
mov    %r15,0x88(%rsp)
mov    %r14,0x90(%rsp)
mov    %r11,0x98(%rsp)
mov    %r10,0xa0(%rsp)
mov    %r9,0xa8(%rsp)
cmpq   $0x0,0x338(%rsp)
jle    1620 <kern_r8_o_b+0x520>
mov    0x48(%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),%xmm0
movsd  0x8(%rdi,%rcx,1),%xmm6
lea    (%rax,%rax,2),%rcx
shl    $0x5,%rcx
movsd  (%rdi,%rdx,1),%xmm4
movsd  0x8(%rdi,%rdx,1),%xmm3
mov    0x1e8(%rsp),%rdx
imul   %rbp,%rdx
movsd  (%rdi,%rcx,1),%xmm11
movsd  0x8(%rdi,%rcx,1),%xmm5
mov    0x100(%rsp),%rcx
lea    (%rcx,%rax,2),%rcx
shl    $0x4,%rax
movsd  (%rdi,%rax,1),%xmm10
movsd  0x8(%rdi,%rax,1),%xmm12
lea    0x0(,%rdx,8),%rax
or     $0x8,%rax
movsd  (%rdi,%rax,1),%xmm1
movsd  (%rdi,%rcx,8),%xmm8
lea    0x0(,%rcx,8),%rax
or     $0x8,%rax
movsd  (%rdi,%rax,1),%xmm9
movsd  (%rdi,%rdx,8),%xmm14
mov    0x1e0(%rsp),%rax
add    %rdx,%rax
movsd  (%rdi,%rax,8),%xmm7
lea    0x0(,%rax,8),%rax
or     $0x8,%rax
movsd  (%rdi,%rax,1),%xmm13
cmp    $0x1,%rsi
movapd %xmm12,0xc0(%rsp)
movaps %xmm1,0xb0(%rsp)
movaps %xmm8,0x160(%rsp)
movaps %xmm9,0x150(%rsp)
movapd %xmm14,0x140(%rsp)
movaps %xmm7,0x130(%rsp)
movaps %xmm13,0x120(%rsp)
jne    1dd0 <kern_r8_o_b+0xcd0>
xor    %r12d,%r12d
movapd %xmm6,%xmm1
unpcklpd %xmm6,%xmm1
movapd %xmm1,0x1b0(%rsp)
movapd %xmm6,%xmm1
unpcklpd %xmm5,%xmm1
movapd %xmm1,0x1a0(%rsp)
unpcklpd %xmm6,%xmm5
movapd %xmm0,%xmm1
unpcklpd %xmm11,%xmm1
movapd %xmm1,0x190(%rsp)
unpcklpd %xmm0,%xmm11
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x180(%rsp)
unpcklpd %xmm3,%xmm3
unpcklpd %xmm4,%xmm4
movaps 0xc0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0xc0(%rsp)
unpcklpd %xmm10,%xmm10
movaps 0xb0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0xb0(%rsp)
movaps 0x140(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x140(%rsp)
movaps 0x150(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x150(%rsp)
movaps 0x160(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x160(%rsp)
movaps 0x120(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0x130(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x130(%rsp)
mov    0x338(%rsp),%rax
sub    %r12,%rax
mov    %rax,0x170(%rsp)
shl    $0x4,%r12
mov    0x58(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    0x40(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    0x38(%rsp),%rax
mov    %rax,-0x50(%rsp)
mov    0x30(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    0x50(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0xa8(%rsp),%rbx
mov    0xa0(%rsp),%r8
mov    0x98(%rsp),%r10
mov    0x90(%rsp),%r13
mov    0x110(%rsp),%r9
mov    0x88(%rsp),%rsi
mov    0x80(%rsp),%rcx
mov    0x78(%rsp),%rbp
mov    0x60(%rsp),%rax
mov    %rax,(%rsp)
mov    0x68(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    0x70(%rsp),%rax
movapd %xmm4,0x1c0(%rsp)
xchg   %ax,%ax
movupd 0x0(%rbp,%r12,1),%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
xorpd  %xmm2,%xmm1
unpcklpd %xmm0,%xmm1
movapd 0x1b0(%rsp),%xmm6
mulpd  %xmm6,%xmm1
movapd 0x180(%rsp),%xmm7
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
mov    %rcx,0xd0(%rsp)
movupd (%rcx,%r12,1),%xmm2
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
xorpd  0x15bd(%rip),%xmm1
unpcklpd %xmm2,%xmm1
mulpd  %xmm6,%xmm1
mulpd  %xmm7,%xmm2
addpd  %xmm1,%xmm2
mov    %rsi,0xe0(%rsp)
movupd (%rsi,%r12,1),%xmm15
movapd %xmm15,%xmm1
unpckhpd %xmm15,%xmm1
xorpd  0x158d(%rip),%xmm1
unpcklpd %xmm15,%xmm1
movapd %xmm3,%xmm9
shufpd $0x1,%xmm3,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm4,%xmm15
addpd  %xmm3,%xmm15
movsd  0x0(%r13,%r12,1),%xmm1
movsd  0x8(%r13,%r12,1),%xmm4
movsd  -0x8(%r9,%r12,1),%xmm6
movsd  (%r9,%r12,1),%xmm12
movapd %xmm12,%xmm7
unpcklpd %xmm4,%xmm7
mulpd  0x1a0(%rsp),%xmm7
movapd %xmm6,%xmm3
unpcklpd %xmm1,%xmm3
mulpd  0x190(%rsp),%xmm3
subpd  %xmm7,%xmm3
unpcklpd %xmm6,%xmm1
mulpd  %xmm5,%xmm1
unpcklpd %xmm12,%xmm4
mulpd  %xmm11,%xmm4
addpd  %xmm1,%xmm4
movupd (%r10,%r12,1),%xmm6
movapd %xmm0,%xmm7
addpd  %xmm6,%xmm7
movapd %xmm7,%xmm14
shufpd $0x1,%xmm7,%xmm14
mulpd  %xmm10,%xmm14
subpd  %xmm0,%xmm6
movupd (%r8,%r12,1),%xmm13
movapd %xmm10,%xmm8
movapd %xmm5,%xmm10
movapd %xmm2,%xmm5
addpd  %xmm13,%xmm5
subpd  %xmm2,%xmm13
movupd (%rbx,%r12,1),%xmm0
movapd %xmm4,%xmm2
movsd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
movapd %xmm0,%xmm12
unpcklpd %xmm15,%xmm12
subpd  %xmm3,%xmm12
shufpd $0x1,%xmm4,%xmm3
addpd  %xmm15,%xmm3
unpckhpd %xmm0,%xmm15
movapd %xmm5,%xmm0
shufpd $0x1,%xmm5,%xmm0
mulpd  0x140(%rsp),%xmm0
subpd  %xmm4,%xmm15
movapd %xmm7,%xmm4
unpckhpd %xmm7,%xmm4
xorpd  0x1481(%rip),%xmm4
unpcklpd %xmm4,%xmm7
mulpd  0xc0(%rsp),%xmm7
addpd  %xmm14,%xmm7
movapd %xmm5,%xmm4
unpckhpd %xmm5,%xmm4
xorpd  0x145f(%rip),%xmm4
unpcklpd %xmm4,%xmm5
mulpd  0xb0(%rsp),%xmm5
addpd  %xmm0,%xmm5
movapd %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
xorpd  0x143e(%rip),%xmm0
unpcklpd %xmm6,%xmm0
mulpd  0x150(%rsp),%xmm0
mulpd  0x160(%rsp),%xmm6
addpd  %xmm0,%xmm6
movapd %xmm13,%xmm0
unpckhpd %xmm13,%xmm0
xorpd  0x1412(%rip),%xmm0
unpcklpd %xmm13,%xmm0
mulpd  0x120(%rsp),%xmm0
mulpd  0x130(%rsp),%xmm13
addpd  %xmm0,%xmm13
movapd %xmm12,%xmm14
subpd  %xmm15,%xmm14
movapd %xmm12,%xmm0
addpd  %xmm15,%xmm0
subpd  %xmm12,%xmm15
movapd %xmm7,%xmm4
unpckhpd %xmm3,%xmm4
movapd %xmm5,%xmm1
unpckhpd %xmm2,%xmm1
addpd  %xmm4,%xmm1
movapd %xmm2,%xmm12
subpd  %xmm3,%xmm12
unpcklpd %xmm7,%xmm3
unpcklpd %xmm5,%xmm2
addpd  %xmm3,%xmm2
subpd  %xmm5,%xmm7
movapd %xmm10,%xmm5
movapd %xmm8,%xmm10
movapd %xmm6,%xmm3
addpd  %xmm13,%xmm3
subpd  %xmm13,%xmm6
movapd %xmm2,%xmm4
addpd  %xmm1,%xmm4
mov    0x10(%rsp),%rdx
movupd %xmm4,(%rdx,%r12,1)
movapd %xmm1,%xmm4
movsd  %xmm2,%xmm4
movsd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
movapd 0x136b(%rip),%xmm2
mov    0x20(%rsp),%r11
movupd %xmm4,(%r11,%r12,1)
movapd 0x1c0(%rsp),%xmm4
movapd %xmm0,%xmm1
movsd  %xmm14,%xmm1
movsd  %xmm0,%xmm15
addpd  %xmm3,%xmm14
addpd  %xmm3,%xmm0
movsd  %xmm14,%xmm0
mov    -0x50(%rsp),%rdi
movupd %xmm0,(%rdi,%r12,1)
subpd  %xmm3,%xmm1
movapd %xmm9,%xmm3
mov    -0x70(%rsp),%r15
movupd %xmm1,(%r15,%r12,1)
movapd %xmm12,%xmm0
subpd  %xmm7,%xmm0
addpd  %xmm12,%xmm7
movapd %xmm7,%xmm1
movsd  %xmm0,%xmm1
mov    -0x60(%rsp),%r14
movupd %xmm1,(%r14,%r12,1)
shufpd $0x2,%xmm0,%xmm7
shufpd $0x1,%xmm6,%xmm6
mov    (%rsp),%rcx
movupd %xmm7,(%rcx,%r12,1)
movapd %xmm15,%xmm0
subpd  %xmm6,%xmm0
addpd  %xmm15,%xmm6
movapd %xmm6,%xmm1
movsd  %xmm0,%xmm1
mov    -0x10(%rsp),%rsi
movupd %xmm1,(%rsi,%r12,1)
shufpd $0x2,%xmm0,%xmm6
movupd %xmm6,(%rax,%r12,1)
add    $0x10,%rax
add    $0x10,%rsi
mov    %rsi,-0x10(%rsp)
add    $0x10,%rcx
mov    %rcx,(%rsp)
add    $0x10,%rbp
mov    0xd0(%rsp),%rcx
add    $0x10,%rcx
mov    0xe0(%rsp),%rsi
add    $0x10,%rsi
add    $0x10,%r9
add    $0x10,%r13
add    $0x10,%r10
add    $0x10,%r8
add    $0x10,%rbx
add    $0x10,%rdx
mov    %rdx,0x10(%rsp)
add    $0x10,%r11
mov    %r11,0x20(%rsp)
add    $0x10,%rdi
mov    %rdi,-0x50(%rsp)
add    $0x10,%r15
mov    %r15,-0x70(%rsp)
add    $0x10,%r14
mov    %r14,-0x60(%rsp)
addq   $0xffffffffffffffff,0x170(%rsp)
jne    19f0 <kern_r8_o_b+0x8f0>
jmp    1620 <kern_r8_o_b+0x520>
nopl   0x0(%rax,%rax,1)
mov    0xf8(%rsp),%rax
imul   0x108(%rsp),%rax
add    0x1d8(%rsp),%rax
mov    -0x20(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    -0x28(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    -0x30(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
mov    -0x18(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
mov    0x1d0(%rsp),%rbx
lea    (%rcx,%rbx,1),%rbp
cmp    %rcx,%rbp
setb   %r11b
mov    -0x71(%rsp),%cl
or     %cl,%r11b
lea    (%rdx,%rbx,1),%rbp
cmp    %rdx,%rbp
mov    -0x38(%rsp),%rdx
lea    (%rdx,%rax,8),%rbp
setb   %r10b
lea    (%rsi,%rbx,1),%rdx
cmp    %rsi,%rdx
setb   %dl
lea    (%rdi,%rbx,1),%rsi
cmp    %rdi,%rsi
mov    0x2e0(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
setb   %r9b
lea    (%rbx,%rbp,1),%rdi
cmp    %rbp,%rdi
setb   %r8b
lea    (%rsi,%rbx,1),%rdi
cmp    %rsi,%rdi
mov    -0x40(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
setb   %dil
lea    (%rsi,%rbx,1),%rbp
cmp    %rsi,%rbp
mov    0x2e8(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
setb   %al
lea    (%rsi,%rbx,1),%rbp
cmp    %rsi,%rbp
setb   %sil
test   %r11b,%r11b
jne    1868 <kern_r8_o_b+0x768>
or     %cl,%r10b
jne    1868 <kern_r8_o_b+0x768>
or     %cl,%dl
jne    1868 <kern_r8_o_b+0x768>
or     %cl,%r9b
jne    1868 <kern_r8_o_b+0x768>
or     %cl,%r8b
jne    1868 <kern_r8_o_b+0x768>
or     %cl,%dil
jne    1868 <kern_r8_o_b+0x768>
or     %cl,%al
jne    1868 <kern_r8_o_b+0x768>
or     %cl,%sil
mov    $0x0,%r12d
jne    186b <kern_r8_o_b+0x76b>
movapd %xmm6,0x200(%rsp)
unpcklpd %xmm6,%xmm6
movapd %xmm6,0x10(%rsp)
movapd %xmm0,0x210(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,(%rsp)
movapd %xmm3,0x250(%rsp)
unpcklpd %xmm3,%xmm3
movapd %xmm3,-0x10(%rsp)
movapd %xmm4,0x1c0(%rsp)
unpcklpd %xmm4,%xmm4
movapd %xmm4,0xd0(%rsp)
movapd %xmm5,0x230(%rsp)
unpcklpd %xmm5,%xmm5
movapd %xmm5,0xe0(%rsp)
movapd %xmm11,0x240(%rsp)
unpcklpd %xmm11,%xmm11
movapd %xmm11,0x1b0(%rsp)
movaps 0xc0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x1a0(%rsp)
movapd %xmm10,0x220(%rsp)
unpcklpd %xmm10,%xmm10
movapd %xmm10,0x190(%rsp)
movaps 0xb0(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0x140(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x170(%rsp)
movaps 0x150(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x290(%rsp)
movaps 0x160(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x280(%rsp)
movaps 0x120(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x270(%rsp)
movaps 0x130(%rsp),%xmm0
movlhps %xmm0,%xmm0
movaps %xmm0,0x260(%rsp)
mov    0xf0(%rsp),%rcx
xor    %ebp,%ebp
mov    0x80(%rsp),%r15
mov    0x78(%rsp),%r12
mov    0x118(%rsp),%r13
mov    0x70(%rsp),%r14
mov    0x68(%rsp),%rbx
mov    0x60(%rsp),%rax
mov    0x58(%rsp),%rdx
mov    0x40(%rsp),%rsi
mov    0x38(%rsp),%r8
mov    0x30(%rsp),%r9
mov    0x50(%rsp),%r10
nopw   0x0(%rax,%rax,1)
movupd (%r12,%rbp,1),%xmm2
movupd 0x10(%r12,%rbp,1),%xmm0
movapd %xmm2,%xmm8
unpcklpd %xmm0,%xmm8
unpckhpd %xmm0,%xmm2
movapd 0x10(%rsp),%xmm3
movapd %xmm3,%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm3,%xmm1
mulpd  %xmm8,%xmm1
movapd (%rsp),%xmm6
mulpd  %xmm6,%xmm8
subpd  %xmm0,%xmm8
mulpd  %xmm6,%xmm2
addpd  %xmm1,%xmm2
movupd (%r15,%rbp,1),%xmm4
movupd 0x10(%r15,%rbp,1),%xmm0
movapd %xmm4,%xmm10
unpcklpd %xmm0,%xmm10
unpckhpd %xmm0,%xmm4
movapd %xmm3,%xmm0
mulpd  %xmm4,%xmm0
movapd %xmm3,%xmm1
mulpd  %xmm10,%xmm1
mulpd  %xmm6,%xmm10
subpd  %xmm0,%xmm10
mulpd  %xmm6,%xmm4
addpd  %xmm1,%xmm4
mov    0x88(%rsp),%rdi
movupd (%rdi,%rbp,1),%xmm5
movupd 0x10(%rdi,%rbp,1),%xmm0
movapd %xmm5,%xmm14
unpcklpd %xmm0,%xmm14
unpckhpd %xmm0,%xmm5
movapd -0x10(%rsp),%xmm1
movapd %xmm1,%xmm0
mulpd  %xmm5,%xmm0
mulpd  %xmm14,%xmm1
movapd 0xd0(%rsp),%xmm7
mulpd  %xmm7,%xmm14
subpd  %xmm0,%xmm14
mulpd  %xmm7,%xmm5
addpd  %xmm1,%xmm5
movapd %xmm5,-0x60(%rsp)
movupd 0x0(%r13,%rbp,1),%xmm15
movupd 0x10(%r13,%rbp,1),%xmm0
movapd %xmm15,%xmm1
unpcklpd %xmm0,%xmm1
unpckhpd %xmm0,%xmm15
movapd %xmm3,%xmm0
mulpd  %xmm15,%xmm0
mulpd  %xmm1,%xmm3
mulpd  %xmm6,%xmm1
subpd  %xmm0,%xmm1
mulpd  %xmm6,%xmm15
addpd  %xmm3,%xmm15
mov    0x90(%rsp),%rdi
movupd (%rdi,%rbp,1),%xmm13
movupd 0x10(%rdi,%rbp,1),%xmm3
movapd %xmm13,%xmm0
unpcklpd %xmm3,%xmm0
unpckhpd %xmm3,%xmm13
movapd 0xe0(%rsp),%xmm6
movapd %xmm6,%xmm3
mulpd  %xmm13,%xmm3
mulpd  %xmm0,%xmm6
movapd 0x1b0(%rsp),%xmm7
mulpd  %xmm7,%xmm0
subpd  %xmm3,%xmm0
mulpd  %xmm7,%xmm13
addpd  %xmm6,%xmm13
mov    0x98(%rsp),%rdi
movupd (%rdi,%rbp,1),%xmm9
movupd 0x10(%rdi,%rbp,1),%xmm3
movapd %xmm9,%xmm12
unpcklpd %xmm3,%xmm12
unpckhpd %xmm3,%xmm9
movapd %xmm8,%xmm3
addpd  %xmm12,%xmm3
movapd %xmm3,-0x70(%rsp)
subpd  %xmm8,%xmm12
movapd %xmm2,%xmm11
addpd  %xmm9,%xmm11
subpd  %xmm2,%xmm9
mov    0xa0(%rsp),%rdi
movupd (%rdi,%rbp,1),%xmm5
movupd 0x10(%rdi,%rbp,1),%xmm2
movapd %xmm5,%xmm6
unpcklpd %xmm2,%xmm6
unpckhpd %xmm2,%xmm5
movapd %xmm10,%xmm7
addpd  %xmm6,%xmm7
subpd  %xmm10,%xmm6
movapd %xmm4,%xmm3
addpd  %xmm5,%xmm3
subpd  %xmm4,%xmm5
mov    0xa8(%rsp),%r11
movupd (%r11,%rbp,1),%xmm4
movupd 0x10(%r11,%rbp,1),%xmm2
movapd %xmm4,%xmm10
unpcklpd %xmm2,%xmm10
unpckhpd %xmm2,%xmm4
movapd %xmm1,%xmm2
addpd  %xmm10,%xmm2
movapd %xmm2,-0x50(%rsp)
subpd  %xmm1,%xmm10
movapd %xmm15,%xmm8
addpd  %xmm4,%xmm8
subpd  %xmm15,%xmm4
movapd %xmm14,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm15
subpd  %xmm0,%xmm14
movapd -0x60(%rsp),%xmm0
movapd %xmm0,%xmm1
addpd  %xmm13,%xmm1
movapd %xmm1,0x20(%rsp)
subpd  %xmm13,%xmm0
movapd %xmm0,-0x60(%rsp)
movapd 0x1a0(%rsp),%xmm2
movapd %xmm2,%xmm0
mulpd  %xmm11,%xmm0
movapd -0x70(%rsp),%xmm1
mulpd  %xmm1,%xmm2
movapd 0x190(%rsp),%xmm13
mulpd  %xmm13,%xmm1
subpd  %xmm0,%xmm1
movapd %xmm1,-0x70(%rsp)
mulpd  %xmm13,%xmm11
addpd  %xmm2,%xmm11
movapd 0x180(%rsp),%xmm2
movapd %xmm2,%xmm0
mulpd  %xmm3,%xmm0
mulpd  %xmm7,%xmm2
movapd 0x170(%rsp),%xmm1
mulpd  %xmm1,%xmm7
subpd  %xmm0,%xmm7
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movapd 0x290(%rsp),%xmm2
movapd %xmm2,%xmm0
mulpd  %xmm9,%xmm0
mulpd  %xmm12,%xmm2
movapd 0x280(%rsp),%xmm1
mulpd  %xmm1,%xmm12
subpd  %xmm0,%xmm12
mulpd  %xmm1,%xmm9
addpd  %xmm2,%xmm9
movapd 0x270(%rsp),%xmm2
movapd %xmm2,%xmm0
mulpd  %xmm5,%xmm0
mulpd  %xmm6,%xmm2
movapd 0x260(%rsp),%xmm1
mulpd  %xmm1,%xmm6
subpd  %xmm0,%xmm6
mulpd  %xmm1,%xmm5
addpd  %xmm2,%xmm5
movapd %xmm15,%xmm1
movapd -0x50(%rsp),%xmm0
addpd  %xmm0,%xmm15
subpd  %xmm1,%xmm0
movapd %xmm0,-0x50(%rsp)
movapd 0x20(%rsp),%xmm1
movapd %xmm1,%xmm0
addpd  %xmm8,%xmm0
subpd  %xmm1,%xmm8
movapd %xmm10,%xmm13
movapd -0x60(%rsp),%xmm1
subpd  %xmm1,%xmm13
addpd  %xmm10,%xmm1
movapd %xmm1,-0x60(%rsp)
movapd %xmm14,%xmm10
addpd  %xmm4,%xmm10
subpd  %xmm14,%xmm4
movapd -0x70(%rsp),%xmm1
movapd %xmm1,%xmm14
addpd  %xmm7,%xmm14
subpd  %xmm7,%xmm1
movapd %xmm1,-0x70(%rsp)
movapd %xmm11,%xmm2
addpd  %xmm3,%xmm2
subpd  %xmm3,%xmm11
movapd %xmm12,%xmm3
addpd  %xmm6,%xmm3
subpd  %xmm6,%xmm12
movapd %xmm9,%xmm6
addpd  %xmm5,%xmm6
subpd  %xmm5,%xmm9
movapd %xmm15,%xmm5
addpd  %xmm14,%xmm5
movapd %xmm2,%xmm7
addpd  %xmm0,%xmm7
movapd %xmm5,%xmm1
unpcklpd %xmm7,%xmm1
movhlps %xmm5,%xmm7
movups %xmm7,0x10(%r10,%rbp,1)
movupd %xmm1,(%r10,%rbp,1)
subpd  %xmm14,%xmm15
subpd  %xmm2,%xmm0
movapd %xmm15,%xmm1
unpcklpd %xmm0,%xmm1
movhlps %xmm15,%xmm0
movups %xmm0,0x10(%r9,%rbp,1)
movupd %xmm1,(%r9,%rbp,1)
movapd %xmm13,%xmm0
addpd  %xmm3,%xmm0
movapd %xmm6,%xmm1
addpd  %xmm10,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%r8,%rbp,1)
movupd %xmm2,(%r8,%rbp,1)
subpd  %xmm3,%xmm13
subpd  %xmm6,%xmm10
movapd %xmm13,%xmm0
unpcklpd %xmm10,%xmm0
movhlps %xmm13,%xmm10
movups %xmm10,0x10(%rsi,%rbp,1)
movupd %xmm0,(%rsi,%rbp,1)
movapd -0x50(%rsp),%xmm3
movapd %xmm3,%xmm0
subpd  %xmm11,%xmm0
movapd %xmm8,%xmm1
movapd -0x70(%rsp),%xmm5
addpd  %xmm5,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rdx,%rbp,1)
movupd %xmm2,(%rdx,%rbp,1)
addpd  %xmm3,%xmm11
subpd  %xmm5,%xmm8
movapd %xmm11,%xmm0
unpcklpd %xmm8,%xmm0
movhlps %xmm11,%xmm8
movups %xmm8,0x10(%rax,%rbp,1)
movupd %xmm0,(%rax,%rbp,1)
movapd -0x60(%rsp),%xmm3
movapd %xmm3,%xmm0
subpd  %xmm9,%xmm0
movapd %xmm4,%xmm1
addpd  %xmm12,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rbx,%rbp,1)
movupd %xmm2,(%rbx,%rbp,1)
addpd  %xmm3,%xmm9
subpd  %xmm12,%xmm4
movapd %xmm9,%xmm0
unpcklpd %xmm4,%xmm0
movhlps %xmm9,%xmm4
movups %xmm4,0x10(%r14,%rbp,1)
movupd %xmm0,(%r14,%rbp,1)
add    $0x20,%rbp
add    $0xfffffffffffffffe,%rcx
jne    2050 <kern_r8_o_b+0xf50>
mov    0xf0(%rsp),%rax
mov    %rax,%r12
cmp    0x338(%rsp),%rax
movapd 0xa7c(%rip),%xmm2
movapd 0x1c0(%rsp),%xmm4
movapd 0x250(%rsp),%xmm3
movapd 0x240(%rsp),%xmm11
movapd 0x230(%rsp),%xmm5
movapd 0x220(%rsp),%xmm10
movapd 0x210(%rsp),%xmm0
movapd 0x200(%rsp),%xmm6
je     1620 <kern_r8_o_b+0x520>
jmp    186b <kern_r8_o_b+0x76b>
add    $0x2a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0xffffffffffffffff,%rax
mov    -0x20(%rsp),%rdi
lea    0x8(%rdi),%rsi
mov    $0x10,%ecx
mul    %rcx
seto   %cl
lea    (%rdi,%rax,1),%rdx
add    $0x8,%rdx
cmp    %rsi,%rdx
jb     1185 <kern_r8_o_b+0x85>
test   %cl,%cl
jne    1185 <kern_r8_o_b+0x85>
mov    -0x28(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     1185 <kern_r8_o_b+0x85>
test   %cl,%cl
jne    1185 <kern_r8_o_b+0x85>
mov    -0x30(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     1185 <kern_r8_o_b+0x85>
test   %cl,%cl
jne    1185 <kern_r8_o_b+0x85>
mov    -0x18(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     1185 <kern_r8_o_b+0x85>
test   %cl,%cl
jne    1185 <kern_r8_o_b+0x85>
mov    -0x38(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     1185 <kern_r8_o_b+0x85>
test   %cl,%cl
jne    1185 <kern_r8_o_b+0x85>
mov    0x2e0(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     1185 <kern_r8_o_b+0x85>
test   %cl,%cl
jne    1185 <kern_r8_o_b+0x85>
mov    -0x40(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rax,%rsi
add    $0x8,%rsi
cmp    %rdx,%rsi
jb     1185 <kern_r8_o_b+0x85>
test   %cl,%cl
jne    1185 <kern_r8_o_b+0x85>
mov    0x2e8(%rsp),%rsi
lea    0x8(%rsi),%rdx
add    %rsi,%rax
add    $0x8,%rax
cmp    %rdx,%rax
jb     1185 <kern_r8_o_b+0x85>
test   %cl,%cl
mov    $0x0,%edi
jne    1187 <kern_r8_o_b+0x87>
mov    0x338(%rsp),%rsi
and    $0xfffffffffffffffe,%rsi
movapd %xmm14,(%rsp)
unpcklpd %xmm14,%xmm14
movapd %xmm14,0x10(%rsp)
xor    %eax,%eax
mov    %rsi,-0x10(%rsp)
mov    -0x28(%rsp),%r8
mov    -0x40(%rsp),%rdi
mov    -0x38(%rsp),%rbp
mov    -0x30(%rsp),%rbx
mov    -0x20(%rsp),%rcx
mov    0x328(%rsp),%r12
mov    0x320(%rsp),%r13
mov    0x300(%rsp),%r9
mov    0x2f8(%rsp),%r10
mov    0x308(%rsp),%r11
mov    0x2f0(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r10,%rax,1),%xmm12
movupd 0x10(%r10,%rax,1),%xmm0
movapd %xmm12,%xmm8
unpcklpd %xmm0,%xmm8
unpckhpd %xmm0,%xmm12
mov    0x318(%rsp),%rdx
movupd (%rdx,%rax,1),%xmm0
movupd 0x10(%rdx,%rax,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movapd %xmm8,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,-0x60(%rsp)
subpd  %xmm2,%xmm8
movapd %xmm12,%xmm15
addpd  %xmm0,%xmm15
subpd  %xmm0,%xmm12
movupd (%r11,%rax,1),%xmm0
movupd 0x10(%r11,%rax,1),%xmm1
movapd %xmm0,%xmm4
unpcklpd %xmm1,%xmm4
unpckhpd %xmm1,%xmm0
movupd (%r12,%rax,1),%xmm1
movupd 0x10(%r12,%rax,1),%xmm2
movapd %xmm1,%xmm6
unpcklpd %xmm2,%xmm6
unpckhpd %xmm2,%xmm1
movapd %xmm4,%xmm2
addpd  %xmm6,%xmm2
movapd %xmm2,-0x50(%rsp)
subpd  %xmm6,%xmm4
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
movapd %xmm2,-0x70(%rsp)
subpd  %xmm1,%xmm0
movupd (%r14,%rax,1),%xmm6
movupd 0x10(%r14,%rax,1),%xmm1
movapd %xmm6,%xmm14
unpcklpd %xmm1,%xmm14
unpckhpd %xmm1,%xmm6
mov    0x310(%rsp),%rdx
movupd (%rdx,%rax,1),%xmm1
movupd 0x10(%rdx,%rax,1),%xmm2
movapd %xmm1,%xmm7
unpcklpd %xmm2,%xmm7
unpckhpd %xmm2,%xmm1
movapd %xmm14,%xmm11
addpd  %xmm7,%xmm11
subpd  %xmm7,%xmm14
movapd %xmm6,%xmm9
addpd  %xmm1,%xmm9
subpd  %xmm1,%xmm6
movupd (%r9,%rax,1),%xmm10
movupd 0x10(%r9,%rax,1),%xmm1
movapd %xmm10,%xmm7
unpcklpd %xmm1,%xmm7
unpckhpd %xmm1,%xmm10
movupd 0x0(%r13,%rax,1),%xmm1
movupd 0x10(%r13,%rax,1),%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm2,%xmm3
unpckhpd %xmm2,%xmm1
movapd %xmm7,%xmm2
addpd  %xmm3,%xmm2
subpd  %xmm3,%xmm7
movapd %xmm10,%xmm3
addpd  %xmm1,%xmm3
subpd  %xmm1,%xmm10
movapd 0x10(%rsp),%xmm5
mulpd  %xmm5,%xmm8
mulpd  %xmm5,%xmm12
movapd %xmm8,%xmm13
subpd  %xmm12,%xmm13
addpd  %xmm8,%xmm12
movapd %xmm5,%xmm1
mulpd  %xmm4,%xmm1
xorpd  0x6f7(%rip),%xmm4
mulpd  %xmm5,%xmm4
mulpd  %xmm5,%xmm0
subpd  %xmm0,%xmm4
subpd  %xmm0,%xmm1
movapd %xmm11,%xmm8
addpd  %xmm2,%xmm8
subpd  %xmm2,%xmm11
movapd %xmm11,0x20(%rsp)
movapd %xmm9,%xmm2
addpd  %xmm3,%xmm2
subpd  %xmm3,%xmm9
movapd %xmm14,%xmm5
subpd  %xmm10,%xmm5
addpd  %xmm14,%xmm10
movapd %xmm6,%xmm3
addpd  %xmm7,%xmm3
subpd  %xmm7,%xmm6
movapd -0x60(%rsp),%xmm7
movapd %xmm7,%xmm14
movapd -0x50(%rsp),%xmm0
addpd  %xmm0,%xmm14
subpd  %xmm0,%xmm7
movapd %xmm7,-0x60(%rsp)
movapd %xmm15,%xmm11
movapd -0x70(%rsp),%xmm0
addpd  %xmm0,%xmm11
subpd  %xmm0,%xmm15
movapd %xmm13,%xmm0
addpd  %xmm4,%xmm13
subpd  %xmm4,%xmm0
movapd %xmm0,-0x70(%rsp)
movapd %xmm12,%xmm4
addpd  %xmm1,%xmm4
subpd  %xmm1,%xmm12
movapd %xmm14,%xmm1
addpd  %xmm8,%xmm1
movapd %xmm11,%xmm7
addpd  %xmm2,%xmm7
movapd %xmm1,%xmm0
unpcklpd %xmm7,%xmm0
movhlps %xmm1,%xmm7
movups %xmm7,0x10(%rcx,%rax,1)
movupd %xmm0,(%rcx,%rax,1)
subpd  %xmm14,%xmm8
subpd  %xmm11,%xmm2
movapd %xmm8,%xmm0
unpcklpd %xmm2,%xmm0
movhlps %xmm8,%xmm2
movups %xmm2,0x10(%r8,%rax,1)
movupd %xmm0,(%r8,%rax,1)
movapd %xmm13,%xmm0
addpd  %xmm5,%xmm0
movapd %xmm4,%xmm1
addpd  %xmm3,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rbx,%rax,1)
movupd %xmm2,(%rbx,%rax,1)
subpd  %xmm13,%xmm5
subpd  %xmm4,%xmm3
movapd %xmm5,%xmm0
unpcklpd %xmm3,%xmm0
movhlps %xmm5,%xmm3
mov    -0x18(%rsp),%rdx
movups %xmm3,0x10(%rdx,%rax,1)
movupd %xmm0,(%rdx,%rax,1)
movapd 0x20(%rsp),%xmm3
movapd %xmm3,%xmm0
subpd  %xmm15,%xmm0
movapd -0x60(%rsp),%xmm4
movapd %xmm4,%xmm1
addpd  %xmm9,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rbp,%rax,1)
movupd %xmm2,0x0(%rbp,%rax,1)
addpd  %xmm3,%xmm15
subpd  %xmm4,%xmm9
movapd %xmm15,%xmm0
unpcklpd %xmm9,%xmm0
movhlps %xmm15,%xmm9
mov    0x2e0(%rsp),%rdx
movups %xmm9,0x10(%rdx,%rax,1)
movupd %xmm0,(%rdx,%rax,1)
movapd %xmm10,%xmm0
subpd  %xmm12,%xmm0
movapd -0x70(%rsp),%xmm3
movapd %xmm3,%xmm1
addpd  %xmm6,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm0,%xmm1
movups %xmm1,0x10(%rdi,%rax,1)
movupd %xmm2,(%rdi,%rax,1)
addpd  %xmm10,%xmm12
subpd  %xmm3,%xmm6
movapd %xmm12,%xmm0
unpcklpd %xmm6,%xmm0
movhlps %xmm12,%xmm6
mov    0x2e8(%rsp),%r15
movups %xmm6,0x10(%r15,%rax,1)
movupd %xmm0,(%r15,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rsi
jne    2780 <kern_r8_o_b+0x1680>
mov    -0x10(%rsp),%rdi
cmp    0x338(%rsp),%rdi
movapd (%rsp),%xmm14
jne    1187 <kern_r8_o_b+0x87>
jmp    149e <kern_r8_o_b+0x39e>

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

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