void storeK(double *GA, double *GB, const double *PA, const double *PB,
            int nBasis, double EE, int p, int q, int i, int j, char type) {
  double r;
  switch (type) {
  case 5:
    GA[p * nBasis + i] -= PA[q * nBasis + j] * EE;
    GB[p * nBasis + i] -= PB[q * nBasis + j] * EE;
    break;
  case 4:
    GA[p * nBasis + i] -= PA[q * nBasis + j] * EE;
    GB[p * nBasis + i] -= PB[q * nBasis + j] * EE;
    break;
  case 3:
    GA[p * nBasis + i] -= PA[q * nBasis + j] * EE;
    GA[p * nBasis + j] -= PA[q * nBasis + i] * EE;
    GA[i * nBasis + p] -= PA[j * nBasis + q] * EE;
    GB[p * nBasis + i] -= PB[q * nBasis + j] * EE;
    GB[p * nBasis + j] -= PB[q * nBasis + i] * EE;
    GB[i * nBasis + p] -= PB[j * nBasis + q] * EE;
    break;
  case 2:
    GA[p * nBasis + i] -= PA[q * nBasis + j] * EE;
    GA[q * nBasis + i] -= PA[p * nBasis + j] * EE;
    GA[i * nBasis + q] -= PA[j * nBasis + p] * EE;
    GB[p * nBasis + i] -= PB[q * nBasis + j] * EE;
    GB[q * nBasis + i] -= PB[p * nBasis + j] * EE;
    GB[i * nBasis + q] -= PB[j * nBasis + p] * EE;
    break;
  case 1:
    GA[p * nBasis + i] -= PA[q * nBasis + j] * EE;
    GA[p * nBasis + j] -= PA[q * nBasis + i] * EE;
    GA[q * nBasis + i] -= PA[p * nBasis + j] * EE;
    GA[q * nBasis + j] -= PA[p * nBasis + i] * EE;
    GB[p * nBasis + i] -= PB[q * nBasis + j] * EE;
    GB[p * nBasis + j] -= PB[q * nBasis + i] * EE;
    GB[q * nBasis + i] -= PB[p * nBasis + j] * EE;
    GB[q * nBasis + j] -= PB[p * nBasis + i] * EE;
    break;
  default:
    r = PA[q * nBasis + j] * EE;
    GA[p * nBasis + i] -= r;
    GA[i * nBasis + p] -= r;
    r = PA[q * nBasis + i] * EE;
    GA[p * nBasis + j] -= r;
    GA[j * nBasis + p] -= r;
    r = PA[p * nBasis + j] * EE;
    GA[q * nBasis + i] -= r;
    GA[i * nBasis + q] -= r;
    r = PA[p * nBasis + i] * EE;
    GA[q * nBasis + j] -= r;
    GA[j * nBasis + q] -= r;
    r = PB[q * nBasis + j] * EE;
    GB[p * nBasis + i] -= r;
    GB[i * nBasis + p] -= r;
    r = PB[q * nBasis + i] * EE;
    GB[p * nBasis + j] -= r;
    GB[j * nBasis + p] -= r;
    r = PB[p * nBasis + j] * EE;
    GB[q * nBasis + i] -= r;
    GB[i * nBasis + q] -= r;
    r = PB[p * nBasis + i] * EE;
    GB[q * nBasis + j] -= r;
    GB[j * nBasis + q] -= r;
    break;
  }
}


