#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 coreGTRGAMMAPROT(double *gammaRates, double *EIGN, double *sumtable,
                      int lower, int upper, int *wrptr, double *ext_dlnLdlz,
                      double *ext_d2lnLdlz2, double lz) {
  double *sum, *diagptable, *diagptable_start;
  int i, l;
  double dlnLdlz = 0;
  double d2lnLdlz2 = 0;
  double ki, kisqr;
  double tmp;
  double inv_Li, dlnLidlz, d2lnLidlz2;
  diagptable = diagptable_start = (double *)malloc(sizeof(double) * 228);
  for (i = 0; i < 4; i++) {
    ki = gammaRates[i];
    kisqr = ki * ki;
    for (l = 0; l < 19; l++) {
      *diagptable++ = exp(EIGN[l] * ki * lz);
      *diagptable++ = EIGN[l] * ki;
      *diagptable++ = EIGN[l] * EIGN[l] * kisqr;
    }
  }
  for (i = lower; i < upper; i++) {
    diagptable = diagptable_start;
    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):
<coreGTRGAMMAPROT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
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)
mov    $0x720,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
cmpl   $0x4,-0x4c(%rbp)
jge    126f <coreGTRGAMMAPROT+0x13f>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%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    125c <coreGTRGAMMAPROT+0x12c>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%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
movslq -0x50(%rbp),%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
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%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    11ba <coreGTRGAMMAPROT+0x8a>
jmp    1261 <coreGTRGAMMAPROT+0x131>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1188 <coreGTRGAMMAPROT+0x58>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    16c8 <coreGTRGAMMAPROT+0x598>
mov    -0x48(%rbp),%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    138e <coreGTRGAMMAPROT+0x25e>
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    12e1 <coreGTRGAMMAPROT+0x1b1>
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    145f <coreGTRGAMMAPROT+0x32f>
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    13b2 <coreGTRGAMMAPROT+0x282>
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    1530 <coreGTRGAMMAPROT+0x400>
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    1483 <coreGTRGAMMAPROT+0x353>
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    1601 <coreGTRGAMMAPROT+0x4d1>
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    1554 <coreGTRGAMMAPROT+0x424>
movsd  0x9f7(%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    1275 <coreGTRGAMMAPROT+0x145>
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    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<coreGTRGAMMAPROT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
movsd  %xmm0,0x18(%rsp)
mov    %r9,0x28(%rsp)
mov    %r8d,0x24(%rsp)
mov    %ecx,0x20(%rsp)
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbp
mov    0x88(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x80(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    $0x720,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
mov    %rbp,0x30(%rsp)
movsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x8(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %r12d,%r12d
mov    %rax,%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%r12,8),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13)
movsd  (%r14,%r12,8),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%r13)
movsd  (%r14,%r12,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%r13)
add    $0x18,%r13
add    $0x1,%r12
cmp    $0x13,%r12
jne    11b0 <coreGTRGAMMAPROT+0x80>
mov    0x30(%rsp),%r12
movsd  0x8(%r12),%xmm0
movsd  %xmm0,0x8(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13)
movsd  (%r14,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%r13)
movsd  (%r14,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%r13)
add    $0x18,%r13
add    $0x1,%rbp
cmp    $0x13,%rbp
jne    1230 <coreGTRGAMMAPROT+0x100>
movsd  0x10(%r12),%xmm0
movsd  %xmm0,0x8(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13)
movsd  (%r14,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%r13)
movsd  (%r14,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%r13)
add    $0x18,%r13
add    $0x1,%rbp
cmp    $0x13,%rbp
jne    12b0 <coreGTRGAMMAPROT+0x180>
movsd  0x18(%r12),%xmm0
movsd  %xmm0,0x8(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13)
movsd  (%r14,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%r13)
movsd  (%r14,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%r13)
add    $0x1,%rbp
add    $0x18,%r13
cmp    $0x13,%rbp
jne    1330 <coreGTRGAMMAPROT+0x200>
xorpd  %xmm3,%xmm3
mov    0x24(%rsp),%ecx
mov    0x20(%rsp),%eax
cmp    %ecx,%eax
jge    1624 <coreGTRGAMMAPROT+0x4f4>
cltq
movslq %ecx,%r8
lea    (%rax,%rax,4),%rdx
shl    $0x7,%rdx
add    %r15,%rdx
xorpd  %xmm4,%xmm4
xorpd  %xmm0,%xmm0
movsd  0xc42(%rip),%xmm1
mov    0x28(%rsp),%rcx
jmp    1424 <coreGTRGAMMAPROT+0x2f4>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm1,%xmm4
divsd  %xmm3,%xmm4
movapd %xmm5,%xmm3
mulsd  %xmm4,%xmm3
unpckhpd %xmm5,%xmm5
mulsd  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cvtsi2sdl (%rcx,%rax,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,%rax
add    $0x280,%rdx
cmp    %r8,%rax
je     1620 <coreGTRGAMMAPROT+0x4f0>
movapd %xmm4,%xmm2
lea    (%rax,%rax,4),%rsi
shl    $0x7,%rsi
movsd  (%r15,%rsi,1),%xmm3
addsd  %xmm0,%xmm3
xor    %esi,%esi
mov    %rbx,%rdi
xorpd  %xmm5,%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi),%xmm4
mulsd  0x8(%rdx,%rsi,1),%xmm4
addsd  %xmm4,%xmm3
movupd 0x8(%rdi),%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
cmp    $0x90,%esi
je     14b0 <coreGTRGAMMAPROT+0x380>
movsd  0x18(%rdi),%xmm5
mulsd  0x10(%rdx,%rsi,1),%xmm5
addsd  %xmm5,%xmm3
movupd 0x20(%rdi),%xmm6
unpcklpd %xmm5,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
add    $0x10,%rsi
add    $0x30,%rdi
jmp    1450 <coreGTRGAMMAPROT+0x320>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  0x10(%rdx,%rsi,1),%xmm3
lea    (%rdx,%rsi,1),%rdi
add    $0x18,%rdi
xor    %ebp,%ebp
movsd  0x1c8(%rbx,%rbp,8),%xmm5
mulsd  (%rdi),%xmm5
addsd  %xmm5,%xmm3
movupd 0x1d0(%rbx,%rbp,8),%xmm6
unpcklpd %xmm5,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
cmp    $0x36,%ebp
je     1520 <coreGTRGAMMAPROT+0x3f0>
movsd  0x1e0(%rbx,%rbp,8),%xmm4
mulsd  0x8(%rdi),%xmm4
addsd  %xmm4,%xmm3
movupd 0x1e8(%rbx,%rbp,8),%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
add    $0x6,%rbp
add    $0x10,%rdi
jmp    14c0 <coreGTRGAMMAPROT+0x390>
nopl   0x0(%rax)
addsd  0xb0(%rdx,%rsi,1),%xmm3
lea    (%rdx,%rsi,1),%rdi
add    $0xb8,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  0x390(%rbx,%rbp,8),%xmm4
mulsd  (%rdi),%xmm4
addsd  %xmm4,%xmm3
movupd 0x398(%rbx,%rbp,8),%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
cmp    $0x36,%ebp
je     15a0 <coreGTRGAMMAPROT+0x470>
movsd  0x3a8(%rbx,%rbp,8),%xmm5
mulsd  0x8(%rdi),%xmm5
addsd  %xmm5,%xmm3
movupd 0x3b0(%rbx,%rbp,8),%xmm6
unpcklpd %xmm5,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
add    $0x6,%rbp
add    $0x10,%rdi
jmp    1540 <coreGTRGAMMAPROT+0x410>
nopl   0x0(%rax)
addsd  0x150(%rdx,%rsi,1),%xmm3
add    %rdx,%rsi
add    $0x158,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x558(%rbx,%rdi,8),%xmm5
mulsd  (%rsi),%xmm5
addsd  %xmm5,%xmm3
movupd 0x560(%rbx,%rdi,8),%xmm6
unpcklpd %xmm5,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
cmp    $0x36,%edi
je     13d0 <coreGTRGAMMAPROT+0x2a0>
movsd  0x570(%rbx,%rdi,8),%xmm4
mulsd  0x8(%rsi),%xmm4
addsd  %xmm4,%xmm3
movupd 0x578(%rbx,%rdi,8),%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
add    $0x6,%rdi
add    $0x10,%rsi
jmp    15c0 <coreGTRGAMMAPROT+0x490>
addpd  %xmm2,%xmm3
mov    0x38(%rsp),%rax
movlpd %xmm3,(%rax)
mov    0x40(%rsp),%rax
movhpd %xmm3,(%rax)
mov    %rbx,%rdi
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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