void categorizeGTRGAMMAMULT(char *tipX1, double *x2_start, int *ex2, double *pz,
                            double *gammaRates, double *EIGN, double *tipVector,
                            int *rateCategory, int lower, int upper,
                            int *modelptr, int NumberOfModels,
                            int multiBranch) {
  double z, lz = 0.0, term[4], ki;
  int i, index = 0;
  double *diagptable, *diagptable_start, allSum, min;
  double *x1, *x2;
  int model;
  if (!multiBranch) {
    z = pz[0];
    if (z < 1.0E-15)
      z = 1.0E-15;
    lz = log(z);
  }
  diagptable = diagptable_start =
      (double *)malloc(sizeof(double) * 12 * NumberOfModels);
  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[12 * model];
    for (i = 0; i < 4; i++) {
      ki = gammaRates[model * 4 + i];
      *diagptable++ = exp(EIGN[model * 3] * ki * lz);
      *diagptable++ = exp(EIGN[model * 3 + 1] * ki * lz);
      *diagptable++ = exp(EIGN[model * 3 + 2] * ki * lz);
    }
  }
  for (i = lower; i < upper; i++) {
    model = modelptr[i];
    x1 = &(tipVector[64 * model + 4 * tipX1[i]]);
    x2 = &x2_start[16 * i];
    diagptable = &diagptable_start[12 * model];
    term[0] = x1[0] * x2[0];
    term[0] += x1[1] * x2[1] * *diagptable++;
    term[0] += x1[2] * x2[2] * *diagptable++;
    term[0] += x1[3] * x2[3] * *diagptable++;
    term[0] =
        log(term[0]) +
        ex2[i] *
            log((
                1.0 /
                115792089237316195423570985008687907853269984665640564039457584007913129639936.0));
    term[1] = x1[0] * x2[4];
    term[1] += x1[1] * x2[5] * *diagptable++;
    term[1] += x1[2] * x2[6] * *diagptable++;
    term[1] += x1[3] * x2[7] * *diagptable++;
    term[1] =
        log(term[1]) +
        ex2[i] *
            log((
                1.0 /
                115792089237316195423570985008687907853269984665640564039457584007913129639936.0));
    term[2] = x1[0] * x2[8];
    term[2] += x1[1] * x2[9] * *diagptable++;
    term[2] += x1[2] * x2[10] * *diagptable++;
    term[2] += x1[3] * x2[11] * *diagptable++;
    term[2] =
        log(term[2]) +
        ex2[i] *
            log((
                1.0 /
                115792089237316195423570985008687907853269984665640564039457584007913129639936.0));
    term[3] = x1[0] * x2[12];
    term[3] += x1[1] * x2[13] * *diagptable++;
    term[3] += x1[2] * x2[14] * *diagptable++;
    term[3] += x1[3] * x2[15] * *diagptable++;
    term[3] =
        log(term[3]) +
        (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] = model * 4 + index;
  }
  free(diagptable_start);
  return;
}


