void kern_r4_u1_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[2 * i];
    wi1 = w[2 * i + 1];
    wr2 = wr1 * wr1 - wi1 * wi1;
    wi2 = wr1 * wi1 * 2;
    wr3 = wr1 * wr2 - wi1 * wi2;
    wi3 = wr1 * wi2 + wi1 * wr2;
    pr1 = i1[8 * i] * wr1 - i1[8 * i + 1] * wi1;
    pi1 = i1[8 * i] * wi1 + i1[8 * i + 1] * wr1;
    pr2 = i2[8 * i] * wr2 - i2[8 * i + 1] * wi2;
    pi2 = i2[8 * i] * wi2 + i2[8 * i + 1] * wr2;
    pr3 = i3[8 * i] * wr3 - i3[8 * i + 1] * wi3;
    pi3 = i3[8 * i] * wi3 + i3[8 * i + 1] * wr3;
    qr0 = i0[8 * i] + pr2;
    qr2 = i0[8 * i] - pr2;
    qi0 = i0[8 * i + 1] + pi2;
    qi2 = i0[8 * i + 1] - pi2;
    qr1 = pr1 + pr3;
    qr3 = pr1 - pr3;
    qi1 = pi1 + pi3;
    qi3 = pi1 - pi3;
    o0[2 * i] = qr0 + qr1;
    o0[2 * i + 1] = qi0 + qi1;
    o2[2 * i] = qr0 - qr1;
    o2[2 * i + 1] = qi0 - qi1;
    o1[2 * i] = qr2 - qi3;
    o1[2 * i + 1] = qi2 + qr3;
    o3[2 * i] = qr2 + qi3;
    o3[2 * i + 1] = qi2 - qr3;
  }
}


