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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double omp_get_wtime();
int sqrt(unsigned int);
double syrk() {
  extern unsigned int datasize;
  int n = sqrt((datasize / sizeof(double)) / 3);
  double alpha = 12435;
  double beta = 4546;
  int i = 0;
  int j = 0;
  int k = 0;
  double *A = (double *)malloc(n * n * sizeof(double));
  double *C = (double *)malloc(n * n * sizeof(double));
  double *CG = (double *)malloc(n * n * sizeof(double));
  double tmp = 0;
  double t_start = 0;
  double t_end = 0;
  int flag = 0;
  if (A == NULL || C == NULL || CG == NULL) {
    return (-10000);
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      A[i * n + j] = (i * j) / n;
      C[i * n + j] = (i * j + 2) / n;
      CG[i * n + j] = (i * j + 2) / n;
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      C[i * n + j] *= beta;
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      for (k = 0; k < n; k++) {
        C[i * n + j] += alpha * A[i * n + k] * A[j * n + k];
      }
    }
  }
  t_start = omp_get_wtime();
#pragma acc data copyin(A [0:n * n]), copy(CG [0:n * n])
  {
#pragma acc parallel loop
    for (i = 0; i < n; i++) {
#pragma acc loop
      for (j = 0; j < n; j++) {
        CG[i * n + j] *= beta;
      }
    }
#pragma acc parallel loop
    for (i = 0; i < n; i++) {
#pragma acc loop
      for (j = 0; j < n; j++) {
        tmp = CG[i * n + j];
        for (k = 0; k < n; k++) {
          tmp += alpha * A[i * n + k] * A[j * n + k];
        }
        CG[i * n + j] = tmp;
      }
    }
  }
  t_end = omp_get_wtime();
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      if (fabs(C[i * n + j] - CG[i * n + j]) / C[i * n + j] > 1e-14) {
        flag = 1;
      }
    }
  }
  free(A);
  free(C);
  free(CG);
  if (flag == 0)
    return (t_end - t_start);
  else
    return (-11000);
}


