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


x86 assembly (clang, -O0):
<twomm>:
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)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    0x2e4d(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%rax
mov    $0x5,%ecx
xor    %edx,%edx
div    %rcx
mov    %eax,%edi
call   1060 <sqrt@plt>
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x48(%rbp)
je     127f <twomm+0x12f>
cmpq   $0x0,-0x50(%rbp)
je     127f <twomm+0x12f>
cmpq   $0x0,-0x40(%rbp)
je     127f <twomm+0x12f>
cmpq   $0x0,-0x58(%rbp)
je     127f <twomm+0x12f>
cmpq   $0x0,-0x60(%rbp)
je     127f <twomm+0x12f>
cmpq   $0x0,-0x68(%rbp)
jne    1291 <twomm+0x141>
movsd  0xd91(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1869 <twomm+0x719>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    130c <twomm+0x1bc>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    12f9 <twomm+0x1a9>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xd4a(%rip),%xmm1
mov    0x2d1b(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%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    12ab <twomm+0x15b>
jmp    12fe <twomm+0x1ae>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1298 <twomm+0x148>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1387 <twomm+0x237>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1374 <twomm+0x224>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xccf(%rip),%xmm1
mov    0x2ca0(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%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    1326 <twomm+0x1d6>
jmp    1379 <twomm+0x229>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1313 <twomm+0x1c3>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1402 <twomm+0x2b2>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    13ef <twomm+0x29f>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xc54(%rip),%xmm1
mov    0x2c25(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%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    13a1 <twomm+0x251>
jmp    13f4 <twomm+0x2a4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    138e <twomm+0x23e>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    14d7 <twomm+0x387>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    14c4 <twomm+0x374>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%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    -0x38(%rbp),%eax
jge    14b1 <twomm+0x361>
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%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    1448 <twomm+0x2f8>
jmp    14b6 <twomm+0x366>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    141c <twomm+0x2cc>
jmp    14c9 <twomm+0x379>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1409 <twomm+0x2b9>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    15ac <twomm+0x45c>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1599 <twomm+0x449>
mov    -0x68(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%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    -0x38(%rbp),%eax
jge    1586 <twomm+0x436>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x68(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%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    151d <twomm+0x3cd>
jmp    158b <twomm+0x43b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14f1 <twomm+0x3a1>
jmp    159e <twomm+0x44e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14de <twomm+0x38e>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1681 <twomm+0x531>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    166e <twomm+0x51e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1645 <twomm+0x4f5>
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15ed <twomm+0x49d>
movsd  -0x20(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%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    15d2 <twomm+0x482>
jmp    1673 <twomm+0x523>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    15bf <twomm+0x46f>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    174a <twomm+0x5fa>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1737 <twomm+0x5e7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    170e <twomm+0x5be>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    16b6 <twomm+0x566>
movsd  -0x20(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%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    169b <twomm+0x54b>
jmp    173c <twomm+0x5ec>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1688 <twomm+0x538>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1808 <twomm+0x6b8>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    17f5 <twomm+0x6a5>
mov    -0x68(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x871(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0x837(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    17e2 <twomm+0x692>
movl   $0x1,-0x34(%rbp)
jmp    17e7 <twomm+0x697>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1770 <twomm+0x620>
jmp    17fa <twomm+0x6aa>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    175d <twomm+0x60d>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x34(%rbp)
jne    185c <twomm+0x70c>
movsd  -0x30(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1869 <twomm+0x719>
movsd  0x79c(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<twomm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    0x2e7b(%rip),%rax
mov    (%rax),%eax
mov    $0xcccccccd,%edi
imul   %rax,%rdi
shr    $0x25,%rdi
call   1060 <sqrt@plt>
mov    %eax,%ebp
mov    %eax,0xc(%rsp)
imul   %eax,%ebp
shl    $0x3,%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %ebp,%edi
call   1050 <malloc@plt>
movsd  0xe36(%rip),%xmm0
test   %rbx,%rbx
je     15d8 <twomm+0x488>
test   %r14,%r14
je     15d8 <twomm+0x488>
test   %r12,%r12
je     15d8 <twomm+0x488>
cmpq   $0x0,0x28(%rsp)
je     15d8 <twomm+0x488>
cmpq   $0x0,0x38(%rsp)
je     15d8 <twomm+0x488>
mov    %rax,%r13
test   %rax,%rax
je     15d8 <twomm+0x488>
mov    %r14,0x20(%rsp)
mov    %rbx,0x30(%rsp)
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    1567 <twomm+0x417>
mov    %eax,%eax
lea    0x0(,%rax,8),%r14
mov    0x30(%rsp),%rbx
xor    %ecx,%ecx
mov    %rax,0x18(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rcx,0x10(%rsp)
xor    %r15d,%r15d
mov    0x2d99(%rip),%rbp
nop
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0xda9(%rip),%xmm2
mov    0x18(%rsp),%rax
movsd  0x0(%rbp),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%r15,8)
add    $0x1,%r15
cmp    %r15,%rax
jne    1250 <twomm+0x100>
mov    0x10(%rsp),%rcx
add    $0x1,%rcx
add    %r14,%rbx
cmp    %rax,%rcx
jne    1240 <twomm+0xf0>
cmpl   $0x0,0xc(%rsp)
mov    0x2d4b(%rip),%r15
jle    1567 <twomm+0x417>
mov    0x20(%rsp),%rbx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %rcx,0x10(%rsp)
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1070 <rand@plt>
mov    0x18(%rsp),%rax
movsd  (%r15),%xmm1
addsd  0xd2f(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rax
jne    12c0 <twomm+0x170>
mov    0x10(%rsp),%rcx
add    $0x1,%rcx
add    %r14,%rbx
cmp    %rax,%rcx
jne    12b0 <twomm+0x160>
cmpl   $0x0,0xc(%rsp)
jle    1567 <twomm+0x417>
mov    0x28(%rsp),%rbx
xor    %eax,%eax
xchg   %ax,%ax
mov    %rax,0x10(%rsp)
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1070 <rand@plt>
mov    0x18(%rsp),%rcx
movsd  (%r15),%xmm1
addsd  0xccf(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rcx
jne    1320 <twomm+0x1d0>
mov    0x10(%rsp),%rax
add    $0x1,%rax
add    %r14,%rbx
cmp    %rcx,%rax
jne    1310 <twomm+0x1c0>
cmpl   $0x0,0xc(%rsp)
jle    1567 <twomm+0x417>
lea    -0x1(%rcx),%rax
mov    %rax,0x10(%rsp)
mov    %ecx,%eax
and    $0xfffffffe,%eax
mov    %rcx,%rdx
mov    0x30(%rsp),%r11
lea    0x8(%r11),%rcx
mov    %rdx,%rbp
shl    $0x4,%rbp
xor    %r8d,%r8d
mov    0x18(%rsp),%r15
jmp    13b5 <twomm+0x265>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r8
add    %r14,%rcx
mov    0x18(%rsp),%rdx
cmp    %rdx,%r8
je     1476 <twomm+0x326>
mov    %r8,%r9
imul   %rdx,%r9
mov    0x20(%rsp),%r10
xor    %edx,%edx
jmp    13dd <twomm+0x28d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
add    $0x8,%r10
cmp    %r15,%rdx
je     13a0 <twomm+0x250>
lea    (%rdx,%r9,1),%rsi
movq   $0x0,(%r12,%rsi,8)
cmpq   $0x0,0x10(%rsp)
je     1440 <twomm+0x2f0>
xorpd  %xmm0,%xmm0
mov    %r10,%rdi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbx,8),%xmm1
mulsd  (%rdi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rsi,8)
movsd  (%rcx,%rbx,8),%xmm0
mulsd  (%rdi,%r14,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rsi,8)
add    $0x2,%rbx
add    %rbp,%rdi
cmp    %rbx,%rax
jne    1400 <twomm+0x2b0>
test   $0x1,%r15b
je     13d0 <twomm+0x280>
jmp    144c <twomm+0x2fc>
nopl   (%rax)
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
test   $0x1,%r15b
je     13d0 <twomm+0x280>
lea    (%rbx,%r9,1),%rdi
movsd  (%r11,%rdi,8),%xmm1
imul   %r15,%rbx
add    %rdx,%rbx
mov    0x20(%rsp),%rdi
mulsd  (%rdi,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rsi,8)
jmp    13d0 <twomm+0x280>
cmpl   $0x0,0xc(%rsp)
jle    1567 <twomm+0x417>
mov    %rdx,%r11
mov    %r11d,%eax
and    $0xfffffffe,%eax
lea    0x8(%r12),%rcx
xor    %r8d,%r8d
jmp    14b0 <twomm+0x360>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
add    %r14,%rcx
cmp    %r11,%r8
je     15e7 <twomm+0x497>
mov    %r8,%r9
imul   %r11,%r9
mov    0x28(%rsp),%r10
xor    %edx,%edx
jmp    14cd <twomm+0x37d>
add    $0x1,%rdx
add    $0x8,%r10
cmp    %r11,%rdx
je     14a0 <twomm+0x350>
lea    (%rdx,%r9,1),%rsi
movq   $0x0,0x0(%r13,%rsi,8)
cmpq   $0x0,0x10(%rsp)
je     1530 <twomm+0x3e0>
xorpd  %xmm0,%xmm0
mov    %r10,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbx,8),%xmm1
mulsd  (%rdi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rsi,8)
movsd  (%rcx,%rbx,8),%xmm0
mulsd  (%rdi,%r14,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x2,%rbx
add    %rbp,%rdi
cmp    %rbx,%rax
jne    14f0 <twomm+0x3a0>
test   $0x1,%r11b
je     14c0 <twomm+0x370>
jmp    153c <twomm+0x3ec>
nop
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
test   $0x1,%r11b
je     14c0 <twomm+0x370>
lea    (%rbx,%r9,1),%rdi
movsd  (%r12,%rdi,8),%xmm1
imul   %r11,%rbx
add    %rdx,%rbx
mov    0x28(%rsp),%rdi
mulsd  (%rdi,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rsi,8)
jmp    14c0 <twomm+0x370>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x40(%rsp)
mov    0x20(%rsp),%rbx
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x10(%rsp)
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
test   %ebp,%ebp
je     15cc <twomm+0x47c>
movsd  0xa4e(%rip),%xmm0
jmp    15d8 <twomm+0x488>
movsd  0x10(%rsp),%xmm0
subsd  0x40(%rsp),%xmm0
add    $0x48,%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,0xc(%rsp)
movsd  %xmm0,0x40(%rsp)
jle    1574 <twomm+0x424>
mov    0x18(%rsp),%rdx
mov    %edx,%eax
and    $0xfffffffe,%eax
mov    0x30(%rsp),%r11
mov    %r11,%rcx
add    $0x8,%rcx
xor    %r8d,%r8d
mov    0x38(%rsp),%r10
mov    0x18(%rsp),%r15
jmp    1645 <twomm+0x4f5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
add    %r14,%rcx
mov    0x18(%rsp),%rdx
cmp    %rdx,%r8
je     1700 <twomm+0x5b0>
mov    %r8,%r9
imul   %rdx,%r9
mov    0x20(%rsp),%rbx
xor    %edx,%edx
jmp    1677 <twomm+0x527>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rdx,%r9,1),%rsi
movsd  %xmm3,(%r12,%rsi,8)
add    $0x1,%rdx
add    $0x8,%rbx
cmp    %r15,%rdx
je     1630 <twomm+0x4e0>
cmpq   $0x0,0x10(%rsp)
je     16d0 <twomm+0x580>
xorpd  %xmm1,%xmm1
mov    %rbx,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rsi,8),%xmm2
mulsd  (%rdi),%xmm2
movsd  (%rcx,%rsi,8),%xmm3
addsd  %xmm1,%xmm2
mulsd  (%rdi,%r14,1),%xmm3
addsd  %xmm2,%xmm3
add    $0x2,%rsi
add    %rbp,%rdi
movapd %xmm3,%xmm1
cmp    %rsi,%rax
jne    1690 <twomm+0x540>
test   $0x1,%r15b
je     1660 <twomm+0x510>
jmp    16dc <twomm+0x58c>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm3,%xmm3
xor    %esi,%esi
test   $0x1,%r15b
je     1660 <twomm+0x510>
lea    (%rsi,%r9,1),%rdi
movsd  (%r11,%rdi,8),%xmm1
imul   %r15,%rsi
add    %rdx,%rsi
mov    0x20(%rsp),%rdi
mulsd  (%rdi,%rsi,8),%xmm1
addsd  %xmm1,%xmm3
jmp    1660 <twomm+0x510>
cmpl   $0x0,0xc(%rsp)
jle    1574 <twomm+0x424>
mov    0x18(%rsp),%r11
mov    %r11d,%eax
and    $0xfffffffe,%eax
mov    %r12,%rcx
add    $0x8,%rcx
xor    %r8d,%r8d
jmp    1740 <twomm+0x5f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r8
add    %r14,%rcx
cmp    %r11,%r8
je     17f0 <twomm+0x6a0>
mov    %r8,%r9
imul   %r11,%r9
mov    0x28(%rsp),%rbx
xor    %edx,%edx
jmp    1767 <twomm+0x617>
lea    (%rdx,%r9,1),%rsi
movsd  %xmm3,(%r10,%rsi,8)
add    $0x1,%rdx
add    $0x8,%rbx
cmp    %r11,%rdx
je     1730 <twomm+0x5e0>
cmpq   $0x0,0x10(%rsp)
je     17c0 <twomm+0x670>
xorpd  %xmm1,%xmm1
mov    %rbx,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rsi,8),%xmm2
mulsd  (%rdi),%xmm2
movsd  (%rcx,%rsi,8),%xmm3
addsd  %xmm1,%xmm2
mulsd  (%rdi,%r14,1),%xmm3
addsd  %xmm2,%xmm3
add    $0x2,%rsi
add    %rbp,%rdi
movapd %xmm3,%xmm1
cmp    %rsi,%rax
jne    1780 <twomm+0x630>
test   $0x1,%r11b
je     1750 <twomm+0x600>
jmp    17cc <twomm+0x67c>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm3,%xmm3
xor    %esi,%esi
test   $0x1,%r11b
je     1750 <twomm+0x600>
lea    (%rsi,%r9,1),%rdi
movsd  (%r12,%rdi,8),%xmm1
imul   %r11,%rsi
add    %rdx,%rsi
mov    0x28(%rsp),%rdi
mulsd  (%rdi,%rsi,8),%xmm1
addsd  %xmm1,%xmm3
jmp    1750 <twomm+0x600>
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x10(%rsp)
mov    0xc(%rsp),%edi
test   %edi,%edi
jle    199d <twomm+0x84d>
mov    0x18(%rsp),%rdx
mov    %edx,%r8d
and    $0xfffffffc,%r8d
mov    0x38(%rsp),%rax
mov    %rax,%rcx
add    $0x10,%rcx
lea    0x0(,%rdx,8),%r9
mov    %r13,%rsi
add    $0x10,%rsi
mov    %r9,%r14
and    $0xffffffffffffffe0,%r14
xor    %r10d,%r10d
movapd 0x7dc(%rip),%xmm0
movsd  0x7c3(%rip),%xmm9
mov    $0x1,%r11d
movapd 0x7d4(%rip),%xmm11
movaps 0x7dc(%rip),%xmm10
mov    %r13,%rdx
xor    %ebp,%ebp
jmp    188d <twomm+0x73d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r9,%rcx
add    %r9,%rsi
add    %r9,%rdx
add    %r9,%rax
cmp    %rbx,%r10
mov    0xc(%rsp),%edi
je     199d <twomm+0x84d>
cmp    $0x4,%edi
jae    189e <twomm+0x74e>
xor    %edi,%edi
mov    0x18(%rsp),%rbx
jmp    1970 <twomm+0x820>
movd   %ebp,%xmm8
pshufd $0x50,%xmm8,%xmm4
xor    %edi,%edi
movdqa %xmm4,%xmm6
nop
movupd -0x10(%rsi,%rdi,1),%xmm2
movupd (%rsi,%rdi,1),%xmm5
movupd -0x10(%rcx,%rdi,1),%xmm1
movupd (%rcx,%rdi,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,%rdi
cmp    %rdi,%r14
jne    18b0 <twomm+0x760>
pshufd $0x50,%xmm8,%xmm1
movaps %xmm4,%xmm2
pcmpeqd %xmm1,%xmm2
andps  %xmm2,%xmm6
andnps %xmm4,%xmm2
orps   %xmm6,%xmm2
movq   %xmm2,%rdi
movq   %xmm1,%rbx
cmp    %rbx,%rdi
cmovne %r11d,%ebp
mov    %r8,%rdi
mov    0x18(%rsp),%rbx
cmp    %rbx,%r8
je     1870 <twomm+0x720>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rdi,8),%xmm1
movapd %xmm1,%xmm2
subsd  (%rax,%rdi,8),%xmm2
andpd  %xmm0,%xmm2
divsd  %xmm1,%xmm2
ucomisd %xmm9,%xmm2
cmova  %r11d,%ebp
add    $0x1,%rdi
cmp    %rdi,%rbx
jne    1970 <twomm+0x820>
jmp    1870 <twomm+0x720>
mov    0x20(%rsp),%rbx
jmp    1588 <twomm+0x438>

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

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