#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 *calloc(int, int);
int /*<<< orphan*/ free(double *);
void dL_update_hmc(double *pdL, double *pdLi, double *pdp, double *pdM,
                   double *pdtj, int N) {
  double *pdLdot, *pdU;
  double tmp, r, *pdrdot, *pdcdot, *pds;
  int i, j, k;
  pdLdot = calloc(N * N, sizeof(double));
  pdU = calloc(N * N, sizeof(double));
  pdrdot = calloc(N, sizeof(double));
  pdcdot = calloc(N, sizeof(double));
  pds = calloc(N, sizeof(double));
  for (i = 0; i < N; ++i) {
    pdU[i + N * i] = 1.0;
    for (j = 0; j < N; ++j) {
      pdM[j + N * i] = 0.0;
    }
    pdtj[i] = 0.0;
  }
  for (k = 0; k < N; ++k) {
    r = pdL[k + N * k];
    for (i = 0; i < N; ++i) {
      pdrdot[i] = 0.5 * pdU[i + N * k] * pdU[i + N * k] / r;
      pdcdot[i] = pdrdot[i] / pdL[k + N * k];
      pds[i] = pdU[i + N * k] / pdL[k + N * k];
      if (k > 0) {
        pdLdot[i + N * (k - 1)] = 0.0;
      }
      pdLdot[i + N * k] = pdrdot[i];
    }
    for (i = k + 1; i < N; ++i) {
      for (j = 0; j < N; ++j) {
        pdLdot[j + N * i] =
            pds[j] * pdU[j + N * i] - pdcdot[j] * pdL[k + N * i];
      }
    }
    for (i = k + 1; i < N; ++i) {
      tmp = pdL[k + N * i];
      for (j = 0; j < N; ++j) {
        pdU[j + N * i] = pdU[j + N * i] - pds[j] * tmp;
      }
    }
    for (i = 0; i < N; ++i) {
      for (j = k; j < N; ++j) {
        pdM[i + N * k] += pdLdot[i + N * j] * pdp[j];
      }
    }
    for (j = 0; j < N; ++j) {
      tmp = pdLi[j + N * k];
      for (i = 0; i < N; ++i) {
        pdtj[i] += tmp * pdLdot[i + j * N];
      }
    }
  }
  free(pdLdot);
  free(pdU);
  free(pdrdot);
  free(pdcdot);
  free(pds);
  return;
}


