void atax_opt(int n, double A[][n], double x[n], double y[n]) {
  int i, j;
  double temp[n];
  for (i = 0; i < n; i++)
    temp[i] = 0;
  for (j = 0; j < n; j = j + 1) {
    for (i = 0; i < n; i = i + 8) {
      temp[j] += A[j][i] * x[i];
      temp[j] += A[j][i + 1] * x[i + 1];
      temp[j] += A[j][i + 2] * x[i + 2];
      temp[j] += A[j][i + 3] * x[i + 3];
      temp[j] += A[j][i + 4] * x[i + 4];
      temp[j] += A[j][i + 5] * x[i + 5];
      temp[j] += A[j][i + 6] * x[i + 6];
      temp[j] += A[j][i + 7] * x[i + 7];
    }
    for (i = 0; i < n; i = i + 8) {
      y[i] += A[j][i] * temp[j];
      y[i + 1] += A[j][i + 1] * temp[j];
      y[i + 2] += A[j][i + 2] * temp[j];
      y[i + 3] += A[j][i + 3] * temp[j];
      y[i + 4] += A[j][i + 4] * temp[j];
      y[i + 5] += A[j][i + 5] * temp[j];
      y[i + 6] += A[j][i + 6] * temp[j];
      y[i + 7] += A[j][i + 7] * temp[j];
    }
  }
}


