#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double omp_get_wtime();
int sqrt(unsigned int);
double covariance() {
  extern unsigned int datasize;
  int i = 0;
  int j = 0;
  int j1 = 0;
  int j2 = 0;
  int n = sqrt((datasize / sizeof(double)) / 2);
  double *data = (double *)malloc(n * n * sizeof(double));
  double *hdata = (double *)malloc(n * n * sizeof(double));
  double *symmat = (double *)malloc(n * n * sizeof(double));
  double *hsymmat = (double *)malloc(n * n * sizeof(double));
  double *mean = (double *)malloc(n * sizeof(double));
  double *hmean = (double *)malloc(n * sizeof(double));
  double tmp = 0;
  double t_start = 0;
  double t_end = 0;
  int flag = 0;
  if (data == NULL || hdata == NULL || symmat == NULL || hsymmat == NULL ||
      mean == NULL || hmean == NULL) {
    return (-10000);
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      data[i * n + j] = i % 12 + 2 * (j % 7);
      hdata[i * n + j] = data[i * n + j];
    }
  }
  for (j = 0; j < n; j++) {
    hmean[j] = 0.0;
    for (i = 0; i < n; i++) {
      hmean[j] += hdata[i * n + j];
    }
    hmean[j] /= n;
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      hdata[i * n + j] -= hmean[j];
    }
  }
  for (j1 = 0; j1 < n; j1++) {
    for (j2 = j1; j2 < n; j2++) {
      hsymmat[j1 * n + j2] = 0.0;
      for (i = 0; i < n; i++) {
        hsymmat[j1 * n + j2] += hdata[i * n + j1] * hdata[i * n + j2];
      }
      hsymmat[j1 * n + j2] /= n - 1;
      hsymmat[j2 * n + j1] = hsymmat[j1 * n + j2];
    }
  }
  t_start = omp_get_wtime();
#pragma acc data copyin(data [0:n * n]), copyout(symmat [0:n * n]),            \
    create(mean [0:n])
  {
#pragma acc parallel loop private(tmp)
    for (j = 0; j < n; j++) {
      tmp = 0;
#pragma acc loop reduction(+ : tmp)
      for (i = 0; i < n; i++) {
        tmp += data[i * n + j];
      }
      mean[j] = tmp / n;
    }
#pragma acc parallel loop
    for (i = 0; i < n; i++) {
#pragma acc loop
      for (j = 0; j < n; j++) {
        data[i * n + j] -= mean[j];
      }
    }
#pragma acc parallel loop
    for (j1 = 0; j1 < n; j1++) {
#pragma acc loop private(tmp)
      for (j2 = j1; j2 < n; j2++) {
        tmp = 0;
#pragma acc loop reduction(+ : tmp)
        for (i = 0; i < n; i++) {
          tmp += data[i * n + j1] * data[i * n + j2];
        }
        symmat[j1 * n + j2] = tmp / (n - 1);
        symmat[j2 * n + j1] = symmat[j1 * n + j2];
      }
    }
  }
  t_end = omp_get_wtime();
  for (j1 = 0; j1 < n; j1++) {
    for (j2 = 0; j2 < n; j2++) {
      if (fabs(hsymmat[j1 * n + j2] - symmat[j1 * n + j2]) /
              hsymmat[j1 * n + j2] >
          1e-14) {
        flag = 1;
      }
    }
  }
  free(data);
  free(hdata);
  free(symmat);
  free(hsymmat);
  free(mean);
  free(hmean);
  if (flag == 0)
    return (t_end - t_start);
  else
    return (-11000);
}


