double evaluateGTRGAMMAPROTMULTINVAR(int *ex1, int *ex2, int *modelptr,
                                     int *wptr, int *iptr, double *x1,
                                     double *x2, double *EIGN,
                                     double *gammaRates, double *tipVector,
                                     double *tFreqs, double *invariants,
                                     double *pz, char *tipX1, int lower, int n,
                                     int numberOfModels, int multiBranch) {
  double sum, z, lz = 0.0, term, ki;
  int i, j, model;
  double *diagptable, *diagptable_start, *left, *right, *scalers, *freqs;
  if (!multiBranch) {
    z = pz[0];
    if (z < 1.0E-15)
      z = 1.0E-15;
    lz = log(z);
  }
  diagptable = diagptable_start =
      (double *)malloc(sizeof(double) * 4 * 19 * numberOfModels);
  freqs = (double *)malloc(20 * numberOfModels * sizeof(double));
  scalers = (double *)malloc(numberOfModels * sizeof(double));
  for (model = 0; model < numberOfModels; model++) {
    if (multiBranch) {
      z = pz[model];
      if (z < 1.0E-15)
        z = 1.0E-15;
      lz = log(z);
    }
    diagptable = &diagptable_start[4 * 19 * model];
    scalers[model] = 0.25 * (1.0 - invariants[model]);
    for (i = 0; i < 20; i++)
      freqs[20 * model + i] = tFreqs[20 * model + i] * invariants[model];
    for (i = 0; i < 4; i++) {
      ki = gammaRates[model * 4 + i];
      for (j = 0; j < 19; j++)
        *diagptable++ = exp(EIGN[model * 19 + j] * ki * lz);
    }
  }
  sum = 0.0;
  if (tipX1) {
    for (i = lower; i < n; i++) {
      model = modelptr[i];
      left = &(tipVector[460 * model + 20 * tipX1[i]]);
      diagptable = &diagptable_start[76 * model];
      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(
            ((scalers[model] * term) + freqs[model * 20 + iptr[i]]) *
            pow((1.0 /
                 115792089237316195423570985008687907853269984665640564039457584007913129639936.0),
                ex2[i]));
      else
        term =
            log(scalers[model] * term) +
            (ex2[i] *
             log((
                 1.0 /
                 115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
      sum += wptr[i] * term;
    }
    free(diagptable_start);
    free(freqs);
    free(scalers);
    return sum;
  }
  for (i = lower; i < n; i++) {
    model = modelptr[i];
    diagptable = &diagptable_start[76 * model];
    term = 0;
    for (j = 0; j < 4; j++) {
      left = &(x1[80 * i + 20 * 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(
          ((scalers[model] * term) + freqs[model * 20 + iptr[i]]) *
          pow((1.0 /
               115792089237316195423570985008687907853269984665640564039457584007913129639936.0),
              ex2[i] + ex1[i]));
    else
      term =
          log(scalers[model] * term) +
          ((ex1[i] + ex2[i]) *
           log((
               1.0 /
               115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
    sum += wptr[i] * term;
  }
  free(diagptable_start);
  free(freqs);
  free(scalers);
  return sum;
}


x86 assembly (clang, -O0):
<evaluateGTRGAMMAPROTMULTINVAR>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x68(%rbp),%eax
mov    0x60(%rbp),%eax
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x0,0x68(%rbp)
jne    11ed <evaluateGTRGAMMAPROTMULTINVAR+0x9d>
mov    0x40(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x1e3a(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    11de <evaluateGTRGAMMAPROTMULTINVAR+0x8e>
movsd  0x1e27(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x50(%rbp)
movslq 0x60(%rbp),%rax
imul   $0x260,%rax,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    %rax,-0x78(%rbp)
imul   $0x14,0x60(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq 0x60(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x60(%rbp),%eax
jge    13cf <evaluateGTRGAMMAPROTMULTINVAR+0x27f>
cmpl   $0x0,0x68(%rbp)
je     128e <evaluateGTRGAMMAPROTMULTINVAR+0x13e>
mov    0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x1d99(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    127f <evaluateGTRGAMMAPROTMULTINVAR+0x12f>
movsd  0x1d86(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x50(%rbp)
mov    -0x80(%rbp),%rax
imul   $0x4c,-0x6c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  0x1d64(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
movsd  0x1d4f(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x64(%rbp)
cmpl   $0x14,-0x64(%rbp)
jge    132a <evaluateGTRGAMMAPROTMULTINVAR+0x1da>
mov    0x30(%rbp),%rax
imul   $0x14,-0x6c(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
imul   $0x14,-0x6c(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12dc <evaluateGTRGAMMAPROTMULTINVAR+0x18c>
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    13bc <evaluateGTRGAMMAPROTMULTINVAR+0x26c>
mov    0x20(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x13,-0x68(%rbp)
jge    13a9 <evaluateGTRGAMMAPROTMULTINVAR+0x259>
mov    0x18(%rbp),%rax
imul   $0x13,-0x6c(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  %xmm0,(%rax)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    135c <evaluateGTRGAMMAPROTMULTINVAR+0x20c>
jmp    13ae <evaluateGTRGAMMAPROTMULTINVAR+0x25e>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1331 <evaluateGTRGAMMAPROTMULTINVAR+0x1e1>
jmp    13c1 <evaluateGTRGAMMAPROTMULTINVAR+0x271>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1237 <evaluateGTRGAMMAPROTMULTINVAR+0xe7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpq   $0x0,0x48(%rbp)
je     1aa5 <evaluateGTRGAMMAPROTMULTINVAR+0x955>
mov    0x50(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x58(%rbp),%eax
jge    1a75 <evaluateGTRGAMMAPROTMULTINVAR+0x925>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    0x28(%rbp),%rax
imul   $0x1cc,-0x6c(%rbp),%ecx
mov    0x48(%rbp),%rdx
movslq -0x64(%rbp),%rsi
movsbl (%rdx,%rsi,1),%edx
imul   $0x14,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
imul   $0x4c,-0x6c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x4,-0x68(%rbp)
jge    1952 <evaluateGTRGAMMAPROTMULTINVAR+0x802>
mov    0x10(%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,-0x90(%rbp)
mov    -0x88(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x90(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x50(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x78(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x80(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x80(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x88(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x90(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x90(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x98(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%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    1454 <evaluateGTRGAMMAPROTMULTINVAR+0x304>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
cmpl   $0x14,(%rax,%rcx,4)
jge    19df <evaluateGTRGAMMAPROTMULTINVAR+0x88f>
mov    -0x98(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    -0xa0(%rbp),%rax
imul   $0x14,-0x6c(%rbp),%ecx
mov    -0x30(%rbp),%rdx
movslq -0x64(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
movsd  0x164c(%rip),%xmm0
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x58(%rbp)
jmp    1a43 <evaluateGTRGAMMAPROTMULTINVAR+0x8f3>
mov    -0x98(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x58(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0xb8(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x15ea(%rip),%xmm0
call   1060 <log@plt>
movsd  -0xb8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13e8 <evaluateGTRGAMMAPROTMULTINVAR+0x298>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    216f <evaluateGTRGAMMAPROTMULTINVAR+0x101f>
mov    0x50(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x58(%rbp),%eax
jge    2144 <evaluateGTRGAMMAPROTMULTINVAR+0xff4>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x80(%rbp),%rax
imul   $0x4c,-0x6c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x4,-0x68(%rbp)
jge    2007 <evaluateGTRGAMMAPROTMULTINVAR+0xeb7>
mov    -0x38(%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    0x10(%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,-0x90(%rbp)
mov    -0x88(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x90(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x50(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x78(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x80(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x80(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x88(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x90(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x90(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x90(%rbp),%rax
mulsd  0x98(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%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    1aea <evaluateGTRGAMMAPROTMULTINVAR+0x99a>
mov    -0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
cmpl   $0x14,(%rax,%rcx,4)
jge    20a1 <evaluateGTRGAMMAPROTMULTINVAR+0xf51>
mov    -0x98(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    -0xa0(%rbp),%rax
imul   $0x14,-0x6c(%rbp),%ecx
mov    -0x30(%rbp),%rdx
movslq -0x64(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x64(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cvtsi2sd %eax,%xmm1
movsd  0xf8a(%rip),%xmm0
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x58(%rbp)
jmp    2112 <evaluateGTRGAMMAPROTMULTINVAR+0xfc2>
mov    -0x98(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x58(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x64(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xf1b(%rip),%xmm0
call   1060 <log@plt>
movsd  -0xd0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1aab <evaluateGTRGAMMAPROTMULTINVAR+0x95b>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<evaluateGTRGAMMAPROTMULTINVAR>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,0x48(%rsp)
mov    %r8,0x60(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rdx,0x68(%rsp)
mov    %rsi,0x20(%rsp)
mov    %rdi,0x40(%rsp)
mov    0x110(%rsp),%ebp
xorpd  %xmm0,%xmm0
cmpl   $0x0,0x118(%rsp)
jne    11ad <evaluateGTRGAMMAPROTMULTINVAR+0x5d>
movsd  0xe64(%rip),%xmm0
mov    0xf0(%rsp),%rax
maxsd  (%rax),%xmm0
call   1060 <log@plt>
movsd  %xmm0,0x8(%rsp)
movslq %ebp,%rbx
imul   $0x260,%rbx,%rdi
call   1040 <malloc@plt>
mov    %rax,0x38(%rsp)
lea    0x0(,%rbx,4),%eax
lea    (%rax,%rax,4),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %rbx,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
movsd  0x8(%rsp),%xmm2
mov    %rax,0x30(%rsp)
test   %ebx,%ebx
jle    14d5 <evaluateGTRGAMMAPROTMULTINVAR+0x385>
mov    0xd0(%rsp),%r13
mov    %ebp,%eax
mov    %rax,0x50(%rsp)
xor    %ebx,%ebx
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebx,%r15d
and    $0x3fffffff,%r15d
shl    $0x5,%r15
add    0x38(%rsp),%r15
cmpl   $0x0,0x118(%rsp)
je     125c <evaluateGTRGAMMAPROTMULTINVAR+0x10c>
movsd  0xdbb(%rip),%xmm0
mov    0xf0(%rsp),%rax
maxsd  (%rax,%r14,8),%xmm0
call   1060 <log@plt>
movapd %xmm0,%xmm2
mov    %rbx,0x58(%rsp)
mov    %ebx,%eax
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
mov    0xe8(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
movsd  0xd83(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0xd7f(%rip),%xmm1
mov    0x30(%rsp),%rax
movsd  %xmm1,(%rax,%r14,8)
lea    0x0(,%r14,4),%r12d
lea    (%r12,%r12,4),%eax
lea    0x0(,%rax,8),%rcx
mov    0xe0(%rsp),%rsi
movupd (%rsi,%rax,8),%xmm1
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm1
mov    0x28(%rsp),%rdx
movupd %xmm1,(%rdx,%rax,8)
or     $0x10,%rcx
movupd (%rsi,%rcx,1),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%rdx,%rcx,1)
movupd 0x20(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x20(%rdx,%rax,8)
movupd 0x30(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x30(%rdx,%rax,8)
movupd 0x40(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x40(%rdx,%rax,8)
movupd 0x50(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x50(%rdx,%rax,8)
movupd 0x60(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x60(%rdx,%rax,8)
movupd 0x70(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x70(%rdx,%rax,8)
movupd 0x80(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x80(%rdx,%rax,8)
movupd 0x90(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x90(%rdx,%rax,8)
movsd  0x0(%r13,%r12,8),%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %ebx,%ebx
movsd  %xmm2,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rbx,1),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  %xmm2,%xmm0
call   1050 <exp@plt>
movsd  0x8(%rsp),%xmm2
movsd  %xmm0,(%r15,%rbx,1)
add    $0x8,%rbx
cmp    $0x98,%rbx
jne    1390 <evaluateGTRGAMMAPROTMULTINVAR+0x240>
shl    $0x3,%r12
mov    %r12,%rax
or     $0x8,%rax
movsd  0x0(%r13,%rax,1),%xmm0
movsd  %xmm0,0x10(%rsp)
add    %rbx,%r15
mov    $0x13,%ebx
mov    %rbp,%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  %xmm2,%xmm0
call   1050 <exp@plt>
movsd  0x8(%rsp),%xmm2
movsd  %xmm0,(%r15)
add    $0x8,%r15
add    $0x8,%r13
add    $0xffffffffffffffff,%rbx
jne    13f0 <evaluateGTRGAMMAPROTMULTINVAR+0x2a0>
mov    %r12,%rax
or     $0x10,%rax
mov    0xd0(%rsp),%r13
movsd  0x0(%r13,%rax,1),%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  %xmm2,%xmm0
call   1050 <exp@plt>
movsd  0x8(%rsp),%xmm2
movsd  %xmm0,(%r15)
add    $0x8,%r15
add    $0x1,%rbx
cmp    $0x13,%rbx
jne    1440 <evaluateGTRGAMMAPROTMULTINVAR+0x2f0>
or     $0x18,%r12
movsd  0x0(%r13,%r12,1),%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  %xmm2,%xmm0
call   1050 <exp@plt>
movsd  0x8(%rsp),%xmm2
movsd  %xmm0,(%r15)
add    $0x8,%r15
add    $0x1,%rbx
cmp    $0x13,%rbx
jne    1490 <evaluateGTRGAMMAPROTMULTINVAR+0x340>
add    $0x1,%r14
mov    0x58(%rsp),%rbx
add    $0x13,%ebx
cmp    0x50(%rsp),%r14
jne    1220 <evaluateGTRGAMMAPROTMULTINVAR+0xd0>
mov    0x108(%rsp),%eax
mov    0x100(%rsp),%ecx
mov    0xc0(%rsp),%r15
xorpd  %xmm3,%xmm3
cmpq   $0x0,0xf8(%rsp)
je     18d0 <evaluateGTRGAMMAPROTMULTINVAR+0x780>
cmp    %eax,%ecx
mov    0x60(%rsp),%r14
jge    1bf8 <evaluateGTRGAMMAPROTMULTINVAR+0xaa8>
mov    0xd8(%rsp),%rbx
movslq %ecx,%rbp
movslq %eax,%r12
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
shl    $0x7,%rax
add    %rax,%r15
xorpd  %xmm3,%xmm3
jmp    1595 <evaluateGTRGAMMAPROTMULTINVAR+0x445>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  %xmm1,%xmm0
call   1060 <log@plt>
movapd %xmm0,%xmm1
mov    0x20(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax,%rbp,4),%xmm0
mulsd  0xab6(%rip),%xmm0
addsd  %xmm1,%xmm0
mov    0x70(%rsp),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%rbp,4),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x18(%rsp),%xmm3
addsd  %xmm1,%xmm3
add    $0x1,%rbp
add    $0x280,%r15
cmp    %r12,%rbp
je     1bf8 <evaluateGTRGAMMAPROTMULTINVAR+0xaa8>
movsd  %xmm3,0x18(%rsp)
mov    0x68(%rsp),%rax
movslq (%rax,%rbp,4),%rax
imul   $0x1cc,%rax,%rcx
mov    0xf8(%rsp),%rdx
movsbq (%rdx,%rbp,1),%rdx
lea    (%rdx,%rdx,4),%rdx
lea    (%rcx,%rdx,4),%rsi
imul   $0x260,%rax,%rcx
add    0x38(%rsp),%rcx
movsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x8(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x10(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x18(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x50(%rsp)
movsd  0x20(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x28(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0x30(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x80(%rsp)
movsd  0x38(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0x40(%rbx,%rsi,8),%xmm14
movsd  0x48(%rbx,%rsi,8),%xmm15
movsd  0x50(%rbx,%rsi,8),%xmm4
movsd  0x58(%rbx,%rsi,8),%xmm5
movsd  0x60(%rbx,%rsi,8),%xmm6
movsd  0x68(%rbx,%rsi,8),%xmm7
movsd  0x70(%rbx,%rsi,8),%xmm1
movsd  0x78(%rbx,%rsi,8),%xmm8
mov    $0x98,%edx
movsd  0x80(%rbx,%rsi,8),%xmm9
movsd  0x88(%rbx,%rsi,8),%xmm10
movsd  0x90(%rbx,%rsi,8),%xmm11
movsd  0x98(%rbx,%rsi,8),%xmm12
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x98(%r15,%rdx,1),%xmm13
ff ff ff
mulsd  0x8(%rsp),%xmm13
addsd  %xmm0,%xmm13
movsd  -0x90(%r15,%rdx,1),%xmm0
ff ff ff
mulsd  0x10(%rsp),%xmm0
mulsd  (%rcx),%xmm0
addsd  %xmm13,%xmm0
movsd  -0x88(%r15,%rdx,1),%xmm2
ff ff ff
mulsd  0x58(%rsp),%xmm2
mulsd  0x8(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  -0x80(%r15,%rdx,1),%xmm0
mulsd  0x50(%rsp),%xmm0
mulsd  0x10(%rcx),%xmm0
movsd  -0x78(%r15,%rdx,1),%xmm3
mulsd  0x40(%rsp),%xmm3
mulsd  0x18(%rcx),%xmm3
addsd  %xmm2,%xmm0
addsd  %xmm0,%xmm3
movsd  -0x70(%r15,%rdx,1),%xmm0
mulsd  0x48(%rsp),%xmm0
mulsd  0x20(%rcx),%xmm0
addsd  %xmm3,%xmm0
movsd  -0x68(%r15,%rdx,1),%xmm2
mulsd  0x80(%rsp),%xmm2
mulsd  0x28(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  -0x60(%r15,%rdx,1),%xmm0
mulsd  0x78(%rsp),%xmm0
mulsd  0x30(%rcx),%xmm0
movsd  -0x58(%r15,%rdx,1),%xmm3
mulsd  %xmm14,%xmm3
mulsd  0x38(%rcx),%xmm3
addsd  %xmm2,%xmm0
addsd  %xmm0,%xmm3
movsd  -0x50(%r15,%rdx,1),%xmm0
mulsd  %xmm15,%xmm0
mulsd  0x40(%rcx),%xmm0
addsd  %xmm3,%xmm0
movsd  -0x48(%r15,%rdx,1),%xmm2
mulsd  %xmm4,%xmm2
mulsd  0x48(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  -0x40(%r15,%rdx,1),%xmm0
mulsd  %xmm5,%xmm0
mulsd  0x50(%rcx),%xmm0
movsd  -0x38(%r15,%rdx,1),%xmm3
mulsd  %xmm6,%xmm3
mulsd  0x58(%rcx),%xmm3
addsd  %xmm2,%xmm0
addsd  %xmm0,%xmm3
movsd  -0x30(%r15,%rdx,1),%xmm0
mulsd  %xmm7,%xmm0
mulsd  0x60(%rcx),%xmm0
addsd  %xmm3,%xmm0
movsd  -0x28(%r15,%rdx,1),%xmm2
mulsd  %xmm1,%xmm2
mulsd  0x68(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  -0x20(%r15,%rdx,1),%xmm0
mulsd  %xmm8,%xmm0
mulsd  0x70(%rcx),%xmm0
movsd  -0x18(%r15,%rdx,1),%xmm3
mulsd  %xmm9,%xmm3
mulsd  0x78(%rcx),%xmm3
addsd  %xmm2,%xmm0
addsd  %xmm0,%xmm3
movsd  -0x10(%r15,%rdx,1),%xmm0
mulsd  %xmm10,%xmm0
mulsd  0x80(%rcx),%xmm0
addsd  %xmm3,%xmm0
movsd  -0x8(%r15,%rdx,1),%xmm2
mulsd  %xmm11,%xmm2
mulsd  0x88(%rcx),%xmm2
addsd  %xmm0,%xmm2
movsd  (%r15,%rdx,1),%xmm0
mulsd  %xmm12,%xmm0
mulsd  0x90(%rcx),%xmm0
addsd  %xmm2,%xmm0
add    $0xa0,%rdx
add    $0x98,%rcx
cmp    $0x318,%rdx
jne    16a0 <evaluateGTRGAMMAPROTMULTINVAR+0x550>
mov    (%r14,%rbp,4),%ecx
mov    0x30(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm1
cmp    $0x13,%ecx
jg     1540 <evaluateGTRGAMMAPROTMULTINVAR+0x3f0>
lea    (%rax,%rax,4),%eax
lea    (%rcx,%rax,4),%eax
cltq
mulsd  %xmm0,%xmm1
mov    0x28(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rsp)
mov    0x20(%rsp),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%rbp,4),%xmm1
movsd  0x765(%rip),%xmm0
call   1070 <pow@plt>
mulsd  0x8(%rsp),%xmm0
call   1060 <log@plt>
jmp    1566 <evaluateGTRGAMMAPROTMULTINVAR+0x416>
cmp    %eax,%ecx
mov    0x60(%rsp),%r14
jge    1bf8 <evaluateGTRGAMMAPROTMULTINVAR+0xaa8>
movslq %ecx,%r13
movslq %eax,%r12
lea    0x0(,%r13,4),%rax
add    %r13,%rax
shl    $0x7,%rax
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,1),%rbp
add    $0x98,%rbp
lea    (%r15,%rax,1),%rbx
add    $0x98,%rbx
xorpd  %xmm3,%xmm3
jmp    1989 <evaluateGTRGAMMAPROTMULTINVAR+0x839>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulsd  %xmm1,%xmm0
call   1060 <log@plt>
movsd  0x18(%rsp),%xmm3
movapd %xmm0,%xmm1
mov    0x20(%rsp),%rax
mov    (%rax,%r13,4),%eax
mov    0x40(%rsp),%rcx
add    (%rcx,%r13,4),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x6c4(%rip),%xmm0
addsd  %xmm1,%xmm0
mov    0x70(%rsp),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%r13,4),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm1,%xmm3
add    $0x1,%r13
add    $0x280,%rbp
add    $0x280,%rbx
cmp    %r12,%r13
je     1bf8 <evaluateGTRGAMMAPROTMULTINVAR+0xaa8>
mov    0x68(%rsp),%rax
movslq (%rax,%r13,4),%rax
imul   $0x260,%rax,%rcx
add    0x38(%rsp),%rcx
xor    %edx,%edx
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x98(%rbp,%rdx,1),%xmm1
ff ff
movsd  -0x90(%rbp,%rdx,1),%xmm2
ff ff
mulsd  -0x98(%rbx,%rdx,1),%xmm1
ff ff
addsd  %xmm0,%xmm1
mulsd  -0x90(%rbx,%rdx,1),%xmm2
ff ff
mulsd  (%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  -0x88(%rbp,%rdx,1),%xmm0
ff ff
mulsd  -0x88(%rbx,%rdx,1),%xmm0
ff ff
mulsd  0x8(%rcx),%xmm0
addsd  %xmm2,%xmm0
movsd  -0x80(%rbp,%rdx,1),%xmm1
mulsd  -0x80(%rbx,%rdx,1),%xmm1
mulsd  0x10(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp,%rdx,1),%xmm0
mulsd  -0x78(%rbx,%rdx,1),%xmm0
mulsd  0x18(%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp,%rdx,1),%xmm1
mulsd  -0x70(%rbx,%rdx,1),%xmm1
mulsd  0x20(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp,%rdx,1),%xmm0
mulsd  -0x68(%rbx,%rdx,1),%xmm0
mulsd  0x28(%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  -0x60(%rbp,%rdx,1),%xmm1
mulsd  -0x60(%rbx,%rdx,1),%xmm1
mulsd  0x30(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp,%rdx,1),%xmm0
mulsd  -0x58(%rbx,%rdx,1),%xmm0
mulsd  0x38(%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp,%rdx,1),%xmm1
mulsd  -0x50(%rbx,%rdx,1),%xmm1
mulsd  0x40(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp,%rdx,1),%xmm0
mulsd  -0x48(%rbx,%rdx,1),%xmm0
mulsd  0x48(%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp,%rdx,1),%xmm1
mulsd  -0x40(%rbx,%rdx,1),%xmm1
mulsd  0x50(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x38(%rbp,%rdx,1),%xmm0
mulsd  -0x38(%rbx,%rdx,1),%xmm0
mulsd  0x58(%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  -0x30(%rbp,%rdx,1),%xmm1
mulsd  -0x30(%rbx,%rdx,1),%xmm1
mulsd  0x60(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x28(%rbp,%rdx,1),%xmm0
mulsd  -0x28(%rbx,%rdx,1),%xmm0
mulsd  0x68(%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  -0x20(%rbp,%rdx,1),%xmm1
mulsd  -0x20(%rbx,%rdx,1),%xmm1
mulsd  0x70(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x18(%rbp,%rdx,1),%xmm0
mulsd  -0x18(%rbx,%rdx,1),%xmm0
mulsd  0x78(%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  -0x10(%rbp,%rdx,1),%xmm1
mulsd  -0x10(%rbx,%rdx,1),%xmm1
mulsd  0x80(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  -0x8(%rbp,%rdx,1),%xmm2
mulsd  -0x8(%rbx,%rdx,1),%xmm2
mulsd  0x88(%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  0x0(%rbp,%rdx,1),%xmm0
mulsd  (%rbx,%rdx,1),%xmm0
mulsd  0x90(%rcx),%xmm0
addsd  %xmm2,%xmm0
add    $0xa0,%rdx
add    $0x98,%rcx
cmp    $0x280,%rdx
jne    19b0 <evaluateGTRGAMMAPROTMULTINVAR+0x860>
mov    (%r14,%r13,4),%ecx
mov    0x30(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm1
cmp    $0x13,%ecx
movsd  %xmm3,0x18(%rsp)
jg     1920 <evaluateGTRGAMMAPROTMULTINVAR+0x7d0>
lea    (%rax,%rax,4),%eax
lea    (%rcx,%rax,4),%eax
cltq
mulsd  %xmm0,%xmm1
mov    0x28(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rsp)
mov    0x40(%rsp),%rax
mov    (%rax,%r13,4),%eax
mov    0x20(%rsp),%rcx
add    (%rcx,%r13,4),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x443(%rip),%xmm0
call   1070 <pow@plt>
mulsd  0x8(%rsp),%xmm0
call   1060 <log@plt>
movsd  0x18(%rsp),%xmm3
jmp    1958 <evaluateGTRGAMMAPROTMULTINVAR+0x808>
movsd  %xmm3,0x18(%rsp)
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
movsd  0x18(%rsp),%xmm0
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @evaluateGTRGAMMAPROTMULTINVAR(i32* %0, i32* %1, i32* %2, i32* %3, i32* %4, double* %5, double* %6, double* %7, double* %8, double* %9, double* %10, double* %11, double* %12, i8* %13, i32 %14, i32 %15, i32 %16, i32 %17) {
%19 = alloca double
%20 = alloca i32*
%21 = alloca i32*
%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 double*
%33 = alloca i8*
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca double*
%47 = alloca double*
%48 = alloca double*
%49 = alloca double*
%50 = alloca double*
%51 = alloca double*
store i32* %0, i32** %20
store i32* %1, i32** %21
store i32* %2, i32** %22
store i32* %3, i32** %23
store i32* %4, i32** %24
store double* %5, double** %25
store double* %6, double** %26
store double* %7, double** %27
store double* %8, double** %28
store double* %9, double** %29
store double* %10, double** %30
store double* %11, double** %31
store double* %12, double** %32
store i8* %13, i8** %33
store i32 %14, i32* %34
store i32 %15, i32* %35
store i32 %16, i32* %36
store i32 %17, i32* %37
store double 0.000000e+00, double* %40
%52 = load i32, i32* %37
%53 = icmp ne i32 %52, 0
br i1 %53, label %64, label %54
54: ; preds = %18
%55 = load double*, double** %32
%56 = getelementptr inbounds double, double* %55, i64 0
%57 = load double, double* %56
store double %57, double* %39
%58 = load double, double* %39
%59 = fcmp olt double %58, 1.000000e-15
br i1 %59, label %60, label %61
60: ; preds = %54
store double 1.000000e-15, double* %39
br label %61
61: ; preds = %60, %54
%62 = load double, double* %39
%63 = call double @log(double %62)
store double %63, double* %40
br label %64
64: ; preds = %61, %18
%65 = load i32, i32* %36
%66 = sext i32 %65 to i64
%67 = mul i64 608, %66
%68 = call i8* @malloc(i64 %67)
%69 = bitcast i8* %68 to double*
store double* %69, double** %47
store double* %69, double** %46
%70 = load i32, i32* %36
%71 = mul nsw i32 20, %70
%72 = sext i32 %71 to i64
%73 = mul i64 %72, 8
%74 = call i8* @malloc(i64 %73)
%75 = bitcast i8* %74 to double*
store double* %75, double** %51
%76 = load i32, i32* %36
%77 = sext i32 %76 to i64
%78 = mul i64 %77, 8
%79 = call i8* @malloc(i64 %78)
%80 = bitcast i8* %79 to double*
store double* %80, double** %50
store i32 0, i32* %45
br label %81
81: ; preds = %185, %64
%82 = load i32, i32* %45
%83 = load i32, i32* %36
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %188
85: ; preds = %81
%86 = load i32, i32* %37
%87 = icmp ne i32 %86, 0
br i1 %87, label %88, label %100
88: ; preds = %85
%89 = load double*, double** %32
%90 = load i32, i32* %45
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds double, double* %89, i64 %91
%93 = load double, double* %92
store double %93, double* %39
%94 = load double, double* %39
%95 = fcmp olt double %94, 1.000000e-15
br i1 %95, label %96, label %97
96: ; preds = %88
store double 1.000000e-15, double* %39
br label %97
97: ; preds = %96, %88
%98 = load double, double* %39
%99 = call double @log(double %98)
store double %99, double* %40
br label %100
100: ; preds = %97, %85
%101 = load double*, double** %47
%102 = load i32, i32* %45
%103 = mul nsw i32 76, %102
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double, double* %101, i64 %104
store double* %105, double** %46
%106 = load double*, double** %31
%107 = load i32, i32* %45
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %106, i64 %108
%110 = load double, double* %109
%111 = fsub double 1.000000e+00, %110
%112 = fmul double 2.500000e-01, %111
%113 = load double*, double** %50
%114 = load i32, i32* %45
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %113, i64 %115
store double %112, double* %116
store i32 0, i32* %43
br label %117
117: ; preds = %142, %100
%118 = load i32, i32* %43
%119 = icmp slt i32 %118, 20
br i1 %119, label %120, label %145
120: ; preds = %117
%121 = load double*, double** %30
%122 = load i32, i32* %45
%123 = mul nsw i32 20, %122
%124 = load i32, i32* %43
%125 = add nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %121, i64 %126
%128 = load double, double* %127
%129 = load double*, double** %31
%130 = load i32, i32* %45
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %129, i64 %131
%133 = load double, double* %132
%134 = fmul double %128, %133
%135 = load double*, double** %51
%136 = load i32, i32* %45
%137 = mul nsw i32 20, %136
%138 = load i32, i32* %43
%139 = add nsw i32 %137, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %135, i64 %140
store double %134, double* %141
br label %142
142: ; preds = %120
%143 = load i32, i32* %43
%144 = add nsw i32 %143, 1
store i32 %144, i32* %43
br label %117
145: ; preds = %117
store i32 0, i32* %43
br label %146
146: ; preds = %181, %145
%147 = load i32, i32* %43
%148 = icmp slt i32 %147, 4
br i1 %148, label %149, label %184
149: ; preds = %146
%150 = load double*, double** %28
%151 = load i32, i32* %45
%152 = mul nsw i32 %151, 4
%153 = load i32, i32* %43
%154 = add nsw i32 %152, %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %150, i64 %155
%157 = load double, double* %156
store double %157, double* %42
store i32 0, i32* %44
br label %158
158: ; preds = %177, %149
%159 = load i32, i32* %44
%160 = icmp slt i32 %159, 19
br i1 %160, label %161, label %180
161: ; preds = %158
%162 = load double*, double** %27
%163 = load i32, i32* %45
%164 = mul nsw i32 %163, 19
%165 = load i32, i32* %44
%166 = add nsw i32 %164, %165
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds double, double* %162, i64 %167
%169 = load double, double* %168
%170 = load double, double* %42
%171 = fmul double %169, %170
%172 = load double, double* %40
%173 = fmul double %171, %172
%174 = call double @exp(double %173)
%175 = load double*, double** %46
%176 = getelementptr inbounds double, double* %175, i32 1
store double* %176, double** %46
store double %174, double* %175
br label %177
177: ; preds = %161
%178 = load i32, i32* %44
%179 = add nsw i32 %178, 1
store i32 %179, i32* %44
br label %158
180: ; preds = %158
br label %181
181: ; preds = %180
%182 = load i32, i32* %43
%183 = add nsw i32 %182, 1
store i32 %183, i32* %43
br label %146
184: ; preds = %146
br label %185
185: ; preds = %184
%186 = load i32, i32* %45
%187 = add nsw i32 %186, 1
store i32 %187, i32* %45
br label %81
188: ; preds = %81
store double 0.000000e+00, double* %38
%189 = load i8*, i8** %33
%190 = icmp ne i8* %189, null
br i1 %190, label %191, label %546
191: ; preds = %188
%192 = load i32, i32* %34
store i32 %192, i32* %43
br label %193
193: ; preds = %535, %191
%194 = load i32, i32* %43
%195 = load i32, i32* %35
%196 = icmp slt i32 %194, %195
br i1 %196, label %197, label %538
197: ; preds = %193
%198 = load i32*, i32** %22
%199 = load i32, i32* %43
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i32, i32* %198, i64 %200
%202 = load i32, i32* %201
store i32 %202, i32* %45
%203 = load double*, double** %29
%204 = load i32, i32* %45
%205 = mul nsw i32 460, %204
%206 = load i8*, i8** %33
%207 = load i32, i32* %43
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i8, i8* %206, i64 %208
%210 = load i8, i8* %209
%211 = sext i8 %210 to i32
%212 = mul nsw i32 20, %211
%213 = add nsw i32 %205, %212
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds double, double* %203, i64 %214
store double* %215, double** %48
%216 = load double*, double** %47
%217 = load i32, i32* %45
%218 = mul nsw i32 76, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %216, i64 %219
store double* %220, double** %46
store double 0.000000e+00, double* %41
store i32 0, i32* %44
br label %221
221: ; preds = %469, %197
%222 = load i32, i32* %44
%223 = icmp slt i32 %222, 4
br i1 %223, label %224, label %472
224: ; preds = %221
%225 = load double*, double** %26
%226 = load i32, i32* %43
%227 = mul nsw i32 80, %226
%228 = load i32, i32* %44
%229 = mul nsw i32 20, %228
%230 = add nsw i32 %227, %229
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %225, i64 %231
store double* %232, double** %49
%233 = load double*, double** %48
%234 = getelementptr inbounds double, double* %233, i64 0
%235 = load double, double* %234
%236 = load double*, double** %49
%237 = getelementptr inbounds double, double* %236, i64 0
%238 = load double, double* %237
%239 = load double, double* %41
%240 = call double @llvm.fmuladd.f64(double %235, double %238, double %239)
store double %240, double* %41
%241 = load double*, double** %48
%242 = getelementptr inbounds double, double* %241, i64 1
%243 = load double, double* %242
%244 = load double*, double** %49
%245 = getelementptr inbounds double, double* %244, i64 1
%246 = load double, double* %245
%247 = fmul double %243, %246
%248 = load double*, double** %46
%249 = getelementptr inbounds double, double* %248, i32 1
store double* %249, double** %46
%250 = load double, double* %248
%251 = load double, double* %41
%252 = call double @llvm.fmuladd.f64(double %247, double %250, double %251)
store double %252, double* %41
%253 = load double*, double** %48
%254 = getelementptr inbounds double, double* %253, i64 2
%255 = load double, double* %254
%256 = load double*, double** %49
%257 = getelementptr inbounds double, double* %256, i64 2
%258 = load double, double* %257
%259 = fmul double %255, %258
%260 = load double*, double** %46
%261 = getelementptr inbounds double, double* %260, i32 1
store double* %261, double** %46
%262 = load double, double* %260
%263 = load double, double* %41
%264 = call double @llvm.fmuladd.f64(double %259, double %262, double %263)
store double %264, double* %41
%265 = load double*, double** %48
%266 = getelementptr inbounds double, double* %265, i64 3
%267 = load double, double* %266
%268 = load double*, double** %49
%269 = getelementptr inbounds double, double* %268, i64 3
%270 = load double, double* %269
%271 = fmul double %267, %270
%272 = load double*, double** %46
%273 = getelementptr inbounds double, double* %272, i32 1
store double* %273, double** %46
%274 = load double, double* %272
%275 = load double, double* %41
%276 = call double @llvm.fmuladd.f64(double %271, double %274, double %275)
store double %276, double* %41
%277 = load double*, double** %48
%278 = getelementptr inbounds double, double* %277, i64 4
%279 = load double, double* %278
%280 = load double*, double** %49
%281 = getelementptr inbounds double, double* %280, i64 4
%282 = load double, double* %281
%283 = fmul double %279, %282
%284 = load double*, double** %46
%285 = getelementptr inbounds double, double* %284, i32 1
store double* %285, double** %46
%286 = load double, double* %284
%287 = load double, double* %41
%288 = call double @llvm.fmuladd.f64(double %283, double %286, double %287)
store double %288, double* %41
%289 = load double*, double** %48
%290 = getelementptr inbounds double, double* %289, i64 5
%291 = load double, double* %290
%292 = load double*, double** %49
%293 = getelementptr inbounds double, double* %292, i64 5
%294 = load double, double* %293
%295 = fmul double %291, %294
%296 = load double*, double** %46
%297 = getelementptr inbounds double, double* %296, i32 1
store double* %297, double** %46
%298 = load double, double* %296
%299 = load double, double* %41
%300 = call double @llvm.fmuladd.f64(double %295, double %298, double %299)
store double %300, double* %41
%301 = load double*, double** %48
%302 = getelementptr inbounds double, double* %301, i64 6
%303 = load double, double* %302
%304 = load double*, double** %49
%305 = getelementptr inbounds double, double* %304, i64 6
%306 = load double, double* %305
%307 = fmul double %303, %306
%308 = load double*, double** %46
%309 = getelementptr inbounds double, double* %308, i32 1
store double* %309, double** %46
%310 = load double, double* %308
%311 = load double, double* %41
%312 = call double @llvm.fmuladd.f64(double %307, double %310, double %311)
store double %312, double* %41
%313 = load double*, double** %48
%314 = getelementptr inbounds double, double* %313, i64 7
%315 = load double, double* %314
%316 = load double*, double** %49
%317 = getelementptr inbounds double, double* %316, i64 7
%318 = load double, double* %317
%319 = fmul double %315, %318
%320 = load double*, double** %46
%321 = getelementptr inbounds double, double* %320, i32 1
store double* %321, double** %46
%322 = load double, double* %320
%323 = load double, double* %41
%324 = call double @llvm.fmuladd.f64(double %319, double %322, double %323)
store double %324, double* %41
%325 = load double*, double** %48
%326 = getelementptr inbounds double, double* %325, i64 8
%327 = load double, double* %326
%328 = load double*, double** %49
%329 = getelementptr inbounds double, double* %328, i64 8
%330 = load double, double* %329
%331 = fmul double %327, %330
%332 = load double*, double** %46
%333 = getelementptr inbounds double, double* %332, i32 1
store double* %333, double** %46
%334 = load double, double* %332
%335 = load double, double* %41
%336 = call double @llvm.fmuladd.f64(double %331, double %334, double %335)
store double %336, double* %41
%337 = load double*, double** %48
%338 = getelementptr inbounds double, double* %337, i64 9
%339 = load double, double* %338
%340 = load double*, double** %49
%341 = getelementptr inbounds double, double* %340, i64 9
%342 = load double, double* %341
%343 = fmul double %339, %342
%344 = load double*, double** %46
%345 = getelementptr inbounds double, double* %344, i32 1
store double* %345, double** %46
%346 = load double, double* %344
%347 = load double, double* %41
%348 = call double @llvm.fmuladd.f64(double %343, double %346, double %347)
store double %348, double* %41
%349 = load double*, double** %48
%350 = getelementptr inbounds double, double* %349, i64 10
%351 = load double, double* %350
%352 = load double*, double** %49
%353 = getelementptr inbounds double, double* %352, i64 10
%354 = load double, double* %353
%355 = fmul double %351, %354
%356 = load double*, double** %46
%357 = getelementptr inbounds double, double* %356, i32 1
store double* %357, double** %46
%358 = load double, double* %356
%359 = load double, double* %41
%360 = call double @llvm.fmuladd.f64(double %355, double %358, double %359)
store double %360, double* %41
%361 = load double*, double** %48
%362 = getelementptr inbounds double, double* %361, i64 11
%363 = load double, double* %362
%364 = load double*, double** %49
%365 = getelementptr inbounds double, double* %364, i64 11
%366 = load double, double* %365
%367 = fmul double %363, %366
%368 = load double*, double** %46
%369 = getelementptr inbounds double, double* %368, i32 1
store double* %369, double** %46
%370 = load double, double* %368
%371 = load double, double* %41
%372 = call double @llvm.fmuladd.f64(double %367, double %370, double %371)
store double %372, double* %41
%373 = load double*, double** %48
%374 = getelementptr inbounds double, double* %373, i64 12
%375 = load double, double* %374
%376 = load double*, double** %49
%377 = getelementptr inbounds double, double* %376, i64 12
%378 = load double, double* %377
%379 = fmul double %375, %378
%380 = load double*, double** %46
%381 = getelementptr inbounds double, double* %380, i32 1
store double* %381, double** %46
%382 = load double, double* %380
%383 = load double, double* %41
%384 = call double @llvm.fmuladd.f64(double %379, double %382, double %383)
store double %384, double* %41
%385 = load double*, double** %48
%386 = getelementptr inbounds double, double* %385, i64 13
%387 = load double, double* %386
%388 = load double*, double** %49
%389 = getelementptr inbounds double, double* %388, i64 13
%390 = load double, double* %389
%391 = fmul double %387, %390
%392 = load double*, double** %46
%393 = getelementptr inbounds double, double* %392, i32 1
store double* %393, double** %46
%394 = load double, double* %392
%395 = load double, double* %41
%396 = call double @llvm.fmuladd.f64(double %391, double %394, double %395)
store double %396, double* %41
%397 = load double*, double** %48
%398 = getelementptr inbounds double, double* %397, i64 14
%399 = load double, double* %398
%400 = load double*, double** %49
%401 = getelementptr inbounds double, double* %400, i64 14
%402 = load double, double* %401
%403 = fmul double %399, %402
%404 = load double*, double** %46
%405 = getelementptr inbounds double, double* %404, i32 1
store double* %405, double** %46
%406 = load double, double* %404
%407 = load double, double* %41
%408 = call double @llvm.fmuladd.f64(double %403, double %406, double %407)
store double %408, double* %41
%409 = load double*, double** %48
%410 = getelementptr inbounds double, double* %409, i64 15
%411 = load double, double* %410
%412 = load double*, double** %49
%413 = getelementptr inbounds double, double* %412, i64 15
%414 = load double, double* %413
%415 = fmul double %411, %414
%416 = load double*, double** %46
%417 = getelementptr inbounds double, double* %416, i32 1
store double* %417, double** %46
%418 = load double, double* %416
%419 = load double, double* %41
%420 = call double @llvm.fmuladd.f64(double %415, double %418, double %419)
store double %420, double* %41
%421 = load double*, double** %48
%422 = getelementptr inbounds double, double* %421, i64 16
%423 = load double, double* %422
%424 = load double*, double** %49
%425 = getelementptr inbounds double, double* %424, i64 16
%426 = load double, double* %425
%427 = fmul double %423, %426
%428 = load double*, double** %46
%429 = getelementptr inbounds double, double* %428, i32 1
store double* %429, double** %46
%430 = load double, double* %428
%431 = load double, double* %41
%432 = call double @llvm.fmuladd.f64(double %427, double %430, double %431)
store double %432, double* %41
%433 = load double*, double** %48
%434 = getelementptr inbounds double, double* %433, i64 17
%435 = load double, double* %434
%436 = load double*, double** %49
%437 = getelementptr inbounds double, double* %436, i64 17
%438 = load double, double* %437
%439 = fmul double %435, %438
%440 = load double*, double** %46
%441 = getelementptr inbounds double, double* %440, i32 1
store double* %441, double** %46
%442 = load double, double* %440
%443 = load double, double* %41
%444 = call double @llvm.fmuladd.f64(double %439, double %442, double %443)
store double %444, double* %41
%445 = load double*, double** %48
%446 = getelementptr inbounds double, double* %445, i64 18
%447 = load double, double* %446
%448 = load double*, double** %49
%449 = getelementptr inbounds double, double* %448, i64 18
%450 = load double, double* %449
%451 = fmul double %447, %450
%452 = load double*, double** %46
%453 = getelementptr inbounds double, double* %452, i32 1
store double* %453, double** %46
%454 = load double, double* %452
%455 = load double, double* %41
%456 = call double @llvm.fmuladd.f64(double %451, double %454, double %455)
store double %456, double* %41
%457 = load double*, double** %48
%458 = getelementptr inbounds double, double* %457, i64 19
%459 = load double, double* %458
%460 = load double*, double** %49
%461 = getelementptr inbounds double, double* %460, i64 19
%462 = load double, double* %461
%463 = fmul double %459, %462
%464 = load double*, double** %46
%465 = getelementptr inbounds double, double* %464, i32 1
store double* %465, double** %46
%466 = load double, double* %464
%467 = load double, double* %41
%468 = call double @llvm.fmuladd.f64(double %463, double %466, double %467)
store double %468, double* %41
br label %469
469: ; preds = %224
%470 = load i32, i32* %44
%471 = add nsw i32 %470, 1
store i32 %471, i32* %44
br label %221
472: ; preds = %221
%473 = load i32*, i32** %24
%474 = load i32, i32* %43
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds i32, i32* %473, i64 %475
%477 = load i32, i32* %476
%478 = icmp slt i32 %477, 20
br i1 %478, label %479, label %508
479: ; preds = %472
%480 = load double*, double** %50
%481 = load i32, i32* %45
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %480, i64 %482
%484 = load double, double* %483
%485 = load double, double* %41
%486 = load double*, double** %51
%487 = load i32, i32* %45
%488 = mul nsw i32 %487, 20
%489 = load i32*, i32** %24
%490 = load i32, i32* %43
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds i32, i32* %489, i64 %491
%493 = load i32, i32* %492
%494 = add nsw i32 %488, %493
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds double, double* %486, i64 %495
%497 = load double, double* %496
%498 = call double @llvm.fmuladd.f64(double %484, double %485, double %497)
%499 = load i32*, i32** %21
%500 = load i32, i32* %43
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds i32, i32* %499, i64 %501
%503 = load i32, i32* %502
%504 = sitofp i32 %503 to double
%505 = call double @pow(double 0x2FF0000000000000, double %504)
%506 = fmul double %498, %505
%507 = call double @log(double %506)
store double %507, double* %41
br label %525
508: ; preds = %472
%509 = load double*, double** %50
%510 = load i32, i32* %45
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds double, double* %509, i64 %511
%513 = load double, double* %512
%514 = load double, double* %41
%515 = fmul double %513, %514
%516 = call double @log(double %515)
%517 = load i32*, i32** %21
%518 = load i32, i32* %43
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds i32, i32* %517, i64 %519
%521 = load i32, i32* %520
%522 = sitofp i32 %521 to double
%523 = call double @log(double 0x2FF0000000000000)
%524 = call double @llvm.fmuladd.f64(double %522, double %523, double %516)
store double %524, double* %41
br label %525
525: ; preds = %508, %479
%526 = load i32*, i32** %23
%527 = load i32, i32* %43
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds i32, i32* %526, i64 %528
%530 = load i32, i32* %529
%531 = sitofp i32 %530 to double
%532 = load double, double* %41
%533 = load double, double* %38
%534 = call double @llvm.fmuladd.f64(double %531, double %532, double %533)
store double %534, double* %38
br label %535
535: ; preds = %525
%536 = load i32, i32* %43
%537 = add nsw i32 %536, 1
store i32 %537, i32* %43
br label %193
538: ; preds = %193
%539 = load double*, double** %47
%540 = bitcast double* %539 to i8*
%541 = load double*, double** %51
%542 = bitcast double* %541 to i8*
%543 = load double*, double** %50
%544 = bitcast double* %543 to i8*
%545 = load double, double* %38
store double %545, double* %19
br label %908
546: ; preds = %188
%547 = load i32, i32* %34
store i32 %547, i32* %43
br label %548
548: ; preds = %897, %546
%549 = load i32, i32* %43
%550 = load i32, i32* %35
%551 = icmp slt i32 %549, %550
br i1 %551, label %552, label %900
552: ; preds = %548
%553 = load i32*, i32** %22
%554 = load i32, i32* %43
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds i32, i32* %553, i64 %555
%557 = load i32, i32* %556
store i32 %557, i32* %45
%558 = load double*, double** %47
%559 = load i32, i32* %45
%560 = mul nsw i32 76, %559
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds double, double* %558, i64 %561
store double* %562, double** %46
store double 0.000000e+00, double* %41
store i32 0, i32* %44
br label %563
563: ; preds = %819, %552
%564 = load i32, i32* %44
%565 = icmp slt i32 %564, 4
br i1 %565, label %566, label %822
566: ; preds = %563
%567 = load double*, double** %25
%568 = load i32, i32* %43
%569 = mul nsw i32 80, %568
%570 = load i32, i32* %44
%571 = mul nsw i32 20, %570
%572 = add nsw i32 %569, %571
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds double, double* %567, i64 %573
store double* %574, double** %48
%575 = load double*, double** %26
%576 = load i32, i32* %43
%577 = mul nsw i32 80, %576
%578 = load i32, i32* %44
%579 = mul nsw i32 20, %578
%580 = add nsw i32 %577, %579
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds double, double* %575, i64 %581
store double* %582, double** %49
%583 = load double*, double** %48
%584 = getelementptr inbounds double, double* %583, i64 0
%585 = load double, double* %584
%586 = load double*, double** %49
%587 = getelementptr inbounds double, double* %586, i64 0
%588 = load double, double* %587
%589 = load double, double* %41
%590 = call double @llvm.fmuladd.f64(double %585, double %588, double %589)
store double %590, double* %41
%591 = load double*, double** %48
%592 = getelementptr inbounds double, double* %591, i64 1
%593 = load double, double* %592
%594 = load double*, double** %49
%595 = getelementptr inbounds double, double* %594, i64 1
%596 = load double, double* %595
%597 = fmul double %593, %596
%598 = load double*, double** %46
%599 = getelementptr inbounds double, double* %598, i32 1
store double* %599, double** %46
%600 = load double, double* %598
%601 = load double, double* %41
%602 = call double @llvm.fmuladd.f64(double %597, double %600, double %601)
store double %602, double* %41
%603 = load double*, double** %48
%604 = getelementptr inbounds double, double* %603, i64 2
%605 = load double, double* %604
%606 = load double*, double** %49
%607 = getelementptr inbounds double, double* %606, i64 2
%608 = load double, double* %607
%609 = fmul double %605, %608
%610 = load double*, double** %46
%611 = getelementptr inbounds double, double* %610, i32 1
store double* %611, double** %46
%612 = load double, double* %610
%613 = load double, double* %41
%614 = call double @llvm.fmuladd.f64(double %609, double %612, double %613)
store double %614, double* %41
%615 = load double*, double** %48
%616 = getelementptr inbounds double, double* %615, i64 3
%617 = load double, double* %616
%618 = load double*, double** %49
%619 = getelementptr inbounds double, double* %618, i64 3
%620 = load double, double* %619
%621 = fmul double %617, %620
%622 = load double*, double** %46
%623 = getelementptr inbounds double, double* %622, i32 1
store double* %623, double** %46
%624 = load double, double* %622
%625 = load double, double* %41
%626 = call double @llvm.fmuladd.f64(double %621, double %624, double %625)
store double %626, double* %41
%627 = load double*, double** %48
%628 = getelementptr inbounds double, double* %627, i64 4
%629 = load double, double* %628
%630 = load double*, double** %49
%631 = getelementptr inbounds double, double* %630, i64 4
%632 = load double, double* %631
%633 = fmul double %629, %632
%634 = load double*, double** %46
%635 = getelementptr inbounds double, double* %634, i32 1
store double* %635, double** %46
%636 = load double, double* %634
%637 = load double, double* %41
%638 = call double @llvm.fmuladd.f64(double %633, double %636, double %637)
store double %638, double* %41
%639 = load double*, double** %48
%640 = getelementptr inbounds double, double* %639, i64 5
%641 = load double, double* %640
%642 = load double*, double** %49
%643 = getelementptr inbounds double, double* %642, i64 5
%644 = load double, double* %643
%645 = fmul double %641, %644
%646 = load double*, double** %46
%647 = getelementptr inbounds double, double* %646, i32 1
store double* %647, double** %46
%648 = load double, double* %646
%649 = load double, double* %41
%650 = call double @llvm.fmuladd.f64(double %645, double %648, double %649)
store double %650, double* %41
%651 = load double*, double** %48
%652 = getelementptr inbounds double, double* %651, i64 6
%653 = load double, double* %652
%654 = load double*, double** %49
%655 = getelementptr inbounds double, double* %654, i64 6
%656 = load double, double* %655
%657 = fmul double %653, %656
%658 = load double*, double** %46
%659 = getelementptr inbounds double, double* %658, i32 1
store double* %659, double** %46
%660 = load double, double* %658
%661 = load double, double* %41
%662 = call double @llvm.fmuladd.f64(double %657, double %660, double %661)
store double %662, double* %41
%663 = load double*, double** %48
%664 = getelementptr inbounds double, double* %663, i64 7
%665 = load double, double* %664
%666 = load double*, double** %49
%667 = getelementptr inbounds double, double* %666, i64 7
%668 = load double, double* %667
%669 = fmul double %665, %668
%670 = load double*, double** %46
%671 = getelementptr inbounds double, double* %670, i32 1
store double* %671, double** %46
%672 = load double, double* %670
%673 = load double, double* %41
%674 = call double @llvm.fmuladd.f64(double %669, double %672, double %673)
store double %674, double* %41
%675 = load double*, double** %48
%676 = getelementptr inbounds double, double* %675, i64 8
%677 = load double, double* %676
%678 = load double*, double** %49
%679 = getelementptr inbounds double, double* %678, i64 8
%680 = load double, double* %679
%681 = fmul double %677, %680
%682 = load double*, double** %46
%683 = getelementptr inbounds double, double* %682, i32 1
store double* %683, double** %46
%684 = load double, double* %682
%685 = load double, double* %41
%686 = call double @llvm.fmuladd.f64(double %681, double %684, double %685)
store double %686, double* %41
%687 = load double*, double** %48
%688 = getelementptr inbounds double, double* %687, i64 9
%689 = load double, double* %688
%690 = load double*, double** %49
%691 = getelementptr inbounds double, double* %690, i64 9
%692 = load double, double* %691
%693 = fmul double %689, %692
%694 = load double*, double** %46
%695 = getelementptr inbounds double, double* %694, i32 1
store double* %695, double** %46
%696 = load double, double* %694
%697 = load double, double* %41
%698 = call double @llvm.fmuladd.f64(double %693, double %696, double %697)
store double %698, double* %41
%699 = load double*, double** %48
%700 = getelementptr inbounds double, double* %699, i64 10
%701 = load double, double* %700
%702 = load double*, double** %49
%703 = getelementptr inbounds double, double* %702, i64 10
%704 = load double, double* %703
%705 = fmul double %701, %704
%706 = load double*, double** %46
%707 = getelementptr inbounds double, double* %706, i32 1
store double* %707, double** %46
%708 = load double, double* %706
%709 = load double, double* %41
%710 = call double @llvm.fmuladd.f64(double %705, double %708, double %709)
store double %710, double* %41
%711 = load double*, double** %48
%712 = getelementptr inbounds double, double* %711, i64 11
%713 = load double, double* %712
%714 = load double*, double** %49
%715 = getelementptr inbounds double, double* %714, i64 11
%716 = load double, double* %715
%717 = fmul double %713, %716
%718 = load double*, double** %46
%719 = getelementptr inbounds double, double* %718, i32 1
store double* %719, double** %46
%720 = load double, double* %718
%721 = load double, double* %41
%722 = call double @llvm.fmuladd.f64(double %717, double %720, double %721)
store double %722, double* %41
%723 = load double*, double** %48
%724 = getelementptr inbounds double, double* %723, i64 12
%725 = load double, double* %724
%726 = load double*, double** %49
%727 = getelementptr inbounds double, double* %726, i64 12
%728 = load double, double* %727
%729 = fmul double %725, %728
%730 = load double*, double** %46
%731 = getelementptr inbounds double, double* %730, i32 1
store double* %731, double** %46
%732 = load double, double* %730
%733 = load double, double* %41
%734 = call double @llvm.fmuladd.f64(double %729, double %732, double %733)
store double %734, double* %41
%735 = load double*, double** %48
%736 = getelementptr inbounds double, double* %735, i64 13
%737 = load double, double* %736
%738 = load double*, double** %49
%739 = getelementptr inbounds double, double* %738, i64 13
%740 = load double, double* %739
%741 = fmul double %737, %740
%742 = load double*, double** %46
%743 = getelementptr inbounds double, double* %742, i32 1
store double* %743, double** %46
%744 = load double, double* %742
%745 = load double, double* %41
%746 = call double @llvm.fmuladd.f64(double %741, double %744, double %745)
store double %746, double* %41
%747 = load double*, double** %48
%748 = getelementptr inbounds double, double* %747, i64 14
%749 = load double, double* %748
%750 = load double*, double** %49
%751 = getelementptr inbounds double, double* %750, i64 14
%752 = load double, double* %751
%753 = fmul double %749, %752
%754 = load double*, double** %46
%755 = getelementptr inbounds double, double* %754, i32 1
store double* %755, double** %46
%756 = load double, double* %754
%757 = load double, double* %41
%758 = call double @llvm.fmuladd.f64(double %753, double %756, double %757)
store double %758, double* %41
%759 = load double*, double** %48
%760 = getelementptr inbounds double, double* %759, i64 15
%761 = load double, double* %760
%762 = load double*, double** %49
%763 = getelementptr inbounds double, double* %762, i64 15
%764 = load double, double* %763
%765 = fmul double %761, %764
%766 = load double*, double** %46
%767 = getelementptr inbounds double, double* %766, i32 1
store double* %767, double** %46
%768 = load double, double* %766
%769 = load double, double* %41
%770 = call double @llvm.fmuladd.f64(double %765, double %768, double %769)
store double %770, double* %41
%771 = load double*, double** %48
%772 = getelementptr inbounds double, double* %771, i64 16
%773 = load double, double* %772
%774 = load double*, double** %49
%775 = getelementptr inbounds double, double* %774, i64 16
%776 = load double, double* %775
%777 = fmul double %773, %776
%778 = load double*, double** %46
%779 = getelementptr inbounds double, double* %778, i32 1
store double* %779, double** %46
%780 = load double, double* %778
%781 = load double, double* %41
%782 = call double @llvm.fmuladd.f64(double %777, double %780, double %781)
store double %782, double* %41
%783 = load double*, double** %48
%784 = getelementptr inbounds double, double* %783, i64 17
%785 = load double, double* %784
%786 = load double*, double** %49
%787 = getelementptr inbounds double, double* %786, i64 17
%788 = load double, double* %787
%789 = fmul double %785, %788
%790 = load double*, double** %46
%791 = getelementptr inbounds double, double* %790, i32 1
store double* %791, double** %46
%792 = load double, double* %790
%793 = load double, double* %41
%794 = call double @llvm.fmuladd.f64(double %789, double %792, double %793)
store double %794, double* %41
%795 = load double*, double** %48
%796 = getelementptr inbounds double, double* %795, i64 18
%797 = load double, double* %796
%798 = load double*, double** %49
%799 = getelementptr inbounds double, double* %798, i64 18
%800 = load double, double* %799
%801 = fmul double %797, %800
%802 = load double*, double** %46
%803 = getelementptr inbounds double, double* %802, i32 1
store double* %803, double** %46
%804 = load double, double* %802
%805 = load double, double* %41
%806 = call double @llvm.fmuladd.f64(double %801, double %804, double %805)
store double %806, double* %41
%807 = load double*, double** %48
%808 = getelementptr inbounds double, double* %807, i64 19
%809 = load double, double* %808
%810 = load double*, double** %49
%811 = getelementptr inbounds double, double* %810, i64 19
%812 = load double, double* %811
%813 = fmul double %809, %812
%814 = load double*, double** %46
%815 = getelementptr inbounds double, double* %814, i32 1
store double* %815, double** %46
%816 = load double, double* %814
%817 = load double, double* %41
%818 = call double @llvm.fmuladd.f64(double %813, double %816, double %817)
store double %818, double* %41
br label %819
819: ; preds = %566
%820 = load i32, i32* %44
%821 = add nsw i32 %820, 1
store i32 %821, i32* %44
br label %563
822: ; preds = %563
%823 = load i32*, i32** %24
%824 = load i32, i32* %43
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds i32, i32* %823, i64 %825
%827 = load i32, i32* %826
%828 = icmp slt i32 %827, 20
br i1 %828, label %829, label %864
829: ; preds = %822
%830 = load double*, double** %50
%831 = load i32, i32* %45
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds double, double* %830, i64 %832
%834 = load double, double* %833
%835 = load double, double* %41
%836 = load double*, double** %51
%837 = load i32, i32* %45
%838 = mul nsw i32 %837, 20
%839 = load i32*, i32** %24
%840 = load i32, i32* %43
%841 = sext i32 %840 to i64
%842 = getelementptr inbounds i32, i32* %839, i64 %841
%843 = load i32, i32* %842
%844 = add nsw i32 %838, %843
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds double, double* %836, i64 %845
%847 = load double, double* %846
%848 = call double @llvm.fmuladd.f64(double %834, double %835, double %847)
%849 = load i32*, i32** %21
%850 = load i32, i32* %43
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds i32, i32* %849, i64 %851
%853 = load i32, i32* %852
%854 = load i32*, i32** %20
%855 = load i32, i32* %43
%856 = sext i32 %855 to i64
%857 = getelementptr inbounds i32, i32* %854, i64 %856
%858 = load i32, i32* %857
%859 = add nsw i32 %853, %858
%860 = sitofp i32 %859 to double
%861 = call double @pow(double 0x2FF0000000000000, double %860)
%862 = fmul double %848, %861
%863 = call double @log(double %862)
store double %863, double* %41
br label %887
864: ; preds = %822
%865 = load double*, double** %50
%866 = load i32, i32* %45
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds double, double* %865, i64 %867
%869 = load double, double* %868
%870 = load double, double* %41
%871 = fmul double %869, %870
%872 = call double @log(double %871)
%873 = load i32*, i32** %20
%874 = load i32, i32* %43
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds i32, i32* %873, i64 %875
%877 = load i32, i32* %876
%878 = load i32*, i32** %21
%879 = load i32, i32* %43
%880 = sext i32 %879 to i64
%881 = getelementptr inbounds i32, i32* %878, i64 %880
%882 = load i32, i32* %881
%883 = add nsw i32 %877, %882
%884 = sitofp i32 %883 to double
%885 = call double @log(double 0x2FF0000000000000)
%886 = call double @llvm.fmuladd.f64(double %884, double %885, double %872)
store double %886, double* %41
br label %887
887: ; preds = %864, %829
%888 = load i32*, i32** %23
%889 = load i32, i32* %43
%890 = sext i32 %889 to i64
%891 = getelementptr inbounds i32, i32* %888, i64 %890
%892 = load i32, i32* %891
%893 = sitofp i32 %892 to double
%894 = load double, double* %41
%895 = load double, double* %38
%896 = call double @llvm.fmuladd.f64(double %893, double %894, double %895)
store double %896, double* %38
br label %897
897: ; preds = %887
%898 = load i32, i32* %43
%899 = add nsw i32 %898, 1
store i32 %899, i32* %43
br label %548
900: ; preds = %548
%901 = load double*, double** %47
%902 = bitcast double* %901 to i8*
%903 = load double*, double** %51
%904 = bitcast double* %903 to i8*
%905 = load double*, double** %50
%906 = bitcast double* %905 to i8*
%907 = load double, double* %38
store double %907, double* %19
br label %908
908: ; preds = %900, %538
%909 = load double, double* %19
ret double %909
}

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