void categorizeGTRGAMMAPROTMULTINVAR(char *tipX1, double *x2, int *ex2,
                                     double *pz, double *gammaRates,
                                     double *EIGN, double *tipVector,
                                     int *rateCategory, int lower, int upper,
                                     int *modelptr, int NumberOfModels,
                                     int *iptr, double *invariants,
                                     double *frequencies, int multiBranch) {
  double z, lz = 0.0, term[4], ki, min, allSum;
  int i, j, index = 0;
  double *diagptable, *diagptable_start;
  double *left, *right;
  int model;
  double *scalers;
  double *freqs;
  if (!multiBranch) {
    z = pz[0];
    if (z < 1.0E-15)
      z = 1.0E-15;
    lz = log(z);
  }
  diagptable = diagptable_start =
      (double *)malloc(sizeof(double) * 4 * 19 * NumberOfModels);
  freqs = (double *)malloc(20 * NumberOfModels * sizeof(double));
  scalers = (double *)malloc(NumberOfModels * sizeof(double));
  for (model = 0; model < NumberOfModels; model++) {
    if (multiBranch) {
      z = pz[model];
      if (z < 1.0E-15)
        z = 1.0E-15;
      lz = log(z);
    }
    diagptable = &diagptable_start[4 * 19 * model];
    scalers[model] = (1.0 - invariants[model]);
    for (i = 0; i < 20; i++)
      freqs[20 * model + i] = frequencies[20 * model + i] * invariants[model];
    for (i = 0; i < 4; i++) {
      ki = gammaRates[model * 4 + i];
      for (j = 0; j < 19; j++)
        *diagptable++ = exp(EIGN[model * 19 + j] * ki * lz);
    }
  }
  for (i = lower; i < upper; i++) {
    model = modelptr[i];
    left = &(tipVector[460 * model + 20 * tipX1[i]]);
    diagptable = &diagptable_start[76 * model];
    for (j = 0; j < 4; j++) {
      right = &(x2[80 * i + 20 * j]);
      term[j] = 0;
      term[j] += left[0] * right[0];
      term[j] += left[1] * right[1] * *diagptable++;
      term[j] += left[2] * right[2] * *diagptable++;
      term[j] += left[3] * right[3] * *diagptable++;
      term[j] += left[4] * right[4] * *diagptable++;
      term[j] += left[5] * right[5] * *diagptable++;
      term[j] += left[6] * right[6] * *diagptable++;
      term[j] += left[7] * right[7] * *diagptable++;
      term[j] += left[8] * right[8] * *diagptable++;
      term[j] += left[9] * right[9] * *diagptable++;
      term[j] += left[10] * right[10] * *diagptable++;
      term[j] += left[11] * right[11] * *diagptable++;
      term[j] += left[12] * right[12] * *diagptable++;
      term[j] += left[13] * right[13] * *diagptable++;
      term[j] += left[14] * right[14] * *diagptable++;
      term[j] += left[15] * right[15] * *diagptable++;
      term[j] += left[16] * right[16] * *diagptable++;
      term[j] += left[17] * right[17] * *diagptable++;
      term[j] += left[18] * right[18] * *diagptable++;
      term[j] += left[19] * right[19] * *diagptable++;
      if (iptr[i] < 20)
        term[j] = log(
            (scalers[model] * term[j] + freqs[model * 20 + iptr[i]]) *
            pow((1.0 /
                 115792089237316195423570985008687907853269984665640564039457584007913129639936.0),
                ex2[i]));
      else
        term[j] =
            log(scalers[model] * term[j]) +
            ex2[i] *
                log((
                    1.0 /
                    115792089237316195423570985008687907853269984665640564039457584007913129639936.0));
    }
    allSum = 0.25 * (term[0] + term[1] + term[2] + term[3]);
    allSum = 1.0 / allSum;
    term[0] = 0.25 * term[0] * allSum;
    term[1] = 0.25 * term[1] * allSum;
    term[2] = 0.25 * term[2] * allSum;
    term[3] = 0.25 * term[3] * allSum;
    min = 1.0E300;
    if (term[0] < min) {
      min = term[0];
      index = 0;
    }
    if (term[1] < min) {
      min = term[1];
      index = 1;
    }
    if (term[2] < min) {
      min = term[2];
      index = 2;
    }
    if (term[3] < min) {
      min = term[3];
      index = 3;
    }
    rateCategory[i] = index;
  }
  free(diagptable_start);
  free(freqs);
  free(scalers);
  return;
}


