#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 mvt() {
  extern unsigned int datasize;
  int n = sqrt(datasize / sizeof(double));
  int i = 0;
  int j = 0;
  double tmp1 = 0;
  double tmp2 = 0;
  int flag1 = 0;
  int flag2 = 0;
  double t_end = 0;
  double t_start = 0;
  double *x1 = (double *)malloc(n * sizeof(double));
  double *x1_Gpu = (double *)malloc(n * sizeof(double));
  double *x2 = (double *)malloc(n * sizeof(double));
  double *x2_Gpu = (double *)malloc(n * sizeof(double));
  double *y1 = (double *)malloc(n * sizeof(double));
  double *y2 = (double *)malloc(n * sizeof(double));
  double *a = (double *)malloc(sizeof(double) * n * n);
  if (x1 == NULL || x1_Gpu == NULL || x2 == NULL || x2_Gpu == NULL ||
      y1 == NULL || y2 == NULL || a == NULL) {
    return (-10000);
  }
  for (i = 0; i < n; i++) {
    x1[i] = (i + 1) / n;
    x1_Gpu[i] = (i + 1) / n;
    x2[i] = (i + 1) / n;
    x2_Gpu[i] = (i + 1) / n;
    y1[i] = (i + 3) / n;
    y2[i] = (i + 4) / n;
    for (j = 0; j < n; j++) {
      a[i * n + j] = ((i + 1) * (j + 1)) / n;
    }
  }
  for (i = 0; i < n; i++) {
    tmp1 = 0;
    for (j = 0; j < n; j++) {
      tmp1 += a[i * n + j] * y1[j];
    }
    x1[i] += tmp1;
  }
  for (i = 0; i < n; i++) {
    tmp2 = 0;
    for (j = 0; j < n; j++) {
      tmp2 += a[j * n + i] * y2[j];
    }
    x2[i] += tmp2;
  }
  tmp1 = 0;
  tmp2 = 0;
  t_start = omp_get_wtime();
#pragma acc data copyin(a [0:n * n], y2 [0:n], y1 [0:n]),                      \
    copy(x1_Gpu [0:n], x2_Gpu [0:n])
  {
#pragma acc parallel loop private(tmp1)
    for (i = 0; i < n; i++) {
      tmp1 = 0;
#pragma acc loop reduction(+ : tmp1)
      for (j = 0; j < n; j++) {
        tmp1 += a[i * n + j] * y1[j];
      }
      x1_Gpu[i] += tmp1;
    }
#pragma acc parallel loop private(tmp2)
    for (i = 0; i < n; i++) {
      tmp2 = 0;
#pragma acc loop reduction(+ : tmp2)
      for (j = 0; j < n; j++) {
        tmp2 += a[j * n + i] * y2[j];
      }
      x2_Gpu[i] += tmp2;
    }
  }
  t_end = omp_get_wtime();
  for (i = 0; i < n; i++) {
    if (fabs(x1[i] - x1_Gpu[i]) / x1[i] > 1e-14) {
      flag1 = 1;
    }
  }
  for (i = 0; i < n; i++) {
    if (fabs(x2[i] - x2_Gpu[i]) / x2[i] > 1e-14) {
      flag2 = 1;
    }
  }
  free(a);
  free(x1);
  free(x1_Gpu);
  free(x2);
  free(x2_Gpu);
  free(y1);
  free(y2);
  if (flag1 == 0 && flag2 == 0)
    return (t_end - t_start);
  else
    return (-11000);
}


