void kern_r4_u4_f(double *restrict o0, double *restrict o1, double *restrict o2,
                  double *restrict o3, double *i0, double *i1, double *i2,
                  double *i3, double *w, long bsize, long blocks) {
  long i;
  for (i = 0; i < blocks; i++) {
    double wr1, wi1;
    double wr2, wi2;
    double wr3, wi3;
    double pr1, pi1;
    double pr2, pi2;
    double pr3, pi3;
    double qr0, qi0;
    double qr1, qi1;
    double qr2, qi2;
    double qr3, qi3;
    wr1 = w[8 * i];
    wi1 = w[8 * i + 1];
    wr2 = w[16 * i];
    wi2 = w[16 * i + 1];
    wr3 = w[24 * i];
    wi3 = w[24 * i + 1];
    pr1 = i1[32 * i] * wr1 + i1[32 * i + 1] * wi1;
    pi1 = i1[32 * i + 1] * wr1 - i1[32 * i] * wi1;
    pr2 = i2[32 * i] * wr2 + i2[32 * i + 1] * wi2;
    pi2 = i2[32 * i + 1] * wr2 - i2[32 * i] * wi2;
    pr3 = i3[32 * i] * wr3 + i3[32 * i + 1] * wi3;
    pi3 = i3[32 * i + 1] * wr3 - i3[32 * i] * wi3;
    qr0 = i0[32 * i] + pr2;
    qr2 = i0[32 * i] - pr2;
    qi0 = i0[32 * i + 1] + pi2;
    qi2 = i0[32 * i + 1] - pi2;
    qr1 = pr1 + pr3;
    qr3 = pr1 - pr3;
    qi1 = pi1 + pi3;
    qi3 = pi1 - pi3;
    pr1 = i1[32 * i + 2] * wr1 + i1[32 * i + 3] * wi1;
    pi1 = i1[32 * i + 3] * wr1 - i1[32 * i + 2] * wi1;
    pr2 = i2[32 * i + 2] * wr2 + i2[32 * i + 3] * wi2;
    pi2 = i2[32 * i + 3] * wr2 - i2[32 * i + 2] * wi2;
    pr3 = i3[32 * i + 2] * wr3 + i3[32 * i + 3] * wi3;
    pi3 = i3[32 * i + 3] * wr3 - i3[32 * i + 2] * wi3;
    o0[8 * i] = qr0 + qr1;
    o0[8 * i + 1] = qi0 + qi1;
    o2[8 * i] = qr0 - qr1;
    o2[8 * i + 1] = qi0 - qi1;
    o1[8 * i] = qr2 + qi3;
    o1[8 * i + 1] = qi2 - qr3;
    o3[8 * i] = qr2 - qi3;
    o3[8 * i + 1] = qi2 + qr3;
    qr0 = i0[32 * i + 2] + pr2;
    qr2 = i0[32 * i + 2] - pr2;
    qi0 = i0[32 * i + 3] + pi2;
    qi2 = i0[32 * i + 3] - pi2;
    qr1 = pr1 + pr3;
    qr3 = pr1 - pr3;
    qi1 = pi1 + pi3;
    qi3 = pi1 - pi3;
    pr1 = i1[32 * i + 4] * wr1 + i1[32 * i + 5] * wi1;
    pi1 = i1[32 * i + 5] * wr1 - i1[32 * i + 4] * wi1;
    pr2 = i2[32 * i + 4] * wr2 + i2[32 * i + 5] * wi2;
    pi2 = i2[32 * i + 5] * wr2 - i2[32 * i + 4] * wi2;
    pr3 = i3[32 * i + 4] * wr3 + i3[32 * i + 5] * wi3;
    pi3 = i3[32 * i + 5] * wr3 - i3[32 * i + 4] * wi3;
    o0[8 * i + 2] = qr0 + qr1;
    o0[8 * i + 3] = qi0 + qi1;
    o2[8 * i + 2] = qr0 - qr1;
    o2[8 * i + 3] = qi0 - qi1;
    o1[8 * i + 2] = qr2 + qi3;
    o1[8 * i + 3] = qi2 - qr3;
    o3[8 * i + 2] = qr2 - qi3;
    o3[8 * i + 3] = qi2 + qr3;
    qr0 = i0[32 * i + 4] + pr2;
    qr2 = i0[32 * i + 4] - pr2;
    qi0 = i0[32 * i + 5] + pi2;
    qi2 = i0[32 * i + 5] - pi2;
    qr1 = pr1 + pr3;
    qr3 = pr1 - pr3;
    qi1 = pi1 + pi3;
    qi3 = pi1 - pi3;
    pr1 = i1[32 * i + 6] * wr1 + i1[32 * i + 7] * wi1;
    pi1 = i1[32 * i + 7] * wr1 - i1[32 * i + 6] * wi1;
    pr2 = i2[32 * i + 6] * wr2 + i2[32 * i + 7] * wi2;
    pi2 = i2[32 * i + 7] * wr2 - i2[32 * i + 6] * wi2;
    pr3 = i3[32 * i + 6] * wr3 + i3[32 * i + 7] * wi3;
    pi3 = i3[32 * i + 7] * wr3 - i3[32 * i + 6] * wi3;
    o0[8 * i + 4] = qr0 + qr1;
    o0[8 * i + 5] = qi0 + qi1;
    o2[8 * i + 4] = qr0 - qr1;
    o2[8 * i + 5] = qi0 - qi1;
    o1[8 * i + 4] = qr2 + qi3;
    o1[8 * i + 5] = qi2 - qr3;
    o3[8 * i + 4] = qr2 - qi3;
    o3[8 * i + 5] = qi2 + qr3;
    qr0 = i0[32 * i + 6] + pr2;
    qr2 = i0[32 * i + 6] - pr2;
    qi0 = i0[32 * i + 7] + pi2;
    qi2 = i0[32 * i + 7] - pi2;
    qr1 = pr1 + pr3;
    qr3 = pr1 - pr3;
    qi1 = pi1 + pi3;
    qi3 = pi1 - pi3;
    o0[8 * i + 6] = qr0 + qr1;
    o0[8 * i + 7] = qi0 + qi1;
    o2[8 * i + 6] = qr0 - qr1;
    o2[8 * i + 7] = qi0 - qi1;
    o1[8 * i + 6] = qr2 + qi3;
    o1[8 * i + 7] = qi2 - qr3;
    o3[8 * i + 6] = qr2 - qi3;
    o3[8 * i + 7] = qi2 + qr3;
  }
}