x86 assembly (clang, -O0):
<atax_opt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rax
mov    %rsp,%rdx
mov    %rdx,-0x30(%rbp)
lea    0xf(,%rcx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1178 <atax_opt+0x78>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    114e <atax_opt+0x4e>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    166c <atax_opt+0x56c>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13f2 <atax_opt+0x2f2>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rsi
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x24(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm2
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm2
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm2
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x4,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x4,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm2
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x5,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x5,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm2
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x6,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x6,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm2
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x7,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x7,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm2
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x24(%rbp)
jmp    1192 <atax_opt+0x92>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1659 <atax_opt+0x559>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rsi
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x24(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x4,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x4,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x5,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x5,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x6,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x6,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
add    $0x7,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x24(%rbp)
jmp    13f9 <atax_opt+0x2f9>
jmp    165e <atax_opt+0x55e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    117f <atax_opt+0x7f>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<atax_opt>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edi,%r13d
mov    %rsp,%r12
lea    0xf(,%r13,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r12
mov    %r12,%rsp
test   %edi,%edi
jle    1567 <atax_opt+0x457>
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rsi,%rcx
lea    0x0(,%r13,8),%rdx
xor    %r15d,%r15d
mov    %r12,%rdi
xor    %esi,%esi
mov    %rcx,-0x30(%rbp)
call   1030 <memset@plt>
mov    -0x30(%rbp),%r9
lea    0x7(%r13),%r11
and    $0xfffffffffffffff8,%r11
lea    (%rbx,%r11,8),%rax
mov    %rax,-0x50(%rbp)
lea    -0x1(%r13),%rax
mov    %rax,-0x58(%rbp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x38(%rbp)
lea    0x0(,%rax,8),%rax
mov    %rax,-0x40(%rbp)
lea    0x38(%r9),%rcx
lea    0x0(,%r13,8),%r10
lea    0x78(%r9),%rdi
lea    0x20(%r9),%r8
jmp    11d6 <atax_opt+0xc6>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
add    %r10,%rcx
add    %r10,%rdi
add    %r10,%r8
cmp    %r13,%r15
je     1567 <atax_opt+0x457>
mov    %r15,%rax
imul   %r13,%rax
lea    (%r9,%rax,8),%rdx
add    %r11,%rax
lea    (%r9,%rax,8),%rax
movsd  (%r12,%r15,8),%xmm0
xor    %esi,%esi
movsd  -0x38(%rcx,%rsi,8),%xmm1
movsd  -0x30(%rcx,%rsi,8),%xmm2
mulsd  (%r14,%rsi,8),%xmm1
mulsd  0x8(%r14,%rsi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x28(%rcx,%rsi,8),%xmm0
mulsd  0x10(%r14,%rsi,8),%xmm0
addsd  %xmm1,%xmm2
movsd  -0x20(%rcx,%rsi,8),%xmm1
mulsd  0x18(%r14,%rsi,8),%xmm1
addsd  %xmm2,%xmm0
movsd  -0x18(%rcx,%rsi,8),%xmm2
mulsd  0x20(%r14,%rsi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x10(%rcx,%rsi,8),%xmm3
mulsd  0x28(%r14,%rsi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  -0x8(%rcx,%rsi,8),%xmm1
mulsd  0x30(%r14,%rsi,8),%xmm1
addsd  %xmm2,%xmm3
movsd  (%rcx,%rsi,8),%xmm0
mulsd  0x38(%r14,%rsi,8),%xmm0
addsd  %xmm3,%xmm1
addsd  %xmm1,%xmm0
add    $0x8,%rsi
cmp    %r13,%rsi
jb     11f0 <atax_opt+0xe0>
movsd  %xmm0,(%r12,%r15,8)
cmpq   $0x8,-0x58(%rbp)
jae    12a0 <atax_opt+0x190>
xor    %edx,%edx
jmp    14a0 <atax_opt+0x390>
nopw   0x0(%rax,%rax,1)
cmp    %rbx,%rax
jbe    12c0 <atax_opt+0x1b0>
cmp    -0x50(%rbp),%rdx
jae    12c0 <atax_opt+0x1b0>
xor    %edx,%edx
jmp    14a0 <atax_opt+0x390>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r11,%rax
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
mov    -0x38(%rbp),%r11
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x78(%rdi,%r9,1),%xmm10
movsd  -0x70(%rdi,%r9,1),%xmm12
movsd  -0x68(%rdi,%r9,1),%xmm11
movsd  -0x60(%rdi,%r9,1),%xmm3
movhpd -0x38(%rdi,%r9,1),%xmm10
movsd  (%rbx,%r9,1),%xmm6
movsd  0x8(%rbx,%r9,1),%xmm7
movsd  0x10(%rbx,%r9,1),%xmm1
movsd  0x18(%rbx,%r9,1),%xmm9
movhpd 0x40(%rbx,%r9,1),%xmm6
mulpd  %xmm8,%xmm10
addpd  %xmm6,%xmm10
movhpd -0x30(%rdi,%r9,1),%xmm12
movhpd 0x48(%rbx,%r9,1),%xmm7
mulpd  %xmm8,%xmm12
addpd  %xmm7,%xmm12
movhpd -0x28(%rdi,%r9,1),%xmm11
movhpd 0x50(%rbx,%r9,1),%xmm1
mulpd  %xmm8,%xmm11
addpd  %xmm1,%xmm11
movhpd -0x20(%rdi,%r9,1),%xmm3
movhpd 0x58(%rbx,%r9,1),%xmm9
mulpd  %xmm8,%xmm3
movsd  -0x58(%rdi,%r9,1),%xmm6
movhpd -0x18(%rdi,%r9,1),%xmm6
addpd  %xmm9,%xmm3
movsd  0x20(%rbx,%r9,1),%xmm1
movhpd 0x60(%rbx,%r9,1),%xmm1
mulpd  %xmm8,%xmm6
movsd  -0x50(%rdi,%r9,1),%xmm7
movhpd -0x10(%rdi,%r9,1),%xmm7
addpd  %xmm1,%xmm6
movsd  0x28(%rbx,%r9,1),%xmm4
movhpd 0x68(%rbx,%r9,1),%xmm4
mulpd  %xmm8,%xmm7
movsd  -0x48(%rdi,%r9,1),%xmm1
movhpd -0x8(%rdi,%r9,1),%xmm1
addpd  %xmm4,%xmm7
movsd  0x30(%rbx,%r9,1),%xmm4
movhpd 0x70(%rbx,%r9,1),%xmm4
mulpd  %xmm8,%xmm1
movsd  -0x40(%rdi,%r9,1),%xmm5
movhpd (%rdi,%r9,1),%xmm5
addpd  %xmm4,%xmm1
movsd  0x38(%rbx,%r9,1),%xmm4
movhpd 0x78(%rbx,%r9,1),%xmm4
mulpd  %xmm8,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm10,%xmm9
unpcklpd %xmm12,%xmm9
movapd %xmm11,%xmm13
unpcklpd %xmm3,%xmm13
movapd %xmm6,%xmm2
unpcklpd %xmm7,%xmm2
movapd %xmm1,%xmm4
unpcklpd %xmm5,%xmm4
movhlps %xmm10,%xmm12
movhlps %xmm11,%xmm3
movhlps %xmm6,%xmm7
movhlps %xmm1,%xmm5
movups %xmm5,0x70(%rbx,%r9,1)
movups %xmm7,0x60(%rbx,%r9,1)
movups %xmm3,0x50(%rbx,%r9,1)
movups %xmm12,0x40(%rbx,%r9,1)
movupd %xmm4,0x30(%rbx,%r9,1)
movupd %xmm2,0x20(%rbx,%r9,1)
movupd %xmm13,0x10(%rbx,%r9,1)
movupd %xmm9,(%rbx,%r9,1)
sub    $0xffffffffffffff80,%r9
add    $0xfffffffffffffffe,%r11
jne    12e0 <atax_opt+0x1d0>
mov    -0x40(%rbp),%rdx
mov    -0x38(%rbp),%rsi
cmp    %rsi,-0x48(%rbp)
mov    -0x30(%rbp),%r9
mov    %rax,%r11
je     11c0 <atax_opt+0xb0>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x20(%r8,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  -0x18(%r8,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdx,8)
movsd  -0x10(%r8,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x10(%rbx,%rdx,8)
movsd  -0x8(%r8,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x18(%rbx,%rdx,8)
movsd  (%r8,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x20(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x20(%rbx,%rdx,8)
movsd  0x8(%r8,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x28(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x28(%rbx,%rdx,8)
movsd  0x10(%r8,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x30(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x30(%rbx,%rdx,8)
movsd  0x18(%r8,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x38(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x38(%rbx,%rdx,8)
add    $0x8,%rdx
cmp    %r13,%rdx
jb     14a0 <atax_opt+0x390>
jmp    11c0 <atax_opt+0xb0>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @atax_opt(i32 %0, double* %1, double* %2, double* %3) {
%5 = alloca i32
%6 = alloca double*
%7 = alloca double*
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i64
store i32 %0, i32* %5
store double* %1, double** %6
store double* %2, double** %7
store double* %3, double** %8
%13 = load i32, i32* %5
%14 = zext i32 %13 to i64
%15 = load i32, i32* %5
%16 = zext i32 %15 to i64
%17 = load i32, i32* %5
%18 = zext i32 %17 to i64
%19 = load i32, i32* %5
%20 = zext i32 %19 to i64
%21 = call i8* @llvm.stacksave()
store i8* %21, i8** %11
%22 = alloca double, i64 %20
store i64 %20, i64* %12
store i32 0, i32* %9
br label %23
23: ; preds = %31, %4
%24 = load i32, i32* %9
%25 = load i32, i32* %5
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %34
27: ; preds = %23
%28 = load i32, i32* %9
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds double, double* %22, i64 %29
store double 0.000000e+00, double* %30
br label %31
31: ; preds = %27
%32 = load i32, i32* %9
%33 = add nsw i32 %32, 1
store i32 %33, i32* %9
br label %23
34: ; preds = %23
store i32 0, i32* %10
br label %35
35: ; preds = %390, %34
%36 = load i32, i32* %10
%37 = load i32, i32* %5
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %393
39: ; preds = %35
store i32 0, i32* %9
br label %40
40: ; preds = %211, %39
%41 = load i32, i32* %9
%42 = load i32, i32* %5
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %214
44: ; preds = %40
%45 = load double*, double** %6
%46 = load i32, i32* %10
%47 = sext i32 %46 to i64
%48 = mul nsw i64 %47, %14
%49 = getelementptr inbounds double, double* %45, i64 %48
%50 = load i32, i32* %9
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
%53 = load double, double* %52
%54 = load double*, double** %7
%55 = load i32, i32* %9
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds double, double* %54, i64 %56
%58 = load double, double* %57
%59 = load i32, i32* %10
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds double, double* %22, i64 %60
%62 = load double, double* %61
%63 = call double @llvm.fmuladd.f64(double %53, double %58, double %62)
store double %63, double* %61
%64 = load double*, double** %6
%65 = load i32, i32* %10
%66 = sext i32 %65 to i64
%67 = mul nsw i64 %66, %14
%68 = getelementptr inbounds double, double* %64, i64 %67
%69 = load i32, i32* %9
%70 = add nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds double, double* %68, i64 %71
%73 = load double, double* %72
%74 = load double*, double** %7
%75 = load i32, i32* %9
%76 = add nsw i32 %75, 1
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %74, i64 %77
%79 = load double, double* %78
%80 = load i32, i32* %10
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %22, i64 %81
%83 = load double, double* %82
%84 = call double @llvm.fmuladd.f64(double %73, double %79, double %83)
store double %84, double* %82
%85 = load double*, double** %6
%86 = load i32, i32* %10
%87 = sext i32 %86 to i64
%88 = mul nsw i64 %87, %14
%89 = getelementptr inbounds double, double* %85, i64 %88
%90 = load i32, i32* %9
%91 = add nsw i32 %90, 2
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %89, i64 %92
%94 = load double, double* %93
%95 = load double*, double** %7
%96 = load i32, i32* %9
%97 = add nsw i32 %96, 2
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %95, i64 %98
%100 = load double, double* %99
%101 = load i32, i32* %10
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %22, i64 %102
%104 = load double, double* %103
%105 = call double @llvm.fmuladd.f64(double %94, double %100, double %104)
store double %105, double* %103
%106 = load double*, double** %6
%107 = load i32, i32* %10
%108 = sext i32 %107 to i64
%109 = mul nsw i64 %108, %14
%110 = getelementptr inbounds double, double* %106, i64 %109
%111 = load i32, i32* %9
%112 = add nsw i32 %111, 3
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %110, i64 %113
%115 = load double, double* %114
%116 = load double*, double** %7
%117 = load i32, i32* %9
%118 = add nsw i32 %117, 3
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %116, i64 %119
%121 = load double, double* %120
%122 = load i32, i32* %10
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %22, i64 %123
%125 = load double, double* %124
%126 = call double @llvm.fmuladd.f64(double %115, double %121, double %125)
store double %126, double* %124
%127 = load double*, double** %6
%128 = load i32, i32* %10
%129 = sext i32 %128 to i64
%130 = mul nsw i64 %129, %14
%131 = getelementptr inbounds double, double* %127, i64 %130
%132 = load i32, i32* %9
%133 = add nsw i32 %132, 4
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %131, i64 %134
%136 = load double, double* %135
%137 = load double*, double** %7
%138 = load i32, i32* %9
%139 = add nsw i32 %138, 4
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %137, i64 %140
%142 = load double, double* %141
%143 = load i32, i32* %10
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds double, double* %22, i64 %144
%146 = load double, double* %145
%147 = call double @llvm.fmuladd.f64(double %136, double %142, double %146)
store double %147, double* %145
%148 = load double*, double** %6
%149 = load i32, i32* %10
%150 = sext i32 %149 to i64
%151 = mul nsw i64 %150, %14
%152 = getelementptr inbounds double, double* %148, i64 %151
%153 = load i32, i32* %9
%154 = add nsw i32 %153, 5
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %152, i64 %155
%157 = load double, double* %156
%158 = load double*, double** %7
%159 = load i32, i32* %9
%160 = add nsw i32 %159, 5
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %158, i64 %161
%163 = load double, double* %162
%164 = load i32, i32* %10
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %22, i64 %165
%167 = load double, double* %166
%168 = call double @llvm.fmuladd.f64(double %157, double %163, double %167)
store double %168, double* %166
%169 = load double*, double** %6
%170 = load i32, i32* %10
%171 = sext i32 %170 to i64
%172 = mul nsw i64 %171, %14
%173 = getelementptr inbounds double, double* %169, i64 %172
%174 = load i32, i32* %9
%175 = add nsw i32 %174, 6
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %173, i64 %176
%178 = load double, double* %177
%179 = load double*, double** %7
%180 = load i32, i32* %9
%181 = add nsw i32 %180, 6
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds double, double* %179, i64 %182
%184 = load double, double* %183
%185 = load i32, i32* %10
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %22, i64 %186
%188 = load double, double* %187
%189 = call double @llvm.fmuladd.f64(double %178, double %184, double %188)
store double %189, double* %187
%190 = load double*, double** %6
%191 = load i32, i32* %10
%192 = sext i32 %191 to i64
%193 = mul nsw i64 %192, %14
%194 = getelementptr inbounds double, double* %190, i64 %193
%195 = load i32, i32* %9
%196 = add nsw i32 %195, 7
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %194, i64 %197
%199 = load double, double* %198
%200 = load double*, double** %7
%201 = load i32, i32* %9
%202 = add nsw i32 %201, 7
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %200, i64 %203
%205 = load double, double* %204
%206 = load i32, i32* %10
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %22, i64 %207
%209 = load double, double* %208
%210 = call double @llvm.fmuladd.f64(double %199, double %205, double %209)
store double %210, double* %208
br label %211
211: ; preds = %44
%212 = load i32, i32* %9
%213 = add nsw i32 %212, 8
store i32 %213, i32* %9
br label %40
214: ; preds = %40
store i32 0, i32* %9
br label %215
215: ; preds = %386, %214
%216 = load i32, i32* %9
%217 = load i32, i32* %5
%218 = icmp slt i32 %216, %217
br i1 %218, label %219, label %389
219: ; preds = %215
%220 = load double*, double** %6
%221 = load i32, i32* %10
%222 = sext i32 %221 to i64
%223 = mul nsw i64 %222, %14
%224 = getelementptr inbounds double, double* %220, i64 %223
%225 = load i32, i32* %9
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
%228 = load double, double* %227
%229 = load i32, i32* %10
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %22, i64 %230
%232 = load double, double* %231
%233 = load double*, double** %8
%234 = load i32, i32* %9
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
%237 = load double, double* %236
%238 = call double @llvm.fmuladd.f64(double %228, double %232, double %237)
store double %238, double* %236
%239 = load double*, double** %6
%240 = load i32, i32* %10
%241 = sext i32 %240 to i64
%242 = mul nsw i64 %241, %14
%243 = getelementptr inbounds double, double* %239, i64 %242
%244 = load i32, i32* %9
%245 = add nsw i32 %244, 1
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %243, i64 %246
%248 = load double, double* %247
%249 = load i32, i32* %10
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds double, double* %22, i64 %250
%252 = load double, double* %251
%253 = load double*, double** %8
%254 = load i32, i32* %9
%255 = add nsw i32 %254, 1
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %253, i64 %256
%258 = load double, double* %257
%259 = call double @llvm.fmuladd.f64(double %248, double %252, double %258)
store double %259, double* %257
%260 = load double*, double** %6
%261 = load i32, i32* %10
%262 = sext i32 %261 to i64
%263 = mul nsw i64 %262, %14
%264 = getelementptr inbounds double, double* %260, i64 %263
%265 = load i32, i32* %9
%266 = add nsw i32 %265, 2
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %264, i64 %267
%269 = load double, double* %268
%270 = load i32, i32* %10
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds double, double* %22, i64 %271
%273 = load double, double* %272
%274 = load double*, double** %8
%275 = load i32, i32* %9
%276 = add nsw i32 %275, 2
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds double, double* %274, i64 %277
%279 = load double, double* %278
%280 = call double @llvm.fmuladd.f64(double %269, double %273, double %279)
store double %280, double* %278
%281 = load double*, double** %6
%282 = load i32, i32* %10
%283 = sext i32 %282 to i64
%284 = mul nsw i64 %283, %14
%285 = getelementptr inbounds double, double* %281, i64 %284
%286 = load i32, i32* %9
%287 = add nsw i32 %286, 3
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %285, i64 %288
%290 = load double, double* %289
%291 = load i32, i32* %10
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds double, double* %22, i64 %292
%294 = load double, double* %293
%295 = load double*, double** %8
%296 = load i32, i32* %9
%297 = add nsw i32 %296, 3
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %295, i64 %298
%300 = load double, double* %299
%301 = call double @llvm.fmuladd.f64(double %290, double %294, double %300)
store double %301, double* %299
%302 = load double*, double** %6
%303 = load i32, i32* %10
%304 = sext i32 %303 to i64
%305 = mul nsw i64 %304, %14
%306 = getelementptr inbounds double, double* %302, i64 %305
%307 = load i32, i32* %9
%308 = add nsw i32 %307, 4
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %306, i64 %309
%311 = load double, double* %310
%312 = load i32, i32* %10
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds double, double* %22, i64 %313
%315 = load double, double* %314
%316 = load double*, double** %8
%317 = load i32, i32* %9
%318 = add nsw i32 %317, 4
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds double, double* %316, i64 %319
%321 = load double, double* %320
%322 = call double @llvm.fmuladd.f64(double %311, double %315, double %321)
store double %322, double* %320
%323 = load double*, double** %6
%324 = load i32, i32* %10
%325 = sext i32 %324 to i64
%326 = mul nsw i64 %325, %14
%327 = getelementptr inbounds double, double* %323, i64 %326
%328 = load i32, i32* %9
%329 = add nsw i32 %328, 5
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %327, i64 %330
%332 = load double, double* %331
%333 = load i32, i32* %10
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double, double* %22, i64 %334
%336 = load double, double* %335
%337 = load double*, double** %8
%338 = load i32, i32* %9
%339 = add nsw i32 %338, 5
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds double, double* %337, i64 %340
%342 = load double, double* %341
%343 = call double @llvm.fmuladd.f64(double %332, double %336, double %342)
store double %343, double* %341
%344 = load double*, double** %6
%345 = load i32, i32* %10
%346 = sext i32 %345 to i64
%347 = mul nsw i64 %346, %14
%348 = getelementptr inbounds double, double* %344, i64 %347
%349 = load i32, i32* %9
%350 = add nsw i32 %349, 6
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %348, i64 %351
%353 = load double, double* %352
%354 = load i32, i32* %10
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds double, double* %22, i64 %355
%357 = load double, double* %356
%358 = load double*, double** %8
%359 = load i32, i32* %9
%360 = add nsw i32 %359, 6
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double, double* %358, i64 %361
%363 = load double, double* %362
%364 = call double @llvm.fmuladd.f64(double %353, double %357, double %363)
store double %364, double* %362
%365 = load double*, double** %6
%366 = load i32, i32* %10
%367 = sext i32 %366 to i64
%368 = mul nsw i64 %367, %14
%369 = getelementptr inbounds double, double* %365, i64 %368
%370 = load i32, i32* %9
%371 = add nsw i32 %370, 7
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double, double* %369, i64 %372
%374 = load double, double* %373
%375 = load i32, i32* %10
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds double, double* %22, i64 %376
%378 = load double, double* %377
%379 = load double*, double** %8
%380 = load i32, i32* %9
%381 = add nsw i32 %380, 7
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds double, double* %379, i64 %382
%384 = load double, double* %383
%385 = call double @llvm.fmuladd.f64(double %374, double %378, double %384)
store double %385, double* %383
br label %386
386: ; preds = %219
%387 = load i32, i32* %9
%388 = add nsw i32 %387, 8
store i32 %388, i32* %9
br label %215
389: ; preds = %215
br label %390
390: ; preds = %389
%391 = load i32, i32* %10
%392 = add nsw i32 %391, 1
store i32 %392, i32* %10
br label %35
393: ; preds = %35
%394 = load i8*, i8** %11
ret void
}

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