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


x86 assembly (clang, -O0):
<bicg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    0x2e6b(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%rax
mov    %eax,%edi
call   1060 <sqrt@plt>
mov    %eax,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
movslq -0x1c(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     1276 <bicg+0x126>
cmpq   $0x0,-0x48(%rbp)
je     1276 <bicg+0x126>
cmpq   $0x0,-0x50(%rbp)
je     1276 <bicg+0x126>
cmpq   $0x0,-0x58(%rbp)
je     1276 <bicg+0x126>
cmpq   $0x0,-0x60(%rbp)
je     1276 <bicg+0x126>
cmpq   $0x0,-0x68(%rbp)
je     1276 <bicg+0x126>
cmpq   $0x0,-0x70(%rbp)
jne    1288 <bicg+0x138>
movsd  0xd9a(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1701 <bicg+0x5b1>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1359 <bicg+0x209>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xd66(%rip),%xmm1
mov    0x2d37(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xd3b(%rip),%xmm1
mov    0x2d0c(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1346 <bicg+0x1f6>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xcfd(%rip),%xmm1
mov    0x2cce(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%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    12f8 <bicg+0x1a8>
jmp    134b <bicg+0x1fb>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    128f <bicg+0x13f>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13f6 <bicg+0x2a6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13d6 <bicg+0x286>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x18(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1387 <bicg+0x237>
movsd  -0x18(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    136c <bicg+0x21c>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1487 <bicg+0x337>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1467 <bicg+0x317>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x18(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1418 <bicg+0x2c8>
movsd  -0x18(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13fd <bicg+0x2ad>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1524 <bicg+0x3d4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1504 <bicg+0x3b4>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x18(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14b5 <bicg+0x365>
movsd  -0x18(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    149a <bicg+0x34a>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15b5 <bicg+0x465>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1595 <bicg+0x445>
mov    -0x48(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x18(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1546 <bicg+0x3f6>
movsd  -0x18(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    152b <bicg+0x3db>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1626 <bicg+0x4d6>
mov    -0x68(%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 0xa37(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x10(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0xa06(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1613 <bicg+0x4c3>
movl   $0x1,-0x34(%rbp)
jmp    1618 <bicg+0x4c8>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    15bc <bicg+0x46c>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1697 <bicg+0x547>
mov    -0x58(%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 0x9c6(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0x995(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1684 <bicg+0x534>
movl   $0x1,-0x34(%rbp)
jmp    1689 <bicg+0x539>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    162d <bicg+0x4dd>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
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,-0x34(%rbp)
jne    16f4 <bicg+0x5a4>
movsd  -0x30(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1701 <bicg+0x5b1>
movsd  0x904(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bicg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    0x2e7b(%rip),%rax
mov    (%rax),%edi
shr    $0x3,%edi
call   1060 <sqrt@plt>
mov    %eax,%r14d
lea    0x0(,%r14,8),%ebp
mov    %ebp,%edi
imul   %eax,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %ebp,%edi
call   1050 <malloc@plt>
movsd  0xe30(%rip),%xmm0
test   %r15,%r15
je     161f <bicg+0x4cf>
test   %rbx,%rbx
je     161f <bicg+0x4cf>
cmpq   $0x0,0x20(%rsp)
je     161f <bicg+0x4cf>
cmpq   $0x0,0x38(%rsp)
je     161f <bicg+0x4cf>
cmpq   $0x0,0x28(%rsp)
je     161f <bicg+0x4cf>
cmpq   $0x0,0x30(%rsp)
je     161f <bicg+0x4cf>
mov    %rax,%r12
test   %rax,%rax
je     161f <bicg+0x4cf>
test   %r14d,%r14d
jle    14a7 <bicg+0x357>
mov    %rbx,0x10(%rsp)
mov    %r14,0x8(%rsp)
mov    %r14d,%r13d
lea    0x0(,%r13,8),%rax
mov    %rax,0x18(%rsp)
mov    0x2da0(%rip),%rbx
mov    %r15,0x40(%rsp)
mov    %r15,%rbp
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  (%rbx),%xmm1
movsd  0xd95(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    0x10(%rsp),%rax
movsd  %xmm0,(%rax,%r14,8)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  (%rbx),%xmm1
addsd  0xd6f(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%r14,8)
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  (%rbx),%xmm1
addsd  0xd45(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%r15,8)
add    $0x1,%r15
cmp    %r15,%r13
jne    12b0 <bicg+0x160>
add    $0x1,%r14
add    0x18(%rsp),%rbp
cmp    %r13,%r14
jne    1260 <bicg+0x110>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
cmpl   $0x0,0x8(%rsp)
movsd  %xmm0,0x50(%rsp)
jle    15ac <bicg+0x45c>
lea    -0x1(%r13),%r14
mov    %r13d,%eax
and    $0x3,%eax
mov    %r13d,%ecx
and    $0xfffffffc,%ecx
mov    0x40(%rsp),%r15
lea    0x18(%r15),%rdx
xor    %esi,%esi
mov    %r15,%r8
mov    0x28(%rsp),%r9
mov    0x18(%rsp),%r10
jmp    1349 <bicg+0x1f9>
nopl   0x0(%rax,%rax,1)
movsd  %xmm4,(%r9,%rsi,8)
add    $0x1,%rsi
add    %r10,%rdx
add    %r10,%r8
cmp    %r13,%rsi
je     13dd <bicg+0x28d>
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
cmp    $0x3,%r14
jb     13ab <bicg+0x25b>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x18(%rdx,%rbp,8),%xmm1
movsd  -0x10(%rdx,%rbp,8),%xmm2
mulsd  (%r12,%rbp,8),%xmm1
mulsd  0x8(%r12,%rbp,8),%xmm2
addsd  %xmm4,%xmm1
movsd  -0x8(%rdx,%rbp,8),%xmm3
mulsd  0x10(%r12,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rdx,%rbp,8),%xmm4
mulsd  0x18(%r12,%rbp,8),%xmm4
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm4
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    1360 <bicg+0x210>
test   %rax,%rax
je     1330 <bicg+0x1e0>
lea    (%r12,%rbp,8),%rbx
lea    (%r8,%rbp,8),%rbp
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm1,%xmm4
add    $0x1,%rdi
cmp    %rdi,%rax
jne    13c0 <bicg+0x270>
jmp    1330 <bicg+0x1e0>
cmpl   $0x0,0x8(%rsp)
mov    0x10(%rsp),%rbx
jle    15b6 <bicg+0x466>
mov    %r13d,%eax
and    $0xfffffffe,%eax
mov    %r13,%rbp
shl    $0x4,%rbp
xor    %ecx,%ecx
mov    %r15,%rdx
mov    0x20(%rsp),%r8
jmp    1427 <bicg+0x2d7>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm3,(%r8,%rcx,8)
add    $0x1,%rcx
add    $0x8,%rdx
cmp    %r13,%rcx
je     14b9 <bicg+0x369>
test   %r14,%r14
je     1480 <bicg+0x330>
xorpd  %xmm1,%xmm1
mov    %rdx,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rsi,8),%xmm2
mulsd  (%rdi),%xmm2
movsd  0x8(%rbx,%rsi,8),%xmm3
addsd  %xmm1,%xmm2
mulsd  (%rdi,%r13,8),%xmm3
addsd  %xmm2,%xmm3
add    $0x2,%rsi
add    %rbp,%rdi
movapd %xmm3,%xmm1
cmp    %rsi,%rax
jne    1440 <bicg+0x2f0>
test   $0x1,%r13b
je     1410 <bicg+0x2c0>
jmp    148c <bicg+0x33c>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm3,%xmm3
xor    %esi,%esi
test   $0x1,%r13b
je     1410 <bicg+0x2c0>
movsd  (%rbx,%rsi,8),%xmm1
imul   %r13,%rsi
add    %rcx,%rsi
mulsd  (%r15,%rsi,8),%xmm1
addsd  %xmm1,%xmm3
jmp    1410 <bicg+0x2c0>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x50(%rsp)
jmp    15b6 <bicg+0x466>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
cmpl   $0x0,0x8(%rsp)
movsd  %xmm0,0x48(%rsp)
jle    170e <bicg+0x5be>
mov    %r13d,%eax
and    $0x3,%eax
mov    %r13d,%ecx
and    $0xfffffffc,%ecx
mov    %r15,%rdx
add    $0x18,%rdx
xor    %r9d,%r9d
mov    %r15,%r8
mov    0x28(%rsp),%r10
mov    0x30(%rsp),%r11
jmp    151e <bicg+0x3ce>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm4,(%r11,%r9,8)
add    $0x1,%r9
mov    0x18(%rsp),%rsi
add    %rsi,%rdx
add    %rsi,%r8
cmp    %r13,%r9
je     162e <bicg+0x4de>
xorpd  %xmm4,%xmm4
xor    %ebx,%ebx
cmp    $0x3,%r14
jb     157b <bicg+0x42b>
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rbx,8),%xmm1
movsd  -0x10(%rdx,%rbx,8),%xmm2
mulsd  (%r12,%rbx,8),%xmm1
mulsd  0x8(%r12,%rbx,8),%xmm2
addsd  %xmm4,%xmm1
movsd  -0x8(%rdx,%rbx,8),%xmm3
mulsd  0x10(%r12,%rbx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rdx,%rbx,8),%xmm4
mulsd  0x18(%r12,%rbx,8),%xmm4
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm4
add    $0x4,%rbx
cmp    %rbx,%rcx
jne    1530 <bicg+0x3e0>
test   %rax,%rax
je     1500 <bicg+0x3b0>
lea    (%r12,%rbx,8),%rdi
lea    (%r8,%rbx,8),%rbx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rsi,8),%xmm1
mulsd  (%rdi,%rsi,8),%xmm1
addsd  %xmm1,%xmm4
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1590 <bicg+0x440>
jmp    1500 <bicg+0x3b0>
mov    0x40(%rsp),%r15
mov    0x10(%rsp),%rbx
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x48(%rsp)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
test   %ebp,%ebp
je     1613 <bicg+0x4c3>
movsd  0xa07(%rip),%xmm0
jmp    161f <bicg+0x4cf>
movsd  0x48(%rsp),%xmm0
subsd  0x50(%rsp),%xmm0
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmpl   $0x0,0x8(%rsp)
jle    1715 <bicg+0x5c5>
mov    %r13d,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
mov    %r15,%rdx
mov    0x10(%rsp),%rbx
mov    0x20(%rsp),%r8
mov    0x38(%rsp),%r9
jmp    1677 <bicg+0x527>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm0,(%r9,%rcx,8)
add    $0x1,%rcx
add    $0x8,%rdx
cmp    %r13,%rcx
je     16f7 <bicg+0x5a7>
test   %r14,%r14
je     16d0 <bicg+0x580>
xorpd  %xmm1,%xmm1
mov    %rdx,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rsi,8),%xmm2
mulsd  (%rdi),%xmm2
movsd  0x8(%rbx,%rsi,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  (%rdi,%r13,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rsi
add    %rbp,%rdi
movapd %xmm0,%xmm1
cmp    %rsi,%rax
jne    1690 <bicg+0x540>
test   $0x1,%r13b
je     1660 <bicg+0x510>
jmp    16dc <bicg+0x58c>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm0,%xmm0
xor    %esi,%esi
test   $0x1,%r13b
je     1660 <bicg+0x510>
movsd  (%rbx,%rsi,8),%xmm1
imul   %r13,%rsi
add    %rcx,%rsi
mulsd  (%r15,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1660 <bicg+0x510>
mov    0x8(%rsp),%rsi
test   %esi,%esi
jle    170e <bicg+0x5be>
cmp    $0x4,%esi
jae    1721 <bicg+0x5d1>
xor    %eax,%eax
xor    %ebp,%ebp
jmp    1805 <bicg+0x6b5>
xor    %ebp,%ebp
jmp    15c5 <bicg+0x475>
xor    %ebp,%ebp
mov    0x10(%rsp),%rbx
jmp    15c5 <bicg+0x475>
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    0x18(%rsp),%rcx
and    $0xffffffffffffffe0,%rcx
xorpd  %xmm0,%xmm0
xor    %edx,%edx
movapd 0x8e1(%rip),%xmm8
movapd 0x8e8(%rip),%xmm9
movaps 0x8f1(%rip),%xmm4
xorpd  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r11,%rdx,1),%xmm3
movupd 0x10(%r11,%rdx,1),%xmm6
movupd (%r10,%rdx,1),%xmm7
movupd 0x10(%r10,%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    1760 <bicg+0x610>
xorpd  %xmm2,%xmm2
pcmpeqd %xmm0,%xmm2
andps  %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movq   %xmm2,%rcx
xor    %ebp,%ebp
test   %rcx,%rcx
setne  %bpl
cmp    %r13,%rax
je     1848 <bicg+0x6f8>
movapd 0x813(%rip),%xmm0
movsd  0x7fb(%rip),%xmm1
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%r11,%rax,8),%xmm2
movapd %xmm2,%xmm3
subsd  (%r10,%rax,8),%xmm3
andpd  %xmm0,%xmm3
divsd  %xmm2,%xmm3
ucomisd %xmm1,%xmm3
cmova  %ecx,%ebp
add    $0x1,%rax
cmp    %rax,%r13
jne    1820 <bicg+0x6d0>
test   %esi,%esi
jle    15c5 <bicg+0x475>
cmp    $0x4,%esi
jae    185e <bicg+0x70e>
xor    %eax,%eax
mov    %ebp,%edx
jmp    195a <bicg+0x80a>
mov    %r13d,%eax
and    $0xfffffffc,%eax
movd   %ebp,%xmm8
pshufd $0x50,%xmm8,%xmm0
mov    0x18(%rsp),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %ecx,%ecx
movapd 0x79d(%rip),%xmm9
movapd 0x7a4(%rip),%xmm10
movaps 0x7ad(%rip),%xmm5
movdqa %xmm0,%xmm2
nopw   0x0(%rax,%rax,1)
movupd (%r9,%rcx,1),%xmm4
movupd 0x10(%r9,%rcx,1),%xmm7
movupd (%r8,%rcx,1),%xmm1
movupd 0x10(%r8,%rcx,1),%xmm3
movapd %xmm4,%xmm6
subpd  %xmm1,%xmm6
movapd %xmm7,%xmm1
subpd  %xmm3,%xmm1
andpd  %xmm9,%xmm6
andpd  %xmm9,%xmm1
divpd  %xmm4,%xmm6
divpd  %xmm7,%xmm1
movapd %xmm10,%xmm3
cmpltpd %xmm6,%xmm3
shufps $0xe8,%xmm3,%xmm3
movapd %xmm10,%xmm4
cmpltpd %xmm1,%xmm4
shufps $0xe8,%xmm4,%xmm4
movaps %xmm3,%xmm1
andnps %xmm0,%xmm1
andps  %xmm5,%xmm3
movaps %xmm3,%xmm0
orps   %xmm1,%xmm0
movaps %xmm4,%xmm1
andnps %xmm2,%xmm1
andps  %xmm5,%xmm4
movaps %xmm4,%xmm2
orps   %xmm1,%xmm2
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    18a0 <bicg+0x750>
pshufd $0x50,%xmm8,%xmm1
movdqa %xmm0,%xmm3
pcmpeqd %xmm1,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
movq   %xmm3,%rcx
movq   %xmm1,%rdx
cmp    %rdx,%rcx
mov    $0x1,%edx
cmove  %ebp,%edx
cmp    %r13,%rax
jne    195a <bicg+0x80a>
mov    %edx,%ebp
jmp    15c5 <bicg+0x475>
movapd 0x6be(%rip),%xmm0
movsd  0x6a6(%rip),%xmm1
mov    $0x1,%ecx
mov    %edx,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rax,8),%xmm2
movapd %xmm2,%xmm3
subsd  (%r8,%rax,8),%xmm3
andpd  %xmm0,%xmm3
divsd  %xmm2,%xmm3
ucomisd %xmm1,%xmm3
cmova  %ecx,%ebp
add    $0x1,%rax
cmp    %rax,%r13
jne    1980 <bicg+0x830>
jmp    15c5 <bicg+0x475>

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

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