void kernel_dgemv_diag_lib4(int kmax, double *dA, double *x, double *y,
                            double *z, int alg) {
  if (kmax <= 0)
    return;
  int k;
  if (alg == 0) {
    k = 0;
    for (; k < kmax - 3; k += 4) {
      z[0] = dA[0] * x[0];
      z[1] = dA[1] * x[1];
      z[2] = dA[2] * x[2];
      z[3] = dA[3] * x[3];
      dA += 4;
      x += 4;
      z += 4;
    }
    for (; k < kmax; k++) {
      z[0] = dA[0] * x[0];
      dA += 1;
      x += 1;
      z += 1;
    }
  } else if (alg == 1) {
    k = 0;
    for (; k < kmax - 3; k += 4) {
      z[0] = y[0] + dA[0] * x[0];
      z[1] = y[1] + dA[1] * x[1];
      z[2] = y[2] + dA[2] * x[2];
      z[3] = y[3] + dA[3] * x[3];
      dA += 4;
      x += 4;
      y += 4;
      z += 4;
    }
    for (; k < kmax; k++) {
      z[0] = y[0] + dA[0] * x[0];
      dA += 1;
      x += 1;
      y += 1;
      z += 1;
    }
  } else {
    k = 0;
    for (; k < kmax - 3; k += 4) {
      z[0] = y[0] - dA[0] * x[0];
      z[1] = y[1] - dA[1] * x[1];
      z[2] = y[2] - dA[2] * x[2];
      z[3] = y[3] - dA[3] * x[3];
      dA += 4;
      x += 4;
      y += 4;
      z += 4;
    }
    for (; k < kmax; k++) {
      z[0] = y[0] - dA[0] * x[0];
      dA += 1;
      x += 1;
      y += 1;
      z += 1;
    }
  }
}