x86 assembly (clang, -O0):
<kern_r4_u4_f>:
push   %rbp
mov    %rsp,%rbp
sub    $0x58,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    0x30(%rbp),%rax
jge    2028 <kern_r4_u4_f+0xf28>
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x4,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x4,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x20(%rbp),%rax
imul   $0x18,-0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x20(%rbp),%rax
imul   $0x18,-0x38(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%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,-0x78(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%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,-0x78(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%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,-0x78(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x18(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x18(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x18(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x18(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%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,-0x78(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x20(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x28(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x20(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x28(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x20(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x28(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x20(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x28(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x30(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x38(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x30(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x38(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x30(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x38(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x30(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  %xmm0,0x38(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    113c <kern_r4_u4_f+0x3c>
add    $0x58,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r4_u4_f>:
push   %r15
push   %r14
push   %rbx
mov    0x40(%rsp),%r15
test   %r15,%r15
jle    1590 <kern_r4_u4_f+0x490>
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%r14
add    $0x8,%r10
xor    %ebx,%ebx
movapd 0xecf(%rip),%xmm8
mov    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r9,%rbx,4),%xmm3
movsd  0x8(%r9,%rbx,4),%xmm0
movapd %xmm3,%xmm2
xorpd  %xmm8,%xmm2
movsd  -0x8(%r10,%rbx,1),%xmm14
movsd  (%r10,%rbx,1),%xmm11
movsd  -0x8(%r10,%rbx,2),%xmm12
movsd  (%r10,%rbx,2),%xmm9
movapd %xmm9,%xmm4
unpcklpd %xmm11,%xmm4
movsd  (%r14,%rbx,4),%xmm5
movsd  0x8(%r14,%rbx,4),%xmm6
unpcklpd %xmm6,%xmm3
unpcklpd %xmm2,%xmm6
mulpd  %xmm4,%xmm6
movapd %xmm5,%xmm4
unpcklpd %xmm0,%xmm4
movapd %xmm12,%xmm2
unpcklpd %xmm14,%xmm2
mulpd  %xmm4,%xmm2
addpd  %xmm6,%xmm2
xorpd  %xmm8,%xmm5
movapd %xmm11,%xmm4
unpcklpd %xmm9,%xmm4
unpcklpd %xmm5,%xmm0
mulpd  %xmm4,%xmm0
movapd %xmm14,%xmm4
unpcklpd %xmm12,%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm0,%xmm4
movupd (%r11,%rbx,4),%xmm3
movupd 0x10(%r11,%rbx,4),%xmm15
movapd %xmm3,%xmm5
xorpd  %xmm8,%xmm5
shufpd $0x2,%xmm3,%xmm5
movapd %xmm3,%xmm7
shufpd $0x1,%xmm3,%xmm7
movsd  -0x8(%rax),%xmm13
movsd  (%rax),%xmm10
unpcklpd %xmm10,%xmm10
mulpd  %xmm10,%xmm5
unpcklpd %xmm13,%xmm13
mulpd  %xmm13,%xmm7
addpd  %xmm5,%xmm7
movupd (%r8,%rbx,4),%xmm6
movapd %xmm4,%xmm3
movsd  %xmm2,%xmm3
movapd %xmm6,%xmm1
subpd  %xmm3,%xmm1
movapd %xmm7,%xmm3
unpckhpd %xmm6,%xmm3
addpd  %xmm4,%xmm3
unpcklpd %xmm7,%xmm6
addpd  %xmm2,%xmm6
shufpd $0x1,%xmm4,%xmm2
subpd  %xmm7,%xmm2
movupd 0x10(%r9,%rbx,4),%xmm5
movapd %xmm5,%xmm4
xorpd  %xmm8,%xmm4
unpcklpd %xmm11,%xmm11
movapd %xmm5,%xmm7
shufpd $0x1,%xmm4,%xmm7
mulpd  %xmm11,%xmm7
unpcklpd %xmm14,%xmm14
mulpd  %xmm14,%xmm5
addpd  %xmm7,%xmm5
movupd 0x10(%r14,%rbx,4),%xmm0
movapd %xmm0,%xmm7
xorpd  %xmm8,%xmm7
unpcklpd %xmm9,%xmm9
movapd %xmm0,%xmm4
shufpd $0x1,%xmm7,%xmm4
mulpd  %xmm9,%xmm4
unpcklpd %xmm12,%xmm12
mulpd  %xmm12,%xmm0
addpd  %xmm4,%xmm0
movapd %xmm15,%xmm4
xorpd  %xmm8,%xmm4
movapd %xmm15,%xmm7
shufpd $0x1,%xmm4,%xmm7
mulpd  %xmm10,%xmm7
mulpd  %xmm13,%xmm15
addpd  %xmm7,%xmm15
movapd %xmm6,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,(%rdi,%rbx,1)
movapd %xmm3,%xmm4
movsd  %xmm6,%xmm4
movsd  %xmm3,%xmm6
subpd  %xmm6,%xmm4
movupd %xmm4,(%rdx,%rbx,1)
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm2,%xmm1
movapd %xmm1,%xmm2
movsd  %xmm3,%xmm2
movupd %xmm2,(%rsi,%rbx,1)
shufpd $0x2,%xmm3,%xmm1
movupd %xmm1,(%rcx,%rbx,1)
movupd 0x10(%r8,%rbx,4),%xmm2
movapd %xmm0,%xmm4
unpcklpd %xmm15,%xmm4
movapd %xmm5,%xmm1
addpd  %xmm15,%xmm1
unpckhpd %xmm0,%xmm15
movapd %xmm0,%xmm6
addpd  %xmm2,%xmm6
movapd %xmm2,%xmm3
unpcklpd %xmm5,%xmm3
subpd  %xmm4,%xmm3
unpckhpd %xmm2,%xmm5
subpd  %xmm15,%xmm5
movupd 0x20(%r9,%rbx,4),%xmm15
movapd %xmm15,%xmm2
xorpd  %xmm8,%xmm2
movapd %xmm15,%xmm4
shufpd $0x1,%xmm2,%xmm4
mulpd  %xmm11,%xmm4
mulpd  %xmm14,%xmm15
addpd  %xmm4,%xmm15
movupd 0x20(%r14,%rbx,4),%xmm2
movapd %xmm2,%xmm4
xorpd  %xmm8,%xmm4
movapd %xmm2,%xmm7
shufpd $0x1,%xmm4,%xmm7
mulpd  %xmm9,%xmm7
mulpd  %xmm12,%xmm2
addpd  %xmm7,%xmm2
movupd 0x20(%r11,%rbx,4),%xmm7
movapd %xmm7,%xmm0
xorpd  %xmm8,%xmm0
movapd %xmm7,%xmm4
shufpd $0x1,%xmm0,%xmm4
mulpd  %xmm10,%xmm4
mulpd  %xmm13,%xmm7
addpd  %xmm4,%xmm7
movapd %xmm1,%xmm0
addpd  %xmm6,%xmm0
movupd %xmm0,0x10(%rdi,%rbx,1)
subpd  %xmm1,%xmm6
movupd %xmm6,0x10(%rdx,%rbx,1)
movapd %xmm5,%xmm0
addpd  %xmm3,%xmm0
movapd %xmm5,%xmm1
subpd  %xmm3,%xmm1
movsd  %xmm0,%xmm1
movupd %xmm1,0x10(%rsi,%rbx,1)
subpd  %xmm5,%xmm3
shufpd $0x2,%xmm0,%xmm3
movupd %xmm3,0x10(%rcx,%rbx,1)
movupd 0x20(%r8,%rbx,4),%xmm0
movapd %xmm2,%xmm1
unpcklpd %xmm7,%xmm1
movapd %xmm15,%xmm3
addpd  %xmm7,%xmm3
unpckhpd %xmm2,%xmm7
movapd %xmm2,%xmm5
addpd  %xmm0,%xmm5
movapd %xmm0,%xmm2
unpcklpd %xmm15,%xmm2
subpd  %xmm1,%xmm2
unpckhpd %xmm0,%xmm15
subpd  %xmm7,%xmm15
movupd 0x30(%r9,%rbx,4),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm14
xorpd  %xmm8,%xmm0
shufpd $0x1,%xmm0,%xmm1
mulpd  %xmm11,%xmm1
addpd  %xmm1,%xmm14
movupd 0x30(%r14,%rbx,4),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm12
xorpd  %xmm8,%xmm0
shufpd $0x1,%xmm0,%xmm1
mulpd  %xmm9,%xmm1
addpd  %xmm1,%xmm12
movupd 0x30(%r11,%rbx,4),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm13
xorpd  %xmm8,%xmm0
shufpd $0x1,%xmm0,%xmm1
mulpd  %xmm10,%xmm1
addpd  %xmm1,%xmm13
movapd %xmm3,%xmm0
addpd  %xmm5,%xmm0
movupd %xmm0,0x20(%rdi,%rbx,1)
subpd  %xmm3,%xmm5
movupd %xmm5,0x20(%rdx,%rbx,1)
movapd %xmm15,%xmm0
addpd  %xmm2,%xmm0
movapd %xmm15,%xmm1
subpd  %xmm2,%xmm1
movsd  %xmm0,%xmm1
movupd %xmm1,0x20(%rsi,%rbx,1)
subpd  %xmm15,%xmm2
shufpd $0x2,%xmm0,%xmm2
movupd %xmm2,0x20(%rcx,%rbx,1)
movupd 0x30(%r8,%rbx,4),%xmm0
movapd %xmm12,%xmm1
unpcklpd %xmm13,%xmm1
movapd %xmm14,%xmm2
addpd  %xmm13,%xmm2
unpckhpd %xmm12,%xmm13
addpd  %xmm0,%xmm12
movapd %xmm0,%xmm3
unpcklpd %xmm14,%xmm3
subpd  %xmm1,%xmm3
unpckhpd %xmm0,%xmm14
subpd  %xmm13,%xmm14
movapd %xmm2,%xmm0
addpd  %xmm12,%xmm0
movupd %xmm0,0x30(%rdi,%rbx,1)
subpd  %xmm2,%xmm12
movupd %xmm12,0x30(%rdx,%rbx,1)
movapd %xmm14,%xmm0
addpd  %xmm3,%xmm0
movapd %xmm14,%xmm1
subpd  %xmm3,%xmm1
movsd  %xmm0,%xmm1
movupd %xmm1,0x30(%rsi,%rbx,1)
subpd  %xmm14,%xmm3
shufpd $0x2,%xmm0,%xmm3
movupd %xmm3,0x30(%rcx,%rbx,1)
add    $0xc0,%rax
add    $0x40,%rbx
add    $0xffffffffffffffff,%r15
jne    1140 <kern_r4_u4_f+0x40>
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @kern_r4_u4_f(double* noalias nocapture writeonly %0, double* noalias nocapture writeonly %1, double* noalias nocapture writeonly %2, double* noalias nocapture writeonly %3, double* nocapture %4, double* nocapture %5, double* nocapture %6, double* nocapture %7, double* nocapture %8, i64 %9, i64 %10) {
%12 = icmp sgt i64 %10, 0
br i1 %12, label %13, label %279
13: ; preds = %11, %13
%14 = phi i64 [ %277, %13 ], [ 0, %11 ]
%15 = shl nsw i64 %14, 3
%16 = getelementptr inbounds double, double* %8, i64 %15
%17 = load double, double* %16
%18 = or i64 %15, 1
%19 = getelementptr inbounds double, double* %8, i64 %18
%20 = load double, double* %19
%21 = shl nsw i64 %14, 4
%22 = getelementptr inbounds double, double* %8, i64 %21
%23 = load double, double* %22
%24 = or i64 %21, 1
%25 = getelementptr inbounds double, double* %8, i64 %24
%26 = load double, double* %25
%27 = mul nuw nsw i64 %14, 24
%28 = getelementptr inbounds double, double* %8, i64 %27
%29 = load double, double* %28
%30 = or i64 %27, 1
%31 = getelementptr inbounds double, double* %8, i64 %30
%32 = load double, double* %31
%33 = shl nsw i64 %14, 5
%34 = getelementptr inbounds double, double* %5, i64 %33
%35 = load double, double* %34
%36 = or i64 %33, 1
%37 = getelementptr inbounds double, double* %5, i64 %36
%38 = load double, double* %37
%39 = fneg double %35
%40 = getelementptr inbounds double, double* %6, i64 %33
%41 = load double, double* %40
%42 = getelementptr inbounds double, double* %6, i64 %36
%43 = load double, double* %42
%44 = insertelement <2 x double> poison, double %26, i64 0
%45 = insertelement <2 x double> %44, double %20, i64 1
%46 = insertelement <2 x double> poison, double %43, i64 0
%47 = insertelement <2 x double> %46, double %39, i64 1
%48 = fmul <2 x double> %45, %47
%49 = insertelement <2 x double> poison, double %41, i64 0
%50 = insertelement <2 x double> %49, double %38, i64 1
%51 = insertelement <2 x double> poison, double %23, i64 0
%52 = insertelement <2 x double> %51, double %17, i64 1
%53 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %50, <2 x double> %52, <2 x double> %48)
%54 = fneg double %41
%55 = insertelement <2 x double> poison, double %20, i64 0
%56 = insertelement <2 x double> %55, double %26, i64 1
%57 = insertelement <2 x double> poison, double %38, i64 0
%58 = insertelement <2 x double> %57, double %54, i64 1
%59 = fmul <2 x double> %56, %58
%60 = insertelement <2 x double> poison, double %35, i64 0
%61 = insertelement <2 x double> %60, double %43, i64 1
%62 = insertelement <2 x double> poison, double %17, i64 0
%63 = insertelement <2 x double> %62, double %23, i64 1
%64 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %61, <2 x double> %63, <2 x double> %59)
%65 = getelementptr inbounds double, double* %7, i64 %33
%66 = bitcast double* %65 to <2 x double>*
%67 = load <2 x double>, <2 x double>* %66
%68 = shufflevector <2 x double> %67, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%69 = extractelement <2 x double> %67, i64 0
%70 = fneg double %69
%71 = insertelement <2 x double> poison, double %32, i64 0
%72 = shufflevector <2 x double> %71, <2 x double> poison, <2 x i32> zeroinitializer
%73 = insertelement <2 x double> %67, double %70, i64 0
%74 = fmul <2 x double> %72, %73
%75 = insertelement <2 x double> poison, double %29, i64 0
%76 = shufflevector <2 x double> %75, <2 x double> poison, <2 x i32> zeroinitializer
%77 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %68, <2 x double> %76, <2 x double> %74)
%78 = getelementptr inbounds double, double* %4, i64 %33
%79 = bitcast double* %78 to <2 x double>*
%80 = load <2 x double>, <2 x double>* %79
%81 = shufflevector <2 x double> %53, <2 x double> %64, <2 x i32> <i32 0, i32 3>
%82 = fsub <2 x double> %80, %81
%83 = shufflevector <2 x double> %77, <2 x double> %80, <2 x i32> <i32 1, i32 3>
%84 = fadd <2 x double> %64, %83
%85 = shufflevector <2 x double> %80, <2 x double> %77, <2 x i32> <i32 0, i32 2>
%86 = fadd <2 x double> %53, %85
%87 = shufflevector <2 x double> %53, <2 x double> %64, <2 x i32> <i32 1, i32 2>
%88 = fsub <2 x double> %87, %77
%89 = or i64 %33, 2
%90 = getelementptr inbounds double, double* %5, i64 %89
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = extractelement <2 x double> %92, i64 0
%94 = fneg double %93
%95 = shufflevector <2 x double> %55, <2 x double> poison, <2 x i32> zeroinitializer
%96 = insertelement <2 x double> %92, double %94, i64 0
%97 = fmul <2 x double> %95, %96
%98 = shufflevector <2 x double> %97, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%99 = shufflevector <2 x double> %62, <2 x double> poison, <2 x i32> zeroinitializer
%100 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %92, <2 x double> %99, <2 x double> %98)
%101 = getelementptr inbounds double, double* %6, i64 %89
%102 = bitcast double* %101 to <2 x double>*
%103 = load <2 x double>, <2 x double>* %102
%104 = extractelement <2 x double> %103, i64 0
%105 = fneg double %104
%106 = shufflevector <2 x double> %44, <2 x double> poison, <2 x i32> zeroinitializer
%107 = insertelement <2 x double> %103, double %105, i64 0
%108 = fmul <2 x double> %106, %107
%109 = shufflevector <2 x double> %108, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%110 = shufflevector <2 x double> %51, <2 x double> poison, <2 x i32> zeroinitializer
%111 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %103, <2 x double> %110, <2 x double> %109)
%112 = getelementptr inbounds double, double* %7, i64 %89
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = extractelement <2 x double> %114, i64 0
%116 = fneg double %115
%117 = insertelement <2 x double> %114, double %116, i64 0
%118 = fmul <2 x double> %72, %117
%119 = shufflevector <2 x double> %118, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%120 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %76, <2 x double> %119)
%121 = getelementptr inbounds double, double* %0, i64 %15
%122 = fadd <2 x double> %86, %84
%123 = bitcast double* %121 to <2 x double>*
store <2 x double> %122, <2 x double>* %123
%124 = getelementptr inbounds double, double* %2, i64 %15
%125 = shufflevector <2 x double> %86, <2 x double> %84, <2 x i32> <i32 0, i32 3>
%126 = shufflevector <2 x double> %84, <2 x double> %86, <2 x i32> <i32 0, i32 3>
%127 = fsub <2 x double> %125, %126
%128 = bitcast double* %124 to <2 x double>*
store <2 x double> %127, <2 x double>* %128
%129 = getelementptr inbounds double, double* %1, i64 %15
%130 = fadd <2 x double> %82, %88
%131 = fsub <2 x double> %82, %88
%132 = shufflevector <2 x double> %130, <2 x double> %131, <2 x i32> <i32 0, i32 3>
%133 = bitcast double* %129 to <2 x double>*
store <2 x double> %132, <2 x double>* %133
%134 = getelementptr inbounds double, double* %3, i64 %15
%135 = shufflevector <2 x double> %131, <2 x double> %130, <2 x i32> <i32 0, i32 3>
%136 = bitcast double* %134 to <2 x double>*
store <2 x double> %135, <2 x double>* %136
%137 = getelementptr inbounds double, double* %4, i64 %89
%138 = bitcast double* %137 to <2 x double>*
%139 = load <2 x double>, <2 x double>* %138
%140 = fadd <2 x double> %111, %139
%141 = shufflevector <2 x double> %139, <2 x double> %100, <2 x i32> <i32 0, i32 2>
%142 = shufflevector <2 x double> %111, <2 x double> %120, <2 x i32> <i32 0, i32 2>
%143 = fsub <2 x double> %141, %142
%144 = fadd <2 x double> %100, %120
%145 = shufflevector <2 x double> %100, <2 x double> %139, <2 x i32> <i32 1, i32 3>
%146 = shufflevector <2 x double> %120, <2 x double> %111, <2 x i32> <i32 1, i32 3>
%147 = fsub <2 x double> %145, %146
%148 = or i64 %33, 4
%149 = getelementptr inbounds double, double* %5, i64 %148
%150 = bitcast double* %149 to <2 x double>*
%151 = load <2 x double>, <2 x double>* %150
%152 = extractelement <2 x double> %151, i64 0
%153 = fneg double %152
%154 = insertelement <2 x double> %151, double %153, i64 0
%155 = fmul <2 x double> %95, %154
%156 = shufflevector <2 x double> %155, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%157 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %151, <2 x double> %99, <2 x double> %156)
%158 = getelementptr inbounds double, double* %6, i64 %148
%159 = bitcast double* %158 to <2 x double>*
%160 = load <2 x double>, <2 x double>* %159
%161 = extractelement <2 x double> %160, i64 0
%162 = fneg double %161
%163 = insertelement <2 x double> %160, double %162, i64 0
%164 = fmul <2 x double> %106, %163
%165 = shufflevector <2 x double> %164, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%166 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %160, <2 x double> %110, <2 x double> %165)
%167 = getelementptr inbounds double, double* %7, i64 %148
%168 = bitcast double* %167 to <2 x double>*
%169 = load <2 x double>, <2 x double>* %168
%170 = extractelement <2 x double> %169, i64 0
%171 = fneg double %170
%172 = insertelement <2 x double> %169, double %171, i64 0
%173 = fmul <2 x double> %72, %172
%174 = shufflevector <2 x double> %173, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%175 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %169, <2 x double> %76, <2 x double> %174)
%176 = or i64 %15, 2
%177 = getelementptr inbounds double, double* %0, i64 %176
%178 = fadd <2 x double> %144, %140
%179 = bitcast double* %177 to <2 x double>*
store <2 x double> %178, <2 x double>* %179
%180 = getelementptr inbounds double, double* %2, i64 %176
%181 = fsub <2 x double> %140, %144
%182 = bitcast double* %180 to <2 x double>*
store <2 x double> %181, <2 x double>* %182
%183 = getelementptr inbounds double, double* %1, i64 %176
%184 = fadd <2 x double> %147, %143
%185 = fsub <2 x double> %147, %143
%186 = shufflevector <2 x double> %184, <2 x double> %185, <2 x i32> <i32 0, i32 3>
%187 = bitcast double* %183 to <2 x double>*
store <2 x double> %186, <2 x double>* %187
%188 = getelementptr inbounds double, double* %3, i64 %176
%189 = fsub <2 x double> %143, %147
%190 = fadd <2 x double> %143, %147
%191 = shufflevector <2 x double> %189, <2 x double> %190, <2 x i32> <i32 0, i32 3>
%192 = bitcast double* %188 to <2 x double>*
store <2 x double> %191, <2 x double>* %192
%193 = getelementptr inbounds double, double* %4, i64 %148
%194 = bitcast double* %193 to <2 x double>*
%195 = load <2 x double>, <2 x double>* %194
%196 = fadd <2 x double> %166, %195
%197 = shufflevector <2 x double> %195, <2 x double> %157, <2 x i32> <i32 0, i32 2>
%198 = shufflevector <2 x double> %166, <2 x double> %175, <2 x i32> <i32 0, i32 2>
%199 = fsub <2 x double> %197, %198
%200 = fadd <2 x double> %157, %175
%201 = shufflevector <2 x double> %157, <2 x double> %195, <2 x i32> <i32 1, i32 3>
%202 = shufflevector <2 x double> %175, <2 x double> %166, <2 x i32> <i32 1, i32 3>
%203 = fsub <2 x double> %201, %202
%204 = or i64 %33, 6
%205 = getelementptr inbounds double, double* %5, i64 %204
%206 = bitcast double* %205 to <2 x double>*
%207 = load <2 x double>, <2 x double>* %206
%208 = extractelement <2 x double> %207, i64 0
%209 = fneg double %208
%210 = insertelement <2 x double> %207, double %209, i64 0
%211 = fmul <2 x double> %95, %210
%212 = shufflevector <2 x double> %211, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%213 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %207, <2 x double> %99, <2 x double> %212)
%214 = getelementptr inbounds double, double* %6, i64 %204
%215 = bitcast double* %214 to <2 x double>*
%216 = load <2 x double>, <2 x double>* %215
%217 = extractelement <2 x double> %216, i64 0
%218 = fneg double %217
%219 = insertelement <2 x double> %216, double %218, i64 0
%220 = fmul <2 x double> %106, %219
%221 = shufflevector <2 x double> %220, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%222 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %216, <2 x double> %110, <2 x double> %221)
%223 = getelementptr inbounds double, double* %7, i64 %204
%224 = bitcast double* %223 to <2 x double>*
%225 = load <2 x double>, <2 x double>* %224
%226 = extractelement <2 x double> %225, i64 0
%227 = fneg double %226
%228 = insertelement <2 x double> %225, double %227, i64 0
%229 = fmul <2 x double> %72, %228
%230 = shufflevector <2 x double> %229, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%231 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %225, <2 x double> %76, <2 x double> %230)
%232 = or i64 %15, 4
%233 = getelementptr inbounds double, double* %0, i64 %232
%234 = fadd <2 x double> %200, %196
%235 = bitcast double* %233 to <2 x double>*
store <2 x double> %234, <2 x double>* %235
%236 = getelementptr inbounds double, double* %2, i64 %232
%237 = fsub <2 x double> %196, %200
%238 = bitcast double* %236 to <2 x double>*
store <2 x double> %237, <2 x double>* %238
%239 = getelementptr inbounds double, double* %1, i64 %232
%240 = fadd <2 x double> %203, %199
%241 = fsub <2 x double> %203, %199
%242 = shufflevector <2 x double> %240, <2 x double> %241, <2 x i32> <i32 0, i32 3>
%243 = bitcast double* %239 to <2 x double>*
store <2 x double> %242, <2 x double>* %243
%244 = getelementptr inbounds double, double* %3, i64 %232
%245 = fsub <2 x double> %199, %203
%246 = fadd <2 x double> %199, %203
%247 = shufflevector <2 x double> %245, <2 x double> %246, <2 x i32> <i32 0, i32 3>
%248 = bitcast double* %244 to <2 x double>*
store <2 x double> %247, <2 x double>* %248
%249 = getelementptr inbounds double, double* %4, i64 %204
%250 = bitcast double* %249 to <2 x double>*
%251 = load <2 x double>, <2 x double>* %250
%252 = fadd <2 x double> %222, %251
%253 = shufflevector <2 x double> %251, <2 x double> %213, <2 x i32> <i32 0, i32 2>
%254 = shufflevector <2 x double> %222, <2 x double> %231, <2 x i32> <i32 0, i32 2>
%255 = fsub <2 x double> %253, %254
%256 = fadd <2 x double> %213, %231
%257 = shufflevector <2 x double> %213, <2 x double> %251, <2 x i32> <i32 1, i32 3>
%258 = shufflevector <2 x double> %231, <2 x double> %222, <2 x i32> <i32 1, i32 3>
%259 = fsub <2 x double> %257, %258
%260 = or i64 %15, 6
%261 = getelementptr inbounds double, double* %0, i64 %260
%262 = fadd <2 x double> %256, %252
%263 = bitcast double* %261 to <2 x double>*
store <2 x double> %262, <2 x double>* %263
%264 = getelementptr inbounds double, double* %2, i64 %260
%265 = fsub <2 x double> %252, %256
%266 = bitcast double* %264 to <2 x double>*
store <2 x double> %265, <2 x double>* %266
%267 = getelementptr inbounds double, double* %1, i64 %260
%268 = fadd <2 x double> %259, %255
%269 = fsub <2 x double> %259, %255
%270 = shufflevector <2 x double> %268, <2 x double> %269, <2 x i32> <i32 0, i32 3>
%271 = bitcast double* %267 to <2 x double>*
store <2 x double> %270, <2 x double>* %271
%272 = getelementptr inbounds double, double* %3, i64 %260
%273 = fsub <2 x double> %255, %259
%274 = fadd <2 x double> %255, %259
%275 = shufflevector <2 x double> %273, <2 x double> %274, <2 x i32> <i32 0, i32 3>
%276 = bitcast double* %272 to <2 x double>*
store <2 x double> %275, <2 x double>* %276
%277 = add nuw nsw i64 %14, 1
%278 = icmp eq i64 %277, %10
br i1 %278, label %279, label %13
279: ; preds = %13, %11
ret void
}