#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 RAND_MAX;
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double omp_get_wtime();
double rand();
int sqrt(int);
double threemm() {
  extern unsigned int datasize;
  int i = 0;
  int j = 0;
  int k = 0;
  double t_start = 0;
  double t_end = 0;
  int flag = 0;
  int n = sqrt((int)((datasize / sizeof(double)) / 7));
  double *A = (double *)malloc(n * n * sizeof(double));
  double *B = (double *)malloc(n * n * sizeof(double));
  double *C = (double *)malloc(n * n * sizeof(double));
  double *D = (double *)malloc(n * n * sizeof(double));
  double *E = (double *)malloc(n * n * sizeof(double));
  double *F = (double *)malloc(n * n * sizeof(double));
  double *G = (double *)malloc(n * n * sizeof(double));
  double *H = (double *)malloc(n * n * sizeof(double));
  if (A == NULL || B == NULL || C == NULL || D == NULL || E == NULL ||
      F == NULL || G == NULL || H == NULL) {
    return (-10000);
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      A[i * n + j] = rand() / (1.0 + RAND_MAX);
      B[i * n + j] = rand() / (1.0 + RAND_MAX);
      C[i * n + j] = rand() / (1.0 + RAND_MAX);
      D[i * n + j] = rand() / (1.0 + RAND_MAX);
      E[i * n + j] = rand() / (1.0 + RAND_MAX);
      F[i * n + j] = rand() / (1.0 + RAND_MAX);
      G[i * n + j] = rand() / (1.0 + RAND_MAX);
      H[i * n + j] = rand() / (1.0 + RAND_MAX);
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      E[i * n + j] = 0;
      for (k = 0; k < n; k++) {
        E[i * n + j] += A[i * n + k] * B[k * n + j];
      }
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      F[i * n + j] = 0;
      for (k = 0; k < n; k++) {
        F[i * n + j] += C[i * n + k] * D[k * n + j];
      }
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      H[i * n + j] = 0;
      for (k = 0; k < n; k++) {
        H[i * n + j] += E[i * n + k] * F[k * n + j];
      }
    }
  }
  t_start = omp_get_wtime();
#pragma acc data copyin(A [0:n * n], B [0:n * n], C [0:n * n], D [0:n * n]),   \
    create(E [0:n * n], F [0:n * n]), copyout(G [0:n * n])
  {
#pragma acc parallel loop
    for (i = 0; i < n; i++) {
#pragma acc loop
      for (j = 0; j < n; j++) {
        E[i * n + j] = 0;
        for (k = 0; k < n; k++) {
          E[i * n + j] += A[i * n + k] * B[k * n + j];
        }
      }
    }
#pragma acc parallel loop
    for (i = 0; i < n; i++) {
#pragma acc loop
      for (j = 0; j < n; j++) {
        F[i * n + j] = 0;
        for (k = 0; k < n; k++) {
          F[i * n + j] += C[i * n + k] * D[k * n + j];
        }
      }
    }
#pragma acc parallel loop
    for (i = 0; i < n; i++) {
#pragma acc loop
      for (j = 0; j < n; j++) {
        G[i * n + j] = 0;
        for (k = 0; k < n; k++) {
          G[i * n + j] += E[i * n + k] * F[k * n + j];
        }
      }
    }
  }
  t_end = omp_get_wtime();
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      if (fabs(H[i * n + j] - G[i * n + j]) / H[i * n + j] > 1e-14) {
        flag = 1;
      }
    }
  }
  free(A);
  free(B);
  free(C);
  free(D);
  free(E);
  free(F);
  free(G);
  free(H);
  if (flag == 0)
    return (t_end - t_start);
  else
    return (-11000);
}


