void coreGTRGAMMAMULTINVAR(int lower, int upper, double *sumtable,
                           double *ext_dlnLdlz, double *ext_d2lnLdlz2,
                           double *EIGN, double *gammaRates, double lz,
                           int *wrptr, int numberOfModels, int *modelptr,
                           double *frequencies, double *invariants, int *iptr) {
  double *sum, *diagptable, *diagptable_start;
  int i;
  double dlnLdlz = 0;
  double d2lnLdlz2 = 0;
  double ki, kisqr;
  int model;
  double *scalers;
  double *freqs;
  double tmp_1, tmp_2, tmp_3;
  double inv_Li, dlnLidlz, d2lnLidlz2;
  diagptable_start = (double *)malloc(sizeof(double) * 36 * numberOfModels);
  freqs = (double *)malloc(4 * numberOfModels * sizeof(double));
  scalers = (double *)malloc(numberOfModels * sizeof(double));
  for (model = 0; model < numberOfModels; model++) {
    scalers[model] = 0.25 * (1.0 - invariants[model]);
    freqs[4 * model] = frequencies[4 * model] * invariants[model];
    freqs[4 * model + 1] = frequencies[4 * model + 1] * invariants[model];
    freqs[4 * model + 2] = frequencies[4 * model + 2] * invariants[model];
    freqs[4 * model + 3] = frequencies[4 * model + 3] * invariants[model];
  }
  for (model = 0; model < numberOfModels; model++) {
    diagptable = &diagptable_start[model * 36];
    for (i = 0; i < 4; i++) {
      ki = gammaRates[model * 4 + i];
      kisqr = ki * ki;
      *diagptable++ = exp(EIGN[model * 3] * ki * lz);
      *diagptable++ = exp(EIGN[model * 3 + 1] * ki * lz);
      *diagptable++ = exp(EIGN[model * 3 + 2] * ki * lz);
      *diagptable++ = EIGN[model * 3] * ki;
      *diagptable++ = EIGN[model * 3] * EIGN[model * 3] * kisqr;
      *diagptable++ = EIGN[model * 3 + 1] * ki;
      *diagptable++ = EIGN[model * 3 + 1] * EIGN[model * 3 + 1] * kisqr;
      *diagptable++ = EIGN[model * 3 + 2] * ki;
      *diagptable++ = EIGN[model * 3 + 2] * EIGN[model * 3 + 2] * kisqr;
    }
  }
  for (i = lower; i < upper; i++) {
    diagptable = &diagptable_start[36 * modelptr[i]];
    sum = &(sumtable[i * 16]);
    inv_Li = *sum++;
    inv_Li += (tmp_1 = *diagptable++ * *sum++);
    inv_Li += (tmp_2 = *diagptable++ * *sum++);
    inv_Li += (tmp_3 = *diagptable++ * *sum++);
    dlnLidlz = tmp_1 * *diagptable++;
    d2lnLidlz2 = tmp_1 * *diagptable++;
    dlnLidlz += tmp_2 * *diagptable++;
    d2lnLidlz2 += tmp_2 * *diagptable++;
    dlnLidlz += tmp_3 * *diagptable++;
    d2lnLidlz2 += tmp_3 * *diagptable++;
    inv_Li += *sum++;
    inv_Li += (tmp_1 = *sum++ * *diagptable++);
    inv_Li += (tmp_2 = *sum++ * *diagptable++);
    inv_Li += (tmp_3 = *sum++ * *diagptable++);
    dlnLidlz += tmp_1 * *diagptable++;
    d2lnLidlz2 += tmp_1 * *diagptable++;
    dlnLidlz += tmp_2 * *diagptable++;
    d2lnLidlz2 += tmp_2 * *diagptable++;
    dlnLidlz += tmp_3 * *diagptable++;
    d2lnLidlz2 += tmp_3 * *diagptable++;
    inv_Li += *sum++;
    inv_Li += (tmp_1 = *sum++ * *diagptable++);
    inv_Li += (tmp_2 = *sum++ * *diagptable++);
    inv_Li += (tmp_3 = *sum++ * *diagptable++);
    dlnLidlz += tmp_1 * *diagptable++;
    d2lnLidlz2 += tmp_1 * *diagptable++;
    dlnLidlz += tmp_2 * *diagptable++;
    d2lnLidlz2 += tmp_2 * *diagptable++;
    dlnLidlz += tmp_3 * *diagptable++;
    d2lnLidlz2 += tmp_3 * *diagptable++;
    inv_Li += *sum++;
    inv_Li += (tmp_1 = *sum++ * *diagptable++);
    inv_Li += (tmp_2 = *sum++ * *diagptable++);
    inv_Li += (tmp_3 = *sum++ * *diagptable++);
    dlnLidlz += tmp_1 * *diagptable++;
    d2lnLidlz2 += tmp_1 * *diagptable++;
    dlnLidlz += tmp_2 * *diagptable++;
    d2lnLidlz2 += tmp_2 * *diagptable++;
    dlnLidlz += tmp_3 * *diagptable++;
    d2lnLidlz2 += tmp_3 * *diagptable++;
    inv_Li *= scalers[modelptr[i]];
    if (iptr[i] < 4)
      inv_Li += freqs[4 * modelptr[i] + iptr[i]];
    inv_Li = 1.0 / inv_Li;
    dlnLidlz *= inv_Li;
    d2lnLidlz2 *= inv_Li;
    dlnLidlz *= scalers[modelptr[i]];
    d2lnLidlz2 *= scalers[modelptr[i]];
    dlnLdlz += wrptr[i] * dlnLidlz;
    d2lnLdlz2 += wrptr[i] * (d2lnLidlz2 - dlnLidlz * dlnLidlz);
  }
  *ext_dlnLdlz = dlnLdlz;
  *ext_d2lnLdlz2 = d2lnLdlz2;
  free(diagptable_start);
  free(freqs);
  free(scalers);
}


