#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 */
double FABS(double);
double exp(double);
void coreGammaInvarFlex(double *gammaRates, double *EIGN, double *sumtable,
                        int upper, int *wrptr, volatile double *ext_dlnLdlz,
                        volatile double *ext_d2lnLdlz2, double lz,
                        double *frequencies, double propInvar, int *iptr,
                        const int numStates) {
  double *sum, diagptable[1024], dlnLdlz = 0.0, d2lnLdlz2 = 0.0, ki, kisqr,
                                 freqs[64], scaler = 0.25 * (1.0 - propInvar),
                                 tmp, inv_Li, dlnLidlz, d2lnLidlz2;
  int i, l, j;
  const int gammaStates = 4 * numStates;
  for (i = 0; i < numStates; i++)
    freqs[i] = frequencies[i] * propInvar;
  for (i = 0; i < 4; i++) {
    ki = gammaRates[i];
    kisqr = ki * ki;
    for (l = 1; l < numStates; l++) {
      diagptable[i * gammaStates + l * 4] = exp(EIGN[l - 1] * ki * lz);
      diagptable[i * gammaStates + l * 4 + 1] = EIGN[l - 1] * ki;
      diagptable[i * gammaStates + l * 4 + 2] =
          EIGN[l - 1] * EIGN[l - 1] * kisqr;
    }
  }
  for (i = 0; i < upper; i++) {
    sum = &sumtable[i * gammaStates];
    inv_Li = 0.0;
    dlnLidlz = 0.0;
    d2lnLidlz2 = 0.0;
    for (j = 0; j < 4; j++) {
      inv_Li += sum[j * numStates];
      for (l = 1; l < numStates; l++) {
        inv_Li += (tmp = diagptable[j * gammaStates + l * 4] *
                         sum[j * numStates + l]);
        dlnLidlz += tmp * diagptable[j * gammaStates + l * 4 + 1];
        d2lnLidlz2 += tmp * diagptable[j * gammaStates + l * 4 + 2];
      }
    }
    inv_Li = FABS(inv_Li) * scaler;
    if (iptr[i] < numStates)
      inv_Li += freqs[iptr[i]];
    inv_Li = 1.0 / inv_Li;
    dlnLidlz *= inv_Li;
    d2lnLidlz2 *= inv_Li;
    dlnLidlz *= scaler;
    d2lnLidlz2 *= scaler;
    dlnLdlz += wrptr[i] * dlnLidlz;
    d2lnLdlz2 += wrptr[i] * (d2lnLidlz2 - dlnLidlz * dlnLidlz);
  }
  *ext_dlnLdlz = dlnLdlz;
  *ext_d2lnLdlz2 = d2lnLdlz2;
}


