#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 */
struct timespec {
  double tv_sec;
  double tv_nsec;
};

/* Variables and functions */
int /*<<< orphan*/ CLOCK_REALTIME;
int atoi(char *);
int /*<<< orphan*/ clock_gettime(int /*<<< orphan*/, struct timespec *);
int /*<<< orphan*/ dummy(double *, double *, double *, double *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int main(int argc, char **argv) {
  int i, j, n, n2;
  long int r = 1;
  double *a, *b, *c, *d;
  double elapsed, mflops;
  struct timespec start, stop;
  if (argc < 2) {
    printf("Enter a value for N (array length)\n");
    exit(2);
  } else {
    n = atoi(argv[1]);
  }
  if (!(a = (double *)malloc(n * sizeof(double)))) {
    printf("malloc failed (a)\n");
    return 1;
  }
  if (!(b = (double *)malloc(n * sizeof(double)))) {
    printf("malloc failed (b)\n");
    return 1;
  }
  if (!(c = (double *)malloc(n * sizeof(double)))) {
    printf("malloc failed (c)\n");
    return 1;
  }
  if (!(d = (double *)malloc(n * sizeof(double)))) {
    printf("malloc failed (d)\n");
    return 1;
  }
  for (i = 0; i < n; i++) {
    b[i] = 1.0;
    c[i] = 2.0;
    d[i] = 3.0;
  }
  while (1) {
    n2 = n / 2;
    clock_gettime(CLOCK_REALTIME, &start);
    for (j = 0; j < r; j++) {
      for (i = 0; i < n; i++) {
        a[i] = b[i] + c[i] * d[i];
      }
      if (a[n2] < 0) {
        dummy(a, b, c, d);
      }
    }
    clock_gettime(CLOCK_REALTIME, &stop);
    elapsed = (stop.tv_sec - start.tv_sec) +
              (stop.tv_nsec - start.tv_nsec) / (double)1e9;
    if (elapsed > 0.2) {
      break;
    } else {
      r = r * 2;
    }
  }
  mflops = r * n * 2.0 / elapsed / 1e6;
  printf("%d\t%f\n", n, mflops);
  free(a);
  free(b);
  free(c);
  free(d);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x1,-0x28(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    11b3 <main+0x43>
lea    0xe8e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x2,%edi
call   1090 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    11fa <main+0x8a>
lea    0xe6d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    14b0 <main+0x340>
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    1231 <main+0xc1>
lea    0xe49(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    14b0 <main+0x340>
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jne    1268 <main+0xf8>
lea    0xe25(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    14b0 <main+0x340>
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jne    129f <main+0x12f>
lea    0xe01(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    14b0 <main+0x340>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12ff <main+0x18f>
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  0xd66(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  0xd41(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  0xd34(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12a6 <main+0x136>
jmp    1304 <main+0x194>
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
mov    0x2cc7(%rip),%rax
mov    (%rax),%edi
lea    -0x68(%rbp),%rsi
call   1050 <clock_gettime@plt>
movl   $0x0,-0x18(%rbp)
movslq -0x18(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    13d4 <main+0x264>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1396 <main+0x226>
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1340 <main+0x1d0>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    13c1 <main+0x251>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x48(%rbp),%rcx
call   1040 <dummy@plt>
jmp    13c6 <main+0x256>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    132b <main+0x1bb>
mov    0x2c05(%rip),%rax
mov    (%rax),%edi
lea    -0x78(%rbp),%rsi
call   1050 <clock_gettime@plt>
movsd  -0x78(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
subsd  -0x60(%rbp),%xmm1
movsd  0xc06(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xbe4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    142b <main+0x2bb>
jmp    143c <main+0x2cc>
mov    -0x28(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1304 <main+0x194>
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rcx,%rax
cvtsi2sd %rax,%xmm0
movsd  0xbc3(%rip),%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  0xbaa(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x1c(%rbp),%esi
movsd  -0x58(%rbp),%xmm0
lea    0xc22(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
cmp    $0x1,%edi
jle    1792 <main+0x612>
mov    0x8(%rsi),%rdi
call   1090 <atoi@plt>
mov    %rax,0x10(%rsp)
lea    0x0(,%rax,8),%ebx
mov    %ebx,%edi
call   1080 <malloc@plt>
test   %rax,%rax
je     1215 <main+0x95>
mov    %rax,%r13
mov    %ebx,%edi
call   1080 <malloc@plt>
test   %rax,%rax
je     121e <main+0x9e>
mov    %rax,%r15
mov    %ebx,%edi
call   1080 <malloc@plt>
test   %rax,%rax
je     1227 <main+0xa7>
mov    %rax,%r12
mov    %ebx,%edi
call   1080 <malloc@plt>
test   %rax,%rax
je     1230 <main+0xb0>
mov    %rax,%rbx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x18(%rsp)
mov    0x10(%rsp),%rbp
test   %ebp,%ebp
jle    1414 <main+0x294>
mov    %ebp,%eax
cmp    $0x4,%ebp
jae    1253 <main+0xd3>
xor    %ecx,%ecx
jmp    1391 <main+0x211>
lea    0xe3b(%rip),%rdi
jmp    1237 <main+0xb7>
lea    0xe44(%rip),%rdi
jmp    1237 <main+0xb7>
lea    0xe4d(%rip),%rdi
jmp    1237 <main+0xb7>
lea    0xe56(%rip),%rdi
call   1050 <puts@plt>
mov    $0x1,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%r15,%rax,8),%rcx
lea    (%r12,%rax,8),%rdi
lea    (%rbx,%rax,8),%rsi
cmp    %rdi,%r15
setb   %r9b
cmp    %rcx,%r12
setb   %r10b
cmp    %rsi,%r15
setb   %dl
cmp    %rcx,%rbx
setb   %r11b
cmp    %rsi,%r12
setb   %sil
cmp    %rdi,%rbx
setb   %r8b
xor    %ecx,%ecx
test   %r10b,%r9b
jne    1391 <main+0x211>
and    %r11b,%dl
jne    1391 <main+0x211>
and    %r8b,%sil
jne    1391 <main+0x211>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1349 <main+0x1c9>
mov    %rsi,%rdi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rdi
xor    %edx,%edx
movapd 0xd24(%rip),%xmm0
movapd 0xd2c(%rip),%xmm1
movapd 0xd34(%rip),%xmm2
nopl   0x0(%rax)
movupd %xmm0,(%r15,%rdx,8)
movupd %xmm0,0x10(%r15,%rdx,8)
movupd %xmm1,(%r12,%rdx,8)
movupd %xmm1,0x10(%r12,%rdx,8)
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm2,0x10(%rbx,%rdx,8)
movupd %xmm0,0x20(%r15,%rdx,8)
movupd %xmm0,0x30(%r15,%rdx,8)
movupd %xmm1,0x20(%r12,%rdx,8)
movupd %xmm1,0x30(%r12,%rdx,8)
movupd %xmm2,0x20(%rbx,%rdx,8)
movupd %xmm2,0x30(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    12f0 <main+0x170>
jmp    134b <main+0x1cb>
xor    %edx,%edx
test   $0x1,%sil
je     1388 <main+0x208>
movaps 0xca8(%rip),%xmm0
movups %xmm0,(%r15,%rdx,8)
movups %xmm0,0x10(%r15,%rdx,8)
movaps 0xca6(%rip),%xmm0
movups %xmm0,(%r12,%rdx,8)
movups %xmm0,0x10(%r12,%rdx,8)
movapd 0xca3(%rip),%xmm0
movupd %xmm0,(%rbx,%rdx,8)
movupd %xmm0,0x10(%rbx,%rdx,8)
cmp    %rax,%rcx
je     1414 <main+0x294>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     13c9 <main+0x249>
movabs $0x3ff0000000000000,%rsi
mov    %rsi,(%r15,%rcx,8)
movabs $0x4000000000000000,%rsi
mov    %rsi,(%r12,%rcx,8)
movabs $0x4008000000000000,%rsi
mov    %rsi,(%rbx,%rcx,8)
or     $0x1,%rcx
add    %rax,%rdx
je     1414 <main+0x294>
movabs $0x3ff0000000000000,%rdx
movabs $0x4000000000000000,%rsi
movabs $0x4008000000000000,%rdi
nopl   0x0(%rax)
mov    %rdx,(%r15,%rcx,8)
mov    %rsi,(%r12,%rcx,8)
mov    %rdi,(%rbx,%rcx,8)
mov    %rdx,0x8(%r15,%rcx,8)
mov    %rsi,0x8(%r12,%rcx,8)
mov    %rdi,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    13f0 <main+0x270>
movslq %ebp,%rax
mov    %rax,0x20(%rsp)
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
sar    %eax
cltq
mov    %rax,0x58(%rsp)
mov    %ebp,%r14d
lea    0x0(,%r14,8),%rsi
add    %r13,%rsi
lea    (%r15,%r14,8),%rcx
lea    (%r12,%r14,8),%rdi
lea    (%rbx,%r14,8),%r8
and    $0xfffffffc,%ebp
mov    %rbp,0x40(%rsp)
lea    -0x4(%rbp),%rdx
mov    %rdx,0x38(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %rcx,%r13
setb   %cl
cmp    %rsi,%r15
setb   %al
and    %cl,%al
cmp    %rdi,%r13
setb   %dil
cmp    %rsi,%r12
setb   %cl
and    %dil,%cl
or     %al,%cl
cmp    %r8,%r13
setb   %dil
cmp    %rsi,%rbx
setb   %al
and    %dil,%al
or     %cl,%al
mov    %al,0xf(%rsp)
mov    %rdx,%rax
mov    %rdx,0x30(%rsp)
and    %rdx,0x18(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x48(%rsp)
mov    $0x1,%ebp
mov    0x2b27(%rip),%rdx
mov    %r14,0x50(%rsp)
jmp    150e <main+0x38e>
mov    0x2b19(%rip),%rbp
mov    0x0(%rbp),%edi
lea    0x60(%rsp),%rsi
call   1060 <clock_gettime@plt>
mov    %rbp,%rdx
movapd 0x60(%rsp),%xmm0
subpd  0x70(%rsp),%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
divsd  0xb3d(%rip),%xmm1
addsd  %xmm0,%xmm1
mov    0x28(%rsp),%rcx
lea    (%rcx,%rcx,1),%rbp
ucomisd 0xb30(%rip),%xmm1
ja     173a <main+0x5ba>
mov    (%rdx),%edi
lea    0x70(%rsp),%rsi
call   1060 <clock_gettime@plt>
cmp    $0x2,%rbp
mov    $0x1,%esi
mov    %rbp,0x28(%rsp)
cmovae %rbp,%rsi
xor    %ebp,%ebp
mov    0x10(%rsp),%rdx
jmp    154d <main+0x3cd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
cmp    %rsi,%rbp
je     14c0 <main+0x340>
test   %edx,%edx
jle    16ec <main+0x56c>
cmp    $0x4,%edx
setb   %al
or     0xf(%rsp),%al
je     1570 <main+0x3f0>
xor    %ecx,%ecx
jmp    167e <main+0x4fe>
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x38(%rsp)
je     1728 <main+0x5a8>
mov    0x18(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
movupd (%rbx,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd 0x10(%rbx,%rax,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,0x0(%r13,%rax,8)
movupd %xmm0,0x10(%r13,%rax,8)
movupd 0x20(%r15,%rax,8),%xmm0
movupd 0x30(%r15,%rax,8),%xmm1
movupd 0x20(%r12,%rax,8),%xmm2
movupd 0x30(%r12,%rax,8),%xmm3
movupd 0x20(%rbx,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd 0x30(%rbx,%rax,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,0x20(%r13,%rax,8)
movupd %xmm0,0x30(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1590 <main+0x410>
testb  $0x1,0x30(%rsp)
je     1671 <main+0x4f1>
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd (%r12,%rax,8),%xmm2
movupd 0x10(%r12,%rax,8),%xmm3
movupd (%rbx,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd 0x10(%rbx,%rax,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,0x0(%r13,%rax,8)
movupd %xmm0,0x10(%r13,%rax,8)
mov    0x40(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
je     16ec <main+0x56c>
mov    %rcx,%rax
test   $0x1,%r14b
je     16a6 <main+0x526>
movsd  (%r12,%rcx,8),%xmm0
mulsd  (%rbx,%rcx,8),%xmm0
addsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x48(%rsp),%rcx
je     16ec <main+0x56c>
movsd  (%r12,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
mulsd  0x8(%rbx,%rax,8),%xmm0
addsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    16b0 <main+0x530>
mov    0x58(%rsp),%rax
xorpd  %xmm0,%xmm0
ucomisd 0x0(%r13,%rax,8),%xmm0
jbe    1540 <main+0x3c0>
mov    %r13,%rdi
mov    %rsi,%r14
mov    %r15,%rsi
mov    %r12,%rdx
mov    %rbx,%rcx
call   1040 <dummy@plt>
mov    %r14,%rsi
mov    0x50(%rsp),%r14
mov    0x10(%rsp),%rdx
jmp    1540 <main+0x3c0>
xor    %eax,%eax
testb  $0x1,0x30(%rsp)
jne    162e <main+0x4ae>
jmp    1671 <main+0x4f1>
imul   0x20(%rsp),%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %rcx,%xmm0
addsd  %xmm0,%xmm0
divsd  %xmm1,%xmm0
divsd  0x8e8(%rip),%xmm0
lea    0x8f1(%rip),%rdi
mov    0x10(%rsp),%rsi
mov    $0x1,%al
call   1070 <printf@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
jmp    1241 <main+0xc1>
lea    0x906(%rip),%rdi
call   1050 <puts@plt>
mov    $0x2,%edi
call   10a0 <exit@plt>

LLVM IR (-O0):
%struct.timespec = type { double, double }
@.str = [36 x i8] c"Enter a value for N (array length)\0A\00"
@.str.1 = [19 x i8] c"malloc failed (a)\0A\00"
@.str.2 = [19 x i8] c"malloc failed (b)\0A\00"
@.str.3 = [19 x i8] c"malloc failed (c)\0A\00"
@.str.4 = [19 x i8] c"malloc failed (d)\0A\00"
@CLOCK_REALTIME = global i32 0
@.str.5 = [7 x i8] c"%d\09%f\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i64
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double
%16 = alloca double
%17 = alloca %struct.timespec
%18 = alloca %struct.timespec
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i64 1, i64* %10
%19 = load i32, i32* %4
%20 = icmp slt i32 %19, 2
br i1 %20, label %21, label %24
21: ; preds = %2
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
%23 = call i32 @exit(i32 2)
unreachable
24: ; preds = %2
%25 = load i8**, i8*** %5
%26 = getelementptr inbounds i8*, i8** %25, i64 1
%27 = load i8*, i8** %26
%28 = call i32 @atoi(i8* %27)
store i32 %28, i32* %8
br label %29
29: ; preds = %24
%30 = load i32, i32* %8
%31 = sext i32 %30 to i64
%32 = mul i64 %31, 8
%33 = trunc i64 %32 to i32
%34 = call i64 @malloc(i32 %33)
%35 = inttoptr i64 %34 to double*
store double* %35, double** %11
%36 = icmp ne double* %35, null
br i1 %36, label %39, label %37
37: ; preds = %29
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %3
br label %190
39: ; preds = %29
%40 = load i32, i32* %8
%41 = sext i32 %40 to i64
%42 = mul i64 %41, 8
%43 = trunc i64 %42 to i32
%44 = call i64 @malloc(i32 %43)
%45 = inttoptr i64 %44 to double*
store double* %45, double** %12
%46 = icmp ne double* %45, null
br i1 %46, label %49, label %47
47: ; preds = %39
%48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
store i32 1, i32* %3
br label %190
49: ; preds = %39
%50 = load i32, i32* %8
%51 = sext i32 %50 to i64
%52 = mul i64 %51, 8
%53 = trunc i64 %52 to i32
%54 = call i64 @malloc(i32 %53)
%55 = inttoptr i64 %54 to double*
store double* %55, double** %13
%56 = icmp ne double* %55, null
br i1 %56, label %59, label %57
57: ; preds = %49
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.3, i64 0, i64 0))
store i32 1, i32* %3
br label %190
59: ; preds = %49
%60 = load i32, i32* %8
%61 = sext i32 %60 to i64
%62 = mul i64 %61, 8
%63 = trunc i64 %62 to i32
%64 = call i64 @malloc(i32 %63)
%65 = inttoptr i64 %64 to double*
store double* %65, double** %14
%66 = icmp ne double* %65, null
br i1 %66, label %69, label %67
67: ; preds = %59
%68 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.4, i64 0, i64 0))
store i32 1, i32* %3
br label %190
69: ; preds = %59
store i32 0, i32* %6
br label %70
70: ; preds = %87, %69
%71 = load i32, i32* %6
%72 = load i32, i32* %8
%73 = icmp slt i32 %71, %72
br i1 %73, label %74, label %90
74: ; preds = %70
%75 = load double*, double** %12
%76 = load i32, i32* %6
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %75, i64 %77
store double 1.000000e+00, double* %78
%79 = load double*, double** %13
%80 = load i32, i32* %6
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
store double 2.000000e+00, double* %82
%83 = load double*, double** %14
%84 = load i32, i32* %6
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %83, i64 %85
store double 3.000000e+00, double* %86
br label %87
87: ; preds = %74
%88 = load i32, i32* %6
%89 = add nsw i32 %88, 1
store i32 %89, i32* %6
br label %70
90: ; preds = %70
br label %91
91: ; preds = %90, %168
%92 = load i32, i32* %8
%93 = sdiv i32 %92, 2
store i32 %93, i32* %9
%94 = load i32, i32* @CLOCK_REALTIME
%95 = call i32 @clock_gettime(i32 %94, %struct.timespec* %17)
store i32 0, i32* %7
br label %96
96: ; preds = %144, %91
%97 = load i32, i32* %7
%98 = sext i32 %97 to i64
%99 = load i64, i64* %10
%100 = icmp slt i64 %98, %99
br i1 %100, label %101, label %147
101: ; preds = %96
store i32 0, i32* %6
br label %102
102: ; preds = %127, %101
%103 = load i32, i32* %6
%104 = load i32, i32* %8
%105 = icmp slt i32 %103, %104
br i1 %105, label %106, label %130
106: ; preds = %102
%107 = load double*, double** %12
%108 = load i32, i32* %6
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %107, i64 %109
%111 = load double, double* %110
%112 = load double*, double** %13
%113 = load i32, i32* %6
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %112, i64 %114
%116 = load double, double* %115
%117 = load double*, double** %14
%118 = load i32, i32* %6
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %117, i64 %119
%121 = load double, double* %120
%122 = call double @llvm.fmuladd.f64(double %116, double %121, double %111)
%123 = load double*, double** %11
%124 = load i32, i32* %6
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
store double %122, double* %126
br label %127
127: ; preds = %106
%128 = load i32, i32* %6
%129 = add nsw i32 %128, 1
store i32 %129, i32* %6
br label %102
130: ; preds = %102
%131 = load double*, double** %11
%132 = load i32, i32* %9
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds double, double* %131, i64 %133
%135 = load double, double* %134
%136 = fcmp olt double %135, 0.000000e+00
br i1 %136, label %137, label %143
137: ; preds = %130
%138 = load double*, double** %11
%139 = load double*, double** %12
%140 = load double*, double** %13
%141 = load double*, double** %14
%142 = call i32 @dummy(double* %138, double* %139, double* %140, double* %141)
br label %143
143: ; preds = %137, %130
br label %144
144: ; preds = %143
%145 = load i32, i32* %7
%146 = add nsw i32 %145, 1
store i32 %146, i32* %7
br label %96
147: ; preds = %96
%148 = load i32, i32* @CLOCK_REALTIME
%149 = call i32 @clock_gettime(i32 %148, %struct.timespec* %18)
%150 = getelementptr inbounds %struct.timespec, %struct.timespec* %18, i32 0, i32 0
%151 = load double, double* %150
%152 = getelementptr inbounds %struct.timespec, %struct.timespec* %17, i32 0, i32 0
%153 = load double, double* %152
%154 = fsub double %151, %153
%155 = getelementptr inbounds %struct.timespec, %struct.timespec* %18, i32 0, i32 1
%156 = load double, double* %155
%157 = getelementptr inbounds %struct.timespec, %struct.timespec* %17, i32 0, i32 1
%158 = load double, double* %157
%159 = fsub double %156, %158
%160 = fdiv double %159, 1.000000e+09
%161 = fadd double %154, %160
store double %161, double* %15
%162 = load double, double* %15
%163 = fcmp ogt double %162, 2.000000e-01
br i1 %163, label %164, label %165
164: ; preds = %147
br label %169
165: ; preds = %147
%166 = load i64, i64* %10
%167 = mul nsw i64 %166, 2
store i64 %167, i64* %10
br label %168
168: ; preds = %165
br label %91
169: ; preds = %164
%170 = load i64, i64* %10
%171 = load i32, i32* %8
%172 = sext i32 %171 to i64
%173 = mul nsw i64 %170, %172
%174 = sitofp i64 %173 to double
%175 = fmul double %174, 2.000000e+00
%176 = load double, double* %15
%177 = fdiv double %175, %176
%178 = fdiv double %177, 1.000000e+06
store double %178, double* %16
%179 = load i32, i32* %8
%180 = load double, double* %16
%181 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), i32 %179, double %180)
%182 = load double*, double** %11
%183 = call i32 @free(double* %182)
%184 = load double*, double** %12
%185 = call i32 @free(double* %184)
%186 = load double*, double** %13
%187 = call i32 @free(double* %186)
%188 = load double*, double** %14
%189 = call i32 @free(double* %188)
store i32 0, i32* %3
br label %190
190: ; preds = %169, %67, %57, %47, %37
%191 = load i32, i32* %3
ret i32 %191
}

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