void kern_r4_u4_b(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] * wi1 + i1[32 * i + 1] * wr1;
    pr2 = i2[32 * i] * wr2 - i2[32 * i + 1] * wi2;
    pi2 = i2[32 * i] * wi2 + i2[32 * i + 1] * wr2;
    pr3 = i3[32 * i] * wr3 - i3[32 * i + 1] * wi3;
    pi3 = i3[32 * i] * wi3 + i3[32 * i + 1] * wr3;
    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 + 2] * wi1 + i1[32 * i + 3] * wr1;
    pr2 = i2[32 * i + 2] * wr2 - i2[32 * i + 3] * wi2;
    pi2 = i2[32 * i + 2] * wi2 + i2[32 * i + 3] * wr2;
    pr3 = i3[32 * i + 2] * wr3 - i3[32 * i + 3] * wi3;
    pi3 = i3[32 * i + 2] * wi3 + i3[32 * i + 3] * wr3;
    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 + 4] * wi1 + i1[32 * i + 5] * wr1;
    pr2 = i2[32 * i + 4] * wr2 - i2[32 * i + 5] * wi2;
    pi2 = i2[32 * i + 4] * wi2 + i2[32 * i + 5] * wr2;
    pr3 = i3[32 * i + 4] * wr3 - i3[32 * i + 5] * wi3;
    pi3 = i3[32 * i + 4] * wi3 + i3[32 * i + 5] * wr3;
    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 + 6] * wi1 + i1[32 * i + 7] * wr1;
    pr2 = i2[32 * i + 6] * wr2 - i2[32 * i + 7] * wi2;
    pi2 = i2[32 * i + 6] * wi2 + i2[32 * i + 7] * wr2;
    pr3 = i3[32 * i + 6] * wr3 - i3[32 * i + 7] * wi3;
    pi3 = i3[32 * i + 6] * wi3 + i3[32 * i + 7] * wr3;
    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_b>:
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_b+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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x40(%rbp),%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x50(%rbp),%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  -0x60(%rbp),%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  -0x40(%rbp),%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  -0x50(%rbp),%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x10(%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  -0x60(%rbp),%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
subsd  -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
addsd  -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
addsd  -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
subsd  -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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm1
mulsd  -0x40(%rbp),%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm1
mulsd  -0x50(%rbp),%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x20(%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x28(%rax,%rcx,8),%xmm1
mulsd  -0x60(%rbp),%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
subsd  -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
addsd  -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
addsd  -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
subsd  -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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm1
mulsd  -0x40(%rbp),%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm1
mulsd  -0x50(%rbp),%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
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x30(%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x5,%rcx
movsd  0x38(%rax,%rcx,8),%xmm1
mulsd  -0x60(%rbp),%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
subsd  -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
addsd  -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
addsd  -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
subsd  -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
subsd  -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
addsd  -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
addsd  -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
subsd  -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_b+0x3c>
add    $0x58,%rsp
pop    %rbp
ret

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

LLVM IR (-O0):
define void @kern_r4_u4_b(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 = fneg double %95
%97 = call double @llvm.fmuladd.f64(double %86, double %87, double %96)
store double %97, double* %30
%98 = load double*, double** %17
%99 = load i64, i64* %23
%100 = mul nsw i64 32, %99
%101 = getelementptr inbounds double, double* %98, i64 %100
%102 = load double, double* %101
%103 = load double, double* %25
%104 = load double*, double** %17
%105 = load i64, i64* %23
%106 = mul nsw i64 32, %105
%107 = add nsw i64 %106, 1
%108 = getelementptr inbounds double, double* %104, i64 %107
%109 = load double, double* %108
%110 = load double, double* %24
%111 = fmul double %109, %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 = fneg double %126
%128 = call double @llvm.fmuladd.f64(double %117, double %118, double %127)
store double %128, double* %32
%129 = load double*, double** %18
%130 = load i64, i64* %23
%131 = mul nsw i64 32, %130
%132 = getelementptr inbounds double, double* %129, i64 %131
%133 = load double, double* %132
%134 = load double, double* %27
%135 = load double*, double** %18
%136 = load i64, i64* %23
%137 = mul nsw i64 32, %136
%138 = add nsw i64 %137, 1
%139 = getelementptr inbounds double, double* %135, i64 %138
%140 = load double, double* %139
%141 = load double, double* %26
%142 = fmul double %140, %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 = fneg double %157
%159 = call double @llvm.fmuladd.f64(double %148, double %149, double %158)
store double %159, double* %34
%160 = load double*, double** %19
%161 = load i64, i64* %23
%162 = mul nsw i64 32, %161
%163 = getelementptr inbounds double, double* %160, i64 %162
%164 = load double, double* %163
%165 = load double, double* %29
%166 = load double*, double** %19
%167 = load i64, i64* %23
%168 = mul nsw i64 32, %167
%169 = add nsw i64 %168, 1
%170 = getelementptr inbounds double, double* %166, i64 %169
%171 = load double, double* %170
%172 = load double, double* %28
%173 = fmul double %171, %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 = fneg double %231
%233 = call double @llvm.fmuladd.f64(double %222, double %223, double %232)
store double %233, double* %30
%234 = load double*, double** %17
%235 = load i64, i64* %23
%236 = mul nsw i64 32, %235
%237 = add nsw i64 %236, 2
%238 = getelementptr inbounds double, double* %234, i64 %237
%239 = load double, double* %238
%240 = load double, double* %25
%241 = load double*, double** %17
%242 = load i64, i64* %23
%243 = mul nsw i64 32, %242
%244 = add nsw i64 %243, 3
%245 = getelementptr inbounds double, double* %241, i64 %244
%246 = load double, double* %245
%247 = load double, double* %24
%248 = fmul double %246, %247
%249 = call double @llvm.fmuladd.f64(double %239, double %240, 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 = fneg double %264
%266 = call double @llvm.fmuladd.f64(double %255, double %256, double %265)
store double %266, double* %32
%267 = load double*, double** %18
%268 = load i64, i64* %23
%269 = mul nsw i64 32, %268
%270 = add nsw i64 %269, 2
%271 = getelementptr inbounds double, double* %267, i64 %270
%272 = load double, double* %271
%273 = load double, double* %27
%274 = load double*, double** %18
%275 = load i64, i64* %23
%276 = mul nsw i64 32, %275
%277 = add nsw i64 %276, 3
%278 = getelementptr inbounds double, double* %274, i64 %277
%279 = load double, double* %278
%280 = load double, double* %26
%281 = fmul double %279, %280
%282 = call double @llvm.fmuladd.f64(double %272, double %273, 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 = fneg double %297
%299 = call double @llvm.fmuladd.f64(double %288, double %289, double %298)
store double %299, double* %34
%300 = load double*, double** %19
%301 = load i64, i64* %23
%302 = mul nsw i64 32, %301
%303 = add nsw i64 %302, 2
%304 = getelementptr inbounds double, double* %300, i64 %303
%305 = load double, double* %304
%306 = load double, double* %29
%307 = load double*, double** %19
%308 = load i64, i64* %23
%309 = mul nsw i64 32, %308
%310 = add nsw i64 %309, 3
%311 = getelementptr inbounds double, double* %307, i64 %310
%312 = load double, double* %311
%313 = load double, double* %28
%314 = fmul double %312, %313
%315 = call double @llvm.fmuladd.f64(double %305, double %306, 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 = fsub 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 = fadd 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 = fadd 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 = fsub 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 = fneg double %434
%436 = call double @llvm.fmuladd.f64(double %425, double %426, double %435)
store double %436, double* %30
%437 = load double*, double** %17
%438 = load i64, i64* %23
%439 = mul nsw i64 32, %438
%440 = add nsw i64 %439, 4
%441 = getelementptr inbounds double, double* %437, i64 %440
%442 = load double, double* %441
%443 = load double, double* %25
%444 = load double*, double** %17
%445 = load i64, i64* %23
%446 = mul nsw i64 32, %445
%447 = add nsw i64 %446, 5
%448 = getelementptr inbounds double, double* %444, i64 %447
%449 = load double, double* %448
%450 = load double, double* %24
%451 = fmul double %449, %450
%452 = call double @llvm.fmuladd.f64(double %442, double %443, 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 = fneg double %467
%469 = call double @llvm.fmuladd.f64(double %458, double %459, double %468)
store double %469, double* %32
%470 = load double*, double** %18
%471 = load i64, i64* %23
%472 = mul nsw i64 32, %471
%473 = add nsw i64 %472, 4
%474 = getelementptr inbounds double, double* %470, i64 %473
%475 = load double, double* %474
%476 = load double, double* %27
%477 = load double*, double** %18
%478 = load i64, i64* %23
%479 = mul nsw i64 32, %478
%480 = add nsw i64 %479, 5
%481 = getelementptr inbounds double, double* %477, i64 %480
%482 = load double, double* %481
%483 = load double, double* %26
%484 = fmul double %482, %483
%485 = call double @llvm.fmuladd.f64(double %475, double %476, 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 = fneg double %500
%502 = call double @llvm.fmuladd.f64(double %491, double %492, double %501)
store double %502, double* %34
%503 = load double*, double** %19
%504 = load i64, i64* %23
%505 = mul nsw i64 32, %504
%506 = add nsw i64 %505, 4
%507 = getelementptr inbounds double, double* %503, i64 %506
%508 = load double, double* %507
%509 = load double, double* %29
%510 = load double*, double** %19
%511 = load i64, i64* %23
%512 = mul nsw i64 32, %511
%513 = add nsw i64 %512, 5
%514 = getelementptr inbounds double, double* %510, i64 %513
%515 = load double, double* %514
%516 = load double, double* %28
%517 = fmul double %515, %516
%518 = call double @llvm.fmuladd.f64(double %508, double %509, 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 = fsub 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 = fadd 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 = fadd 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 = fsub 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 = fneg double %641
%643 = call double @llvm.fmuladd.f64(double %632, double %633, double %642)
store double %643, double* %30
%644 = load double*, double** %17
%645 = load i64, i64* %23
%646 = mul nsw i64 32, %645
%647 = add nsw i64 %646, 6
%648 = getelementptr inbounds double, double* %644, i64 %647
%649 = load double, double* %648
%650 = load double, double* %25
%651 = load double*, double** %17
%652 = load i64, i64* %23
%653 = mul nsw i64 32, %652
%654 = add nsw i64 %653, 7
%655 = getelementptr inbounds double, double* %651, i64 %654
%656 = load double, double* %655
%657 = load double, double* %24
%658 = fmul double %656, %657
%659 = call double @llvm.fmuladd.f64(double %649, double %650, 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 = fneg double %674
%676 = call double @llvm.fmuladd.f64(double %665, double %666, double %675)
store double %676, double* %32
%677 = load double*, double** %18
%678 = load i64, i64* %23
%679 = mul nsw i64 32, %678
%680 = add nsw i64 %679, 6
%681 = getelementptr inbounds double, double* %677, i64 %680
%682 = load double, double* %681
%683 = load double, double* %27
%684 = load double*, double** %18
%685 = load i64, i64* %23
%686 = mul nsw i64 32, %685
%687 = add nsw i64 %686, 7
%688 = getelementptr inbounds double, double* %684, i64 %687
%689 = load double, double* %688
%690 = load double, double* %26
%691 = fmul double %689, %690
%692 = call double @llvm.fmuladd.f64(double %682, double %683, 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 = fneg double %707
%709 = call double @llvm.fmuladd.f64(double %698, double %699, double %708)
store double %709, double* %34
%710 = load double*, double** %19
%711 = load i64, i64* %23
%712 = mul nsw i64 32, %711
%713 = add nsw i64 %712, 6
%714 = getelementptr inbounds double, double* %710, i64 %713
%715 = load double, double* %714
%716 = load double, double* %29
%717 = load double*, double** %19
%718 = load i64, i64* %23
%719 = mul nsw i64 32, %718
%720 = add nsw i64 %719, 7
%721 = getelementptr inbounds double, double* %717, i64 %720
%722 = load double, double* %721
%723 = load double, double* %28
%724 = fmul double %722, %723
%725 = call double @llvm.fmuladd.f64(double %715, double %716, 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 = fsub 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 = fadd 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 = fadd 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 = fsub 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 = fsub 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 = fadd 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 = fadd 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 = fsub 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_b(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 %287
13: ; preds = %11, %13
%14 = phi i64 [ %285, %13 ], [ 0, %11 ]
%15 = shl nsw i64 %14, 3
%16 = getelementptr inbounds double, double* %8, i64 %15
%17 = bitcast double* %16 to <2 x double>*
%18 = load <2 x double>, <2 x double>* %17
%19 = shl nsw i64 %14, 4
%20 = getelementptr inbounds double, double* %8, i64 %19
%21 = bitcast double* %20 to <2 x double>*
%22 = load <2 x double>, <2 x double>* %21
%23 = mul nuw nsw i64 %14, 24
%24 = getelementptr inbounds double, double* %8, i64 %23
%25 = bitcast double* %24 to <2 x double>*
%26 = load <2 x double>, <2 x double>* %25
%27 = shl nsw i64 %14, 5
%28 = getelementptr inbounds double, double* %5, i64 %27
%29 = load double, double* %28
%30 = or i64 %27, 1
%31 = getelementptr inbounds double, double* %5, i64 %30
%32 = load double, double* %31
%33 = fneg double %32
%34 = insertelement <2 x double> poison, double %32, i64 0
%35 = insertelement <2 x double> %34, double %33, i64 1
%36 = fmul <2 x double> %18, %35
%37 = shufflevector <2 x double> %36, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%38 = insertelement <2 x double> poison, double %29, i64 0
%39 = shufflevector <2 x double> %38, <2 x double> poison, <2 x i32> zeroinitializer
%40 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %39, <2 x double> %18, <2 x double> %37)
%41 = getelementptr inbounds double, double* %6, i64 %27
%42 = load double, double* %41
%43 = getelementptr inbounds double, double* %6, i64 %30
%44 = load double, double* %43
%45 = fneg double %44
%46 = insertelement <2 x double> poison, double %44, i64 0
%47 = insertelement <2 x double> %46, double %45, i64 1
%48 = fmul <2 x double> %22, %47
%49 = shufflevector <2 x double> %48, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%50 = insertelement <2 x double> poison, double %42, i64 0
%51 = shufflevector <2 x double> %50, <2 x double> poison, <2 x i32> zeroinitializer
%52 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %51, <2 x double> %22, <2 x double> %49)
%53 = getelementptr inbounds double, double* %7, i64 %27
%54 = load double, double* %53
%55 = getelementptr inbounds double, double* %7, i64 %30
%56 = load double, double* %55
%57 = fneg double %56
%58 = insertelement <2 x double> poison, double %56, i64 0
%59 = insertelement <2 x double> %58, double %57, i64 1
%60 = fmul <2 x double> %26, %59
%61 = shufflevector <2 x double> %60, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%62 = insertelement <2 x double> poison, double %54, i64 0
%63 = shufflevector <2 x double> %62, <2 x double> poison, <2 x i32> zeroinitializer
%64 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %63, <2 x double> %26, <2 x double> %61)
%65 = getelementptr inbounds double, double* %4, i64 %27
%66 = bitcast double* %65 to <2 x double>*
%67 = load <2 x double>, <2 x double>* %66
%68 = fadd <2 x double> %52, %67
%69 = fsub <2 x double> %67, %52
%70 = fadd <2 x double> %40, %64
%71 = fsub <2 x double> %40, %64
%72 = shufflevector <2 x double> %71, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%73 = or i64 %27, 2
%74 = getelementptr inbounds double, double* %5, i64 %73
%75 = load double, double* %74
%76 = or i64 %27, 3
%77 = getelementptr inbounds double, double* %5, i64 %76
%78 = load double, double* %77
%79 = fneg double %78
%80 = insertelement <2 x double> poison, double %78, i64 0
%81 = insertelement <2 x double> %80, double %79, i64 1
%82 = fmul <2 x double> %18, %81
%83 = shufflevector <2 x double> %82, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%84 = insertelement <2 x double> poison, double %75, i64 0
%85 = shufflevector <2 x double> %84, <2 x double> poison, <2 x i32> zeroinitializer
%86 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %85, <2 x double> %18, <2 x double> %83)
%87 = getelementptr inbounds double, double* %6, i64 %73
%88 = load double, double* %87
%89 = getelementptr inbounds double, double* %6, i64 %76
%90 = load double, double* %89
%91 = fneg double %90
%92 = insertelement <2 x double> poison, double %90, i64 0
%93 = insertelement <2 x double> %92, double %91, i64 1
%94 = fmul <2 x double> %22, %93
%95 = shufflevector <2 x double> %94, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%96 = insertelement <2 x double> poison, double %88, i64 0
%97 = shufflevector <2 x double> %96, <2 x double> poison, <2 x i32> zeroinitializer
%98 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %97, <2 x double> %22, <2 x double> %95)
%99 = getelementptr inbounds double, double* %7, i64 %73
%100 = load double, double* %99
%101 = getelementptr inbounds double, double* %7, i64 %76
%102 = load double, double* %101
%103 = fneg double %102
%104 = insertelement <2 x double> poison, double %102, i64 0
%105 = insertelement <2 x double> %104, double %103, i64 1
%106 = fmul <2 x double> %26, %105
%107 = shufflevector <2 x double> %106, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%108 = insertelement <2 x double> poison, double %100, i64 0
%109 = shufflevector <2 x double> %108, <2 x double> poison, <2 x i32> zeroinitializer
%110 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %109, <2 x double> %26, <2 x double> %107)
%111 = getelementptr inbounds double, double* %0, i64 %15
%112 = fadd <2 x double> %68, %70
%113 = bitcast double* %111 to <2 x double>*
store <2 x double> %112, <2 x double>* %113
%114 = getelementptr inbounds double, double* %2, i64 %15
%115 = fsub <2 x double> %68, %70
%116 = bitcast double* %114 to <2 x double>*
store <2 x double> %115, <2 x double>* %116
%117 = getelementptr inbounds double, double* %1, i64 %15
%118 = fsub <2 x double> %69, %72
%119 = fadd <2 x double> %69, %72
%120 = shufflevector <2 x double> %118, <2 x double> %119, <2 x i32> <i32 0, i32 3>
%121 = bitcast double* %117 to <2 x double>*
store <2 x double> %120, <2 x double>* %121
%122 = getelementptr inbounds double, double* %3, i64 %15
%123 = shufflevector <2 x double> %119, <2 x double> %118, <2 x i32> <i32 0, i32 3>
%124 = bitcast double* %122 to <2 x double>*
store <2 x double> %123, <2 x double>* %124
%125 = getelementptr inbounds double, double* %4, i64 %73
%126 = bitcast double* %125 to <2 x double>*
%127 = load <2 x double>, <2 x double>* %126
%128 = fadd <2 x double> %98, %127
%129 = shufflevector <2 x double> %127, <2 x double> %86, <2 x i32> <i32 0, i32 2>
%130 = shufflevector <2 x double> %98, <2 x double> %110, <2 x i32> <i32 0, i32 2>
%131 = fsub <2 x double> %129, %130
%132 = fadd <2 x double> %86, %110
%133 = shufflevector <2 x double> %86, <2 x double> %127, <2 x i32> <i32 1, i32 3>
%134 = shufflevector <2 x double> %110, <2 x double> %98, <2 x i32> <i32 1, i32 3>
%135 = fsub <2 x double> %133, %134
%136 = or i64 %27, 4
%137 = getelementptr inbounds double, double* %5, i64 %136
%138 = load double, double* %137
%139 = or i64 %27, 5
%140 = getelementptr inbounds double, double* %5, i64 %139
%141 = load double, double* %140
%142 = fneg double %141
%143 = insertelement <2 x double> poison, double %141, i64 0
%144 = insertelement <2 x double> %143, double %142, i64 1
%145 = fmul <2 x double> %18, %144
%146 = shufflevector <2 x double> %145, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%147 = insertelement <2 x double> poison, double %138, i64 0
%148 = shufflevector <2 x double> %147, <2 x double> poison, <2 x i32> zeroinitializer
%149 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %148, <2 x double> %18, <2 x double> %146)
%150 = getelementptr inbounds double, double* %6, i64 %136
%151 = load double, double* %150
%152 = getelementptr inbounds double, double* %6, i64 %139
%153 = load double, double* %152
%154 = fneg double %153
%155 = insertelement <2 x double> poison, double %153, i64 0
%156 = insertelement <2 x double> %155, double %154, i64 1
%157 = fmul <2 x double> %22, %156
%158 = shufflevector <2 x double> %157, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%159 = insertelement <2 x double> poison, double %151, i64 0
%160 = shufflevector <2 x double> %159, <2 x double> poison, <2 x i32> zeroinitializer
%161 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %160, <2 x double> %22, <2 x double> %158)
%162 = getelementptr inbounds double, double* %7, i64 %136
%163 = load double, double* %162
%164 = getelementptr inbounds double, double* %7, i64 %139
%165 = load double, double* %164
%166 = fneg double %165
%167 = insertelement <2 x double> poison, double %165, i64 0
%168 = insertelement <2 x double> %167, double %166, i64 1
%169 = fmul <2 x double> %26, %168
%170 = shufflevector <2 x double> %169, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%171 = insertelement <2 x double> poison, double %163, i64 0
%172 = shufflevector <2 x double> %171, <2 x double> poison, <2 x i32> zeroinitializer
%173 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %172, <2 x double> %26, <2 x double> %170)
%174 = or i64 %15, 2
%175 = getelementptr inbounds double, double* %0, i64 %174
%176 = fadd <2 x double> %132, %128
%177 = bitcast double* %175 to <2 x double>*
store <2 x double> %176, <2 x double>* %177
%178 = getelementptr inbounds double, double* %2, i64 %174
%179 = fsub <2 x double> %128, %132
%180 = bitcast double* %178 to <2 x double>*
store <2 x double> %179, <2 x double>* %180
%181 = getelementptr inbounds double, double* %1, i64 %174
%182 = fsub <2 x double> %131, %135
%183 = fadd <2 x double> %131, %135
%184 = shufflevector <2 x double> %182, <2 x double> %183, <2 x i32> <i32 0, i32 3>
%185 = bitcast double* %181 to <2 x double>*
store <2 x double> %184, <2 x double>* %185
%186 = getelementptr inbounds double, double* %3, i64 %174
%187 = fadd <2 x double> %135, %131
%188 = fsub <2 x double> %135, %131
%189 = shufflevector <2 x double> %187, <2 x double> %188, <2 x i32> <i32 0, i32 3>
%190 = bitcast double* %186 to <2 x double>*
store <2 x double> %189, <2 x double>* %190
%191 = getelementptr inbounds double, double* %4, i64 %136
%192 = bitcast double* %191 to <2 x double>*
%193 = load <2 x double>, <2 x double>* %192
%194 = fadd <2 x double> %161, %193
%195 = shufflevector <2 x double> %193, <2 x double> %149, <2 x i32> <i32 0, i32 2>
%196 = shufflevector <2 x double> %161, <2 x double> %173, <2 x i32> <i32 0, i32 2>
%197 = fsub <2 x double> %195, %196
%198 = fadd <2 x double> %149, %173
%199 = shufflevector <2 x double> %149, <2 x double> %193, <2 x i32> <i32 1, i32 3>
%200 = shufflevector <2 x double> %173, <2 x double> %161, <2 x i32> <i32 1, i32 3>
%201 = fsub <2 x double> %199, %200
%202 = or i64 %27, 6
%203 = getelementptr inbounds double, double* %5, i64 %202
%204 = load double, double* %203
%205 = or i64 %27, 7
%206 = getelementptr inbounds double, double* %5, i64 %205
%207 = load double, double* %206
%208 = fneg double %207
%209 = insertelement <2 x double> poison, double %207, i64 0
%210 = insertelement <2 x double> %209, double %208, i64 1
%211 = fmul <2 x double> %18, %210
%212 = shufflevector <2 x double> %211, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%213 = insertelement <2 x double> poison, double %204, i64 0
%214 = shufflevector <2 x double> %213, <2 x double> poison, <2 x i32> zeroinitializer
%215 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %214, <2 x double> %18, <2 x double> %212)
%216 = getelementptr inbounds double, double* %6, i64 %202
%217 = load double, double* %216
%218 = getelementptr inbounds double, double* %6, i64 %205
%219 = load double, double* %218
%220 = fneg double %219
%221 = insertelement <2 x double> poison, double %219, i64 0
%222 = insertelement <2 x double> %221, double %220, i64 1
%223 = fmul <2 x double> %22, %222
%224 = shufflevector <2 x double> %223, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%225 = insertelement <2 x double> poison, double %217, i64 0
%226 = shufflevector <2 x double> %225, <2 x double> poison, <2 x i32> zeroinitializer
%227 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %226, <2 x double> %22, <2 x double> %224)
%228 = getelementptr inbounds double, double* %7, i64 %202
%229 = load double, double* %228
%230 = getelementptr inbounds double, double* %7, i64 %205
%231 = load double, double* %230
%232 = fneg double %231
%233 = insertelement <2 x double> poison, double %231, i64 0
%234 = insertelement <2 x double> %233, double %232, i64 1
%235 = fmul <2 x double> %26, %234
%236 = shufflevector <2 x double> %235, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%237 = insertelement <2 x double> poison, double %229, i64 0
%238 = shufflevector <2 x double> %237, <2 x double> poison, <2 x i32> zeroinitializer
%239 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %238, <2 x double> %26, <2 x double> %236)
%240 = or i64 %15, 4
%241 = getelementptr inbounds double, double* %0, i64 %240
%242 = fadd <2 x double> %198, %194
%243 = bitcast double* %241 to <2 x double>*
store <2 x double> %242, <2 x double>* %243
%244 = getelementptr inbounds double, double* %2, i64 %240
%245 = fsub <2 x double> %194, %198
%246 = bitcast double* %244 to <2 x double>*
store <2 x double> %245, <2 x double>* %246
%247 = getelementptr inbounds double, double* %1, i64 %240
%248 = fsub <2 x double> %197, %201
%249 = fadd <2 x double> %197, %201
%250 = shufflevector <2 x double> %248, <2 x double> %249, <2 x i32> <i32 0, i32 3>
%251 = bitcast double* %247 to <2 x double>*
store <2 x double> %250, <2 x double>* %251
%252 = getelementptr inbounds double, double* %3, i64 %240
%253 = fadd <2 x double> %201, %197
%254 = fsub <2 x double> %201, %197
%255 = shufflevector <2 x double> %253, <2 x double> %254, <2 x i32> <i32 0, i32 3>
%256 = bitcast double* %252 to <2 x double>*
store <2 x double> %255, <2 x double>* %256
%257 = getelementptr inbounds double, double* %4, i64 %202
%258 = bitcast double* %257 to <2 x double>*
%259 = load <2 x double>, <2 x double>* %258
%260 = fadd <2 x double> %227, %259
%261 = shufflevector <2 x double> %259, <2 x double> %215, <2 x i32> <i32 0, i32 2>
%262 = shufflevector <2 x double> %227, <2 x double> %239, <2 x i32> <i32 0, i32 2>
%263 = fsub <2 x double> %261, %262
%264 = fadd <2 x double> %215, %239
%265 = shufflevector <2 x double> %215, <2 x double> %259, <2 x i32> <i32 1, i32 3>
%266 = shufflevector <2 x double> %239, <2 x double> %227, <2 x i32> <i32 1, i32 3>
%267 = fsub <2 x double> %265, %266
%268 = or i64 %15, 6
%269 = getelementptr inbounds double, double* %0, i64 %268
%270 = fadd <2 x double> %264, %260
%271 = bitcast double* %269 to <2 x double>*
store <2 x double> %270, <2 x double>* %271
%272 = getelementptr inbounds double, double* %2, i64 %268
%273 = fsub <2 x double> %260, %264
%274 = bitcast double* %272 to <2 x double>*
store <2 x double> %273, <2 x double>* %274
%275 = getelementptr inbounds double, double* %1, i64 %268
%276 = fsub <2 x double> %263, %267
%277 = fadd <2 x double> %263, %267
%278 = shufflevector <2 x double> %276, <2 x double> %277, <2 x i32> <i32 0, i32 3>
%279 = bitcast double* %275 to <2 x double>*
store <2 x double> %278, <2 x double>* %279
%280 = getelementptr inbounds double, double* %3, i64 %268
%281 = fadd <2 x double> %267, %263
%282 = fsub <2 x double> %267, %263
%283 = shufflevector <2 x double> %281, <2 x double> %282, <2 x i32> <i32 0, i32 3>
%284 = bitcast double* %280 to <2 x double>*
store <2 x double> %283, <2 x double>* %284
%285 = add nuw nsw i64 %14, 1
%286 = icmp eq i64 %285, %10
br i1 %286, label %287, label %13
287: ; preds = %13, %11
ret void
}