#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ exp(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
void coreGTRGAMMAPROTMULT(double *gammaRates, double *EIGN, double *sumtable,
                          int lower, int upper, int *wrptr, double *ext_dlnLdlz,
                          double *ext_d2lnLdlz2, double lz, int numberOfModels,
                          int *modelptr) {
  double *sum, *diagptable, *diagptable_start;
  int i, l;
  double dlnLdlz = 0;
  double d2lnLdlz2 = 0;
  double ki, kisqr;
  double tmp;
  double inv_Li, dlnLidlz, d2lnLidlz2;
  int model;
  diagptable = diagptable_start =
      (double *)malloc(sizeof(double) * 228 * numberOfModels);
  for (model = 0; model < numberOfModels; model++) {
    diagptable = &diagptable_start[model * 228];
    for (i = 0; i < 4; i++) {
      ki = gammaRates[model * 4 + i];
      kisqr = ki * ki;
      for (l = 0; l < 19; l++) {
        *diagptable++ = exp(EIGN[model * 19 + l] * ki * lz);
        *diagptable++ = EIGN[model * 19 + l] * ki;
        *diagptable++ = EIGN[model * 19 + l] * EIGN[model * 19 + l] * kisqr;
      }
    }
  }
  for (i = lower; i < upper; i++) {
    diagptable = &diagptable_start[228 * modelptr[i]];
    sum = &sumtable[i * 80];
    inv_Li = 0.0;
    dlnLidlz = 0.0;
    d2lnLidlz2 = 0.0;
    inv_Li += *sum++;
    for (l = 1; l < 20; l++) {
      inv_Li += (tmp = *diagptable++ * *sum++);
      dlnLidlz += tmp * *diagptable++;
      d2lnLidlz2 += tmp * *diagptable++;
    }
    inv_Li += *sum++;
    for (l = 1; l < 20; l++) {
      inv_Li += (tmp = *diagptable++ * *sum++);
      dlnLidlz += tmp * *diagptable++;
      d2lnLidlz2 += tmp * *diagptable++;
    }
    inv_Li += *sum++;
    for (l = 1; l < 20; l++) {
      inv_Li += (tmp = *diagptable++ * *sum++);
      dlnLidlz += tmp * *diagptable++;
      d2lnLidlz2 += tmp * *diagptable++;
    }
    inv_Li += *sum++;
    for (l = 1; l < 20; l++) {
      inv_Li += (tmp = *diagptable++ * *sum++);
      dlnLidlz += tmp * *diagptable++;
      d2lnLidlz2 += tmp * *diagptable++;
    }
    inv_Li = 1.0 / inv_Li;
    dlnLidlz *= inv_Li;
    d2lnLidlz2 *= inv_Li;
    dlnLdlz += wrptr[i] * dlnLidlz;
    d2lnLdlz2 += wrptr[i] * (d2lnLidlz2 - dlnLidlz * dlnLidlz);
  }
  *ext_dlnLdlz = dlnLdlz;
  *ext_d2lnLdlz2 = d2lnLdlz2;
  free(diagptable_start);
}