x86 assembly (clang, -O0):
<coreGTRGAMMAMULTINVAR>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movslq 0x20(%rbp),%rax
imul   $0x120,%rax,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    0x20(%rbp),%eax
shl    $0x2,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq 0x20(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    12f0 <coreGTRGAMMAMULTINVAR+0x1c0>
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xe1e(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
movsd  0xe19(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    11c6 <coreGTRGAMMAMULTINVAR+0x96>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1542 <coreGTRGAMMAMULTINVAR+0x412>
mov    -0x48(%rbp),%rax
imul   $0x24,-0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
cmpl   $0x4,-0x4c(%rbp)
jge    152f <coreGTRGAMMAMULTINVAR+0x3ff>
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
imul   $0x3,-0x74(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1320 <coreGTRGAMMAMULTINVAR+0x1f0>
jmp    1534 <coreGTRGAMMAMULTINVAR+0x404>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12f7 <coreGTRGAMMAMULTINVAR+0x1c7>
mov    -0x4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1f2a <coreGTRGAMMAMULTINVAR+0xdfa>
mov    -0x48(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
imul   $0x24,(%rcx,%rdx,4),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x4,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x80(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x4,(%rax,%rcx,4)
jge    1e0d <coreGTRGAMMAMULTINVAR+0xcdd>
mov    -0x88(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x2,%ecx
mov    0x40(%rbp),%rdx
movslq -0x4c(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x1eb(%rip),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x80(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x80(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm3
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1548 <coreGTRGAMMAMULTINVAR+0x418>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<coreGTRGAMMAMULTINVAR>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
movsd  %xmm0,0x8(%rsp)
mov    %r9,%r15
mov    %r8,0x68(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,0x58(%rsp)
mov    %esi,0x38(%rsp)
mov    %edi,0x3c(%rsp)
movslq 0xe0(%rsp),%r12
mov    0x100(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0xf8(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0xf0(%rsp),%r13
mov    0xe8(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0xd8(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0xd0(%rsp),%r14
mov    %r12,%rax
shl    $0x5,%rax
lea    (%rax,%rax,8),%rdi
call   1040 <malloc@plt>
mov    %rax,%rbp
lea    0x0(,%r12,4),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,0x30(%rsp)
lea    0x0(,%r12,8),%rdi
call   1040 <malloc@plt>
mov    %rax,0x28(%rsp)
test   %r12,%r12
jle    148d <coreGTRGAMMAMULTINVAR+0x35d>
mov    %r12d,%ebx
cmp    $0x1,%r12d
jne    1213 <coreGTRGAMMAMULTINVAR+0xe3>
xor    %eax,%eax
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%r8
mov    0x10(%rsp),%rdi
jmp    12d9 <coreGTRGAMMAMULTINVAR+0x1a9>
mov    %ebx,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
movapd 0xdde(%rip),%xmm0
movapd 0xde6(%rip),%xmm1
mov    %rax,%rdx
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%r8
mov    0x10(%rsp),%rdi
nopl   0x0(%rax)
movupd (%rdi,%rcx,1),%xmm2
movapd %xmm0,%xmm3
subpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm3
movupd %xmm3,(%r8,%rcx,1)
movupd 0x0(%r13,%rcx,4),%xmm3
movupd 0x10(%r13,%rcx,4),%xmm4
movupd 0x20(%r13,%rcx,4),%xmm5
movupd 0x30(%r13,%rcx,4),%xmm6
movapd %xmm3,%xmm7
unpcklpd %xmm5,%xmm7
unpckhpd %xmm5,%xmm3
movapd %xmm4,%xmm5
unpcklpd %xmm6,%xmm5
unpckhpd %xmm6,%xmm4
mulpd  %xmm2,%xmm7
mulpd  %xmm2,%xmm3
mulpd  %xmm2,%xmm5
mulpd  %xmm2,%xmm4
movapd %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movapd %xmm7,%xmm6
unpcklpd %xmm3,%xmm6
movhlps %xmm5,%xmm4
movhlps %xmm7,%xmm3
movups %xmm3,0x20(%rsi,%rcx,4)
movups %xmm4,0x30(%rsi,%rcx,4)
movupd %xmm6,(%rsi,%rcx,4)
movupd %xmm2,0x10(%rsi,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1240 <coreGTRGAMMAMULTINVAR+0x110>
cmp    %rbx,%rax
je     1346 <coreGTRGAMMAMULTINVAR+0x216>
mov    %rbx,%rcx
sub    %rax,%rcx
shl    $0x3,%rax
movsd  0xd35(%rip),%xmm0
movsd  0xd35(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%rax,1),%xmm2
movapd %xmm0,%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
movsd  %xmm3,(%r8,%rax,1)
movupd 0x0(%r13,%rax,4),%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm2,%xmm3
movupd %xmm3,(%rsi,%rax,4)
movupd 0x10(%r13,%rax,4),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,0x10(%rsi,%rax,4)
add    $0x8,%rax
add    $0xffffffffffffffff,%rcx
jne    1300 <coreGTRGAMMAMULTINVAR+0x1d0>
test   %r12d,%r12d
jle    148d <coreGTRGAMMAMULTINVAR+0x35d>
xor    %ecx,%ecx
mov    %rbx,0x70(%rsp)
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%rcx,4),%eax
lea    (%rax,%rax,8),%eax
lea    0x0(,%rax,8),%rbx
add    %rbp,%rbx
mov    %rcx,0x78(%rsp)
lea    (%rcx,%rcx,2),%r12
movsd  (%r15,%r12,8),%xmm0
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%r13,8),%xmm1
movapd %xmm1,0x10(%rsp)
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm2,0x80(%rsp)
mulsd  %xmm1,%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,(%rbx)
movsd  0x8(%r15,%r12,8),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x8(%rbx)
movsd  0x10(%r15,%r12,8),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x10(%rbx)
movsd  (%r15,%r12,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd 0x10(%rsp),%xmm3
unpcklpd 0x80(%rsp),%xmm3
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
mulpd  %xmm3,%xmm2
movupd %xmm2,0x18(%rbx)
movsd  0x8(%r15,%r12,8),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
unpcklpd %xmm2,%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm1,0x28(%rbx)
movsd  0x10(%r15,%r12,8),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
unpcklpd %xmm2,%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm1,0x38(%rbx)
add    $0x1,%r13
add    $0x48,%rbx
cmp    $0x4,%r13
jne    1390 <coreGTRGAMMAMULTINVAR+0x260>
mov    0x78(%rsp),%rcx
add    $0x1,%rcx
add    $0x20,%r14
mov    0x70(%rsp),%rbx
cmp    %rbx,%rcx
jne    1360 <coreGTRGAMMAMULTINVAR+0x230>
xorpd  %xmm1,%xmm1
mov    0x3c(%rsp),%ecx
mov    0x38(%rsp),%edx
cmp    %edx,%ecx
mov    0x30(%rsp),%r14
mov    0x28(%rsp),%r15
jge    17d2 <coreGTRGAMMAMULTINVAR+0x6a2>
movslq %ecx,%rax
movslq %edx,%r8
shl    $0x4,%ecx
xorps  %xmm3,%xmm3
mov    0x58(%rsp),%rbx
mov    0x50(%rsp),%r9
mov    0x48(%rsp),%r10
mov    0x40(%rsp),%r11
jmp    168b <coreGTRGAMMAMULTINVAR+0x55b>
movsd  0xb47(%rip),%xmm11
divsd  %xmm8,%xmm11
movsd  0x18(%rbp,%rdx,1),%xmm3
mulsd  %xmm15,%xmm3
movsd  0x28(%rbp,%rdx,1),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
mulsd  0x20(%rbp,%rdx,1),%xmm15
mulsd  0x30(%rbp,%rdx,1),%xmm0
addsd  %xmm15,%xmm0
movsd  0x38(%rbp,%rdx,1),%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm4,%xmm3
mulsd  0x40(%rbp,%rdx,1),%xmm6
addsd  %xmm0,%xmm6
movsd  0x60(%rbp,%rdx,1),%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm3,%xmm0
mulsd  0x68(%rbp,%rdx,1),%xmm5
addsd  %xmm6,%xmm5
movsd  0x70(%rbp,%rdx,1),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
mulsd  0x78(%rbp,%rdx,1),%xmm2
addsd  %xmm5,%xmm2
movsd  0x80(%rbp,%rdx,1),%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm3,%xmm0
mulsd  0x88(%rbp,%rdx,1),%xmm10
addsd  %xmm2,%xmm10
movsd  0xa8(%rbp,%rdx,1),%xmm2
mulsd  %xmm14,%xmm2
addsd  %xmm0,%xmm2
mulsd  0xb0(%rbp,%rdx,1),%xmm14
addsd  %xmm10,%xmm14
movsd  0xb8(%rbp,%rdx,1),%xmm0
mulsd  %xmm7,%xmm0
addsd  %xmm2,%xmm0
mulsd  0xc0(%rbp,%rdx,1),%xmm7
addsd  %xmm14,%xmm7
movsd  0xc8(%rbp,%rdx,1),%xmm2
mulsd  %xmm13,%xmm2
addsd  %xmm0,%xmm2
mulsd  0xd0(%rbp,%rdx,1),%xmm13
addsd  %xmm7,%xmm13
movsd  0xf0(%rbp,%rdx,1),%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm2,%xmm0
mulsd  0xf8(%rbp,%rdx,1),%xmm12
addsd  %xmm13,%xmm12
movsd  0x100(%rbp,%rdx,1),%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm0,%xmm2
mulsd  0x108(%rbp,%rdx,1),%xmm9
addsd  %xmm12,%xmm9
movsd  0x110(%rbp,%rdx,1),%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
mulsd  0x118(%rbp,%rdx,1),%xmm1
addsd  %xmm9,%xmm1
mulsd  %xmm11,%xmm0
mulsd  %xmm11,%xmm1
movsd  0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
unpcklpd %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsi2sdl (%r11,%rax,4),%xmm0
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm1
movapd %xmm1,%xmm3
movapd 0x10(%rsp),%xmm0
addpd  %xmm0,%xmm3
add    $0x1,%rax
add    $0x10,%ecx
cmp    %rax,%r8
je     17ce <coreGTRGAMMAMULTINVAR+0x69e>
movslq (%r10,%rax,4),%rsi
lea    (%rsi,%rsi,8),%rdx
shl    $0x5,%rdx
movslq %ecx,%rdi
movsd  0x0(%rbp,%rdx,1),%xmm15
mulsd  0x8(%rbx,%rdi,8),%xmm15
movsd  0x8(%rbp,%rdx,1),%xmm0
movsd  (%rbx,%rdi,8),%xmm8
mulsd  0x10(%rbx,%rdi,8),%xmm0
addsd  %xmm15,%xmm8
movsd  0x10(%rbp,%rdx,1),%xmm6
mulsd  0x18(%rbx,%rdi,8),%xmm6
addsd  %xmm0,%xmm8
addsd  %xmm6,%xmm8
addsd  0x20(%rbx,%rdi,8),%xmm8
movsd  0x28(%rbx,%rdi,8),%xmm5
mulsd  0x48(%rbp,%rdx,1),%xmm5
addsd  %xmm5,%xmm8
movupd 0x30(%rbx,%rdi,8),%xmm1
movupd 0x50(%rbp,%rdx,1),%xmm2
mulpd  %xmm1,%xmm2
addsd  %xmm2,%xmm8
movapd %xmm2,%xmm10
unpckhpd %xmm2,%xmm10
addsd  %xmm10,%xmm8
addsd  0x40(%rbx,%rdi,8),%xmm8
movsd  0x48(%rbx,%rdi,8),%xmm14
mulsd  0x90(%rbp,%rdx,1),%xmm14
addsd  %xmm14,%xmm8
movupd 0x50(%rbx,%rdi,8),%xmm1
movupd 0x98(%rbp,%rdx,1),%xmm7
mulpd  %xmm1,%xmm7
addsd  %xmm7,%xmm8
movapd %xmm7,%xmm13
unpckhpd %xmm7,%xmm13
addsd  %xmm13,%xmm8
addsd  0x60(%rbx,%rdi,8),%xmm8
movsd  0x68(%rbx,%rdi,8),%xmm12
mulsd  0xd8(%rbp,%rdx,1),%xmm12
addsd  %xmm12,%xmm8
movupd 0x70(%rbx,%rdi,8),%xmm1
movupd 0xe0(%rbp,%rdx,1),%xmm9
mulpd  %xmm1,%xmm9
addsd  %xmm9,%xmm8
movapd %xmm9,%xmm1
unpckhpd %xmm9,%xmm1
addsd  %xmm1,%xmm8
movsd  (%r15,%rsi,8),%xmm4
mulsd  %xmm4,%xmm8
movslq (%r9,%rax,4),%rdi
cmp    $0x3,%rdi
movaps %xmm3,0x10(%rsp)
movsd  %xmm4,0x8(%rsp)
jg     14d0 <coreGTRGAMMAMULTINVAR+0x3a0>
lea    (%rdi,%rsi,4),%rsi
addsd  (%r14,%rsi,8),%xmm8
jmp    14d0 <coreGTRGAMMAMULTINVAR+0x3a0>
addpd  %xmm0,%xmm1
mov    0x60(%rsp),%rax
movhpd %xmm1,(%rax)
mov    0x68(%rsp),%rax
movlpd %xmm1,(%rax)
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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