#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);
void evaluateGTRGAMMAPROT_VECTOR(int *ex2, double *x2, double *v, double *EIGN,
                                 double *gammaRates, double *tipVector,
                                 double pz, char *tipX1, int lower, int n) {
  double z, lz, term, ki;
  int i, j;
  double *diagptable, *diagptable_start;
  double *left, *right;
  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++;
    }
    term =
        log(0.25 * term) +
        ex2[i] *
            log((
                1.0 /
                115792089237316195423570985008687907853269984665640564039457584007913129639936.0));
    v[i] = term;
  }
  free(diagptable_start);
}


x86 assembly (clang, -O0):
<evaluateGTRGAMMAPROT_VECTOR>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
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  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xe7c(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    119c <evaluateGTRGAMMAPROT_VECTOR+0x5c>
movsd  0xe69(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1060 <log@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    $0x260,%edi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpl   $0x4,-0x5c(%rbp)
jge    1249 <evaluateGTRGAMMAPROT_VECTOR+0x109>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x13,-0x60(%rbp)
jge    1236 <evaluateGTRGAMMAPROT_VECTOR+0xf6>
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x58(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
call   1050 <exp@plt>
cvtsi2sd %eax,%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  %xmm0,(%rax)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    11eb <evaluateGTRGAMMAPROT_VECTOR+0xab>
jmp    123b <evaluateGTRGAMMAPROT_VECTOR+0xfb>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11c8 <evaluateGTRGAMMAPROT_VECTOR+0x88>
mov    0x18(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1788 <evaluateGTRGAMMAPROT_VECTOR+0x648>
mov    -0x30(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
imul   $0x14,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x4,-0x60(%rbp)
jge    1716 <evaluateGTRGAMMAPROT_VECTOR+0x5d6>
mov    -0x10(%rbp),%rax
imul   $0x50,-0x5c(%rbp),%ecx
imul   $0x14,-0x60(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x80(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x50(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x78(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x80(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x80(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x88(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x90(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x90(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x80(%rbp),%rax
mulsd  0x98(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1293 <evaluateGTRGAMMAPROT_VECTOR+0x153>
movsd  0x8f2(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
call   1060 <log@plt>
mov    %eax,-0x84(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
movsd  0x8c1(%rip),%xmm0
call   1060 <log@plt>
mov    -0x88(%rbp),%ecx
mov    %eax,%edx
mov    -0x84(%rbp),%eax
imul   %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    124f <evaluateGTRGAMMAPROT_VECTOR+0x10f>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<evaluateGTRGAMMAPROT_VECTOR>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,%r15
mov    %r8,%rbp
mov    %rcx,%r14
mov    %rdx,0x48(%rsp)
mov    %rsi,%rbx
mov    %rdi,0x40(%rsp)
mov    0xb0(%rsp),%eax
mov    %eax,0x28(%rsp)
mov    0xa8(%rsp),%eax
mov    %eax,0x20(%rsp)
mov    0xa0(%rsp),%rax
mov    %rax,0x38(%rsp)
movsd  0xe71(%rip),%xmm1
maxsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1060 <log@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x260,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
mov    %rbp,0x18(%rsp)
movsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %r12d,%r12d
mov    %rax,0x30(%rsp)
xchg   %ax,%ax
movsd  (%r14,%r12,8),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0x10(%rsp),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13)
add    $0x8,%r13
add    $0x1,%r12
cmp    $0x13,%r12
jne    11d0 <evaluateGTRGAMMAPROT_VECTOR+0x90>
mov    0x18(%rsp),%r12
movsd  0x8(%r12),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rbp,1),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0x10(%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    1220 <evaluateGTRGAMMAPROT_VECTOR+0xe0>
movsd  0x10(%r12),%xmm0
movsd  %xmm0,0x8(%rsp)
add    %rbp,%r13
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r14,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0x10(%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    1270 <evaluateGTRGAMMAPROT_VECTOR+0x130>
movsd  0x18(%r12),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0x10(%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    12c0 <evaluateGTRGAMMAPROT_VECTOR+0x180>
mov    0x28(%rsp),%eax
mov    0x20(%rsp),%ecx
cmp    %eax,%ecx
jge    161d <evaluateGTRGAMMAPROT_VECTOR+0x4dd>
movslq %ecx,%r14
movslq %eax,%r12
lea    (%r14,%r14,4),%rax
shl    $0x7,%rax
add    %rax,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x38(%rsp),%rax
movsbq (%rax,%r14,1),%rax
lea    (%rax,%rax,4),%rdx
shl    $0x5,%rdx
movsd  (%r15,%rdx,1),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%r15,%rdx,1),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%r15,%rdx,1),%xmm0
movsd  %xmm0,0x28(%rsp)
movsd  0x18(%r15,%rdx,1),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x20(%r15,%rdx,1),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x28(%r15,%rdx,1),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x30(%r15,%rdx,1),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x38(%r15,%rdx,1),%xmm0
movsd  %xmm0,0x50(%rsp)
movsd  0x40(%r15,%rdx,1),%xmm14
movsd  0x48(%r15,%rdx,1),%xmm15
movsd  0x50(%r15,%rdx,1),%xmm4
movsd  0x58(%r15,%rdx,1),%xmm5
movsd  0x60(%r15,%rdx,1),%xmm6
movsd  0x68(%r15,%rdx,1),%xmm7
movsd  0x70(%r15,%rdx,1),%xmm1
movsd  0x78(%r15,%rdx,1),%xmm8
mov    $0x98,%eax
mov    0x30(%rsp),%rcx
movsd  0x80(%r15,%rdx,1),%xmm9
movsd  0x88(%r15,%rdx,1),%xmm10
movsd  0x90(%r15,%rdx,1),%xmm11
movsd  0x98(%r15,%rdx,1),%xmm12
xorpd  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movsd  -0x98(%rbx,%rax,1),%xmm13
ff ff ff
mulsd  0x10(%rsp),%xmm13
addsd  %xmm0,%xmm13
movsd  -0x90(%rbx,%rax,1),%xmm0
ff ff
mulsd  0x8(%rsp),%xmm0
mulsd  (%rcx),%xmm0
addsd  %xmm13,%xmm0
movsd  -0x88(%rbx,%rax,1),%xmm2
ff ff
mulsd  0x28(%rsp),%xmm2
mulsd  0x8(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  -0x80(%rbx,%rax,1),%xmm0
mulsd  0x20(%rsp),%xmm0
mulsd  0x10(%rcx),%xmm0
movsd  -0x78(%rbx,%rax,1),%xmm3
mulsd  0x18(%rsp),%xmm3
mulsd  0x18(%rcx),%xmm3
addsd  %xmm2,%xmm0
addsd  %xmm0,%xmm3
movsd  -0x70(%rbx,%rax,1),%xmm0
mulsd  0x60(%rsp),%xmm0
mulsd  0x20(%rcx),%xmm0
addsd  %xmm3,%xmm0
movsd  -0x68(%rbx,%rax,1),%xmm2
mulsd  0x58(%rsp),%xmm2
mulsd  0x28(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  -0x60(%rbx,%rax,1),%xmm0
mulsd  0x50(%rsp),%xmm0
mulsd  0x30(%rcx),%xmm0
movsd  -0x58(%rbx,%rax,1),%xmm3
mulsd  %xmm14,%xmm3
mulsd  0x38(%rcx),%xmm3
addsd  %xmm2,%xmm0
addsd  %xmm0,%xmm3
movsd  -0x50(%rbx,%rax,1),%xmm0
mulsd  %xmm15,%xmm0
mulsd  0x40(%rcx),%xmm0
addsd  %xmm3,%xmm0
movsd  -0x48(%rbx,%rax,1),%xmm2
mulsd  %xmm4,%xmm2
mulsd  0x48(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  -0x40(%rbx,%rax,1),%xmm0
mulsd  %xmm5,%xmm0
mulsd  0x50(%rcx),%xmm0
movsd  -0x38(%rbx,%rax,1),%xmm3
mulsd  %xmm6,%xmm3
mulsd  0x58(%rcx),%xmm3
addsd  %xmm2,%xmm0
addsd  %xmm0,%xmm3
movsd  -0x30(%rbx,%rax,1),%xmm0
mulsd  %xmm7,%xmm0
mulsd  0x60(%rcx),%xmm0
addsd  %xmm3,%xmm0
movsd  -0x28(%rbx,%rax,1),%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x68(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  -0x20(%rbx,%rax,1),%xmm0
mulsd  %xmm8,%xmm0
mulsd  0x70(%rcx),%xmm0
movsd  -0x18(%rbx,%rax,1),%xmm3
mulsd  %xmm9,%xmm3
mulsd  0x78(%rcx),%xmm3
addsd  %xmm2,%xmm0
addsd  %xmm0,%xmm3
movsd  -0x10(%rbx,%rax,1),%xmm0
mulsd  %xmm10,%xmm0
mulsd  0x80(%rcx),%xmm0
addsd  %xmm3,%xmm0
movsd  -0x8(%rbx,%rax,1),%xmm2
mulsd  %xmm11,%xmm2
mulsd  0x88(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  (%rbx,%rax,1),%xmm0
mulsd  %xmm12,%xmm0
mulsd  0x90(%rcx),%xmm0
addsd  %xmm2,%xmm0
add    $0xa0,%rax
add    $0x98,%rcx
cmp    $0x318,%rax
jne    1410 <evaluateGTRGAMMAPROT_VECTOR+0x2d0>
mulsd  0xa35(%rip),%xmm0
call   1060 <log@plt>
mov    %eax,%r13d
mov    0x40(%rsp),%rax
mov    (%rax,%r14,4),%ebp
movsd  0xa24(%rip),%xmm0
call   1060 <log@plt>
imul   %ebp,%eax
add    %r13d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x48(%rsp),%rax
movsd  %xmm0,(%rax,%r14,8)
add    $0x1,%r14
add    $0x280,%rbx
cmp    %r12,%r14
jne    1320 <evaluateGTRGAMMAPROT_VECTOR+0x1e0>
mov    0x30(%rsp),%rdi
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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