#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 */
int /*<<< orphan*/ exp(double);
int /*<<< orphan*/ free(double *);
int log(double);
scalar_t__ malloc(int);
double pow(double, int);
void evaluateGTRGAMMAPROTINVAR_VECTOR(int *ex2, int *iptr, double *x2,
                                      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, j;
  double *diagptable, *diagptable_start;
  double *left, *right;
  double scaler = 0.25 * (1.0 - invariants);
  double freqs[20];
  for (i = 0; i < 20; i++)
    freqs[i] = tFreqs[i] * invariants;
  z = pz;
  if (z < 1.0E-15)
    z = 1.0E-15;
  lz = log(z);
  diagptable = diagptable_start = (double *)malloc(sizeof(double) * 4 * 19);
  for (i = 0; i < 4; i++) {
    ki = gammaRates[i];
    for (j = 0; j < 19; j++)
      *diagptable++ = exp(EIGN[j] * ki * lz);
  }
  for (i = lower; i < n; i++) {
    left = &(tipVector[20 * tipX1[i]]);
    diagptable = diagptable_start;
    term = 0;
    for (j = 0; j < 4; j++) {
      right = &(x2[80 * i + 20 * j]);
      term += left[0] * right[0];
      term += left[1] * right[1] * *diagptable++;
      term += left[2] * right[2] * *diagptable++;
      term += left[3] * right[3] * *diagptable++;
      term += left[4] * right[4] * *diagptable++;
      term += left[5] * right[5] * *diagptable++;
      term += left[6] * right[6] * *diagptable++;
      term += left[7] * right[7] * *diagptable++;
      term += left[8] * right[8] * *diagptable++;
      term += left[9] * right[9] * *diagptable++;
      term += left[10] * right[10] * *diagptable++;
      term += left[11] * right[11] * *diagptable++;
      term += left[12] * right[12] * *diagptable++;
      term += left[13] * right[13] * *diagptable++;
      term += left[14] * right[14] * *diagptable++;
      term += left[15] * right[15] * *diagptable++;
      term += left[16] * right[16] * *diagptable++;
      term += left[17] * right[17] * *diagptable++;
      term += left[18] * right[18] * *diagptable++;
      term += left[19] * right[19] * *diagptable++;
    }
    if (iptr[i] < 20)
      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_start);
}