x86 assembly (clang, -O0):
<categorizeGTRGAMMAPROTMULTINVAR>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x84(%rbp)
cmpl   $0x0,0x58(%rbp)
jne    11ef <categorizeGTRGAMMAPROTMULTINVAR+0x9f>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xe38(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    11e0 <categorizeGTRGAMMAPROTMULTINVAR+0x90>
movsd  0xe25(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x40(%rbp)
movslq 0x38(%rbp),%rax
imul   $0x260,%rax,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
mov    %rax,-0x90(%rbp)
imul   $0x14,0x38(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movslq 0x38(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    13fe <categorizeGTRGAMMAPROTMULTINVAR+0x2ae>
cmpl   $0x0,0x58(%rbp)
je     129f <categorizeGTRGAMMAPROTMULTINVAR+0x14f>
mov    -0x20(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xd88(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1290 <categorizeGTRGAMMAPROTMULTINVAR+0x140>
movsd  0xd75(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x98(%rbp),%rax
imul   $0x4c,-0xac(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    0x48(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  0xd47(%rip),%xmm0
subsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x7c(%rbp)
cmpl   $0x14,-0x7c(%rbp)
jge    1347 <categorizeGTRGAMMAPROTMULTINVAR+0x1f7>
mov    0x50(%rbp),%rax
imul   $0x14,-0xac(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0xac(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
imul   $0x14,-0xac(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    12f0 <categorizeGTRGAMMAPROTMULTINVAR+0x1a0>
movl   $0x0,-0x7c(%rbp)
cmpl   $0x4,-0x7c(%rbp)
jge    13e5 <categorizeGTRGAMMAPROTMULTINVAR+0x295>
mov    -0x28(%rbp),%rax
mov    -0xac(%rbp),%ecx
shl    $0x2,%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x80(%rbp)
cmpl   $0x13,-0x80(%rbp)
jge    13d2 <categorizeGTRGAMMAPROTMULTINVAR+0x282>
mov    -0x30(%rbp),%rax
imul   $0x13,-0xac(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  %xmm0,(%rax)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    137c <categorizeGTRGAMMAPROTMULTINVAR+0x22c>
jmp    13d7 <categorizeGTRGAMMAPROTMULTINVAR+0x287>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    134e <categorizeGTRGAMMAPROTMULTINVAR+0x1fe>
jmp    13ea <categorizeGTRGAMMAPROTMULTINVAR+0x29a>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1242 <categorizeGTRGAMMAPROTMULTINVAR+0xf2>
mov    0x20(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1cde <categorizeGTRGAMMAPROTMULTINVAR+0xb8e>
mov    0x30(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xac(%rbp)
mov    0x10(%rbp),%rax
imul   $0x1cc,-0xac(%rbp),%ecx
mov    -0x8(%rbp),%rdx
movslq -0x7c(%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,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
imul   $0x4c,-0xac(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x80(%rbp)
cmpl   $0x4,-0x80(%rbp)
jge    1b7f <categorizeGTRGAMMAPROTMULTINVAR+0xa2f>
mov    -0x10(%rbp),%rax
imul   $0x50,-0x7c(%rbp),%ecx
imul   $0x14,-0x80(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movslq -0x80(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x40(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x50(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x60(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x60(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x68(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x70(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x78(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x78(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x80(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x80(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x88(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x88(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x90(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x90(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0xa0(%rbp),%rax
movsd  0x98(%rax),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x98(%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    0x40(%rbp),%rax
movslq -0x7c(%rbp),%rcx
cmpl   $0x14,(%rax,%rcx,4)
jge    1afb <categorizeGTRGAMMAPROTMULTINVAR+0x9ab>
mov    -0xb8(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm2
mov    -0xc0(%rbp),%rax
imul   $0x14,-0xac(%rbp),%ecx
mov    0x40(%rbp),%rdx
movslq -0x7c(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
movsd  0x54d(%rip),%xmm0
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
call   1060 <log@plt>
movslq -0x80(%rbp),%rax
movsd  %xmm0,-0x60(%rbp,%rax,8)
jmp    1b6c <categorizeGTRGAMMAPROTMULTINVAR+0xa1c>
mov    -0xb8(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x80(%rbp),%rax
mulsd  -0x60(%rbp,%rax,8),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0x4de(%rip),%xmm0
call   1060 <log@plt>
movsd  -0xd8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x80(%rbp),%rax
movsd  %xmm0,-0x60(%rbp,%rax,8)
jmp    1b71 <categorizeGTRGAMMAPROTMULTINVAR+0xa21>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1477 <categorizeGTRGAMMAPROTMULTINVAR+0x327>
movsd  -0x60(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
addsd  -0x48(%rbp),%xmm1
movsd  0x475(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x46c(%rip),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x452(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x43b(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x424(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x40d(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x3ee(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c47 <categorizeGTRGAMMAPROTMULTINVAR+0xaf7>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x84(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c6f <categorizeGTRGAMMAPROTMULTINVAR+0xb1f>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x1,-0x84(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c97 <categorizeGTRGAMMAPROTMULTINVAR+0xb47>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x2,-0x84(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1cbf <categorizeGTRGAMMAPROTMULTINVAR+0xb6f>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x3,-0x84(%rbp)
mov    -0x84(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1404 <categorizeGTRGAMMAPROTMULTINVAR+0x2b4>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<categorizeGTRGAMMAPROTMULTINVAR>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,0x20(%rsp)
mov    %r8,%r13
mov    %rcx,0x50(%rsp)
mov    %rdx,0x58(%rsp)
mov    %rsi,0x60(%rsp)
mov    %rdi,0x80(%rsp)
mov    0x158(%rsp),%ecx
mov    0x150(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x148(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0x140(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    0x138(%rsp),%ebx
mov    0x130(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    0x128(%rsp),%eax
mov    %eax,0x4c(%rsp)
mov    0x120(%rsp),%eax
mov    %eax,0x48(%rsp)
mov    0x118(%rsp),%rax
mov    %rax,0x70(%rsp)
xorpd  %xmm0,%xmm0
mov    0x110(%rsp),%rax
mov    %rax,0x68(%rsp)
mov    %ecx,0x18(%rsp)
test   %ecx,%ecx
jne    121d <categorizeGTRGAMMAPROTMULTINVAR+0xcd>
movsd  0xdf1(%rip),%xmm0
mov    0x50(%rsp),%rax
maxsd  (%rax),%xmm0
call   1060 <log@plt>
movsd  %xmm0,0x10(%rsp)
movslq %ebx,%rbp
imul   $0x260,%rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0x30(%rsp)
lea    0x0(,%rbp,4),%eax
lea    (%rax,%rax,4),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %rbp,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
movsd  0x10(%rsp),%xmm2
mov    %rax,0x28(%rsp)
test   %ebp,%ebp
jle    1528 <categorizeGTRGAMMAPROTMULTINVAR+0x3d8>
mov    %ebx,%eax
mov    %rax,0x88(%rsp)
xor    %ebx,%ebx
xor    %r14d,%r14d
mov    %r13,0x90(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %ebx,%ebp
and    $0x3fffffff,%ebp
shl    $0x5,%rbp
add    0x30(%rsp),%rbp
cmpl   $0x0,0x18(%rsp)
je     12c4 <categorizeGTRGAMMAPROTMULTINVAR+0x174>
movsd  0xd50(%rip),%xmm0
mov    0x50(%rsp),%rax
maxsd  (%rax,%r14,8),%xmm0
call   1060 <log@plt>
movapd %xmm0,%xmm2
mov    %rbx,0x38(%rsp)
mov    %ebx,%eax
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,8),%r15
mov    0x98(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
movsd  0xd1e(%rip),%xmm1
subsd  %xmm0,%xmm1
mov    0x28(%rsp),%rax
movsd  %xmm1,(%rax,%r14,8)
lea    0x0(,%r14,4),%r12d
lea    (%r12,%r12,4),%eax
lea    0x0(,%rax,8),%rcx
mov    0xa0(%rsp),%rsi
movupd (%rsi,%rax,8),%xmm1
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm1
mov    0x40(%rsp),%rdx
movupd %xmm1,(%rdx,%rax,8)
or     $0x10,%rcx
movupd (%rsi,%rcx,1),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%rdx,%rcx,1)
movupd 0x20(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x20(%rdx,%rax,8)
movupd 0x30(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x30(%rdx,%rax,8)
movupd 0x40(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x40(%rdx,%rax,8)
movupd 0x50(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x50(%rdx,%rax,8)
movupd 0x60(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x60(%rdx,%rax,8)
movupd 0x70(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x70(%rdx,%rax,8)
movupd 0x80(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x80(%rdx,%rax,8)
movupd 0x90(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x90(%rdx,%rax,8)
movsd  0x0(%r13,%r12,8),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebx,%ebx
movsd  %xmm2,0x10(%rsp)
nop
movsd  (%r15,%rbx,1),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  %xmm2,%xmm0
call   1050 <exp@plt>
movsd  0x10(%rsp),%xmm2
movsd  %xmm0,0x0(%rbp,%rbx,1)
add    $0x8,%rbx
cmp    $0x98,%rbx
jne    13e0 <categorizeGTRGAMMAPROTMULTINVAR+0x290>
shl    $0x3,%r12
mov    %r12,%rax
or     $0x8,%rax
movsd  0x0(%r13,%rax,1),%xmm0
movsd  %xmm0,0x8(%rsp)
add    %rbx,%rbp
mov    $0x13,%r13d
mov    %r15,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  %xmm2,%xmm0
call   1050 <exp@plt>
movsd  0x10(%rsp),%xmm2
movsd  %xmm0,0x0(%rbp)
add    $0x8,%rbp
add    $0x8,%rbx
add    $0xffffffffffffffff,%r13
jne    1440 <categorizeGTRGAMMAPROTMULTINVAR+0x2f0>
mov    %r12,%rax
or     $0x10,%rax
mov    0x90(%rsp),%r13
movsd  0x0(%r13,%rax,1),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,8),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  %xmm2,%xmm0
call   1050 <exp@plt>
movsd  0x10(%rsp),%xmm2
movsd  %xmm0,0x0(%rbp)
add    $0x8,%rbp
add    $0x1,%rbx
cmp    $0x13,%rbx
jne    1490 <categorizeGTRGAMMAPROTMULTINVAR+0x340>
or     $0x18,%r12
movsd  0x0(%r13,%r12,1),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,8),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  %xmm2,%xmm0
call   1050 <exp@plt>
movsd  0x10(%rsp),%xmm2
movsd  %xmm0,0x0(%rbp)
add    $0x8,%rbp
add    $0x1,%rbx
cmp    $0x13,%rbx
jne    14e0 <categorizeGTRGAMMAPROTMULTINVAR+0x390>
add    $0x1,%r14
mov    0x38(%rsp),%rbx
add    $0x13,%ebx
cmp    0x88(%rsp),%r14
jne    1290 <categorizeGTRGAMMAPROTMULTINVAR+0x140>
mov    0x4c(%rsp),%eax
mov    0x48(%rsp),%ecx
cmp    %eax,%ecx
jge    1953 <categorizeGTRGAMMAPROTMULTINVAR+0x803>
movslq %ecx,%rbp
cltq
mov    %rax,0x18(%rsp)
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
shl    $0x7,%rax
mov    0x60(%rsp),%rcx
lea    (%rax,%rcx,1),%rbx
add    $0x98,%rbx
xor    %r13d,%r13d
jmp    165c <categorizeGTRGAMMAPROTMULTINVAR+0x50c>
nopl   0x0(%rax)
movapd 0xb0(%rsp),%xmm1
movapd 0xc0(%rsp),%xmm0
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
addsd  %xmm2,%xmm3
mulsd  0xa7a(%rip),%xmm3
movsd  0xa5a(%rip),%xmm2
divsd  %xmm3,%xmm2
movapd 0xa86(%rip),%xmm4
mulpd  %xmm4,%xmm1
unpcklpd %xmm2,%xmm2
mulpd  %xmm2,%xmm1
movsd  0xa5a(%rip),%xmm5
ucomisd %xmm1,%xmm5
movapd %xmm1,0xb0(%rsp)
mov    $0x0,%eax
cmova  %eax,%r13d
movapd %xmm1,%xmm3
minsd  %xmm5,%xmm3
unpckhpd %xmm1,%xmm1
ucomisd %xmm1,%xmm3
mulpd  %xmm4,%xmm0
mov    $0x1,%eax
cmova  %eax,%r13d
mulpd  %xmm2,%xmm0
minsd  %xmm3,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,0xc0(%rsp)
mov    $0x2,%eax
cmova  %eax,%r13d
movapd %xmm0,%xmm2
minsd  %xmm1,%xmm2
unpckhpd %xmm0,%xmm0
ucomisd %xmm0,%xmm2
mov    $0x3,%eax
cmova  %eax,%r13d
mov    0x70(%rsp),%rax
mov    %r13d,(%rax,%rbp,4)
add    $0x1,%rbp
mov    0x20(%rsp),%rbx
add    $0x280,%rbx
cmp    0x18(%rsp),%rbp
je     1953 <categorizeGTRGAMMAPROTMULTINVAR+0x803>
mov    0x78(%rsp),%rax
movslq (%rax,%rbp,4),%rax
imul   $0x1cc,%rax,%rcx
mov    0x80(%rsp),%rdx
movsbq (%rdx,%rbp,1),%rdx
lea    (%rdx,%rdx,4),%rdx
lea    (%rcx,%rdx,4),%rcx
mov    0x68(%rsp),%rdx
lea    (%rdx,%rcx,8),%r14
imul   $0x260,%rax,%r12
add    0x30(%rsp),%r12
lea    0x0(,%rax,4),%rcx
lea    (%rcx,%rcx,4),%rcx
mov    %rcx,0x38(%rsp)
mov    0x28(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbx,0x20(%rsp)
xor    %r15d,%r15d
jmp    171e <categorizeGTRGAMMAPROTMULTINVAR+0x5ce>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  0x10(%rsp),%xmm0
call   1060 <log@plt>
movapd %xmm0,%xmm1
mov    0x58(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax,%rbp,4),%xmm0
mulsd  0x91c(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0xb0(%rsp,%r15,8)
add    $0x1,%r15
add    $0xa0,%rbx
add    $0x98,%r12
cmp    $0x4,%r15
je     1570 <categorizeGTRGAMMAPROTMULTINVAR+0x420>
movsd  (%r14),%xmm0
movsd  0x8(%r14),%xmm1
mulsd  -0x98(%rbx),%xmm0
ff
addsd  0x8f7(%rip),%xmm0
mulsd  -0x90(%rbx),%xmm1
ff
mulsd  (%r12),%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm0
mulsd  -0x88(%rbx),%xmm0
ff
mulsd  0x8(%r12),%xmm0
addsd  %xmm1,%xmm0
movsd  0x18(%r14),%xmm1
mulsd  -0x80(%rbx),%xmm1
mulsd  0x10(%r12),%xmm1
addsd  %xmm0,%xmm1
movsd  0x20(%r14),%xmm0
mulsd  -0x78(%rbx),%xmm0
mulsd  0x18(%r12),%xmm0
addsd  %xmm1,%xmm0
movsd  0x28(%r14),%xmm1
mulsd  -0x70(%rbx),%xmm1
mulsd  0x20(%r12),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0xb0(%rsp,%r15,8)
movsd  0x30(%r14),%xmm0
movsd  0x38(%r14),%xmm2
mulsd  -0x68(%rbx),%xmm0
mulsd  0x28(%r12),%xmm0
mulsd  -0x60(%rbx),%xmm2
mulsd  0x30(%r12),%xmm2
addsd  %xmm1,%xmm0
movsd  0x40(%r14),%xmm1
mulsd  -0x58(%rbx),%xmm1
addsd  %xmm0,%xmm2
mulsd  0x38(%r12),%xmm1
movsd  0x48(%r14),%xmm0
mulsd  -0x50(%rbx),%xmm0
mulsd  0x40(%r12),%xmm0
addsd  %xmm2,%xmm1
movsd  0x50(%r14),%xmm2
mulsd  -0x48(%rbx),%xmm2
addsd  %xmm1,%xmm0
mulsd  0x48(%r12),%xmm2
movsd  0x58(%r14),%xmm1
mulsd  -0x40(%rbx),%xmm1
mulsd  0x50(%r12),%xmm1
addsd  %xmm0,%xmm2
movsd  0x60(%r14),%xmm0
mulsd  -0x38(%rbx),%xmm0
addsd  %xmm2,%xmm1
mulsd  0x58(%r12),%xmm0
movsd  0x68(%r14),%xmm2
mulsd  -0x30(%rbx),%xmm2
mulsd  0x60(%r12),%xmm2
addsd  %xmm1,%xmm0
movsd  0x70(%r14),%xmm1
mulsd  -0x28(%rbx),%xmm1
addsd  %xmm0,%xmm2
mulsd  0x68(%r12),%xmm1
movsd  0x78(%r14),%xmm0
mulsd  -0x20(%rbx),%xmm0
mulsd  0x70(%r12),%xmm0
addsd  %xmm2,%xmm1
movsd  0x80(%r14),%xmm2
mulsd  -0x18(%rbx),%xmm2
addsd  %xmm1,%xmm0
mulsd  0x78(%r12),%xmm2
movsd  0x88(%r14),%xmm1
mulsd  -0x10(%rbx),%xmm1
mulsd  0x80(%r12),%xmm1
addsd  %xmm0,%xmm2
movsd  0x90(%r14),%xmm3
mulsd  -0x8(%rbx),%xmm3
addsd  %xmm2,%xmm1
mulsd  0x88(%r12),%xmm3
movsd  0x98(%r14),%xmm0
mulsd  (%rbx),%xmm0
mulsd  0x90(%r12),%xmm0
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
mov    0xa8(%rsp),%rax
movslq (%rax,%rbp,4),%rax
cmp    $0x13,%rax
jg     16d0 <categorizeGTRGAMMAPROTMULTINVAR+0x580>
add    0x38(%rsp),%rax
mulsd  0x10(%rsp),%xmm0
mov    0x40(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x58(%rsp),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%rbp,4),%xmm1
movsd  0x6da(%rip),%xmm0
call   1070 <pow@plt>
mulsd  0x8(%rsp),%xmm0
call   1060 <log@plt>
jmp    16f8 <categorizeGTRGAMMAPROTMULTINVAR+0x5a8>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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