x86 assembly (clang, -O0):
<kern_r4_u1_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    15be <kern_r4_u1_b+0x4be>
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  0xe3f(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%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,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%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    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%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    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%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    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%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    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%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    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%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    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x3,%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    $0x3,%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
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
shl    $0x1,%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    $0x1,%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    $0x1,%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    $0x1,%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    $0x1,%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    $0x1,%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    $0x1,%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    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    113c <kern_r4_u1_b+0x3c>
add    $0x58,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kern_r4_u1_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x58(%rsp),%r11
test   %r11,%r11
jle    157f <kern_r4_u1_b+0x47f>
mov    %rdx,%r10
mov    0x48(%rsp),%r13
mov    0x40(%rsp),%r14
mov    0x38(%rsp),%r15
cmp    $0x3,%r11
jae    1138 <kern_r4_u1_b+0x38>
xor    %r12d,%r12d
jmp    13e9 <kern_r4_u1_b+0x2e9>
lea    -0x1(%r11),%rax
lea    0x8(%rdi),%rbx
mov    $0x10,%edx
mul    %rdx
seto   %dl
lea    (%rdi,%rax,1),%rbp
add    $0x8,%rbp
xor    %r12d,%r12d
cmp    %rbx,%rbp
jb     13e9 <kern_r4_u1_b+0x2e9>
test   %dl,%dl
jne    13e9 <kern_r4_u1_b+0x2e9>
lea    0x8(%r10),%rbx
lea    (%r10,%rax,1),%rbp
add    $0x8,%rbp
cmp    %rbx,%rbp
jb     13e9 <kern_r4_u1_b+0x2e9>
test   %dl,%dl
jne    13e9 <kern_r4_u1_b+0x2e9>
lea    0x8(%rsi),%rbx
lea    (%rsi,%rax,1),%rbp
add    $0x8,%rbp
cmp    %rbx,%rbp
jb     13e9 <kern_r4_u1_b+0x2e9>
test   %dl,%dl
jne    13e9 <kern_r4_u1_b+0x2e9>
lea    0x8(%rcx),%rbx
add    %rcx,%rax
add    $0x8,%rax
cmp    %rbx,%rax
jb     13e9 <kern_r4_u1_b+0x2e9>
test   %dl,%dl
jne    13e9 <kern_r4_u1_b+0x2e9>
mov    %r11d,%eax
and    $0x1,%eax
test   %rax,%rax
mov    $0x2,%edx
cmovne %rax,%rdx
mov    %r11,%r12
sub    %rdx,%r12
xor    %eax,%eax
mov    %r12,%rdx
nopw   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rax,1),%xmm6
movupd 0x10(%r13,%rax,1),%xmm0
movapd %xmm6,%xmm11
unpcklpd %xmm0,%xmm11
unpckhpd %xmm0,%xmm6
movapd %xmm11,%xmm0
mulpd  %xmm6,%xmm0
addpd  %xmm0,%xmm0
movapd %xmm11,%xmm9
mulpd  %xmm0,%xmm9
movupd (%r15,%rax,4),%xmm7
movupd 0x40(%r15,%rax,4),%xmm8
movapd %xmm7,%xmm5
unpcklpd %xmm8,%xmm5
movapd %xmm0,%xmm10
movapd %xmm5,%xmm14
mulpd  %xmm0,%xmm5
movapd %xmm0,%xmm4
mulpd  %xmm6,%xmm4
movapd %xmm6,%xmm15
movupd (%r9,%rax,4),%xmm0
movupd 0x40(%r9,%rax,4),%xmm13
movapd %xmm0,%xmm1
unpcklpd %xmm13,%xmm1
movapd %xmm6,%xmm2
movapd %xmm1,%xmm12
mulpd  %xmm6,%xmm1
mulpd  %xmm6,%xmm6
unpckhpd %xmm13,%xmm0
movapd %xmm11,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm11,%xmm12
mulpd  %xmm11,%xmm0
mulpd  %xmm11,%xmm11
subpd  %xmm6,%xmm11
mulpd  %xmm11,%xmm3
subpd  %xmm4,%xmm3
mulpd  %xmm11,%xmm15
addpd  %xmm15,%xmm9
subpd  %xmm2,%xmm12
addpd  %xmm0,%xmm1
unpckhpd %xmm8,%xmm7
mulpd  %xmm7,%xmm10
mulpd  %xmm11,%xmm14
subpd  %xmm10,%xmm14
mulpd  %xmm11,%xmm7
addpd  %xmm7,%xmm5
movupd (%r14,%rax,4),%xmm0
movupd 0x40(%r14,%rax,4),%xmm2
movapd %xmm0,%xmm4
unpcklpd %xmm2,%xmm4
unpckhpd %xmm2,%xmm0
movapd %xmm4,%xmm6
mulpd  %xmm9,%xmm4
mulpd  %xmm0,%xmm9
mulpd  %xmm3,%xmm6
subpd  %xmm9,%xmm6
mulpd  %xmm3,%xmm0
addpd  %xmm0,%xmm4
movupd (%r8,%rax,4),%xmm2
movupd 0x40(%r8,%rax,4),%xmm0
movapd %xmm2,%xmm8
unpcklpd %xmm0,%xmm8
unpckhpd %xmm0,%xmm2
movapd %xmm14,%xmm0
addpd  %xmm8,%xmm0
subpd  %xmm14,%xmm8
movapd %xmm5,%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm5,%xmm2
movapd %xmm12,%xmm9
addpd  %xmm6,%xmm9
subpd  %xmm6,%xmm12
movapd %xmm1,%xmm6
addpd  %xmm4,%xmm6
subpd  %xmm4,%xmm1
movapd %xmm0,%xmm4
addpd  %xmm9,%xmm4
movapd %xmm3,%xmm7
addpd  %xmm6,%xmm7
movapd %xmm4,%xmm5
unpcklpd %xmm7,%xmm5
movhlps %xmm4,%xmm7
movups %xmm7,0x10(%rdi,%rax,1)
movupd %xmm5,(%rdi,%rax,1)
subpd  %xmm9,%xmm0
subpd  %xmm6,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm3,%xmm4
movhlps %xmm0,%xmm3
movups %xmm3,0x10(%r10,%rax,1)
movupd %xmm4,(%r10,%rax,1)
movapd %xmm8,%xmm0
subpd  %xmm1,%xmm0
movapd %xmm2,%xmm3
addpd  %xmm12,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm3,%xmm4
movhlps %xmm0,%xmm3
movups %xmm3,0x10(%rsi,%rax,1)
movupd %xmm4,(%rsi,%rax,1)
addpd  %xmm8,%xmm1
subpd  %xmm12,%xmm2
movapd %xmm1,%xmm0
unpcklpd %xmm2,%xmm0
movhlps %xmm1,%xmm2
movups %xmm2,0x10(%rcx,%rax,1)
movupd %xmm0,(%rcx,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rdx
jne    11e0 <kern_r4_u1_b+0xe0>
sub    %r12,%r11
mov    %r12,%rax
shl    $0x4,%rax
add    %rax,%r13
add    %rax,%rdi
add    %rax,%r10
add    %rax,%rsi
add    %rax,%rcx
shl    $0x6,%r12
add    %r12,%r9
add    $0x8,%r9
lea    (%r15,%r12,1),%rdx
add    $0x8,%rdx
lea    (%r14,%r12,1),%rbx
add    $0x8,%rbx
add    %r12,%r8
xor    %eax,%eax
movapd 0xbd5(%rip),%xmm8
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rax,1),%xmm5
movapd %xmm5,%xmm2
movapd %xmm5,%xmm4
movapd %xmm5,%xmm6
movapd %xmm5,%xmm3
movsd  -0x8(%r9,%rax,4),%xmm1
movapd %xmm5,%xmm7
unpcklpd %xmm1,%xmm1
mulpd  %xmm5,%xmm1
unpckhpd %xmm5,%xmm5
movapd %xmm5,%xmm0
xorpd  %xmm8,%xmm0
mulsd  %xmm5,%xmm2
mulsd  %xmm5,%xmm5
mulsd  %xmm4,%xmm4
subsd  %xmm5,%xmm4
addsd  %xmm2,%xmm2
movsd  %xmm2,%xmm6
unpcklpd %xmm4,%xmm0
mulpd  %xmm6,%xmm0
unpcklpd %xmm3,%xmm3
movapd %xmm4,%xmm5
unpcklpd %xmm2,%xmm5
mulpd  %xmm5,%xmm3
addpd  %xmm0,%xmm3
movsd  (%r9,%rax,4),%xmm0
movapd %xmm0,%xmm6
xorpd  %xmm8,%xmm6
unpcklpd %xmm0,%xmm6
shufpd $0x1,%xmm7,%xmm7
mulpd  %xmm6,%xmm7
addpd  %xmm7,%xmm1
movsd  -0x8(%rdx,%rax,4),%xmm0
movsd  (%rdx,%rax,4),%xmm6
movapd %xmm6,%xmm7
xorpd  %xmm8,%xmm7
unpcklpd %xmm4,%xmm2
unpcklpd %xmm6,%xmm7
mulpd  %xmm2,%xmm7
unpcklpd %xmm0,%xmm0
mulpd  %xmm5,%xmm0
addpd  %xmm7,%xmm0
movsd  -0x8(%rbx,%rax,4),%xmm2
movsd  (%rbx,%rax,4),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm8,%xmm5
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
shufpd $0x1,%xmm3,%xmm3
unpcklpd %xmm4,%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm5,%xmm2
movupd (%r8,%rax,4),%xmm3
movapd %xmm0,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm0,%xmm3
movapd %xmm1,%xmm0
addpd  %xmm2,%xmm0
subpd  %xmm2,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm4,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,(%rdi,%rax,1)
subpd  %xmm0,%xmm4
movupd %xmm4,(%r10,%rax,1)
movapd %xmm3,%xmm0
subpd  %xmm1,%xmm0
addpd  %xmm3,%xmm1
movapd %xmm1,%xmm2
movsd  %xmm0,%xmm2
movupd %xmm2,(%rsi,%rax,1)
shufpd $0x2,%xmm0,%xmm1
movupd %xmm1,(%rcx,%rax,1)
add    $0x10,%rax
add    $0xffffffffffffffff,%r11
jne    1430 <kern_r4_u1_b+0x330>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @kern_r4_u1_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 %231
13: ; preds = %11
%14 = icmp ult i64 %10, 3
br i1 %14, label %145, label %15
15: ; preds = %13
%16 = add i64 %10, -1
%17 = getelementptr double, double* %0, i64 1
%18 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %16, i64 16)
%19 = extractvalue { i64, i1 } %18, 0
%20 = extractvalue { i64, i1 } %18, 1
%21 = bitcast double* %17 to i8*
%22 = getelementptr i8, i8* %21, i64 %19
%23 = icmp ult i8* %22, %21
%24 = or i1 %23, %20
%25 = getelementptr double, double* %2, i64 1
%26 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %16, i64 16)
%27 = extractvalue { i64, i1 } %26, 0
%28 = extractvalue { i64, i1 } %26, 1
%29 = bitcast double* %25 to i8*
%30 = getelementptr i8, i8* %29, i64 %27
%31 = icmp ult i8* %30, %29
%32 = or i1 %31, %28
%33 = getelementptr double, double* %1, i64 1
%34 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %16, i64 16)
%35 = extractvalue { i64, i1 } %34, 0
%36 = extractvalue { i64, i1 } %34, 1
%37 = bitcast double* %33 to i8*
%38 = getelementptr i8, i8* %37, i64 %35
%39 = icmp ult i8* %38, %37
%40 = or i1 %39, %36
%41 = getelementptr double, double* %3, i64 1
%42 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %16, i64 16)
%43 = extractvalue { i64, i1 } %42, 0
%44 = extractvalue { i64, i1 } %42, 1
%45 = bitcast double* %41 to i8*
%46 = getelementptr i8, i8* %45, i64 %43
%47 = icmp ult i8* %46, %45
%48 = or i1 %47, %44
%49 = or i1 %24, %32
%50 = or i1 %49, %40
%51 = or i1 %50, %48
br i1 %51, label %145, label %52
52: ; preds = %15
%53 = and i64 %10, 1
%54 = icmp eq i64 %53, 0
%55 = select i1 %54, i64 2, i64 %53
%56 = sub i64 %10, %55
%57 = getelementptr inbounds double, double* %0, i64 -1
%58 = getelementptr inbounds double, double* %2, i64 -1
%59 = getelementptr inbounds double, double* %1, i64 -1
%60 = getelementptr inbounds double, double* %3, i64 -1
br label %61
61: ; preds = %61, %52
%62 = phi i64 [ 0, %52 ], [ %143, %61 ]
%63 = shl nuw nsw i64 %62, 1
%64 = getelementptr inbounds double, double* %8, i64 %63
%65 = bitcast double* %64 to <4 x double>*
%66 = load <4 x double>, <4 x double>* %65
%67 = shufflevector <4 x double> %66, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%68 = shufflevector <4 x double> %66, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%69 = or i64 %63, 1
%70 = fneg <2 x double> %68
%71 = fmul <2 x double> %68, %70
%72 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %67, <2 x double> %67, <2 x double> %71)
%73 = fmul <2 x double> %67, %68
%74 = fmul <2 x double> %73, <double 2.000000e+00, double 2.000000e+00>
%75 = fmul <2 x double> %74, %70
%76 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %67, <2 x double> %72, <2 x double> %75)
%77 = fmul <2 x double> %68, %72
%78 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %67, <2 x double> %74, <2 x double> %77)
%79 = shl nsw i64 %62, 3
%80 = getelementptr inbounds double, double* %5, i64 %79
%81 = bitcast double* %80 to <16 x double>*
%82 = load <16 x double>, <16 x double>* %81
%83 = shufflevector <16 x double> %82, <16 x double> poison, <2 x i32> <i32 0, i32 8>
%84 = shufflevector <16 x double> %82, <16 x double> poison, <2 x i32> <i32 1, i32 9>
%85 = fneg <2 x double> %84
%86 = fmul <2 x double> %68, %85
%87 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %83, <2 x double> %67, <2 x double> %86)
%88 = fmul <2 x double> %67, %84
%89 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %83, <2 x double> %68, <2 x double> %88)
%90 = getelementptr inbounds double, double* %6, i64 %79
%91 = bitcast double* %90 to <16 x double>*
%92 = load <16 x double>, <16 x double>* %91
%93 = shufflevector <16 x double> %92, <16 x double> poison, <2 x i32> <i32 0, i32 8>
%94 = shufflevector <16 x double> %92, <16 x double> poison, <2 x i32> <i32 1, i32 9>
%95 = fneg <2 x double> %94
%96 = fmul <2 x double> %74, %95
%97 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %93, <2 x double> %72, <2 x double> %96)
%98 = fmul <2 x double> %72, %94
%99 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %93, <2 x double> %74, <2 x double> %98)
%100 = getelementptr inbounds double, double* %7, i64 %79
%101 = bitcast double* %100 to <16 x double>*
%102 = load <16 x double>, <16 x double>* %101
%103 = shufflevector <16 x double> %102, <16 x double> poison, <2 x i32> <i32 0, i32 8>
%104 = shufflevector <16 x double> %102, <16 x double> poison, <2 x i32> <i32 1, i32 9>
%105 = fneg <2 x double> %104
%106 = fmul <2 x double> %78, %105
%107 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %103, <2 x double> %76, <2 x double> %106)
%108 = fmul <2 x double> %76, %104
%109 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %103, <2 x double> %78, <2 x double> %108)
%110 = getelementptr inbounds double, double* %4, i64 %79
%111 = bitcast double* %110 to <16 x double>*
%112 = load <16 x double>, <16 x double>* %111
%113 = shufflevector <16 x double> %112, <16 x double> poison, <2 x i32> <i32 0, i32 8>
%114 = shufflevector <16 x double> %112, <16 x double> poison, <2 x i32> <i32 1, i32 9>
%115 = fadd <2 x double> %97, %113
%116 = fsub <2 x double> %113, %97
%117 = fadd <2 x double> %99, %114
%118 = fsub <2 x double> %114, %99
%119 = fadd <2 x double> %87, %107
%120 = fsub <2 x double> %87, %107
%121 = fadd <2 x double> %89, %109
%122 = fsub <2 x double> %89, %109
%123 = fadd <2 x double> %115, %119
%124 = fadd <2 x double> %117, %121
%125 = getelementptr inbounds double, double* %57, i64 %69
%126 = bitcast double* %125 to <4 x double>*
%127 = shufflevector <2 x double> %123, <2 x double> %124, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %127, <4 x double>* %126
%128 = fsub <2 x double> %115, %119
%129 = fsub <2 x double> %117, %121
%130 = getelementptr inbounds double, double* %58, i64 %69
%131 = bitcast double* %130 to <4 x double>*
%132 = shufflevector <2 x double> %128, <2 x double> %129, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %132, <4 x double>* %131
%133 = fsub <2 x double> %116, %122
%134 = fadd <2 x double> %118, %120
%135 = getelementptr inbounds double, double* %59, i64 %69
%136 = bitcast double* %135 to <4 x double>*
%137 = shufflevector <2 x double> %133, <2 x double> %134, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %137, <4 x double>* %136
%138 = fadd <2 x double> %116, %122
%139 = fsub <2 x double> %118, %120
%140 = getelementptr inbounds double, double* %60, i64 %69
%141 = bitcast double* %140 to <4 x double>*
%142 = shufflevector <2 x double> %138, <2 x double> %139, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %142, <4 x double>* %141
%143 = add nuw i64 %62, 2
%144 = icmp eq i64 %143, %56
br i1 %144, label %145, label %61
145: ; preds = %61, %15, %13
%146 = phi i64 [ 0, %15 ], [ 0, %13 ], [ %56, %61 ]
br label %147
147: ; preds = %145, %147
%148 = phi i64 [ %229, %147 ], [ %146, %145 ]
%149 = shl nuw nsw i64 %148, 1
%150 = getelementptr inbounds double, double* %8, i64 %149
%151 = bitcast double* %150 to <2 x double>*
%152 = load <2 x double>, <2 x double>* %151
%153 = extractelement <2 x double> %152, i64 1
%154 = fneg double %153
%155 = fmul double %153, %154
%156 = extractelement <2 x double> %152, i64 0
%157 = tail call double @llvm.fmuladd.f64(double %156, double %156, double %155)
%158 = fmul double %156, %153
%159 = fmul double %158, 2.000000e+00
%160 = insertelement <2 x double> poison, double %159, i64 0
%161 = insertelement <2 x double> %152, double %159, i64 0
%162 = insertelement <2 x double> poison, double %154, i64 0
%163 = insertelement <2 x double> %162, double %157, i64 1
%164 = fmul <2 x double> %161, %163
%165 = shufflevector <2 x double> %152, <2 x double> undef, <2 x i32> zeroinitializer
%166 = insertelement <2 x double> poison, double %157, i64 0
%167 = insertelement <2 x double> %166, double %159, i64 1
%168 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %165, <2 x double> %167, <2 x double> %164)
%169 = shl nsw i64 %148, 3
%170 = getelementptr inbounds double, double* %5, i64 %169
%171 = load double, double* %170
%172 = or i64 %169, 1
%173 = getelementptr inbounds double, double* %5, i64 %172
%174 = load double, double* %173
%175 = fneg double %174
%176 = insertelement <2 x double> poison, double %174, i64 0
%177 = insertelement <2 x double> %176, double %175, i64 1
%178 = fmul <2 x double> %152, %177
%179 = shufflevector <2 x double> %178, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%180 = insertelement <2 x double> poison, double %171, i64 0
%181 = shufflevector <2 x double> %180, <2 x double> poison, <2 x i32> zeroinitializer
%182 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %181, <2 x double> %152, <2 x double> %179)
%183 = getelementptr inbounds double, double* %6, i64 %169
%184 = load double, double* %183
%185 = getelementptr inbounds double, double* %6, i64 %172
%186 = load double, double* %185
%187 = fneg double %186
%188 = insertelement <2 x double> %160, double %157, i64 1
%189 = insertelement <2 x double> poison, double %187, i64 0
%190 = insertelement <2 x double> %189, double %186, i64 1
%191 = fmul <2 x double> %188, %190
%192 = insertelement <2 x double> poison, double %184, i64 0
%193 = shufflevector <2 x double> %192, <2 x double> poison, <2 x i32> zeroinitializer
%194 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %193, <2 x double> %167, <2 x double> %191)
%195 = getelementptr inbounds double, double* %7, i64 %169
%196 = load double, double* %195
%197 = getelementptr inbounds double, double* %7, i64 %172
%198 = load double, double* %197
%199 = fneg double %198
%200 = shufflevector <2 x double> %168, <2 x double> undef, <2 x i32> <i32 1, i32 0>
%201 = insertelement <2 x double> poison, double %199, i64 0
%202 = insertelement <2 x double> %201, double %198, i64 1
%203 = fmul <2 x double> %200, %202
%204 = insertelement <2 x double> poison, double %196, i64 0
%205 = shufflevector <2 x double> %204, <2 x double> poison, <2 x i32> zeroinitializer
%206 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %205, <2 x double> %168, <2 x double> %203)
%207 = getelementptr inbounds double, double* %4, i64 %169
%208 = bitcast double* %207 to <2 x double>*
%209 = load <2 x double>, <2 x double>* %208
%210 = fadd <2 x double> %194, %209
%211 = fsub <2 x double> %209, %194
%212 = fadd <2 x double> %182, %206
%213 = fsub <2 x double> %182, %206
%214 = shufflevector <2 x double> %213, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%215 = getelementptr inbounds double, double* %0, i64 %149
%216 = fadd <2 x double> %210, %212
%217 = bitcast double* %215 to <2 x double>*
store <2 x double> %216, <2 x double>* %217
%218 = getelementptr inbounds double, double* %2, i64 %149
%219 = fsub <2 x double> %210, %212
%220 = bitcast double* %218 to <2 x double>*
store <2 x double> %219, <2 x double>* %220
%221 = getelementptr inbounds double, double* %1, i64 %149
%222 = fsub <2 x double> %211, %214
%223 = fadd <2 x double> %211, %214
%224 = shufflevector <2 x double> %222, <2 x double> %223, <2 x i32> <i32 0, i32 3>
%225 = bitcast double* %221 to <2 x double>*
store <2 x double> %224, <2 x double>* %225
%226 = getelementptr inbounds double, double* %3, i64 %149
%227 = shufflevector <2 x double> %223, <2 x double> %222, <2 x i32> <i32 0, i32 3>
%228 = bitcast double* %226 to <2 x double>*
store <2 x double> %227, <2 x double>* %228
%229 = add nuw nsw i64 %148, 1
%230 = icmp eq i64 %229, %10
br i1 %230, label %231, label %147
231: ; preds = %147, %11
ret void
}