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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double RAND_MAX;
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double omp_get_wtime();
double rand();
int sqrt(unsigned int);
double twodconv() {
  int i = 0;
  int j = 0;
  double c11, c12, c13, c21, c22, c23, c31, c32, c33;
  double t_start = 0;
  double t_end = 0;
  extern unsigned int datasize;
  int n = sqrt((datasize / sizeof(double)) / 2);
  int flag = 0;
  double *A = (double *)malloc(n * n * sizeof(double));
  double *B = (double *)malloc(n * n * sizeof(double));
  double *B_Gpu = (double *)malloc(n * n * sizeof(double));
  if (A == NULL || B == NULL || B_Gpu == NULL) {
    return (-10000);
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      A[i * n + j] = rand() / (1.0 + RAND_MAX);
    }
  }
  c11 = +2;
  c21 = +5;
  c31 = -8;
  c12 = -3;
  c22 = +6;
  c32 = -9;
  c13 = +4;
  c23 = +7;
  c33 = +10;
  for (i = 1; i < n - 1; i++) {
    for (j = 1; j < n - 1; j++) {
      B[i * n + j] = c11 * A[(i - 1) * n + (j - 1)] + c12 * A[i * n + (j - 1)] +
                     c13 * A[(i + 1) * n + (j - 1)] + c21 * A[(i - 1) * n + j] +
                     c22 * A[i * n + j] + c23 * A[(i + 1) * n + j] +
                     c31 * A[(i - 1) * n + (j + 1)] + c32 * A[i * n + (j + 1)] +
                     c33 * A[(i + 1) * n + (j + 1)];
    }
  }
  t_start = omp_get_wtime();
#pragma acc data copyin(A [0:n * n]), copyout(B_Gpu [0:n * n])
  {
#pragma acc kernels
#pragma acc loop independent
    for (i = 1; i < n - 1; i++) {
      for (j = 1; j < n - 1; j++) {
        B_Gpu[i * n + j] =
            c11 * A[(i - 1) * n + (j - 1)] + c12 * A[i * n + (j - 1)] +
            c13 * A[(i + 1) * n + (j - 1)] + c21 * A[(i - 1) * n + j] +
            c22 * A[i * n + j] + c23 * A[(i + 1) * n + j] +
            c31 * A[(i - 1) * n + (j + 1)] + c32 * A[i * n + (j + 1)] +
            c33 * A[(i + 1) * n + (j + 1)];
      }
    }
  }
  t_end = omp_get_wtime();
  for (i = 1; i < n - 1; i++) {
    for (j = 1; j < n - 1; j++) {
      if (fabs(B[i * n + j] - B_Gpu[i * n + j]) / B[i * n + j] > 1e-14) {
        flag = 1;
      }
    }
  }
  free(A);
  free(B);
  free(B_Gpu);
  if (flag == 0)
    return (t_end - t_start);
  else
    return (-11000);
}


