void evaluateGTRCAT_VECTOR(int *ex2, int *cptr, double *x2_start, double *v,
                           double *EIGN, double *rptr, double *tipVector,
                           double pz, char *tipX1, int lower, int n,
                           int numberOfCategories) {
  double z, lz, ki, lz1, lz2, lz3, term;
  int i;
  double *diagptable, *diagptable_start;
  double *x1, *x2;
  z = pz;
  if (z < 1.0E-15)
    z = 1.0E-15;
  lz = log(z);
  lz1 = EIGN[0] * lz;
  lz2 = EIGN[1] * lz;
  lz3 = EIGN[2] * lz;
  diagptable = diagptable_start =
      (double *)malloc(sizeof(double) * numberOfCategories * 3);
  for (i = 0; i < numberOfCategories; i++) {
    ki = rptr[i];
    *diagptable++ = exp(ki * lz1);
    *diagptable++ = exp(ki * lz2);
    *diagptable++ = exp(ki * lz3);
  }
  for (i = lower; i < n; i++) {
    x1 = &(tipVector[4 * tipX1[i]]);
    x2 = &x2_start[4 * i];
    diagptable = &diagptable_start[3 * cptr[i]];
    term = x1[0] * x2[0];
    term += x1[1] * x2[1] * *diagptable++;
    term += x1[2] * x2[2] * *diagptable++;
    term += x1[3] * x2[3] * *diagptable++;
    term =
        log(term) +
        (ex2[i] *
         log((
             1.0 /
             115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
    v[i] = term;
  }
  free(diagptable_start);
}


x86 assembly (clang, -O0):
<evaluateGTRCAT_VECTOR>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
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  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xe75(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    11a3 <evaluateGTRCAT_VECTOR+0x63>
movsd  0xe62(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movslq 0x30(%rbp),%rax
shl    $0x3,%rax
imul   $0x3,%rax,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    129f <evaluateGTRCAT_VECTOR+0x15f>
mov    -0x30(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    120d <evaluateGTRCAT_VECTOR+0xcd>
mov    0x20(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1457 <evaluateGTRCAT_VECTOR+0x317>
mov    0x10(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x74(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x74(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x74(%rbp),%rdx
imul   $0x3,(%rcx,%rdx,4),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x90(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x98(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x90(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x98(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  (%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x90(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x98(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  (%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x90(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x98(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
movsd  (%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xbf6(%rip),%xmm0
call   1060 <log@plt>
movsd  -0xa8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12a5 <evaluateGTRCAT_VECTOR+0x165>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<evaluateGTRCAT_VECTOR>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,0x60(%rsp)
mov    %r8,%r13
mov    %rcx,0x40(%rsp)
mov    %rdx,0x38(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rdi,0x20(%rsp)
movslq 0xc0(%rsp),%rbp
mov    0xb8(%rsp),%eax
mov    %eax,0xc(%rsp)
mov    0xb0(%rsp),%r14d
mov    0xa8(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    0xa0(%rsp),%r12
movsd  0xe5e(%rip),%xmm1
maxsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1060 <log@plt>
movsd  0x0(%r13),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp)
movsd  0x8(%r13),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x48(%rsp)
mulsd  0x10(%r13),%xmm0
movsd  %xmm0,0x58(%rsp)
lea    0x0(,%rbp,8),%rax
lea    (%rax,%rax,2),%rdi
call   1040 <malloc@plt>
mov    %rax,0x10(%rsp)
test   %rbp,%rbp
jle    125e <evaluateGTRCAT_VECTOR+0x11e>
mov    %ebp,%ebp
xor    %r15d,%r15d
mov    0x10(%rsp),%r13
mov    0x60(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
movsd  %xmm1,(%rsp)
movsd  0x50(%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x0(%r13)
movsd  0x48(%rsp),%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x8(%r13)
movsd  (%rsp),%xmm0
mulsd  0x58(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x10(%r13)
add    $0x1,%r15
add    $0x18,%r13
cmp    %r15,%rbp
jne    1200 <evaluateGTRCAT_VECTOR+0xc0>
mov    0xc(%rsp),%eax
cmp    %eax,%r14d
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%r13
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r15
jge    1351 <evaluateGTRCAT_VECTOR+0x211>
movslq %r14d,%rbp
cltq
mov    %rax,(%rsp)
shl    $0x2,%r14d
mov    %r12,0x30(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbq (%r8,%rbp,1),%rax
shl    $0x5,%rax
movslq %r14d,%r14
movslq (%rbx,%rbp,4),%rcx
movsd  (%r12,%rax,1),%xmm0
movsd  0x8(%r12,%rax,1),%xmm1
mov    0x38(%rsp),%rdx
mulsd  (%rdx,%r14,8),%xmm0
mulsd  0x8(%rdx,%r14,8),%xmm1
lea    (%rcx,%rcx,2),%rcx
mulsd  (%r15,%rcx,8),%xmm1
movsd  0x10(%r12,%rax,1),%xmm2
mulsd  0x10(%rdx,%r14,8),%xmm2
mulsd  0x8(%r15,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%r12,%rax,1),%xmm0
mulsd  0x18(%rdx,%r14,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x10(%r15,%rcx,8),%xmm0
addsd  %xmm2,%xmm0
mov    %r8,%r12
call   1060 <log@plt>
mov    %r12,%r8
mov    0x30(%rsp),%r12
mov    0x40(%rsp),%rcx
xorps  %xmm1,%xmm1
cvtsi2sdl 0x0(%r13,%rbp,4),%xmm1
mulsd  0xcd2(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
add    $0x1,%rbp
add    $0x4,%r14d
cmp    %rbp,(%rsp)
jne    12a0 <evaluateGTRCAT_VECTOR+0x160>
mov    %r15,%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 @evaluateGTRCAT_VECTOR(i32* %0, i32* %1, double* %2, double* %3, double* %4, double* %5, double* %6, double %7, i8* %8, i32 %9, i32 %10, i32 %11) {
%13 = alloca i32*
%14 = alloca i32*
%15 = alloca double*
%16 = alloca double*
%17 = alloca double*
%18 = alloca double*
%19 = alloca double*
%20 = alloca double
%21 = alloca i8*
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca i32
%33 = alloca double*
%34 = alloca double*
%35 = alloca double*
%36 = alloca double*
store i32* %0, i32** %13
store i32* %1, i32** %14
store double* %2, double** %15
store double* %3, double** %16
store double* %4, double** %17
store double* %5, double** %18
store double* %6, double** %19
store double %7, double* %20
store i8* %8, i8** %21
store i32 %9, i32* %22
store i32 %10, i32* %23
store i32 %11, i32* %24
%37 = load double, double* %20
store double %37, double* %25
%38 = load double, double* %25
%39 = fcmp olt double %38, 1.000000e-15
br i1 %39, label %40, label %41
40: ; preds = %12
store double 1.000000e-15, double* %25
br label %41
41: ; preds = %40, %12
%42 = load double, double* %25
%43 = call double @log(double %42)
store double %43, double* %26
%44 = load double*, double** %17
%45 = getelementptr inbounds double, double* %44, i64 0
%46 = load double, double* %45
%47 = load double, double* %26
%48 = fmul double %46, %47
store double %48, double* %28
%49 = load double*, double** %17
%50 = getelementptr inbounds double, double* %49, i64 1
%51 = load double, double* %50
%52 = load double, double* %26
%53 = fmul double %51, %52
store double %53, double* %29
%54 = load double*, double** %17
%55 = getelementptr inbounds double, double* %54, i64 2
%56 = load double, double* %55
%57 = load double, double* %26
%58 = fmul double %56, %57
store double %58, double* %30
%59 = load i32, i32* %24
%60 = sext i32 %59 to i64
%61 = mul i64 8, %60
%62 = mul i64 %61, 3
%63 = call i8* @malloc(i64 %62)
%64 = bitcast i8* %63 to double*
store double* %64, double** %34
store double* %64, double** %33
store i32 0, i32* %32
br label %65
65: ; preds = %93, %41
%66 = load i32, i32* %32
%67 = load i32, i32* %24
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %96
69: ; preds = %65
%70 = load double*, double** %18
%71 = load i32, i32* %32
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %70, i64 %72
%74 = load double, double* %73
store double %74, double* %27
%75 = load double, double* %27
%76 = load double, double* %28
%77 = fmul double %75, %76
%78 = call double @exp(double %77)
%79 = load double*, double** %33
%80 = getelementptr inbounds double, double* %79, i32 1
store double* %80, double** %33
store double %78, double* %79
%81 = load double, double* %27
%82 = load double, double* %29
%83 = fmul double %81, %82
%84 = call double @exp(double %83)
%85 = load double*, double** %33
%86 = getelementptr inbounds double, double* %85, i32 1
store double* %86, double** %33
store double %84, double* %85
%87 = load double, double* %27
%88 = load double, double* %30
%89 = fmul double %87, %88
%90 = call double @exp(double %89)
%91 = load double*, double** %33
%92 = getelementptr inbounds double, double* %91, i32 1
store double* %92, double** %33
store double %90, double* %91
br label %93
93: ; preds = %69
%94 = load i32, i32* %32
%95 = add nsw i32 %94, 1
store i32 %95, i32* %32
br label %65
96: ; preds = %65
%97 = load i32, i32* %22
store i32 %97, i32* %32
br label %98
98: ; preds = %185, %96
%99 = load i32, i32* %32
%100 = load i32, i32* %23
%101 = icmp slt i32 %99, %100
br i1 %101, label %102, label %188
102: ; preds = %98
%103 = load double*, double** %19
%104 = load i8*, i8** %21
%105 = load i32, i32* %32
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %104, i64 %106
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = mul nsw i32 4, %109
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds double, double* %103, i64 %111
store double* %112, double** %35
%113 = load double*, double** %15
%114 = load i32, i32* %32
%115 = mul nsw i32 4, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %113, i64 %116
store double* %117, double** %36
%118 = load double*, double** %34
%119 = load i32*, i32** %14
%120 = load i32, i32* %32
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i32, i32* %119, i64 %121
%123 = load i32, i32* %122
%124 = mul nsw i32 3, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %118, i64 %125
store double* %126, double** %33
%127 = load double*, double** %35
%128 = getelementptr inbounds double, double* %127, i64 0
%129 = load double, double* %128
%130 = load double*, double** %36
%131 = getelementptr inbounds double, double* %130, i64 0
%132 = load double, double* %131
%133 = fmul double %129, %132
store double %133, double* %31
%134 = load double*, double** %35
%135 = getelementptr inbounds double, double* %134, i64 1
%136 = load double, double* %135
%137 = load double*, double** %36
%138 = getelementptr inbounds double, double* %137, i64 1
%139 = load double, double* %138
%140 = fmul double %136, %139
%141 = load double*, double** %33
%142 = getelementptr inbounds double, double* %141, i32 1
store double* %142, double** %33
%143 = load double, double* %141
%144 = load double, double* %31
%145 = call double @llvm.fmuladd.f64(double %140, double %143, double %144)
store double %145, double* %31
%146 = load double*, double** %35
%147 = getelementptr inbounds double, double* %146, i64 2
%148 = load double, double* %147
%149 = load double*, double** %36
%150 = getelementptr inbounds double, double* %149, i64 2
%151 = load double, double* %150
%152 = fmul double %148, %151
%153 = load double*, double** %33
%154 = getelementptr inbounds double, double* %153, i32 1
store double* %154, double** %33
%155 = load double, double* %153
%156 = load double, double* %31
%157 = call double @llvm.fmuladd.f64(double %152, double %155, double %156)
store double %157, double* %31
%158 = load double*, double** %35
%159 = getelementptr inbounds double, double* %158, i64 3
%160 = load double, double* %159
%161 = load double*, double** %36
%162 = getelementptr inbounds double, double* %161, i64 3
%163 = load double, double* %162
%164 = fmul double %160, %163
%165 = load double*, double** %33
%166 = getelementptr inbounds double, double* %165, i32 1
store double* %166, double** %33
%167 = load double, double* %165
%168 = load double, double* %31
%169 = call double @llvm.fmuladd.f64(double %164, double %167, double %168)
store double %169, double* %31
%170 = load double, double* %31
%171 = call double @log(double %170)
%172 = load i32*, i32** %13
%173 = load i32, i32* %32
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i32, i32* %172, i64 %174
%176 = load i32, i32* %175
%177 = sitofp i32 %176 to double
%178 = call double @log(double 0x2FF0000000000000)
%179 = call double @llvm.fmuladd.f64(double %177, double %178, double %171)
store double %179, double* %31
%180 = load double, double* %31
%181 = load double*, double** %16
%182 = load i32, i32* %32
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %181, i64 %183
store double %180, double* %184
br label %185
185: ; preds = %102
%186 = load i32, i32* %32
%187 = add nsw i32 %186, 1
store i32 %187, i32* %32
br label %98
188: ; preds = %98
%189 = load double*, double** %34
%190 = bitcast double* %189 to i8*
ret void
}

LLVM IR (-O2):
define void @evaluateGTRCAT_VECTOR(i32* nocapture %0, i32* nocapture %1, double* nocapture %2, double* nocapture writeonly %3, double* nocapture %4, double* nocapture %5, double* nocapture %6, double %7, i8* nocapture %8, i32 %9, i32 %10, i32 %11) {
%13 = fcmp olt double %7, 1.000000e-15
%14 = select i1 %13, double 1.000000e-15, double %7
%15 = tail call double @log(double %14)
%16 = load double, double* %4
%17 = fmul double %15, %16
%18 = getelementptr inbounds double, double* %4, i64 1
%19 = load double, double* %18
%20 = fmul double %15, %19
%21 = getelementptr inbounds double, double* %4, i64 2
%22 = load double, double* %21
%23 = fmul double %15, %22
%24 = sext i32 %11 to i64
%25 = mul nsw i64 %24, 24
%26 = tail call i8* @malloc(i64 %25)
%27 = bitcast i8* %26 to double*
%28 = icmp sgt i32 %11, 0
br i1 %28, label %29, label %31
29: ; preds = %12
%30 = zext i32 %11 to i64
br label %36
31: ; preds = %36, %12
%32 = icmp slt i32 %9, %10
br i1 %32, label %33, label %103
33: ; preds = %31
%34 = sext i32 %9 to i64
%35 = sext i32 %10 to i64
br label %52
36: ; preds = %29, %36
%37 = phi i64 [ 0, %29 ], [ %50, %36 ]
%38 = phi double* [ %27, %29 ], [ %49, %36 ]
%39 = getelementptr inbounds double, double* %5, i64 %37
%40 = load double, double* %39
%41 = fmul double %17, %40
%42 = tail call double @exp(double %41)
%43 = getelementptr inbounds double, double* %38, i64 1
store double %42, double* %38
%44 = fmul double %20, %40
%45 = tail call double @exp(double %44)
%46 = getelementptr inbounds double, double* %38, i64 2
store double %45, double* %43
%47 = fmul double %23, %40
%48 = tail call double @exp(double %47)
%49 = getelementptr inbounds double, double* %38, i64 3
store double %48, double* %46
%50 = add nuw nsw i64 %37, 1
%51 = icmp eq i64 %50, %30
br i1 %51, label %31, label %36
52: ; preds = %33, %52
%53 = phi i64 [ %34, %33 ], [ %101, %52 ]
%54 = trunc i64 %53 to i32
%55 = getelementptr inbounds i8, i8* %8, i64 %53
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
%58 = shl nsw i32 %57, 2
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %6, i64 %59
%61 = shl nsw i32 %54, 2
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double, double* %2, i64 %62
%64 = getelementptr inbounds i32, i32* %1, i64 %53
%65 = load i32, i32* %64
%66 = mul nsw i32 %65, 3
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %27, i64 %67
%69 = load double, double* %60
%70 = load double, double* %63
%71 = fmul double %69, %70
%72 = getelementptr inbounds double, double* %60, i64 1
%73 = load double, double* %72
%74 = getelementptr inbounds double, double* %63, i64 1
%75 = load double, double* %74
%76 = fmul double %73, %75
%77 = getelementptr inbounds double, double* %68, i64 1
%78 = load double, double* %68
%79 = tail call double @llvm.fmuladd.f64(double %76, double %78, double %71)
%80 = getelementptr inbounds double, double* %60, i64 2
%81 = load double, double* %80
%82 = getelementptr inbounds double, double* %63, i64 2
%83 = load double, double* %82
%84 = fmul double %81, %83
%85 = getelementptr inbounds double, double* %77, i64 1
%86 = load double, double* %77
%87 = tail call double @llvm.fmuladd.f64(double %84, double %86, double %79)
%88 = getelementptr inbounds double, double* %60, i64 3
%89 = load double, double* %88
%90 = getelementptr inbounds double, double* %63, i64 3
%91 = load double, double* %90
%92 = fmul double %89, %91
%93 = load double, double* %85
%94 = tail call double @llvm.fmuladd.f64(double %92, double %93, double %87)
%95 = tail call double @log(double %94)
%96 = getelementptr inbounds i32, i32* %0, i64 %53
%97 = load i32, i32* %96
%98 = sitofp i32 %97 to double
%99 = tail call double @llvm.fmuladd.f64(double %98, double 0xC0662E42FEFA39EF, double %95)
%100 = getelementptr inbounds double, double* %3, i64 %53
store double %99, double* %100
%101 = add nsw i64 %53, 1
%102 = icmp eq i64 %101, %35
br i1 %102, label %103, label %52
103: ; preds = %52, %31
tail call void @free(i8* %26)
ret void
}