x86 assembly (clang, -O0):
<syrk>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x2e99(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%rax
mov    $0x3,%ecx
xor    %edx,%edx
div    %rcx
mov    %eax,%edi
call   1060 <sqrt@plt>
mov    %eax,-0xc(%rbp)
movsd  0xe97(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xe82(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     1220 <syrk+0xe0>
cmpq   $0x0,-0x40(%rbp)
je     1220 <syrk+0xe0>
cmpq   $0x0,-0x48(%rbp)
jne    1232 <syrk+0xf2>
movsd  0xdf8(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    166e <syrk+0x52e>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ee <syrk+0x1ae>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12db <syrk+0x19b>
mov    -0x24(%rbp),%eax
imul   -0x28(%rbp),%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
imul   -0x28(%rbp),%eax
add    $0x2,%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
imul   -0x28(%rbp),%eax
add    $0x2,%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    124c <syrk+0x10c>
jmp    12e0 <syrk+0x1a0>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1239 <syrk+0xf9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1355 <syrk+0x215>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1342 <syrk+0x202>
movsd  -0x20(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1308 <syrk+0x1c8>
jmp    1347 <syrk+0x207>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12f5 <syrk+0x1b5>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1416 <syrk+0x2d6>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1403 <syrk+0x2c3>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13f0 <syrk+0x2b0>
movsd  -0x18(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1382 <syrk+0x242>
jmp    13f5 <syrk+0x2b5>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    136f <syrk+0x22f>
jmp    1408 <syrk+0x2c8>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    135c <syrk+0x21c>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1489 <syrk+0x349>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1476 <syrk+0x336>
movsd  -0x20(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    143c <syrk+0x2fc>
jmp    147b <syrk+0x33b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1429 <syrk+0x2e9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    156a <syrk+0x42a>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1557 <syrk+0x417>
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    152e <syrk+0x3ee>
movsd  -0x18(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d1 <syrk+0x391>
movsd  -0x50(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14a3 <syrk+0x363>
jmp    155c <syrk+0x41c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1490 <syrk+0x350>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1628 <syrk+0x4e8>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1615 <syrk+0x4d5>
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xa61(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0xa27(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1602 <syrk+0x4c2>
movl   $0x1,-0x64(%rbp)
jmp    1607 <syrk+0x4c7>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1590 <syrk+0x450>
jmp    161a <syrk+0x4da>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    157d <syrk+0x43d>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x64(%rbp)
jne    1661 <syrk+0x521>
movsd  -0x60(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    166e <syrk+0x52e>
movsd  0x9a7(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<syrk>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    0x2e93(%rip),%rax
mov    (%rax),%eax
mov    $0xaaaaaaab,%edi
imul   %rax,%rdi
shr    $0x24,%rdi
call   1060 <sqrt@plt>
mov    %eax,%r12d
mov    %eax,%ebp
imul   %eax,%ebp
shl    $0x3,%ebp
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>
movsd  0xe69(%rip),%xmm0
mov    %rbx,0x10(%rsp)
test   %rbx,%rbx
je     14c2 <syrk+0x382>
test   %r14,%r14
je     14c2 <syrk+0x382>
test   %rax,%rax
je     14c2 <syrk+0x382>
mov    %rax,0x18(%rsp)
mov    %r12d,%r15d
test   %r15d,%r15d
jle    146e <syrk+0x32e>
lea    0x0(,%r15,8),%r12
xor    %r8d,%r8d
mov    0x18(%rsp),%r9
mov    %r14,%rbp
mov    0x10(%rsp),%rsi
mov    $0x2,%ecx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
lea    -0x2(%rcx),%eax
cltd
idiv   %r15d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
mov    %ecx,%eax
cltd
idiv   %r15d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
movsd  %xmm0,(%r9,%rdi,8)
add    $0x1,%rdi
add    %r8d,%ecx
cmp    %rdi,%r15
jne    11f0 <syrk+0xb0>
add    $0x1,%r8
add    %r12,%rsi
add    %r12,%rbp
add    %r12,%r9
cmp    %r15,%r8
jne    11e0 <syrk+0xa0>
test   %r15d,%r15d
jle    146e <syrk+0x32e>
mov    %r15d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%r9
mov    %r9,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbx,%r8
and    $0xfffffffffffffffe,%r8
lea    0x30(%r14),%rdx
xor    %esi,%esi
movapd 0xdc3(%rip),%xmm4
mov    %r14,%rdi
jmp    1293 <syrk+0x153>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
add    %r12,%rdx
add    %r12,%rdi
cmp    %r15,%rsi
je     1369 <syrk+0x229>
cmp    $0x4,%r15d
jae    12a0 <syrk+0x160>
xor    %ecx,%ecx
jmp    1340 <syrk+0x200>
test   %r9,%r9
je     1360 <syrk+0x220>
mov    %r8,%rcx
xor    %ebp,%ebp
xchg   %ax,%ax
movupd -0x30(%rdx,%rbp,8),%xmm0
movupd -0x20(%rdx,%rbp,8),%xmm1
movupd -0x10(%rdx,%rbp,8),%xmm2
movupd (%rdx,%rbp,8),%xmm3
mulpd  %xmm4,%xmm0
mulpd  %xmm4,%xmm1
movupd %xmm0,-0x30(%rdx,%rbp,8)
movupd %xmm1,-0x20(%rdx,%rbp,8)
mulpd  %xmm4,%xmm2
mulpd  %xmm4,%xmm3
movupd %xmm2,-0x10(%rdx,%rbp,8)
movupd %xmm3,(%rdx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rcx
jne    12b0 <syrk+0x170>
test   $0x1,%bl
je     1329 <syrk+0x1e9>
mov    %rsi,%rcx
imul   %r15,%rcx
add    %rcx,%rbp
movupd (%r14,%rbp,8),%xmm0
movupd 0x10(%r14,%rbp,8),%xmm1
mulpd  %xmm4,%xmm0
mulpd  %xmm4,%xmm1
movupd %xmm0,(%r14,%rbp,8)
movupd %xmm1,0x10(%r14,%rbp,8)
mov    %rax,%rcx
cmp    %r15,%rax
je     1280 <syrk+0x140>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rcx,8),%xmm0
mulsd  0xcbb(%rip),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1340 <syrk+0x200>
jmp    1280 <syrk+0x140>
xor    %ebp,%ebp
test   $0x1,%bl
jne    12fd <syrk+0x1bd>
jmp    1329 <syrk+0x1e9>
test   %r15d,%r15d
jle    146e <syrk+0x32e>
mov    %rbx,0x28(%rsp)
mov    %r9,0x30(%rsp)
lea    -0x1(%r15),%r13
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    0x10(%rsp),%rcx
lea    0x8(%rcx),%rsi
xor    %r9d,%r9d
movsd  0xc76(%rip),%xmm2
mov    %rsi,0x8(%rsp)
mov    0x10(%rsp),%r8
jmp    13c0 <syrk+0x280>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r12,%rsi
cmp    %r15,%r9
je     14d1 <syrk+0x391>
mov    %r9,%r10
imul   %r15,%r10
mov    0x8(%rsp),%rcx
xor    %r11d,%r11d
jmp    13ec <syrk+0x2ac>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
add    %r12,%rcx
cmp    %r15,%r11
je     13b0 <syrk+0x270>
lea    (%r11,%r10,1),%rdi
movsd  (%r14,%rdi,8),%xmm0
xor    %ebp,%ebp
test   %r13,%r13
je     143b <syrk+0x2fb>
nopl   (%rax)
movsd  -0x8(%rsi,%rbp,8),%xmm1
mulsd  %xmm2,%xmm1
mulsd  -0x8(%rcx,%rbp,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rdi,8)
movsd  (%rsi,%rbp,8),%xmm0
mulsd  %xmm2,%xmm0
mulsd  (%rcx,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rdi,8)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1400 <syrk+0x2c0>
test   $0x1,%r15b
je     13e0 <syrk+0x2a0>
mov    %r11,%rdx
imul   %r15,%rdx
lea    (%r10,%rbp,1),%rbx
movsd  (%r8,%rbx,8),%xmm1
mulsd  %xmm2,%xmm1
add    %rbp,%rdx
mulsd  (%r8,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rdi,8)
jmp    13e0 <syrk+0x2a0>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x20(%rsp)
xor    %r13d,%r13d
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x8(%rsp)
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
test   %r13d,%r13d
je     14b6 <syrk+0x376>
movsd  0xb6c(%rip),%xmm0
jmp    14c2 <syrk+0x382>
movsd  0x8(%rsp),%xmm0
subsd  0x20(%rsp),%xmm0
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
test   %r15d,%r15d
movsd  %xmm0,0x20(%rsp)
jle    147b <syrk+0x33b>
mov    %r15d,%eax
and    $0xfffffffc,%eax
movabs $0x7ffffffffffffffe,%r9
ff ff 7f
mov    0x28(%rsp),%r11
and    %r11,%r9
mov    0x18(%rsp),%r8
lea    0x30(%r8),%rcx
xor    %ebx,%ebx
mov    %r8,%rsi
mov    0x30(%rsp),%r10
movsd  0xaf2(%rip),%xmm5
movapd 0xb12(%rip),%xmm6
jmp    1533 <syrk+0x3f3>
add    $0x1,%rbx
add    %r12,%rcx
add    %r12,%rsi
cmp    %r15,%rbx
je     1606 <syrk+0x4c6>
cmp    $0x4,%r15d
jae    1540 <syrk+0x400>
xor    %edi,%edi
jmp    15e0 <syrk+0x4a0>
test   %r10,%r10
je     15fc <syrk+0x4bc>
mov    %r9,%rbp
xor    %edi,%edi
xchg   %ax,%ax
movupd -0x30(%rcx,%rdi,8),%xmm4
movupd -0x20(%rcx,%rdi,8),%xmm1
movupd -0x10(%rcx,%rdi,8),%xmm2
movupd (%rcx,%rdi,8),%xmm3
mulpd  %xmm6,%xmm4
mulpd  %xmm6,%xmm1
movupd %xmm4,-0x30(%rcx,%rdi,8)
movupd %xmm1,-0x20(%rcx,%rdi,8)
mulpd  %xmm6,%xmm2
mulpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rcx,%rdi,8)
movupd %xmm3,(%rcx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1550 <syrk+0x410>
test   $0x1,%r11b
je     15ca <syrk+0x48a>
mov    %rbx,%rdx
imul   %r15,%rdx
add    %rdx,%rdi
movupd (%r8,%rdi,8),%xmm2
movupd 0x10(%r8,%rdi,8),%xmm1
mulpd  %xmm6,%xmm2
mulpd  %xmm6,%xmm1
movupd %xmm2,(%r8,%rdi,8)
movupd %xmm1,0x10(%r8,%rdi,8)
mov    %rax,%rdi
cmp    %r15,%rax
je     1520 <syrk+0x3e0>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm5,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r15
jne    15e0 <syrk+0x4a0>
jmp    1520 <syrk+0x3e0>
xor    %edi,%edi
test   $0x1,%r11b
jne    159e <syrk+0x45e>
jmp    15ca <syrk+0x48a>
test   %r15d,%r15d
jle    147b <syrk+0x33b>
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    0x10(%rsp),%rsi
add    $0x8,%rsi
xor    %r9d,%r9d
mov    %rsi,0x8(%rsp)
movsd  0x9e2(%rip),%xmm3
jmp    1640 <syrk+0x500>
add    $0x1,%r9
add    %r12,%rsi
cmp    %r15,%r9
je     16e6 <syrk+0x5a6>
mov    %r9,%r10
imul   %r15,%r10
mov    0x8(%rsp),%rcx
xor    %ebx,%ebx
jmp    1662 <syrk+0x522>
movsd  %xmm2,(%r8,%r11,8)
add    $0x1,%rbx
add    %r12,%rcx
cmp    %r15,%rbx
je     1630 <syrk+0x4f0>
lea    (%rbx,%r10,1),%r11
movsd  (%r8,%r11,8),%xmm2
xor    %ebp,%ebp
test   %r13,%r13
je     16af <syrk+0x56f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rsi,%rbp,8),%xmm1
mulsd  %xmm3,%xmm1
mulsd  -0x8(%rcx,%rbp,8),%xmm1
addsd  %xmm2,%xmm1
movsd  (%rsi,%rbp,8),%xmm2
mulsd  %xmm3,%xmm2
mulsd  (%rcx,%rbp,8),%xmm2
addsd  %xmm1,%xmm2
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1680 <syrk+0x540>
test   $0x1,%r15b
je     1650 <syrk+0x510>
mov    %rbx,%rdx
imul   %r15,%rdx
lea    (%r10,%rbp,1),%rdi
mov    0x10(%rsp),%r8
movsd  (%r8,%rdi,8),%xmm1
mulsd  %xmm3,%xmm1
add    %rbp,%rdx
mulsd  (%r8,%rdx,8),%xmm1
mov    0x18(%rsp),%r8
addsd  %xmm1,%xmm2
jmp    1650 <syrk+0x510>
xor    %r13d,%r13d
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
test   %r15d,%r15d
movsd  %xmm0,0x8(%rsp)
jle    148b <syrk+0x34b>
mov    %r15d,%r8d
and    $0xfffffffc,%r8d
mov    0x18(%rsp),%rdi
mov    %rdi,%rcx
add    $0x10,%rcx
mov    %r14,%rdx
add    $0x10,%rdx
mov    %r12,%rsi
and    $0xffffffffffffffe0,%rsi
xor    %r9d,%r9d
movapd 0x915(%rip),%xmm0
movsd  0x8e4(%rip),%xmm9
mov    $0x1,%r10d
movapd 0x90d(%rip),%xmm11
movaps 0x915(%rip),%xmm10
mov    %r14,%rax
xor    %r13d,%r13d
jmp    1779 <syrk+0x639>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
add    %r12,%rcx
add    %r12,%rdx
add    %r12,%rax
add    %r12,%rdi
cmp    %r15,%r9
je     148b <syrk+0x34b>
cmp    $0x4,%r15d
jae    1790 <syrk+0x650>
xor    %ebp,%ebp
jmp    1860 <syrk+0x720>
cs nopw 0x0(%rax,%rax,1)
movd   %r13d,%xmm8
pshufd $0x50,%xmm8,%xmm4
xor    %ebp,%ebp
movdqa %xmm4,%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rbp,1),%xmm2
movupd (%rdx,%rbp,1),%xmm5
movupd -0x10(%rcx,%rbp,1),%xmm1
movupd (%rcx,%rbp,1),%xmm3
movapd %xmm2,%xmm7
subpd  %xmm1,%xmm7
movapd %xmm5,%xmm1
subpd  %xmm3,%xmm1
andpd  %xmm0,%xmm7
andpd  %xmm0,%xmm1
divpd  %xmm2,%xmm7
divpd  %xmm5,%xmm1
movapd %xmm11,%xmm2
cmpltpd %xmm7,%xmm2
shufps $0xe8,%xmm2,%xmm2
movapd %xmm11,%xmm3
cmpltpd %xmm1,%xmm3
shufps $0xe8,%xmm3,%xmm3
movaps %xmm2,%xmm1
andnps %xmm4,%xmm1
andps  %xmm10,%xmm2
movaps %xmm2,%xmm4
orps   %xmm1,%xmm4
movaps %xmm3,%xmm1
andnps %xmm6,%xmm1
andps  %xmm10,%xmm3
movaps %xmm3,%xmm6
orps   %xmm1,%xmm6
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    17b0 <syrk+0x670>
pshufd $0x50,%xmm8,%xmm1
movaps %xmm4,%xmm2
pcmpeqd %xmm1,%xmm2
andps  %xmm2,%xmm6
andnps %xmm4,%xmm2
orps   %xmm6,%xmm2
movq   %xmm2,%rbp
movq   %xmm1,%rbx
cmp    %rbx,%rbp
cmovne %r10d,%r13d
mov    %r8,%rbp
cmp    %r15,%r8
je     1760 <syrk+0x620>
xchg   %ax,%ax
movsd  (%rax,%rbp,8),%xmm1
movapd %xmm1,%xmm2
subsd  (%rdi,%rbp,8),%xmm2
andpd  %xmm0,%xmm2
divsd  %xmm1,%xmm2
ucomisd %xmm9,%xmm2
cmova  %r10d,%r13d
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1860 <syrk+0x720>
jmp    1760 <syrk+0x620>

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

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