x86 assembly (clang, -O0):
<coreGammaInvarFlex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x22b0,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
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    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2058(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2060(%rbp)
ff
movsd  0xe8f(%rip),%xmm1
subsd  -0x40(%rbp),%xmm1
movsd  0xe7a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x2278(%rbp)
ff
mov    0x28(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x22a8(%rbp)
movl   $0x0,-0x229c(%rbp)
mov    -0x229c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    11f0 <coreGammaInvarFlex+0xd0>
mov    0x18(%rbp),%rax
movslq -0x229c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x40(%rbp),%xmm0
movslq -0x229c(%rbp),%rax
movsd  %xmm0,-0x2270(%rbp,%rax,8)
ff ff
mov    -0x229c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x229c(%rbp)
jmp    11a8 <coreGammaInvarFlex+0x88>
movl   $0x0,-0x229c(%rbp)
cmpl   $0x4,-0x229c(%rbp)
jge    1362 <coreGammaInvarFlex+0x242>
mov    -0x8(%rbp),%rax
movslq -0x229c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2068(%rbp)
ff
movsd  -0x2068(%rbp),%xmm0
ff
mulsd  -0x2068(%rbp),%xmm0
ff
movsd  %xmm0,-0x2070(%rbp)
ff
movl   $0x1,-0x22a0(%rbp)
mov    -0x22a0(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1349 <coreGammaInvarFlex+0x229>
mov    -0x10(%rbp),%rax
mov    -0x22a0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x2068(%rbp),%xmm0
ff
mulsd  -0x38(%rbp),%xmm0
call   1040 <exp@plt>
mov    -0x229c(%rbp),%eax
imul   -0x22a8(%rbp),%eax
mov    -0x22a0(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
cltq
movsd  %xmm0,-0x2050(%rbp,%rax,8)
ff ff
mov    -0x10(%rbp),%rax
mov    -0x22a0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x2068(%rbp),%xmm0
ff
mov    -0x229c(%rbp),%eax
imul   -0x22a8(%rbp),%eax
mov    -0x22a0(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x2050(%rbp,%rax,8)
ff ff
mov    -0x10(%rbp),%rax
mov    -0x22a0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x22a0(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x2070(%rbp),%xmm0
ff
mov    -0x229c(%rbp),%eax
imul   -0x22a8(%rbp),%eax
mov    -0x22a0(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x2,%eax
cltq
movsd  %xmm0,-0x2050(%rbp,%rax,8)
ff ff
mov    -0x22a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x22a0(%rbp)
jmp    1241 <coreGammaInvarFlex+0x121>
jmp    134e <coreGammaInvarFlex+0x22e>
mov    -0x229c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x229c(%rbp)
jmp    11fa <coreGammaInvarFlex+0xda>
movl   $0x0,-0x229c(%rbp)
mov    -0x229c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1698 <coreGammaInvarFlex+0x578>
mov    -0x18(%rbp),%rax
mov    -0x229c(%rbp),%ecx
imul   -0x22a8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2288(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2290(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2298(%rbp)
ff
movl   $0x0,-0x22a4(%rbp)
cmpl   $0x4,-0x22a4(%rbp)
jge    1521 <coreGammaInvarFlex+0x401>
mov    -0x48(%rbp),%rax
mov    -0x22a4(%rbp),%ecx
imul   0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x2288(%rbp),%xmm0
ff
movsd  %xmm0,-0x2288(%rbp)
ff
movl   $0x1,-0x22a0(%rbp)
mov    -0x22a0(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1508 <coreGammaInvarFlex+0x3e8>
mov    -0x22a4(%rbp),%eax
imul   -0x22a8(%rbp),%eax
mov    -0x22a0(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
cltq
movsd  -0x2050(%rbp,%rax,8),%xmm0
ff ff
mov    -0x48(%rbp),%rax
mov    -0x22a4(%rbp),%ecx
imul   0x28(%rbp),%ecx
add    -0x22a0(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2280(%rbp)
ff
addsd  -0x2288(%rbp),%xmm0
ff
movsd  %xmm0,-0x2288(%rbp)
ff
movsd  -0x2280(%rbp),%xmm0
ff
mov    -0x22a4(%rbp),%eax
imul   -0x22a8(%rbp),%eax
mov    -0x22a0(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
movsd  -0x2050(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x2290(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2290(%rbp)
ff
movsd  -0x2280(%rbp),%xmm0
ff
mov    -0x22a4(%rbp),%eax
imul   -0x22a8(%rbp),%eax
mov    -0x22a0(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
add    $0x2,%eax
cltq
movsd  -0x2050(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x2298(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2298(%rbp)
ff
mov    -0x22a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x22a0(%rbp)
jmp    1402 <coreGammaInvarFlex+0x2e2>
jmp    150d <coreGammaInvarFlex+0x3ed>
mov    -0x22a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x22a4(%rbp)
jmp    13c5 <coreGammaInvarFlex+0x2a5>
movsd  -0x2288(%rbp),%xmm0
ff
call   1030 <FABS@plt>
mulsd  -0x2278(%rbp),%xmm0
ff
movsd  %xmm0,-0x2288(%rbp)
ff
mov    0x20(%rbp),%rax
movslq -0x229c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x28(%rbp),%eax
jge    157d <coreGammaInvarFlex+0x45d>
mov    0x20(%rbp),%rax
movslq -0x229c(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsd  -0x2270(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x2288(%rbp),%xmm0
ff
movsd  %xmm0,-0x2288(%rbp)
ff
movsd  0xa83(%rip),%xmm0
divsd  -0x2288(%rbp),%xmm0
ff
movsd  %xmm0,-0x2288(%rbp)
ff
movsd  -0x2288(%rbp),%xmm0
ff
mulsd  -0x2290(%rbp),%xmm0
ff
movsd  %xmm0,-0x2290(%rbp)
ff
movsd  -0x2288(%rbp),%xmm0
ff
mulsd  -0x2298(%rbp),%xmm0
ff
movsd  %xmm0,-0x2298(%rbp)
ff
movsd  -0x2278(%rbp),%xmm0
ff
mulsd  -0x2290(%rbp),%xmm0
ff
movsd  %xmm0,-0x2290(%rbp)
ff
movsd  -0x2278(%rbp),%xmm0
ff
mulsd  -0x2298(%rbp),%xmm0
ff
movsd  %xmm0,-0x2298(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x229c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0x2290(%rbp),%xmm2
ff
movsd  -0x2058(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2058(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x229c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0x2298(%rbp),%xmm1
ff
movsd  -0x2290(%rbp),%xmm2
ff
movsd  -0x2290(%rbp),%xmm3
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x2060(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2060(%rbp)
ff
mov    -0x229c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x229c(%rbp)
jmp    136c <coreGammaInvarFlex+0x24c>
movsd  -0x2058(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x2060(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x22b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<coreGammaInvarFlex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x22d8,%rsp
mov    %r9,%r14
mov    %r8,0xc8(%rsp)
mov    %ecx,%r15d
mov    %rdx,0x98(%rsp)
mov    0x2328(%rsp),%ebp
lea    0x0(,%rbp,4),%r8d
mov    %ebp,%r12d
test   %ebp,%ebp
jle    1178 <coreGammaInvarFlex+0x58>
movapd %xmm0,%xmm4
mov    %rsi,%r13
mov    0x2318(%rsp),%rax
cmp    $0x4,%ebp
jae    118c <coreGammaInvarFlex+0x6c>
xor    %ecx,%ecx
jmp    1250 <coreGammaInvarFlex+0x130>
movslq %r8d,%rax
mov    %rax,0x28(%rsp)
movl   $0x0,(%rsp)
jmp    154d <coreGammaInvarFlex+0x42d>
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rcx),%rdx
mov    %rdx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rdx,%rdx
je     19ca <coreGammaInvarFlex+0x8aa>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd (%rax,%rdx,8),%xmm3
movupd 0x10(%rax,%rdx,8),%xmm2
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
movapd %xmm3,0xd0(%rsp,%rdx,8)
movapd %xmm2,0xe0(%rsp,%rdx,8)
movupd 0x20(%rax,%rdx,8),%xmm3
movupd 0x30(%rax,%rdx,8),%xmm2
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
movapd %xmm3,0xf0(%rsp,%rdx,8)
movapd %xmm2,0x100(%rsp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    11c0 <coreGammaInvarFlex+0xa0>
test   $0x1,%bl
je     123f <coreGammaInvarFlex+0x11f>
movupd (%rax,%rdx,8),%xmm3
movupd 0x10(%rax,%rdx,8),%xmm2
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
movapd %xmm3,0xd0(%rsp,%rdx,8)
movapd %xmm2,0xe0(%rsp,%rdx,8)
cmp    %r12,%rcx
je     126b <coreGammaInvarFlex+0x14b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0xd0(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1250 <coreGammaInvarFlex+0x130>
movslq %r8d,%rax
mov    %rax,0x28(%rsp)
cmp    $0x1,%ebp
jle    152f <coreGammaInvarFlex+0x40f>
movapd %xmm1,0xa0(%rsp)
mov    %r8,0x30(%rsp)
mov    %rdi,0x38(%rsp)
movsd  (%rdi),%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm1,0x10(%rsp)
unpcklpd %xmm0,%xmm1
movapd %xmm1,(%rsp)
lea    -0x4(,%r12,4),%rbx
ff
xor    %ebp,%ebp
movsd  %xmm4,0x40(%rsp)
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,2),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  %xmm4,%xmm0
call   1040 <exp@plt>
movsd  0x40(%rsp),%xmm4
movsd  %xmm0,0x2f0(%rsp,%rbp,8)
movsd  0x0(%r13,%rbp,2),%xmm0
lea    0x5(%rbp),%eax
cltq
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
unpcklpd %xmm1,%xmm0
mulpd  (%rsp),%xmm0
movupd %xmm0,0x2d0(%rsp,%rax,8)
add    $0x4,%rbp
cmp    %rbp,%rbx
jne    12c0 <coreGammaInvarFlex+0x1a0>
mov    0x2328(%rsp),%ebp
cmp    $0x2,%ebp
jl     1538 <coreGammaInvarFlex+0x418>
mov    %r15d,0x60(%rsp)
mov    %r14,0x58(%rsp)
mov    0x38(%rsp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x10(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
lea    -0x8(,%r12,8),%r14
ff
mov    0x28(%rsp),%rax
lea    (%rsp,%rax,8),%r15
add    $0x2f0,%r15
mov    0x30(%rsp),%rax
lea    0x5(%rax),%ebx
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  0x0(%r13,%rbp,1),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  %xmm4,%xmm0
call   1040 <exp@plt>
movsd  0x40(%rsp),%xmm4
movsd  %xmm0,(%r15,%rbp,4)
movsd  0x0(%r13,%rbp,1),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movslq %ebx,%rbx
movsd  %xmm1,0x2d0(%rsp,%rbx,8)
mulsd  %xmm0,%xmm0
mulsd  (%rsp),%xmm0
lea    0x1(%rbx),%eax
cltq
movsd  %xmm0,0x2d0(%rsp,%rax,8)
add    $0x8,%rbp
add    $0x4,%ebx
cmp    %rbp,%r14
jne    1370 <coreGammaInvarFlex+0x250>
mov    0x38(%rsp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rax,1),%rbx
shl    $0x4,%rax
lea    0x2d0(%rsp),%rcx
lea    (%rax,%rcx,1),%r15
add    $0x20,%r15
add    $0x6,%ebx
xor    %ebp,%ebp
nopl   (%rax)
movsd  0x0(%r13,%rbp,1),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  %xmm4,%xmm0
call   1040 <exp@plt>
movsd  0x40(%rsp),%xmm4
movsd  %xmm0,(%r15,%rbp,4)
movsd  0x0(%r13,%rbp,1),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  %xmm0,%xmm1
lea    -0x1(%rbx),%eax
cltq
movsd  %xmm1,0x2d0(%rsp,%rax,8)
mulsd  %xmm0,%xmm0
mulsd  (%rsp),%xmm0
movslq %ebx,%rbx
movsd  %xmm0,0x2d0(%rsp,%rbx,8)
add    $0x8,%rbp
add    $0x4,%ebx
cmp    %rbp,%r14
jne    1410 <coreGammaInvarFlex+0x2f0>
mov    0x38(%rsp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,0x10(%rsp)
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rax,2),%rax
lea    (%rsp,%rax,8),%r15
add    $0x2f0,%r15
lea    0x6(%rax),%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%r13,%rbx,1),%xmm0
mulsd  0x10(%rsp),%xmm0
mulsd  %xmm4,%xmm0
call   1040 <exp@plt>
movsd  0x40(%rsp),%xmm4
movsd  %xmm0,(%r15,%rbx,4)
movsd  0x0(%r13,%rbx,1),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  %xmm0,%xmm1
lea    -0x1(%rbp),%eax
cltq
movsd  %xmm1,0x2d0(%rsp,%rax,8)
mulsd  %xmm0,%xmm0
mulsd  (%rsp),%xmm0
movslq %ebp,%rbp
movsd  %xmm0,0x2d0(%rsp,%rbp,8)
add    $0x8,%rbx
add    $0x4,%ebp
cmp    %rbx,%r14
jne    14b0 <coreGammaInvarFlex+0x390>
mov    $0x1,%al
mov    %eax,(%rsp)
mov    0x58(%rsp),%r14
mov    0x2328(%rsp),%ebp
mov    0x30(%rsp),%r8
mov    0x60(%rsp),%r15d
jmp    1544 <coreGammaInvarFlex+0x424>
movl   $0x0,(%rsp)
jmp    154d <coreGammaInvarFlex+0x42d>
movl   $0x0,(%rsp)
mov    0x30(%rsp),%r8
movapd 0xa0(%rsp),%xmm1
mov    0x2310(%rsp),%rax
test   %r15d,%r15d
jle    19ab <coreGammaInvarFlex+0x88b>
mov    %r14,0x58(%rsp)
movsd  0xa95(%rip),%xmm0
subsd  %xmm1,%xmm0
mulsd  0xa91(%rip),%xmm0
movsd  %xmm0,0x38(%rsp)
movslq %ebp,%r14
mov    %r15d,%eax
mov    %rax,0xa0(%rsp)
lea    (%r14,%r14,1),%rax
mov    %rax,0x88(%rsp)
lea    (%r14,%r14,2),%rsi
mov    0x28(%rsp),%rcx
lea    (%rcx,%rcx,1),%rdi
lea    (%rcx,%rcx,2),%rax
lea    0x0(,%rcx,8),%rdx
mov    %rdx,0x60(%rsp)
lea    -0x1(%r12),%rdx
mov    %rdx,0x68(%rsp)
mov    0x98(%rsp),%r13
lea    0x0(,%r14,8),%r15
add    %r13,%r15
lea    (%rsp,%rcx,8),%rdx
add    $0x2f0,%rdx
mov    %rdx,0xc0(%rsp)
add    $0x5,%r8d
mov    %r8,0x30(%rsp)
mov    %r14,0x90(%rsp)
shl    $0x4,%r14
add    %r13,%r14
shl    $0x4,%rcx
lea    0x2d0(%rsp),%rdx
add    %rdx,%rcx
add    $0x20,%rcx
mov    %rcx,0xb0(%rsp)
add    $0x4,%edi
mov    %rdi,0xb8(%rsp)
mov    %rsi,0x80(%rsp)
lea    0x0(,%rsi,8),%rbx
add    %r13,%rbx
lea    (%rsp,%rax,8),%r9
add    $0x2d0,%r9
mov    %eax,%r10d
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
mov    %r9,0x78(%rsp)
mov    %r10,0x70(%rsp)
jmp    16ed <coreGammaInvarFlex+0x5cd>
nopl   0x0(%rax)
mov    0x78(%rsp),%r9
mov    0x70(%rsp),%r10
movapd 0x40(%rsp),%xmm3
movapd 0x10(%rsp),%xmm4
movsd  0x982(%rip),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm4,%xmm0
mulsd  %xmm1,%xmm0
unpckhpd %xmm4,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm4
mov    0xc8(%rsp),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%rbp,4),%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm4
unpcklpd %xmm1,%xmm1
unpcklpd %xmm0,%xmm4
mulpd  %xmm1,%xmm4
movapd %xmm4,%xmm0
addpd  %xmm3,%xmm0
add    $0x1,%rbp
mov    0x60(%rsp),%rax
add    %rax,%r13
add    %rax,%r15
add    %rax,%r14
add    %rax,%rbx
cmp    0xa0(%rsp),%rbp
je     1998 <coreGammaInvarFlex+0x878>
movapd %xmm0,%xmm4
mov    %rbp,%rcx
imul   0x28(%rsp),%rcx
mov    0x98(%rsp),%rax
lea    (%rax,%rcx,8),%r8
movsd  (%rax,%rcx,8),%xmm0
addsd  0x8fd(%rip),%xmm0
cmpb   $0x0,(%rsp)
movapd %xmm4,0x40(%rsp)
je     1920 <coreGammaInvarFlex+0x800>
xorpd  %xmm3,%xmm3
mov    $0x4,%ecx
mov    0x68(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm1
movsd  0x2d0(%rsp,%rcx,8),%xmm2
mulsd  0x0(%r13,%rcx,2),%xmm2
addsd  %xmm2,%xmm0
lea    0x1(%rcx),%esi
movslq %esi,%rsi
movupd 0x2d0(%rsp,%rsi,8),%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
movapd %xmm2,%xmm3
addpd  %xmm1,%xmm3
add    $0x4,%rcx
add    $0xffffffffffffffff,%rdx
jne    1740 <coreGammaInvarFlex+0x620>
addpd  %xmm1,%xmm2
mov    0x90(%rsp),%rax
addsd  (%r8,%rax,8),%xmm0
cmpb   $0x0,(%rsp)
je     1932 <coreGammaInvarFlex+0x812>
mov    $0x1,%ecx
mov    0x30(%rsp),%rax
mov    %eax,%esi
mov    0xc0(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm3
movsd  (%rdx),%xmm2
mulsd  (%r15,%rcx,8),%xmm2
addsd  %xmm2,%xmm0
movslq %esi,%rsi
lea    0x1(%rsi),%edi
movslq %edi,%rdi
unpcklpd %xmm2,%xmm2
movsd  0x2d0(%rsp,%rsi,8),%xmm1
movhpd 0x2d0(%rsp,%rdi,8),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,%xmm2
addpd  %xmm3,%xmm2
add    $0x1,%rcx
add    $0x20,%rdx
add    $0x4,%esi
cmp    %rcx,%r12
jne    17c0 <coreGammaInvarFlex+0x6a0>
addpd  %xmm3,%xmm1
mov    0x88(%rsp),%rax
addsd  (%r8,%rax,8),%xmm0
cmpb   $0x0,(%rsp)
je     1944 <coreGammaInvarFlex+0x824>
mov    $0x1,%ecx
mov    0xb8(%rsp),%rdx
mov    0xb0(%rsp),%rsi
xchg   %ax,%ax
movsd  (%rsi),%xmm3
mulsd  (%r14,%rcx,8),%xmm3
movapd %xmm1,%xmm2
addsd  %xmm3,%xmm0
lea    0x1(%rdx),%edi
movslq %edi,%rdi
mov    %edx,%eax
or     $0x2,%eax
cltq
unpcklpd %xmm3,%xmm3
movsd  0x2d0(%rsp,%rdi,8),%xmm5
movhpd 0x2d0(%rsp,%rax,8),%xmm5
mulpd  %xmm3,%xmm5
movapd %xmm5,%xmm1
addpd  %xmm2,%xmm1
add    $0x1,%rcx
add    $0x20,%rsi
add    $0x4,%edx
cmp    %rcx,%r12
jne    1840 <coreGammaInvarFlex+0x720>
addpd  %xmm2,%xmm5
mov    0x80(%rsp),%rax
addsd  (%r8,%rax,8),%xmm0
cmpb   $0x0,(%rsp)
je     1990 <coreGammaInvarFlex+0x870>
mov    $0x4,%eax
mov    0x68(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movapd %xmm5,%xmm1
lea    (%r10,%rax,1),%edx
movsd  (%r9,%rax,8),%xmm3
mulsd  (%rbx,%rax,2),%xmm3
addsd  %xmm3,%xmm0
mov    %edx,%esi
or     $0x1,%esi
movslq %esi,%rsi
or     $0x2,%edx
movslq %edx,%rdx
unpcklpd %xmm3,%xmm3
movsd  0x2d0(%rsp,%rsi,8),%xmm2
movhpd 0x2d0(%rsp,%rdx,8),%xmm2
mulpd  %xmm3,%xmm2
movapd %xmm2,%xmm5
addpd  %xmm1,%xmm5
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
jne    18c0 <coreGammaInvarFlex+0x7a0>
addpd  %xmm1,%xmm2
movapd %xmm2,0x10(%rsp)
jmp    1958 <coreGammaInvarFlex+0x838>
nopl   (%rax)
mov    0x90(%rsp),%rax
addsd  (%r8,%rax,8),%xmm0
xorpd  %xmm2,%xmm2
mov    0x88(%rsp),%rax
addsd  (%r8,%rax,8),%xmm0
movapd %xmm2,%xmm1
mov    0x80(%rsp),%rax
addsd  (%r8,%rax,8),%xmm0
movapd %xmm1,0x10(%rsp)
call   1030 <FABS@plt>
movsd  0x38(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mov    0x2320(%rsp),%rax
movslq (%rax,%rbp,4),%rax
mov    0x2328(%rsp),%ecx
cmp    %ecx,%eax
jge    1660 <coreGammaInvarFlex+0x540>
addsd  0xd0(%rsp,%rax,8),%xmm0
jmp    1660 <coreGammaInvarFlex+0x540>
movapd %xmm5,0x10(%rsp)
jmp    1958 <coreGammaInvarFlex+0x838>
addpd  %xmm3,%xmm4
mov    0x58(%rsp),%r14
mov    0x2310(%rsp),%rax
jmp    19af <coreGammaInvarFlex+0x88f>
xorpd  %xmm4,%xmm4
movhpd %xmm4,(%r14)
movlpd %xmm4,(%rax)
add    $0x22d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%bl
jne    121a <coreGammaInvarFlex+0xfa>
jmp    123f <coreGammaInvarFlex+0x11f>

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

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