#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double exp(double);
int /*<<< orphan*/ free(double *);
int log(double);
scalar_t__ malloc(int);
double pow(double, int);
void evaluateGTRGAMMAINVAR_VECTOR(int *ex2, int *iptr, double *x2_start,
                                  double *v, double *EIGN, double *gammaRates,
                                  double *tipVector, double *tFreqs,
                                  double invariants, double pz, char *tipX1,
                                  int lower, int n) {
  double z, lz, term, ki;
  int i;
  double *diagptable;
  double freqs[4];
  double *x1, *x2;
  double scaler = 0.25 * (1.0 - invariants);
  freqs[0] = tFreqs[0] * invariants;
  freqs[1] = tFreqs[1] * invariants;
  freqs[2] = tFreqs[2] * invariants;
  freqs[3] = tFreqs[3] * invariants;
  z = pz;
  if (z < 1.0E-15)
    z = 1.0E-15;
  lz = log(z);
  diagptable = (double *)malloc(sizeof(double) * 16);
  for (i = 0; i < 4; i++) {
    ki = gammaRates[i];
    diagptable[i * 4] = 1.0;
    diagptable[i * 4 + 1] = exp(EIGN[0] * ki * lz);
    diagptable[i * 4 + 2] = exp(EIGN[1] * ki * lz);
    diagptable[i * 4 + 3] = exp(EIGN[2] * ki * lz);
  }
  for (i = lower; i < n; i++) {
    x1 = &(tipVector[4 * tipX1[i]]);
    x2 = &x2_start[16 * i];
    term = x1[0] * x2[0] * diagptable[0];
    term += x1[1] * x2[1] * diagptable[1];
    term += x1[2] * x2[2] * diagptable[2];
    term += x1[3] * x2[3] * diagptable[3];
    term += x1[0] * x2[4] * diagptable[4];
    term += x1[1] * x2[5] * diagptable[5];
    term += x1[2] * x2[6] * diagptable[6];
    term += x1[3] * x2[7] * diagptable[7];
    term += x1[0] * x2[8] * diagptable[8];
    term += x1[1] * x2[9] * diagptable[9];
    term += x1[2] * x2[10] * diagptable[10];
    term += x1[3] * x2[11] * diagptable[11];
    term += x1[0] * x2[12] * diagptable[12];
    term += x1[1] * x2[13] * diagptable[13];
    term += x1[2] * x2[14] * diagptable[14];
    term += x1[3] * x2[15] * diagptable[15];
    if (iptr[i] < 4)
      term = log(
          (scaler * term + freqs[iptr[i]]) *
          pow((1.0 /
               115792089237316195423570985008687907853269984665640564039457584007913129639936.0),
              ex2[i]));
    else
      term =
          log(scaler * term) +
          ex2[i] *
              log((
                  1.0 /
                  115792089237316195423570985008687907853269984665640564039457584007913129639936.0));
    v[i] = term;
  }
  free(diagptable);
}


