double evaluateGTRCATPROTMULT(int *ex1, int *ex2, int *cptr, int *modelptr,
                              int *wptr, double *x1, double *x2, double *EIGN,
                              double *rptr, double *tipVector, double *pz,
                              char *tipX1, int lower, int n,
                              int numberOfCategories, int numberOfModels,
                              int multiBranch) {
  double sum, z, lz = 0.0, ki, lza[19], term;
  double *diagptable, *diagptable_start, *left, *right;
  int model, modelCounter, i, l;
  if (!multiBranch) {
    z = pz[0];
    if (z < 1.0E-15)
      z = 1.0E-15;
    lz = log(z);
  }
  diagptable = diagptable_start = (double *)malloc(
      sizeof(double) * numberOfCategories * 19 * numberOfModels);
  for (modelCounter = 0; modelCounter < numberOfModels; modelCounter++) {
    if (multiBranch) {
      z = pz[modelCounter];
      if (z < 1.0E-15)
        z = 1.0E-15;
      lz = log(z);
    }
    for (l = 0; l < 19; l++)
      lza[l] = EIGN[modelCounter * 19 + l] * lz;
    for (i = 0; i < numberOfCategories; i++) {
      ki = rptr[i];
      *diagptable++ = exp(ki * lza[0]);
      *diagptable++ = exp(ki * lza[1]);
      *diagptable++ = exp(ki * lza[2]);
      *diagptable++ = exp(ki * lza[3]);
      *diagptable++ = exp(ki * lza[4]);
      *diagptable++ = exp(ki * lza[5]);
      *diagptable++ = exp(ki * lza[6]);
      *diagptable++ = exp(ki * lza[7]);
      *diagptable++ = exp(ki * lza[8]);
      *diagptable++ = exp(ki * lza[9]);
      *diagptable++ = exp(ki * lza[10]);
      *diagptable++ = exp(ki * lza[11]);
      *diagptable++ = exp(ki * lza[12]);
      *diagptable++ = exp(ki * lza[13]);
      *diagptable++ = exp(ki * lza[14]);
      *diagptable++ = exp(ki * lza[15]);
      *diagptable++ = exp(ki * lza[16]);
      *diagptable++ = exp(ki * lza[17]);
      *diagptable++ = exp(ki * lza[18]);
    }
  }
  sum = 0.0;
  if (tipX1) {
    for (i = lower; i < n; i++) {
      model = modelptr[i];
      left = &(tipVector[model * 460 + 20 * tipX1[i]]);
      right = &(x2[20 * i]);
      diagptable =
          &diagptable_start[model * 19 * numberOfCategories + 19 * cptr[i]];
      term = left[0] * right[0];
      term += left[1] * right[1] * *diagptable++;
      term += left[2] * right[2] * *diagptable++;
      term += left[3] * right[3] * *diagptable++;
      term += left[4] * right[4] * *diagptable++;
      term += left[5] * right[5] * *diagptable++;
      term += left[6] * right[6] * *diagptable++;
      term += left[7] * right[7] * *diagptable++;
      term += left[8] * right[8] * *diagptable++;
      term += left[9] * right[9] * *diagptable++;
      term += left[10] * right[10] * *diagptable++;
      term += left[11] * right[11] * *diagptable++;
      term += left[12] * right[12] * *diagptable++;
      term += left[13] * right[13] * *diagptable++;
      term += left[14] * right[14] * *diagptable++;
      term += left[15] * right[15] * *diagptable++;
      term += left[16] * right[16] * *diagptable++;
      term += left[17] * right[17] * *diagptable++;
      term += left[18] * right[18] * *diagptable++;
      term += left[19] * right[19] * *diagptable++;
      term =
          (log(term)) +
          (ex2[i] *
           log((
               1.0 /
               115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
      sum += wptr[i] * term;
    }
    free(diagptable_start);
    return sum;
  }
  for (i = lower; i < n; i++) {
    model = modelptr[i];
    diagptable =
        &diagptable_start[model * 19 * numberOfCategories + 19 * cptr[i]];
    left = &x1[20 * i];
    right = &x2[20 * i];
    term = left[0] * right[0];
    term += left[1] * right[1] * *diagptable++;
    term += left[2] * right[2] * *diagptable++;
    term += left[3] * right[3] * *diagptable++;
    term += left[4] * right[4] * *diagptable++;
    term += left[5] * right[5] * *diagptable++;
    term += left[6] * right[6] * *diagptable++;
    term += left[7] * right[7] * *diagptable++;
    term += left[8] * right[8] * *diagptable++;
    term += left[9] * right[9] * *diagptable++;
    term += left[10] * right[10] * *diagptable++;
    term += left[11] * right[11] * *diagptable++;
    term += left[12] * right[12] * *diagptable++;
    term += left[13] * right[13] * *diagptable++;
    term += left[14] * right[14] * *diagptable++;
    term += left[15] * right[15] * *diagptable++;
    term += left[16] * right[16] * *diagptable++;
    term += left[17] * right[17] * *diagptable++;
    term += left[18] * right[18] * *diagptable++;
    term += left[19] * right[19] * *diagptable++;
    term =
        log(term) +
        ((ex1[i] + ex2[i]) *
         log((
             1.0 /
             115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
    sum += wptr[i] * term;
  }
  free(diagptable_start);
  return sum;
}


x86 assembly (clang, -O0):
<evaluateGTRCATPROTMULT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    0x60(%rbp),%eax
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
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,0x60(%rbp)
jne    11d8 <evaluateGTRCATPROTMULT+0x98>
mov    0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x1e4f(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    11c9 <evaluateGTRCATPROTMULT+0x89>
movsd  0x1e3c(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x50(%rbp)
movslq 0x50(%rbp),%rax
shl    $0x3,%rax
imul   $0x13,%rax,%rdi
movslq 0x58(%rbp),%rax
imul   %rax,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x108(%rbp)
mov    %rax,-0x100(%rbp)
movl   $0x0,-0x120(%rbp)
mov    -0x120(%rbp),%eax
cmp    0x58(%rbp),%eax
jge    163c <evaluateGTRCATPROTMULT+0x4fc>
cmpl   $0x0,0x60(%rbp)
je     1266 <evaluateGTRCATPROTMULT+0x126>
mov    0x30(%rbp),%rax
movslq -0x120(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x1dc1(%rip),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    1257 <evaluateGTRCATPROTMULT+0x117>
movsd  0x1dae(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x128(%rbp)
cmpl   $0x13,-0x128(%rbp)
jge    12bf <evaluateGTRCATPROTMULT+0x17f>
mov    0x18(%rbp),%rax
imul   $0x13,-0x120(%rbp),%ecx
add    -0x128(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x50(%rbp),%xmm0
movslq -0x128(%rbp),%rax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    1270 <evaluateGTRCATPROTMULT+0x130>
movl   $0x0,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1623 <evaluateGTRCATPROTMULT+0x4e3>
mov    0x20(%rbp),%rax
movslq -0x124(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xf0(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xe8(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xe0(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xd8(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xd0(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  %xmm0,(%rax)
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    12c9 <evaluateGTRCATPROTMULT+0x189>
jmp    1628 <evaluateGTRCATPROTMULT+0x4e8>
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    1209 <evaluateGTRCATPROTMULT+0xc9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpq   $0x0,0x38(%rbp)
je     1d55 <evaluateGTRCATPROTMULT+0xc15>
mov    0x40(%rbp),%eax
mov    %eax,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    1d3a <evaluateGTRCATPROTMULT+0xbfa>
mov    -0x28(%rbp),%rax
movslq -0x124(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x11c(%rbp)
mov    0x28(%rbp),%rax
imul   $0x1cc,-0x11c(%rbp),%ecx
mov    0x38(%rbp),%rdx
movslq -0x124(%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,-0x110(%rbp)
mov    0x10(%rbp),%rax
imul   $0x14,-0x124(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x118(%rbp)
mov    -0x108(%rbp),%rax
imul   $0x13,-0x11c(%rbp),%ecx
imul   0x50(%rbp),%ecx
mov    -0x20(%rbp),%rdx
movslq -0x124(%rbp),%rsi
imul   $0x13,(%rdx,%rsi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x50(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x78(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x80(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x80(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x88(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
mov    -0x110(%rbp),%rax
movsd  0x90(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x90(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x98(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
call   1060 <log@plt>
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x124(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  0x1334(%rip),%xmm0
call   1060 <log@plt>
movsd  -0x138(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x130(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x30(%rbp),%rax
movslq -0x124(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    1658 <evaluateGTRCATPROTMULT+0x518>
mov    -0x108(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    244f <evaluateGTRCATPROTMULT+0x130f>
mov    0x40(%rbp),%eax
mov    %eax,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    2439 <evaluateGTRCATPROTMULT+0x12f9>
mov    -0x28(%rbp),%rax
movslq -0x124(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x108(%rbp),%rax
imul   $0x13,-0x11c(%rbp),%ecx
imul   0x50(%rbp),%ecx
mov    -0x20(%rbp),%rdx
movslq -0x124(%rbp),%rsi
imul   $0x13,(%rdx,%rsi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x38(%rbp),%rax
imul   $0x14,-0x124(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x110(%rbp)
mov    0x10(%rbp),%rax
imul   $0x14,-0x124(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x118(%rbp)
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
mov    -0x110(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x50(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x78(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x80(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x80(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x88(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x90(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x90(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0x118(%rbp),%rax
mulsd  0x98(%rax),%xmm0
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
call   1060 <log@plt>
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x124(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x124(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0xc35(%rip),%xmm0
call   1060 <log@plt>
movsd  -0x148(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x140(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x30(%rbp),%rax
movslq -0x124(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    1d5e <evaluateGTRCATPROTMULT+0xc1e>
mov    -0x108(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<evaluateGTRCATPROTMULT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,0x70(%rsp)
mov    %r8,0x28(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rsi,0x20(%rsp)
mov    %rdi,0x68(%rsp)
mov    0x168(%rsp),%ebx
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x30(%rsp)
cmpl   $0x0,0x170(%rsp)
jne    11a9 <evaluateGTRCATPROTMULT+0x69>
movsd  0xe6e(%rip),%xmm0
mov    0x140(%rsp),%rax
maxsd  (%rax),%xmm0
call   1060 <log@plt>
movsd  %xmm0,0x30(%rsp)
movslq 0x160(%rsp),%rax
movslq %ebx,%rbp
imul   %rbp,%rax
imul   $0x98,%rax,%rdi
call   1040 <malloc@plt>
mov    %rax,%r12
test   %ebp,%ebp
mov    0x160(%rsp),%ebp
mov    0x28(%rsp),%rcx
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rdi
jle    15d7 <evaluateGTRCATPROTMULT+0x497>
mov    0x130(%rsp),%r13
mov    %ebx,%eax
mov    %rax,0x78(%rsp)
mov    %ebp,%r15d
xor    %r14d,%r14d
mov    %r12,%rbx
jmp    120f <evaluateGTRCATPROTMULT+0xcf>
nop
add    $0x1,%r14
cmp    0x78(%rsp),%r14
je     15d7 <evaluateGTRCATPROTMULT+0x497>
cmpl   $0x0,0x170(%rsp)
je     1249 <evaluateGTRCATPROTMULT+0x109>
movsd  0xddf(%rip),%xmm0
mov    0x140(%rsp),%rax
maxsd  (%rax,%r14,8),%xmm0
call   1060 <log@plt>
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rcx
movsd  %xmm0,0x30(%rsp)
test   %ebp,%ebp
jle    1200 <evaluateGTRCATPROTMULT+0xc0>
lea    (%r14,%r14,8),%eax
lea    (%r14,%rax,2),%eax
mov    0x128(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
movsd  0x30(%rsp),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x8(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x58(%rsp)
movsd  0x10(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp)
movsd  0x18(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x48(%rsp)
movsd  0x20(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp)
movsd  0x28(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x38(%rsp)
movsd  0x30(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xe0(%rsp)
movsd  0x38(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xd8(%rsp)
movsd  0x40(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xd0(%rsp)
movsd  0x48(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xc8(%rsp)
movsd  0x50(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xc0(%rsp)
movsd  0x58(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xb8(%rsp)
movsd  0x60(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xb0(%rsp)
movsd  0x68(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xa8(%rsp)
movsd  0x70(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xa0(%rsp)
movsd  0x78(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x98(%rsp)
movsd  0x80(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x90(%rsp)
movsd  0x88(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x88(%rsp)
movsd  0x90(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x80(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mulsd  0x10(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0x58(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x8(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0x50(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x10(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0x48(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x18(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0x40(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x20(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0x38(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x28(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0xe0(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x30(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0xd8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x38(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0xd0(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x40(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0xc8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x48(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0xc0(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x50(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0xb8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x58(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0xb0(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x60(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0xa8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x68(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0xa0(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x70(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0x98(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x78(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0x90(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x80(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0x88(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x88(%rbx)
movsd  0x8(%rsp),%xmm0
mulsd  0x80(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x90(%rbx)
add    $0x98,%rbx
add    $0x1,%rbp
cmp    %rbp,%r15
jne    13d0 <evaluateGTRCATPROTMULT+0x290>
mov    0x160(%rsp),%ebp
mov    0x28(%rsp),%rcx
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rdi
jmp    1200 <evaluateGTRCATPROTMULT+0xc0>
mov    0x158(%rsp),%eax
mov    0x150(%rsp),%ebx
mov    0x120(%rsp),%r15
mov    0x148(%rsp),%rdx
xorpd  %xmm0,%xmm0
test   %rdx,%rdx
je     18c4 <evaluateGTRCATPROTMULT+0x784>
cmp    %eax,%ebx
mov    0x60(%rsp),%rcx
jge    1ba7 <evaluateGTRCATPROTMULT+0xa67>
mov    %ebp,%esi
mov    0x138(%rsp),%r13
movslq %ebx,%r14
cltq
mov    %rax,0x10(%rsp)
lea    (%r14,%r14,4),%rax
shl    $0x5,%rax
lea    (%rax,%r15,1),%rbx
add    $0x98,%rbx
xorpd  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,0x8(%rsp)
mov    %rcx,%r15
movslq (%rcx,%r14,4),%rcx
imul   $0x1cc,%rcx,%rax
movsbq (%rdx,%r14,1),%rdx
lea    (%rdx,%rdx,4),%rdx
lea    (%rax,%rdx,4),%rax
imul   %esi,%ecx
add    (%rdi,%r14,4),%ecx
lea    (%rcx,%rcx,8),%edx
lea    (%rcx,%rdx,2),%ecx
movsd  0x0(%r13,%rax,8),%xmm0
movsd  0x8(%r13,%rax,8),%xmm1
mulsd  -0x98(%rbx),%xmm0
ff
mulsd  -0x90(%rbx),%xmm1
ff
movslq %ecx,%rcx
mulsd  (%r12,%rcx,8),%xmm1
movsd  0x10(%r13,%rax,8),%xmm2
mulsd  -0x88(%rbx),%xmm2
ff
mulsd  0x8(%r12,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%r13,%rax,8),%xmm0
mulsd  -0x80(%rbx),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x10(%r12,%rcx,8),%xmm0
movsd  0x20(%r13,%rax,8),%xmm1
mulsd  -0x78(%rbx),%xmm1
mulsd  0x18(%r12,%rcx,8),%xmm1
addsd  %xmm2,%xmm0
movsd  0x28(%r13,%rax,8),%xmm2
mulsd  -0x70(%rbx),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x20(%r12,%rcx,8),%xmm2
movsd  0x30(%r13,%rax,8),%xmm0
mulsd  -0x68(%rbx),%xmm0
mulsd  0x28(%r12,%rcx,8),%xmm0
addsd  %xmm1,%xmm2
movsd  0x38(%r13,%rax,8),%xmm1
mulsd  -0x60(%rbx),%xmm1
addsd  %xmm2,%xmm0
mulsd  0x30(%r12,%rcx,8),%xmm1
movsd  0x40(%r13,%rax,8),%xmm2
mulsd  -0x58(%rbx),%xmm2
mulsd  0x38(%r12,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x48(%r13,%rax,8),%xmm0
mulsd  -0x50(%rbx),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x40(%r12,%rcx,8),%xmm0
movsd  0x50(%r13,%rax,8),%xmm1
mulsd  -0x48(%rbx),%xmm1
mulsd  0x48(%r12,%rcx,8),%xmm1
addsd  %xmm2,%xmm0
movsd  0x58(%r13,%rax,8),%xmm2
mulsd  -0x40(%rbx),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x50(%r12,%rcx,8),%xmm2
movsd  0x60(%r13,%rax,8),%xmm0
mulsd  -0x38(%rbx),%xmm0
mulsd  0x58(%r12,%rcx,8),%xmm0
addsd  %xmm1,%xmm2
movsd  0x68(%r13,%rax,8),%xmm1
mulsd  -0x30(%rbx),%xmm1
addsd  %xmm2,%xmm0
mulsd  0x60(%r12,%rcx,8),%xmm1
movsd  0x70(%r13,%rax,8),%xmm2
mulsd  -0x28(%rbx),%xmm2
mulsd  0x68(%r12,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x78(%r13,%rax,8),%xmm0
mulsd  -0x20(%rbx),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x70(%r12,%rcx,8),%xmm0
movsd  0x80(%r13,%rax,8),%xmm1
mulsd  -0x18(%rbx),%xmm1
mulsd  0x78(%r12,%rcx,8),%xmm1
addsd  %xmm2,%xmm0
movsd  0x88(%r13,%rax,8),%xmm2
mulsd  -0x10(%rbx),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x80(%r12,%rcx,8),%xmm2
movsd  0x90(%r13,%rax,8),%xmm3
mulsd  -0x8(%rbx),%xmm3
mulsd  0x88(%r12,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x98(%r13,%rax,8),%xmm0
mulsd  (%rbx),%xmm0
addsd  %xmm2,%xmm3
mulsd  0x90(%r12,%rcx,8),%xmm0
addsd  %xmm3,%xmm0
mov    %esi,%ebp
call   1060 <log@plt>
mov    %r15,%rcx
mov    %ebp,%esi
mov    0x148(%rsp),%rdx
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%r14,4),%xmm1
mulsd  0x78b(%rip),%xmm1
addsd  %xmm0,%xmm1
mov    0x28(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax,%r14,4),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%rsp),%xmm0
add    $0x1,%r14
add    $0xa0,%rbx
cmp    %r14,0x10(%rsp)
jne    1640 <evaluateGTRCATPROTMULT+0x500>
jmp    1ba7 <evaluateGTRCATPROTMULT+0xa67>
cmp    %eax,%ebx
mov    %ebp,%r14d
mov    0x60(%rsp),%r8
mov    0x70(%rsp),%rbp
jge    1ba7 <evaluateGTRCATPROTMULT+0xa67>
movslq %ebx,%r9
movslq %eax,%r10
lea    (%r9,%r9,4),%rax
lea    0x26(,%rax,8),%rbx
lea    (%r8,%r9,4),%rax
mov    %rax,0x58(%rsp)
lea    (%rdi,%r9,4),%rax
mov    %rax,0x50(%rsp)
mov    0x68(%rsp),%rax
lea    (%rax,%r9,4),%rax
mov    %rax,0x48(%rsp)
lea    (%rsi,%r9,4),%rax
mov    %rax,0x40(%rsp)
lea    (%rcx,%r9,4),%rax
mov    %rax,0x38(%rsp)
sub    %r9,%r10
mov    %r10,0x10(%rsp)
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
nopl   0x0(%rax)
movsd  %xmm0,0x8(%rsp)
mov    0x58(%rsp),%rax
mov    (%rax,%r13,4),%eax
imul   %r14d,%eax
mov    0x50(%rsp),%rcx
add    (%rcx,%r13,4),%eax
lea    (%rax,%rax,8),%ecx
lea    (%rax,%rcx,2),%eax
movsd  -0x98(%rbp,%rbx,4),%xmm0
ff ff
movsd  -0x90(%rbp,%rbx,4),%xmm1
ff ff
mulsd  -0x98(%r15,%rbx,4),%xmm0
ff ff ff
mulsd  -0x90(%r15,%rbx,4),%xmm1
ff ff ff
cltq
mulsd  (%r12,%rax,8),%xmm1
movsd  -0x88(%rbp,%rbx,4),%xmm2
ff ff
mulsd  -0x88(%r15,%rbx,4),%xmm2
ff ff ff
mulsd  0x8(%r12,%rax,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp,%rbx,4),%xmm0
mulsd  -0x80(%r15,%rbx,4),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x10(%r12,%rax,8),%xmm0
movsd  -0x78(%rbp,%rbx,4),%xmm1
mulsd  -0x78(%r15,%rbx,4),%xmm1
mulsd  0x18(%r12,%rax,8),%xmm1
addsd  %xmm2,%xmm0
movsd  -0x70(%rbp,%rbx,4),%xmm2
mulsd  -0x70(%r15,%rbx,4),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x20(%r12,%rax,8),%xmm2
movsd  -0x68(%rbp,%rbx,4),%xmm0
mulsd  -0x68(%r15,%rbx,4),%xmm0
mulsd  0x28(%r12,%rax,8),%xmm0
addsd  %xmm1,%xmm2
movsd  -0x60(%rbp,%rbx,4),%xmm1
mulsd  -0x60(%r15,%rbx,4),%xmm1
addsd  %xmm2,%xmm0
mulsd  0x30(%r12,%rax,8),%xmm1
movsd  -0x58(%rbp,%rbx,4),%xmm2
mulsd  -0x58(%r15,%rbx,4),%xmm2
mulsd  0x38(%r12,%rax,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp,%rbx,4),%xmm0
mulsd  -0x50(%r15,%rbx,4),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x40(%r12,%rax,8),%xmm0
movsd  -0x48(%rbp,%rbx,4),%xmm1
mulsd  -0x48(%r15,%rbx,4),%xmm1
mulsd  0x48(%r12,%rax,8),%xmm1
addsd  %xmm2,%xmm0
movsd  -0x40(%rbp,%rbx,4),%xmm2
mulsd  -0x40(%r15,%rbx,4),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x50(%r12,%rax,8),%xmm2
movsd  -0x38(%rbp,%rbx,4),%xmm0
mulsd  -0x38(%r15,%rbx,4),%xmm0
mulsd  0x58(%r12,%rax,8),%xmm0
addsd  %xmm1,%xmm2
movsd  -0x30(%rbp,%rbx,4),%xmm1
mulsd  -0x30(%r15,%rbx,4),%xmm1
addsd  %xmm2,%xmm0
mulsd  0x60(%r12,%rax,8),%xmm1
movsd  -0x28(%rbp,%rbx,4),%xmm2
mulsd  -0x28(%r15,%rbx,4),%xmm2
mulsd  0x68(%r12,%rax,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x20(%rbp,%rbx,4),%xmm0
mulsd  -0x20(%r15,%rbx,4),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x70(%r12,%rax,8),%xmm0
movsd  -0x18(%rbp,%rbx,4),%xmm1
mulsd  -0x18(%r15,%rbx,4),%xmm1
mulsd  0x78(%r12,%rax,8),%xmm1
addsd  %xmm2,%xmm0
movsd  -0x10(%rbp,%rbx,4),%xmm2
mulsd  -0x10(%r15,%rbx,4),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x80(%r12,%rax,8),%xmm2
movsd  -0x8(%rbp,%rbx,4),%xmm3
mulsd  -0x8(%r15,%rbx,4),%xmm3
mulsd  0x88(%r12,%rax,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x0(%rbp,%rbx,4),%xmm0
mulsd  (%r15,%rbx,4),%xmm0
addsd  %xmm2,%xmm3
mulsd  0x90(%r12,%rax,8),%xmm0
addsd  %xmm3,%xmm0
call   1060 <log@plt>
mov    0x40(%rsp),%rax
mov    (%rax,%r13,4),%eax
mov    0x48(%rsp),%rcx
add    (%rcx,%r13,4),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  0x4a0(%rip),%xmm1
addsd  %xmm0,%xmm1
mov    0x38(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax,%r13,4),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%rsp),%xmm0
add    $0x28,%rbx
add    $0x1,%r13
cmp    %r13,0x10(%rsp)
jne    1930 <evaluateGTRCATPROTMULT+0x7f0>
movsd  %xmm0,0x8(%rsp)
mov    %r12,%rdi
call   1030 <free@plt>
movsd  0x8(%rsp),%xmm0
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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