x86 assembly (clang, -O0):
<covariance>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    0x2e7d(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%rax
shr    $0x1,%rax
mov    %eax,%edi
call   1060 <sqrt@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     1266 <covariance+0x126>
cmpq   $0x0,-0x30(%rbp)
je     1266 <covariance+0x126>
cmpq   $0x0,-0x38(%rbp)
je     1266 <covariance+0x126>
cmpq   $0x0,-0x40(%rbp)
je     1266 <covariance+0x126>
cmpq   $0x0,-0x48(%rbp)
je     1266 <covariance+0x126>
cmpq   $0x0,-0x50(%rbp)
jne    1278 <covariance+0x138>
movsd  0xda2(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1879 <covariance+0x739>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1328 <covariance+0x1e8>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1315 <covariance+0x1d5>
mov    -0xc(%rbp),%eax
mov    $0xc,%ecx
cltd
idiv   %ecx
mov    %edx,-0x70(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x7,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
mov    -0x70(%rbp),%edx
shl    $0x1,%eax
add    %eax,%edx
cvtsi2sd %edx,%xmm0
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1292 <covariance+0x152>
jmp    131a <covariance+0x1da>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    127f <covariance+0x13f>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13bd <covariance+0x27d>
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1394 <covariance+0x254>
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1352 <covariance+0x212>
cvtsi2sdl -0x1c(%rbp),%xmm1
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    132f <covariance+0x1ef>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1430 <covariance+0x2f0>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    141d <covariance+0x2dd>
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13d7 <covariance+0x297>
jmp    1422 <covariance+0x2e2>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13c4 <covariance+0x284>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1554 <covariance+0x414>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1541 <covariance+0x401>
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14de <covariance+0x39e>
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1475 <covariance+0x335>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1449 <covariance+0x309>
jmp    1546 <covariance+0x406>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1437 <covariance+0x2f7>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15e5 <covariance+0x4a5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15bc <covariance+0x47c>
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1582 <covariance+0x442>
movsd  -0x58(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1567 <covariance+0x427>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1658 <covariance+0x518>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1645 <covariance+0x505>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    15ff <covariance+0x4bf>
jmp    164a <covariance+0x50a>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    15ec <covariance+0x4ac>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    175a <covariance+0x61a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1747 <covariance+0x607>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16e4 <covariance+0x5a4>
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    168c <covariance+0x54c>
movsd  -0x58(%rbp),%xmm0
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1671 <covariance+0x531>
jmp    174c <covariance+0x60c>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    165f <covariance+0x51f>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1818 <covariance+0x6d8>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1805 <covariance+0x6c5>
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x861(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0x827(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    17f2 <covariance+0x6b2>
movl   $0x1,-0x6c(%rbp)
jmp    17f7 <covariance+0x6b7>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1780 <covariance+0x640>
jmp    180a <covariance+0x6ca>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    176d <covariance+0x62d>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x6c(%rbp)
jne    186c <covariance+0x72c>
movsd  -0x68(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1879 <covariance+0x739>
movsd  0x78c(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<covariance>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    0x2e90(%rip),%rax
mov    (%rax),%edi
shr    $0x4,%edi
call   1060 <sqrt@plt>
lea    0x0(,%rax,8),%ebp
mov    %ebp,%ebx
mov    %rax,0x28(%rsp)
imul   %eax,%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %ebp,%edi
call   1050 <malloc@plt>
movsd  0xe48(%rip),%xmm0
test   %r15,%r15
je     1a08 <covariance+0x8c8>
test   %r13,%r13
je     1a08 <covariance+0x8c8>
cmpq   $0x0,0x50(%rsp)
je     1a08 <covariance+0x8c8>
test   %r14,%r14
je     1a08 <covariance+0x8c8>
cmpq   $0x0,0x58(%rsp)
je     1a08 <covariance+0x8c8>
test   %rax,%rax
je     1a08 <covariance+0x8c8>
mov    %r15,(%rsp)
mov    0x28(%rsp),%r11
test   %r11d,%r11d
mov    %rax,0x70(%rsp)
jle    1998 <covariance+0x858>
mov    %r11d,%r8d
lea    -0x1(%r8),%rax
mov    %rax,0x10(%rsp)
mov    %r8d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x48(%rsp)
lea    0x10(%r13),%r10
lea    0x0(,%r8,8),%rax
mov    %rax,0x30(%rsp)
mov    (%rsp),%rdi
lea    0x10(%rdi),%rdx
and    $0xffffffffffffffe0,%rax
mov    %rax,0x40(%rsp)
mov    $0x2,%eax
mov    %rax,0x20(%rsp)
mov    $0x1,%eax
mov    %rax,0x18(%rsp)
xor    %ecx,%ecx
movdqa 0xdbd(%rip),%xmm8
movdqa 0xdc4(%rip),%xmm9
movdqa 0xdcc(%rip),%xmm2
movdqa 0xdd4(%rip),%xmm3
mov    %r13,0x60(%rsp)
mov    %r8,0x8(%rsp)
jmp    12d2 <covariance+0x192>
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rcx
add    $0x1,%rcx
mov    0x30(%rsp),%rax
add    %rax,%r10
add    %rax,%rdx
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
mov    0x8(%rsp),%r8
add    %r8,0x18(%rsp)
cmp    %r8,%rcx
mov    (%rsp),%rdi
mov    0x60(%rsp),%r13
mov    0x28(%rsp),%r11
je     158c <covariance+0x44c>
mov    %ecx,%eax
mov    $0xaaaaaaab,%esi
imul   %rsi,%rax
shr    $0x23,%rax
shl    $0x2,%eax
lea    (%rax,%rax,2),%r15d
mov    %rcx,%r9
imul   %r8,%r9
mov    %ecx,%eax
sub    %r15d,%eax
cmp    $0x4,%r11d
mov    %rcx,0x38(%rsp)
jb     1333 <covariance+0x1f3>
lea    (%r9,%r8,1),%rsi
lea    0x0(,%rsi,8),%rcx
add    %r13,%rcx
lea    (%rdi,%r9,8),%rbx
cmp    %rcx,%rbx
jae    1480 <covariance+0x340>
lea    0x0(,%r9,8),%rcx
add    %r13,%rcx
lea    (%rdi,%rsi,8),%rsi
cmp    %rsi,%rcx
jae    1480 <covariance+0x340>
xor    %ebx,%ebx
mov    %rbx,%r8
testb  $0x1,0x8(%rsp)
je     1389 <covariance+0x249>
imul   $0x24924925,%rbx,%rbp
shr    $0x20,%rbp
mov    %ebx,%esi
sub    %ebp,%esi
shr    %esi
add    %ebp,%esi
shr    $0x2,%esi
lea    0x0(,%rsi,8),%ebp
sub    %ebp,%esi
add    %ebx,%esi
lea    (%rax,%rsi,2),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
add    %rbx,%r9
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%r9,8)
mov    0x60(%rsp),%rax
movsd  %xmm0,(%rax,%r9,8)
mov    %rbx,%r8
or     $0x1,%r8
cmp    %rbx,0x10(%rsp)
je     1290 <covariance+0x150>
mov    0x8(%rsp),%rdi
sub    %r8,%rdi
mov    0x20(%rsp),%rax
lea    (%rax,%r8,2),%ebp
sub    %r15d,%ebp
lea    0x1(%r8),%esi
mov    %r8,%rbx
add    0x18(%rsp),%rbx
mov    (%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%r8,2),%r11d
sub    %r15d,%r11d
mov    0x60(%rsp),%rcx
lea    (%rcx,%rbx,8),%r9
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %esi,%ebx
imul   $0x24924925,%rbx,%rcx
shr    $0x20,%rcx
mov    %esi,%ebx
sub    %ecx,%ebx
shr    %ebx
add    %ecx,%ebx
shr    $0x2,%ebx
mov    %ebx,%ecx
shl    $0x4,%ecx
mov    %ebx,%r12d
sub    %ecx,%r12d
add    %ebx,%r12d
mov    %r8d,%ecx
imul   $0x24924925,%rcx,%rbx
shr    $0x20,%rbx
mov    %r8d,%ecx
sub    %ebx,%ecx
shr    %ecx
add    %ebx,%ecx
shr    $0x2,%ecx
mov    %ecx,%r13d
shl    $0x4,%r13d
mov    %ecx,%ebx
sub    %r13d,%ebx
add    %ecx,%ebx
add    %r11d,%ebx
add    %r15d,%ebx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
add    %ebp,%r12d
movsd  %xmm0,-0x8(%rax,%r15,4)
movsd  %xmm0,-0x8(%r9,%r15,4)
add    %r15d,%r12d
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
movsd  %xmm0,(%rax,%r15,4)
movsd  %xmm0,(%r9,%r15,4)
add    $0x2,%esi
add    $0x4,%r15
add    $0x2,%r8d
add    $0xfffffffffffffffe,%rdi
jne    13e0 <covariance+0x2a0>
jmp    1290 <covariance+0x150>
nopl   (%rax)
movd   %eax,%xmm4
pshufd $0x50,%xmm4,%xmm4
xor    %esi,%esi
movdqa %xmm8,%xmm5
mov    0x40(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm5,%xmm6
paddd  %xmm9,%xmm6
movdqa %xmm5,%xmm7
pmuludq %xmm2,%xmm7
pshufd $0xed,%xmm7,%xmm0
pshufd $0xf5,%xmm5,%xmm7
pmuludq %xmm2,%xmm7
pshufd $0xed,%xmm7,%xmm7
punpckldq %xmm7,%xmm0
movdqa %xmm5,%xmm7
psubd  %xmm0,%xmm7
psrld  $0x1,%xmm7
paddd  %xmm0,%xmm7
psrld  $0x2,%xmm7
movdqa %xmm7,%xmm0
pslld  $0x3,%xmm0
psubd  %xmm0,%xmm7
paddd  %xmm5,%xmm7
movdqa %xmm6,%xmm0
pmuludq %xmm2,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm6,%xmm1
pmuludq %xmm2,%xmm1
pshufd $0xed,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm6,%xmm1
psubd  %xmm0,%xmm1
psrld  $0x1,%xmm1
paddd  %xmm0,%xmm1
psrld  $0x2,%xmm1
movdqa %xmm1,%xmm0
pslld  $0x3,%xmm0
psubd  %xmm0,%xmm1
paddd  %xmm6,%xmm1
paddd  %xmm7,%xmm7
paddd  %xmm1,%xmm1
paddd  %xmm4,%xmm7
paddd  %xmm4,%xmm1
cvtdq2pd %xmm7,%xmm0
cvtdq2pd %xmm1,%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
movupd %xmm0,-0x10(%r10,%rsi,1)
movupd %xmm1,(%r10,%rsi,1)
paddd  %xmm3,%xmm5
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    14a0 <covariance+0x360>
mov    0x48(%rsp),%rcx
mov    %rcx,%rbx
cmp    %r8,%rcx
je     1290 <covariance+0x150>
jmp    1335 <covariance+0x1f5>
test   %r11d,%r11d
mov    0x70(%rsp),%rdx
jle    1998 <covariance+0x858>
cvtsi2sd %r11d,%xmm4
mov    %r8d,%eax
and    $0xfffffffe,%eax
mov    %r8,%r15
shl    $0x4,%r15
xor    %ecx,%ecx
mov    %r13,%rbx
jmp    15d6 <covariance+0x496>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x1,%rcx
add    $0x8,%rbx
cmp    %r8,%rcx
je     1644 <covariance+0x504>
movq   $0x0,(%rdx,%rcx,8)
cmpq   $0x0,0x10(%rsp)
je     1620 <covariance+0x4e0>
xorpd  %xmm0,%xmm0
mov    %rbx,%rdi
xor    %esi,%esi
nop
addsd  (%rdi),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
addsd  (%rdi,%r8,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x2,%rsi
add    %r15,%rdi
cmp    %rsi,%rax
jne    15f0 <covariance+0x4b0>
test   $0x1,%r8b
je     15c0 <covariance+0x480>
jmp    162c <covariance+0x4ec>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %esi,%esi
test   $0x1,%r8b
je     15c0 <covariance+0x480>
imul   %r8,%rsi
add    %rcx,%rsi
addsd  0x0(%r13,%rsi,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
jmp    15c0 <covariance+0x480>
test   %r11d,%r11d
jle    1998 <covariance+0x858>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x68(%rsp)
lea    (%rdx,%r8,8),%r9
mov    %r8d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x48(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
mov    %rcx,%r12
and    $0xfffffffffffffffe,%r12
mov    %r8,%rax
neg    %rax
mov    %rax,0x20(%rsp)
lea    0x30(%r13),%rax
lea    0x8(%r13),%rsi
xor    %ecx,%ecx
jmp    16c8 <covariance+0x588>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rcx
mov    0x30(%rsp),%rdi
add    %rdi,%rax
add    %rdi,%rsi
cmp    %r8,%rcx
je     184e <covariance+0x70e>
mov    %rcx,%r10
imul   %r8,%r10
cmp    $0x4,%r11d
jb     1703 <covariance+0x5c3>
mov    %rcx,%rdi
imul   %r8,%rdi
lea    0x0(,%rdi,8),%rbp
add    %r13,%rbp
cmp    %r9,%rbp
jae    1770 <covariance+0x630>
add    %r8,%rdi
lea    0x0(,%rdi,8),%rdi
add    %r13,%rdi
cmp    %rdi,%rdx
jae    1770 <covariance+0x630>
xor    %ebx,%ebx
mov    %rbx,%rbp
test   $0x1,%r8b
je     172b <covariance+0x5eb>
add    %rbx,%r10
movsd  0x0(%r13,%r10,8),%xmm0
subsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,0x0(%r13,%r10,8)
mov    %rbx,%rbp
or     $0x1,%rbp
not    %rbx
cmp    0x20(%rsp),%rbx
mov    0x8(%rsp),%r8
je     16b0 <covariance+0x570>
xchg   %ax,%ax
movsd  -0x8(%rsi,%rbp,8),%xmm0
subsd  (%rdx,%rbp,8),%xmm0
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm0,-0x8(%rsi,%rbp,8)
subsd  0x8(%rdx,%rbp,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r8
jne    1740 <covariance+0x600>
jmp    16b0 <covariance+0x570>
nop
cmpq   $0x0,0x48(%rsp)
je     1843 <covariance+0x703>
mov    %r12,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rdx,%rbp,8),%xmm0
movupd 0x10(%rdx,%rbp,8),%xmm1
movupd -0x30(%rax,%rbp,8),%xmm2
subpd  %xmm0,%xmm2
movupd -0x20(%rax,%rbp,8),%xmm0
subpd  %xmm1,%xmm0
movupd -0x10(%rax,%rbp,8),%xmm1
movupd (%rax,%rbp,8),%xmm3
movupd %xmm2,-0x30(%rax,%rbp,8)
movupd %xmm0,-0x20(%rax,%rbp,8)
movupd 0x20(%rdx,%rbp,8),%xmm0
subpd  %xmm0,%xmm1
movupd 0x30(%rdx,%rbp,8),%xmm0
subpd  %xmm0,%xmm3
movupd %xmm1,-0x10(%rax,%rbp,8)
movupd %xmm3,(%rax,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1790 <covariance+0x650>
testb  $0x1,0x18(%rsp)
je     1828 <covariance+0x6e8>
movupd (%rdx,%rbp,8),%xmm0
movupd 0x10(%rdx,%rbp,8),%xmm1
add    %r10,%rbp
movupd 0x0(%r13,%rbp,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%r13,%rbp,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rbp,8)
movupd %xmm0,0x10(%r13,%rbp,8)
mov    0x38(%rsp),%rdi
mov    %rdi,%rbx
mov    0x8(%rsp),%r8
cmp    %r8,%rdi
je     16b0 <covariance+0x570>
jmp    1705 <covariance+0x5c5>
xor    %ebp,%ebp
testb  $0x1,0x18(%rsp)
jne    17f6 <covariance+0x6b6>
jmp    1828 <covariance+0x6e8>
test   %r11d,%r11d
jle    1998 <covariance+0x858>
movsd  %xmm4,0x78(%rsp)
lea    -0x1(%r11),%eax
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
lea    0x0(,%r8,8),%rdi
add    %r13,%rdi
mov    %r8,%rax
xor    %r9d,%r9d
mov    %r13,%rbp
mov    0x8(%rsp),%r12
jmp    18aa <covariance+0x76a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
add    $0x8,%rdi
add    $0x8,%rbp
mov    0x8(%rsp),%rax
cmp    %rax,%r9
je     1a1a <covariance+0x8da>
mov    %r9,%r8
imul   %rax,%r8
mov    %rbp,%rsi
mov    %rdi,%rcx
mov    %r9,%r10
jmp    18eb <covariance+0x7ab>
nopl   0x0(%rax)
divsd  %xmm2,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
mov    %r10,%rax
imul   %r12,%rax
add    %r9,%rax
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%r10
add    $0x8,%rcx
add    $0x8,%rsi
cmp    %r12,%r10
je     1890 <covariance+0x750>
lea    (%r10,%r8,1),%rbx
movq   $0x0,(%r14,%rbx,8)
cmpq   $0x0,0x10(%rsp)
je     1960 <covariance+0x820>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,1),%xmm1
mulsd  (%rsi,%rax,1),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rbx,8)
movsd  (%rdi,%rax,1),%xmm0
mulsd  (%rcx,%rax,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
add    $0x2,%rdx
add    %r15,%rax
cmp    %rdx,%r11
jne    1910 <covariance+0x7d0>
test   $0x1,%r12b
je     18c0 <covariance+0x780>
jmp    1970 <covariance+0x830>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %edx,%edx
test   $0x1,%r12b
je     18c0 <covariance+0x780>
imul   %r12,%rdx
lea    (%rdx,%r9,1),%rax
movsd  0x0(%r13,%rax,8),%xmm1
add    %r10,%rdx
mulsd  0x0(%r13,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
jmp    18c0 <covariance+0x780>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x40(%rsp)
mov    (%rsp),%r15
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x10(%rsp)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
test   %ebx,%ebx
je     19fc <covariance+0x8bc>
movsd  0x616(%rip),%xmm0
jmp    1a08 <covariance+0x8c8>
movsd  0x10(%rsp),%xmm0
subsd  0x40(%rsp),%xmm0
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movsd  %xmm2,0x80(%rsp)
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
mov    0x28(%rsp),%r11
test   %r11d,%r11d
movsd  %xmm0,0x40(%rsp)
jle    19a5 <covariance+0x865>
mov    0x8(%rsp),%rcx
mov    %ecx,%r8d
and    $0x3,%r8d
mov    %rcx,%rbx
shl    $0x5,%rbx
mov    0x30(%rsp),%rax
lea    (%rax,%rax,2),%rdx
xor    %r12d,%r12d
mov    (%rsp),%r9
mov    0x58(%rsp),%r10
movq   0x80(%rsp),%xmm4
movsd  0x78(%rsp),%xmm2
mov    0x30(%rsp),%rsi
jmp    1a97 <covariance+0x957>
nopl   0x0(%rax)
divsd  %xmm2,%xmm1
movsd  %xmm1,(%r10,%r12,8)
add    $0x1,%r12
add    $0x8,%r9
cmp    %rcx,%r12
je     1b12 <covariance+0x9d2>
cmpq   $0x3,0x10(%rsp)
mov    0x38(%rsp),%rax
xorpd  %xmm1,%xmm1
jae    1ab0 <covariance+0x970>
xor    %ebp,%ebp
jmp    1ae0 <covariance+0x9a0>
nopl   0x0(%rax)
mov    %r9,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
addsd  (%rdi),%xmm1
addsd  (%rdi,%rcx,8),%xmm1
addsd  (%rdi,%r15,1),%xmm1
addsd  (%rdi,%rdx,1),%xmm1
add    $0x4,%rbp
add    %rbx,%rdi
cmp    %rbp,%rax
jne    1ac0 <covariance+0x980>
test   %r8,%r8
je     1a80 <covariance+0x940>
imul   %rcx,%rbp
add    %r12,%rbp
mov    (%rsp),%rax
lea    (%rax,%rbp,8),%rdi
mov    %r8,%rax
nopw   0x0(%rax,%rax,1)
addsd  (%rdi),%xmm1
add    %rsi,%rdi
add    $0xffffffffffffffff,%rax
jne    1b00 <covariance+0x9c0>
jmp    1a80 <covariance+0x940>
test   %r11d,%r11d
jle    19a5 <covariance+0x865>
lea    (%r10,%rcx,8),%r8
mov    %rcx,%rbx
mov    %ebx,%r9d
and    $0xfffffffc,%r9d
mov    0x18(%rsp),%rax
and    %rax,0x68(%rsp)
mov    (%rsp),%rax
lea    0x30(%rax),%rdx
lea    0x8(%rax),%rsi
xor    %edi,%edi
jmp    1b68 <covariance+0xa28>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdi
mov    0x30(%rsp),%rax
add    %rax,%rdx
add    %rax,%rsi
cmp    %rbx,%rdi
je     1cfd <covariance+0xbbd>
mov    %rdi,%r12
imul   %rbx,%r12
cmp    $0x4,%r11d
jb     1b9d <covariance+0xa5d>
mov    %rdi,%rcx
imul   %rbx,%rcx
mov    (%rsp),%rax
lea    (%rax,%rcx,8),%rbp
cmp    %r8,%rbp
jae    1c20 <covariance+0xae0>
add    %rbx,%rcx
lea    (%rax,%rcx,8),%rcx
cmp    %rcx,%r10
jae    1c20 <covariance+0xae0>
xor    %ecx,%ecx
mov    %rcx,%rbp
test   $0x1,%bl
je     1bc7 <covariance+0xa87>
add    %rcx,%r12
mov    (%rsp),%rax
movsd  (%rax,%r12,8),%xmm0
subsd  (%r10,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%r12,8)
mov    %rcx,%rbp
or     $0x1,%rbp
not    %rcx
cmp    0x20(%rsp),%rcx
mov    0x8(%rsp),%rbx
je     1b50 <covariance+0xa10>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rbp,8),%xmm0
subsd  (%r10,%rbp,8),%xmm0
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm0,-0x8(%rsi,%rbp,8)
subsd  0x8(%r10,%rbp,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rbx
jne    1be0 <covariance+0xaa0>
jmp    1b50 <covariance+0xa10>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x48(%rsp)
je     1cf2 <covariance+0xbb2>
mov    0x68(%rsp),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r10,%rbp,8),%xmm0
movupd 0x10(%r10,%rbp,8),%xmm1
movupd -0x30(%rdx,%rbp,8),%xmm2
subpd  %xmm0,%xmm2
movupd -0x20(%rdx,%rbp,8),%xmm0
subpd  %xmm1,%xmm0
movupd -0x10(%rdx,%rbp,8),%xmm1
movupd (%rdx,%rbp,8),%xmm3
movupd %xmm2,-0x30(%rdx,%rbp,8)
movupd %xmm0,-0x20(%rdx,%rbp,8)
movupd 0x20(%r10,%rbp,8),%xmm0
subpd  %xmm0,%xmm1
movupd 0x30(%r10,%rbp,8),%xmm0
subpd  %xmm0,%xmm3
movupd %xmm1,-0x10(%rdx,%rbp,8)
movupd %xmm3,(%rdx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1c40 <covariance+0xb00>
testb  $0x1,0x18(%rsp)
je     1cdc <covariance+0xb9c>
movupd (%r10,%rbp,8),%xmm0
movupd 0x10(%r10,%rbp,8),%xmm1
add    %r12,%rbp
mov    (%rsp),%rax
movupd (%rax,%rbp,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbp,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%rax,%rbp,8)
movupd %xmm0,0x10(%rax,%rbp,8)
mov    %r9,%rcx
mov    0x8(%rsp),%rbx
cmp    %rbx,%r9
je     1b50 <covariance+0xa10>
jmp    1b9f <covariance+0xa5f>
xor    %ebp,%ebp
testb  $0x1,0x18(%rsp)
jne    1caa <covariance+0xb6a>
jmp    1cdc <covariance+0xb9c>
test   %r11d,%r11d
jle    19a5 <covariance+0x865>
mov    0x8(%rsp),%rcx
mov    %ecx,%eax
and    $0xfffffffe,%eax
mov    (%rsp),%rbp
lea    0x0(,%rcx,8),%rdi
add    %rbp,%rdi
xor    %r9d,%r9d
mov    0x8(%rsp),%r11
mov    (%rsp),%r12
jmp    1d4a <covariance+0xc0a>
nopl   (%rax)
add    $0x1,%r9
add    $0x8,%rdi
add    $0x8,%rbp
mov    0x8(%rsp),%rcx
cmp    %rcx,%r9
je     1e20 <covariance+0xce0>
mov    %r9,%r8
imul   %rcx,%r8
mov    %rbp,%rsi
mov    %rdi,%rcx
mov    %r9,%r10
jmp    1d92 <covariance+0xc52>
nopl   0x0(%rax)
divsd  %xmm4,%xmm0
lea    (%r10,%r8,1),%rdx
mov    0x50(%rsp),%rbx
movsd  %xmm0,(%rbx,%rdx,8)
mov    %r10,%rdx
imul   %r11,%rdx
add    %r9,%rdx
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%r10
add    $0x8,%rcx
add    $0x8,%rsi
cmp    %r11,%r10
je     1d30 <covariance+0xbf0>
cmpq   $0x0,0x10(%rsp)
je     1df0 <covariance+0xcb0>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rdx,1),%xmm1
mulsd  (%rsi,%rdx,1),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdi,%rdx,1),%xmm0
mulsd  (%rcx,%rdx,1),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rbx
add    %r15,%rdx
cmp    %rbx,%rax
jne    1db0 <covariance+0xc70>
test   $0x1,%r11b
je     1d60 <covariance+0xc20>
jmp    1e00 <covariance+0xcc0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
test   $0x1,%r11b
je     1d60 <covariance+0xc20>
imul   %r11,%rbx
lea    (%rbx,%r9,1),%rdx
movsd  (%r12,%rdx,8),%xmm1
add    %r10,%rbx
mulsd  (%r12,%rbx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1d60 <covariance+0xc20>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x10(%rsp)
cmpl   $0x0,0x28(%rsp)
jle    1fcd <covariance+0xe8d>
mov    0x8(%rsp),%rdx
mov    %edx,%r12d
and    $0xfffffffc,%r12d
mov    0x50(%rsp),%rax
mov    %rax,%rcx
add    $0x10,%rcx
lea    0x0(,%rdx,8),%r8
mov    %r14,%rsi
add    $0x10,%rsi
mov    %r8,%r9
and    $0xffffffffffffffe0,%r9
xor    %r10d,%r10d
movapd 0x1ed(%rip),%xmm0
movsd  0x18c(%rip),%xmm9
mov    $0x1,%r11d
movapd 0x1e5(%rip),%xmm11
movaps 0x1ed(%rip),%xmm10
mov    %r14,%rdx
xor    %ebx,%ebx
mov    (%rsp),%r15
jmp    1eb9 <covariance+0xd79>
xchg   %ax,%ax
add    $0x1,%r10
add    %r8,%rcx
add    %r8,%rsi
add    %r8,%rdx
add    %r8,%rax
cmp    %rdi,%r10
je     19b8 <covariance+0x878>
cmpl   $0x4,0x28(%rsp)
jae    1ecc <covariance+0xd8c>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdi
jmp    1fa0 <covariance+0xe60>
movd   %ebx,%xmm8
pshufd $0x50,%xmm8,%xmm4
xor    %ebp,%ebp
movdqa %xmm4,%xmm6
nopl   (%rax)
movupd -0x10(%rsi,%rbp,1),%xmm2
movupd (%rsi,%rbp,1),%xmm5
movupd -0x10(%rcx,%rbp,1),%xmm1
movupd (%rcx,%rbp,1),%xmm3
movapd %xmm2,%xmm7
subpd  %xmm1,%xmm7
movapd %xmm5,%xmm1
subpd  %xmm3,%xmm1
andpd  %xmm0,%xmm7
andpd  %xmm0,%xmm1
divpd  %xmm2,%xmm7
divpd  %xmm5,%xmm1
movapd %xmm11,%xmm2
cmpltpd %xmm7,%xmm2
shufps $0xe8,%xmm2,%xmm2
movapd %xmm11,%xmm3
cmpltpd %xmm1,%xmm3
shufps $0xe8,%xmm3,%xmm3
movaps %xmm2,%xmm1
andnps %xmm4,%xmm1
andps  %xmm10,%xmm2
movaps %xmm2,%xmm4
orps   %xmm1,%xmm4
movaps %xmm3,%xmm1
andnps %xmm6,%xmm1
andps  %xmm10,%xmm3
movaps %xmm3,%xmm6
orps   %xmm1,%xmm6
add    $0x20,%rbp
cmp    %rbp,%r9
jne    1ee0 <covariance+0xda0>
pshufd $0x50,%xmm8,%xmm1
movaps %xmm4,%xmm2
pcmpeqd %xmm1,%xmm2
andps  %xmm2,%xmm6
andnps %xmm4,%xmm2
orps   %xmm6,%xmm2
movq   %xmm2,%r15
movq   %xmm1,%rbp
cmp    %rbp,%r15
cmovne %r11d,%ebx
mov    %r12,%rbp
mov    0x8(%rsp),%rdi
cmp    %rdi,%r12
mov    (%rsp),%r15
je     1ea0 <covariance+0xd60>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rbp,8),%xmm1
movapd %xmm1,%xmm2
subsd  (%rax,%rbp,8),%xmm2
andpd  %xmm0,%xmm2
divsd  %xmm1,%xmm2
ucomisd %xmm9,%xmm2
cmova  %r11d,%ebx
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    1fa0 <covariance+0xe60>
jmp    1ea0 <covariance+0xd60>
mov    (%rsp),%r15
jmp    19b8 <covariance+0x878>

LLVM IR (-O0):
@datasize = external global i32
define double @covariance() {
%1 = alloca double
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca i32
store i32 0, i32* %2
store i32 0, i32* %3
store i32 0, i32* %4
store i32 0, i32* %5
%17 = load i32, i32* @datasize
%18 = zext i32 %17 to i64
%19 = udiv i64 %18, 8
%20 = udiv i64 %19, 2
%21 = trunc i64 %20 to i32
%22 = call i32 @sqrt(i32 %21)
store i32 %22, i32* %6
%23 = load i32, i32* %6
%24 = load i32, i32* %6
%25 = mul nsw i32 %23, %24
%26 = sext i32 %25 to i64
%27 = mul i64 %26, 8
%28 = trunc i64 %27 to i32
%29 = call i64 @malloc(i32 %28)
%30 = inttoptr i64 %29 to double*
store double* %30, double** %7
%31 = load i32, i32* %6
%32 = load i32, i32* %6
%33 = mul nsw i32 %31, %32
%34 = sext i32 %33 to i64
%35 = mul i64 %34, 8
%36 = trunc i64 %35 to i32
%37 = call i64 @malloc(i32 %36)
%38 = inttoptr i64 %37 to double*
store double* %38, double** %8
%39 = load i32, i32* %6
%40 = load i32, i32* %6
%41 = mul nsw i32 %39, %40
%42 = sext i32 %41 to i64
%43 = mul i64 %42, 8
%44 = trunc i64 %43 to i32
%45 = call i64 @malloc(i32 %44)
%46 = inttoptr i64 %45 to double*
store double* %46, double** %9
%47 = load i32, i32* %6
%48 = load i32, i32* %6
%49 = mul nsw i32 %47, %48
%50 = sext i32 %49 to i64
%51 = mul i64 %50, 8
%52 = trunc i64 %51 to i32
%53 = call i64 @malloc(i32 %52)
%54 = inttoptr i64 %53 to double*
store double* %54, double** %10
%55 = load i32, i32* %6
%56 = sext i32 %55 to i64
%57 = mul i64 %56, 8
%58 = trunc i64 %57 to i32
%59 = call i64 @malloc(i32 %58)
%60 = inttoptr i64 %59 to double*
store double* %60, double** %11
%61 = load i32, i32* %6
%62 = sext i32 %61 to i64
%63 = mul i64 %62, 8
%64 = trunc i64 %63 to i32
%65 = call i64 @malloc(i32 %64)
%66 = inttoptr i64 %65 to double*
store double* %66, double** %12
store double 0.000000e+00, double* %13
store double 0.000000e+00, double* %14
store double 0.000000e+00, double* %15
store i32 0, i32* %16
%67 = load double*, double** %7
%68 = icmp eq double* %67, null
br i1 %68, label %84, label %69
69: ; preds = %0
%70 = load double*, double** %8
%71 = icmp eq double* %70, null
br i1 %71, label %84, label %72
72: ; preds = %69
%73 = load double*, double** %9
%74 = icmp eq double* %73, null
br i1 %74, label %84, label %75
75: ; preds = %72
%76 = load double*, double** %10
%77 = icmp eq double* %76, null
br i1 %77, label %84, label %78
78: ; preds = %75
%79 = load double*, double** %11
%80 = icmp eq double* %79, null
br i1 %80, label %84, label %81
81: ; preds = %78
%82 = load double*, double** %12
%83 = icmp eq double* %82, null
br i1 %83, label %84, label %85
84: ; preds = %81, %78, %75, %72, %69, %0
store double -1.000000e+04, double* %1
br label %528
85: ; preds = %81
store i32 0, i32* %2
br label %86
86: ; preds = %132, %85
%87 = load i32, i32* %2
%88 = load i32, i32* %6
%89 = icmp slt i32 %87, %88
br i1 %89, label %90, label %135
90: ; preds = %86
store i32 0, i32* %3
br label %91
91: ; preds = %128, %90
%92 = load i32, i32* %3
%93 = load i32, i32* %6
%94 = icmp slt i32 %92, %93
br i1 %94, label %95, label %131
95: ; preds = %91
%96 = load i32, i32* %2
%97 = srem i32 %96, 12
%98 = load i32, i32* %3
%99 = srem i32 %98, 7
%100 = mul nsw i32 2, %99
%101 = add nsw i32 %97, %100
%102 = sitofp i32 %101 to double
%103 = load double*, double** %7
%104 = load i32, i32* %2
%105 = load i32, i32* %6
%106 = mul nsw i32 %104, %105
%107 = load i32, i32* %3
%108 = add nsw i32 %106, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %103, i64 %109
store double %102, double* %110
%111 = load double*, double** %7
%112 = load i32, i32* %2
%113 = load i32, i32* %6
%114 = mul nsw i32 %112, %113
%115 = load i32, i32* %3
%116 = add nsw i32 %114, %115
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %111, i64 %117
%119 = load double, double* %118
%120 = load double*, double** %8
%121 = load i32, i32* %2
%122 = load i32, i32* %6
%123 = mul nsw i32 %121, %122
%124 = load i32, i32* %3
%125 = add nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %120, i64 %126
store double %119, double* %127
br label %128
128: ; preds = %95
%129 = load i32, i32* %3
%130 = add nsw i32 %129, 1
store i32 %130, i32* %3
br label %91
131: ; preds = %91
br label %132
132: ; preds = %131
%133 = load i32, i32* %2
%134 = add nsw i32 %133, 1
store i32 %134, i32* %2
br label %86
135: ; preds = %86
store i32 0, i32* %3
br label %136
136: ; preds = %177, %135
%137 = load i32, i32* %3
%138 = load i32, i32* %6
%139 = icmp slt i32 %137, %138
br i1 %139, label %140, label %180
140: ; preds = %136
%141 = load double*, double** %12
%142 = load i32, i32* %3
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
store double 0.000000e+00, double* %144
store i32 0, i32* %2
br label %145
145: ; preds = %165, %140
%146 = load i32, i32* %2
%147 = load i32, i32* %6
%148 = icmp slt i32 %146, %147
br i1 %148, label %149, label %168
149: ; preds = %145
%150 = load double*, double** %8
%151 = load i32, i32* %2
%152 = load i32, i32* %6
%153 = mul nsw i32 %151, %152
%154 = load i32, i32* %3
%155 = add nsw i32 %153, %154
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double, double* %150, i64 %156
%158 = load double, double* %157
%159 = load double*, double** %12
%160 = load i32, i32* %3
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %159, i64 %161
%163 = load double, double* %162
%164 = fadd double %163, %158
store double %164, double* %162
br label %165
165: ; preds = %149
%166 = load i32, i32* %2
%167 = add nsw i32 %166, 1
store i32 %167, i32* %2
br label %145
168: ; preds = %145
%169 = load i32, i32* %6
%170 = sitofp i32 %169 to double
%171 = load double*, double** %12
%172 = load i32, i32* %3
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %171, i64 %173
%175 = load double, double* %174
%176 = fdiv double %175, %170
store double %176, double* %174
br label %177
177: ; preds = %168
%178 = load i32, i32* %3
%179 = add nsw i32 %178, 1
store i32 %179, i32* %3
br label %136
180: ; preds = %136
store i32 0, i32* %2
br label %181
181: ; preds = %210, %180
%182 = load i32, i32* %2
%183 = load i32, i32* %6
%184 = icmp slt i32 %182, %183
br i1 %184, label %185, label %213
185: ; preds = %181
store i32 0, i32* %3
br label %186
186: ; preds = %206, %185
%187 = load i32, i32* %3
%188 = load i32, i32* %6
%189 = icmp slt i32 %187, %188
br i1 %189, label %190, label %209
190: ; preds = %186
%191 = load double*, double** %12
%192 = load i32, i32* %3
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
%195 = load double, double* %194
%196 = load double*, double** %8
%197 = load i32, i32* %2
%198 = load i32, i32* %6
%199 = mul nsw i32 %197, %198
%200 = load i32, i32* %3
%201 = add nsw i32 %199, %200
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %196, i64 %202
%204 = load double, double* %203
%205 = fsub double %204, %195
store double %205, double* %203
br label %206
206: ; preds = %190
%207 = load i32, i32* %3
%208 = add nsw i32 %207, 1
store i32 %208, i32* %3
br label %186
209: ; preds = %186
br label %210
210: ; preds = %209
%211 = load i32, i32* %2
%212 = add nsw i32 %211, 1
store i32 %212, i32* %2
br label %181
213: ; preds = %181
store i32 0, i32* %4
br label %214
214: ; preds = %304, %213
%215 = load i32, i32* %4
%216 = load i32, i32* %6
%217 = icmp slt i32 %215, %216
br i1 %217, label %218, label %307
218: ; preds = %214
%219 = load i32, i32* %4
store i32 %219, i32* %5
br label %220
220: ; preds = %300, %218
%221 = load i32, i32* %5
%222 = load i32, i32* %6
%223 = icmp slt i32 %221, %222
br i1 %223, label %224, label %303
224: ; preds = %220
%225 = load double*, double** %10
%226 = load i32, i32* %4
%227 = load i32, i32* %6
%228 = mul nsw i32 %226, %227
%229 = load i32, i32* %5
%230 = add nsw i32 %228, %229
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %225, i64 %231
store double 0.000000e+00, double* %232
store i32 0, i32* %2
br label %233
233: ; preds = %266, %224
%234 = load i32, i32* %2
%235 = load i32, i32* %6
%236 = icmp slt i32 %234, %235
br i1 %236, label %237, label %269
237: ; preds = %233
%238 = load double*, double** %8
%239 = load i32, i32* %2
%240 = load i32, i32* %6
%241 = mul nsw i32 %239, %240
%242 = load i32, i32* %4
%243 = add nsw i32 %241, %242
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds double, double* %238, i64 %244
%246 = load double, double* %245
%247 = load double*, double** %8
%248 = load i32, i32* %2
%249 = load i32, i32* %6
%250 = mul nsw i32 %248, %249
%251 = load i32, i32* %5
%252 = add nsw i32 %250, %251
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %247, i64 %253
%255 = load double, double* %254
%256 = load double*, double** %10
%257 = load i32, i32* %4
%258 = load i32, i32* %6
%259 = mul nsw i32 %257, %258
%260 = load i32, i32* %5
%261 = add nsw i32 %259, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %256, i64 %262
%264 = load double, double* %263
%265 = call double @llvm.fmuladd.f64(double %246, double %255, double %264)
store double %265, double* %263
br label %266
266: ; preds = %237
%267 = load i32, i32* %2
%268 = add nsw i32 %267, 1
store i32 %268, i32* %2
br label %233
269: ; preds = %233
%270 = load i32, i32* %6
%271 = sub nsw i32 %270, 1
%272 = sitofp i32 %271 to double
%273 = load double*, double** %10
%274 = load i32, i32* %4
%275 = load i32, i32* %6
%276 = mul nsw i32 %274, %275
%277 = load i32, i32* %5
%278 = add nsw i32 %276, %277
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double, double* %273, i64 %279
%281 = load double, double* %280
%282 = fdiv double %281, %272
store double %282, double* %280
%283 = load double*, double** %10
%284 = load i32, i32* %4
%285 = load i32, i32* %6
%286 = mul nsw i32 %284, %285
%287 = load i32, i32* %5
%288 = add nsw i32 %286, %287
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %283, i64 %289
%291 = load double, double* %290
%292 = load double*, double** %10
%293 = load i32, i32* %5
%294 = load i32, i32* %6
%295 = mul nsw i32 %293, %294
%296 = load i32, i32* %4
%297 = add nsw i32 %295, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %292, i64 %298
store double %291, double* %299
br label %300
300: ; preds = %269
%301 = load i32, i32* %5
%302 = add nsw i32 %301, 1
store i32 %302, i32* %5
br label %220
303: ; preds = %220
br label %304
304: ; preds = %303
%305 = load i32, i32* %4
%306 = add nsw i32 %305, 1
store i32 %306, i32* %4
br label %214
307: ; preds = %214
%308 = call double (...) @omp_get_wtime()
store double %308, double* %14
store i32 0, i32* %3
br label %309
309: ; preds = %342, %307
%310 = load i32, i32* %3
%311 = load i32, i32* %6
%312 = icmp slt i32 %310, %311
br i1 %312, label %313, label %345
313: ; preds = %309
store double 0.000000e+00, double* %13
store i32 0, i32* %2
br label %314
314: ; preds = %330, %313
%315 = load i32, i32* %2
%316 = load i32, i32* %6
%317 = icmp slt i32 %315, %316
br i1 %317, label %318, label %333
318: ; preds = %314
%319 = load double*, double** %7
%320 = load i32, i32* %2
%321 = load i32, i32* %6
%322 = mul nsw i32 %320, %321
%323 = load i32, i32* %3
%324 = add nsw i32 %322, %323
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %319, i64 %325
%327 = load double, double* %326
%328 = load double, double* %13
%329 = fadd double %328, %327
store double %329, double* %13
br label %330
330: ; preds = %318
%331 = load i32, i32* %2
%332 = add nsw i32 %331, 1
store i32 %332, i32* %2
br label %314
333: ; preds = %314
%334 = load double, double* %13
%335 = load i32, i32* %6
%336 = sitofp i32 %335 to double
%337 = fdiv double %334, %336
%338 = load double*, double** %11
%339 = load i32, i32* %3
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds double, double* %338, i64 %340
store double %337, double* %341
br label %342
342: ; preds = %333
%343 = load i32, i32* %3
%344 = add nsw i32 %343, 1
store i32 %344, i32* %3
br label %309
345: ; preds = %309
store i32 0, i32* %2
br label %346
346: ; preds = %375, %345
%347 = load i32, i32* %2
%348 = load i32, i32* %6
%349 = icmp slt i32 %347, %348
br i1 %349, label %350, label %378
350: ; preds = %346
store i32 0, i32* %3
br label %351
351: ; preds = %371, %350
%352 = load i32, i32* %3
%353 = load i32, i32* %6
%354 = icmp slt i32 %352, %353
br i1 %354, label %355, label %374
355: ; preds = %351
%356 = load double*, double** %11
%357 = load i32, i32* %3
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %356, i64 %358
%360 = load double, double* %359
%361 = load double*, double** %7
%362 = load i32, i32* %2
%363 = load i32, i32* %6
%364 = mul nsw i32 %362, %363
%365 = load i32, i32* %3
%366 = add nsw i32 %364, %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %361, i64 %367
%369 = load double, double* %368
%370 = fsub double %369, %360
store double %370, double* %368
br label %371
371: ; preds = %355
%372 = load i32, i32* %3
%373 = add nsw i32 %372, 1
store i32 %373, i32* %3
br label %351
374: ; preds = %351
br label %375
375: ; preds = %374
%376 = load i32, i32* %2
%377 = add nsw i32 %376, 1
store i32 %377, i32* %2
br label %346
378: ; preds = %346
store i32 0, i32* %4
br label %379
379: ; preds = %453, %378
%380 = load i32, i32* %4
%381 = load i32, i32* %6
%382 = icmp slt i32 %380, %381
br i1 %382, label %383, label %456
383: ; preds = %379
%384 = load i32, i32* %4
store i32 %384, i32* %5
br label %385
385: ; preds = %449, %383
%386 = load i32, i32* %5
%387 = load i32, i32* %6
%388 = icmp slt i32 %386, %387
br i1 %388, label %389, label %452
389: ; preds = %385
store double 0.000000e+00, double* %13
store i32 0, i32* %2
br label %390
390: ; preds = %415, %389
%391 = load i32, i32* %2
%392 = load i32, i32* %6
%393 = icmp slt i32 %391, %392
br i1 %393, label %394, label %418
394: ; preds = %390
%395 = load double*, double** %7
%396 = load i32, i32* %2
%397 = load i32, i32* %6
%398 = mul nsw i32 %396, %397
%399 = load i32, i32* %4
%400 = add nsw i32 %398, %399
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %395, i64 %401
%403 = load double, double* %402
%404 = load double*, double** %7
%405 = load i32, i32* %2
%406 = load i32, i32* %6
%407 = mul nsw i32 %405, %406
%408 = load i32, i32* %5
%409 = add nsw i32 %407, %408
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds double, double* %404, i64 %410
%412 = load double, double* %411
%413 = load double, double* %13
%414 = call double @llvm.fmuladd.f64(double %403, double %412, double %413)
store double %414, double* %13
br label %415
415: ; preds = %394
%416 = load i32, i32* %2
%417 = add nsw i32 %416, 1
store i32 %417, i32* %2
br label %390
418: ; preds = %390
%419 = load double, double* %13
%420 = load i32, i32* %6
%421 = sub nsw i32 %420, 1
%422 = sitofp i32 %421 to double
%423 = fdiv double %419, %422
%424 = load double*, double** %9
%425 = load i32, i32* %4
%426 = load i32, i32* %6
%427 = mul nsw i32 %425, %426
%428 = load i32, i32* %5
%429 = add nsw i32 %427, %428
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds double, double* %424, i64 %430
store double %423, double* %431
%432 = load double*, double** %9
%433 = load i32, i32* %4
%434 = load i32, i32* %6
%435 = mul nsw i32 %433, %434
%436 = load i32, i32* %5
%437 = add nsw i32 %435, %436
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds double, double* %432, i64 %438
%440 = load double, double* %439
%441 = load double*, double** %9
%442 = load i32, i32* %5
%443 = load i32, i32* %6
%444 = mul nsw i32 %442, %443
%445 = load i32, i32* %4
%446 = add nsw i32 %444, %445
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double, double* %441, i64 %447
store double %440, double* %448
br label %449
449: ; preds = %418
%450 = load i32, i32* %5
%451 = add nsw i32 %450, 1
store i32 %451, i32* %5
br label %385
452: ; preds = %385
br label %453
453: ; preds = %452
%454 = load i32, i32* %4
%455 = add nsw i32 %454, 1
store i32 %455, i32* %4
br label %379
456: ; preds = %379
%457 = call double (...) @omp_get_wtime()
store double %457, double* %15
store i32 0, i32* %4
br label %458
458: ; preds = %505, %456
%459 = load i32, i32* %4
%460 = load i32, i32* %6
%461 = icmp slt i32 %459, %460
br i1 %461, label %462, label %508
462: ; preds = %458
store i32 0, i32* %5
br label %463
463: ; preds = %501, %462
%464 = load i32, i32* %5
%465 = load i32, i32* %6
%466 = icmp slt i32 %464, %465
br i1 %466, label %467, label %504
467: ; preds = %463
%468 = load double*, double** %10
%469 = load i32, i32* %4
%470 = load i32, i32* %6
%471 = mul nsw i32 %469, %470
%472 = load i32, i32* %5
%473 = add nsw i32 %471, %472
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double, double* %468, i64 %474
%476 = load double, double* %475
%477 = load double*, double** %9
%478 = load i32, i32* %4
%479 = load i32, i32* %6
%480 = mul nsw i32 %478, %479
%481 = load i32, i32* %5
%482 = add nsw i32 %480, %481
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %477, i64 %483
%485 = load double, double* %484
%486 = fsub double %476, %485
%487 = call double @llvm.fabs.f64(double %486)
%488 = load double*, double** %10
%489 = load i32, i32* %4
%490 = load i32, i32* %6
%491 = mul nsw i32 %489, %490
%492 = load i32, i32* %5
%493 = add nsw i32 %491, %492
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds double, double* %488, i64 %494
%496 = load double, double* %495
%497 = fdiv double %487, %496
%498 = fcmp ogt double %497, 0x3D06849B86A12B9B
br i1 %498, label %499, label %500
499: ; preds = %467
store i32 1, i32* %16
br label %500
500: ; preds = %499, %467
br label %501
501: ; preds = %500
%502 = load i32, i32* %5
%503 = add nsw i32 %502, 1
store i32 %503, i32* %5
br label %463
504: ; preds = %463
br label %505
505: ; preds = %504
%506 = load i32, i32* %4
%507 = add nsw i32 %506, 1
store i32 %507, i32* %4
br label %458
508: ; preds = %458
%509 = load double*, double** %7
%510 = call i32 @free(double* %509)
%511 = load double*, double** %8
%512 = call i32 @free(double* %511)
%513 = load double*, double** %9
%514 = call i32 @free(double* %513)
%515 = load double*, double** %10
%516 = call i32 @free(double* %515)
%517 = load double*, double** %11
%518 = call i32 @free(double* %517)
%519 = load double*, double** %12
%520 = call i32 @free(double* %519)
%521 = load i32, i32* %16
%522 = icmp eq i32 %521, 0
br i1 %522, label %523, label %527
523: ; preds = %508
%524 = load double, double* %15
%525 = load double, double* %14
%526 = fsub double %524, %525
store double %526, double* %1
br label %528
527: ; preds = %508
store double -1.100000e+04, double* %1
br label %528
528: ; preds = %527, %523, %84
%529 = load double, double* %1
ret double %529
}

LLVM IR (-O2):
@datasize = external global i32
define double @covariance() {
%1 = load i32, i32* @datasize
%2 = lshr i32 %1, 4
%3 = tail call i32 @sqrt(i32 %2)
%4 = shl i32 %3, 3
%5 = mul i32 %4, %3
%6 = tail call i64 @malloc(i32 %5)
%7 = inttoptr i64 %6 to double*
%8 = tail call i64 @malloc(i32 %5)
%9 = inttoptr i64 %8 to double*
%10 = tail call i64 @malloc(i32 %5)
%11 = inttoptr i64 %10 to double*
%12 = tail call i64 @malloc(i32 %5)
%13 = inttoptr i64 %12 to double*
%14 = tail call i64 @malloc(i32 %4)
%15 = inttoptr i64 %14 to double*
%16 = inttoptr i64 %14 to i8*
%17 = tail call i64 @malloc(i32 %4)
%18 = inttoptr i64 %17 to double*
%19 = inttoptr i64 %17 to i8*
%20 = icmp eq i64 %6, 0
%21 = icmp eq i64 %8, 0
%22 = select i1 %20, i1 true, i1 %21
%23 = icmp eq i64 %10, 0
%24 = select i1 %22, i1 true, i1 %23
%25 = icmp eq i64 %12, 0
%26 = select i1 %24, i1 true, i1 %25
%27 = icmp eq i64 %14, 0
%28 = select i1 %26, i1 true, i1 %27
%29 = icmp eq i64 %17, 0
%30 = select i1 %28, i1 true, i1 %29
br i1 %30, label %712, label %31
31: ; preds = %0
%32 = icmp sgt i32 %3, 0
br i1 %32, label %33, label %364
33: ; preds = %31
%34 = zext i32 %3 to i64
%35 = zext i32 %3 to i64
%36 = add nsw i64 %35, -1
%37 = icmp ult i32 %3, 4
%38 = and i64 %35, 4294967292
%39 = icmp eq i64 %38, %35
%40 = and i64 %35, 1
%41 = icmp eq i64 %40, 0
br label %42
42: ; preds = %132, %33
%43 = phi i64 [ 0, %33 ], [ %133, %132 ]
%44 = mul i64 %43, %35
%45 = add i64 %44, %35
%46 = trunc i64 %43 to i32
%47 = urem i32 %46, 12
%48 = mul nsw i64 %43, %34
br i1 %37, label %87, label %49
49: ; preds = %42
%50 = getelementptr double, double* %9, i64 %45
%51 = getelementptr double, double* %9, i64 %44
%52 = getelementptr double, double* %7, i64 %45
%53 = getelementptr double, double* %7, i64 %44
%54 = icmp ult double* %53, %50
%55 = icmp ult double* %51, %52
%56 = and i1 %54, %55
br i1 %56, label %87, label %57
57: ; preds = %49
%58 = insertelement <2 x i32> poison, i32 %47, i64 0
%59 = shufflevector <2 x i32> %58, <2 x i32> poison, <2 x i32> zeroinitializer
%60 = insertelement <2 x i32> poison, i32 %47, i64 0
%61 = shufflevector <2 x i32> %60, <2 x i32> poison, <2 x i32> zeroinitializer
br label %62
62: ; preds = %62, %57
%63 = phi i64 [ 0, %57 ], [ %83, %62 ]
%64 = phi <2 x i32> [ <i32 0, i32 1>, %57 ], [ %84, %62 ]
%65 = add <2 x i32> %64, <i32 2, i32 2>
%66 = urem <2 x i32> %64, <i32 7, i32 7>
%67 = urem <2 x i32> %65, <i32 7, i32 7>
%68 = shl nuw nsw <2 x i32> %66, <i32 1, i32 1>
%69 = shl nuw nsw <2 x i32> %67, <i32 1, i32 1>
%70 = add nuw nsw <2 x i32> %68, %59
%71 = add nuw nsw <2 x i32> %69, %61
%72 = sitofp <2 x i32> %70 to <2 x double>
%73 = sitofp <2 x i32> %71 to <2 x double>
%74 = add nuw nsw i64 %63, %48
%75 = getelementptr inbounds double, double* %7, i64 %74
%76 = bitcast double* %75 to <2 x double>*
store <2 x double> %72, <2 x double>* %76
%77 = getelementptr inbounds double, double* %75, i64 2
%78 = bitcast double* %77 to <2 x double>*
store <2 x double> %73, <2 x double>* %78
%79 = getelementptr inbounds double, double* %9, i64 %74
%80 = bitcast double* %79 to <2 x double>*
store <2 x double> %72, <2 x double>* %80
%81 = getelementptr inbounds double, double* %79, i64 2
%82 = bitcast double* %81 to <2 x double>*
store <2 x double> %73, <2 x double>* %82
%83 = add nuw i64 %63, 4
%84 = add <2 x i32> %64, <i32 4, i32 4>
%85 = icmp eq i64 %83, %38
br i1 %85, label %86, label %62
86: ; preds = %62
br i1 %39, label %132, label %87
87: ; preds = %49, %42, %86
%88 = phi i64 [ 0, %49 ], [ 0, %42 ], [ %38, %86 ]
br i1 %41, label %99, label %89
89: ; preds = %87
%90 = trunc i64 %88 to i32
%91 = urem i32 %90, 7
%92 = shl nuw nsw i32 %91, 1
%93 = add nuw nsw i32 %92, %47
%94 = sitofp i32 %93 to double
%95 = add nuw nsw i64 %88, %48
%96 = getelementptr inbounds double, double* %7, i64 %95
store double %94, double* %96
%97 = getelementptr inbounds double, double* %9, i64 %95
store double %94, double* %97
%98 = or i64 %88, 1
br label %99
99: ; preds = %89, %87
%100 = phi i64 [ %88, %87 ], [ %98, %89 ]
%101 = icmp eq i64 %36, %88
br i1 %101, label %132, label %111
102: ; preds = %132
br i1 %32, label %103, label %364
103: ; preds = %102
%104 = sitofp i32 %3 to double
%105 = zext i32 %3 to i64
%106 = zext i32 %3 to i64
%107 = and i64 %35, 1
%108 = icmp eq i64 %36, 0
%109 = and i64 %35, 4294967294
%110 = icmp eq i64 %107, 0
br label %154
111: ; preds = %99, %111
%112 = phi i64 [ %130, %111 ], [ %100, %99 ]
%113 = trunc i64 %112 to i32
%114 = urem i32 %113, 7
%115 = shl nuw nsw i32 %114, 1
%116 = add nuw nsw i32 %115, %47
%117 = sitofp i32 %116 to double
%118 = add nuw nsw i64 %112, %48
%119 = getelementptr inbounds double, double* %7, i64 %118
store double %117, double* %119
%120 = getelementptr inbounds double, double* %9, i64 %118
store double %117, double* %120
%121 = add nuw nsw i64 %112, 1
%122 = trunc i64 %121 to i32
%123 = urem i32 %122, 7
%124 = shl nuw nsw i32 %123, 1
%125 = add nuw nsw i32 %124, %47
%126 = sitofp i32 %125 to double
%127 = add nuw nsw i64 %121, %48
%128 = getelementptr inbounds double, double* %7, i64 %127
store double %126, double* %128
%129 = getelementptr inbounds double, double* %9, i64 %127
store double %126, double* %129
%130 = add nuw nsw i64 %112, 2
%131 = icmp eq i64 %130, %35
br i1 %131, label %132, label %111
132: ; preds = %99, %111, %86
%133 = add nuw nsw i64 %43, 1
%134 = icmp eq i64 %133, %35
br i1 %134, label %102, label %42
135: ; preds = %185
br i1 %32, label %136, label %364
136: ; preds = %135
%137 = zext i32 %3 to i64
%138 = zext i32 %3 to i64
%139 = getelementptr double, double* %18, i64 %35
%140 = and i64 %35, 4294967292
%141 = add nsw i64 %140, -4
%142 = lshr exact i64 %141, 2
%143 = add nuw nsw i64 %142, 1
%144 = icmp ult i32 %3, 4
%145 = and i64 %35, 4294967292
%146 = and i64 %143, 1
%147 = icmp eq i64 %141, 0
%148 = and i64 %143, 9223372036854775806
%149 = icmp eq i64 %146, 0
%150 = icmp eq i64 %145, %35
%151 = and i64 %35, 1
%152 = icmp eq i64 %151, 0
%153 = sub nsw i64 0, %35
br label %190
154: ; preds = %185, %103
%155 = phi i64 [ 0, %103 ], [ %188, %185 ]
%156 = getelementptr inbounds double, double* %18, i64 %155
store double 0.000000e+00, double* %156
br i1 %108, label %175, label %157
157: ; preds = %154, %157
%158 = phi double [ %171, %157 ], [ 0.000000e+00, %154 ]
%159 = phi i64 [ %172, %157 ], [ 0, %154 ]
%160 = phi i64 [ %173, %157 ], [ 0, %154 ]
%161 = mul nsw i64 %159, %105
%162 = add nuw nsw i64 %161, %155
%163 = getelementptr inbounds double, double* %9, i64 %162
%164 = load double, double* %163
%165 = fadd double %164, %158
store double %165, double* %156
%166 = or i64 %159, 1
%167 = mul nsw i64 %166, %105
%168 = add nuw nsw i64 %167, %155
%169 = getelementptr inbounds double, double* %9, i64 %168
%170 = load double, double* %169
%171 = fadd double %170, %165
store double %171, double* %156
%172 = add nuw nsw i64 %159, 2
%173 = add i64 %160, 2
%174 = icmp eq i64 %173, %109
br i1 %174, label %175, label %157
175: ; preds = %157, %154
%176 = phi double [ undef, %154 ], [ %171, %157 ]
%177 = phi double [ 0.000000e+00, %154 ], [ %171, %157 ]
%178 = phi i64 [ 0, %154 ], [ %172, %157 ]
br i1 %110, label %185, label %179
179: ; preds = %175
%180 = mul nsw i64 %178, %105
%181 = add nuw nsw i64 %180, %155
%182 = getelementptr inbounds double, double* %9, i64 %181
%183 = load double, double* %182
%184 = fadd double %183, %177
store double %184, double* %156
br label %185
185: ; preds = %175, %179
%186 = phi double [ %176, %175 ], [ %184, %179 ]
%187 = fdiv double %186, %104
store double %187, double* %156
%188 = add nuw nsw i64 %155, 1
%189 = icmp eq i64 %188, %106
br i1 %189, label %135, label %154
190: ; preds = %306, %136
%191 = phi i64 [ 0, %136 ], [ %307, %306 ]
%192 = mul i64 %191, %35
%193 = mul nsw i64 %191, %137
br i1 %144, label %265, label %194
194: ; preds = %190
%195 = add i64 %192, %35
%196 = getelementptr double, double* %9, i64 %195
%197 = bitcast double* %196 to i8*
%198 = getelementptr double, double* %9, i64 %192
%199 = icmp ult double* %198, %139
%200 = icmp ult i8* %19, %197
%201 = and i1 %199, %200
br i1 %201, label %265, label %202
202: ; preds = %194
br i1 %147, label %244, label %203
203: ; preds = %202, %203
%204 = phi i64 [ %241, %203 ], [ 0, %202 ]
%205 = phi i64 [ %242, %203 ], [ 0, %202 ]
%206 = getelementptr inbounds double, double* %18, i64 %204
%207 = bitcast double* %206 to <2 x double>*
%208 = load <2 x double>, <2 x double>* %207
%209 = getelementptr inbounds double, double* %206, i64 2
%210 = bitcast double* %209 to <2 x double>*
%211 = load <2 x double>, <2 x double>* %210
%212 = add nuw nsw i64 %204, %193
%213 = getelementptr inbounds double, double* %9, i64 %212
%214 = bitcast double* %213 to <2 x double>*
%215 = load <2 x double>, <2 x double>* %214
%216 = getelementptr inbounds double, double* %213, i64 2
%217 = bitcast double* %216 to <2 x double>*
%218 = load <2 x double>, <2 x double>* %217
%219 = fsub <2 x double> %215, %208
%220 = fsub <2 x double> %218, %211
%221 = bitcast double* %213 to <2 x double>*
store <2 x double> %219, <2 x double>* %221
%222 = bitcast double* %216 to <2 x double>*
store <2 x double> %220, <2 x double>* %222
%223 = or i64 %204, 4
%224 = getelementptr inbounds double, double* %18, i64 %223
%225 = bitcast double* %224 to <2 x double>*
%226 = load <2 x double>, <2 x double>* %225
%227 = getelementptr inbounds double, double* %224, i64 2
%228 = bitcast double* %227 to <2 x double>*
%229 = load <2 x double>, <2 x double>* %228
%230 = add nuw nsw i64 %223, %193
%231 = getelementptr inbounds double, double* %9, i64 %230
%232 = bitcast double* %231 to <2 x double>*
%233 = load <2 x double>, <2 x double>* %232
%234 = getelementptr inbounds double, double* %231, i64 2
%235 = bitcast double* %234 to <2 x double>*
%236 = load <2 x double>, <2 x double>* %235
%237 = fsub <2 x double> %233, %226
%238 = fsub <2 x double> %236, %229
%239 = bitcast double* %231 to <2 x double>*
store <2 x double> %237, <2 x double>* %239
%240 = bitcast double* %234 to <2 x double>*
store <2 x double> %238, <2 x double>* %240
%241 = add nuw i64 %204, 8
%242 = add i64 %205, 2
%243 = icmp eq i64 %242, %148
br i1 %243, label %244, label %203
244: ; preds = %203, %202
%245 = phi i64 [ 0, %202 ], [ %241, %203 ]
br i1 %149, label %264, label %246
246: ; preds = %244
%247 = getelementptr inbounds double, double* %18, i64 %245
%248 = bitcast double* %247 to <2 x double>*
%249 = load <2 x double>, <2 x double>* %248
%250 = getelementptr inbounds double, double* %247, i64 2
%251 = bitcast double* %250 to <2 x double>*
%252 = load <2 x double>, <2 x double>* %251
%253 = add nuw nsw i64 %245, %193
%254 = getelementptr inbounds double, double* %9, i64 %253
%255 = bitcast double* %254 to <2 x double>*
%256 = load <2 x double>, <2 x double>* %255
%257 = getelementptr inbounds double, double* %254, i64 2
%258 = bitcast double* %257 to <2 x double>*
%259 = load <2 x double>, <2 x double>* %258
%260 = fsub <2 x double> %256, %249
%261 = fsub <2 x double> %259, %252
%262 = bitcast double* %254 to <2 x double>*
store <2 x double> %260, <2 x double>* %262
%263 = bitcast double* %257 to <2 x double>*
store <2 x double> %261, <2 x double>* %263
br label %264
264: ; preds = %244, %246
br i1 %150, label %306, label %265
265: ; preds = %194, %190, %264
%266 = phi i64 [ 0, %194 ], [ 0, %190 ], [ %145, %264 ]
%267 = xor i64 %266, -1
br i1 %152, label %276, label %268
268: ; preds = %265
%269 = getelementptr inbounds double, double* %18, i64 %266
%270 = load double, double* %269
%271 = add nuw nsw i64 %266, %193
%272 = getelementptr inbounds double, double* %9, i64 %271
%273 = load double, double* %272
%274 = fsub double %273, %270
store double %274, double* %272
%275 = or i64 %266, 1
br label %276
276: ; preds = %268, %265
%277 = phi i64 [ %266, %265 ], [ %275, %268 ]
%278 = icmp eq i64 %267, %153
br i1 %278, label %306, label %289
279: ; preds = %306
br i1 %32, label %280, label %364
280: ; preds = %279
%281 = add nsw i32 %3, -1
%282 = sitofp i32 %281 to double
%283 = zext i32 %3 to i64
%284 = zext i32 %3 to i64
%285 = and i64 %35, 1
%286 = icmp eq i64 %36, 0
%287 = and i64 %35, 4294967294
%288 = icmp eq i64 %285, 0
br label %309
289: ; preds = %276, %289
%290 = phi i64 [ %304, %289 ], [ %277, %276 ]
%291 = getelementptr inbounds double, double* %18, i64 %290
%292 = load double, double* %291
%293 = add nuw nsw i64 %290, %193
%294 = getelementptr inbounds double, double* %9, i64 %293
%295 = load double, double* %294
%296 = fsub double %295, %292
store double %296, double* %294
%297 = add nuw nsw i64 %290, 1
%298 = getelementptr inbounds double, double* %18, i64 %297
%299 = load double, double* %298
%300 = add nuw nsw i64 %297, %193
%301 = getelementptr inbounds double, double* %9, i64 %300
%302 = load double, double* %301
%303 = fsub double %302, %299
store double %303, double* %301
%304 = add nuw nsw i64 %290, 2
%305 = icmp eq i64 %304, %138
br i1 %305, label %306, label %289
306: ; preds = %276, %289, %264
%307 = add nuw nsw i64 %191, 1
%308 = icmp eq i64 %307, %138
br i1 %308, label %279, label %190
309: ; preds = %361, %280
%310 = phi i64 [ 0, %280 ], [ %362, %361 ]
%311 = mul nsw i64 %310, %283
br label %312
312: ; preds = %353, %309
%313 = phi i64 [ %310, %309 ], [ %359, %353 ]
%314 = add nuw nsw i64 %313, %311
%315 = getelementptr inbounds double, double* %13, i64 %314
store double 0.000000e+00, double* %315
br i1 %286, label %340, label %316
316: ; preds = %312, %316
%317 = phi double [ %336, %316 ], [ 0.000000e+00, %312 ]
%318 = phi i64 [ %337, %316 ], [ 0, %312 ]
%319 = phi i64 [ %338, %316 ], [ 0, %312 ]
%320 = mul nsw i64 %318, %283
%321 = add nuw nsw i64 %320, %310
%322 = getelementptr inbounds double, double* %9, i64 %321
%323 = load double, double* %322
%324 = add nuw nsw i64 %320, %313
%325 = getelementptr inbounds double, double* %9, i64 %324
%326 = load double, double* %325
%327 = tail call double @llvm.fmuladd.f64(double %323, double %326, double %317)
store double %327, double* %315
%328 = or i64 %318, 1
%329 = mul nsw i64 %328, %283
%330 = add nuw nsw i64 %329, %310
%331 = getelementptr inbounds double, double* %9, i64 %330
%332 = load double, double* %331
%333 = add nuw nsw i64 %329, %313
%334 = getelementptr inbounds double, double* %9, i64 %333
%335 = load double, double* %334
%336 = tail call double @llvm.fmuladd.f64(double %332, double %335, double %327)
store double %336, double* %315
%337 = add nuw nsw i64 %318, 2
%338 = add i64 %319, 2
%339 = icmp eq i64 %338, %287
br i1 %339, label %340, label %316
340: ; preds = %316, %312
%341 = phi double [ undef, %312 ], [ %336, %316 ]
%342 = phi double [ 0.000000e+00, %312 ], [ %336, %316 ]
%343 = phi i64 [ 0, %312 ], [ %337, %316 ]
br i1 %288, label %353, label %344
344: ; preds = %340
%345 = mul nsw i64 %343, %283
%346 = add nuw nsw i64 %345, %310
%347 = getelementptr inbounds double, double* %9, i64 %346
%348 = load double, double* %347
%349 = add nuw nsw i64 %345, %313
%350 = getelementptr inbounds double, double* %9, i64 %349
%351 = load double, double* %350
%352 = tail call double @llvm.fmuladd.f64(double %348, double %351, double %342)
store double %352, double* %315
br label %353
353: ; preds = %340, %344
%354 = phi double [ %341, %340 ], [ %352, %344 ]
%355 = fdiv double %354, %282
store double %355, double* %315
%356 = mul nsw i64 %313, %283
%357 = add nuw nsw i64 %356, %310
%358 = getelementptr inbounds double, double* %13, i64 %357
store double %355, double* %358
%359 = add nuw nsw i64 %313, 1
%360 = icmp eq i64 %359, %284
br i1 %360, label %361, label %312
361: ; preds = %353
%362 = add nuw nsw i64 %310, 1
%363 = icmp eq i64 %362, %284
br i1 %363, label %366, label %309
364: ; preds = %279, %135, %102, %31
%365 = tail call double (...) @omp_get_wtime()
br label %619
366: ; preds = %361
%367 = tail call double (...) @omp_get_wtime()
br i1 %32, label %368, label %619
368: ; preds = %366
%369 = sitofp i32 %3 to double
%370 = zext i32 %3 to i64
%371 = zext i32 %3 to i64
%372 = and i64 %35, 3
%373 = icmp ult i64 %36, 3
%374 = and i64 %35, 4294967292
%375 = icmp eq i64 %372, 0
br label %376
376: ; preds = %439, %368
%377 = phi i64 [ 0, %368 ], [ %443, %439 ]
br i1 %373, label %423, label %393
378: ; preds = %439
br i1 %32, label %379, label %619
379: ; preds = %378
%380 = zext i32 %3 to i64
%381 = zext i32 %3 to i64
%382 = getelementptr double, double* %15, i64 %35
%383 = icmp ult i32 %3, 4
%384 = and i64 %35, 4294967292
%385 = and i64 %143, 1
%386 = icmp eq i64 %141, 0
%387 = and i64 %143, 9223372036854775806
%388 = icmp eq i64 %385, 0
%389 = icmp eq i64 %384, %35
%390 = and i64 %35, 1
%391 = icmp eq i64 %390, 0
%392 = sub nsw i64 0, %35
br label %445
393: ; preds = %376, %393
%394 = phi i64 [ %420, %393 ], [ 0, %376 ]
%395 = phi double [ %419, %393 ], [ 0.000000e+00, %376 ]
%396 = phi i64 [ %421, %393 ], [ 0, %376 ]
%397 = mul nsw i64 %394, %370
%398 = add nuw nsw i64 %397, %377
%399 = getelementptr inbounds double, double* %7, i64 %398
%400 = load double, double* %399
%401 = fadd double %395, %400
%402 = or i64 %394, 1
%403 = mul nsw i64 %402, %370
%404 = add nuw nsw i64 %403, %377
%405 = getelementptr inbounds double, double* %7, i64 %404
%406 = load double, double* %405
%407 = fadd double %401, %406
%408 = or i64 %394, 2
%409 = mul nsw i64 %408, %370
%410 = add nuw nsw i64 %409, %377
%411 = getelementptr inbounds double, double* %7, i64 %410
%412 = load double, double* %411
%413 = fadd double %407, %412
%414 = or i64 %394, 3
%415 = mul nsw i64 %414, %370
%416 = add nuw nsw i64 %415, %377
%417 = getelementptr inbounds double, double* %7, i64 %416
%418 = load double, double* %417
%419 = fadd double %413, %418
%420 = add nuw nsw i64 %394, 4
%421 = add i64 %396, 4
%422 = icmp eq i64 %421, %374
br i1 %422, label %423, label %393
423: ; preds = %393, %376
%424 = phi double [ undef, %376 ], [ %419, %393 ]
%425 = phi i64 [ 0, %376 ], [ %420, %393 ]
%426 = phi double [ 0.000000e+00, %376 ], [ %419, %393 ]
br i1 %375, label %439, label %427
427: ; preds = %423, %427
%428 = phi i64 [ %436, %427 ], [ %425, %423 ]
%429 = phi double [ %435, %427 ], [ %426, %423 ]
%430 = phi i64 [ %437, %427 ], [ 0, %423 ]
%431 = mul nsw i64 %428, %370
%432 = add nuw nsw i64 %431, %377
%433 = getelementptr inbounds double, double* %7, i64 %432
%434 = load double, double* %433
%435 = fadd double %429, %434
%436 = add nuw nsw i64 %428, 1
%437 = add i64 %430, 1
%438 = icmp eq i64 %437, %372
br i1 %438, label %439, label %427
439: ; preds = %427, %423
%440 = phi double [ %424, %423 ], [ %435, %427 ]
%441 = fdiv double %440, %369
%442 = getelementptr inbounds double, double* %15, i64 %377
store double %441, double* %442
%443 = add nuw nsw i64 %377, 1
%444 = icmp eq i64 %443, %371
br i1 %444, label %378, label %376
445: ; preds = %561, %379
%446 = phi i64 [ 0, %379 ], [ %562, %561 ]
%447 = mul i64 %446, %35
%448 = mul nsw i64 %446, %380
br i1 %383, label %520, label %449
449: ; preds = %445
%450 = add i64 %447, %35
%451 = getelementptr double, double* %7, i64 %450
%452 = bitcast double* %451 to i8*
%453 = getelementptr double, double* %7, i64 %447
%454 = icmp ult double* %453, %382
%455 = icmp ult i8* %16, %452
%456 = and i1 %454, %455
br i1 %456, label %520, label %457
457: ; preds = %449
br i1 %386, label %499, label %458
458: ; preds = %457, %458
%459 = phi i64 [ %496, %458 ], [ 0, %457 ]
%460 = phi i64 [ %497, %458 ], [ 0, %457 ]
%461 = getelementptr inbounds double, double* %15, i64 %459
%462 = bitcast double* %461 to <2 x double>*
%463 = load <2 x double>, <2 x double>* %462
%464 = getelementptr inbounds double, double* %461, i64 2
%465 = bitcast double* %464 to <2 x double>*
%466 = load <2 x double>, <2 x double>* %465
%467 = add nuw nsw i64 %459, %448
%468 = getelementptr inbounds double, double* %7, i64 %467
%469 = bitcast double* %468 to <2 x double>*
%470 = load <2 x double>, <2 x double>* %469
%471 = getelementptr inbounds double, double* %468, i64 2
%472 = bitcast double* %471 to <2 x double>*
%473 = load <2 x double>, <2 x double>* %472
%474 = fsub <2 x double> %470, %463
%475 = fsub <2 x double> %473, %466
%476 = bitcast double* %468 to <2 x double>*
store <2 x double> %474, <2 x double>* %476
%477 = bitcast double* %471 to <2 x double>*
store <2 x double> %475, <2 x double>* %477
%478 = or i64 %459, 4
%479 = getelementptr inbounds double, double* %15, i64 %478
%480 = bitcast double* %479 to <2 x double>*
%481 = load <2 x double>, <2 x double>* %480
%482 = getelementptr inbounds double, double* %479, i64 2
%483 = bitcast double* %482 to <2 x double>*
%484 = load <2 x double>, <2 x double>* %483
%485 = add nuw nsw i64 %478, %448
%486 = getelementptr inbounds double, double* %7, i64 %485
%487 = bitcast double* %486 to <2 x double>*
%488 = load <2 x double>, <2 x double>* %487
%489 = getelementptr inbounds double, double* %486, i64 2
%490 = bitcast double* %489 to <2 x double>*
%491 = load <2 x double>, <2 x double>* %490
%492 = fsub <2 x double> %488, %481
%493 = fsub <2 x double> %491, %484
%494 = bitcast double* %486 to <2 x double>*
store <2 x double> %492, <2 x double>* %494
%495 = bitcast double* %489 to <2 x double>*
store <2 x double> %493, <2 x double>* %495
%496 = add nuw i64 %459, 8
%497 = add i64 %460, 2
%498 = icmp eq i64 %497, %387
br i1 %498, label %499, label %458
499: ; preds = %458, %457
%500 = phi i64 [ 0, %457 ], [ %496, %458 ]
br i1 %388, label %519, label %501
501: ; preds = %499
%502 = getelementptr inbounds double, double* %15, i64 %500
%503 = bitcast double* %502 to <2 x double>*
%504 = load <2 x double>, <2 x double>* %503
%505 = getelementptr inbounds double, double* %502, i64 2
%506 = bitcast double* %505 to <2 x double>*
%507 = load <2 x double>, <2 x double>* %506
%508 = add nuw nsw i64 %500, %448
%509 = getelementptr inbounds double, double* %7, i64 %508
%510 = bitcast double* %509 to <2 x double>*
%511 = load <2 x double>, <2 x double>* %510
%512 = getelementptr inbounds double, double* %509, i64 2
%513 = bitcast double* %512 to <2 x double>*
%514 = load <2 x double>, <2 x double>* %513
%515 = fsub <2 x double> %511, %504
%516 = fsub <2 x double> %514, %507
%517 = bitcast double* %509 to <2 x double>*
store <2 x double> %515, <2 x double>* %517
%518 = bitcast double* %512 to <2 x double>*
store <2 x double> %516, <2 x double>* %518
br label %519
519: ; preds = %499, %501
br i1 %389, label %561, label %520
520: ; preds = %449, %445, %519
%521 = phi i64 [ 0, %449 ], [ 0, %445 ], [ %384, %519 ]
%522 = xor i64 %521, -1
br i1 %391, label %531, label %523
523: ; preds = %520
%524 = getelementptr inbounds double, double* %15, i64 %521
%525 = load double, double* %524
%526 = add nuw nsw i64 %521, %448
%527 = getelementptr inbounds double, double* %7, i64 %526
%528 = load double, double* %527
%529 = fsub double %528, %525
store double %529, double* %527
%530 = or i64 %521, 1
br label %531
531: ; preds = %523, %520
%532 = phi i64 [ %521, %520 ], [ %530, %523 ]
%533 = icmp eq i64 %522, %392
br i1 %533, label %561, label %544
534: ; preds = %561
br i1 %32, label %535, label %619
535: ; preds = %534
%536 = add nsw i32 %3, -1
%537 = sitofp i32 %536 to double
%538 = zext i32 %3 to i64
%539 = zext i32 %3 to i64
%540 = and i64 %35, 1
%541 = icmp eq i64 %36, 0
%542 = and i64 %35, 4294967294
%543 = icmp eq i64 %540, 0
br label %564
544: ; preds = %531, %544
%545 = phi i64 [ %559, %544 ], [ %532, %531 ]
%546 = getelementptr inbounds double, double* %15, i64 %545
%547 = load double, double* %546
%548 = add nuw nsw i64 %545, %448
%549 = getelementptr inbounds double, double* %7, i64 %548
%550 = load double, double* %549
%551 = fsub double %550, %547
store double %551, double* %549
%552 = add nuw nsw i64 %545, 1
%553 = getelementptr inbounds double, double* %15, i64 %552
%554 = load double, double* %553
%555 = add nuw nsw i64 %552, %448
%556 = getelementptr inbounds double, double* %7, i64 %555
%557 = load double, double* %556
%558 = fsub double %557, %554
store double %558, double* %556
%559 = add nuw nsw i64 %545, 2
%560 = icmp eq i64 %559, %381
br i1 %560, label %561, label %544
561: ; preds = %531, %544, %519
%562 = add nuw nsw i64 %446, 1
%563 = icmp eq i64 %562, %381
br i1 %563, label %534, label %445
564: ; preds = %616, %535
%565 = phi i64 [ 0, %535 ], [ %617, %616 ]
%566 = mul nsw i64 %565, %538
br label %567
567: ; preds = %606, %564
%568 = phi i64 [ %565, %564 ], [ %614, %606 ]
br i1 %541, label %593, label %569
569: ; preds = %567, %569
%570 = phi i64 [ %590, %569 ], [ 0, %567 ]
%571 = phi double [ %589, %569 ], [ 0.000000e+00, %567 ]
%572 = phi i64 [ %591, %569 ], [ 0, %567 ]
%573 = mul nsw i64 %570, %538
%574 = add nuw nsw i64 %573, %565
%575 = getelementptr inbounds double, double* %7, i64 %574
%576 = load double, double* %575
%577 = add nuw nsw i64 %573, %568
%578 = getelementptr inbounds double, double* %7, i64 %577
%579 = load double, double* %578
%580 = tail call double @llvm.fmuladd.f64(double %576, double %579, double %571)
%581 = or i64 %570, 1
%582 = mul nsw i64 %581, %538
%583 = add nuw nsw i64 %582, %565
%584 = getelementptr inbounds double, double* %7, i64 %583
%585 = load double, double* %584
%586 = add nuw nsw i64 %582, %568
%587 = getelementptr inbounds double, double* %7, i64 %586
%588 = load double, double* %587
%589 = tail call double @llvm.fmuladd.f64(double %585, double %588, double %580)
%590 = add nuw nsw i64 %570, 2
%591 = add i64 %572, 2
%592 = icmp eq i64 %591, %542
br i1 %592, label %593, label %569
593: ; preds = %569, %567
%594 = phi double [ undef, %567 ], [ %589, %569 ]
%595 = phi i64 [ 0, %567 ], [ %590, %569 ]
%596 = phi double [ 0.000000e+00, %567 ], [ %589, %569 ]
br i1 %543, label %606, label %597
597: ; preds = %593
%598 = mul nsw i64 %595, %538
%599 = add nuw nsw i64 %598, %565
%600 = getelementptr inbounds double, double* %7, i64 %599
%601 = load double, double* %600
%602 = add nuw nsw i64 %598, %568
%603 = getelementptr inbounds double, double* %7, i64 %602
%604 = load double, double* %603
%605 = tail call double @llvm.fmuladd.f64(double %601, double %604, double %596)
br label %606
606: ; preds = %593, %597
%607 = phi double [ %594, %593 ], [ %605, %597 ]
%608 = fdiv double %607, %537
%609 = add nuw nsw i64 %568, %566
%610 = getelementptr inbounds double, double* %11, i64 %609
store double %608, double* %610
%611 = mul nsw i64 %568, %538
%612 = add nuw nsw i64 %611, %565
%613 = getelementptr inbounds double, double* %11, i64 %612
store double %608, double* %613
%614 = add nuw nsw i64 %568, 1
%615 = icmp eq i64 %614, %539
br i1 %615, label %616, label %567
616: ; preds = %606
%617 = add nuw nsw i64 %565, 1
%618 = icmp eq i64 %617, %539
br i1 %618, label %622, label %564
619: ; preds = %534, %378, %364, %366
%620 = phi double [ %367, %534 ], [ %367, %378 ], [ %367, %366 ], [ %365, %364 ]
%621 = tail call double (...) @omp_get_wtime()
br label %699
622: ; preds = %616
%623 = tail call double (...) @omp_get_wtime()
br i1 %32, label %624, label %699
624: ; preds = %622
%625 = zext i32 %3 to i64
%626 = zext i32 %3 to i64
%627 = icmp ult i32 %3, 4
%628 = and i64 %35, 4294967292
%629 = icmp eq i64 %628, %35
br label %630
630: ; preds = %695, %624
%631 = phi i64 [ 0, %624 ], [ %697, %695 ]
%632 = phi i32 [ 0, %624 ], [ %696, %695 ]
%633 = mul nsw i64 %631, %625
br i1 %627, label %677, label %634
634: ; preds = %630
%635 = insertelement <2 x i32> poison, i32 %632, i64 0
%636 = shufflevector <2 x i32> %635, <2 x i32> poison, <2 x i32> zeroinitializer
br label %637
637: ; preds = %637, %634
%638 = phi i64 [ 0, %634 ], [ %664, %637 ]
%639 = phi <2 x i32> [ %636, %634 ], [ %662, %637 ]
%640 = phi <2 x i32> [ %636, %634 ], [ %663, %637 ]
%641 = add nuw nsw i64 %638, %633
%642 = getelementptr inbounds double, double* %13, i64 %641
%643 = bitcast double* %642 to <2 x double>*
%644 = load <2 x double>, <2 x double>* %643
%645 = getelementptr inbounds double, double* %642, i64 2
%646 = bitcast double* %645 to <2 x double>*
%647 = load <2 x double>, <2 x double>* %646
%648 = getelementptr inbounds double, double* %11, i64 %641
%649 = bitcast double* %648 to <2 x double>*
%650 = load <2 x double>, <2 x double>* %649
%651 = getelementptr inbounds double, double* %648, i64 2
%652 = bitcast double* %651 to <2 x double>*
%653 = load <2 x double>, <2 x double>* %652
%654 = fsub <2 x double> %644, %650
%655 = fsub <2 x double> %647, %653
%656 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %654)
%657 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %655)
%658 = fdiv <2 x double> %656, %644
%659 = fdiv <2 x double> %657, %647
%660 = fcmp ogt <2 x double> %658, <double 0x3D06849B86A12B9B, double 0x3D06849B86A12B9B>
%661 = fcmp ogt <2 x double> %659, <double 0x3D06849B86A12B9B, double 0x3D06849B86A12B9B>
%662 = select <2 x i1> %660, <2 x i32> <i32 1, i32 1>, <2 x i32> %639
%663 = select <2 x i1> %661, <2 x i32> <i32 1, i32 1>, <2 x i32> %640
%664 = add nuw i64 %638, 4
%665 = icmp eq i64 %664, %628
br i1 %665, label %666, label %637
666: ; preds = %637
%667 = insertelement <2 x i32> poison, i32 %632, i64 0
%668 = shufflevector <2 x i32> %667, <2 x i32> poison, <2 x i32> zeroinitializer
%669 = icmp eq <2 x i32> %662, %668
%670 = select <2 x i1> %669, <2 x i32> %663, <2 x i32> %662
%671 = insertelement <2 x i32> poison, i32 %632, i64 0
%672 = shufflevector <2 x i32> %671, <2 x i32> poison, <2 x i32> zeroinitializer
%673 = bitcast <2 x i32> %670 to i64
%674 = bitcast <2 x i32> %672 to i64
%675 = icmp eq i64 %673, %674
%676 = select i1 %675, i32 %632, i32 1
br i1 %629, label %695, label %677
677: ; preds = %630, %666
%678 = phi i64 [ 0, %630 ], [ %628, %666 ]
%679 = phi i32 [ %632, %630 ], [ %676, %666 ]
br label %680
680: ; preds = %677, %680
%681 = phi i64 [ %693, %680 ], [ %678, %677 ]
%682 = phi i32 [ %692, %680 ], [ %679, %677 ]
%683 = add nuw nsw i64 %681, %633
%684 = getelementptr inbounds double, double* %13, i64 %683
%685 = load double, double* %684
%686 = getelementptr inbounds double, double* %11, i64 %683
%687 = load double, double* %686
%688 = fsub double %685, %687
%689 = tail call double @llvm.fabs.f64(double %688)
%690 = fdiv double %689, %685
%691 = fcmp ogt double %690, 0x3D06849B86A12B9B
%692 = select i1 %691, i32 1, i32 %682
%693 = add nuw nsw i64 %681, 1
%694 = icmp eq i64 %693, %626
br i1 %694, label %695, label %680
695: ; preds = %680, %666
%696 = phi i32 [ %676, %666 ], [ %692, %680 ]
%697 = add nuw nsw i64 %631, 1
%698 = icmp eq i64 %697, %626
br i1 %698, label %699, label %630
699: ; preds = %695, %619, %622
%700 = phi double [ %623, %622 ], [ %621, %619 ], [ %623, %695 ]
%701 = phi double [ %367, %622 ], [ %620, %619 ], [ %367, %695 ]
%702 = phi i32 [ 0, %622 ], [ 0, %619 ], [ %696, %695 ]
%703 = tail call i32 @free(double* %7)
%704 = tail call i32 @free(double* %9)
%705 = tail call i32 @free(double* %11)
%706 = tail call i32 @free(double* %13)
%707 = tail call i32 @free(double* %15)
%708 = tail call i32 @free(double* %18)
%709 = icmp eq i32 %702, 0
%710 = fsub double %700, %701
%711 = select i1 %709, double %710, double -1.100000e+04
br label %712
712: ; preds = %699, %0
%713 = phi double [ -1.000000e+04, %0 ], [ %711, %699 ]
ret double %713
}