x86 assembly (clang, -O0):
<evaluateGTRGAMMAINVAR_VECTOR>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  0xe79(%rip),%xmm1
subsd  -0x38(%rbp),%xmm1
movsd  0xe64(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xded(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    122b <evaluateGTRGAMMAINVAR_VECTOR+0xdb>
movsd  0xdda(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1060 <log@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    $0x80,%edi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    131d <evaluateGTRGAMMAINVAR_VECTOR+0x1cd>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  0xd8c(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1253 <evaluateGTRGAMMAINVAR_VECTOR+0x103>
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    177b <evaluateGTRGAMMAINVAR_VECTOR+0x62b>
mov    0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x64(%rbp),%ecx
shl    $0x4,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x70(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x18(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x20(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x28(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x30(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x38(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x40(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x48(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x50(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x50(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x58(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x60(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x68(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x70(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x78(%rax),%xmm0
mov    -0x70(%rbp),%rax
movsd  0x78(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
cmpl   $0x4,(%rax,%rcx,4)
jge    1709 <evaluateGTRGAMMAINVAR_VECTOR+0x5b9>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
movsd  0x936(%rip),%xmm0
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
call   1060 <log@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    175b <evaluateGTRGAMMAINVAR_VECTOR+0x60b>
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x58(%rbp),%xmm0
call   1060 <log@plt>
mov    %eax,-0xb4(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb8(%rbp)
movsd  0x8de(%rip),%xmm0
call   1060 <log@plt>
mov    -0xb8(%rbp),%ecx
mov    %eax,%edx
mov    -0xb4(%rbp),%eax
imul   %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1323 <evaluateGTRGAMMAINVAR_VECTOR+0x1d3>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<evaluateGTRGAMMAINVAR_VECTOR>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
movapd %xmm0,%xmm2
mov    %r9,%r12
mov    %r8,%rbp
mov    %rcx,0x28(%rsp)
mov    %rdx,%r14
mov    %rsi,0x40(%rsp)
mov    %rdi,0x20(%rsp)
mov    0xd0(%rsp),%eax
mov    %eax,0x18(%rsp)
mov    0xc8(%rsp),%r15d
mov    0xc0(%rsp),%r13
mov    0xb0(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0xb8(%rsp),%rax
movupd (%rax),%xmm0
movapd %xmm2,0x30(%rsp)
unpcklpd %xmm2,%xmm2
mulpd  %xmm2,%xmm0
movapd %xmm0,0x50(%rsp)
movupd 0x10(%rax),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm0,0x60(%rsp)
movsd  0xe2f(%rip),%xmm0
maxsd  %xmm1,%xmm0
call   1060 <log@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
mov    $0x80,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
movsd  (%r12),%xmm1
movsd  %xmm1,0x10(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rbx)
movsd  0x0(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x8(%rbx)
movsd  0x8(%rbp),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x10(%rbx)
movsd  0x10(%rsp),%xmm0
mulsd  0x10(%rbp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x18(%rbx)
movsd  0x8(%r12),%xmm1
movsd  %xmm1,0x10(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x20(%rbx)
movsd  0x0(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x28(%rbx)
movsd  0x8(%rbp),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x30(%rbx)
movsd  0x10(%rsp),%xmm0
mulsd  0x10(%rbp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x38(%rbx)
movsd  0x10(%r12),%xmm1
movsd  %xmm1,0x10(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x40(%rbx)
movsd  0x0(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x48(%rbx)
movsd  0x8(%rbp),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x50(%rbx)
movsd  0x10(%rsp),%xmm0
mulsd  0x10(%rbp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x58(%rbx)
movsd  0x18(%r12),%xmm1
movsd  %xmm1,0x10(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x60(%rbx)
movsd  0x0(%rbp),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x68(%rbx)
movsd  0x8(%rbp),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x70(%rbx)
movsd  0x10(%rsp),%xmm0
mulsd  0x10(%rbp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
mov    0x18(%rsp),%edx
movsd  %xmm0,0x78(%rbx)
cmp    %edx,%r15d
jge    161d <evaluateGTRGAMMAINVAR_VECTOR+0x4cd>
movsd  0xc49(%rip),%xmm1
subsd  0x30(%rsp),%xmm1
mulsd  0xc4b(%rip),%xmm1
movsd  %xmm1,0x30(%rsp)
movslq %r15d,%rax
mov    %r15d,%ebp
shl    $0x4,%ebp
add    %rax,%r13
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
mov    %rcx,0x8(%rsp)
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
mov    %rcx,0x20(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x10(%rsp)
not    %r15d
add    %edx,%r15d
xor    %r12d,%r12d
nopw   0x0(%rax,%rax,1)
movsbq 0x0(%r13,%r12,1),%rcx
shl    $0x5,%rcx
movslq %ebp,%rax
mov    0x48(%rsp),%rdx
movsd  (%rdx,%rcx,1),%xmm2
movsd  0x8(%rdx,%rcx,1),%xmm1
movsd  (%r14,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  (%rbx),%xmm3
movsd  0x8(%r14,%rax,8),%xmm4
mulsd  %xmm1,%xmm4
mulsd  0x8(%rbx),%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rdx,%rcx,1),%xmm3
movsd  0x10(%r14,%rax,8),%xmm5
mulsd  %xmm3,%xmm5
mulsd  0x10(%rbx),%xmm5
addsd  %xmm4,%xmm5
movsd  0x18(%rdx,%rcx,1),%xmm7
movsd  0x18(%r14,%rax,8),%xmm4
mulsd  %xmm7,%xmm4
mulsd  0x18(%rbx),%xmm4
addsd  %xmm5,%xmm4
movsd  0x20(%r14,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
mulsd  0x20(%rbx),%xmm5
addsd  %xmm4,%xmm5
movsd  0x28(%r14,%rax,8),%xmm4
mulsd  %xmm1,%xmm4
mulsd  0x28(%rbx),%xmm4
movsd  0x30(%r14,%rax,8),%xmm6
mulsd  %xmm3,%xmm6
mulsd  0x30(%rbx),%xmm6
addsd  %xmm5,%xmm4
addsd  %xmm4,%xmm6
movsd  0x38(%r14,%rax,8),%xmm4
mulsd  %xmm7,%xmm4
mulsd  0x38(%rbx),%xmm4
addsd  %xmm6,%xmm4
movsd  0x40(%r14,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
mulsd  0x40(%rbx),%xmm5
addsd  %xmm4,%xmm5
movsd  0x48(%r14,%rax,8),%xmm4
mulsd  %xmm1,%xmm4
mulsd  0x48(%rbx),%xmm4
movsd  0x50(%r14,%rax,8),%xmm6
mulsd  %xmm3,%xmm6
mulsd  0x50(%rbx),%xmm6
addsd  %xmm5,%xmm4
addsd  %xmm4,%xmm6
movsd  0x58(%r14,%rax,8),%xmm4
mulsd  %xmm7,%xmm4
mulsd  0x58(%rbx),%xmm4
mulsd  0x60(%r14,%rax,8),%xmm2
addsd  %xmm6,%xmm4
mulsd  0x60(%rbx),%xmm2
addsd  %xmm4,%xmm2
mulsd  0x68(%r14,%rax,8),%xmm1
mulsd  0x68(%rbx),%xmm1
mulsd  0x70(%r14,%rax,8),%xmm3
mulsd  0x70(%rbx),%xmm3
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm3
mulsd  0x78(%r14,%rax,8),%xmm7
mulsd  %xmm0,%xmm7
addsd  %xmm3,%xmm7
mov    0x8(%rsp),%rax
movslq (%rax,%r12,4),%rax
cmp    $0x3,%rax
jg     15b0 <evaluateGTRGAMMAINVAR_VECTOR+0x460>
mulsd  0x30(%rsp),%xmm7
addsd  0x50(%rsp,%rax,8),%xmm7
movsd  %xmm7,0x18(%rsp)
mov    0x20(%rsp),%rax
mov    (%rax,%r12,4),%edi
movsd  0xa84(%rip),%xmm0
call   1070 <pow@plt>
mulsd  0x18(%rsp),%xmm0
call   1060 <log@plt>
jmp    15f5 <evaluateGTRGAMMAINVAR_VECTOR+0x4a5>
cs nopw 0x0(%rax,%rax,1)
mulsd  0x30(%rsp),%xmm7
movapd %xmm7,%xmm0
call   1060 <log@plt>
mov    %eax,0x28(%rsp)
mov    %ebp,0x18(%rsp)
mov    %r13,%rbp
mov    %r15,%r13
mov    0x20(%rsp),%rax
mov    (%rax,%r12,4),%r15d
movsd  0xa3a(%rip),%xmm0
call   1060 <log@plt>
imul   %r15d,%eax
mov    %r13,%r15
mov    %rbp,%r13
mov    0x18(%rsp),%ebp
add    0x28(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x10(%rsp),%rax
movsd  %xmm0,(%rax,%r12,8)
cmp    %r12d,%r15d
je     161d <evaluateGTRGAMMAINVAR_VECTOR+0x4cd>
movsd  0x78(%rbx),%xmm0
add    $0x10,%ebp
add    $0x1,%r12
jmp    1410 <evaluateGTRGAMMAINVAR_VECTOR+0x2c0>
mov    %rbx,%rdi
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

LLVM IR (-O2):
define void @evaluateGTRGAMMAINVAR_VECTOR(i32* nocapture %0, i32* nocapture %1, double* nocapture %2, double* nocapture writeonly %3, double* nocapture %4, double* nocapture %5, double* nocapture %6, double* nocapture %7, double %8, double %9, i8* nocapture %10, i32 %11, i32 %12) {
%14 = alloca [4 x double]
%15 = bitcast [4 x double]* %14 to i8*
%16 = fsub double 1.000000e+00, %8
%17 = bitcast double* %7 to <2 x double>*
%18 = load <2 x double>, <2 x double>* %17
%19 = insertelement <2 x double> poison, double %8, i64 0
%20 = shufflevector <2 x double> %19, <2 x double> poison, <2 x i32> zeroinitializer
%21 = fmul <2 x double> %18, %20
%22 = bitcast [4 x double]* %14 to <2 x double>*
store <2 x double> %21, <2 x double>* %22
%23 = getelementptr inbounds double, double* %7, i64 2
%24 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 2
%25 = bitcast double* %23 to <2 x double>*
%26 = load <2 x double>, <2 x double>* %25
%27 = fmul <2 x double> %26, %20
%28 = bitcast double* %24 to <2 x double>*
store <2 x double> %27, <2 x double>* %28
%29 = fcmp olt double %9, 1.000000e-15
%30 = select i1 %29, double 1.000000e-15, double %9
%31 = tail call i32 @log(double %30)
%32 = sitofp i32 %31 to double
%33 = tail call i64 @malloc(i32 128)
%34 = inttoptr i64 %33 to double*
%35 = getelementptr inbounds double, double* %4, i64 1
%36 = getelementptr inbounds double, double* %4, i64 2
%37 = load double, double* %5
store double 1.000000e+00, double* %34
%38 = load double, double* %4
%39 = fmul double %37, %38
%40 = fmul double %39, %32
%41 = tail call double @exp(double %40)
%42 = getelementptr inbounds double, double* %34, i64 1
store double %41, double* %42
%43 = load double, double* %35
%44 = fmul double %37, %43
%45 = fmul double %44, %32
%46 = tail call double @exp(double %45)
%47 = getelementptr inbounds double, double* %34, i64 2
store double %46, double* %47
%48 = load double, double* %36
%49 = fmul double %37, %48
%50 = fmul double %49, %32
%51 = tail call double @exp(double %50)
%52 = getelementptr inbounds double, double* %34, i64 3
store double %51, double* %52
%53 = getelementptr inbounds double, double* %5, i64 1
%54 = load double, double* %53
%55 = getelementptr inbounds double, double* %34, i64 4
store double 1.000000e+00, double* %55
%56 = load double, double* %4
%57 = fmul double %54, %56
%58 = fmul double %57, %32
%59 = tail call double @exp(double %58)
%60 = getelementptr inbounds double, double* %34, i64 5
store double %59, double* %60
%61 = load double, double* %35
%62 = fmul double %54, %61
%63 = fmul double %62, %32
%64 = tail call double @exp(double %63)
%65 = getelementptr inbounds double, double* %34, i64 6
store double %64, double* %65
%66 = load double, double* %36
%67 = fmul double %54, %66
%68 = fmul double %67, %32
%69 = tail call double @exp(double %68)
%70 = getelementptr inbounds double, double* %34, i64 7
store double %69, double* %70
%71 = getelementptr inbounds double, double* %5, i64 2
%72 = load double, double* %71
%73 = getelementptr inbounds double, double* %34, i64 8
store double 1.000000e+00, double* %73
%74 = load double, double* %4
%75 = fmul double %72, %74
%76 = fmul double %75, %32
%77 = tail call double @exp(double %76)
%78 = getelementptr inbounds double, double* %34, i64 9
store double %77, double* %78
%79 = load double, double* %35
%80 = fmul double %72, %79
%81 = fmul double %80, %32
%82 = tail call double @exp(double %81)
%83 = getelementptr inbounds double, double* %34, i64 10
store double %82, double* %83
%84 = load double, double* %36
%85 = fmul double %72, %84
%86 = fmul double %85, %32
%87 = tail call double @exp(double %86)
%88 = getelementptr inbounds double, double* %34, i64 11
store double %87, double* %88
%89 = getelementptr inbounds double, double* %5, i64 3
%90 = load double, double* %89
%91 = getelementptr inbounds double, double* %34, i64 12
store double 1.000000e+00, double* %91
%92 = load double, double* %4
%93 = fmul double %90, %92
%94 = fmul double %93, %32
%95 = tail call double @exp(double %94)
%96 = getelementptr inbounds double, double* %34, i64 13
store double %95, double* %96
%97 = load double, double* %35
%98 = fmul double %90, %97
%99 = fmul double %98, %32
%100 = tail call double @exp(double %99)
%101 = getelementptr inbounds double, double* %34, i64 14
store double %100, double* %101
%102 = load double, double* %36
%103 = fmul double %90, %102
%104 = fmul double %103, %32
%105 = tail call double @exp(double %104)
%106 = getelementptr inbounds double, double* %34, i64 15
store double %105, double* %106
%107 = fmul double %16, 2.500000e-01
%108 = icmp slt i32 %11, %12
br i1 %108, label %109, label %239
109: ; preds = %13
%110 = sext i32 %11 to i64
br label %111
111: ; preds = %237, %109
%112 = phi double [ %105, %109 ], [ %238, %237 ]
%113 = phi i64 [ %110, %109 ], [ %234, %237 ]
%114 = trunc i64 %113 to i32
%115 = getelementptr inbounds i8, i8* %10, i64 %113
%116 = load i8, i8* %115
%117 = sext i8 %116 to i32
%118 = shl nsw i32 %117, 2
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %6, i64 %119
%121 = shl nsw i32 %114, 4
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %2, i64 %122
%124 = load double, double* %120
%125 = load double, double* %123
%126 = fmul double %124, %125
%127 = load double, double* %34
%128 = fmul double %126, %127
%129 = getelementptr inbounds double, double* %120, i64 1
%130 = load double, double* %129
%131 = getelementptr inbounds double, double* %123, i64 1
%132 = load double, double* %131
%133 = fmul double %130, %132
%134 = load double, double* %42
%135 = tail call double @llvm.fmuladd.f64(double %133, double %134, double %128)
%136 = getelementptr inbounds double, double* %120, i64 2
%137 = load double, double* %136
%138 = getelementptr inbounds double, double* %123, i64 2
%139 = load double, double* %138
%140 = fmul double %137, %139
%141 = load double, double* %47
%142 = tail call double @llvm.fmuladd.f64(double %140, double %141, double %135)
%143 = getelementptr inbounds double, double* %120, i64 3
%144 = load double, double* %143
%145 = getelementptr inbounds double, double* %123, i64 3
%146 = load double, double* %145
%147 = fmul double %144, %146
%148 = load double, double* %52
%149 = tail call double @llvm.fmuladd.f64(double %147, double %148, double %142)
%150 = getelementptr inbounds double, double* %123, i64 4
%151 = load double, double* %150
%152 = fmul double %124, %151
%153 = load double, double* %55
%154 = tail call double @llvm.fmuladd.f64(double %152, double %153, double %149)
%155 = getelementptr inbounds double, double* %123, i64 5
%156 = load double, double* %155
%157 = fmul double %130, %156
%158 = load double, double* %60
%159 = tail call double @llvm.fmuladd.f64(double %157, double %158, double %154)
%160 = getelementptr inbounds double, double* %123, i64 6
%161 = load double, double* %160
%162 = fmul double %137, %161
%163 = load double, double* %65
%164 = tail call double @llvm.fmuladd.f64(double %162, double %163, double %159)
%165 = getelementptr inbounds double, double* %123, i64 7
%166 = load double, double* %165
%167 = fmul double %144, %166
%168 = load double, double* %70
%169 = tail call double @llvm.fmuladd.f64(double %167, double %168, double %164)
%170 = getelementptr inbounds double, double* %123, i64 8
%171 = load double, double* %170
%172 = fmul double %124, %171
%173 = load double, double* %73
%174 = tail call double @llvm.fmuladd.f64(double %172, double %173, double %169)
%175 = getelementptr inbounds double, double* %123, i64 9
%176 = load double, double* %175
%177 = fmul double %130, %176
%178 = load double, double* %78
%179 = tail call double @llvm.fmuladd.f64(double %177, double %178, double %174)
%180 = getelementptr inbounds double, double* %123, i64 10
%181 = load double, double* %180
%182 = fmul double %137, %181
%183 = load double, double* %83
%184 = tail call double @llvm.fmuladd.f64(double %182, double %183, double %179)
%185 = getelementptr inbounds double, double* %123, i64 11
%186 = load double, double* %185
%187 = fmul double %144, %186
%188 = load double, double* %88
%189 = tail call double @llvm.fmuladd.f64(double %187, double %188, double %184)
%190 = getelementptr inbounds double, double* %123, i64 12
%191 = load double, double* %190
%192 = fmul double %124, %191
%193 = load double, double* %91
%194 = tail call double @llvm.fmuladd.f64(double %192, double %193, double %189)
%195 = getelementptr inbounds double, double* %123, i64 13
%196 = load double, double* %195
%197 = fmul double %130, %196
%198 = load double, double* %96
%199 = tail call double @llvm.fmuladd.f64(double %197, double %198, double %194)
%200 = getelementptr inbounds double, double* %123, i64 14
%201 = load double, double* %200
%202 = fmul double %137, %201
%203 = load double, double* %101
%204 = tail call double @llvm.fmuladd.f64(double %202, double %203, double %199)
%205 = getelementptr inbounds double, double* %123, i64 15
%206 = load double, double* %205
%207 = fmul double %144, %206
%208 = tail call double @llvm.fmuladd.f64(double %207, double %112, double %204)
%209 = getelementptr inbounds i32, i32* %1, i64 %113
%210 = load i32, i32* %209
%211 = icmp slt i32 %210, 4
br i1 %211, label %212, label %222
212: ; preds = %111
%213 = sext i32 %210 to i64
%214 = getelementptr inbounds [4 x double], [4 x double]* %14, i64 0, i64 %213
%215 = load double, double* %214
%216 = tail call double @llvm.fmuladd.f64(double %107, double %208, double %215)
%217 = getelementptr inbounds i32, i32* %0, i64 %113
%218 = load i32, i32* %217
%219 = tail call double @pow(double 0x2FF0000000000000, i32 %218)
%220 = fmul double %216, %219
%221 = tail call i32 @log(double %220)
br label %230
222: ; preds = %111
%223 = fmul double %107, %208
%224 = tail call i32 @log(double %223)
%225 = getelementptr inbounds i32, i32* %0, i64 %113
%226 = load i32, i32* %225
%227 = tail call i32 @log(double 0x2FF0000000000000)
%228 = mul nsw i32 %227, %226
%229 = add nsw i32 %228, %224
br label %230
230: ; preds = %222, %212
%231 = phi i32 [ %221, %212 ], [ %229, %222 ]
%232 = sitofp i32 %231 to double
%233 = getelementptr inbounds double, double* %3, i64 %113
store double %232, double* %233
%234 = add nsw i64 %113, 1
%235 = trunc i64 %234 to i32
%236 = icmp eq i32 %235, %12
br i1 %236, label %239, label %237
237: ; preds = %230
%238 = load double, double* %106
br label %111
239: ; preds = %230, %13
%240 = tail call i32 @free(double* %34)
ret void
}