x86 assembly (clang, -O0):
<dL_update_hmc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x2c(%rbp),%edi
imul   -0x2c(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x2c(%rbp),%edi
imul   -0x2c(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    122d <dL_update_hmc+0x10d>
mov    -0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xe3a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    120f <dL_update_hmc+0xef>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    11da <dL_update_hmc+0xba>
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    11a7 <dL_update_hmc+0x87>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1655 <dL_update_hmc+0x535>
mov    -0x8(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1386 <dL_update_hmc+0x266>
mov    -0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xd75(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x74(%rbp)
jle    1353 <dL_update_hmc+0x233>
mov    -0x38(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x74(%rbp),%esi
sub    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1264 <dL_update_hmc+0x144>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1450 <dL_update_hmc+0x330>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    143d <dL_update_hmc+0x31d>
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    13a2 <dL_update_hmc+0x282>
jmp    1442 <dL_update_hmc+0x322>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    138f <dL_update_hmc+0x26f>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1517 <dL_update_hmc+0x3f7>
mov    -0x8(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1504 <dL_update_hmc+0x3e4>
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x6c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1489 <dL_update_hmc+0x369>
jmp    1509 <dL_update_hmc+0x3e9>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1459 <dL_update_hmc+0x339>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    15a7 <dL_update_hmc+0x487>
mov    -0x74(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1594 <dL_update_hmc+0x474>
mov    -0x38(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x70(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1530 <dL_update_hmc+0x410>
jmp    1599 <dL_update_hmc+0x479>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    151e <dL_update_hmc+0x3fe>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1642 <dL_update_hmc+0x522>
mov    -0x10(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    162f <dL_update_hmc+0x50f>
movsd  -0x48(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    15de <dL_update_hmc+0x4be>
jmp    1634 <dL_update_hmc+0x514>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    15ae <dL_update_hmc+0x48e>
jmp    1647 <dL_update_hmc+0x527>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1234 <dL_update_hmc+0x114>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dL_update_hmc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9d,%r14d
mov    %r8,%rbx
mov    %rcx,%r15
mov    %rdx,%r12
mov    %rsi,0xd0(%rsp)
mov    %rdi,0x88(%rsp)
mov    %r9d,%ebp
imul   %r9d,%ebp
mov    %ebp,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,0x40(%rsp)
mov    %ebp,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,0x20(%rsp)
mov    %r14d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,0x58(%rsp)
mov    %r14d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,0x38(%rsp)
mov    %r14d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %r14,%rbp
mov    %rax,%r13
test   %ebp,%ebp
jle    1a27 <dL_update_hmc+0x8f7>
mov    %ebp,%r14d
lea    0x0(,%r14,8),%rdx
xor    %eax,%eax
movabs $0x3ff0000000000000,%r8
cmp    $0x1,%ebp
mov    %rbp,0x18(%rsp)
jne    11ed <dL_update_hmc+0xbd>
xor    %ebp,%ebp
jmp    12f7 <dL_update_hmc+0x1c7>
mov    %r14d,%edi
and    $0xfffffffe,%edi
mov    %rdi,0x48(%rsp)
lea    0x0(%rbp,%rbp,1),%edi
mov    %edi,0x78(%rsp)
mov    %r14,%rdi
shl    $0x4,%rdi
mov    %rdi,0x28(%rsp)
mov    $0x1,%ecx
mov    %r15,%rdi
mov    %ebp,%esi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    %rdi,0x50(%rsp)
mov    %rcx,0x80(%rsp)
mov    %rbp,0x10(%rsp)
movslq %esi,%rsi
mov    %rsi,(%rsp)
add    %rsi,%rcx
mov    %rcx,0x8(%rsp)
cltq
mov    %rax,0x30(%rsp)
mov    0x30(%rsp),%rax
add    %rbp,%rax
mov    0x20(%rsp),%rcx
mov    %r8,(%rcx,%rax,8)
xor    %esi,%esi
mov    %rdx,%rbp
call   1040 <memset@plt>
mov    0x10(%rsp),%rax
movq   $0x0,(%rbx,%rax,8)
mov    0x20(%rsp),%rax
movabs $0x3ff0000000000000,%rcx
mov    0x8(%rsp),%rdx
mov    %rcx,(%rax,%rdx,8)
mov    0x50(%rsp),%rax
lea    (%rax,%rbp,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    0x50(%rsp),%rdi
mov    0x80(%rsp),%rcx
mov    0x30(%rsp),%rax
movabs $0x3ff0000000000000,%r8
mov    %rbp,%rdx
mov    0x10(%rsp),%rbp
movq   $0x0,0x8(%rbx,%rbp,8)
add    $0x2,%rbp
mov    0x78(%rsp),%r9d
add    %r9d,%eax
add    $0x2,%rcx
mov    (%rsp),%rsi
add    %r9d,%esi
mov    %rsi,(%rsp)
mov    (%rsp),%rsi
add    0x28(%rsp),%rdi
cmp    %rbp,0x48(%rsp)
jne    1220 <dL_update_hmc+0xf0>
mov    0x20(%rsp),%rcx
test   $0x1,%r14b
je     132c <dL_update_hmc+0x1fc>
mov    %ebp,%eax
imul   0x18(%rsp),%eax
cltq
add    %rbp,%rax
mov    %r8,(%rcx,%rax,8)
mov    %rbp,%rax
imul   %r14,%rax
lea    (%r15,%rax,8),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
movq   $0x0,(%rbx,%rbp,8)
cmpl   $0x0,0x18(%rsp)
jle    1a27 <dL_update_hmc+0x8f7>
mov    %r14d,%eax
and    $0xfffffffc,%eax
mov    %rax,(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,0xb8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x80(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x78(%rsp)
mov    $0x1,%eax
mov    %rax,0x70(%rsp)
mov    $0x1,%eax
sub    %r14,%rax
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    %rdx,0x90(%rsp)
lea    0x0(,%r14,8),%r9
mov    %r9,%r11
and    $0xfffffffffffffff0,%r11
lea    (%rcx,%rax,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x98(%rsp)
lea    0x10(%rcx,%r14,8),%rax
mov    %rax,0xa8(%rsp)
mov    0x20(%rsp),%r10
lea    (%r10,%r14,8),%rdi
add    $0x10,%rdi
mov    %rdi,0x68(%rsp)
mov    %r9,%rdi
and    $0xffffffffffffffe0,%rdi
mov    %rdi,0x48(%rsp)
lea    (%r10,%r14,8),%rdi
mov    %rdi,0x60(%rsp)
mov    %rcx,%rdi
add    $0x30,%rdi
mov    %rdi,0xc0(%rsp)
movsd  0xc0c(%rip),%xmm0
movapd 0xbf3(%rip),%xmm9
xorps  %xmm8,%xmm8
lea    (%rcx,%r14,8),%rdi
mov    %rdi,0xa0(%rsp)
xor    %esi,%esi
mov    %r14,%r8
mov    %rcx,%rdx
mov    %r11,0xc8(%rsp)
jmp    1494 <dL_update_hmc+0x364>
nop
addq   $0x1,0x70(%rsp)
add    %r9,0x90(%rsp)
mov    0x28(%rsp),%rdx
add    %r9,%rdx
mov    0xb0(%rsp),%r10
add    %r9,%r10
add    %r9,0x98(%rsp)
add    %r9,0xa8(%rsp)
add    %r9,0x68(%rsp)
add    %r9,0x60(%rsp)
add    %r9,0xa0(%rsp)
add    $0x8,%r12
add    $0xffffffffffffffff,%r8
mov    0x8(%rsp),%rax
mov    %rax,%rsi
cmp    %r14,%rax
mov    0xc8(%rsp),%r11
je     1a27 <dL_update_hmc+0x8f7>
mov    %esi,%eax
mov    0x18(%rsp),%rdi
imul   %edi,%eax
cltq
add    %rsi,%rax
mov    0x88(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm3
cmp    $0x2,%edi
mov    %r10,0xb0(%rsp)
mov    %rdx,0x28(%rsp)
jae    14e0 <dL_update_hmc+0x3b0>
mov    %rsi,%rdi
xor    %ecx,%ecx
mov    0x58(%rsp),%rbp
jmp    16c0 <dL_update_hmc+0x590>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %eax,%eax
mov    0x58(%rsp),%rbp
mov    0x38(%rsp),%rcx
mov    0x90(%rsp),%rdi
jmp    150e <dL_update_hmc+0x3de>
xchg   %ax,%ax
movupd %xmm5,(%rdx,%rax,1)
add    $0x10,%rax
cmp    %rax,%r11
je     1550 <dL_update_hmc+0x420>
movupd (%r10,%rax,1),%xmm6
movapd %xmm6,%xmm5
mulpd  %xmm9,%xmm5
mulpd  %xmm6,%xmm5
divpd  %xmm4,%xmm5
movupd %xmm5,0x0(%rbp,%rax,1)
movapd %xmm5,%xmm7
divpd  %xmm4,%xmm7
movupd %xmm7,(%rcx,%rax,1)
divpd  %xmm4,%xmm6
movupd %xmm6,0x0(%r13,%rax,1)
test   %rsi,%rsi
je     1500 <dL_update_hmc+0x3d0>
movups %xmm8,-0x8(%rdi,%rax,1)
jmp    1500 <dL_update_hmc+0x3d0>
mov    %rsi,%rdi
mov    0xb8(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
jne    16c0 <dL_update_hmc+0x590>
mov    %rdi,%r11
lea    0x1(%rdi),%rcx
mov    0xa0(%rsp),%r10
mov    0x60(%rsp),%rsi
mov    0x68(%rsp),%rax
mov    0xa8(%rsp),%rdx
mov    0x70(%rsp),%rdi
mov    %rcx,0x8(%rsp)
cmp    %r14,%rcx
mov    %rdi,%rcx
mov    %r11,0x30(%rsp)
jb     15c9 <dL_update_hmc+0x499>
jmp    178a <dL_update_hmc+0x65a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
add    %r9,%rdx
add    %r9,%rax
add    %r9,%rsi
add    %r9,%r10
cmp    %r14,%rcx
je     1770 <dL_update_hmc+0x640>
mov    %rcx,%rbp
imul   %r14,%rbp
add    %r11,%rbp
mov    0x88(%rsp),%r11
movsd  (%r11,%rbp,8),%xmm3
cmpl   $0x4,0x18(%rsp)
jae    1600 <dL_update_hmc+0x4d0>
xor    %ebp,%ebp
mov    0x38(%rsp),%rdi
mov    0x30(%rsp),%r11
jmp    1690 <dL_update_hmc+0x560>
nopl   0x0(%rax)
mov    %rcx,0x10(%rsp)
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %ebp,%ebp
mov    0x38(%rsp),%rdi
mov    0x48(%rsp),%rcx
nopl   0x0(%rax)
movupd 0x0(%r13,%rbp,1),%xmm5
movupd 0x10(%r13,%rbp,1),%xmm6
movupd -0x10(%rax,%rbp,1),%xmm7
mulpd  %xmm5,%xmm7
movupd (%rax,%rbp,1),%xmm5
mulpd  %xmm6,%xmm5
movupd (%rdi,%rbp,1),%xmm6
movupd 0x10(%rdi,%rbp,1),%xmm2
mulpd  %xmm4,%xmm6
subpd  %xmm6,%xmm7
mulpd  %xmm4,%xmm2
subpd  %xmm2,%xmm5
movupd %xmm7,-0x10(%rdx,%rbp,1)
movupd %xmm5,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    1620 <dL_update_hmc+0x4f0>
mov    (%rsp),%r11
mov    %r11,%rbp
cmp    %r14,%r11
mov    0x30(%rsp),%r11
mov    0x10(%rsp),%rcx
je     15b0 <dL_update_hmc+0x480>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,8),%xmm2
movsd  (%rdi,%rbp,8),%xmm4
mulsd  %xmm3,%xmm4
mulsd  (%rsi,%rbp,8),%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%r10,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1690 <dL_update_hmc+0x560>
jmp    15b0 <dL_update_hmc+0x480>
nopl   (%rax)
mov    0x98(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x8(%rsp)
mov    0xb0(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x10(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%rdx
lea    0x0(%r13,%rcx,8),%rsi
mov    0x38(%rsp),%rax
lea    (%rax,%rcx,8),%rax
lea    0x0(,%rcx,8),%r10
add    %rbp,%r10
mov    %r14,%r11
sub    %rcx,%r11
xor    %ecx,%ecx
jmp    1722 <dL_update_hmc+0x5f2>
xchg   %ax,%ax
movsd  %xmm4,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r11
je     1567 <dL_update_hmc+0x437>
mov    0x10(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm5
movapd %xmm5,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm5,%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%r10,%rcx,8)
movapd %xmm4,%xmm6
divsd  %xmm3,%xmm6
movsd  %xmm6,(%rax,%rcx,8)
divsd  %xmm3,%xmm5
movsd  %xmm5,(%rsi,%rcx,8)
test   %rdi,%rdi
je     1710 <dL_update_hmc+0x5e0>
mov    0x8(%rsp),%rbp
movq   $0x0,0x0(%rbp,%rcx,8)
jmp    1710 <dL_update_hmc+0x5e0>
xchg   %ax,%ax
mov    0x60(%rsp),%rax
mov    0x68(%rsp),%rcx
mov    0x70(%rsp),%rdx
cmp    %r14,0x8(%rsp)
jb     1973 <dL_update_hmc+0x843>
imul   %r14,%r11
mov    0x28(%rsp),%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rcx,%r11,1),%rdx
movsd  (%r15,%rdx,8),%xmm3
xor    %esi,%esi
mov    %rbp,%rax
nop
movsd  (%rax),%xmm2
mulsd  (%r12,%rsi,8),%xmm2
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r15,%rdx,8)
add    %r9,%rax
add    $0x1,%rsi
cmp    %rsi,%r8
jne    17b0 <dL_update_hmc+0x680>
add    $0x1,%rcx
add    $0x8,%rbp
cmp    %r14,%rcx
jne    17a0 <dL_update_hmc+0x670>
mov    %r11,%rdi
mov    0x40(%rsp),%rsi
mov    0xc0(%rsp),%rcx
xor    %r10d,%r10d
mov    0xd0(%rsp),%r11
jmp    1813 <dL_update_hmc+0x6e3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r9,%rcx
add    %r9,%rsi
cmp    %r14,%r10
je     1430 <dL_update_hmc+0x300>
lea    (%r10,%rdi,1),%rax
movsd  (%r11,%rax,8),%xmm3
cmpl   $0x4,0x18(%rsp)
jae    1830 <dL_update_hmc+0x700>
xor    %eax,%eax
jmp    1920 <dL_update_hmc+0x7f0>
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmpq   $0x0,0x50(%rsp)
je     1941 <dL_update_hmc+0x811>
mov    0x78(%rsp),%rdx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rcx,%rax,8),%xmm2
movupd -0x20(%rcx,%rax,8),%xmm5
mulpd  %xmm4,%xmm2
movupd (%rbx,%rax,8),%xmm6
addpd  %xmm2,%xmm6
movupd 0x10(%rbx,%rax,8),%xmm2
movupd 0x20(%rbx,%rax,8),%xmm7
movupd 0x30(%rbx,%rax,8),%xmm1
mulpd  %xmm4,%xmm5
addpd  %xmm2,%xmm5
movupd %xmm6,(%rbx,%rax,8)
movupd %xmm5,0x10(%rbx,%rax,8)
movupd -0x10(%rcx,%rax,8),%xmm2
movupd (%rcx,%rax,8),%xmm5
mulpd  %xmm4,%xmm2
addpd  %xmm7,%xmm2
mulpd  %xmm4,%xmm5
addpd  %xmm1,%xmm5
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm5,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    1850 <dL_update_hmc+0x720>
testb  $0x1,0x80(%rsp)
01
je     190a <dL_update_hmc+0x7da>
mov    %r10,%rdx
imul   %r14,%rdx
add    %rax,%rdx
mov    0x40(%rsp),%rbp
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd 0x10(%rbp,%rdx,8),%xmm2
movupd (%rbx,%rax,8),%xmm5
movupd 0x10(%rbx,%rax,8),%xmm6
mulpd  %xmm4,%xmm1
addpd  %xmm5,%xmm1
mulpd  %xmm4,%xmm2
addpd  %xmm6,%xmm2
movupd %xmm1,(%rbx,%rax,8)
movupd %xmm2,0x10(%rbx,%rax,8)
mov    (%rsp),%rdx
mov    %rdx,%rax
cmp    %r14,%rdx
je     1800 <dL_update_hmc+0x6d0>
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1920 <dL_update_hmc+0x7f0>
jmp    1800 <dL_update_hmc+0x6d0>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    18c9 <dL_update_hmc+0x799>
jmp    190a <dL_update_hmc+0x7da>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    %r9,%rcx
add    %r9,%rax
cmp    %r14,%rdx
je     178a <dL_update_hmc+0x65a>
mov    %rdx,%rsi
imul   %r14,%rsi
add    %r11,%rsi
mov    0x88(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm3
cmpl   $0x4,0x18(%rsp)
jae    19a0 <dL_update_hmc+0x870>
xor    %esi,%esi
jmp    1a00 <dL_update_hmc+0x8d0>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %esi,%esi
mov    0x48(%rsp),%rdi
nop
movupd -0x10(%rcx,%rsi,1),%xmm2
movupd (%rcx,%rsi,1),%xmm5
movupd 0x0(%r13,%rsi,1),%xmm6
movupd 0x10(%r13,%rsi,1),%xmm7
mulpd  %xmm4,%xmm6
subpd  %xmm6,%xmm2
mulpd  %xmm4,%xmm7
subpd  %xmm7,%xmm5
movupd %xmm2,-0x10(%rcx,%rsi,1)
movupd %xmm5,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    19b0 <dL_update_hmc+0x880>
mov    (%rsp),%rdi
mov    %rdi,%rsi
cmp    %r14,%rdi
je     1960 <dL_update_hmc+0x830>
nopl   (%rax)
movsd  (%rax,%rsi,8),%xmm2
movsd  0x0(%r13,%rsi,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rax,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r14
jne    1a00 <dL_update_hmc+0x8d0>
jmp    1960 <dL_update_hmc+0x830>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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