x86 assembly (clang, -O0):
<threemm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    0x2e55(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%rax
mov    $0x7,%ecx
xor    %edx,%edx
div    %rcx
mov    %eax,%edi
call   1060 <sqrt@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     12bd <threemm+0x16d>
cmpq   $0x0,-0x40(%rbp)
je     12bd <threemm+0x16d>
cmpq   $0x0,-0x48(%rbp)
je     12bd <threemm+0x16d>
cmpq   $0x0,-0x50(%rbp)
je     12bd <threemm+0x16d>
cmpq   $0x0,-0x58(%rbp)
je     12bd <threemm+0x16d>
cmpq   $0x0,-0x60(%rbp)
je     12bd <threemm+0x16d>
cmpq   $0x0,-0x68(%rbp)
je     12bd <threemm+0x16d>
cmpq   $0x0,-0x70(%rbp)
jne    12cf <threemm+0x17f>
movsd  0xd53(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1af1 <threemm+0x9a1>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    14b6 <threemm+0x366>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    14a3 <threemm+0x353>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xd0c(%rip),%xmm1
mov    0x2cdd(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xcd8(%rip),%xmm1
mov    0x2ca9(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xca4(%rip),%xmm1
mov    0x2c75(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xc70(%rip),%xmm1
mov    0x2c41(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xc3c(%rip),%xmm1
mov    0x2c0d(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xc08(%rip),%xmm1
mov    0x2bd9(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xbd4(%rip),%xmm1
mov    0x2ba5(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xba0(%rip),%xmm1
mov    0x2b71(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%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    12e9 <threemm+0x199>
jmp    14a8 <threemm+0x358>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12d6 <threemm+0x186>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    158b <threemm+0x43b>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1578 <threemm+0x428>
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1565 <threemm+0x415>
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14fc <threemm+0x3ac>
jmp    156a <threemm+0x41a>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14d0 <threemm+0x380>
jmp    157d <threemm+0x42d>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14bd <threemm+0x36d>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1660 <threemm+0x510>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    164d <threemm+0x4fd>
mov    -0x60(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    163a <threemm+0x4ea>
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x60(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15d1 <threemm+0x481>
jmp    163f <threemm+0x4ef>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    15a5 <threemm+0x455>
jmp    1652 <threemm+0x502>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1592 <threemm+0x442>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1735 <threemm+0x5e5>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1722 <threemm+0x5d2>
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    170f <threemm+0x5bf>
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    16a6 <threemm+0x556>
jmp    1714 <threemm+0x5c4>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    167a <threemm+0x52a>
jmp    1727 <threemm+0x5d7>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1667 <threemm+0x517>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1816 <threemm+0x6c6>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1803 <threemm+0x6b3>
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    17f0 <threemm+0x6a0>
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1787 <threemm+0x637>
jmp    17f5 <threemm+0x6a5>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    175b <threemm+0x60b>
jmp    1808 <threemm+0x6b8>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1748 <threemm+0x5f8>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    18eb <threemm+0x79b>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    18d8 <threemm+0x788>
mov    -0x60(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    18c5 <threemm+0x775>
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x60(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    185c <threemm+0x70c>
jmp    18ca <threemm+0x77a>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1830 <threemm+0x6e0>
jmp    18dd <threemm+0x78d>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    181d <threemm+0x6cd>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    19c0 <threemm+0x870>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    19ad <threemm+0x85d>
mov    -0x68(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    199a <threemm+0x84a>
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x68(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1931 <threemm+0x7e1>
jmp    199f <threemm+0x84f>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1905 <threemm+0x7b5>
jmp    19b2 <threemm+0x862>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    18f2 <threemm+0x7a2>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1a7e <threemm+0x92e>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1a6b <threemm+0x91b>
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x5fb(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0x5c1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1a58 <threemm+0x908>
movl   $0x1,-0x2c(%rbp)
jmp    1a5d <threemm+0x90d>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    19e6 <threemm+0x896>
jmp    1a70 <threemm+0x920>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    19d3 <threemm+0x883>
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>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x2c(%rbp)
jne    1ae4 <threemm+0x994>
movsd  -0x28(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1af1 <threemm+0x9a1>
movsd  0x514(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<threemm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    0x2e78(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%eax
imul   $0x24924925,%rax,%rdi
shr    $0x20,%rdi
call   1060 <sqrt@plt>
mov    %eax,%r13d
mov    %eax,%ebx
imul   %eax,%ebx
shl    $0x3,%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
movsd  0xe1d(%rip),%xmm0
test   %r14,%r14
je     17d3 <threemm+0x683>
test   %rbp,%rbp
je     17d3 <threemm+0x683>
cmpq   $0x0,0x38(%rsp)
je     17d3 <threemm+0x683>
cmpq   $0x0,0x30(%rsp)
je     17d3 <threemm+0x683>
test   %r12,%r12
je     17d3 <threemm+0x683>
test   %r15,%r15
je     17d3 <threemm+0x683>
cmpq   $0x0,0x28(%rsp)
je     17d3 <threemm+0x683>
test   %rax,%rax
je     17d3 <threemm+0x683>
mov    %rbp,%r8
mov    %rax,0x48(%rsp)
test   %r13d,%r13d
mov    %r14,0x20(%rsp)
mov    %rbp,0x50(%rsp)
jle    174f <threemm+0x5ff>
mov    %r13d,0x14(%rsp)
mov    %r13d,%edi
lea    0x0(,%rdi,8),%r13
mov    0x2d82(%rip),%rbp
mov    %r15,%rax
mov    0x48(%rsp),%r15
mov    0x28(%rsp),%r10
mov    %rax,0x78(%rsp)
mov    %rax,%r9
mov    %r12,%rbx
mov    0x30(%rsp),%rdx
mov    0x38(%rsp),%rcx
mov    %r14,%rax
xor    %esi,%esi
mov    %rdi,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,0x58(%rsp)
mov    %rbx,0x60(%rsp)
mov    %r9,0x68(%rsp)
mov    %r8,0x70(%rsp)
mov    %rcx,0x40(%rsp)
mov    %r10,0x18(%rsp)
mov    %rsi,0x80(%rsp)
xor    %r14d,%r14d
mov    %rax,%rbx
nopl   0x0(%rax)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0x0(%rbp),%xmm1
addsd  0xd24(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%r14,1)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0x0(%rbp),%xmm1
addsd  0xd06(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x70(%rsp),%rax
movsd  %xmm0,(%rax,%r14,1)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0x0(%rbp),%xmm1
addsd  0xce3(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,(%rax,%r14,1)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0x0(%rbp),%xmm1
addsd  0xcc0(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x58(%rsp),%rax
movsd  %xmm0,(%rax,%r14,1)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0x0(%rbp),%xmm1
addsd  0xc9d(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x60(%rsp),%rax
movsd  %xmm0,(%rax,%r14,1)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0x0(%rbp),%xmm1
addsd  0xc7a(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x68(%rsp),%rax
movsd  %xmm0,(%rax,%r14,1)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0x0(%rbp),%xmm1
addsd  0xc57(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax,%r14,1)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0xc39(%rip),%xmm2
movsd  0x0(%rbp),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%r14,1)
add    $0x8,%r14
cmp    %r14,%r13
jne    12d0 <threemm+0x180>
mov    0x80(%rsp),%rsi
add    $0x1,%rsi
mov    %rbx,%rax
add    %r13,%rax
mov    0x70(%rsp),%r11
add    %r13,%r11
mov    0x40(%rsp),%r8
add    %r13,%r8
mov    0x58(%rsp),%r14
add    %r13,%r14
mov    0x60(%rsp),%rbx
add    %r13,%rbx
mov    0x68(%rsp),%rdx
add    %r13,%rdx
mov    0x18(%rsp),%rcx
add    %r13,%rcx
add    %r13,%r15
mov    0x8(%rsp),%rdi
cmp    %rdi,%rsi
mov    %rcx,%r10
mov    %rdx,%r9
mov    %r14,%rdx
mov    %r8,%rcx
mov    %r11,%r8
jne    12a0 <threemm+0x150>
cmpl   $0x0,0x14(%rsp)
mov    0x20(%rsp),%r10
mov    0x50(%rsp),%r11
mov    0x78(%rsp),%r15
jle    174f <threemm+0x5ff>
lea    -0x1(%rdi),%rax
mov    %rax,0x18(%rsp)
mov    %edi,%eax
and    $0xfffffffe,%eax
lea    0x8(%r10),%rcx
mov    %rdi,%r14
shl    $0x4,%r14
xor    %r8d,%r8d
jmp    14a0 <threemm+0x350>
nopl   0x0(%rax)
add    $0x1,%r8
add    %r13,%rcx
cmp    %rdi,%r8
je     1560 <threemm+0x410>
mov    %r8,%r9
imul   %rdi,%r9
mov    %r11,%rbx
xor    %ebp,%ebp
jmp    14bd <threemm+0x36d>
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x8,%rbx
cmp    %rdi,%rbp
je     1490 <threemm+0x340>
lea    (%r9,%rbp,1),%rdx
movq   $0x0,(%r12,%rdx,8)
cmpq   $0x0,0x18(%rsp)
je     1520 <threemm+0x3d0>
xorpd  %xmm0,%xmm0
mov    %rbx,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rsi,8),%xmm1
mulsd  (%rdi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rdx,8)
movsd  (%rcx,%rsi,8),%xmm0
mulsd  (%rdi,%r13,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rdx,8)
add    $0x2,%rsi
add    %r14,%rdi
cmp    %rsi,%rax
jne    14e0 <threemm+0x390>
jmp    1526 <threemm+0x3d6>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x8(%rsp),%rdi
test   $0x1,%dil
je     14b0 <threemm+0x360>
lea    (%rsi,%r9,1),%rdi
movsd  (%r10,%rdi,8),%xmm1
mov    0x8(%rsp),%rdi
imul   %rdi,%rsi
add    %rbp,%rsi
mulsd  (%r11,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rdx,8)
jmp    14b0 <threemm+0x360>
cmpl   $0x0,0x14(%rsp)
jle    174f <threemm+0x5ff>
mov    %edi,%eax
and    $0xfffffffe,%eax
mov    0x38(%rsp),%r10
lea    0x8(%r10),%rcx
xor    %r8d,%r8d
mov    0x30(%rsp),%r11
jmp    15a0 <threemm+0x450>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r8
add    %r13,%rcx
cmp    %rdi,%r8
je     1660 <threemm+0x510>
mov    %r8,%r9
imul   %rdi,%r9
mov    %r11,%rbx
xor    %ebp,%ebp
jmp    15bd <threemm+0x46d>
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x8,%rbx
cmp    %rdi,%rbp
je     1590 <threemm+0x440>
lea    (%r9,%rbp,1),%rdx
movq   $0x0,(%r15,%rdx,8)
cmpq   $0x0,0x18(%rsp)
je     1620 <threemm+0x4d0>
xorpd  %xmm0,%xmm0
mov    %rbx,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rsi,8),%xmm1
mulsd  (%rdi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
movsd  (%rcx,%rsi,8),%xmm0
mulsd  (%rdi,%r13,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    $0x2,%rsi
add    %r14,%rdi
cmp    %rsi,%rax
jne    15e0 <threemm+0x490>
jmp    1626 <threemm+0x4d6>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x8(%rsp),%rdi
test   $0x1,%dil
je     15b0 <threemm+0x460>
lea    (%rsi,%r9,1),%rdi
movsd  (%r10,%rdi,8),%xmm1
mov    0x8(%rsp),%rdi
imul   %rdi,%rsi
add    %rbp,%rsi
mulsd  (%r11,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
jmp    15b0 <threemm+0x460>
cmpl   $0x0,0x14(%rsp)
jle    174f <threemm+0x5ff>
mov    %edi,%eax
and    $0xfffffffe,%eax
lea    0x8(%r12),%rcx
xor    %r8d,%r8d
mov    0x48(%rsp),%rbx
jmp    1690 <threemm+0x540>
nop
add    $0x1,%r8
add    %r13,%rcx
cmp    %rdi,%r8
je     17e5 <threemm+0x695>
mov    %r8,%r9
imul   %rdi,%r9
mov    %r15,%r10
xor    %ebp,%ebp
jmp    16ad <threemm+0x55d>
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x8,%r10
cmp    %rdi,%rbp
je     1680 <threemm+0x530>
lea    (%r9,%rbp,1),%rdx
movq   $0x0,(%rbx,%rdx,8)
cmpq   $0x0,0x18(%rsp)
je     1710 <threemm+0x5c0>
xorpd  %xmm0,%xmm0
mov    %r10,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rsi,8),%xmm1
mulsd  (%rdi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  (%rcx,%rsi,8),%xmm0
mulsd  (%rdi,%r13,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x2,%rsi
add    %r14,%rdi
cmp    %rsi,%rax
jne    16d0 <threemm+0x580>
jmp    1716 <threemm+0x5c6>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x8(%rsp),%rdi
test   $0x1,%dil
je     16a0 <threemm+0x550>
lea    (%rsi,%r9,1),%rdi
movsd  (%r12,%rdi,8),%xmm1
mov    0x8(%rsp),%rdi
imul   %rdi,%rsi
add    %rbp,%rsi
mulsd  (%r15,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
jmp    16a0 <threemm+0x550>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x40(%rsp)
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x18(%rsp)
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
test   %r14d,%r14d
je     17c7 <threemm+0x677>
movsd  0x853(%rip),%xmm0
jmp    17d3 <threemm+0x683>
movsd  0x18(%rsp),%xmm0
subsd  0x40(%rsp),%xmm0
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
cmpl   $0x0,0x14(%rsp)
movsd  %xmm0,0x40(%rsp)
jle    175c <threemm+0x60c>
mov    0x8(%rsp),%rdi
mov    %edi,%eax
and    $0xfffffffe,%eax
mov    0x20(%rsp),%r10
mov    %r10,%rcx
add    $0x8,%rcx
xor    %r8d,%r8d
mov    0x50(%rsp),%r11
jmp    1830 <threemm+0x6e0>
nopl   (%rax)
add    $0x1,%r8
add    %r13,%rcx
cmp    %rdi,%r8
je     18f0 <threemm+0x7a0>
mov    %r8,%r9
imul   %rdi,%r9
mov    %r11,%rbx
xor    %ebp,%ebp
jmp    184d <threemm+0x6fd>
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x8,%rbx
cmp    %rdi,%rbp
je     1820 <threemm+0x6d0>
lea    (%r9,%rbp,1),%rdx
movq   $0x0,(%r12,%rdx,8)
cmpq   $0x0,0x18(%rsp)
je     18b0 <threemm+0x760>
xorpd  %xmm2,%xmm2
mov    %rbx,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rsi,8),%xmm1
mulsd  (%rdi),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%r12,%rdx,8)
movsd  (%rcx,%rsi,8),%xmm2
mulsd  (%rdi,%r13,1),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%rdx,8)
add    $0x2,%rsi
add    %r14,%rdi
cmp    %rsi,%rax
jne    1870 <threemm+0x720>
jmp    18b6 <threemm+0x766>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
xor    %esi,%esi
mov    0x8(%rsp),%rdi
test   $0x1,%dil
je     1840 <threemm+0x6f0>
lea    (%rsi,%r9,1),%rdi
movsd  (%r10,%rdi,8),%xmm1
mov    0x8(%rsp),%rdi
imul   %rdi,%rsi
add    %rbp,%rsi
mulsd  (%r11,%rsi,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%r12,%rdx,8)
jmp    1840 <threemm+0x6f0>
cmpl   $0x0,0x14(%rsp)
jle    175c <threemm+0x60c>
mov    %edi,%eax
and    $0xfffffffe,%eax
mov    0x38(%rsp),%r10
mov    %r10,%rcx
add    $0x8,%rcx
xor    %r8d,%r8d
mov    0x30(%rsp),%r11
jmp    1930 <threemm+0x7e0>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r8
add    %r13,%rcx
cmp    %rdi,%r8
je     19f0 <threemm+0x8a0>
mov    %r8,%r9
imul   %rdi,%r9
mov    %r11,%rbx
xor    %ebp,%ebp
jmp    194d <threemm+0x7fd>
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x8,%rbx
cmp    %rdi,%rbp
je     1920 <threemm+0x7d0>
lea    (%r9,%rbp,1),%rdx
movq   $0x0,(%r15,%rdx,8)
cmpq   $0x0,0x18(%rsp)
je     19b0 <threemm+0x860>
xorpd  %xmm0,%xmm0
mov    %rbx,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rsi,8),%xmm1
mulsd  (%rdi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
movsd  (%rcx,%rsi,8),%xmm0
mulsd  (%rdi,%r13,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    $0x2,%rsi
add    %r14,%rdi
cmp    %rsi,%rax
jne    1970 <threemm+0x820>
jmp    19b6 <threemm+0x866>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x8(%rsp),%rdi
test   $0x1,%dil
je     1940 <threemm+0x7f0>
lea    (%rsi,%r9,1),%rdi
movsd  (%r10,%rdi,8),%xmm1
mov    0x8(%rsp),%rdi
imul   %rdi,%rsi
add    %rbp,%rsi
mulsd  (%r11,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
jmp    1940 <threemm+0x7f0>
cmpl   $0x0,0x14(%rsp)
jle    175c <threemm+0x60c>
mov    %edi,%eax
and    $0xfffffffe,%eax
mov    %r12,%rcx
add    $0x8,%rcx
xor    %r8d,%r8d
mov    0x28(%rsp),%rbx
jmp    1a30 <threemm+0x8e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    %r13,%rcx
cmp    %rdi,%r8
je     1aef <threemm+0x99f>
mov    %r8,%r9
imul   %rdi,%r9
mov    %r15,%r10
xor    %ebp,%ebp
jmp    1a4d <threemm+0x8fd>
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x8,%r10
cmp    %rdi,%rbp
je     1a20 <threemm+0x8d0>
lea    (%r9,%rbp,1),%rdx
movq   $0x0,(%rbx,%rdx,8)
cmpq   $0x0,0x18(%rsp)
je     1ab0 <threemm+0x960>
xorpd  %xmm0,%xmm0
mov    %r10,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rsi,8),%xmm1
mulsd  (%rdi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  (%rcx,%rsi,8),%xmm0
mulsd  (%rdi,%r13,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x2,%rsi
add    %r14,%rdi
cmp    %rsi,%rax
jne    1a70 <threemm+0x920>
jmp    1ab6 <threemm+0x966>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x8(%rsp),%rdi
test   $0x1,%dil
je     1a40 <threemm+0x8f0>
lea    (%rsi,%r9,1),%rdi
movsd  (%r12,%rdi,8),%xmm1
mov    0x8(%rsp),%rdi
imul   %rdi,%rsi
add    %rbp,%rsi
mulsd  (%r15,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
jmp    1a40 <threemm+0x8f0>
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
mov    0x14(%rsp),%r13d
test   %r13d,%r13d
movsd  %xmm0,0x18(%rsp)
jle    176c <threemm+0x61c>
mov    0x8(%rsp),%rax
mov    %eax,%r8d
and    $0xfffffffc,%r8d
mov    0x28(%rsp),%rdx
mov    %rdx,%rcx
add    $0x10,%rcx
lea    0x0(,%rax,8),%r9
mov    0x48(%rsp),%rbp
mov    %rbp,%rsi
add    $0x10,%rsi
mov    %r9,%rdi
and    $0xffffffffffffffe0,%rdi
xor    %r10d,%r10d
movapd 0x4d5(%rip),%xmm0
movsd  0x4bc(%rip),%xmm9
mov    $0x1,%r11d
movapd 0x4cd(%rip),%xmm11
movaps 0x4d5(%rip),%xmm10
xor    %r14d,%r14d
jmp    1b89 <threemm+0xa39>
add    $0x1,%r10
add    %r9,%rcx
add    %r9,%rsi
add    %r9,%rbp
add    %r9,%rdx
cmp    %rbx,%r10
je     176c <threemm+0x61c>
cmp    $0x4,%r13d
jae    1b9b <threemm+0xa4b>
xor    %eax,%eax
mov    0x8(%rsp),%rbx
jmp    1c70 <threemm+0xb20>
movd   %r14d,%xmm8
pshufd $0x50,%xmm8,%xmm4
xor    %eax,%eax
movdqa %xmm4,%xmm6
nopl   0x0(%rax)
movupd -0x10(%rsi,%rax,1),%xmm2
movupd (%rsi,%rax,1),%xmm5
movupd -0x10(%rcx,%rax,1),%xmm1
movupd (%rcx,%rax,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,%rax
cmp    %rax,%rdi
jne    1bb0 <threemm+0xa60>
pshufd $0x50,%xmm8,%xmm1
movaps %xmm4,%xmm2
pcmpeqd %xmm1,%xmm2
andps  %xmm2,%xmm6
andnps %xmm4,%xmm2
orps   %xmm6,%xmm2
movq   %xmm2,%rax
movq   %xmm1,%rbx
cmp    %rbx,%rax
cmovne %r11d,%r14d
mov    %r8,%rax
mov    0x8(%rsp),%rbx
cmp    %rbx,%r8
je     1b70 <threemm+0xa20>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rax,8),%xmm1
movapd %xmm1,%xmm2
subsd  (%rdx,%rax,8),%xmm2
andpd  %xmm0,%xmm2
divsd  %xmm1,%xmm2
ucomisd %xmm9,%xmm2
cmova  %r11d,%r14d
add    $0x1,%rax
cmp    %rax,%rbx
jne    1c70 <threemm+0xb20>
jmp    1b70 <threemm+0xa20>

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

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