#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 coreGTRCATPROTMULT(double *EIGN, double lz, int numberOfCategories,
                        double *rptr, int *cptr, int lower, int upper,
                        double *wrptr, double *wr2ptr, double *ext_dlnLdlz,
                        double *ext_d2lnLdlz2, double *sumtable,
                        int numberOfModels, int *modelptr) {
  double *sum;
  int i, l;
  double dlnLdlz = 0.0;
  double d2lnLdlz2 = 0.0;
  double *d1, *d_start;
  double *e, *s, *e_start, *s_start;
  int model;
  double dd[19];
  double tmp;
  double inv_Li, dlnLidlz, d2lnLidlz2;
  e = e_start = (double *)malloc(19 * numberOfModels * sizeof(double));
  s = s_start = (double *)malloc(19 * numberOfModels * sizeof(double));
  d1 = d_start = (double *)malloc(numberOfModels * numberOfCategories * 19 *
                                  sizeof(double));
  for (model = 0; model < numberOfModels; model++) {
    for (l = 0; l < 19; l++) {
      e[model * 19 + l] = EIGN[model * 19 + l] * EIGN[model * 19 + l];
      s[model * 19 + l] = EIGN[model * 19 + l];
      dd[l] = s[model * 19 + l] * lz;
    }
    for (i = 0; i < numberOfCategories; i++) {
      for (l = 0; l < 19; l++)
        *d1++ = exp(dd[l] * rptr[i]);
    }
  }
  for (i = lower; i < upper; i++) {
    model = modelptr[i];
    sum = &sumtable[20 * i];
    d1 = &(d_start[model * numberOfCategories * 19 + 19 * cptr[i]]);
    e = &(e_start[model * 19]);
    s = &(s_start[model * 19]);
    inv_Li = sum[0];
    inv_Li += (tmp = d1[0] * sum[1]);
    dlnLidlz = tmp * s[0];
    d2lnLidlz2 = tmp * e[0];
    for (l = 1; l < 19; l++) {
      inv_Li += (tmp = d1[l] * sum[l + 1]);
      dlnLidlz += tmp * s[l];
      d2lnLidlz2 += tmp * e[l];
    }
    inv_Li = 1.0 / inv_Li;
    dlnLidlz *= inv_Li;
    d2lnLidlz2 *= inv_Li;
    dlnLdlz += wrptr[i] * dlnLidlz;
    d2lnLdlz2 += wr2ptr[i] * (d2lnLidlz2 - dlnLidlz * dlnLidlz);
  }
  *ext_dlnLdlz = dlnLdlz;
  *ext_d2lnLdlz2 = d2lnLdlz2;
  free(d_start);
  free(s_start);
  free(e_start);
}