x86 assembly (clang, -O0):
<twodconv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x2e60(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%rax
shr    $0x1,%rax
mov    %eax,%edi
call   1060 <sqrt@plt>
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
imul   -0x6c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x6c(%rbp),%eax
imul   -0x6c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0x6c(%rbp),%eax
imul   -0x6c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x88(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     120a <twodconv+0xba>
cmpq   $0x0,-0x80(%rbp)
je     120a <twodconv+0xba>
cmpq   $0x0,-0x88(%rbp)
jne    121c <twodconv+0xcc>
movsd  0xe4e(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    17c3 <twodconv+0x673>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1297 <twodconv+0x147>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1284 <twodconv+0x134>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xe07(%rip),%xmm1
mov    0x2d90(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1236 <twodconv+0xe6>
jmp    1289 <twodconv+0x139>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1223 <twodconv+0xd3>
movsd  0xda1(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xd8c(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xd77(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xd62(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  0xd4d(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xd38(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xd23(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xd0e(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xcf9(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14d6 <twodconv+0x386>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14c3 <twodconv+0x373>
movsd  -0x18(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x20(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    132b <twodconv+0x1db>
jmp    14c8 <twodconv+0x378>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1313 <twodconv+0x1c3>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    16af <twodconv+0x55f>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    169c <twodconv+0x54c>
movsd  -0x18(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x20(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1501 <twodconv+0x3b1>
jmp    16a1 <twodconv+0x551>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14e9 <twodconv+0x399>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    177a <twodconv+0x62a>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1767 <twodconv+0x617>
mov    -0x80(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x94f(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x80(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0x90d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1754 <twodconv+0x604>
movl   $0x1,-0x70(%rbp)
jmp    1759 <twodconv+0x609>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    16da <twodconv+0x58a>
jmp    176c <twodconv+0x61c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    16c2 <twodconv+0x572>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x70(%rbp)
jne    17b6 <twodconv+0x666>
movsd  -0x68(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    17c3 <twodconv+0x673>
movsd  0x88a(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<twodconv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    0x2e78(%rip),%rax
mov    (%rax),%edi
shr    $0x4,%edi
call   1060 <sqrt@plt>
mov    %eax,%r13d
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>
mov    %rax,0x18(%rsp)
movsd  0xe5b(%rip),%xmm0
mov    %rbx,0x8(%rsp)
test   %rbx,%rbx
je     1690 <twodconv+0x540>
test   %r14,%r14
je     1690 <twodconv+0x540>
cmpq   $0x0,0x18(%rsp)
je     1690 <twodconv+0x540>
mov    %r14,0x30(%rsp)
test   %r13d,%r13d
jle    1639 <twodconv+0x4e9>
mov    %r13d,%r12d
lea    0x0(,%r12,8),%rax
mov    %rax,0x20(%rsp)
mov    0x2dfb(%rip),%r15
mov    0x8(%rsp),%rbp
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  0xde9(%rip),%xmm2
movsd  (%r15),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1210 <twodconv+0xc0>
add    $0x1,%r14
add    0x20(%rsp),%rbp
cmp    %r12,%r14
jne    1200 <twodconv+0xb0>
cmp    $0x3,%r13d
jl     1639 <twodconv+0x4e9>
mov    %r13,0x78(%rsp)
lea    -0x1(%r13),%eax
mov    %eax,%r14d
lea    0x1(%r12),%rax
mov    %rax,0xb0(%rsp)
lea    (%r12,%r14,1),%rax
mov    %rax,0xa8(%rsp)
lea    (%r12,%r12,1),%rax
mov    %rax,0xa0(%rsp)
lea    0x1(%r14,%r12,2),%rax
mov    %rax,0x98(%rsp)
lea    0x1(%r12,%r14,1),%rax
mov    %rax,0x90(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x88(%rsp)
lea    -0x1(%r14),%rax
mov    %rax,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x80(%rsp)
mov    %rax,0x10(%rsp)
or     $0x1,%rax
mov    %rax,0x50(%rsp)
mov    0x8(%rsp),%rax
lea    0x10(%rax),%rcx
lea    (%rax,%r12,8),%rdx
add    $0x10,%rdx
mov    %r12,%rsi
shl    $0x4,%rsi
mov    %rsi,0xb8(%rsp)
add    %rax,%rsi
add    $0x10,%rsi
mov    0x30(%rsp),%rdi
lea    0x8(%rdi,%r12,8),%r11
lea    -0x1(%r12,%r12,1),%rbp
lea    -0x1(%r12),%rdi
mov    %rdi,0x48(%rsp)
mov    $0x1,%edi
xor    %ebx,%ebx
mov    %rbx,0x58(%rsp)
mov    %rax,0x40(%rsp)
mov    %r12,0x38(%rsp)
mov    %r14,0x60(%rsp)
jmp    136c <twodconv+0x21c>
nopl   0x0(%rax,%rax,1)
addq   $0x1,0x58(%rsp)
mov    0x20(%rsp),%rax
add    %rax,%rcx
add    %rax,%rdx
add    %rax,%rsi
add    %rax,%r11
add    %r12,%rbp
add    %r12,0x38(%rsp)
add    %r12,0x48(%rsp)
add    %rax,0x40(%rsp)
mov    0x60(%rsp),%r14
mov    0x70(%rsp),%rdi
cmp    %r14,%rdi
je     16a2 <twodconv+0x552>
add    $0x1,%rdi
mov    %rdi,0x70(%rsp)
mov    $0x1,%eax
cmpq   $0x2,0x10(%rsp)
jb     1530 <twodconv+0x3e0>
mov    0x58(%rsp),%rax
imul   %r12,%rax
mov    0xb0(%rsp),%rdi
lea    (%rdi,%rax,1),%rbx
mov    0xa8(%rsp),%rdi
lea    (%rdi,%rax,1),%r9
mov    0x30(%rsp),%rdi
mov    %rbp,0x28(%rsp)
lea    (%rdi,%rbx,8),%rbp
mov    0x88(%rsp),%rbx
lea    (%rbx,%rax,1),%r15
mov    0x8(%rsp),%r8
lea    (%r8,%rax,8),%rbx
mov    %rbx,0x68(%rsp)
mov    0x90(%rsp),%rbx
lea    (%rbx,%rax,1),%r13
lea    (%rax,%r12,1),%r14
mov    0x98(%rsp),%rbx
add    %rax,%rbx
lea    (%r8,%rbx,8),%rbx
add    0xa0(%rsp),%rax
cmp    %rbx,%rbp
lea    (%rdi,%r9,8),%r10
lea    (%r8,%rax,8),%rax
setb   %r9b
cmp    %r10,%rax
lea    (%r8,%r13,8),%rax
setb   %r13b
cmp    %rax,%rbp
lea    (%r8,%r14,8),%rax
setb   %bl
cmp    %r10,%rax
lea    (%r8,%r15,8),%rax
setb   %r14b
cmp    %rax,%rbp
mov    0x28(%rsp),%rbp
setb   %r8b
cmp    %r10,0x68(%rsp)
setb   %r10b
mov    $0x1,%eax
test   %r13b,%r9b
jne    1530 <twodconv+0x3e0>
mov    $0x1,%eax
and    %r14b,%bl
jne    1530 <twodconv+0x3e0>
mov    $0x1,%eax
and    %r10b,%r8b
jne    1530 <twodconv+0x3e0>
xor    %eax,%eax
mov    0x80(%rsp),%rdi
xchg   %ax,%ax
movupd -0x10(%rdx,%rax,8),%xmm1
movupd -0x8(%rdx,%rax,8),%xmm2
movupd (%rdx,%rax,8),%xmm0
mulpd  0xbd7(%rip),%xmm1
movupd -0x10(%rcx,%rax,8),%xmm3
movupd -0x8(%rcx,%rax,8),%xmm4
movupd (%rcx,%rax,8),%xmm5
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd -0x10(%rsi,%rax,8),%xmm1
movupd -0x8(%rsi,%rax,8),%xmm6
movupd (%rsi,%rax,8),%xmm7
mulpd  0xbb5(%rip),%xmm1
addpd  %xmm3,%xmm1
mulpd  0xbb9(%rip),%xmm4
addpd  %xmm1,%xmm4
mulpd  0xbbd(%rip),%xmm2
addpd  %xmm4,%xmm2
mulpd  0xbc1(%rip),%xmm6
addpd  %xmm2,%xmm6
mulpd  0xbc5(%rip),%xmm5
addpd  %xmm6,%xmm5
mulpd  0xbc9(%rip),%xmm0
addpd  %xmm5,%xmm0
mulpd  0xbcd(%rip),%xmm7
addpd  %xmm0,%xmm7
movupd %xmm7,(%r11,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1470 <twodconv+0x320>
mov    0x50(%rsp),%rax
cmp    %rdi,0x10(%rsp)
je     1330 <twodconv+0x1e0>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%r14
sub    %rax,%r14
mov    %rbp,%r10
add    %rax,%rbp
mov    0x8(%rsp),%rbx
lea    (%rbx,%rbp,8),%r8
mov    0x38(%rsp),%rdi
lea    (%rax,%rdi,1),%rbp
mov    0x30(%rsp),%rdi
lea    (%rdi,%rbp,8),%r9
mov    0x48(%rsp),%rdi
lea    (%rax,%rdi,1),%rbp
lea    (%rbx,%rbp,8),%r15
mov    %r10,%rbp
mov    0x40(%rsp),%rdi
lea    (%rdi,%rax,8),%r13
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rax,8),%xmm0
mulsd  0xa82(%rip),%xmm0
movsd  -0x8(%r13,%rax,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r8,%rax,8),%xmm0
mulsd  0xa6d(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  0xa62(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  0xa57(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0x8(%r8,%rax,8),%xmm1
mulsd  0xa4c(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x8(%r13,%rax,8),%xmm0
mulsd  0xa41(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  0x10(%r15,%rax,8),%xmm1
mulsd  0xa36(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r8,%rax,8),%xmm0
mulsd  0xa2b(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1580 <twodconv+0x430>
jmp    1330 <twodconv+0x1e0>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x50(%rsp)
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x20(%rsp)
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
test   %ebx,%ebx
je     1684 <twodconv+0x534>
movsd  0x9d6(%rip),%xmm0
jmp    1690 <twodconv+0x540>
movsd  0x20(%rsp),%xmm0
subsd  0x50(%rsp),%xmm0
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x50(%rsp)
cmpl   $0x3,0x78(%rsp)
jl     1646 <twodconv+0x4f6>
mov    0x10(%rsp),%rax
or     $0x1,%rax
mov    %rax,0xc0(%rsp)
mov    0x8(%rsp),%r15
lea    0x10(%r15),%rcx
lea    (%r15,%r12,8),%rdx
add    $0x10,%rdx
mov    0xb8(%rsp),%rax
lea    0x10(%rax,%r15,1),%rsi
mov    0x18(%rsp),%rax
lea    0x8(%rax,%r12,8),%r11
lea    -0x1(%r12,%r12,1),%rax
mov    %rax,0x48(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,0x40(%rsp)
mov    $0x1,%eax
xor    %edi,%edi
mov    %rdi,0x38(%rsp)
mov    %r12,%r13
movsd  0x8f5(%rip),%xmm8
movsd  0x8f4(%rip),%xmm9
movsd  0x8f3(%rip),%xmm10
movsd  0x8f2(%rip),%xmm11
movsd  0x8f1(%rip),%xmm12
movsd  0x8f0(%rip),%xmm13
movsd  0x8ef(%rip),%xmm14
movsd  0x8ee(%rip),%xmm15
jmp    1795 <twodconv+0x645>
nopl   0x0(%rax)
addq   $0x1,0x38(%rsp)
mov    0x20(%rsp),%rax
add    %rax,%rcx
add    %rax,%rdx
add    %rax,%rsi
add    %rax,%r11
add    %r12,0x48(%rsp)
add    %r12,%r13
add    %r12,0x40(%rsp)
add    %rax,%r15
mov    0x70(%rsp),%rax
cmp    %r14,%rax
je     1a71 <twodconv+0x921>
add    $0x1,%rax
mov    %rax,0x70(%rsp)
mov    $0x1,%eax
cmpq   $0x2,0x10(%rsp)
jb     1990 <twodconv+0x840>
mov    0x38(%rsp),%rax
imul   %r12,%rax
mov    0xb0(%rsp),%rdi
lea    (%rdi,%rax,1),%rbp
mov    0xa8(%rsp),%rdi
add    %rax,%rdi
mov    %rdi,0x68(%rsp)
mov    0x18(%rsp),%rdi
lea    (%rdi,%rbp,8),%rbp
mov    0x88(%rsp),%rbx
lea    (%rbx,%rax,1),%rbx
mov    %rbx,0x28(%rsp)
mov    0x8(%rsp),%r14
lea    (%r14,%rax,8),%rbx
mov    %rbx,0x58(%rsp)
mov    0x90(%rsp),%rbx
lea    (%rbx,%rax,1),%r10
lea    (%rax,%r12,1),%r8
mov    0x98(%rsp),%rbx
lea    (%rbx,%rax,1),%r9
lea    (%r14,%r9,8),%r9
add    0xa0(%rsp),%rax
cmp    %r9,%rbp
mov    0x68(%rsp),%rbx
lea    (%rdi,%rbx,8),%rdi
lea    (%r14,%rax,8),%rax
setb   %r9b
cmp    %rdi,%rax
lea    (%r14,%r10,8),%rax
setb   %r10b
cmp    %rax,%rbp
lea    (%r14,%r8,8),%rax
setb   %bl
cmp    %rdi,%rax
mov    0x28(%rsp),%rax
lea    (%r14,%rax,8),%rax
mov    0x60(%rsp),%r14
setb   0x28(%rsp)
cmp    %rax,%rbp
setb   %r8b
cmp    %rdi,0x58(%rsp)
setb   %dil
mov    $0x1,%eax
test   %r10b,%r9b
jne    1990 <twodconv+0x840>
mov    $0x1,%eax
and    0x28(%rsp),%bl
jne    1990 <twodconv+0x840>
mov    $0x1,%eax
and    %dil,%r8b
jne    1990 <twodconv+0x840>
xor    %eax,%eax
mov    0x80(%rsp),%rdi
movapd 0x80f(%rip),%xmm9
movapd 0x816(%rip),%xmm8
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rax,8),%xmm1
movupd -0x8(%rdx,%rax,8),%xmm2
movupd (%rdx,%rax,8),%xmm0
mulpd  0x787(%rip),%xmm1
movupd -0x10(%rcx,%rax,8),%xmm3
movupd -0x8(%rcx,%rax,8),%xmm4
movupd (%rcx,%rax,8),%xmm5
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd -0x10(%rsi,%rax,8),%xmm1
movupd -0x8(%rsi,%rax,8),%xmm6
movupd (%rsi,%rax,8),%xmm7
mulpd  0x765(%rip),%xmm1
addpd  %xmm3,%xmm1
mulpd  0x769(%rip),%xmm4
addpd  %xmm1,%xmm4
mulpd  0x76d(%rip),%xmm2
addpd  %xmm4,%xmm2
mulpd  0x771(%rip),%xmm6
addpd  %xmm2,%xmm6
mulpd  0x775(%rip),%xmm5
addpd  %xmm6,%xmm5
mulpd  %xmm9,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm8,%xmm7
addpd  %xmm0,%xmm7
movupd %xmm7,(%r11,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    18c0 <twodconv+0x770>
mov    0xc0(%rsp),%rax
cmp    %rdi,0x10(%rsp)
movsd  0x696(%rip),%xmm8
movsd  0x695(%rip),%xmm9
je     1760 <twodconv+0x610>
nopl   0x0(%rax)
mov    %r14,%rbx
sub    %rax,%rbx
mov    0x48(%rsp),%rdi
add    %rax,%rdi
mov    0x8(%rsp),%r10
lea    (%r10,%rdi,8),%r8
lea    (%rax,%r13,1),%rdi
mov    0x18(%rsp),%rbp
lea    0x0(%rbp,%rdi,8),%r9
mov    0x40(%rsp),%rdi
add    %rax,%rdi
lea    (%r10,%rdi,8),%rbp
lea    (%r15,%rax,8),%rax
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r10,8),%xmm0
mulsd  %xmm8,%xmm0
movsd  -0x8(%rax,%r10,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r8,%r10,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rax,%r10,8),%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
movsd  0x8(%rbp,%r10,8),%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm1,%xmm0
movsd  0x8(%r8,%r10,8),%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm0,%xmm1
movsd  0x8(%rax,%r10,8),%xmm0
mulsd  %xmm13,%xmm0
addsd  %xmm1,%xmm0
movsd  0x10(%rbp,%r10,8),%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r8,%r10,8),%xmm0
mulsd  %xmm15,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%r10,8)
add    $0x1,%r10
cmp    %r10,%rbx
jne    19d0 <twodconv+0x880>
jmp    1760 <twodconv+0x610>
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x20(%rsp)
movslq 0x78(%rsp),%rcx
mov    0x10(%rsp),%rax
and    $0xfffffffffffffffc,%rax
lea    0x1(%rax),%r8
mov    0x18(%rsp),%rsi
lea    (%rsi,%rcx,8),%rdx
add    $0x18,%rdx
lea    0x0(,%rcx,8),%r9
mov    0x30(%rsp),%r15
lea    0x18(%r15,%rcx,8),%rdi
lea    (%r15,%rcx,8),%rbp
lea    (%rsi,%rcx,8),%rcx
mov    $0x1,%r10d
movapd 0x619(%rip),%xmm0
movsd  0x580(%rip),%xmm9
mov    $0x1,%r11d
movapd 0x611(%rip),%xmm11
movaps 0x619(%rip),%xmm10
jmp    1b09 <twodconv+0x9b9>
nopl   0x0(%rax)
add    $0x1,%r10
add    %r9,%rdx
add    %r9,%rdi
add    %r9,%rbp
add    %r9,%rcx
cmp    %r14,%r10
je     165a <twodconv+0x50a>
cmpq   $0x4,0x10(%rsp)
jae    1b20 <twodconv+0x9d0>
mov    $0x1,%esi
jmp    1c00 <twodconv+0xab0>
nopl   0x0(%rax,%rax,1)
movd   %ebx,%xmm8
pshufd $0x50,%xmm8,%xmm4
xor    %esi,%esi
movdqa %xmm4,%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rsi,8),%xmm2
movupd (%rdi,%rsi,8),%xmm5
movupd -0x10(%rdx,%rsi,8),%xmm1
movupd (%rdx,%rsi,8),%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    $0x4,%rsi
cmp    %rsi,%rax
jne    1b40 <twodconv+0x9f0>
pshufd $0x50,%xmm8,%xmm1
movaps %xmm4,%xmm2
pcmpeqd %xmm1,%xmm2
andps  %xmm2,%xmm6
andnps %xmm4,%xmm2
orps   %xmm6,%xmm2
movq   %xmm2,%r14
movq   %xmm1,%rsi
cmp    %rsi,%r14
cmovne %r11d,%ebx
mov    %r8,%rsi
cmp    %rax,0x10(%rsp)
mov    0x60(%rsp),%r14
je     1af0 <twodconv+0x9a0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rsi,8),%xmm1
movapd %xmm1,%xmm2
subsd  (%rcx,%rsi,8),%xmm2
andpd  %xmm0,%xmm2
divsd  %xmm1,%xmm2
ucomisd %xmm9,%xmm2
cmova  %r11d,%ebx
add    $0x1,%rsi
cmp    %rsi,%r14
jne    1c00 <twodconv+0xab0>
jmp    1af0 <twodconv+0x9a0>

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

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