#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 const, int);
int /*<<< orphan*/ free(double *);
double *malloc(int const);
int omp_get_thread_num();
void dL_update_hmc2(const double *pdL, const double *pdLi, const double *pdp,
                    double *pdM, double *pdtj, const int N) {
  double *pdLdot, *pdU, *pdLtrans;
  double r, drdot, dcdot, ds, temp;
  int i, j, k, index;
  pdLtrans = malloc(N * N * sizeof(double));
  for (i = 0; i < N; ++i) {
    for (j = 0; j < N; ++j) {
      pdM[j + N * i] = 0.0;
      pdLtrans[j + N * i] = pdL[i + N * j];
    }
    pdtj[i] = 0.0;
  }
#pragma omp parallel private(i, j, k, index, pdLdot, pdU, r, drdot, dcdot, ds, \
                             temp)                                             \
    shared(pdL, pdLtrans, pdLi, pdp, pdM, pdtj) default(none)
  {
    const int ithread = omp_get_thread_num();
    double *pdMlocal, dtjlocal;
    pdMlocal = calloc(N, sizeof(double));
#pragma omp for nowait
    for (i = 0; i < N; ++i) {
      pdLdot = calloc(N, sizeof(double));
      pdU = calloc(N, sizeof(double));
      pdU[i] = 1.0;
      temp = 0.0;
      dtjlocal = 0.0;
      for (k = 0; k < N; ++k) {
        r = pdL[k + N * k];
        drdot = 0.5 * pdU[k] * pdU[k] / r;
        dcdot = drdot / pdL[k + N * k];
        ds = pdU[k] / pdL[k + N * k];
        if (k > 0) {
          pdLdot[k - 1] = 0.0;
        }
        pdLdot[k] = drdot;
        for (j = k + 1; j < N; ++j) {
          pdLdot[j] = ds * pdU[j] - dcdot * pdLtrans[j + N * k];
        }
        for (j = k + 1; j < N; ++j) {
          pdU[j] = pdU[j] - ds * pdLtrans[j + N * k];
        }
        temp = 0;
        for (j = k; j < N; ++j) {
          temp += pdLdot[j] * pdp[j];
        }
        pdMlocal[k] = temp;
        temp = 0;
        for (j = 0; j < N; ++j) {
          temp += pdLi[j + N * k] * pdLdot[j];
        }
        dtjlocal += temp;
      }
#pragma omp critical
      {
        for (k = 0; k < N; ++k) {
          index = i + N * k;
          pdM[index] = pdMlocal[k];
        }
        pdtj[i] += dtjlocal;
      }
      free(pdLdot);
      free(pdU);
    }
    free(pdMlocal);
  }
  free(pdLtrans);
  return;
}