x86 assembly (clang, -O0):
<coreGTRCATPROTMULT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
imul   $0x13,0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    %rax,-0x68(%rbp)
imul   $0x13,0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    %rax,-0x70(%rbp)
mov    0x38(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   $0x13,%eax,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1335 <coreGTRCATPROTMULT+0x205>
movl   $0x0,-0x40(%rbp)
cmpl   $0x13,-0x40(%rbp)
jge    12a1 <coreGTRCATPROTMULT+0x171>
mov    -0x8(%rbp),%rax
imul   $0x13,-0x84(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x13,-0x84(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
imul   $0x13,-0x84(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
imul   $0x13,-0x84(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
imul   $0x13,-0x84(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
imul   $0x13,-0x84(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x10(%rbp),%xmm0
movslq -0x40(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11f3 <coreGTRCATPROTMULT+0xc3>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    131c <coreGTRCATPROTMULT+0x1ec>
movl   $0x0,-0x40(%rbp)
cmpl   $0x13,-0x40(%rbp)
jge    1309 <coreGTRCATPROTMULT+0x1d9>
movslq -0x40(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   1050 <exp@plt>
cvtsi2sd %eax,%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x58(%rbp)
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12bb <coreGTRCATPROTMULT+0x18b>
jmp    130e <coreGTRCATPROTMULT+0x1de>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12a8 <coreGTRCATPROTMULT+0x178>
jmp    1321 <coreGTRCATPROTMULT+0x1f1>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    11dd <coreGTRCATPROTMULT+0xad>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    15b9 <coreGTRCATPROTMULT+0x489>
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
mov    0x30(%rbp),%rax
imul   $0x14,-0x3c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x84(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   $0x13,%ecx,%ecx
mov    -0x28(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
imul   $0x13,(%rdx,%rsi,4),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x78(%rbp),%rax
imul   $0x13,-0x84(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%rax
imul   $0x13,-0x84(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
addsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movl   $0x1,-0x40(%rbp)
cmpl   $0x13,-0x40(%rbp)
jge    14e6 <coreGTRCATPROTMULT+0x3b6>
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
addsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x140(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    143d <coreGTRCATPROTMULT+0x30d>
movsd  0xb12(%rip),%xmm0
divsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mulsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mulsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x138(%rbp),%xmm2
ff
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x138(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm3
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    133b <coreGTRCATPROTMULT+0x20b>
movsd  -0x48(%rbp),%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<coreGTRCATPROTMULT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r9d,0x3c(%rsp)
mov    %r8d,0x38(%rsp)
mov    %rcx,0x68(%rsp)
mov    %rdx,%r13
mov    %esi,%ebp
movapd %xmm0,0x90(%rsp)
mov    %rdi,0x20(%rsp)
mov    0x1b0(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x1a8(%rsp),%ebx
mov    0x1a0(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x198(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    0x190(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0x188(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x180(%rsp),%rax
mov    %rax,0x48(%rsp)
imul   $0x98,%ebx,%r12d
mov    %r12d,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    %r12d,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %ebp,0xc(%rsp)
imul   %ebp,%r12d
mov    %r12d,%edi
call   1040 <malloc@plt>
mov    0x20(%rsp),%rdx
movapd 0x90(%rsp),%xmm2
mov    %rax,0x18(%rsp)
test   %ebx,%ebx
mov    %r15,0x28(%rsp)
mov    %r14,0x10(%rsp)
jle    15ee <coreGTRCATPROTMULT+0x4be>
mov    %r14,%r8
mov    %ebx,%eax
mov    %rax,0x80(%rsp)
mov    0xc(%rsp),%eax
mov    %rax,0x88(%rsp)
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
movapd %xmm0,0xa0(%rsp)
xor    %esi,%esi
mov    %rdx,%r14
mov    %r8,%rbp
mov    %r15,%rbx
mov    0x18(%rsp),%rax
jmp    127c <coreGTRCATPROTMULT+0x14c>
cs nopw 0x0(%rax,%rax,1)
mov    0x40(%rsp),%rsi
add    $0x1,%rsi
add    $0x98,%rbx
add    $0x98,%rbp
add    $0x98,%r14
cmp    0x80(%rsp),%rsi
je     15ee <coreGTRCATPROTMULT+0x4be>
mov    %rbp,0x30(%rsp)
lea    (%rsi,%rsi,8),%rcx
mov    %rsi,0x40(%rsp)
lea    (%rsi,%rcx,2),%rcx
lea    (%r8,%rcx,8),%rbp
lea    0x98(%r8,%rcx,8),%rsi
lea    (%r15,%rcx,8),%r9
lea    (%r15,%rcx,8),%r8
add    $0x98,%r8
lea    (%rdx,%rcx,8),%r11
lea    (%rdx,%rcx,8),%rdi
add    $0x98,%rdi
cmp    %r8,%rbp
setb   %r10b
cmp    %rsi,%r9
mov    %r15,%r12
setb   %r15b
and    %r10b,%r15b
cmp    %rdi,%rbp
setb   %r10b
cmp    %rsi,%r11
setb   %dl
and    %r10b,%dl
or     %r15b,%dl
cmp    %rdi,%r9
setb   %sil
cmp    %r8,%r11
setb   %dil
and    %sil,%dil
or     %dl,%dil
cmp    $0x1,%dil
jne    1310 <coreGTRCATPROTMULT+0x1e0>
xor    %esi,%esi
mov    %r12,%r15
mov    0x10(%rsp),%r8
mov    0x20(%rsp),%rdx
jmp    14a2 <coreGTRCATPROTMULT+0x372>
nopl   (%rax)
mov    0x20(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mov    0x10(%rsp),%r8
movupd %xmm1,(%r8,%rcx,8)
movupd %xmm0,(%r12,%rcx,8)
movapd 0xa0(%rsp),%xmm3
mulpd  %xmm3,%xmm0
movapd %xmm0,0xb0(%rsp)
movupd 0x10(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x10(%r8,%rcx,8)
movupd %xmm0,0x10(%r12,%rcx,8)
mulpd  %xmm3,%xmm0
movapd %xmm0,0xc0(%rsp)
movupd 0x20(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x20(%r8,%rcx,8)
movupd %xmm0,0x20(%r12,%rcx,8)
mulpd  %xmm3,%xmm0
movapd %xmm0,0xd0(%rsp)
movupd 0x30(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x30(%r8,%rcx,8)
movupd %xmm0,0x30(%r12,%rcx,8)
mulpd  %xmm3,%xmm0
movapd %xmm0,0xe0(%rsp)
movupd 0x40(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x40(%r8,%rcx,8)
movupd %xmm0,0x40(%r12,%rcx,8)
mulpd  %xmm3,%xmm0
movapd %xmm0,0xf0(%rsp)
movupd 0x50(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x50(%r8,%rcx,8)
movupd %xmm0,0x50(%r12,%rcx,8)
mulpd  %xmm3,%xmm0
movapd %xmm0,0x100(%rsp)
movupd 0x60(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x60(%r8,%rcx,8)
movupd %xmm0,0x60(%r12,%rcx,8)
mulpd  %xmm3,%xmm0
movapd %xmm0,0x110(%rsp)
movupd 0x70(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x70(%r8,%rcx,8)
movupd %xmm0,0x70(%r12,%rcx,8)
mulpd  %xmm3,%xmm0
movapd %xmm0,0x120(%rsp)
movupd 0x80(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x80(%r8,%rcx,8)
movupd %xmm0,0x80(%r12,%rcx,8)
mulpd  %xmm3,%xmm0
movapd %xmm0,0x130(%rsp)
mov    $0x12,%esi
mov    %r12,%r15
mov    0x30(%rsp),%rbp
add    %rsi,%rcx
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
mulsd  %xmm2,%xmm0
movsd  %xmm0,0xb0(%rsp,%rsi,8)
test   %dil,%dil
je     1554 <coreGTRCATPROTMULT+0x424>
add    $0xffffffffffffffee,%rsi
nopw   0x0(%rax,%rax,1)
movsd  0x98(%r14,%rsi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x98(%rbp,%rsi,8)
movsd  0x98(%r14,%rsi,8),%xmm0
movsd  %xmm0,0x98(%rbx,%rsi,8)
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x148(%rsp,%rsi,8)
movsd  0xa0(%r14,%rsi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0xa0(%rbp,%rsi,8)
movsd  0xa0(%r14,%rsi,8),%xmm0
movsd  %xmm0,0xa0(%rbx,%rsi,8)
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x150(%rsp,%rsi,8)
add    $0x2,%rsi
jne    14e0 <coreGTRCATPROTMULT+0x3b0>
cmpl   $0x0,0xc(%rsp)
jle    1250 <coreGTRCATPROTMULT+0x120>
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,%r12
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0xb0(%rsp,%rbp,1),%xmm0
mulsd  0x0(%r13,%r15,8),%xmm0
call   1050 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12,%rbp,1)
add    $0x8,%rbp
cmp    $0x98,%rbp
jne    1580 <coreGTRCATPROTMULT+0x450>
add    $0x1,%r15
lea    (%r12,%rbp,1),%rax
cmp    0x88(%rsp),%r15
jne    1570 <coreGTRCATPROTMULT+0x440>
add    %rbp,%r12
mov    %r12,%rax
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r15
movapd 0x90(%rsp),%xmm2
mov    0x20(%rsp),%rdx
mov    0x40(%rsp),%rsi
mov    0x30(%rsp),%rbp
jmp    1255 <coreGTRCATPROTMULT+0x125>
xorpd  %xmm4,%xmm4
mov    0x3c(%rsp),%ecx
mov    0x38(%rsp),%eax
cmp    %ecx,%eax
jge    1787 <coreGTRCATPROTMULT+0x657>
cltq
movslq %ecx,%r8
lea    (%rax,%rax,4),%rcx
shl    $0x5,%rcx
mov    0x58(%rsp),%rbp
lea    (%rcx,%rbp,1),%rdx
add    $0x18,%rdx
mov    0x10(%rsp),%r9
add    $0x10,%r9
mov    %r15,%r10
add    $0x10,%r10
mov    0x18(%rsp),%r15
add    $0x10,%r15
xorpd  %xmm2,%xmm2
movsd  0x9bf(%rip),%xmm0
mov    0x68(%rsp),%r11
mov    0x60(%rsp),%r14
mov    0x50(%rsp),%r12
mov    0x48(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nop
movslq (%r14,%rax,4),%rcx
lea    (%rax,%rax,4),%rsi
shl    $0x5,%rsi
mov    %ecx,%edi
imul   0xc(%rsp),%edi
add    (%r11,%rax,4),%edi
lea    (%rdi,%rdi,8),%ebx
lea    (%rdi,%rbx,2),%edi
movslq %edi,%rdi
mov    0x18(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm4
mulsd  0x8(%rbp,%rsi,1),%xmm4
imul   $0x98,%rcx,%rbx
movapd %xmm2,%xmm1
movsd  0x0(%rbp,%rsi,1),%xmm2
addsd  %xmm4,%xmm2
unpcklpd %xmm4,%xmm4
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rbx,1),%xmm3
mov    0x28(%rsp),%rcx
movhpd (%rcx,%rbx,1),%xmm3
mulpd  %xmm4,%xmm3
lea    (%r9,%rbx,1),%rcx
add    %r10,%rbx
lea    (%r15,%rdi,8),%rsi
xor    %edi,%edi
xchg   %ax,%ax
movsd  -0x8(%rsi,%rdi,1),%xmm4
movsd  (%rsi,%rdi,1),%xmm5
mulsd  -0x8(%rdx,%rdi,1),%xmm4
addsd  %xmm4,%xmm2
unpcklpd %xmm4,%xmm4
movsd  -0x8(%rcx,%rdi,1),%xmm6
movhpd -0x8(%rbx,%rdi,1),%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm3,%xmm6
movsd  (%rcx,%rdi,1),%xmm3
mulsd  (%rdx,%rdi,1),%xmm5
addsd  %xmm5,%xmm2
unpcklpd %xmm5,%xmm5
movhpd (%rbx,%rdi,1),%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm6,%xmm3
add    $0x10,%rdi
cmp    $0x90,%rdi
jne    16d0 <coreGTRCATPROTMULT+0x5a0>
movapd %xmm0,%xmm4
divsd  %xmm2,%xmm4
movapd %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm4
movapd %xmm2,%xmm3
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm4
movsd  (%r12,%rax,8),%xmm3
movhpd 0x0(%r13,%rax,8),%xmm3
unpcklpd %xmm2,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm4,%xmm2
addpd  %xmm1,%xmm2
add    $0x1,%rax
add    $0xa0,%rdx
cmp    %r8,%rax
jne    1660 <coreGTRCATPROTMULT+0x530>
addpd  %xmm1,%xmm4
mov    0x28(%rsp),%r15
mov    0x70(%rsp),%rax
movhpd %xmm4,(%rax)
mov    0x78(%rsp),%rax
movlpd %xmm4,(%rax)
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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