x86 assembly (clang, -O0):
<evaluateGTRGAMMAPROTINVAR_VECTOR>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%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  0xe71(%rip),%xmm1
subsd  -0x38(%rbp),%xmm1
movsd  0xe5c(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x64(%rbp)
cmpl   $0x14,-0x64(%rbp)
jge    11ee <evaluateGTRGAMMAPROTINVAR_VECTOR+0x9e>
mov    0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x38(%rbp),%xmm0
movslq -0x64(%rbp),%rax
movsd  %xmm0,-0x130(%rbp,%rax,8)
ff ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11b7 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x67>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xe10(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    1218 <evaluateGTRGAMMAPROTINVAR_VECTOR+0xc8>
movsd  0xdfd(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1060 <log@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    $0x260,%edi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    12c5 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x175>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x13,-0x68(%rbp)
jge    12b2 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x162>
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
call   1050 <exp@plt>
cvtsi2sd %eax,%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  %xmm0,(%rax)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1267 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x117>
jmp    12b7 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x167>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1244 <evaluateGTRGAMMAPROTINVAR_VECTOR+0xf4>
mov    0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    18c1 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x771>
mov    0x10(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
imul   $0x14,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x4,-0x68(%rbp)
jge    17d1 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x681>
mov    -0x18(%rbp),%rax
imul   $0x50,-0x64(%rbp),%ecx
imul   $0x14,-0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x88(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x50(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x78(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x80(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x80(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x88(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x90(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x90(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x88(%rbp),%rax
mulsd  0x98(%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    130f <evaluateGTRGAMMAPROTINVAR_VECTOR+0x1bf>
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
cmpl   $0x14,(%rax,%rcx,4)
jge    184f <evaluateGTRGAMMAPROTINVAR_VECTOR+0x6ff>
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
movsd  0x7f0(%rip),%xmm0
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x138(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
call   1060 <log@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    18a1 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x751>
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x58(%rbp),%xmm0
call   1060 <log@plt>
mov    %eax,-0x13c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x140(%rbp)
movsd  0x798(%rip),%xmm0
call   1060 <log@plt>
mov    -0x140(%rbp),%ecx
mov    %eax,%edx
mov    -0x13c(%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    12cb <evaluateGTRGAMMAPROTINVAR_VECTOR+0x17b>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<evaluateGTRGAMMAPROTINVAR_VECTOR>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9,%r15
mov    %r8,%r14
mov    %rcx,0x38(%rsp)
mov    %rdx,%rbx
mov    %rsi,0x48(%rsp)
mov    %rdi,0x30(%rsp)
mov    0x180(%rsp),%eax
mov    %eax,0x14(%rsp)
mov    0x178(%rsp),%eax
mov    %eax,0x20(%rsp)
mov    0x170(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x160(%rsp),%r12
mov    0x168(%rsp),%rax
movsd  0xe4c(%rip),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x18(%rsp)
movupd (%rax),%xmm2
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm2
movapd %xmm2,0x80(%rsp)
movupd 0x10(%rax),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,0x90(%rsp)
movupd 0x20(%rax),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,0xa0(%rsp)
movupd 0x30(%rax),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,0xb0(%rsp)
movupd 0x40(%rax),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,0xc0(%rsp)
movupd 0x50(%rax),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,0xd0(%rsp)
movupd 0x60(%rax),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,0xe0(%rsp)
movupd 0x70(%rax),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,0xf0(%rsp)
movupd 0x80(%rax),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,0x100(%rsp)
movupd 0x90(%rax),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,0x110(%rsp)
movsd  0xd85(%rip),%xmm0
maxsd  %xmm1,%xmm0
call   1060 <log@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
mov    $0x260,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
mov    %r15,%rbp
movsd  (%r15),%xmm0
movsd  %xmm0,(%rsp)
xor    %r15d,%r15d
mov    %rax,0x28(%rsp)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%r15,8),%xmm0
mulsd  (%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13)
add    $0x8,%r13
add    $0x1,%r15
cmp    $0x13,%r15
jne    12c0 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x170>
mov    %rbp,%r15
movsd  0x8(%rbp),%xmm0
movsd  %xmm0,(%rsp)
xor    %ebp,%ebp
movsd  (%r14,%rbp,1),%xmm0
mulsd  (%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13,%rbp,1)
add    $0x8,%rbp
cmp    $0x98,%rbp
jne    1300 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x1b0>
movsd  0x10(%r15),%xmm0
movsd  %xmm0,(%rsp)
add    %rbp,%r13
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rbp,8),%xmm0
mulsd  (%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13)
add    $0x8,%r13
add    $0x1,%rbp
cmp    $0x13,%rbp
jne    1350 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x200>
movsd  0x18(%r15),%xmm0
movsd  %xmm0,(%rsp)
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  (%r14,%rbp,8),%xmm0
mulsd  (%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13)
add    $0x8,%r13
add    $0x1,%rbp
cmp    $0x13,%rbp
jne    1390 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x240>
mov    0x14(%rsp),%esi
mov    0x20(%rsp),%eax
cmp    %esi,%eax
mov    0x38(%rsp),%r13
mov    0x28(%rsp),%r14
jge    1751 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x601>
movsd  0x18(%rsp),%xmm0
mulsd  0xc27(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
movslq %eax,%r15
lea    (%r15,%r15,4),%rax
shl    $0x7,%rax
add    %rax,%rbx
jmp    1455 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x305>
nop
mulsd  0x18(%rsp),%xmm0
call   1060 <log@plt>
mov    %eax,%r14d
mov    0x30(%rsp),%rax
mov    (%rax,%r15,4),%ebp
movsd  0xbf9(%rip),%xmm0
call   1060 <log@plt>
imul   %ebp,%eax
mov    0x14(%rsp),%esi
add    %r14d,%eax
mov    0x28(%rsp),%r14
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13,%r15,8)
add    $0x1,%r15
add    $0x280,%rbx
cmp    %esi,%r15d
je     1751 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x601>
mov    0x40(%rsp),%rax
movsbq (%rax,%r15,1),%rax
lea    (%rax,%rax,4),%rdx
shl    $0x5,%rdx
movsd  (%r12,%rdx,1),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x8(%r12,%rdx,1),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x10(%r12,%rdx,1),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x18(%r12,%rdx,1),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0x20(%r12,%rdx,1),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0x28(%r12,%rdx,1),%xmm0
movsd  %xmm0,0x68(%rsp)
movsd  0x30(%r12,%rdx,1),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x38(%r12,%rdx,1),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x40(%r12,%rdx,1),%xmm0
movsd  %xmm0,0x50(%rsp)
movsd  0x48(%r12,%rdx,1),%xmm15
movsd  0x50(%r12,%rdx,1),%xmm14
movsd  0x58(%r12,%rdx,1),%xmm3
movsd  0x60(%r12,%rdx,1),%xmm4
movsd  0x68(%r12,%rdx,1),%xmm5
movsd  0x70(%r12,%rdx,1),%xmm6
movsd  0x78(%r12,%rdx,1),%xmm7
mov    $0x98,%eax
mov    %r14,%rcx
movsd  0x80(%r12,%rdx,1),%xmm8
movsd  0x88(%r12,%rdx,1),%xmm9
movsd  0x90(%r12,%rdx,1),%xmm10
movsd  0x98(%r12,%rdx,1),%xmm11
xorpd  %xmm0,%xmm0
nop
movsd  -0x98(%rbx,%rax,1),%xmm12
ff ff ff
mulsd  0x8(%rsp),%xmm12
addsd  %xmm0,%xmm12
movsd  -0x90(%rbx,%rax,1),%xmm13
ff ff ff
mulsd  (%rsp),%xmm13
mulsd  (%rcx),%xmm13
addsd  %xmm12,%xmm13
movsd  -0x88(%rbx,%rax,1),%xmm0
ff ff
mulsd  0x20(%rsp),%xmm0
mulsd  0x8(%rcx),%xmm0
addsd  %xmm13,%xmm0
movsd  -0x80(%rbx,%rax,1),%xmm1
mulsd  0x78(%rsp),%xmm1
mulsd  0x10(%rcx),%xmm1
movsd  -0x78(%rbx,%rax,1),%xmm2
mulsd  0x70(%rsp),%xmm2
mulsd  0x18(%rcx),%xmm2
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm2
movsd  -0x70(%rbx,%rax,1),%xmm0
mulsd  0x68(%rsp),%xmm0
mulsd  0x20(%rcx),%xmm0
addsd  %xmm2,%xmm0
movsd  -0x68(%rbx,%rax,1),%xmm1
mulsd  0x60(%rsp),%xmm1
mulsd  0x28(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbx,%rax,1),%xmm0
mulsd  0x58(%rsp),%xmm0
mulsd  0x30(%rcx),%xmm0
movsd  -0x58(%rbx,%rax,1),%xmm2
mulsd  0x50(%rsp),%xmm2
mulsd  0x38(%rcx),%xmm2
addsd  %xmm1,%xmm0
addsd  %xmm0,%xmm2
movsd  -0x50(%rbx,%rax,1),%xmm0
mulsd  %xmm15,%xmm0
mulsd  0x40(%rcx),%xmm0
addsd  %xmm2,%xmm0
movsd  -0x48(%rbx,%rax,1),%xmm1
mulsd  %xmm14,%xmm1
mulsd  0x48(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbx,%rax,1),%xmm0
mulsd  %xmm3,%xmm0
mulsd  0x50(%rcx),%xmm0
movsd  -0x38(%rbx,%rax,1),%xmm2
mulsd  %xmm4,%xmm2
mulsd  0x58(%rcx),%xmm2
addsd  %xmm1,%xmm0
addsd  %xmm0,%xmm2
movsd  -0x30(%rbx,%rax,1),%xmm0
mulsd  %xmm5,%xmm0
mulsd  0x60(%rcx),%xmm0
addsd  %xmm2,%xmm0
movsd  -0x28(%rbx,%rax,1),%xmm1
mulsd  %xmm6,%xmm1
mulsd  0x68(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x20(%rbx,%rax,1),%xmm0
mulsd  %xmm7,%xmm0
mulsd  0x70(%rcx),%xmm0
movsd  -0x18(%rbx,%rax,1),%xmm2
mulsd  %xmm8,%xmm2
mulsd  0x78(%rcx),%xmm2
addsd  %xmm1,%xmm0
addsd  %xmm0,%xmm2
movsd  -0x10(%rbx,%rax,1),%xmm0
mulsd  %xmm9,%xmm0
mulsd  0x80(%rcx),%xmm0
addsd  %xmm2,%xmm0
movsd  -0x8(%rbx,%rax,1),%xmm1
mulsd  %xmm10,%xmm1
mulsd  0x88(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rbx,%rax,1),%xmm0
mulsd  %xmm11,%xmm0
mulsd  0x90(%rcx),%xmm0
addsd  %xmm1,%xmm0
add    $0xa0,%rax
add    $0x98,%rcx
cmp    $0x318,%rax
jne    1540 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x3f0>
mov    0x48(%rsp),%rax
movslq (%rax,%r15,4),%rax
cmp    $0x13,%rax
jg     1400 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x2b0>
mulsd  0x18(%rsp),%xmm0
addsd  0x80(%rsp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x30(%rsp),%rax
mov    (%rax,%r15,4),%edi
movsd  0x8e0(%rip),%xmm0
mov    %esi,%ebp
call   1070 <pow@plt>
mulsd  0x8(%rsp),%xmm0
call   1060 <log@plt>
mov    %ebp,%esi
jmp    1433 <evaluateGTRGAMMAPROTINVAR_VECTOR+0x2e3>
mov    %r14,%rdi
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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