x86 assembly (clang, -O0):
<storeK>:
push   %rbp
mov    %rsp,%rbp
mov    0x28(%rbp),%al
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
movsbl 0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x4,%eax
ja     1968 <storeK+0x868>
mov    -0x48(%rbp),%rax
lea    0xeb2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ca8 <storeK+0xba8>
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ca8 <storeK+0xba8>
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ca8 <storeK+0xba8>
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ca8 <storeK+0xba8>
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ca8 <storeK+0xba8>
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    0x20(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
pop    %rbp
ret

x86 assembly (clang, -O2):
<storeK>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x48(%rsp),%r13d
mov    0x40(%rsp),%r11d
mov    0x38(%rsp),%r10d
movsbl 0x50(%rsp),%ebx
add    $0xffffffff,%ebx
cmp    $0x4,%ebx
ja     1166 <storeK+0x66>
lea    0xed3(%rip),%rax
movslq (%rax,%rbx,4),%rbx
add    %rax,%rbx
jmp    *%rbx
imul   %r8d,%r10d
add    %r13d,%r10d
movslq %r10d,%rax
imul   %r8d,%r9d
add    %r11d,%r9d
movslq %r9d,%rbp
movsd  (%rdi,%rbp,8),%xmm1
movsd  (%rdx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
jmp    14fd <storeK+0x3fd>
mov    %r10d,%ebx
imul   %r8d,%ebx
lea    (%rbx,%r13,1),%eax
movslq %eax,%r14
movsd  (%rdx,%r14,8),%xmm1
mulsd  %xmm0,%xmm1
mov    %r9d,%eax
imul   %r8d,%eax
lea    (%rax,%r11,1),%ebp
movslq %ebp,%r15
movsd  (%rdi,%r15,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%r15,8)
add    %r11d,%ebx
imul   %r8d,%r11d
lea    (%r11,%r9,1),%ebp
movslq %ebp,%rbp
movsd  (%rdi,%rbp,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rbp,8)
movslq %ebx,%r12
movsd  (%rdx,%r12,8),%xmm1
mulsd  %xmm0,%xmm1
add    %r13d,%eax
movslq %eax,%rbx
movsd  (%rdi,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rbx,8)
imul   %r8d,%r13d
add    %r13d,%r9d
movslq %r9d,%r8
movsd  (%rdi,%r8,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%r8,8)
movsd  (%rdx,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rdi,%r12,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%r12,8)
add    %r10d,%r11d
movslq %r11d,%r9
movsd  (%rdi,%r9,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%r9,8)
movsd  (%rdx,%r15,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rdi,%r14,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%r14,8)
add    %r10d,%r13d
movslq %r13d,%rax
movsd  (%rdi,%rax,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rax,8)
movsd  (%rcx,%r14,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rsi,%r15,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%r15,8)
movsd  (%rsi,%rbp,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rbp,8)
movsd  (%rcx,%r12,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rsi,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rbx,8)
movsd  (%rsi,%r8,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%r8,8)
movsd  (%rcx,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rsi,%r12,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%r12,8)
movsd  (%rsi,%r9,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%r9,8)
mulsd  (%rcx,%r15,8),%xmm0
movsd  (%rsi,%r14,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%r14,8)
movsd  (%rsi,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
jmp    1510 <storeK+0x410>
imul   %r8d,%r10d
lea    (%r10,%r13,1),%eax
movslq %eax,%r14
imul   %r8d,%r9d
lea    (%r9,%r11,1),%eax
movslq %eax,%r8
movsd  (%rdi,%r8,8),%xmm1
movsd  (%rdx,%r14,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%r8,8)
add    %r11d,%r10d
movslq %r10d,%rbx
add    %r13d,%r9d
movslq %r9d,%rax
movsd  (%rdi,%rax,8),%xmm1
movsd  (%rdx,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  (%rdi,%rbx,8),%xmm1
movsd  (%rdx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
movsd  (%rdi,%r14,8),%xmm1
movsd  (%rdx,%r8,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%r14,8)
movsd  (%rsi,%r8,8),%xmm1
movsd  (%rcx,%r14,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%r8,8)
movsd  (%rsi,%rax,8),%xmm1
movsd  (%rcx,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
movsd  (%rsi,%rbx,8),%xmm1
movsd  (%rcx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rbx,8)
movsd  (%rsi,%r14,8),%xmm1
mulsd  (%rcx,%r8,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%r14,8)
jmp    1510 <storeK+0x410>
mov    %r10d,%eax
imul   %r8d,%eax
lea    (%rax,%r13,1),%ebx
movslq %ebx,%r14
mov    %r9d,%ebx
imul   %r8d,%ebx
lea    (%rbx,%r11,1),%ebp
movslq %ebp,%r15
movsd  (%rdi,%r15,8),%xmm1
movsd  (%rdx,%r14,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%r15,8)
add    %r13d,%ebx
movslq %ebx,%r12
add    %r11d,%eax
movslq %eax,%rbx
movsd  (%rdi,%rbx,8),%xmm1
movsd  (%rdx,%r12,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
imul   %r8d,%r13d
add    %r9d,%r13d
movslq %r13d,%rax
imul   %r8d,%r11d
add    %r10d,%r11d
jmp    14b1 <storeK+0x3b1>
mov    %r10d,%eax
imul   %r8d,%eax
lea    (%rax,%r13,1),%ebx
movslq %ebx,%r14
mov    %r9d,%ebx
imul   %r8d,%ebx
lea    (%rbx,%r11,1),%ebp
movslq %ebp,%r15
movsd  (%rdi,%r15,8),%xmm1
movsd  (%rdx,%r14,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%r15,8)
add    %r11d,%eax
movslq %eax,%r12
add    %r13d,%ebx
movslq %ebx,%rbx
movsd  (%rdi,%rbx,8),%xmm1
movsd  (%rdx,%r12,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
imul   %r8d,%r13d
add    %r10d,%r13d
movslq %r13d,%rax
imul   %r8d,%r11d
add    %r9d,%r11d
movslq %r11d,%rbp
movsd  (%rdi,%rbp,8),%xmm1
movsd  (%rdx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
movsd  (%rsi,%r15,8),%xmm1
movsd  (%rcx,%r14,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%r15,8)
movsd  (%rsi,%rbx,8),%xmm1
movsd  (%rcx,%r12,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rbx,8)
movsd  (%rsi,%rbp,8),%xmm1
mulsd  (%rcx,%rax,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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