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


x86 assembly (clang, -O0):
<storeJK>:
push   %rbp
mov    %rsp,%rbp
mov    0x20(%rbp),%al
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
movsbl 0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x38(%rbp)
sub    $0x4,%eax
ja     1b79 <storeJK+0xa79>
mov    -0x38(%rbp),%rax
lea    0x1ebe(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ff4 <storeJK+0xef4>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ff4 <storeJK+0xef4>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x1ad4(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ff4 <storeJK+0xef4>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x178d(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ff4 <storeJK+0xef4>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ff4 <storeJK+0xef4>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x28(%rbp),%xmm0
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
pop    %rbp
ret

x86 assembly (clang, -O2):
<storeJK>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x40(%rsp),%r12d
mov    0x38(%rsp),%r10d
movsbl 0x48(%rsp),%eax
add    $0xffffffff,%eax
cmp    $0x4,%eax
ja     1224 <storeJK+0x124>
lea    0xed4(%rip),%rbx
movslq (%rbx,%rax,4),%rax
add    %rbx,%rax
jmp    *%rax
mov    %r8d,%ebx
imul   %ecx,%ebx
lea    (%rbx,%r9,1),%eax
movslq %eax,%r15
mov    %r10d,%eax
imul   %ecx,%eax
add    %r12d,%eax
cltq
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rdi,%r15,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%r15,8)
lea    (%rbx,%r10,1),%eax
movslq %eax,%r11
movsd  (%rdi,%r11,8),%xmm2
imul   %ecx,%r9d
lea    (%r9,%r12,1),%eax
movslq %eax,%r14
movsd  (%rdx,%r14,8),%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi,%r11,8)
imul   %r12d,%ecx
add    %r10d,%ecx
movslq %ecx,%rax
movsd  (%rsi,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  (%rdi,%r15,8),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rdi,%r15,8)
add    %r12d,%ebx
movslq %ebx,%rax
movsd  (%rdi,%rax,8),%xmm3
add    %r9d,%r10d
movslq %r10d,%rcx
movsd  (%rdx,%rcx,8),%xmm4
mulsd  %xmm0,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,(%rdi,%rax,8)
add    %r8d,%r9d
movslq %r9d,%rsi
addsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
movsd  (%rdi,%rcx,8),%xmm1
movsd  (%rdx,%rax,8),%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
addsd  (%rdi,%rsi,8),%xmm2
movsd  %xmm2,(%rdi,%rsi,8)
movsd  (%rdi,%r14,8),%xmm1
mulsd  (%rdx,%r11,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%r14,8)
jmp    1644 <storeJK+0x544>
mov    %r8d,%r14d
imul   %ecx,%r14d
lea    (%r14,%r10,1),%eax
movslq %eax,%r15
movsd  (%rdi,%r15,8),%xmm1
mov    %r9d,%r11d
imul   %ecx,%r11d
lea    (%r11,%r12,1),%ebx
movslq %ebx,%rbx
movsd  (%rdx,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%r15,8)
lea    (%r14,%r12,1),%ebp
movslq %ebp,%rbp
movsd  (%rdi,%rbp,8),%xmm1
lea    (%r11,%r10,1),%eax
cltq
movsd  (%rdx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
movsd  (%rdi,%rax,8),%xmm1
movsd  (%rdx,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  (%rdi,%rbx,8),%xmm1
movsd  (%rdx,%r15,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
mov    %r10d,%ebx
imul   %ecx,%ebx
lea    (%rbx,%r8,1),%eax
movslq %eax,%r15
movsd  (%rdi,%r15,8),%xmm1
imul   %r12d,%ecx
lea    (%rcx,%r9,1),%eax
movslq %eax,%r13
movsd  (%rdx,%r13,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%r15,8)
lea    (%rcx,%r8,1),%ebp
movslq %ebp,%rbp
movsd  (%rdi,%rbp,8),%xmm1
lea    (%rbx,%r9,1),%eax
cltq
movsd  (%rdx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
movsd  (%rdi,%rax,8),%xmm1
movsd  (%rdx,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  (%rdi,%r13,8),%xmm1
movsd  (%rdx,%r15,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%r13,8)
addsd  %xmm0,%xmm0
add    %r9d,%r14d
movslq %r14d,%rax
add    %r12d,%ebx
movslq %ebx,%rdx
movsd  (%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rdi,%rax,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rax,8)
add    %r8d,%r11d
movslq %r11d,%rbp
addsd  (%rdi,%rbp,8),%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
mulsd  (%rsi,%rax,8),%xmm0
movsd  (%rdi,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
add    %r10d,%ecx
movslq %ecx,%rax
addsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
jmp    1644 <storeJK+0x544>
mov    %r8d,%ebx
imul   %ecx,%ebx
lea    (%rbx,%r9,1),%eax
movslq %eax,%r14
mov    %r10d,%r15d
imul   %ecx,%r15d
lea    (%r15,%r12,1),%eax
movslq %eax,%r11
movsd  (%rsi,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rdi,%r14,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%r14,8)
lea    (%rbx,%r10,1),%eax
movslq %eax,%r13
movsd  (%rdi,%r13,8),%xmm2
mov    %r9d,%ebp
imul   %ecx,%ebp
lea    (%r12,%rbp,1),%eax
cltq
movsd  (%rdx,%rax,8),%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi,%r13,8)
lea    0x0(%rbp,%r8,1),%eax
cltq
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    %r10d,%ebp
movslq %ebp,%rax
movsd  (%rdi,%rax,8),%xmm1
add    %r12d,%ebx
movslq %ebx,%rbp
movsd  (%rdx,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
lea    (%r15,%r8,1),%eax
cltq
movsd  (%rdi,%rax,8),%xmm1
imul   %ecx,%r12d
lea    (%r12,%r9,1),%ecx
movslq %ecx,%rcx
movsd  (%rdx,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    %r9d,%r15d
movslq %r15d,%rax
movsd  (%rdi,%rax,8),%xmm1
add    %r8d,%r12d
movslq %r12d,%rcx
movsd  (%rdx,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  (%rsi,%r14,8),%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%r11,8),%xmm1
movsd  %xmm1,(%rdi,%r11,8)
jmp    1644 <storeJK+0x544>
mov    %r8d,%eax
imul   %ecx,%eax
lea    (%rax,%r10,1),%ebp
movslq %ebp,%r11
movsd  (%rdi,%r11,8),%xmm1
mov    %r9d,%ebx
imul   %ecx,%ebx
lea    (%rbx,%r12,1),%ebp
movslq %ebp,%rbp
movsd  (%rdx,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%r11,8)
lea    (%rax,%r12,1),%ebp
movslq %ebp,%rbp
movsd  (%rdi,%rbp,8),%xmm1
add    %r10d,%ebx
movslq %ebx,%rbx
movsd  (%rdx,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
mov    %r10d,%ebx
imul   %ecx,%ebx
lea    (%rbx,%r12,1),%ebp
movslq %ebp,%rbp
add    %r9d,%eax
movslq %eax,%r11
movsd  (%rsi,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rdi,%rbp,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rbp,8)
lea    (%rbx,%r8,1),%eax
cltq
movsd  (%rdi,%rax,8),%xmm2
imul   %ecx,%r12d
lea    (%r12,%r9,1),%ecx
movslq %ecx,%rcx
movsd  (%rdx,%rcx,8),%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi,%rax,8)
movsd  (%rsi,%rbp,8),%xmm2
addsd  %xmm2,%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdi,%r11,8),%xmm2
movsd  %xmm2,(%rdi,%r11,8)
add    %r12d,%r10d
movslq %r10d,%rax
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    %r8d,%r12d
movslq %r12d,%rax
movsd  (%rdi,%rax,8),%xmm1
add    %r9d,%ebx
movslq %ebx,%rcx
jmp    1636 <storeJK+0x536>
mov    %r8d,%eax
imul   %ecx,%eax
lea    (%rax,%r9,1),%ebx
movslq %ebx,%r11
add    %r10d,%eax
imul   %ecx,%r10d
lea    (%r10,%r12,1),%ebx
movslq %ebx,%rbx
movsd  (%rsi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%r11,8),%xmm1
movsd  %xmm1,(%rdi,%r11,8)
cltq
movsd  (%rdi,%rax,8),%xmm1
mov    %r9d,%ebp
imul   %ecx,%ebp
add    %r12d,%ebp
movslq %ebp,%rbp
movsd  (%rdx,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  (%rsi,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rbx,8),%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
add    %r8d,%r10d
movslq %r10d,%rax
movsd  (%rdi,%rax,8),%xmm1
imul   %ecx,%r12d
add    %r9d,%r12d
movslq %r12d,%rcx
jmp    1636 <storeJK+0x536>
imul   %ecx,%r8d
lea    (%r8,%r9,1),%eax
cltq
add    %r10d,%r8d
imul   %ecx,%r10d
add    %r12d,%r10d
movslq %r10d,%rbx
movsd  (%rsi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movslq %r8d,%rax
movsd  (%rdi,%rax,8),%xmm1
imul   %ecx,%r9d
add    %r12d,%r9d
movslq %r9d,%rcx
mulsd  (%rdx,%rcx,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @storeJK(double* noalias %0, double* noalias %1, double* noalias %2, i32 %3, double %4, i32 %5, i32 %6, i32 %7, i32 %8, i8 signext %9) {
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca i32
%15 = alloca double
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i8
store double* %0, double** %11
store double* %1, double** %12
store double* %2, double** %13
store i32 %3, i32* %14
store double %4, double* %15
store i32 %5, i32* %16
store i32 %6, i32* %17
store i32 %7, i32* %18
store i32 %8, i32* %19
store i8 %9, i8* %20
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
switch i32 %22, label %829 [
i32 5, label %23
i32 4, label %81
i32 3, label %196
i32 2, label %398
i32 1, label %600
]
23: ; preds = %10
%24 = load double*, double** %11
%25 = load i32, i32* %14
%26 = load i32, i32* %16
%27 = mul nsw i32 %25, %26
%28 = load i32, i32* %17
%29 = add nsw i32 %27, %28
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds double, double* %24, i64 %30
%32 = load double, double* %31
%33 = load double*, double** %12
%34 = load i32, i32* %14
%35 = load i32, i32* %18
%36 = mul nsw i32 %34, %35
%37 = load i32, i32* %19
%38 = add nsw i32 %36, %37
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %33, i64 %39
%41 = load double, double* %40
%42 = load double, double* %15
%43 = call double @llvm.fmuladd.f64(double %41, double %42, double %32)
%44 = load double*, double** %11
%45 = load i32, i32* %14
%46 = load i32, i32* %16
%47 = mul nsw i32 %45, %46
%48 = load i32, i32* %17
%49 = add nsw i32 %47, %48
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %44, i64 %50
store double %43, double* %51
%52 = load double*, double** %11
%53 = load i32, i32* %14
%54 = load i32, i32* %16
%55 = mul nsw i32 %53, %54
%56 = load i32, i32* %18
%57 = add nsw i32 %55, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %52, i64 %58
%60 = load double, double* %59
%61 = load double*, double** %13
%62 = load i32, i32* %14
%63 = load i32, i32* %17
%64 = mul nsw i32 %62, %63
%65 = load i32, i32* %19
%66 = add nsw i32 %64, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %61, i64 %67
%69 = load double, double* %68
%70 = load double, double* %15
%71 = fneg double %69
%72 = call double @llvm.fmuladd.f64(double %71, double %70, double %60)
%73 = load double*, double** %11
%74 = load i32, i32* %14
%75 = load i32, i32* %16
%76 = mul nsw i32 %74, %75
%77 = load i32, i32* %18
%78 = add nsw i32 %76, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %73, i64 %79
store double %72, double* %80
br label %1177
81: ; preds = %10
%82 = load double*, double** %11
%83 = load i32, i32* %14
%84 = load i32, i32* %16
%85 = mul nsw i32 %83, %84
%86 = load i32, i32* %17
%87 = add nsw i32 %85, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %82, i64 %88
%90 = load double, double* %89
%91 = load double*, double** %12
%92 = load i32, i32* %14
%93 = load i32, i32* %18
%94 = mul nsw i32 %92, %93
%95 = load i32, i32* %19
%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* %15
%101 = call double @llvm.fmuladd.f64(double %99, double %100, double %90)
%102 = load double*, double** %11
%103 = load i32, i32* %14
%104 = load i32, i32* %16
%105 = mul nsw i32 %103, %104
%106 = load i32, i32* %17
%107 = add nsw i32 %105, %106
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %102, i64 %108
store double %101, double* %109
%110 = load double*, double** %11
%111 = load i32, i32* %14
%112 = load i32, i32* %16
%113 = mul nsw i32 %111, %112
%114 = load i32, i32* %18
%115 = add nsw i32 %113, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %110, i64 %116
%118 = load double, double* %117
%119 = load double*, double** %13
%120 = load i32, i32* %14
%121 = load i32, i32* %17
%122 = mul nsw i32 %120, %121
%123 = load i32, i32* %19
%124 = add nsw i32 %122, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %119, i64 %125
%127 = load double, double* %126
%128 = load double, double* %15
%129 = fneg double %127
%130 = call double @llvm.fmuladd.f64(double %129, double %128, double %118)
%131 = load double*, double** %11
%132 = load i32, i32* %14
%133 = load i32, i32* %16
%134 = mul nsw i32 %132, %133
%135 = load i32, i32* %18
%136 = add nsw i32 %134, %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %131, i64 %137
store double %130, double* %138
%139 = load double*, double** %11
%140 = load i32, i32* %14
%141 = load i32, i32* %18
%142 = mul nsw i32 %140, %141
%143 = load i32, i32* %19
%144 = add nsw i32 %142, %143
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds double, double* %139, i64 %145
%147 = load double, double* %146
%148 = load double*, double** %12
%149 = load i32, i32* %14
%150 = load i32, i32* %16
%151 = mul nsw i32 %149, %150
%152 = load i32, i32* %17
%153 = add nsw i32 %151, %152
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds double, double* %148, i64 %154
%156 = load double, double* %155
%157 = load double, double* %15
%158 = call double @llvm.fmuladd.f64(double %156, double %157, double %147)
%159 = load double*, double** %11
%160 = load i32, i32* %14
%161 = load i32, i32* %18
%162 = mul nsw i32 %160, %161
%163 = load i32, i32* %19
%164 = add nsw i32 %162, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %159, i64 %165
store double %158, double* %166
%167 = load double*, double** %11
%168 = load i32, i32* %14
%169 = load i32, i32* %18
%170 = mul nsw i32 %168, %169
%171 = load i32, i32* %16
%172 = add nsw i32 %170, %171
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %167, i64 %173
%175 = load double, double* %174
%176 = load double*, double** %13
%177 = load i32, i32* %14
%178 = load i32, i32* %19
%179 = mul nsw i32 %177, %178
%180 = load i32, i32* %17
%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* %15
%186 = fneg double %184
%187 = call double @llvm.fmuladd.f64(double %186, double %185, double %175)
%188 = load double*, double** %11
%189 = load i32, i32* %14
%190 = load i32, i32* %18
%191 = mul nsw i32 %189, %190
%192 = load i32, i32* %16
%193 = add nsw i32 %191, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %188, i64 %194
store double %187, double* %195
br label %1177
196: ; preds = %10
%197 = load double*, double** %11
%198 = load i32, i32* %14
%199 = load i32, i32* %16
%200 = mul nsw i32 %198, %199
%201 = load i32, i32* %18
%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** %13
%207 = load i32, i32* %14
%208 = load i32, i32* %17
%209 = mul nsw i32 %207, %208
%210 = load i32, i32* %19
%211 = add nsw i32 %209, %210
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds double, double* %206, i64 %212
%214 = load double, double* %213
%215 = load double, double* %15
%216 = fneg double %214
%217 = call double @llvm.fmuladd.f64(double %216, double %215, double %205)
%218 = load double*, double** %11
%219 = load i32, i32* %14
%220 = load i32, i32* %16
%221 = mul nsw i32 %219, %220
%222 = load i32, i32* %18
%223 = add nsw i32 %221, %222
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds double, double* %218, i64 %224
store double %217, double* %225
%226 = load double*, double** %11
%227 = load i32, i32* %14
%228 = load i32, i32* %16
%229 = mul nsw i32 %227, %228
%230 = load i32, i32* %19
%231 = add nsw i32 %229, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds double, double* %226, i64 %232
%234 = load double, double* %233
%235 = load double*, double** %13
%236 = load i32, i32* %14
%237 = load i32, i32* %17
%238 = mul nsw i32 %236, %237
%239 = load i32, i32* %18
%240 = add nsw i32 %238, %239
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds double, double* %235, i64 %241
%243 = load double, double* %242
%244 = load double, double* %15
%245 = fneg double %243
%246 = call double @llvm.fmuladd.f64(double %245, double %244, double %234)
%247 = load double*, double** %11
%248 = load i32, i32* %14
%249 = load i32, i32* %16
%250 = mul nsw i32 %248, %249
%251 = load i32, i32* %19
%252 = add nsw i32 %250, %251
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %247, i64 %253
store double %246, double* %254
%255 = load double*, double** %11
%256 = load i32, i32* %14
%257 = load i32, i32* %18
%258 = mul nsw i32 %256, %257
%259 = load i32, i32* %19
%260 = add nsw i32 %258, %259
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double, double* %255, i64 %261
%263 = load double, double* %262
%264 = load double*, double** %12
%265 = load i32, i32* %14
%266 = load i32, i32* %16
%267 = mul nsw i32 %265, %266
%268 = load i32, i32* %17
%269 = add nsw i32 %267, %268
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %264, i64 %270
%272 = load double, double* %271
%273 = load double, double* %15
%274 = call double @llvm.fmuladd.f64(double %272, double %273, double %263)
%275 = load double*, double** %11
%276 = load i32, i32* %14
%277 = load i32, i32* %18
%278 = mul nsw i32 %276, %277
%279 = load i32, i32* %19
%280 = add nsw i32 %278, %279
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds double, double* %275, i64 %281
store double %274, double* %282
%283 = load double*, double** %11
%284 = load i32, i32* %14
%285 = load i32, i32* %18
%286 = mul nsw i32 %284, %285
%287 = load i32, i32* %16
%288 = add nsw i32 %286, %287
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %283, i64 %289
%291 = load double, double* %290
%292 = load double*, double** %13
%293 = load i32, i32* %14
%294 = load i32, i32* %19
%295 = mul nsw i32 %293, %294
%296 = load i32, i32* %17
%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 = load double, double* %15
%302 = fneg double %300
%303 = call double @llvm.fmuladd.f64(double %302, double %301, double %291)
%304 = load double*, double** %11
%305 = load i32, i32* %14
%306 = load i32, i32* %18
%307 = mul nsw i32 %305, %306
%308 = load i32, i32* %16
%309 = add nsw i32 %307, %308
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds double, double* %304, i64 %310
store double %303, double* %311
%312 = load double*, double** %11
%313 = load i32, i32* %14
%314 = load i32, i32* %16
%315 = mul nsw i32 %313, %314
%316 = load i32, i32* %17
%317 = add nsw i32 %315, %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %312, i64 %318
%320 = load double, double* %319
%321 = load double*, double** %12
%322 = load i32, i32* %14
%323 = load i32, i32* %18
%324 = mul nsw i32 %322, %323
%325 = load i32, i32* %19
%326 = add nsw i32 %324, %325
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds double, double* %321, i64 %327
%329 = load double, double* %328
%330 = fmul double 2.000000e+00, %329
%331 = load double, double* %15
%332 = call double @llvm.fmuladd.f64(double %330, double %331, double %320)
%333 = load double*, double** %11
%334 = load i32, i32* %14
%335 = load i32, i32* %16
%336 = mul nsw i32 %334, %335
%337 = load i32, i32* %17
%338 = add nsw i32 %336, %337
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %333, i64 %339
store double %332, double* %340
%341 = load double*, double** %11
%342 = load i32, i32* %14
%343 = load i32, i32* %19
%344 = mul nsw i32 %342, %343
%345 = load i32, i32* %18
%346 = add nsw i32 %344, %345
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds double, double* %341, i64 %347
%349 = load double, double* %348
%350 = load double*, double** %12
%351 = load i32, i32* %14
%352 = load i32, i32* %16
%353 = mul nsw i32 %351, %352
%354 = load i32, i32* %17
%355 = add nsw i32 %353, %354
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds double, double* %350, i64 %356
%358 = load double, double* %357
%359 = load double, double* %15
%360 = call double @llvm.fmuladd.f64(double %358, double %359, double %349)
%361 = load double*, double** %11
%362 = load i32, i32* %14
%363 = load i32, i32* %19
%364 = mul nsw i32 %362, %363
%365 = load i32, i32* %18
%366 = add nsw i32 %364, %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %361, i64 %367
store double %360, double* %368
%369 = load double*, double** %11
%370 = load i32, i32* %14
%371 = load i32, i32* %19
%372 = mul nsw i32 %370, %371
%373 = load i32, i32* %16
%374 = add nsw i32 %372, %373
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds double, double* %369, i64 %375
%377 = load double, double* %376
%378 = load double*, double** %13
%379 = load i32, i32* %14
%380 = load i32, i32* %18
%381 = mul nsw i32 %379, %380
%382 = load i32, i32* %17
%383 = add nsw i32 %381, %382
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds double, double* %378, i64 %384
%386 = load double, double* %385
%387 = load double, double* %15
%388 = fneg double %386
%389 = call double @llvm.fmuladd.f64(double %388, double %387, double %377)
%390 = load double*, double** %11
%391 = load i32, i32* %14
%392 = load i32, i32* %19
%393 = mul nsw i32 %391, %392
%394 = load i32, i32* %16
%395 = add nsw i32 %393, %394
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double, double* %390, i64 %396
store double %389, double* %397
br label %1177
398: ; preds = %10
%399 = load double*, double** %11
%400 = load i32, i32* %14
%401 = load i32, i32* %16
%402 = mul nsw i32 %400, %401
%403 = load i32, i32* %17
%404 = add nsw i32 %402, %403
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds double, double* %399, i64 %405
%407 = load double, double* %406
%408 = load double*, double** %12
%409 = load i32, i32* %14
%410 = load i32, i32* %18
%411 = mul nsw i32 %409, %410
%412 = load i32, i32* %19
%413 = add nsw i32 %411, %412
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %408, i64 %414
%416 = load double, double* %415
%417 = load double, double* %15
%418 = call double @llvm.fmuladd.f64(double %416, double %417, double %407)
%419 = load double*, double** %11
%420 = load i32, i32* %14
%421 = load i32, i32* %16
%422 = mul nsw i32 %420, %421
%423 = load i32, i32* %17
%424 = add nsw i32 %422, %423
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds double, double* %419, i64 %425
store double %418, double* %426
%427 = load double*, double** %11
%428 = load i32, i32* %14
%429 = load i32, i32* %16
%430 = mul nsw i32 %428, %429
%431 = load i32, i32* %18
%432 = add nsw i32 %430, %431
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %427, i64 %433
%435 = load double, double* %434
%436 = load double*, double** %13
%437 = load i32, i32* %14
%438 = load i32, i32* %17
%439 = mul nsw i32 %437, %438
%440 = load i32, i32* %19
%441 = add nsw i32 %439, %440
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %436, i64 %442
%444 = load double, double* %443
%445 = load double, double* %15
%446 = fneg double %444
%447 = call double @llvm.fmuladd.f64(double %446, double %445, double %435)
%448 = load double*, double** %11
%449 = load i32, i32* %14
%450 = load i32, i32* %16
%451 = mul nsw i32 %449, %450
%452 = load i32, i32* %18
%453 = add nsw i32 %451, %452
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds double, double* %448, i64 %454
store double %447, double* %455
%456 = load double*, double** %11
%457 = load i32, i32* %14
%458 = load i32, i32* %17
%459 = mul nsw i32 %457, %458
%460 = load i32, i32* %16
%461 = add nsw i32 %459, %460
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds double, double* %456, i64 %462
%464 = load double, double* %463
%465 = load double*, double** %12
%466 = load i32, i32* %14
%467 = load i32, i32* %18
%468 = mul nsw i32 %466, %467
%469 = load i32, i32* %19
%470 = add nsw i32 %468, %469
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds double, double* %465, i64 %471
%473 = load double, double* %472
%474 = load double, double* %15
%475 = call double @llvm.fmuladd.f64(double %473, double %474, double %464)
%476 = load double*, double** %11
%477 = load i32, i32* %14
%478 = load i32, i32* %17
%479 = mul nsw i32 %477, %478
%480 = load i32, i32* %16
%481 = add nsw i32 %479, %480
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %476, i64 %482
store double %475, double* %483
%484 = load double*, double** %11
%485 = load i32, i32* %14
%486 = load i32, i32* %17
%487 = mul nsw i32 %485, %486
%488 = load i32, i32* %18
%489 = add nsw i32 %487, %488
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds double, double* %484, i64 %490
%492 = load double, double* %491
%493 = load double*, double** %13
%494 = load i32, i32* %14
%495 = load i32, i32* %16
%496 = mul nsw i32 %494, %495
%497 = load i32, i32* %19
%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* %15
%503 = fneg double %501
%504 = call double @llvm.fmuladd.f64(double %503, double %502, double %492)
%505 = load double*, double** %11
%506 = load i32, i32* %14
%507 = load i32, i32* %17
%508 = mul nsw i32 %506, %507
%509 = load i32, i32* %18
%510 = add nsw i32 %508, %509
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds double, double* %505, i64 %511
store double %504, double* %512
%513 = load double*, double** %11
%514 = load i32, i32* %14
%515 = load i32, i32* %18
%516 = mul nsw i32 %514, %515
%517 = load i32, i32* %16
%518 = add nsw i32 %516, %517
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds double, double* %513, i64 %519
%521 = load double, double* %520
%522 = load double*, double** %13
%523 = load i32, i32* %14
%524 = load i32, i32* %19
%525 = mul nsw i32 %523, %524
%526 = load i32, i32* %17
%527 = add nsw i32 %525, %526
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double, double* %522, i64 %528
%530 = load double, double* %529
%531 = load double, double* %15
%532 = fneg double %530
%533 = call double @llvm.fmuladd.f64(double %532, double %531, double %521)
%534 = load double*, double** %11
%535 = load i32, i32* %14
%536 = load i32, i32* %18
%537 = mul nsw i32 %535, %536
%538 = load i32, i32* %16
%539 = add nsw i32 %537, %538
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double, double* %534, i64 %540
store double %533, double* %541
%542 = load double*, double** %11
%543 = load i32, i32* %14
%544 = load i32, i32* %18
%545 = mul nsw i32 %543, %544
%546 = load i32, i32* %17
%547 = add nsw i32 %545, %546
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds double, double* %542, i64 %548
%550 = load double, double* %549
%551 = load double*, double** %13
%552 = load i32, i32* %14
%553 = load i32, i32* %19
%554 = mul nsw i32 %552, %553
%555 = load i32, i32* %16
%556 = add nsw i32 %554, %555
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds double, double* %551, i64 %557
%559 = load double, double* %558
%560 = load double, double* %15
%561 = fneg double %559
%562 = call double @llvm.fmuladd.f64(double %561, double %560, double %550)
%563 = load double*, double** %11
%564 = load i32, i32* %14
%565 = load i32, i32* %18
%566 = mul nsw i32 %564, %565
%567 = load i32, i32* %17
%568 = add nsw i32 %566, %567
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds double, double* %563, i64 %569
store double %562, double* %570
%571 = load double*, double** %11
%572 = load i32, i32* %14
%573 = load i32, i32* %18
%574 = mul nsw i32 %572, %573
%575 = load i32, i32* %19
%576 = add nsw i32 %574, %575
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds double, double* %571, i64 %577
%579 = load double, double* %578
%580 = load double*, double** %12
%581 = load i32, i32* %14
%582 = load i32, i32* %16
%583 = mul nsw i32 %581, %582
%584 = load i32, i32* %17
%585 = add nsw i32 %583, %584
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds double, double* %580, i64 %586
%588 = load double, double* %587
%589 = fmul double 2.000000e+00, %588
%590 = load double, double* %15
%591 = call double @llvm.fmuladd.f64(double %589, double %590, double %579)
%592 = load double*, double** %11
%593 = load i32, i32* %14
%594 = load i32, i32* %18
%595 = mul nsw i32 %593, %594
%596 = load i32, i32* %19
%597 = add nsw i32 %595, %596
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds double, double* %592, i64 %598
store double %591, double* %599
br label %1177
600: ; preds = %10
%601 = load double*, double** %11
%602 = load i32, i32* %14
%603 = load i32, i32* %16
%604 = mul nsw i32 %602, %603
%605 = load i32, i32* %17
%606 = add nsw i32 %604, %605
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds double, double* %601, i64 %607
%609 = load double, double* %608
%610 = load double*, double** %12
%611 = load i32, i32* %14
%612 = load i32, i32* %18
%613 = mul nsw i32 %611, %612
%614 = load i32, i32* %19
%615 = add nsw i32 %613, %614
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds double, double* %610, i64 %616
%618 = load double, double* %617
%619 = load double, double* %15
%620 = call double @llvm.fmuladd.f64(double %618, double %619, double %609)
%621 = load double*, double** %11
%622 = load i32, i32* %14
%623 = load i32, i32* %16
%624 = mul nsw i32 %622, %623
%625 = load i32, i32* %17
%626 = add nsw i32 %624, %625
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds double, double* %621, i64 %627
store double %620, double* %628
%629 = load double*, double** %11
%630 = load i32, i32* %14
%631 = load i32, i32* %16
%632 = mul nsw i32 %630, %631
%633 = load i32, i32* %18
%634 = add nsw i32 %632, %633
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds double, double* %629, i64 %635
%637 = load double, double* %636
%638 = load double*, double** %13
%639 = load i32, i32* %14
%640 = load i32, i32* %17
%641 = mul nsw i32 %639, %640
%642 = load i32, i32* %19
%643 = add nsw i32 %641, %642
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds double, double* %638, i64 %644
%646 = load double, double* %645
%647 = load double, double* %15
%648 = fneg double %646
%649 = call double @llvm.fmuladd.f64(double %648, double %647, double %637)
%650 = load double*, double** %11
%651 = load i32, i32* %14
%652 = load i32, i32* %16
%653 = mul nsw i32 %651, %652
%654 = load i32, i32* %18
%655 = add nsw i32 %653, %654
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds double, double* %650, i64 %656
store double %649, double* %657
%658 = load double*, double** %11
%659 = load i32, i32* %14
%660 = load i32, i32* %16
%661 = mul nsw i32 %659, %660
%662 = load i32, i32* %17
%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 = load double*, double** %12
%668 = load i32, i32* %14
%669 = load i32, i32* %19
%670 = mul nsw i32 %668, %669
%671 = load i32, i32* %18
%672 = add nsw i32 %670, %671
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds double, double* %667, i64 %673
%675 = load double, double* %674
%676 = load double, double* %15
%677 = call double @llvm.fmuladd.f64(double %675, double %676, double %666)
%678 = load double*, double** %11
%679 = load i32, i32* %14
%680 = load i32, i32* %16
%681 = mul nsw i32 %679, %680
%682 = load i32, i32* %17
%683 = add nsw i32 %681, %682
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds double, double* %678, i64 %684
store double %677, double* %685
%686 = load double*, double** %11
%687 = load i32, i32* %14
%688 = load i32, i32* %16
%689 = mul nsw i32 %687, %688
%690 = load i32, i32* %19
%691 = add nsw i32 %689, %690
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds double, double* %686, i64 %692
%694 = load double, double* %693
%695 = load double*, double** %13
%696 = load i32, i32* %14
%697 = load i32, i32* %17
%698 = mul nsw i32 %696, %697
%699 = load i32, i32* %18
%700 = add nsw i32 %698, %699
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds double, double* %695, i64 %701
%703 = load double, double* %702
%704 = load double, double* %15
%705 = fneg double %703
%706 = call double @llvm.fmuladd.f64(double %705, double %704, double %694)
%707 = load double*, double** %11
%708 = load i32, i32* %14
%709 = load i32, i32* %16
%710 = mul nsw i32 %708, %709
%711 = load i32, i32* %19
%712 = add nsw i32 %710, %711
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds double, double* %707, i64 %713
store double %706, double* %714
%715 = load double*, double** %11
%716 = load i32, i32* %14
%717 = load i32, i32* %17
%718 = mul nsw i32 %716, %717
%719 = load i32, i32* %16
%720 = add nsw i32 %718, %719
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds double, double* %715, i64 %721
%723 = load double, double* %722
%724 = load double*, double** %12
%725 = load i32, i32* %14
%726 = load i32, i32* %18
%727 = mul nsw i32 %725, %726
%728 = load i32, i32* %19
%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 = load double, double* %15
%734 = call double @llvm.fmuladd.f64(double %732, double %733, double %723)
%735 = load double*, double** %11
%736 = load i32, i32* %14
%737 = load i32, i32* %17
%738 = mul nsw i32 %736, %737
%739 = load i32, i32* %16
%740 = add nsw i32 %738, %739
%741 = sext i32 %740 to i64
%742 = getelementptr inbounds double, double* %735, i64 %741
store double %734, double* %742
%743 = load double*, double** %11
%744 = load i32, i32* %14
%745 = load i32, i32* %17
%746 = mul nsw i32 %744, %745
%747 = load i32, i32* %18
%748 = add nsw i32 %746, %747
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds double, double* %743, i64 %749
%751 = load double, double* %750
%752 = load double*, double** %13
%753 = load i32, i32* %14
%754 = load i32, i32* %16
%755 = mul nsw i32 %753, %754
%756 = load i32, i32* %19
%757 = add nsw i32 %755, %756
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds double, double* %752, i64 %758
%760 = load double, double* %759
%761 = load double, double* %15
%762 = fneg double %760
%763 = call double @llvm.fmuladd.f64(double %762, double %761, double %751)
%764 = load double*, double** %11
%765 = load i32, i32* %14
%766 = load i32, i32* %17
%767 = mul nsw i32 %765, %766
%768 = load i32, i32* %18
%769 = add nsw i32 %767, %768
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds double, double* %764, i64 %770
store double %763, double* %771
%772 = load double*, double** %11
%773 = load i32, i32* %14
%774 = load i32, i32* %17
%775 = mul nsw i32 %773, %774
%776 = load i32, i32* %16
%777 = add nsw i32 %775, %776
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds double, double* %772, i64 %778
%780 = load double, double* %779
%781 = load double*, double** %12
%782 = load i32, i32* %14
%783 = load i32, i32* %19
%784 = mul nsw i32 %782, %783
%785 = load i32, i32* %18
%786 = add nsw i32 %784, %785
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds double, double* %781, i64 %787
%789 = load double, double* %788
%790 = load double, double* %15
%791 = call double @llvm.fmuladd.f64(double %789, double %790, double %780)
%792 = load double*, double** %11
%793 = load i32, i32* %14
%794 = load i32, i32* %17
%795 = mul nsw i32 %793, %794
%796 = load i32, i32* %16
%797 = add nsw i32 %795, %796
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds double, double* %792, i64 %798
store double %791, double* %799
%800 = load double*, double** %11
%801 = load i32, i32* %14
%802 = load i32, i32* %17
%803 = mul nsw i32 %801, %802
%804 = load i32, i32* %19
%805 = add nsw i32 %803, %804
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds double, double* %800, i64 %806
%808 = load double, double* %807
%809 = load double*, double** %13
%810 = load i32, i32* %14
%811 = load i32, i32* %16
%812 = mul nsw i32 %810, %811
%813 = load i32, i32* %18
%814 = add nsw i32 %812, %813
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds double, double* %809, i64 %815
%817 = load double, double* %816
%818 = load double, double* %15
%819 = fneg double %817
%820 = call double @llvm.fmuladd.f64(double %819, double %818, double %808)
%821 = load double*, double** %11
%822 = load i32, i32* %14
%823 = load i32, i32* %17
%824 = mul nsw i32 %822, %823
%825 = load i32, i32* %19
%826 = add nsw i32 %824, %825
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds double, double* %821, i64 %827
store double %820, double* %828
br label %1177
829: ; preds = %10
%830 = load double*, double** %11
%831 = load i32, i32* %14
%832 = load i32, i32* %16
%833 = mul nsw i32 %831, %832
%834 = load i32, i32* %18
%835 = add nsw i32 %833, %834
%836 = sext i32 %835 to i64
%837 = getelementptr inbounds double, double* %830, i64 %836
%838 = load double, double* %837
%839 = load double*, double** %13
%840 = load i32, i32* %14
%841 = load i32, i32* %17
%842 = mul nsw i32 %840, %841
%843 = load i32, i32* %19
%844 = add nsw i32 %842, %843
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds double, double* %839, i64 %845
%847 = load double, double* %846
%848 = load double, double* %15
%849 = fneg double %847
%850 = call double @llvm.fmuladd.f64(double %849, double %848, double %838)
%851 = load double*, double** %11
%852 = load i32, i32* %14
%853 = load i32, i32* %16
%854 = mul nsw i32 %852, %853
%855 = load i32, i32* %18
%856 = add nsw i32 %854, %855
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds double, double* %851, i64 %857
store double %850, double* %858
%859 = load double*, double** %11
%860 = load i32, i32* %14
%861 = load i32, i32* %16
%862 = mul nsw i32 %860, %861
%863 = load i32, i32* %19
%864 = add nsw i32 %862, %863
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds double, double* %859, i64 %865
%867 = load double, double* %866
%868 = load double*, double** %13
%869 = load i32, i32* %14
%870 = load i32, i32* %17
%871 = mul nsw i32 %869, %870
%872 = load i32, i32* %18
%873 = add nsw i32 %871, %872
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds double, double* %868, i64 %874
%876 = load double, double* %875
%877 = load double, double* %15
%878 = fneg double %876
%879 = call double @llvm.fmuladd.f64(double %878, double %877, double %867)
%880 = load double*, double** %11
%881 = load i32, i32* %14
%882 = load i32, i32* %16
%883 = mul nsw i32 %881, %882
%884 = load i32, i32* %19
%885 = add nsw i32 %883, %884
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds double, double* %880, i64 %886
store double %879, double* %887
%888 = load double*, double** %11
%889 = load i32, i32* %14
%890 = load i32, i32* %17
%891 = mul nsw i32 %889, %890
%892 = load i32, i32* %18
%893 = add nsw i32 %891, %892
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds double, double* %888, i64 %894
%896 = load double, double* %895
%897 = load double*, double** %13
%898 = load i32, i32* %14
%899 = load i32, i32* %16
%900 = mul nsw i32 %898, %899
%901 = load i32, i32* %19
%902 = add nsw i32 %900, %901
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds double, double* %897, i64 %903
%905 = load double, double* %904
%906 = load double, double* %15
%907 = fneg double %905
%908 = call double @llvm.fmuladd.f64(double %907, double %906, double %896)
%909 = load double*, double** %11
%910 = load i32, i32* %14
%911 = load i32, i32* %17
%912 = mul nsw i32 %910, %911
%913 = load i32, i32* %18
%914 = add nsw i32 %912, %913
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds double, double* %909, i64 %915
store double %908, double* %916
%917 = load double*, double** %11
%918 = load i32, i32* %14
%919 = load i32, i32* %17
%920 = mul nsw i32 %918, %919
%921 = load i32, i32* %19
%922 = add nsw i32 %920, %921
%923 = sext i32 %922 to i64
%924 = getelementptr inbounds double, double* %917, i64 %923
%925 = load double, double* %924
%926 = load double*, double** %13
%927 = load i32, i32* %14
%928 = load i32, i32* %16
%929 = mul nsw i32 %927, %928
%930 = load i32, i32* %18
%931 = add nsw i32 %929, %930
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds double, double* %926, i64 %932
%934 = load double, double* %933
%935 = load double, double* %15
%936 = fneg double %934
%937 = call double @llvm.fmuladd.f64(double %936, double %935, double %925)
%938 = load double*, double** %11
%939 = load i32, i32* %14
%940 = load i32, i32* %17
%941 = mul nsw i32 %939, %940
%942 = load i32, i32* %19
%943 = add nsw i32 %941, %942
%944 = sext i32 %943 to i64
%945 = getelementptr inbounds double, double* %938, i64 %944
store double %937, double* %945
%946 = load double*, double** %11
%947 = load i32, i32* %14
%948 = load i32, i32* %18
%949 = mul nsw i32 %947, %948
%950 = load i32, i32* %16
%951 = add nsw i32 %949, %950
%952 = sext i32 %951 to i64
%953 = getelementptr inbounds double, double* %946, i64 %952
%954 = load double, double* %953
%955 = load double*, double** %13
%956 = load i32, i32* %14
%957 = load i32, i32* %19
%958 = mul nsw i32 %956, %957
%959 = load i32, i32* %17
%960 = add nsw i32 %958, %959
%961 = sext i32 %960 to i64
%962 = getelementptr inbounds double, double* %955, i64 %961
%963 = load double, double* %962
%964 = load double, double* %15
%965 = fneg double %963
%966 = call double @llvm.fmuladd.f64(double %965, double %964, double %954)
%967 = load double*, double** %11
%968 = load i32, i32* %14
%969 = load i32, i32* %18
%970 = mul nsw i32 %968, %969
%971 = load i32, i32* %16
%972 = add nsw i32 %970, %971
%973 = sext i32 %972 to i64
%974 = getelementptr inbounds double, double* %967, i64 %973
store double %966, double* %974
%975 = load double*, double** %11
%976 = load i32, i32* %14
%977 = load i32, i32* %19
%978 = mul nsw i32 %976, %977
%979 = load i32, i32* %16
%980 = add nsw i32 %978, %979
%981 = sext i32 %980 to i64
%982 = getelementptr inbounds double, double* %975, i64 %981
%983 = load double, double* %982
%984 = load double*, double** %13
%985 = load i32, i32* %14
%986 = load i32, i32* %18
%987 = mul nsw i32 %985, %986
%988 = load i32, i32* %17
%989 = add nsw i32 %987, %988
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds double, double* %984, i64 %990
%992 = load double, double* %991
%993 = load double, double* %15
%994 = fneg double %992
%995 = call double @llvm.fmuladd.f64(double %994, double %993, double %983)
%996 = load double*, double** %11
%997 = load i32, i32* %14
%998 = load i32, i32* %19
%999 = mul nsw i32 %997, %998
%1000 = load i32, i32* %16
%1001 = add nsw i32 %999, %1000
%1002 = sext i32 %1001 to i64
%1003 = getelementptr inbounds double, double* %996, i64 %1002
store double %995, double* %1003
%1004 = load double*, double** %11
%1005 = load i32, i32* %14
%1006 = load i32, i32* %18
%1007 = mul nsw i32 %1005, %1006
%1008 = load i32, i32* %17
%1009 = add nsw i32 %1007, %1008
%1010 = sext i32 %1009 to i64
%1011 = getelementptr inbounds double, double* %1004, i64 %1010
%1012 = load double, double* %1011
%1013 = load double*, double** %13
%1014 = load i32, i32* %14
%1015 = load i32, i32* %19
%1016 = mul nsw i32 %1014, %1015
%1017 = load i32, i32* %16
%1018 = add nsw i32 %1016, %1017
%1019 = sext i32 %1018 to i64
%1020 = getelementptr inbounds double, double* %1013, i64 %1019
%1021 = load double, double* %1020
%1022 = load double, double* %15
%1023 = fneg double %1021
%1024 = call double @llvm.fmuladd.f64(double %1023, double %1022, double %1012)
%1025 = load double*, double** %11
%1026 = load i32, i32* %14
%1027 = load i32, i32* %18
%1028 = mul nsw i32 %1026, %1027
%1029 = load i32, i32* %17
%1030 = add nsw i32 %1028, %1029
%1031 = sext i32 %1030 to i64
%1032 = getelementptr inbounds double, double* %1025, i64 %1031
store double %1024, double* %1032
%1033 = load double*, double** %11
%1034 = load i32, i32* %14
%1035 = load i32, i32* %19
%1036 = mul nsw i32 %1034, %1035
%1037 = load i32, i32* %17
%1038 = add nsw i32 %1036, %1037
%1039 = sext i32 %1038 to i64
%1040 = getelementptr inbounds double, double* %1033, i64 %1039
%1041 = load double, double* %1040
%1042 = load double*, double** %13
%1043 = load i32, i32* %14
%1044 = load i32, i32* %18
%1045 = mul nsw i32 %1043, %1044
%1046 = load i32, i32* %16
%1047 = add nsw i32 %1045, %1046
%1048 = sext i32 %1047 to i64
%1049 = getelementptr inbounds double, double* %1042, i64 %1048
%1050 = load double, double* %1049
%1051 = load double, double* %15
%1052 = fneg double %1050
%1053 = call double @llvm.fmuladd.f64(double %1052, double %1051, double %1041)
%1054 = load double*, double** %11
%1055 = load i32, i32* %14
%1056 = load i32, i32* %19
%1057 = mul nsw i32 %1055, %1056
%1058 = load i32, i32* %17
%1059 = add nsw i32 %1057, %1058
%1060 = sext i32 %1059 to i64
%1061 = getelementptr inbounds double, double* %1054, i64 %1060
store double %1053, double* %1061
%1062 = load double, double* %15
%1063 = load double, double* %15
%1064 = fadd double %1062, %1063
store double %1064, double* %15
%1065 = load double*, double** %11
%1066 = load i32, i32* %14
%1067 = load i32, i32* %16
%1068 = mul nsw i32 %1066, %1067
%1069 = load i32, i32* %17
%1070 = add nsw i32 %1068, %1069
%1071 = sext i32 %1070 to i64
%1072 = getelementptr inbounds double, double* %1065, i64 %1071
%1073 = load double, double* %1072
%1074 = load double*, double** %12
%1075 = load i32, i32* %14
%1076 = load i32, i32* %18
%1077 = mul nsw i32 %1075, %1076
%1078 = load i32, i32* %19
%1079 = add nsw i32 %1077, %1078
%1080 = sext i32 %1079 to i64
%1081 = getelementptr inbounds double, double* %1074, i64 %1080
%1082 = load double, double* %1081
%1083 = load double, double* %15
%1084 = call double @llvm.fmuladd.f64(double %1082, double %1083, double %1073)
%1085 = load double*, double** %11
%1086 = load i32, i32* %14
%1087 = load i32, i32* %16
%1088 = mul nsw i32 %1086, %1087
%1089 = load i32, i32* %17
%1090 = add nsw i32 %1088, %1089
%1091 = sext i32 %1090 to i64
%1092 = getelementptr inbounds double, double* %1085, i64 %1091
store double %1084, double* %1092
%1093 = load double*, double** %11
%1094 = load i32, i32* %14
%1095 = load i32, i32* %17
%1096 = mul nsw i32 %1094, %1095
%1097 = load i32, i32* %16
%1098 = add nsw i32 %1096, %1097
%1099 = sext i32 %1098 to i64
%1100 = getelementptr inbounds double, double* %1093, i64 %1099
%1101 = load double, double* %1100
%1102 = load double*, double** %12
%1103 = load i32, i32* %14
%1104 = load i32, i32* %18
%1105 = mul nsw i32 %1103, %1104
%1106 = load i32, i32* %19
%1107 = add nsw i32 %1105, %1106
%1108 = sext i32 %1107 to i64
%1109 = getelementptr inbounds double, double* %1102, i64 %1108
%1110 = load double, double* %1109
%1111 = load double, double* %15
%1112 = call double @llvm.fmuladd.f64(double %1110, double %1111, double %1101)
%1113 = load double*, double** %11
%1114 = load i32, i32* %14
%1115 = load i32, i32* %17
%1116 = mul nsw i32 %1114, %1115
%1117 = load i32, i32* %16
%1118 = add nsw i32 %1116, %1117
%1119 = sext i32 %1118 to i64
%1120 = getelementptr inbounds double, double* %1113, i64 %1119
store double %1112, double* %1120
%1121 = load double*, double** %11
%1122 = load i32, i32* %14
%1123 = load i32, i32* %18
%1124 = mul nsw i32 %1122, %1123
%1125 = load i32, i32* %19
%1126 = add nsw i32 %1124, %1125
%1127 = sext i32 %1126 to i64
%1128 = getelementptr inbounds double, double* %1121, i64 %1127
%1129 = load double, double* %1128
%1130 = load double*, double** %12
%1131 = load i32, i32* %14
%1132 = load i32, i32* %16
%1133 = mul nsw i32 %1131, %1132
%1134 = load i32, i32* %17
%1135 = add nsw i32 %1133, %1134
%1136 = sext i32 %1135 to i64
%1137 = getelementptr inbounds double, double* %1130, i64 %1136
%1138 = load double, double* %1137
%1139 = load double, double* %15
%1140 = call double @llvm.fmuladd.f64(double %1138, double %1139, double %1129)
%1141 = load double*, double** %11
%1142 = load i32, i32* %14
%1143 = load i32, i32* %18
%1144 = mul nsw i32 %1142, %1143
%1145 = load i32, i32* %19
%1146 = add nsw i32 %1144, %1145
%1147 = sext i32 %1146 to i64
%1148 = getelementptr inbounds double, double* %1141, i64 %1147
store double %1140, double* %1148
%1149 = load double*, double** %11
%1150 = load i32, i32* %14
%1151 = load i32, i32* %19
%1152 = mul nsw i32 %1150, %1151
%1153 = load i32, i32* %18
%1154 = add nsw i32 %1152, %1153
%1155 = sext i32 %1154 to i64
%1156 = getelementptr inbounds double, double* %1149, i64 %1155
%1157 = load double, double* %1156
%1158 = load double*, double** %12
%1159 = load i32, i32* %14
%1160 = load i32, i32* %16
%1161 = mul nsw i32 %1159, %1160
%1162 = load i32, i32* %17
%1163 = add nsw i32 %1161, %1162
%1164 = sext i32 %1163 to i64
%1165 = getelementptr inbounds double, double* %1158, i64 %1164
%1166 = load double, double* %1165
%1167 = load double, double* %15
%1168 = call double @llvm.fmuladd.f64(double %1166, double %1167, double %1157)
%1169 = load double*, double** %11
%1170 = load i32, i32* %14
%1171 = load i32, i32* %19
%1172 = mul nsw i32 %1170, %1171
%1173 = load i32, i32* %18
%1174 = add nsw i32 %1172, %1173
%1175 = sext i32 %1174 to i64
%1176 = getelementptr inbounds double, double* %1169, i64 %1175
store double %1168, double* %1176
br label %1177
1177: ; preds = %829, %600, %398, %196, %81, %23
ret void
}

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