x86 assembly (clang, -O0):
<kernel_dgemv_diag_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     112a <kernel_dgemv_diag_lib4+0x2a>
jmp    15c5 <kernel_dgemv_diag_lib4+0x4c5>
cmpl   $0x0,-0x2c(%rbp)
jne    1247 <kernel_dgemv_diag_lib4+0x147>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    11e7 <kernel_dgemv_diag_lib4+0xe7>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    113b <kernel_dgemv_diag_lib4+0x3b>
jmp    11ec <kernel_dgemv_diag_lib4+0xec>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1242 <kernel_dgemv_diag_lib4+0x142>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ec <kernel_dgemv_diag_lib4+0xec>
jmp    15c5 <kernel_dgemv_diag_lib4+0x4c5>
cmpl   $0x1,-0x2c(%rbp)
jne    13cf <kernel_dgemv_diag_lib4+0x2cf>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1353 <kernel_dgemv_diag_lib4+0x253>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    1258 <kernel_dgemv_diag_lib4+0x158>
jmp    1358 <kernel_dgemv_diag_lib4+0x258>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13ca <kernel_dgemv_diag_lib4+0x2ca>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1358 <kernel_dgemv_diag_lib4+0x258>
jmp    15c0 <kernel_dgemv_diag_lib4+0x4c0>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    152d <kernel_dgemv_diag_lib4+0x42d>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    13d6 <kernel_dgemv_diag_lib4+0x2d6>
jmp    1532 <kernel_dgemv_diag_lib4+0x432>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15bb <kernel_dgemv_diag_lib4+0x4bb>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1532 <kernel_dgemv_diag_lib4+0x432>
jmp    15c0 <kernel_dgemv_diag_lib4+0x4c0>
jmp    15c5 <kernel_dgemv_diag_lib4+0x4c5>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_dgemv_diag_lib4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    1c30 <kernel_dgemv_diag_lib4+0xb30>
test   %r9d,%r9d
je     128b <kernel_dgemv_diag_lib4+0x18b>
cmp    $0x1,%r9d
jne    13a6 <kernel_dgemv_diag_lib4+0x2a6>
xor    %r9d,%r9d
cmp    $0x4,%edi
jb     11f5 <kernel_dgemv_diag_lib4+0xf5>
lea    -0x3(%rdi),%r9d
cmp    $0x5,%r9d
mov    $0x4,%r15d
cmovge %r9d,%r15d
mov    $0x4,%eax
add    $0xffffffff,%r15d
xor    %r10d,%r10d
cmp    $0x4,%r15d
jae    1545 <kernel_dgemv_diag_lib4+0x445>
mov    %rsi,%r11
mov    %r8,%r14
mov    %rcx,%r13
mov    %rdx,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r11),%xmm0
mulsd  (%rax),%xmm0
addsd  0x0(%r13),%xmm0
movsd  %xmm0,(%r14)
movsd  0x8(%r11),%xmm0
mulsd  0x8(%rax),%xmm0
addsd  0x8(%r13),%xmm0
movsd  %xmm0,0x8(%r14)
movsd  0x10(%r11),%xmm0
mulsd  0x10(%rax),%xmm0
addsd  0x10(%r13),%xmm0
movsd  %xmm0,0x10(%r14)
movsd  0x18(%r11),%xmm0
mulsd  0x18(%rax),%xmm0
addsd  0x18(%r13),%xmm0
movsd  %xmm0,0x18(%r14)
add    $0x20,%r11
add    $0x20,%rax
add    $0x20,%r13
add    $0x20,%r14
add    $0x4,%r10d
cmp    %r9d,%r10d
jl     1170 <kernel_dgemv_diag_lib4+0x70>
mov    %edi,%r9d
and    $0xfffffffc,%r9d
mov    %rax,%rdx
mov    %r13,%rcx
mov    %r14,%r8
mov    %r11,%rsi
cmp    %edi,%r9d
jge    1c30 <kernel_dgemv_diag_lib4+0xb30>
mov    %r9d,%eax
not    %eax
add    %edi,%eax
cmp    $0x3,%eax
jae    16f7 <kernel_dgemv_diag_lib4+0x5f7>
mov    %edi,%ebp
sub    %r9d,%ebp
mov    %r9d,%eax
not    %eax
test   $0x1,%bpl
je     1243 <kernel_dgemv_diag_lib4+0x143>
movsd  (%rsi),%xmm0
mulsd  (%rdx),%xmm0
addsd  (%rcx),%xmm0
movsd  %xmm0,(%r8)
add    $0x8,%rsi
add    $0x8,%rdx
add    $0x8,%rcx
add    $0x8,%r8
add    $0x1,%r9d
add    %edi,%eax
je     1c30 <kernel_dgemv_diag_lib4+0xb30>
sub    %r9d,%edi
xor    %eax,%eax
movsd  (%rsi,%rax,8),%xmm0
mulsd  (%rdx,%rax,8),%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
mulsd  0x8(%rdx,%rax,8),%xmm0
addsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r8,%rax,8)
add    $0x2,%rax
cmp    %eax,%edi
jne    1250 <kernel_dgemv_diag_lib4+0x150>
jmp    1c30 <kernel_dgemv_diag_lib4+0xb30>
xor    %eax,%eax
cmp    $0x4,%edi
jb     12f5 <kernel_dgemv_diag_lib4+0x1f5>
lea    -0x3(%rdi),%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi),%xmm0
mulsd  (%rdx),%xmm0
movsd  %xmm0,(%r8)
movsd  0x8(%rsi),%xmm0
mulsd  0x8(%rdx),%xmm0
movsd  %xmm0,0x8(%r8)
movsd  0x10(%rsi),%xmm0
mulsd  0x10(%rdx),%xmm0
movsd  %xmm0,0x10(%r8)
movsd  0x18(%rsi),%xmm0
mulsd  0x18(%rdx),%xmm0
movsd  %xmm0,0x18(%r8)
add    $0x20,%rsi
add    $0x20,%rdx
add    $0x20,%r8
add    $0x4,%ecx
cmp    %eax,%ecx
jl     12a0 <kernel_dgemv_diag_lib4+0x1a0>
mov    %edi,%eax
and    $0xfffffffc,%eax
cmp    %edi,%eax
jge    1c30 <kernel_dgemv_diag_lib4+0xb30>
mov    %eax,%ecx
not    %ecx
add    %edi,%ecx
cmp    $0x3,%ecx
jae    1823 <kernel_dgemv_diag_lib4+0x723>
mov    %edi,%ebp
sub    %eax,%ebp
mov    %eax,%ecx
not    %ecx
add    %edi,%ecx
and    $0x3,%ebp
je     1342 <kernel_dgemv_diag_lib4+0x242>
neg    %ebp
xor    %ebx,%ebx
nop
movsd  (%rsi),%xmm0
mulsd  (%rdx),%xmm0
movsd  %xmm0,(%r8)
add    $0x8,%rsi
add    $0x8,%rdx
add    $0x8,%r8
add    $0xffffffff,%ebx
cmp    %ebx,%ebp
jne    1320 <kernel_dgemv_diag_lib4+0x220>
sub    %ebx,%eax
cmp    $0x3,%ecx
jb     1c30 <kernel_dgemv_diag_lib4+0xb30>
sub    %eax,%edi
xor    %eax,%eax
nop
movsd  (%rsi,%rax,8),%xmm0
mulsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
mulsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r8,%rax,8)
movsd  0x10(%rsi,%rax,8),%xmm0
mulsd  0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r8,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm0
mulsd  0x18(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r8,%rax,8)
add    $0x4,%rax
cmp    %eax,%edi
jne    1350 <kernel_dgemv_diag_lib4+0x250>
jmp    1c30 <kernel_dgemv_diag_lib4+0xb30>
xor    %r9d,%r9d
cmp    $0x4,%edi
jb     1489 <kernel_dgemv_diag_lib4+0x389>
lea    -0x3(%rdi),%r9d
cmp    $0x5,%r9d
mov    $0x4,%r15d
cmovge %r9d,%r15d
mov    $0x4,%eax
add    $0xffffffff,%r15d
xor    %r10d,%r10d
cmp    $0x4,%r15d
jae    1908 <kernel_dgemv_diag_lib4+0x808>
mov    %rsi,%r11
mov    %r8,%r14
mov    %rcx,%r13
mov    %rdx,%rax
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13),%xmm0
movsd  (%r11),%xmm1
mulsd  (%rax),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14)
movsd  0x8(%r13),%xmm0
movsd  0x8(%r11),%xmm1
mulsd  0x8(%rax),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14)
movsd  0x10(%r13),%xmm0
movsd  0x10(%r11),%xmm1
mulsd  0x10(%rax),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%r14)
movsd  0x18(%r13),%xmm0
movsd  0x18(%r11),%xmm1
mulsd  0x18(%rax),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%r14)
add    $0x20,%r11
add    $0x20,%rax
add    $0x20,%r13
add    $0x20,%r14
add    $0x4,%r10d
cmp    %r9d,%r10d
jl     13f0 <kernel_dgemv_diag_lib4+0x2f0>
mov    %edi,%r9d
and    $0xfffffffc,%r9d
mov    %rax,%rdx
mov    %r13,%rcx
mov    %r14,%r8
mov    %r11,%rsi
cmp    %edi,%r9d
jge    1c30 <kernel_dgemv_diag_lib4+0xb30>
mov    %r9d,%r14d
not    %r14d
add    %edi,%r14d
cmp    $0x3,%r14d
jae    1ab9 <kernel_dgemv_diag_lib4+0x9b9>
mov    %rsi,%r10
mov    %r8,%r11
mov    %rcx,%rax
mov    %rdx,%rbx
mov    %edi,%edx
sub    %r9d,%edx
mov    %r9d,%ecx
not    %ecx
test   $0x1,%dl
je     14ea <kernel_dgemv_diag_lib4+0x3ea>
movsd  (%r10),%xmm0
mulsd  (%rbx),%xmm0
movsd  (%rax),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r11)
add    $0x8,%r10
add    $0x8,%rbx
add    $0x8,%rax
add    $0x8,%r11
add    $0x1,%r9d
add    %edi,%ecx
je     1c30 <kernel_dgemv_diag_lib4+0xb30>
sub    %r9d,%edi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm0
movsd  (%r10,%rcx,8),%xmm1
mulsd  (%rbx,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  0x8(%r10,%rcx,8),%xmm1
mulsd  0x8(%rbx,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r11,%rcx,8)
add    $0x2,%rcx
cmp    %ecx,%edi
jne    1500 <kernel_dgemv_diag_lib4+0x400>
jmp    1c30 <kernel_dgemv_diag_lib4+0xb30>
cmp    $0x5,%r9d
cmovge %r9d,%eax
add    $0xffffffff,%eax
and    $0xfffffffc,%eax
lea    (%rcx,%rax,8),%rbp
add    $0x20,%rbp
cmp    %r8,%rbp
seta   %r14b
lea    (%r8,%rax,8),%rbp
add    $0x20,%rbp
cmp    %rcx,%rbp
seta   %r12b
lea    (%rsi,%rax,8),%rbx
add    $0x20,%rbx
cmp    %r8,%rbx
seta   %bl
cmp    %rsi,%rbp
seta   %r11b
lea    (%rdx,%rax,8),%rax
add    $0x20,%rax
cmp    %r8,%rax
seta   %al
cmp    %rdx,%rbp
seta   %bpl
test   %r12b,%r14b
jne    1159 <kernel_dgemv_diag_lib4+0x59>
and    %r11b,%bl
jne    1159 <kernel_dgemv_diag_lib4+0x59>
and    %bpl,%al
jne    1159 <kernel_dgemv_diag_lib4+0x59>
shr    $0x2,%r15d
add    $0x1,%r15d
mov    %r15d,%r12d
and    $0xfffffffe,%r12d
lea    0x0(,%r12,4),%r10d
mov    %r12,%rax
shl    $0x5,%rax
lea    (%rsi,%rax,1),%r11
lea    (%r8,%rax,1),%r14
lea    (%rcx,%rax,1),%r13
add    %rdx,%rax
xor    %ebx,%ebx
mov    %r12,%rbp
nopl   0x0(%rax,%rax,1)
movupd (%rcx,%rbx,1),%xmm12
movupd 0x10(%rcx,%rbx,1),%xmm9
movupd 0x20(%rcx,%rbx,1),%xmm2
movupd 0x30(%rcx,%rbx,1),%xmm3
movapd %xmm12,%xmm10
unpcklpd %xmm2,%xmm10
unpckhpd %xmm2,%xmm12
movapd %xmm9,%xmm8
unpcklpd %xmm3,%xmm8
unpckhpd %xmm3,%xmm9
movupd (%rsi,%rbx,1),%xmm7
movupd 0x10(%rsi,%rbx,1),%xmm0
movupd 0x20(%rsi,%rbx,1),%xmm4
movupd 0x30(%rsi,%rbx,1),%xmm5
movapd %xmm7,%xmm2
unpcklpd %xmm4,%xmm2
unpckhpd %xmm4,%xmm7
movapd %xmm0,%xmm3
unpcklpd %xmm5,%xmm3
unpckhpd %xmm5,%xmm0
movupd (%rdx,%rbx,1),%xmm4
movupd 0x10(%rdx,%rbx,1),%xmm5
movupd 0x20(%rdx,%rbx,1),%xmm6
movupd 0x30(%rdx,%rbx,1),%xmm11
movapd %xmm4,%xmm1
unpcklpd %xmm6,%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm10,%xmm1
unpckhpd %xmm6,%xmm4
mulpd  %xmm7,%xmm4
addpd  %xmm12,%xmm4
movapd %xmm5,%xmm2
unpcklpd %xmm11,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm8,%xmm2
unpckhpd %xmm11,%xmm5
mulpd  %xmm0,%xmm5
addpd  %xmm9,%xmm5
movapd %xmm2,%xmm0
unpcklpd %xmm5,%xmm0
movapd %xmm1,%xmm3
unpcklpd %xmm4,%xmm3
movhlps %xmm2,%xmm5
movhlps %xmm1,%xmm4
movups %xmm4,0x20(%r8,%rbx,1)
movups %xmm5,0x30(%r8,%rbx,1)
movupd %xmm3,(%r8,%rbx,1)
movupd %xmm0,0x10(%r8,%rbx,1)
add    $0x40,%rbx
add    $0xfffffffffffffffe,%rbp
jne    15f0 <kernel_dgemv_diag_lib4+0x4f0>
cmp    %r15,%r12
jne    1170 <kernel_dgemv_diag_lib4+0x70>
jmp    11e2 <kernel_dgemv_diag_lib4+0xe2>
lea    (%r8,%rax,8),%rbp
add    $0x8,%rbp
lea    (%rcx,%rax,8),%rbx
add    $0x8,%rbx
lea    (%rsi,%rax,8),%r10
add    $0x8,%r10
lea    (%rdx,%rax,8),%r14
add    $0x8,%r14
cmp    %rbx,%r8
setb   %r15b
cmp    %rbp,%rcx
setb   %r12b
cmp    %r10,%r8
setb   %bl
cmp    %rbp,%rsi
setb   %r11b
cmp    %r14,%r8
setb   %r10b
cmp    %rbp,%rdx
setb   %bpl
test   %r12b,%r15b
jne    120e <kernel_dgemv_diag_lib4+0x10e>
and    %r11b,%bl
jne    120e <kernel_dgemv_diag_lib4+0x10e>
and    %bpl,%r10b
jne    120e <kernel_dgemv_diag_lib4+0x10e>
add    $0x1,%rax
mov    %rax,%r10
and    $0xfffffffffffffffc,%r10
lea    -0x4(%r10),%rbx
mov    %rbx,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rbx,%rbx
je     1b95 <kernel_dgemv_diag_lib4+0xa95>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd (%rcx,%rbp,8),%xmm0
movupd 0x10(%rcx,%rbp,8),%xmm1
movupd (%rsi,%rbp,8),%xmm2
movupd 0x10(%rsi,%rbp,8),%xmm3
movupd (%rdx,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd 0x10(%rdx,%rbp,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,(%r8,%rbp,8)
movupd %xmm0,0x10(%r8,%rbp,8)
movupd 0x20(%rcx,%rbp,8),%xmm0
movupd 0x30(%rcx,%rbp,8),%xmm1
movupd 0x20(%rsi,%rbp,8),%xmm2
movupd 0x30(%rsi,%rbp,8),%xmm3
movupd 0x20(%rdx,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd 0x30(%rdx,%rbp,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,0x20(%r8,%rbp,8)
movupd %xmm0,0x30(%r8,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1790 <kernel_dgemv_diag_lib4+0x690>
jmp    1b97 <kernel_dgemv_diag_lib4+0xa97>
lea    (%r8,%rcx,8),%rbp
add    $0x8,%rbp
lea    (%rsi,%rcx,8),%rbx
add    $0x8,%rbx
lea    (%rdx,%rcx,8),%r9
add    $0x8,%r9
cmp    %rbx,%r8
setb   %r10b
cmp    %rbp,%rsi
setb   %r11b
cmp    %r9,%r8
setb   %bl
cmp    %rbp,%rdx
setb   %r9b
test   %r11b,%r10b
jne    130c <kernel_dgemv_diag_lib4+0x20c>
and    %r9b,%bl
jne    130c <kernel_dgemv_diag_lib4+0x20c>
add    $0x1,%rcx
mov    %rcx,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rbp
mov    %rbp,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rbp,%rbp
je     1bf8 <kernel_dgemv_diag_lib4+0xaf8>
mov    %r10,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rsi,%rbp,8),%xmm0
movupd 0x10(%rsi,%rbp,8),%xmm1
movupd (%rdx,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdx,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r8,%rbp,8)
movupd %xmm0,0x10(%r8,%rbp,8)
movupd 0x20(%rsi,%rbp,8),%xmm0
movupd 0x30(%rsi,%rbp,8),%xmm1
movupd 0x20(%rdx,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rdx,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r8,%rbp,8)
movupd %xmm0,0x30(%r8,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    18a0 <kernel_dgemv_diag_lib4+0x7a0>
jmp    1bfa <kernel_dgemv_diag_lib4+0xafa>
cmp    $0x5,%r9d
cmovge %r9d,%eax
add    $0xffffffff,%eax
and    $0xfffffffc,%eax
lea    (%rcx,%rax,8),%rbp
add    $0x20,%rbp
cmp    %r8,%rbp
seta   %r14b
lea    (%r8,%rax,8),%rbp
add    $0x20,%rbp
cmp    %rcx,%rbp
seta   %r12b
lea    (%rsi,%rax,8),%rbx
add    $0x20,%rbx
cmp    %r8,%rbx
seta   %bl
cmp    %rsi,%rbp
seta   %r11b
lea    (%rdx,%rax,8),%rax
add    $0x20,%rax
cmp    %r8,%rax
seta   %al
cmp    %rdx,%rbp
seta   %bpl
test   %r12b,%r14b
jne    13da <kernel_dgemv_diag_lib4+0x2da>
and    %r11b,%bl
jne    13da <kernel_dgemv_diag_lib4+0x2da>
and    %bpl,%al
jne    13da <kernel_dgemv_diag_lib4+0x2da>
shr    $0x2,%r15d
add    $0x1,%r15d
mov    %r15d,%r12d
and    $0xfffffffe,%r12d
lea    0x0(,%r12,4),%r10d
mov    %r12,%rax
shl    $0x5,%rax
lea    (%rsi,%rax,1),%r11
lea    (%r8,%rax,1),%r14
lea    (%rcx,%rax,1),%r13
add    %rdx,%rax
xor    %ebx,%ebx
mov    %r12,%rbp
nopl   0x0(%rax,%rax,1)
movupd (%rcx,%rbx,1),%xmm0
movupd 0x10(%rcx,%rbx,1),%xmm1
movupd 0x20(%rcx,%rbx,1),%xmm3
movupd 0x30(%rcx,%rbx,1),%xmm4
movapd %xmm0,%xmm12
unpcklpd %xmm3,%xmm12
unpckhpd %xmm3,%xmm0
movapd %xmm1,%xmm3
unpcklpd %xmm4,%xmm3
unpckhpd %xmm4,%xmm1
movupd (%rsi,%rbx,1),%xmm5
movupd 0x10(%rsi,%rbx,1),%xmm8
movupd 0x20(%rsi,%rbx,1),%xmm6
movupd 0x30(%rsi,%rbx,1),%xmm7
movapd %xmm5,%xmm4
unpcklpd %xmm6,%xmm4
unpckhpd %xmm6,%xmm5
movapd %xmm8,%xmm9
unpcklpd %xmm7,%xmm9
unpckhpd %xmm7,%xmm8
movupd (%rdx,%rbx,1),%xmm2
movupd 0x10(%rdx,%rbx,1),%xmm6
movupd 0x20(%rdx,%rbx,1),%xmm10
movupd 0x30(%rdx,%rbx,1),%xmm11
movapd %xmm2,%xmm7
unpcklpd %xmm10,%xmm7
mulpd  %xmm4,%xmm7
subpd  %xmm7,%xmm12
unpckhpd %xmm10,%xmm2
mulpd  %xmm5,%xmm2
subpd  %xmm2,%xmm0
movapd %xmm6,%xmm2
unpcklpd %xmm11,%xmm2
mulpd  %xmm9,%xmm2
subpd  %xmm2,%xmm3
unpckhpd %xmm11,%xmm6
mulpd  %xmm8,%xmm6
subpd  %xmm6,%xmm1
movapd %xmm3,%xmm2
unpcklpd %xmm1,%xmm2
movapd %xmm12,%xmm4
unpcklpd %xmm0,%xmm4
movhlps %xmm3,%xmm1
movhlps %xmm12,%xmm0
movups %xmm0,0x20(%r8,%rbx,1)
movups %xmm1,0x30(%r8,%rbx,1)
movupd %xmm4,(%r8,%rbx,1)
movupd %xmm2,0x10(%r8,%rbx,1)
add    $0x40,%rbx
add    $0xfffffffffffffffe,%rbp
jne    19b0 <kernel_dgemv_diag_lib4+0x8b0>
cmp    %r15,%r12
jne    13f0 <kernel_dgemv_diag_lib4+0x2f0>
jmp    1476 <kernel_dgemv_diag_lib4+0x376>
lea    (%r8,%r14,8),%rbp
add    $0x8,%rbp
lea    (%rcx,%r14,8),%rax
add    $0x8,%rax
lea    (%rsi,%r14,8),%rbx
add    $0x8,%rbx
lea    (%rdx,%r14,8),%r11
add    $0x8,%r11
cmp    %rax,%r8
setb   %r15b
cmp    %rbp,%rcx
setb   %r12b
cmp    %rbx,%r8
setb   %al
cmp    %rbp,%rsi
setb   %r10b
cmp    %r11,%r8
setb   %bl
cmp    %rbp,%rdx
setb   %r11b
test   %r12b,%r15b
jne    14a5 <kernel_dgemv_diag_lib4+0x3a5>
and    %r10b,%al
jne    14a5 <kernel_dgemv_diag_lib4+0x3a5>
and    %r11b,%bl
jne    14a5 <kernel_dgemv_diag_lib4+0x3a5>
add    $0x1,%r14
mov    %r14,%r15
and    $0xfffffffffffffffc,%r15
add    %r15d,%r9d
lea    (%rsi,%r15,8),%r10
lea    (%r8,%r15,8),%r11
lea    (%rcx,%r15,8),%rax
lea    (%rdx,%r15,8),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd (%rcx,%rbp,8),%xmm0
movupd 0x10(%rcx,%rbp,8),%xmm1
movupd (%rsi,%rbp,8),%xmm2
movupd 0x10(%rsi,%rbp,8),%xmm3
movupd (%rdx,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
subpd  %xmm4,%xmm0
movupd 0x10(%rdx,%rbp,8),%xmm2
mulpd  %xmm3,%xmm2
subpd  %xmm2,%xmm1
movupd %xmm0,(%r8,%rbp,8)
movupd %xmm1,0x10(%r8,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r15
jne    1b40 <kernel_dgemv_diag_lib4+0xa40>
cmp    %r15,%r14
jne    14b1 <kernel_dgemv_diag_lib4+0x3b1>
jmp    1c30 <kernel_dgemv_diag_lib4+0xb30>
xor    %ebp,%ebp
test   $0x1,%r11b
je     1bdb <kernel_dgemv_diag_lib4+0xadb>
movupd (%rcx,%rbp,8),%xmm0
movupd 0x10(%rcx,%rbp,8),%xmm1
movupd (%rsi,%rbp,8),%xmm2
movupd 0x10(%rsi,%rbp,8),%xmm3
movupd (%rdx,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd 0x10(%rdx,%rbp,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,(%r8,%rbp,8)
movupd %xmm0,0x10(%r8,%rbp,8)
cmp    %r10,%rax
je     1c30 <kernel_dgemv_diag_lib4+0xb30>
add    %r10d,%r9d
lea    (%rsi,%r10,8),%rsi
lea    (%r8,%r10,8),%r8
lea    (%rcx,%r10,8),%rcx
lea    (%rdx,%r10,8),%rdx
jmp    120e <kernel_dgemv_diag_lib4+0x10e>
xor    %ebp,%ebp
test   $0x1,%r10b
je     1c2b <kernel_dgemv_diag_lib4+0xb2b>
movupd (%rsi,%rbp,8),%xmm0
movupd 0x10(%rsi,%rbp,8),%xmm1
movupd (%rdx,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdx,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r8,%rbp,8)
movupd %xmm0,0x10(%r8,%rbp,8)
cmp    %r9,%rcx
jne    1c3b <kernel_dgemv_diag_lib4+0xb3b>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    %r9d,%eax
lea    (%rsi,%r9,8),%rsi
lea    (%r8,%r9,8),%r8
lea    (%rdx,%r9,8),%rdx
jmp    130c <kernel_dgemv_diag_lib4+0x20c>

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

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