x86 assembly (clang, -O0):
<dL_update_hmc2>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%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),%eax
imul   -0x2c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1218 <dL_update_hmc2+0xd8>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11fa <dL_update_hmc2+0xba>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x78(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x74(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1195 <dL_update_hmc2+0x55>
mov    -0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1182 <dL_update_hmc2+0x42>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x84(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    15d9 <dL_update_hmc2+0x499>
mov    -0x2c(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xd82(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1552 <dL_update_hmc2+0x412>
mov    -0x8(%rbp),%rax
mov    -0x7c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x7c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  0xd32(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x7c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x7c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x7c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x7c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jle    135d <dL_update_hmc2+0x21d>
mov    -0x38(%rbp),%rax
mov    -0x7c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13ed <dL_update_hmc2+0x2ad>
movsd  -0x68(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x7c(%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
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1378 <dL_update_hmc2+0x238>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1466 <dL_update_hmc2+0x326>
mov    -0x40(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x7c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    13f6 <dL_update_hmc2+0x2b6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14ba <dL_update_hmc2+0x37a>
mov    -0x38(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1474 <dL_update_hmc2+0x334>
movsd  -0x70(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    152f <dL_update_hmc2+0x3ef>
mov    -0x10(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x7c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14de <dL_update_hmc2+0x39e>
movsd  -0x70(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    129d <dL_update_hmc2+0x15d>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    159f <dL_update_hmc2+0x45f>
mov    -0x74(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1559 <dL_update_hmc2+0x419>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1240 <dL_update_hmc2+0x100>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dL_update_hmc2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r9d,%r15d
mov    %r8,0x80(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rdx,0x100(%rsp)
mov    %rsi,0x70(%rsp)
mov    %rdi,0x48(%rsp)
mov    %r9d,%edi
imul   %r9d,%edi
shl    $0x3,%edi
call   1060 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %r15d,%r13d
test   %r15d,%r15d
jle    1294 <dL_update_hmc2+0x154>
mov    %r13d,%eax
and    $0xfffffffe,%eax
mov    0x8(%rsp),%rcx
add    $0x8,%rcx
lea    0x0(,%r13,8),%rdx
mov    0x28(%rsp),%rsi
add    $0x8,%rsi
mov    %r13,%rdi
shl    $0x4,%rdi
xor    %r9d,%r9d
mov    0x48(%rsp),%r8
jmp    11f8 <dL_update_hmc2+0xb8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x80(%rsp),%rbp
movq   $0x0,0x0(%rbp,%r9,8)
add    $0x1,%r9
add    %rdx,%rcx
add    %rdx,%rsi
add    $0x8,%r8
cmp    %r13,%r9
je     1294 <dL_update_hmc2+0x154>
cmp    $0x1,%r15d
jne    1210 <dL_update_hmc2+0xd0>
xor    %ebp,%ebp
jmp    1251 <dL_update_hmc2+0x111>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,-0x8(%rsi,%rbp,8)
movsd  (%rbx),%xmm0
movsd  %xmm0,-0x8(%rcx,%rbp,8)
movq   $0x0,(%rsi,%rbp,8)
movsd  (%rbx,%rdx,1),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x2,%rbp
add    %rdi,%rbx
cmp    %rbp,%rax
jne    1220 <dL_update_hmc2+0xe0>
test   $0x1,%r13b
je     11d0 <dL_update_hmc2+0x90>
mov    %r9,%r10
imul   %r13,%r10
add    %rbp,%r10
mov    0x28(%rsp),%rbx
movq   $0x0,(%rbx,%r10,8)
imul   %r13,%rbp
add    %r9,%rbp
mov    0x48(%rsp),%rbx
movsd  (%rbx,%rbp,8),%xmm0
mov    0x8(%rsp),%rbp
movsd  %xmm0,0x0(%rbp,%r10,8)
jmp    11d0 <dL_update_hmc2+0x90>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %r15d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,%rbx
test   %r15d,%r15d
jle    19aa <dL_update_hmc2+0x86a>
lea    -0x1(%r13),%rax
mov    %rax,0x58(%rsp)
mov    %r13d,%eax
and    $0x3,%eax
mov    %rax,0x30(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x88(%rsp)
mov    0x8(%rsp),%rax
lea    0x18(%rax),%rcx
mov    %rcx,0xe0(%rsp)
lea    0x0(,%r13,8),%rbp
lea    0x8(,%r13,8),%rcx
mov    %rcx,0xf0(%rsp)
add    $0x38,%rax
mov    %rax,0xd8(%rsp)
lea    -0x5(%r13),%rax
mov    %rax,0xd0(%rsp)
mov    0x70(%rsp),%rax
add    $0x18,%rax
mov    %rax,0xc8(%rsp)
mov    %r13,%r12
shl    $0x4,%r12
mov    %r13,%rax
shl    $0x5,%rax
mov    %rax,0xb8(%rsp)
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
mov    %rax,0xb0(%rsp)
xor    %eax,%eax
mov    0x28(%rsp),%rcx
mov    %rcx,0x78(%rsp)
mov    %r15d,0x24(%rsp)
mov    %rbx,0x50(%rsp)
mov    %rbp,0xf8(%rsp)
mov    %r12,0xc0(%rsp)
jmp    13c1 <dL_update_hmc2+0x281>
nopl   0x0(%rax)
mov    0x80(%rsp),%rax
addsd  (%rax,%r9,8),%xmm8
movsd  %xmm8,(%rax,%r9,8)
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x90(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rax
add    $0x1,%rax
addq   $0x8,0x78(%rsp)
cmp    %r13,%rax
je     19aa <dL_update_hmc2+0x86a>
mov    %r15d,%edi
mov    $0x8,%esi
mov    %rax,%rbx
call   1050 <calloc@plt>
mov    %rax,%r14
mov    %r15d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    %rbx,0x38(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rdx,%rbx,8)
lea    0x18(%rdx),%r11
lea    0x18(%r14),%rcx
mov    %rdx,%r12
add    $0x38,%r12
xorpd  %xmm8,%xmm8
mov    $0x1,%eax
mov    %rax,0x10(%rsp)
mov    0x70(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0xc8(%rsp),%rdi
mov    0xd0(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0xd8(%rsp),%rbx
mov    0x8(%rsp),%rsi
mov    %rcx,%r9
mov    0xe0(%rsp),%r8
mov    0x58(%rsp),%rax
mov    %rax,0xa0(%rsp)
xor    %r10d,%r10d
movsd  0xb98(%rip),%xmm9
movapd 0xb9f(%rip),%xmm10
mov    %rdx,0x90(%rsp)
jmp    14ee <dL_update_hmc2+0x3ae>
nopl   0x0(%rax,%rax,1)
addsd  %xmm1,%xmm8
addq   $0x1,0x10(%rsp)
addq   $0xffffffffffffffff,0xa0(%rsp)
add    $0x8,%r11
mov    0xf0(%rsp),%rax
add    %rax,%r8
add    $0x8,%r9
mov    0xf8(%rsp),%rbp
add    %rbp,%rsi
mov    0x68(%rsp),%rbx
add    %rax,%rbx
add    $0x8,%r12
addq   $0xffffffffffffffff,0x98(%rsp)
add    %rbp,%rdi
add    %rbp,%r10
mov    %r10,0x60(%rsp)
mov    0xa8(%rsp),%rax
mov    %rax,%r10
cmp    %r13,%rax
mov    0x90(%rsp),%rdx
je     18d0 <dL_update_hmc2+0x790>
mov    %rbx,0x68(%rsp)
mov    %r10d,%eax
imul   %r15d,%eax
cltq
add    %r10,%rax
mov    0x48(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm3
movsd  (%rdx,%r10,8),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm9,%xmm2
test   %r10,%r10
je     1529 <dL_update_hmc2+0x3e9>
lea    -0x1(%r10),%eax
movq   $0x0,(%r14,%rax,8)
mulsd  %xmm1,%xmm2
divsd  %xmm3,%xmm2
movsd  %xmm2,(%r14,%r10,8)
lea    0x1(%r10),%rax
mov    %rax,0xa8(%rsp)
cmp    %r13,%rax
mov    0x68(%rsp),%rbx
jae    17e0 <dL_update_hmc2+0x6a0>
mov    %r10,%rax
not    %rax
mov    %rax,0x40(%rsp)
add    %r13,%rax
divsd  %xmm3,%xmm1
xorpd  %xmm10,%xmm2
divsd  %xmm3,%xmm2
mov    0x10(%rsp),%rbp
cmp    $0x4,%rax
jb     1630 <dL_update_hmc2+0x4f0>
mov    0xa0(%rsp),%rbx
and    $0xfffffffffffffffc,%rbx
mov    %rax,0x18(%rsp)
mov    %rax,%rbp
and    $0xfffffffffffffffc,%rbp
mov    0x10(%rsp),%rax
mov    %rbp,0xe8(%rsp)
add    %rax,%rbp
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%r11,%r15,8),%xmm5
movupd (%r11,%r15,8),%xmm6
movupd -0x10(%r8,%r15,8),%xmm7
movupd (%r8,%r15,8),%xmm0
mulpd  %xmm3,%xmm7
mulpd  %xmm3,%xmm0
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm0,%xmm6
movupd %xmm5,-0x10(%r9,%r15,8)
movupd %xmm6,(%r9,%r15,8)
add    $0x4,%r15
cmp    %r15,%rbx
jne    15c0 <dL_update_hmc2+0x480>
mov    0x18(%rsp),%rax
cmp    0xe8(%rsp),%rax
mov    0x24(%rsp),%r15d
mov    0x68(%rsp),%rbx
je     1655 <dL_update_hmc2+0x515>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%rdx,%rbp,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,(%r14,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1630 <dL_update_hmc2+0x4f0>
cmp    %r13,0xa8(%rsp)
jae    17e0 <dL_update_hmc2+0x6a0>
xorpd  %xmm10,%xmm1
mov    0x10(%rsp),%rbp
cmp    $0x4,%rax
jb     17c0 <dL_update_hmc2+0x680>
mov    %rax,0x18(%rsp)
mov    0x40(%rsp),%rax
lea    (%rax,%r13,1),%rbp
add    $0xfffffffffffffffc,%rbp
mov    %rbp,%rax
shr    $0x2,%rax
add    $0x1,%rax
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmp    $0x4,%rbp
mov    %rax,0x40(%rsp)
jae    16b4 <dL_update_hmc2+0x574>
xor    %r15d,%r15d
mov    0x18(%rsp),%rax
jmp    174b <dL_update_hmc2+0x60b>
mov    0x98(%rsp),%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %r15d,%r15d
mov    0x18(%rsp),%rax
movupd -0x30(%rbx,%r15,8),%xmm0
movupd -0x20(%rbx,%r15,8),%xmm3
mulpd  %xmm2,%xmm0
movupd -0x30(%r12,%r15,8),%xmm4
addpd  %xmm0,%xmm4
movupd -0x20(%r12,%r15,8),%xmm0
movupd -0x10(%r12,%r15,8),%xmm5
movupd (%r12,%r15,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm0,%xmm3
movupd %xmm4,-0x30(%r12,%r15,8)
movupd %xmm3,-0x20(%r12,%r15,8)
movupd -0x10(%rbx,%r15,8),%xmm0
movupd (%rbx,%r15,8),%xmm3
mulpd  %xmm2,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm0,-0x10(%r12,%r15,8)
movupd %xmm3,(%r12,%r15,8)
add    $0x8,%r15
add    $0xfffffffffffffffe,%rbp
jne    16d0 <dL_update_hmc2+0x590>
mov    %rax,%rbp
and    $0xfffffffffffffffc,%rbp
testb  $0x1,0x40(%rsp)
je     17a7 <dL_update_hmc2+0x667>
mov    %r10,%rax
imul   %r13,%rax
add    0x10(%rsp),%r15
movupd (%rdx,%r15,8),%xmm0
movupd 0x10(%rdx,%r15,8),%xmm3
add    %r15,%rax
mov    0x8(%rsp),%rbx
movupd (%rbx,%rax,8),%xmm4
movupd 0x10(%rbx,%rax,8),%xmm5
mov    0x18(%rsp),%rax
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%rdx,%r15,8)
movupd %xmm5,0x10(%rdx,%r15,8)
cmp    %rbp,%rax
mov    0x24(%rsp),%r15d
je     17e0 <dL_update_hmc2+0x6a0>
add    0x10(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    17c0 <dL_update_hmc2+0x680>
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
mov    %r10,%rbx
mov    0x100(%rsp),%rax
nop
movsd  (%r14,%rbx,8),%xmm0
mulsd  (%rax,%rbx,8),%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rbx
cmp    %rbx,%r13
jne    17f0 <dL_update_hmc2+0x6b0>
mov    0x50(%rsp),%rax
movsd  %xmm1,(%rax,%r10,8)
cmpq   $0x3,0x58(%rsp)
jae    1830 <dL_update_hmc2+0x6f0>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
mov    0x30(%rsp),%rdx
mov    0x60(%rsp),%r10
jmp    1897 <dL_update_hmc2+0x757>
nopl   (%rax)
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
mov    0x30(%rsp),%rdx
mov    0x88(%rsp),%rax
mov    0x60(%rsp),%r10
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rdi,%rbp,8),%xmm0
movsd  -0x10(%rdi,%rbp,8),%xmm2
mulsd  -0x18(%rcx,%rbp,8),%xmm0
mulsd  -0x10(%rcx,%rbp,8),%xmm2
addsd  %xmm1,%xmm0
movsd  -0x8(%rdi,%rbp,8),%xmm3
mulsd  -0x8(%rcx,%rbp,8),%xmm3
addsd  %xmm0,%xmm2
movsd  (%rdi,%rbp,8),%xmm1
mulsd  (%rcx,%rbp,8),%xmm1
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
add    $0x4,%rbp
cmp    %rbp,%rax
jne    1850 <dL_update_hmc2+0x710>
test   %rdx,%rdx
je     1480 <dL_update_hmc2+0x340>
lea    (%r14,%rbp,8),%rbx
lea    (%r10,%rbp,8),%rbp
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rax
cmp    %rax,%rdx
jne    18b0 <dL_update_hmc2+0x770>
jmp    1480 <dL_update_hmc2+0x340>
nopl   (%rax)
cmpq   $0x3,0x58(%rsp)
jae    18f0 <dL_update_hmc2+0x7b0>
xor    %eax,%eax
mov    0x50(%rsp),%rbx
mov    0x30(%rsp),%r8
mov    0x38(%rsp),%r9
jmp    1967 <dL_update_hmc2+0x827>
nopl   0x0(%rax,%rax,1)
mov    0x78(%rsp),%rcx
xor    %eax,%eax
mov    0x50(%rsp),%rbx
mov    0x30(%rsp),%r8
mov    0x88(%rsp),%rdx
mov    0xc0(%rsp),%r12
mov    0xb8(%rsp),%rdi
mov    0xb0(%rsp),%rsi
mov    0x38(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rcx)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,1)
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%r12,1)
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,1)
add    $0x4,%rax
add    %rdi,%rcx
cmp    %rax,%rdx
jne    1930 <dL_update_hmc2+0x7f0>
test   $0x3,%r13b
je     1380 <dL_update_hmc2+0x240>
lea    (%rbx,%rax,8),%rcx
imul   %r13,%rax
add    %r9,%rax
mov    0x28(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rax)
add    $0x1,%rdx
add    %rbp,%rax
cmp    %rdx,%r8
jne    1990 <dL_update_hmc2+0x850>
jmp    1380 <dL_update_hmc2+0x240>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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