void categorizeGTRGAMMAPROT(char *tipX1, double *x2, int *ex2, double *pz,
                            double *gammaRates, double *EIGN, double *tipVector,
                            int *rateCategory, int lower, int upper) {
  double z, lz, term[4], ki, min, allSum;
  int i, j, index = 0;
  double *diagptable, *diagptable_start;
  double *left, *right;
  z = pz[0];
  if (z < 1.0E-15)
    z = 1.0E-15;
  lz = log(z);
  diagptable = diagptable_start = (double *)malloc(sizeof(double) * 4 * 19);
  for (i = 0; i < 4; i++) {
    ki = gammaRates[i];
    for (j = 0; j < 19; j++)
      *diagptable++ = exp(EIGN[j] * ki * lz);
  }
  for (i = lower; i < upper; i++) {
    left = &(tipVector[20 * tipX1[i]]);
    diagptable = diagptable_start;
    for (j = 0; j < 4; j++) {
      right = &(x2[80 * i + 20 * j]);
      term[j] = 0.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++;
      term[j] =
          log(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);
  return;
}


x86 assembly (clang, -O0):
<categorizeGTRGAMMAPROT>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
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)
movl   $0x0,-0x84(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xe70(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    11a8 <categorizeGTRGAMMAPROT+0x68>
movsd  0xe5d(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x40(%rbp)
mov    $0x260,%edi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x7c(%rbp)
cmpl   $0x4,-0x7c(%rbp)
jge    1259 <categorizeGTRGAMMAPROT+0x119>
mov    -0x28(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x80(%rbp)
cmpl   $0x13,-0x80(%rbp)
jge    1246 <categorizeGTRGAMMAPROT+0x106>
mov    -0x30(%rbp),%rax
movslq -0x80(%rbp),%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    11f9 <categorizeGTRGAMMAPROT+0xb9>
jmp    124b <categorizeGTRGAMMAPROT+0x10b>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    11d6 <categorizeGTRGAMMAPROT+0x96>
mov    0x20(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1a56 <categorizeGTRGAMMAPROT+0x916>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
imul   $0x14,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x80(%rbp)
cmpl   $0x4,-0x80(%rbp)
jge    18f7 <categorizeGTRGAMMAPROT+0x7b7>
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)
movslq -0x80(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x761(%rip),%xmm0
call   1060 <log@plt>
movsd  -0xb8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x80(%rbp),%rax
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    12a4 <categorizeGTRGAMMAPROT+0x164>
movsd  -0x60(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
addsd  -0x48(%rbp),%xmm1
movsd  0x6fd(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x6f4(%rip),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x6da(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x6c3(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x6ac(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x695(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0x676(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    19bf <categorizeGTRGAMMAPROT+0x87f>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x84(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    19e7 <categorizeGTRGAMMAPROT+0x8a7>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x1,-0x84(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a0f <categorizeGTRGAMMAPROT+0x8cf>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x2,-0x84(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a37 <categorizeGTRGAMMAPROT+0x8f7>
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    125f <categorizeGTRGAMMAPROT+0x11f>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<categorizeGTRGAMMAPROT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%r15
mov    %r8,%r14
mov    %rdx,0x48(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdi,0x40(%rsp)
mov    0xc8(%rsp),%r13d
mov    0xc0(%rsp),%r12d
mov    0xb8(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0xb0(%rsp),%rax
mov    %rax,0x30(%rsp)
movsd  0xe6b(%rip),%xmm0
maxsd  (%rcx),%xmm0
call   1060 <log@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x260,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14),%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  (%r15),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,(%rbx,%rbp,8)
movsd  0x8(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x8(%rbx,%rbp,8)
movsd  0x10(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x10(%rbx,%rbp,8)
movsd  0x18(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x18(%rbx,%rbp,8)
movsd  0x20(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x20(%rbx,%rbp,8)
movsd  0x28(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x28(%rbx,%rbp,8)
movsd  0x30(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x30(%rbx,%rbp,8)
movsd  0x38(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x38(%rbx,%rbp,8)
movsd  0x40(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x40(%rbx,%rbp,8)
movsd  0x48(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x48(%rbx,%rbp,8)
movsd  0x50(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x50(%rbx,%rbp,8)
movsd  0x58(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x58(%rbx,%rbp,8)
movsd  0x60(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x60(%rbx,%rbp,8)
movsd  0x68(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x68(%rbx,%rbp,8)
movsd  0x70(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x70(%rbx,%rbp,8)
movsd  0x78(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x78(%rbx,%rbp,8)
movsd  0x80(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x80(%rbx,%rbp,8)
movsd  0x88(%r15),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x88(%rbx,%rbp,8)
movsd  0x10(%rsp),%xmm0
mulsd  0x90(%r15),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x90(%rbx,%rbp,8)
add    $0x8,%r14
add    $0x13,%rbp
cmp    $0x4c,%rbp
jne    11c0 <categorizeGTRGAMMAPROT+0x80>
cmp    %r13d,%r12d
jge    178b <categorizeGTRGAMMAPROT+0x64b>
movslq %r12d,%rax
movslq %r13d,%rcx
mov    %rcx,0x20(%rsp)
mov    %rax,%rcx
lea    (%rax,%rax,4),%rax
shl    $0x7,%rax
mov    0x18(%rsp),%rdx
lea    (%rax,%rdx,1),%r12
add    $0x98,%r12
xorpd  %xmm4,%xmm4
xor    %edx,%edx
mov    %rbx,0x28(%rsp)
mov    0x48(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,0x10(%rsp)
mov    0x40(%rsp),%rax
movsbq (%rax,%rcx,1),%rax
lea    (%rax,%rax,4),%rbp
shl    $0x5,%rbp
add    0x30(%rsp),%rbp
mov    %r12,0x8(%rsp)
xor    %r15d,%r15d
mov    %rbx,%r13
mov    %rcx,%rbx
nopl   0x0(%rax)
movsd  0x0(%rbp),%xmm0
movsd  0x8(%rbp),%xmm1
mulsd  -0x98(%r12),%xmm0
ff ff ff
mulsd  -0x90(%r12),%xmm1
ff ff ff
addsd  %xmm4,%xmm0
mulsd  0x0(%r13),%xmm1
movsd  0x10(%rbp),%xmm2
mulsd  -0x88(%r12),%xmm2
ff ff ff
mulsd  0x8(%r13),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%rbp),%xmm0
mulsd  -0x80(%r12),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x10(%r13),%xmm0
movsd  0x20(%rbp),%xmm1
mulsd  -0x78(%r12),%xmm1
mulsd  0x18(%r13),%xmm1
addsd  %xmm2,%xmm0
movsd  0x28(%rbp),%xmm2
mulsd  -0x70(%r12),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x20(%r13),%xmm2
movsd  0x30(%rbp),%xmm0
mulsd  -0x68(%r12),%xmm0
mulsd  0x28(%r13),%xmm0
addsd  %xmm1,%xmm2
movsd  0x38(%rbp),%xmm1
mulsd  -0x60(%r12),%xmm1
addsd  %xmm2,%xmm0
mulsd  0x30(%r13),%xmm1
movsd  0x40(%rbp),%xmm2
mulsd  -0x58(%r12),%xmm2
mulsd  0x38(%r13),%xmm2
addsd  %xmm0,%xmm1
movsd  0x48(%rbp),%xmm0
mulsd  -0x50(%r12),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x40(%r13),%xmm0
movsd  0x50(%rbp),%xmm1
mulsd  -0x48(%r12),%xmm1
mulsd  0x48(%r13),%xmm1
addsd  %xmm2,%xmm0
movsd  0x58(%rbp),%xmm2
mulsd  -0x40(%r12),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x50(%r13),%xmm2
movsd  0x60(%rbp),%xmm0
mulsd  -0x38(%r12),%xmm0
mulsd  0x58(%r13),%xmm0
addsd  %xmm1,%xmm2
movsd  0x68(%rbp),%xmm1
mulsd  -0x30(%r12),%xmm1
addsd  %xmm2,%xmm0
mulsd  0x60(%r13),%xmm1
movsd  0x70(%rbp),%xmm2
mulsd  -0x28(%r12),%xmm2
mulsd  0x68(%r13),%xmm2
addsd  %xmm0,%xmm1
movsd  0x78(%rbp),%xmm0
mulsd  -0x20(%r12),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x70(%r13),%xmm0
movsd  0x80(%rbp),%xmm1
mulsd  -0x18(%r12),%xmm1
mulsd  0x78(%r13),%xmm1
addsd  %xmm2,%xmm0
movsd  0x88(%rbp),%xmm2
mulsd  -0x10(%r12),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x80(%r13),%xmm2
movsd  0x90(%rbp),%xmm3
mulsd  -0x8(%r12),%xmm3
mulsd  0x88(%r13),%xmm3
addsd  %xmm1,%xmm2
movsd  0x98(%rbp),%xmm0
mulsd  (%r12),%xmm0
addsd  %xmm2,%xmm3
mulsd  0x90(%r13),%xmm0
addsd  %xmm3,%xmm0
call   1060 <log@plt>
movsd  0x99c(%rip),%xmm2
xorpd  %xmm4,%xmm4
xorps  %xmm1,%xmm1
cvtsi2sdl (%r14,%rbx,4),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp,%r15,8)
add    $0x1,%r15
add    $0xa0,%r12
add    $0x98,%r13
cmp    $0x4,%r15
jne    1490 <categorizeGTRGAMMAPROT+0x350>
movapd 0x50(%rsp),%xmm1
movapd 0x60(%rsp),%xmm0
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
addsd  %xmm2,%xmm3
mulsd  0x93c(%rip),%xmm3
movsd  0x93c(%rip),%xmm2
divsd  %xmm3,%xmm2
movapd 0x948(%rip),%xmm5
mulpd  %xmm5,%xmm1
unpcklpd %xmm2,%xmm2
mulpd  %xmm2,%xmm1
movsd  0x924(%rip),%xmm6
ucomisd %xmm1,%xmm6
movapd %xmm1,0x50(%rsp)
mov    $0x0,%eax
mov    0x10(%rsp),%edx
cmova  %eax,%edx
movapd %xmm1,%xmm3
minsd  %xmm6,%xmm3
unpckhpd %xmm1,%xmm1
ucomisd %xmm1,%xmm3
mulpd  %xmm5,%xmm0
mov    $0x1,%eax
cmova  %eax,%edx
mulpd  %xmm2,%xmm0
minsd  %xmm3,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,0x60(%rsp)
mov    $0x2,%eax
cmova  %eax,%edx
movapd %xmm0,%xmm2
minsd  %xmm1,%xmm2
unpckhpd %xmm0,%xmm0
ucomisd %xmm0,%xmm2
mov    $0x3,%eax
cmova  %eax,%edx
mov    0x38(%rsp),%rax
mov    %edx,(%rax,%rbx,4)
add    $0x1,%rbx
mov    0x8(%rsp),%r12
add    $0x280,%r12
mov    %rbx,%rcx
cmp    0x20(%rsp),%rbx
mov    0x28(%rsp),%rbx
jne    1460 <categorizeGTRGAMMAPROT+0x320>
mov    %rbx,%rdi
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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