x86 assembly (clang, -O0):
<coreGTRGAMMAPROTMULT>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x28(%rbp),%rax
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    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movslq 0x20(%rbp),%rax
imul   $0x720,%rax,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    12fb <coreGTRGAMMAPROTMULT+0x1cb>
mov    -0x48(%rbp),%rax
imul   $0xe4,-0x94(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
cmpl   $0x4,-0x4c(%rbp)
jge    12e2 <coreGTRGAMMAPROTMULT+0x1b2>
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x2,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x50(%rbp)
cmpl   $0x13,-0x50(%rbp)
jge    12cf <coreGTRGAMMAPROTMULT+0x19f>
mov    -0x10(%rbp),%rax
imul   $0x13,-0x94(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
call   1050 <exp@plt>
cvtsi2sd %eax,%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
imul   $0x13,-0x94(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
imul   $0x13,-0x94(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
imul   $0x13,-0x94(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  %xmm0,(%rax)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1209 <coreGTRGAMMAPROTMULT+0xd9>
jmp    12d4 <coreGTRGAMMAPROTMULT+0x1a4>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11cc <coreGTRGAMMAPROTMULT+0x9c>
jmp    12e7 <coreGTRGAMMAPROTMULT+0x1b7>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    119a <coreGTRGAMMAPROTMULT+0x6a>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    176d <coreGTRGAMMAPROTMULT+0x63d>
mov    -0x48(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
imul   $0xe4,(%rcx,%rdx,4),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
imul   $0x50,-0x4c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x50(%rbp)
cmpl   $0x14,-0x50(%rbp)
jge    1433 <coreGTRGAMMAPROTMULT+0x303>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1386 <coreGTRGAMMAPROTMULT+0x256>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x50(%rbp)
cmpl   $0x14,-0x50(%rbp)
jge    1504 <coreGTRGAMMAPROTMULT+0x3d4>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1457 <coreGTRGAMMAPROTMULT+0x327>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x50(%rbp)
cmpl   $0x14,-0x50(%rbp)
jge    15d5 <coreGTRGAMMAPROTMULT+0x4a5>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1528 <coreGTRGAMMAPROTMULT+0x3f8>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
movsd  (%rax),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x50(%rbp)
cmpl   $0x14,-0x50(%rbp)
jge    16a6 <coreGTRGAMMAPROTMULT+0x576>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x40(%rbp)
movsd  (%rax),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    15f9 <coreGTRGAMMAPROTMULT+0x4c9>
movsd  0x952(%rip),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm3
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1301 <coreGTRGAMMAPROTMULT+0x1d1>
movsd  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<coreGTRGAMMAPROTMULT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movsd  %xmm0,0x10(%rsp)
mov    %r9,0x38(%rsp)
mov    %r8d,0x24(%rsp)
mov    %ecx,0x20(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rsi,%rbp
mov    %rdi,%r14
mov    0xa8(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    0xa0(%rsp),%ebx
mov    0x98(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x90(%rsp),%rax
mov    %rax,0x40(%rsp)
imul   $0x720,%ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0x18(%rsp)
test   %ebx,%ebx
jle    13f1 <coreGTRGAMMAPROTMULT+0x2c1>
mov    %ebx,%eax
mov    %rax,0x50(%rsp)
xor    %r13d,%r13d
nopl   (%rax)
imul   $0xe4,%r13d,%eax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%r15
lea    0x0(,%r13,4),%r12
mov    %r13,%rax
shl    $0x5,%rax
mov    %r14,%rbx
movsd  (%r14,%rax,1),%xmm0
movsd  %xmm0,(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %r14d,%r14d
movsd  0x10(%rsp),%xmm1
movsd  0x0(%rbp,%r14,8),%xmm0
mulsd  (%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1050 <exp@plt>
movsd  0x10(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r15)
movsd  0x0(%rbp,%r14,8),%xmm0
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x8(%r15)
movsd  0x0(%rbp,%r14,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x10(%r15)
add    $0x18,%r15
add    $0x1,%r14
cmp    $0x13,%r14
jne    11f0 <coreGTRGAMMAPROTMULT+0xc0>
shl    $0x3,%r12
mov    %r12,%rax
or     $0x8,%rax
mov    %rbx,%r14
movsd  (%rbx,%rax,1),%xmm0
movsd  %xmm0,(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  (%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1050 <exp@plt>
movsd  0x10(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r15)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x8(%r15)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x10(%r15)
add    $0x18,%r15
add    $0x1,%rbx
cmp    $0x13,%rbx
jne    1280 <coreGTRGAMMAPROTMULT+0x150>
mov    %r12,%rax
or     $0x10,%rax
movsd  (%r14,%rax,1),%xmm0
movsd  %xmm0,(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  (%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1050 <exp@plt>
movsd  0x10(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r15)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x8(%r15)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x10(%r15)
add    $0x18,%r15
add    $0x1,%rbx
cmp    $0x13,%rbx
jne    1300 <coreGTRGAMMAPROTMULT+0x1d0>
or     $0x18,%r12
movsd  (%r14,%r12,1),%xmm0
movsd  %xmm0,(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  (%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1050 <exp@plt>
movsd  0x10(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r15)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x8(%r15)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x10(%r15)
add    $0x1,%rbx
add    $0x18,%r15
cmp    $0x13,%rbx
jne    1380 <coreGTRGAMMAPROTMULT+0x250>
add    $0x1,%r13
add    $0x98,%rbp
cmp    0x50(%rsp),%r13
jne    11b0 <coreGTRGAMMAPROTMULT+0x80>
xorpd  %xmm3,%xmm3
mov    0x24(%rsp),%ecx
mov    0x20(%rsp),%edx
cmp    %ecx,%edx
jge    1697 <coreGTRGAMMAPROTMULT+0x567>
mov    0x18(%rsp),%rax
lea    0x1c8(%rax),%r8
lea    0x390(%rax),%r9
lea    0x558(%rax),%r10
movslq %edx,%r14
movslq %ecx,%r11
lea    (%r14,%r14,4),%rbp
shl    $0x7,%rbp
mov    0x30(%rsp),%r12
add    %r12,%rbp
xorpd  %xmm4,%xmm4
xorpd  %xmm0,%xmm0
movsd  0xbbb(%rip),%xmm1
mov    0x38(%rsp),%r15
mov    0x28(%rsp),%r13
jmp    14b5 <coreGTRGAMMAPROTMULT+0x385>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm4
divsd  %xmm3,%xmm4
movapd %xmm5,%xmm3
mulsd  %xmm4,%xmm3
unpckhpd %xmm5,%xmm5
mulsd  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cvtsi2sdl (%r15,%r14,4),%xmm4
movapd %xmm3,%xmm6
mulsd  %xmm3,%xmm6
subsd  %xmm6,%xmm5
unpcklpd %xmm4,%xmm4
unpcklpd %xmm5,%xmm3
mulpd  %xmm4,%xmm3
movapd %xmm3,%xmm4
addpd  %xmm2,%xmm4
add    $0x1,%r14
add    $0x280,%rbp
cmp    %r11,%r14
je     1693 <coreGTRGAMMAPROTMULT+0x563>
movapd %xmm4,%xmm2
movslq 0x0(%r13,%r14,4),%rax
imul   $0xe4,%rax,%rbx
mov    0x18(%rsp),%rax
lea    (%rax,%rbx,8),%rcx
lea    (%r14,%r14,4),%rax
shl    $0x7,%rax
movsd  (%r12,%rax,1),%xmm3
addsd  %xmm0,%xmm3
xor    %eax,%eax
xorpd  %xmm5,%xmm5
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx),%xmm4
mulsd  0x8(%rbp,%rax,1),%xmm4
addsd  %xmm4,%xmm3
movupd 0x8(%rcx),%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
cmp    $0x90,%eax
je     1540 <coreGTRGAMMAPROTMULT+0x410>
movsd  0x18(%rcx),%xmm5
mulsd  0x10(%rbp,%rax,1),%xmm5
addsd  %xmm5,%xmm3
movupd 0x20(%rcx),%xmm6
unpcklpd %xmm5,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
add    $0x10,%rax
add    $0x30,%rcx
jmp    14f0 <coreGTRGAMMAPROTMULT+0x3c0>
addsd  0x10(%rbp,%rax,1),%xmm3
lea    (%r8,%rbx,8),%rdx
lea    (%rax,%rbp,1),%rdi
add    $0x18,%rdi
lea    (%r9,%rbx,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm5
mulsd  (%rdi),%xmm5
addsd  %xmm5,%xmm3
movupd 0x8(%rdx,%rsi,8),%xmm6
unpcklpd %xmm5,%xmm5
mulpd  %xmm6,%xmm5
cmp    $0x36,%esi
je     15b0 <coreGTRGAMMAPROTMULT+0x480>
addpd  %xmm4,%xmm5
movsd  0x18(%rdx,%rsi,8),%xmm4
mulsd  0x8(%rdi),%xmm4
addsd  %xmm4,%xmm3
movupd 0x20(%rdx,%rsi,8),%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
add    $0x6,%rsi
add    $0x10,%rdi
jmp    1560 <coreGTRGAMMAPROTMULT+0x430>
nop
addsd  0xb0(%rbp,%rax,1),%xmm3
addpd  %xmm4,%xmm5
lea    (%rax,%rbp,1),%rdx
add    $0xb8,%rdx
lea    (%r10,%rbx,8),%rbx
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%rcx,%rsi,8),%xmm4
mulsd  (%rdx),%xmm4
addsd  %xmm4,%xmm3
movupd 0x8(%rcx,%rsi,8),%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
cmp    $0x36,%esi
je     1620 <coreGTRGAMMAPROTMULT+0x4f0>
movsd  0x18(%rcx,%rsi,8),%xmm5
mulsd  0x8(%rdx),%xmm5
addsd  %xmm5,%xmm3
movupd 0x20(%rcx,%rsi,8),%xmm6
unpcklpd %xmm5,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
add    $0x6,%rsi
add    $0x10,%rdx
jmp    15d0 <coreGTRGAMMAPROTMULT+0x4a0>
nop
addsd  0x150(%rbp,%rax,1),%xmm3
add    %rbp,%rax
add    $0x158,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm5
mulsd  (%rax),%xmm5
addsd  %xmm5,%xmm3
movupd 0x8(%rbx,%rcx,8),%xmm6
unpcklpd %xmm5,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
cmp    $0x36,%ecx
je     1460 <coreGTRGAMMAPROTMULT+0x330>
movsd  0x18(%rbx,%rcx,8),%xmm4
mulsd  0x8(%rax),%xmm4
addsd  %xmm4,%xmm3
movupd 0x20(%rbx,%rcx,8),%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
add    $0x6,%rcx
add    $0x10,%rax
jmp    1640 <coreGTRGAMMAPROTMULT+0x510>
addpd  %xmm2,%xmm3
mov    0x40(%rsp),%rax
movlpd %xmm3,(%rax)
mov    0x48(%rsp),%rax
movhpd %xmm3,(%rax)
mov    0x18(%rsp),%rdi
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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