x86 assembly (clang, -O0):
<mvt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x2e96(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%rax
mov    %eax,%edi
call   1060 <sqrt@plt>
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x48(%rbp)
je     1278 <mvt+0x138>
cmpq   $0x0,-0x50(%rbp)
je     1278 <mvt+0x138>
cmpq   $0x0,-0x58(%rbp)
je     1278 <mvt+0x138>
cmpq   $0x0,-0x60(%rbp)
je     1278 <mvt+0x138>
cmpq   $0x0,-0x68(%rbp)
je     1278 <mvt+0x138>
cmpq   $0x0,-0x70(%rbp)
je     1278 <mvt+0x138>
cmpq   $0x0,-0x78(%rbp)
jne    128a <mvt+0x14a>
movsd  0xd90(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1776 <mvt+0x636>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13a0 <mvt+0x260>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x3,%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x4,%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    138d <mvt+0x24d>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cltd
idivl  -0xc(%rbp)
cvtsi2sd %eax,%xmm0
mov    -0x78(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1346 <mvt+0x206>
jmp    1392 <mvt+0x252>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1291 <mvt+0x151>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1436 <mvt+0x2f6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1411 <mvt+0x2d1>
mov    -0x78(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13c2 <mvt+0x282>
movsd  -0x20(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13a7 <mvt+0x267>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14cc <mvt+0x38c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14a7 <mvt+0x367>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1458 <mvt+0x318>
movsd  -0x28(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    143d <mvt+0x2fd>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    157e <mvt+0x43e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1559 <mvt+0x419>
mov    -0x78(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    150a <mvt+0x3ca>
movsd  -0x20(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14ef <mvt+0x3af>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1614 <mvt+0x4d4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15ef <mvt+0x4af>
mov    -0x78(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15a0 <mvt+0x460>
movsd  -0x28(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x10(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1585 <mvt+0x445>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1691 <mvt+0x551>
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 0x9cc(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0x99b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    167e <mvt+0x53e>
movl   $0x1,-0x2c(%rbp)
jmp    1683 <mvt+0x543>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1627 <mvt+0x4e7>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1702 <mvt+0x5c2>
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x10(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x95b(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0x92a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    16ef <mvt+0x5af>
movl   $0x1,-0x30(%rbp)
jmp    16f4 <mvt+0x5b4>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1698 <mvt+0x558>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x2c(%rbp)
jne    1769 <mvt+0x629>
cmpl   $0x0,-0x30(%rbp)
jne    1769 <mvt+0x629>
movsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1776 <mvt+0x636>
movsd  0x88f(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mvt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    0x2e93(%rip),%rax
mov    (%rax),%edi
shr    $0x3,%edi
call   1060 <sqrt@plt>
mov    %eax,%r12d
lea    0x0(,%r12,8),%r14d
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
imul   %r12d,%r14d
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,(%rsp)
movsd  0xe38(%rip),%xmm0
test   %rbx,%rbx
je     15c9 <mvt+0x489>
test   %rbp,%rbp
je     15c9 <mvt+0x489>
cmpq   $0x0,0x18(%rsp)
je     15c9 <mvt+0x489>
cmpq   $0x0,0x10(%rsp)
je     15c9 <mvt+0x489>
test   %r15,%r15
je     15c9 <mvt+0x489>
test   %r13,%r13
je     15c9 <mvt+0x489>
cmpq   $0x0,(%rsp)
je     15c9 <mvt+0x489>
mov    %rbp,0x28(%rsp)
mov    %rbx,0x30(%rsp)
test   %r12d,%r12d
jle    153b <mvt+0x3fb>
mov    %r12d,%r10d
lea    -0x1(%r10),%rax
mov    %rax,0x8(%rsp)
mov    %r10d,%r11d
and    $0xfffffffe,%r11d
mov    (%rsp),%rax
lea    0x8(%rax),%r14
lea    0x0(,%r10,8),%rax
mov    %rax,0x20(%rsp)
mov    $0x1,%r9d
mov    $0x2,%ebx
xor    %r8d,%r8d
mov    %r10,0x38(%rsp)
jmp    1275 <mvt+0x135>
nop
add    $0x1,%r9d
add    $0x2,%ebx
add    0x20(%rsp),%r14
cmp    %rsi,%r8
je     137b <mvt+0x23b>
mov    %r8,%r10
add    $0x1,%r8
mov    %r8d,%eax
cltd
idiv   %r12d
mov    %eax,%esi
lea    0x3(%r10),%eax
cltd
idiv   %r12d
mov    %eax,%edi
lea    0x4(%r10),%eax
cltd
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
idiv   %r12d
mov    0x30(%rsp),%rcx
movsd  %xmm0,(%rcx,%r10,8)
mov    0x28(%rsp),%rcx
movsd  %xmm0,(%rcx,%r10,8)
mov    0x18(%rsp),%rcx
movsd  %xmm0,(%rcx,%r10,8)
mov    0x10(%rsp),%rcx
movsd  %xmm0,(%rcx,%r10,8)
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movsd  %xmm0,(%r15,%r10,8)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%r13,%r10,8)
cmpq   $0x0,0x8(%rsp)
je     1340 <mvt+0x200>
mov    %ebx,%esi
mov    %r9d,%edi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edi,%eax
cltd
idiv   %r12d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x8(%r14,%rbp,8)
lea    0x2(%rbp),%rcx
mov    %esi,%eax
cltd
idiv   %r12d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r14,%rbp,8)
add    %ebx,%edi
add    %ebx,%esi
mov    %rcx,%rbp
cmp    %rcx,%r11
jne    1300 <mvt+0x1c0>
jmp    1342 <mvt+0x202>
nopl   0x0(%rax)
xor    %ecx,%ecx
mov    0x38(%rsp),%rsi
test   $0x1,%sil
je     1260 <mvt+0x120>
imul   %rsi,%r10
lea    0x1(%rcx),%edx
mov    %r8d,%eax
imul   %edx,%eax
cltd
idiv   %r12d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
add    %rcx,%r10
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%r10,8)
jmp    1260 <mvt+0x120>
test   %r12d,%r12d
mov    0x20(%rsp),%r11
jle    153b <mvt+0x3fb>
mov    %rsi,%r10
mov    %r10d,%eax
and    $0x3,%eax
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
mov    (%rsp),%r8
lea    0x18(%r8),%rdx
xor    %esi,%esi
mov    0x30(%rsp),%r9
jmp    13cf <mvt+0x28f>
nopl   0x0(%rax)
addsd  (%r9,%rsi,8),%xmm0
movsd  %xmm0,(%r9,%rsi,8)
add    $0x1,%rsi
add    %r11,%rdx
add    %r11,%r8
cmp    %r10,%rsi
je     146d <mvt+0x32d>
cmpq   $0x3,0x8(%rsp)
jae    13e0 <mvt+0x2a0>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
jmp    143b <mvt+0x2fb>
nop
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rbp,8),%xmm1
movsd  -0x10(%rdx,%rbp,8),%xmm2
mulsd  (%r15,%rbp,8),%xmm1
mulsd  0x8(%r15,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rdx,%rbp,8),%xmm3
mulsd  0x10(%r15,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rdx,%rbp,8),%xmm0
mulsd  0x18(%r15,%rbp,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    13f0 <mvt+0x2b0>
test   %rax,%rax
je     13b0 <mvt+0x270>
lea    (%r15,%rbp,8),%rbx
lea    (%r8,%rbp,8),%rbp
xor    %edi,%edi
xchg   %ax,%ax
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1450 <mvt+0x310>
jmp    13b0 <mvt+0x270>
test   %r12d,%r12d
jle    153b <mvt+0x3fb>
mov    %r10d,%eax
and    $0xfffffffe,%eax
mov    %r10,%r14
shl    $0x4,%r14
xor    %ecx,%ecx
mov    (%rsp),%rdx
mov    0x18(%rsp),%rbp
mov    (%rsp),%rbx
jmp    14bd <mvt+0x37d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
add    $0x8,%rdx
cmp    %r10,%rcx
je     15d8 <mvt+0x498>
cmpq   $0x0,0x8(%rsp)
je     1510 <mvt+0x3d0>
xorpd  %xmm0,%xmm0
mov    %rdx,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%rdi),%xmm1
mulsd  0x0(%r13,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdi,%r10,8),%xmm0
mulsd  0x8(%r13,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rsi
add    %r14,%rdi
cmp    %rsi,%rax
jne    14d0 <mvt+0x390>
test   $0x1,%r10b
je     14a0 <mvt+0x360>
jmp    151c <mvt+0x3dc>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorpd  %xmm0,%xmm0
xor    %esi,%esi
test   $0x1,%r10b
je     14a0 <mvt+0x360>
mov    %rsi,%rdi
imul   %r10,%rdi
add    %rcx,%rdi
movsd  (%rbx,%rdi,8),%xmm1
mulsd  0x0(%r13,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    14a0 <mvt+0x360>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x40(%rsp)
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x8(%rsp)
mov    $0x1,%bpl
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
movsd  0xa6c(%rip),%xmm1
test   %bpl,%bpl
jne    15b4 <mvt+0x474>
movapd %xmm1,%xmm0
test   %r14d,%r14d
jne    15c5 <mvt+0x485>
jmp    15c9 <mvt+0x489>
movsd  0x8(%rsp),%xmm0
subsd  0x40(%rsp),%xmm0
test   %r14d,%r14d
je     15c9 <mvt+0x489>
movapd %xmm1,%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>
test   %r12d,%r12d
movsd  %xmm0,0x40(%rsp)
jle    1548 <mvt+0x408>
mov    0x38(%rsp),%r10
mov    %r10d,%eax
and    $0x3,%eax
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
mov    (%rsp),%r8
mov    %r8,%rdx
add    $0x18,%rdx
xor    %esi,%esi
mov    0x28(%rsp),%r9
mov    0x20(%rsp),%r11
jmp    163f <mvt+0x4ff>
nopl   0x0(%rax,%rax,1)
addsd  (%r9,%rsi,8),%xmm4
movsd  %xmm4,(%r9,%rsi,8)
add    $0x1,%rsi
add    %r11,%rdx
add    %r11,%r8
cmp    %r10,%rsi
je     16dd <mvt+0x59d>
cmpq   $0x3,0x8(%rsp)
jae    1650 <mvt+0x510>
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
jmp    16ab <mvt+0x56b>
nop
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rbp,8),%xmm1
movsd  -0x10(%rdx,%rbp,8),%xmm2
mulsd  (%r15,%rbp,8),%xmm1
mulsd  0x8(%r15,%rbp,8),%xmm2
addsd  %xmm4,%xmm1
movsd  -0x8(%rdx,%rbp,8),%xmm3
mulsd  0x10(%r15,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rdx,%rbp,8),%xmm4
mulsd  0x18(%r15,%rbp,8),%xmm4
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm4
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    1660 <mvt+0x520>
test   %rax,%rax
je     1620 <mvt+0x4e0>
lea    (%r15,%rbp,8),%rbx
lea    (%r8,%rbp,8),%rbp
xor    %edi,%edi
xchg   %ax,%ax
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm1,%xmm4
add    $0x1,%rdi
cmp    %rdi,%rax
jne    16c0 <mvt+0x580>
jmp    1620 <mvt+0x4e0>
test   %r12d,%r12d
jle    1548 <mvt+0x408>
mov    %r10d,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
mov    (%rsp),%rdx
mov    0x10(%rsp),%rbp
mov    (%rsp),%rbx
jmp    171d <mvt+0x5dd>
nopl   (%rax)
addsd  0x0(%rbp,%rcx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
add    $0x8,%rdx
cmp    %r10,%rcx
je     179b <mvt+0x65b>
cmpq   $0x0,0x8(%rsp)
je     1770 <mvt+0x630>
xorpd  %xmm2,%xmm2
mov    %rdx,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%rdi),%xmm1
mulsd  0x0(%r13,%rsi,8),%xmm1
addsd  %xmm2,%xmm1
movsd  (%rdi,%r10,8),%xmm2
mulsd  0x8(%r13,%rsi,8),%xmm2
addsd  %xmm1,%xmm2
add    $0x2,%rsi
add    %r14,%rdi
cmp    %rsi,%rax
jne    1730 <mvt+0x5f0>
test   $0x1,%r10b
je     1700 <mvt+0x5c0>
jmp    177c <mvt+0x63c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorpd  %xmm2,%xmm2
xor    %esi,%esi
test   $0x1,%r10b
je     1700 <mvt+0x5c0>
mov    %rsi,%rdi
imul   %r10,%rdi
add    %rcx,%rdi
movsd  (%rbx,%rdi,8),%xmm1
mulsd  0x0(%r13,%rsi,8),%xmm1
addsd  %xmm1,%xmm2
jmp    1700 <mvt+0x5c0>
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
mov    $0x1,%bpl
test   %r12d,%r12d
movsd  %xmm0,0x8(%rsp)
jle    155b <mvt+0x41b>
cmp    $0x4,%r12d
jae    17e5 <mvt+0x6a5>
xor    %eax,%eax
xor    %r14d,%r14d
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdi
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x38(%rsp),%rbx
mov    0x20(%rsp),%r10
jmp    18e2 <mvt+0x7a2>
mov    0x38(%rsp),%rbx
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    0x20(%rsp),%r10
mov    %r10,%rcx
and    $0xffffffffffffffe0,%rcx
xorpd  %xmm0,%xmm0
xor    %edx,%edx
movapd 0x816(%rip),%xmm8
movapd 0x81d(%rip),%xmm9
movaps 0x826(%rip),%xmm4
xorpd  %xmm1,%xmm1
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdi
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rsi,%rdx,1),%xmm3
movupd 0x10(%rsi,%rdx,1),%xmm6
movupd (%rdi,%rdx,1),%xmm7
movupd 0x10(%rdi,%rdx,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,%rdx
cmp    %rdx,%rcx
jne    1840 <mvt+0x700>
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    %rbx,%rax
je     1927 <mvt+0x7e7>
movapd 0x736(%rip),%xmm0
movsd  0x716(%rip),%xmm1
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm2
movapd %xmm2,%xmm3
subsd  (%rdi,%rax,8),%xmm3
andpd  %xmm0,%xmm3
divsd  %xmm2,%xmm3
ucomisd %xmm1,%xmm3
cmova  %ecx,%r14d
add    $0x1,%rax
cmp    %rax,%rbx
jne    1900 <mvt+0x7c0>
test   %r12d,%r12d
jle    155b <mvt+0x41b>
cmp    $0x4,%r12d
jae    193f <mvt+0x7ff>
xor    %eax,%eax
xor    %ecx,%ecx
jmp    1a15 <mvt+0x8d5>
mov    %ebx,%eax
and    $0xfffffffc,%eax
and    $0xffffffffffffffe0,%r10
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
movapd 0x6ca(%rip),%xmm8
movapd 0x6d1(%rip),%xmm9
movaps 0x6da(%rip),%xmm4
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movupd (%r8,%rcx,1),%xmm3
movupd 0x10(%r8,%rcx,1),%xmm6
movupd (%r9,%rcx,1),%xmm7
movupd 0x10(%r9,%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,%r10
jne    1970 <mvt+0x830>
pxor   %xmm2,%xmm2
pcmpeqd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movq   %xmm2,%rdx
xor    %ecx,%ecx
test   %rdx,%rdx
setne  %cl
cmp    %rbx,%rax
je     1a58 <mvt+0x918>
movapd 0x603(%rip),%xmm0
movsd  0x5e3(%rip),%xmm1
mov    $0x1,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%rax,8),%xmm2
movapd %xmm2,%xmm3
subsd  (%r9,%rax,8),%xmm3
andpd  %xmm0,%xmm3
divsd  %xmm2,%xmm3
ucomisd %xmm1,%xmm3
cmova  %edx,%ecx
add    $0x1,%rax
cmp    %rax,%rbx
jne    1a30 <mvt+0x8f0>
test   %ecx,%ecx
sete   %bpl
jmp    155b <mvt+0x41b>

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

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