x86 assembly (clang, -O0):
<categorizeGTRGAMMAMULT>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x40(%rbp),%eax
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,-0x70(%rbp)
cmpl   $0x0,0x40(%rbp)
jne    11d0 <categorizeGTRGAMMAMULT+0x90>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xe57(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    11c1 <categorizeGTRGAMMAMULT+0x81>
movsd  0xe44(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x40(%rbp)
movslq 0x38(%rbp),%rax
imul   $0x60,%rax,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    %rax,-0x78(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    135f <categorizeGTRGAMMAMULT+0x21f>
cmpl   $0x0,0x40(%rbp)
je     124c <categorizeGTRGAMMAMULT+0x10c>
mov    -0x20(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xddb(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    123d <categorizeGTRGAMMAMULT+0xfd>
movsd  0xdc8(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x80(%rbp),%rax
imul   $0xc,-0xa4(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x6c(%rbp)
cmpl   $0x4,-0x6c(%rbp)
jge    1346 <categorizeGTRGAMMAMULT+0x206>
mov    -0x28(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x2,%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
imul   $0x3,-0xa4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
imul   $0x3,-0xa4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
imul   $0x3,-0xa4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1050 <exp@plt>
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  %xmm0,(%rax)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    126c <categorizeGTRGAMMAMULT+0x12c>
jmp    134b <categorizeGTRGAMMAMULT+0x20b>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    11ef <categorizeGTRGAMMAMULT+0xaf>
mov    0x20(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1a09 <categorizeGTRGAMMAMULT+0x8c9>
mov    0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa4(%rbp)
mov    0x10(%rbp),%rax
mov    -0xa4(%rbp),%ecx
shl    $0x6,%ecx
mov    -0x8(%rbp),%rdx
movslq -0x6c(%rbp),%rsi
movsbl (%rdx,%rsi,1),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x4,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x80(%rbp),%rax
imul   $0xc,-0xa4(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0xb3a(%rip),%xmm0
call   1060 <log@plt>
movsd  -0xe8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x38(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0xa13(%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
movsd  %xmm0,-0x58(%rbp)
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x40(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x50(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x58(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x8ec(%rip),%xmm0
call   1060 <log@plt>
movsd  -0xc8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x60(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x68(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x70(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x98(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0xa0(%rbp),%rax
mulsd  0x78(%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x7c5(%rip),%xmm0
call   1060 <log@plt>
movsd  -0xb8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x60(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
addsd  -0x48(%rbp),%xmm1
movsd  0x774(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x768(%rip),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x748(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  0x72e(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  0x714(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  0x6fa(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  0x6d8(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x60(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1963 <categorizeGTRGAMMAMULT+0x823>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    198e <categorizeGTRGAMMAMULT+0x84e>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x1,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    19b9 <categorizeGTRGAMMAMULT+0x879>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x2,-0x70(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    19e4 <categorizeGTRGAMMAMULT+0x8a4>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x3,-0x70(%rbp)
mov    -0xa4(%rbp),%edx
shl    $0x2,%edx
add    -0x70(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1365 <categorizeGTRGAMMAMULT+0x225>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<categorizeGTRGAMMAMULT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,%r13
mov    %r8,0x40(%rsp)
mov    %rcx,0x58(%rsp)
mov    %rdx,0x28(%rsp)
mov    %rsi,0x80(%rsp)
mov    %rdi,0x68(%rsp)
mov    0x100(%rsp),%ecx
mov    0xf8(%rsp),%ebx
mov    0xf0(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0xe8(%rsp),%eax
mov    %eax,0x3c(%rsp)
mov    0xe0(%rsp),%eax
mov    %rax,0x78(%rsp)
mov    0xd8(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0xd0(%rsp),%rax
mov    %rax,0x70(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
mov    %ecx,0x30(%rsp)
test   %ecx,%ecx
jne    11eb <categorizeGTRGAMMAMULT+0xab>
movsd  0xe28(%rip),%xmm0
mov    0x58(%rsp),%rax
maxsd  (%rax),%xmm0
call   1060 <log@plt>
movsd  %xmm0,(%rsp)
movslq %ebx,%rbp
mov    %rbp,%rax
shl    $0x5,%rax
lea    (%rax,%rax,2),%rdi
call   1040 <malloc@plt>
test   %ebp,%ebp
jle    1413 <categorizeGTRGAMMAMULT+0x2d3>
mov    %ebx,%ecx
mov    %rcx,0x90(%rsp)
xor    %ebp,%ebp
mov    0x40(%rsp),%r15
jmp    13e4 <categorizeGTRGAMMAMULT+0x2a4>
nopl   0x0(%rax)
lea    0x0(,%rbp,4),%ecx
lea    (%rcx,%rcx,2),%r12d
mov    %rbp,0x20(%rsp)
mov    0x20(%rsp),%rax
lea    (%rax,%rax,2),%r14d
movsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rsp)
mov    %rcx,%rbp
movsd  0x0(%r13,%r14,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,(%rbx,%r12,8)
movsd  0x8(%r13,%r14,8),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x8(%rbx,%r12,8)
movsd  0x10(%rsp),%xmm0
mulsd  0x10(%r13,%r14,8),%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x10(%rbx,%r12,8)
movsd  0x8(%r15,%rbp,8),%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x0(%r13,%r14,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x18(%rbx,%r12,8)
movsd  0x8(%r13,%r14,8),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x20(%rbx,%r12,8)
movsd  0x10(%rsp),%xmm0
mulsd  0x10(%r13,%r14,8),%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x28(%rbx,%r12,8)
movsd  0x10(%r15,%rbp,8),%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x0(%r13,%r14,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x30(%rbx,%r12,8)
movsd  0x8(%r13,%r14,8),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x38(%rbx,%r12,8)
movsd  0x10(%rsp),%xmm0
mulsd  0x10(%r13,%r14,8),%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x40(%rbx,%r12,8)
movsd  0x18(%r15,%rbp,8),%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x0(%r13,%r14,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x48(%rbx,%r12,8)
movsd  0x8(%r13,%r14,8),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x50(%rbx,%r12,8)
movsd  0x10(%rsp),%xmm0
mulsd  0x10(%r13,%r14,8),%xmm0
mov    0x20(%rsp),%rbp
mulsd  (%rsp),%xmm0
call   1050 <exp@plt>
mov    %rbx,%rax
movsd  %xmm0,0x58(%rbx,%r12,8)
add    $0x1,%rbp
cmp    0x90(%rsp),%rbp
je     1413 <categorizeGTRGAMMAMULT+0x2d3>
mov    %rax,%rbx
cmpl   $0x0,0x30(%rsp)
je     1220 <categorizeGTRGAMMAMULT+0xe0>
movsd  0xc06(%rip),%xmm0
mov    0x58(%rsp),%rax
maxsd  (%rax,%rbp,8),%xmm0
call   1060 <log@plt>
movsd  %xmm0,(%rsp)
jmp    1220 <categorizeGTRGAMMAMULT+0xe0>
mov    0x78(%rsp),%r12
mov    0x3c(%rsp),%ebx
cmp    %ebx,%r12d
mov    0x80(%rsp),%r15
mov    0x68(%rsp),%r9
mov    0x60(%rsp),%r8
mov    0x70(%rsp),%r14
mov    %rax,%rdi
jge    179a <categorizeGTRGAMMAMULT+0x65a>
movslq %r12d,%rax
movslq %ebx,%rbx
mov    %rbx,0x30(%rsp)
shl    $0x4,%r12d
xor    %r13d,%r13d
mov    %rdi,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
mov    %rax,(%rsp)
movslq (%r8,%rax,4),%rsi
mov    %rsi,0x20(%rsp)
mov    %rsi,%rax
shl    $0x6,%rax
mov    (%rsp),%rcx
movsbq (%r9,%rcx,1),%rcx
lea    (%rax,%rcx,4),%rbx
movslq %r12d,%r12
lea    (%rsi,%rsi,2),%rbp
movsd  (%r14,%rbx,8),%xmm0
movsd  0x8(%r14,%rbx,8),%xmm1
mulsd  (%r15,%r12,8),%xmm0
mulsd  0x8(%r15,%r12,8),%xmm1
shl    $0x5,%rbp
mulsd  (%rdi,%rbp,1),%xmm1
movsd  0x10(%r14,%rbx,8),%xmm2
mulsd  0x10(%r15,%r12,8),%xmm2
mulsd  0x8(%rdi,%rbp,1),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%r14,%rbx,8),%xmm0
mulsd  0x18(%r15,%r12,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x10(%rdi,%rbp,1),%xmm0
addsd  %xmm2,%xmm0
call   1060 <log@plt>
movapd %xmm0,0x10(%rsp)
movsd  (%r14,%rbx,8),%xmm0
movsd  0x8(%r14,%rbx,8),%xmm1
mulsd  0x20(%r15,%r12,8),%xmm0
mulsd  0x28(%r15,%r12,8),%xmm1
mov    0x8(%rsp),%rax
mulsd  0x18(%rax,%rbp,1),%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14,%rbx,8),%xmm2
mulsd  0x30(%r15,%r12,8),%xmm2
mov    0x8(%rsp),%rax
mulsd  0x20(%rax,%rbp,1),%xmm2
addsd  %xmm1,%xmm2
movsd  0x18(%r14,%rbx,8),%xmm0
mulsd  0x38(%r15,%r12,8),%xmm0
mov    0x8(%rsp),%rax
mulsd  0x28(%rax,%rbp,1),%xmm0
addsd  %xmm2,%xmm0
mov    0x28(%rsp),%rax
mov    (%rsp),%rcx
movss  (%rax,%rcx,4),%xmm1
movaps %xmm1,0x40(%rsp)
call   1060 <log@plt>
mov    0x28(%rsp),%rax
mov    (%rsp),%rcx
movss  (%rax,%rcx,4),%xmm1
movaps 0x40(%rsp),%xmm2
unpcklps %xmm1,%xmm2
cvtdq2pd %xmm2,%xmm2
movapd 0x10(%rsp),%xmm3
unpcklpd %xmm0,%xmm3
mulpd  0xa9e(%rip),%xmm2
movsd  (%r14,%rbx,8),%xmm0
movsd  0x8(%r14,%rbx,8),%xmm1
mulsd  0x40(%r15,%r12,8),%xmm0
mulsd  0x48(%r15,%r12,8),%xmm1
addpd  %xmm3,%xmm2
movapd %xmm2,0x10(%rsp)
mov    0x8(%rsp),%rax
mulsd  0x30(%rax,%rbp,1),%xmm1
movsd  0x10(%r14,%rbx,8),%xmm2
mulsd  0x50(%r15,%r12,8),%xmm2
mov    0x8(%rsp),%rax
mulsd  0x38(%rax,%rbp,1),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%r14,%rbx,8),%xmm0
mulsd  0x58(%r15,%r12,8),%xmm0
addsd  %xmm1,%xmm2
mov    0x8(%rsp),%rax
mulsd  0x40(%rax,%rbp,1),%xmm0
addsd  %xmm2,%xmm0
call   1060 <log@plt>
mov    0x28(%rsp),%rax
mov    (%rsp),%rcx
xorps  %xmm3,%xmm3
cvtsi2sdl (%rax,%rcx,4),%xmm3
movsd  0x9ea(%rip),%xmm1
mulsd  %xmm1,%xmm3
movsd  (%r14,%rbx,8),%xmm1
movsd  0x8(%r14,%rbx,8),%xmm2
mulsd  0x60(%r15,%r12,8),%xmm1
mulsd  0x68(%r15,%r12,8),%xmm2
addsd  %xmm0,%xmm3
movsd  %xmm3,0x40(%rsp)
mov    0x8(%rsp),%rax
mulsd  0x48(%rax,%rbp,1),%xmm2
movsd  0x10(%r14,%rbx,8),%xmm3
mulsd  0x70(%r15,%r12,8),%xmm3
mov    0x8(%rsp),%rax
mulsd  0x50(%rax,%rbp,1),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r14,%rbx,8),%xmm0
mulsd  0x78(%r15,%r12,8),%xmm0
addsd  %xmm2,%xmm3
mov    0x8(%rsp),%rax
mulsd  0x58(%rax,%rbp,1),%xmm0
addsd  %xmm3,%xmm0
call   1060 <log@plt>
mov    0x88(%rsp),%rbp
mov    0x8(%rsp),%rdi
mov    0x60(%rsp),%r8
mov    0x68(%rsp),%r9
mov    0x28(%rsp),%rcx
mov    (%rsp),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl (%rcx,%rax,4),%xmm1
mulsd  0x943(%rip),%xmm1
addsd  %xmm0,%xmm1
movapd 0x10(%rsp),%xmm5
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
movapd %xmm5,%xmm2
addsd  %xmm0,%xmm2
movsd  0x40(%rsp),%xmm6
addsd  %xmm6,%xmm2
addsd  %xmm1,%xmm2
movsd  0x91b(%rip),%xmm4
mulsd  %xmm4,%xmm2
movsd  0x917(%rip),%xmm3
divsd  %xmm2,%xmm3
mulsd  %xmm4,%xmm5
mulsd  %xmm3,%xmm5
movsd  0x90b(%rip),%xmm2
ucomisd %xmm5,%xmm2
mulsd  %xmm4,%xmm0
mov    $0x0,%eax
cmova  %eax,%r13d
mulsd  %xmm3,%xmm0
minsd  %xmm2,%xmm5
ucomisd %xmm0,%xmm5
movapd %xmm6,%xmm2
mulsd  %xmm4,%xmm2
mov    $0x1,%eax
cmova  %eax,%r13d
mulsd  %xmm3,%xmm2
minsd  %xmm5,%xmm0
ucomisd %xmm2,%xmm0
mulsd  %xmm4,%xmm1
mov    $0x2,%eax
cmova  %eax,%r13d
mulsd  %xmm3,%xmm1
minsd  %xmm0,%xmm2
ucomisd %xmm1,%xmm2
mov    $0x3,%eax
cmova  %eax,%r13d
mov    0x20(%rsp),%rax
lea    0x0(%r13,%rax,4),%eax
mov    (%rsp),%rbx
mov    %eax,0x0(%rbp,%rbx,4)
mov    (%rsp),%rax
add    $0x1,%rax
add    $0x10,%r12d
cmp    %rax,0x30(%rsp)
jne    1460 <categorizeGTRGAMMAMULT+0x320>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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