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


x86 assembly (clang, -O0):
<atax>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    0x2e73(%rip),%rax
movslq (%rax),%rax
shr    $0x3,%rax
mov    %eax,%edi
call   1060 <sqrt@plt>
mov    %eax,-0x14(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     1263 <atax+0x113>
cmpq   $0x0,-0x40(%rbp)
je     1263 <atax+0x113>
cmpq   $0x0,-0x48(%rbp)
je     1263 <atax+0x113>
cmpq   $0x0,-0x50(%rbp)
je     1263 <atax+0x113>
cmpq   $0x0,-0x58(%rbp)
jne    1275 <atax+0x125>
movsd  0xdad(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1658 <atax+0x508>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    132b <atax+0x1db>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xd79(%rip),%xmm1
mov    0x2d4a(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1318 <atax+0x1c8>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xd2b(%rip),%xmm1
mov    0x2cfc(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x14(%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    12ca <atax+0x17a>
jmp    131d <atax+0x1cd>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    127c <atax+0x12c>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13bc <atax+0x26c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    139c <atax+0x24c>
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    134d <atax+0x1fd>
movsd  -0x60(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1332 <atax+0x1e2>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    144d <atax+0x2fd>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    142d <atax+0x2dd>
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13de <atax+0x28e>
movsd  -0x60(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13c3 <atax+0x273>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14f2 <atax+0x3a2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14d2 <atax+0x382>
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1483 <atax+0x333>
movsd  -0x60(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1468 <atax+0x318>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1583 <atax+0x433>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1563 <atax+0x413>
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1514 <atax+0x3c4>
movsd  -0x60(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14f9 <atax+0x3a9>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1600 <atax+0x4b0>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xa5d(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0xa2c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    15ed <atax+0x49d>
movl   $0x1,-0x2c(%rbp)
jmp    15f2 <atax+0x4a2>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1596 <atax+0x446>
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>
cmpl   $0x0,-0x2c(%rbp)
jne    164b <atax+0x4fb>
movsd  -0x20(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1658 <atax+0x508>
movsd  0x9ad(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<atax>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    0x2e7b(%rip),%rax
mov    (%rax),%edi
sar    $0x3,%edi
call   1060 <sqrt@plt>
lea    0x0(,%rax,8),%ebp
mov    %ebp,%edi
mov    %rax,0x8(%rsp)
imul   %eax,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
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,0x10(%rsp)
mov    %ebp,%edi
call   1050 <malloc@plt>
movsd  0xe49(%rip),%xmm0
test   %r13,%r13
je     149c <atax+0x34c>
test   %r12,%r12
je     149c <atax+0x34c>
test   %rbx,%rbx
je     149c <atax+0x34c>
cmpq   $0x0,0x10(%rsp)
je     149c <atax+0x34c>
test   %rax,%rax
je     149c <atax+0x34c>
mov    %rbx,0x18(%rsp)
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
mov    %rax,0x20(%rsp)
jle    1438 <atax+0x2e8>
mov    %ecx,%r15d
lea    0x0(,%r15,8),%rsi
mov    0x2dd8(%rip),%rbp
mov    %r13,0x40(%rsp)
mov    %r13,%rbx
xor    %r14d,%r14d
mov    %rsi,0x28(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0x0(%rbp),%xmm1
movsd  0xdd4(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%r14,8)
mov    0x18(%rsp),%rax
movq   $0x0,(%rax,%r14,8)
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0x0(%rbp),%xmm1
addsd  0xd94(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%r13,8)
add    $0x1,%r13
cmp    %r13,%r15
jne    1260 <atax+0x110>
add    $0x1,%r14
mov    0x28(%rsp),%rsi
add    %rsi,%rbx
cmp    %r15,%r14
jne    1220 <atax+0xd0>
mov    0x8(%rsp),%r11
test   %r11d,%r11d
mov    0x40(%rsp),%r13
mov    0x20(%rsp),%r9
jle    1438 <atax+0x2e8>
lea    -0x1(%r15),%r14
mov    %r15d,%eax
and    $0x3,%eax
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
lea    0x18(%r13),%rdx
xor    %r10d,%r10d
mov    %r13,%r8
jmp    12e9 <atax+0x199>
nopl   0x0(%rax)
movsd  %xmm0,(%r9,%r10,8)
add    $0x1,%r10
add    %rsi,%rdx
add    %rsi,%r8
cmp    %r15,%r10
je     137d <atax+0x22d>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cmp    $0x3,%r14
jb     134b <atax+0x1fb>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x18(%rdx,%rbp,8),%xmm1
movsd  -0x10(%rdx,%rbp,8),%xmm2
mulsd  (%r12,%rbp,8),%xmm1
mulsd  0x8(%r12,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rdx,%rbp,8),%xmm3
mulsd  0x10(%r12,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rdx,%rbp,8),%xmm0
mulsd  0x18(%r12,%rbp,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    1300 <atax+0x1b0>
test   %rax,%rax
je     12d0 <atax+0x180>
lea    (%r12,%rbp,8),%rbx
lea    (%r8,%rbp,8),%rbp
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1360 <atax+0x210>
jmp    12d0 <atax+0x180>
test   %r11d,%r11d
jle    1438 <atax+0x2e8>
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    %r15,%rbp
shl    $0x4,%rbp
xor    %ecx,%ecx
mov    %r13,%rdx
mov    0x18(%rsp),%rbx
jmp    13b6 <atax+0x266>
nop
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0x8,%rdx
cmp    %r15,%rcx
je     14ab <atax+0x35b>
xorpd  %xmm0,%xmm0
test   %r14,%r14
je     1410 <atax+0x2c0>
mov    %rdx,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi),%xmm1
mulsd  (%r9,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdi,%r15,8),%xmm0
mulsd  0x8(%r9,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rsi
add    %rbp,%rdi
cmp    %rsi,%rax
jne    13d0 <atax+0x280>
test   $0x1,%r15b
je     13a0 <atax+0x250>
jmp    1418 <atax+0x2c8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %esi,%esi
test   $0x1,%r15b
je     13a0 <atax+0x250>
mov    %rsi,%rdi
imul   %r15,%rdi
add    %rcx,%rdi
movsd  0x0(%r13,%rdi,8),%xmm1
mulsd  (%r9,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    13a0 <atax+0x250>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x38(%rsp)
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x30(%rsp)
mov    $0x1,%bl
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
test   %bl,%bl
jne    1490 <atax+0x340>
movsd  0xb8a(%rip),%xmm0
jmp    149c <atax+0x34c>
movsd  0x30(%rsp),%xmm0
subsd  0x38(%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,0x8(%rsp)
movsd  %xmm0,0x38(%rsp)
jle    1445 <atax+0x2f5>
mov    %r15d,%eax
and    $0x3,%eax
mov    %r15d,%r10d
and    $0xfffffffc,%r10d
mov    %r13,%rdx
add    $0x18,%rdx
xor    %r9d,%r9d
mov    %r13,%r8
mov    0x20(%rsp),%rcx
mov    0x28(%rsp),%r11
jmp    1509 <atax+0x3b9>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm0,(%rcx,%r9,8)
add    $0x1,%r9
add    %r11,%rdx
add    %r11,%r8
cmp    %r15,%r9
je     159c <atax+0x44c>
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
cmp    $0x3,%r14
jb     156b <atax+0x41b>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x18(%rdx,%rbx,8),%xmm1
movsd  -0x10(%rdx,%rbx,8),%xmm2
mulsd  (%r12,%rbx,8),%xmm1
mulsd  0x8(%r12,%rbx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rdx,%rbx,8),%xmm3
mulsd  0x10(%r12,%rbx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rdx,%rbx,8),%xmm0
mulsd  0x18(%r12,%rbx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbx
cmp    %rbx,%r10
jne    1520 <atax+0x3d0>
test   %rax,%rax
je     14f0 <atax+0x3a0>
lea    (%r12,%rbx,8),%rdi
lea    (%r8,%rbx,8),%rbx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rsi,8),%xmm1
mulsd  (%rdi,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1580 <atax+0x430>
jmp    14f0 <atax+0x3a0>
cmpl   $0x0,0x8(%rsp)
jle    1445 <atax+0x2f5>
mov    %r15d,%eax
and    $0xfffffffe,%eax
xor    %ebx,%ebx
mov    %r13,%rdx
mov    0x10(%rsp),%r8
jmp    15d7 <atax+0x487>
nopl   0x0(%rax)
movsd  %xmm0,(%r8,%rbx,8)
add    $0x1,%rbx
add    $0x8,%rdx
cmp    %r15,%rbx
je     1657 <atax+0x507>
xorpd  %xmm0,%xmm0
test   %r14,%r14
je     1630 <atax+0x4e0>
mov    %rdx,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi),%xmm1
mulsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdi,%r15,8),%xmm0
mulsd  0x8(%rcx,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rsi
add    %rbp,%rdi
cmp    %rsi,%rax
jne    15f0 <atax+0x4a0>
test   $0x1,%r15b
je     15c0 <atax+0x470>
jmp    1638 <atax+0x4e8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
test   $0x1,%r15b
je     15c0 <atax+0x470>
mov    %rsi,%rdi
imul   %r15,%rdi
add    %rbx,%rdi
movsd  0x0(%r13,%rdi,8),%xmm1
mulsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    15c0 <atax+0x470>
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
mov    0x8(%rsp),%rax
test   %eax,%eax
movsd  %xmm0,0x30(%rsp)
jle    1452 <atax+0x302>
cmp    $0x4,%eax
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rdi
jae    168a <atax+0x53a>
xor    %eax,%eax
jmp    1762 <atax+0x612>
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    0x28(%rsp),%rsi
and    $0xffffffffffffffe0,%rsi
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
movapd 0x978(%rip),%xmm8
movapd 0x97f(%rip),%xmm9
movaps 0x988(%rip),%xmm4
xorpd  %xmm1,%xmm1
nopl   0x0(%rax)
movupd (%rdi,%rcx,1),%xmm3
movupd 0x10(%rdi,%rcx,1),%xmm6
movupd (%rdx,%rcx,1),%xmm7
movupd 0x10(%rdx,%rcx,1),%xmm2
movapd %xmm3,%xmm5
subpd  %xmm7,%xmm5
movapd %xmm6,%xmm7
subpd  %xmm2,%xmm7
andpd  %xmm8,%xmm5
andpd  %xmm8,%xmm7
divpd  %xmm3,%xmm5
divpd  %xmm6,%xmm7
movapd %xmm9,%xmm2
cmpltpd %xmm5,%xmm2
shufps $0xe8,%xmm2,%xmm2
movapd %xmm9,%xmm3
cmpltpd %xmm7,%xmm3
shufps $0xe8,%xmm3,%xmm3
movaps %xmm2,%xmm5
andnps %xmm0,%xmm5
andps  %xmm4,%xmm2
movaps %xmm2,%xmm0
orps   %xmm5,%xmm0
movaps %xmm3,%xmm2
andnps %xmm1,%xmm2
andps  %xmm4,%xmm3
movaps %xmm3,%xmm1
orps   %xmm2,%xmm1
add    $0x20,%rcx
cmp    %rcx,%rsi
jne    16c0 <atax+0x570>
xorpd  %xmm2,%xmm2
pcmpeqd %xmm0,%xmm2
andps  %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movq   %xmm2,%rcx
xor    %r14d,%r14d
test   %rcx,%rcx
setne  %r14b
cmp    %r15,%rax
je     17a7 <atax+0x657>
movapd 0x8b6(%rip),%xmm0
movsd  0x89e(%rip),%xmm1
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm2
movapd %xmm2,%xmm3
subsd  (%rdx,%rax,8),%xmm3
andpd  %xmm0,%xmm3
divsd  %xmm2,%xmm3
ucomisd %xmm1,%xmm3
cmova  %ecx,%r14d
add    $0x1,%rax
cmp    %rax,%r15
jne    1780 <atax+0x630>
test   %r14d,%r14d
sete   %bl
jmp    1454 <atax+0x304>

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

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