#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 {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ CLOCK_MONOTONIC_RAW;
scalar_t__ RAND_MAX;
int /*<<< orphan*/ clock_gettime(int /*<<< orphan*/, struct timespec *);
int /*<<< orphan*/ elapsed_time_hr(struct timespec, struct timespec, char *);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int omp_get_num_threads();
scalar_t__ omp_get_thread_num();
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ rand();
void double_stencil5(unsigned int size) {
  int i, j, iter;
  int n = size - 2;
  double fac = 1.0 / 8;
  double *a0 = (double *)malloc(sizeof(double) * size * size);
  double *a1 = (double *)malloc(sizeof(double) * size * size);
  if (a0 == NULL || a1 == NULL) {
    printf(
        "9-point Double Precision Stencil Error: Unable to allocate memory\n");
  }
#pragma omp parallel
  {
    if (omp_get_thread_num() == 0) {
      printf("Running on Host with %d OpenMP thread(s):\n\n",
             omp_get_num_threads());
    }
  }
  struct timespec start, end;
#pragma omp parallel for private(j)
  for (i = 0; i < size; i++) {
    for (j = 0; j < size; j++) {
      a0[i * size + j] = 0.0;
    }
  }
#pragma omp parallel for private(j)
  for (i = 1; i < n + 1; i++) {
    for (j = 1; j < n + 1; j++) {
      a0[i * size + j] = (double)rand() / (double)(1.0 + RAND_MAX);
    }
  }
  clock_gettime(CLOCK_MONOTONIC_RAW, &start);
  for (iter = 0; iter < 100; iter++) {
#pragma omp parallel
    {
#pragma omp for private(j)
      for (i = 1; i < n + 1; i++) {
        for (j = 1; j < n + 1; j++) {
          a1[i * size + j] = (a0[i * size + (j - 1)] + a0[i * size + (j + 1)] +
                              a0[(i - 1) * size + j] + a0[(i + 1) * size + j]) *
                             fac;
        }
      }
#pragma omp for private(j)
      for (i = 1; i < n + 1; i++) {
        for (j = 1; j < n + 1; j++) {
          a0[i * size + j] = a1[i * size + j];
        }
      }
    }
  }
  clock_gettime(CLOCK_MONOTONIC_RAW, &end);
  elapsed_time_hr(start, end, "Double Precision Stencil - 5 point");
  free(a0);
  free(a1);
}


x86 assembly (clang, -O0):
<double_stencil5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x14(%rbp)
movsd  0xe64(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x3,%rax
mov    -0x4(%rbp),%ecx
imul   %rcx,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x3,%rax
mov    -0x4(%rbp),%ecx
imul   %rcx,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     11e9 <double_stencil5+0x69>
cmpq   $0x0,-0x30(%rbp)
jne    11f7 <double_stencil5+0x77>
lea    0xe20(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    $0x0,%al
call   1050 <omp_get_thread_num@plt>
cmp    $0x0,%rax
jne    121f <double_stencil5+0x9f>
mov    $0x0,%al
call   1080 <omp_get_num_threads@plt>
mov    %eax,%esi
lea    0xe3b(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    127e <double_stencil5+0xfe>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    126b <double_stencil5+0xeb>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1239 <double_stencil5+0xb9>
jmp    1270 <double_stencil5+0xf0>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1226 <double_stencil5+0xa6>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    130c <double_stencil5+0x18c>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12f9 <double_stencil5+0x179>
mov    $0x0,%al
call   10a0 <rand@plt>
cvtsi2sd %rax,%xmm0
mov    0x2d27(%rip),%rax
cvtsi2sdq (%rax),%xmm2
movsd  0xd3a(%rip),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    129d <double_stencil5+0x11d>
jmp    12fe <double_stencil5+0x17e>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1285 <double_stencil5+0x105>
mov    0x2ccd(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1060 <clock_gettime@plt>
movl   $0x0,-0x10(%rbp)
cmpl   $0x64,-0x10(%rbp)
jge    148c <double_stencil5+0x30c>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13fe <double_stencil5+0x27e>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13eb <double_stencil5+0x26b>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
addsd  (%rax,%rcx,8),%xmm0
mulsd  -0x20(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    134e <double_stencil5+0x1ce>
jmp    13f0 <double_stencil5+0x270>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1336 <double_stencil5+0x1b6>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1479 <double_stencil5+0x2f9>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1466 <double_stencil5+0x2e6>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    141d <double_stencil5+0x29d>
jmp    146b <double_stencil5+0x2eb>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1405 <double_stencil5+0x285>
jmp    147e <double_stencil5+0x2fe>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1325 <double_stencil5+0x1a5>
mov    0x2b4d(%rip),%rax
mov    (%rax),%edi
lea    -0x40(%rbp),%rsi
call   1060 <clock_gettime@plt>
mov    -0x38(%rbp),%edi
mov    -0x40(%rbp),%esi
lea    0xbd4(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    -0x28(%rbp),%rdi
call   1040 <free@plt>
mov    -0x30(%rbp),%rdi
call   1040 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<double_stencil5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %edi,%r13d
mov    %edi,%ebp
imul   %edi,%ebp
shl    $0x3,%ebp
mov    %ebp,%edi
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   10a0 <malloc@plt>
mov    %rax,%r14
test   %rbx,%rbx
je     11ca <double_stencil5+0x3a>
test   %r14,%r14
jne    11d6 <double_stencil5+0x46>
lea    0xe9e(%rip),%rdi
call   1050 <puts@plt>
xor    %eax,%eax
call   1060 <omp_get_thread_num@plt>
test   %rax,%rax
jne    11f9 <double_stencil5+0x69>
xor    %eax,%eax
call   1090 <omp_get_num_threads@plt>
lea    0xe30(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1080 <printf@plt>
movabs $0x7ffffffffffffffc,%r15
xor    %eax,%eax
mov    %rax,0x20(%rsp)
mov    %r13d,%r12d
test   %r13d,%r13d
mov    %r13,0x40(%rsp)
mov    %r12,0x10(%rsp)
je     1463 <double_stencil5+0x2d3>
lea    -0x1(%r12),%r8
mov    %r12d,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9d,%r10d
and    $0x3,%r10d
and    %r15,%r9
mov    %rcx,%r15
and    $0x3,%r12d
mov    $0x8,%edx
xorpd  %xmm0,%xmm0
xor    %esi,%esi
jmp    127c <double_stencil5+0xec>
nopl   0x0(%rax)
mov    0x20(%rsp),%rax
add    $0x1,%eax
add    %r13d,%edx
add    %rbp,%rsi
mov    %rax,0x20(%rsp)
cmp    %r13d,%eax
je     13bc <double_stencil5+0x22c>
cmp    $0x4,%r13d
jae    1300 <double_stencil5+0x170>
xor    %ecx,%ecx
mov    0x10(%rsp),%rbp
mov    %rcx,%rax
not    %rax
add    %rbp,%rax
test   %r12,%r12
je     12b5 <double_stencil5+0x125>
mov    %r12,%rdi
xchg   %ax,%ax
lea    (%rsi,%rcx,1),%ebp
movq   $0x0,(%rbx,%rbp,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    12a0 <double_stencil5+0x110>
cmp    $0x3,%rax
mov    0x10(%rsp),%rbp
jb     1260 <double_stencil5+0xd0>
lea    (%rsi,%rcx,1),%rax
mov    %eax,%edi
movq   $0x0,(%rbx,%rdi,8)
lea    0x1(%rax),%edi
movq   $0x0,(%rbx,%rdi,8)
lea    0x2(%rax),%edi
movq   $0x0,(%rbx,%rdi,8)
add    $0x3,%eax
movq   $0x0,(%rbx,%rax,8)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    12c0 <double_stencil5+0x130>
jmp    1260 <double_stencil5+0xd0>
nopl   (%rax)
mov    0x20(%rsp),%rax
imul   %r13d,%eax
add    %r8d,%eax
jb     1286 <double_stencil5+0xf6>
mov    %r8,%rax
shr    $0x20,%rax
mov    $0x0,%ecx
mov    0x10(%rsp),%rbp
jne    128d <double_stencil5+0xfd>
cmp    $0xc,%r15
jae    1333 <double_stencil5+0x1a3>
xor    %ecx,%ecx
jmp    1384 <double_stencil5+0x1f4>
mov    %r9,%rdi
mov    %edx,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
lea    -0x8(%rax),%ebp
movupd %xmm0,(%rbx,%rbp,8)
movupd %xmm0,0x10(%rbx,%rbp,8)
lea    -0x4(%rax),%ebp
movupd %xmm0,(%rbx,%rbp,8)
movupd %xmm0,0x10(%rbx,%rbp,8)
mov    %eax,%ebp
movupd %xmm0,(%rbx,%rbp,8)
movupd %xmm0,0x10(%rbx,%rbp,8)
lea    0x4(%rax),%ebp
movupd %xmm0,(%rbx,%rbp,8)
movupd %xmm0,0x10(%rbx,%rbp,8)
add    $0x10,%rcx
add    $0x10,%eax
add    $0xfffffffffffffffc,%rdi
jne    1340 <double_stencil5+0x1b0>
test   %r10,%r10
je     13a6 <double_stencil5+0x216>
add    %esi,%ecx
mov    %r10,%rax
xchg   %ax,%ax
mov    %ecx,%edi
movupd %xmm0,(%rbx,%rdi,8)
movupd %xmm0,0x10(%rbx,%rdi,8)
add    $0x4,%ecx
add    $0xffffffffffffffff,%rax
jne    1390 <double_stencil5+0x200>
mov    %r11,%rcx
mov    0x10(%rsp),%rbp
cmp    %rbp,%r11
je     1260 <double_stencil5+0xd0>
jmp    128d <double_stencil5+0xfd>
lea    -0x1(%r13),%ebp
cmp    $0x2,%ebp
setge  %al
mov    %rax,0x20(%rsp)
jl     146a <double_stencil5+0x2da>
mov    %ebp,0x28(%rsp)
mov    %ebp,%eax
lea    0x1(%r13),%ecx
add    $0xffffffffffffffff,%rax
mov    %rax,0x18(%rsp)
mov    $0x1,%ebp
mov    0x2bf8(%rip),%r15
mov    0x18(%rsp),%r12
mov    %ecx,0x34(%rsp)
mov    %ecx,%r13d
nopl   0x0(%rax)
xor    %eax,%eax
call   10b0 <rand@plt>
movsd  0xbf1(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdq (%r15),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    %r13d,%eax
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%r13d
add    $0xffffffffffffffff,%r12
jne    1400 <double_stencil5+0x270>
add    $0x1,%ebp
mov    0x40(%rsp),%r13
mov    0x34(%rsp),%ecx
add    %r13d,%ecx
cmp    0x28(%rsp),%ebp
jne    13f0 <double_stencil5+0x260>
movabs $0x7ffffffffffffffc,%r15
ff ff 7f
mov    0x10(%rsp),%r12
mov    0x28(%rsp),%ebp
jmp    1480 <double_stencil5+0x2f0>
mov    $0xffffffff,%ebp
jmp    1480 <double_stencil5+0x2f0>
xor    %eax,%eax
mov    %rax,0x20(%rsp)
movabs $0x7ffffffffffffffc,%r15
ff ff 7f
mov    0x10(%rsp),%r12
mov    0x2b59(%rip),%rax
mov    (%rax),%edi
lea    0x78(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    %ebp,%r11d
lea    -0x2(%r11),%r8
lea    0x1(%r13),%eax
mov    %rax,0x88(%rsp)
lea    -0x1(%r11),%rdx
lea    -0x8(%rbx,%r11,8),%rsi
lea    -0x8(%r14,%r11,8),%rax
lea    0x2(%r13),%edi
mov    %rdi,0x120(%rsp)
lea    0x0(%r13,%r13,1),%edi
lea    -0x5(%r11),%rbp
mov    %rbp,0xe0(%rsp)
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %rdx,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xe8(%rsp)
mov    %rdx,%rcx
or     $0x1,%rcx
mov    %rcx,0xd0(%rsp)
mov    %rax,0xf0(%rsp)
cmp    %rbx,%rax
seta   %al
mov    %rsi,0xf8(%rsp)
cmp    %r14,%rsi
seta   %cl
and    %al,%cl
mov    %cl,0xf(%rsp)
mov    %rdx,0x28(%rsp)
and    $0xfffffffffffffffc,%rdx
add    $0x2,%r15
mov    %rbp,%rax
mov    %rbp,0xd8(%rsp)
and    %rbp,%r15
movsd  0xacc(%rip),%xmm0
mov    %r8,%rax
mov    %r8,0x68(%rsp)
shr    $0x20,%r8
mov    %r8,0x80(%rsp)
movapd 0xab8(%rip),%xmm1
lea    0x1(%r13,%r13,1),%eax
mov    %rax,0x118(%rsp)
mov    %rdx,0xc8(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0xc0(%rsp)
mov    %rdi,0xa8(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0xa0(%rsp)
lea    -0x1(%r13),%eax
mov    %rax,0x98(%rsp)
lea    0x5(%r13),%eax
mov    %eax,0x7c(%rsp)
xor    %eax,%eax
mov    0x20(%rsp),%r13
mov    %r15,0xb0(%rsp)
jmp    15d4 <double_stencil5+0x444>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xb8(%rsp),%rax
add    $0x1,%eax
cmp    $0x64,%eax
je     1ae9 <double_stencil5+0x959>
mov    %rax,0xb8(%rsp)
test   %r13b,%r13b
je     15c0 <double_stencil5+0x430>
mov    $0x1,%r10d
xor    %r13d,%r13d
mov    0x98(%rsp),%r9
mov    0xa8(%rsp),%r8
mov    0xa0(%rsp),%r15
mov    %r12,%rbp
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10d
mov    $0x1,%ecx
cmpq   $0x2,0x28(%rsp)
mov    %eax,0x34(%rsp)
jae    1690 <double_stencil5+0x500>
mov    %rcx,%rsi
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%rax
lea    (%r9,%rcx,1),%edi
movsd  (%rbx,%rdi,8),%xmm2
lea    0x1(%rax),%edi
addsd  (%rbx,%rdi,8),%xmm2
lea    (%rcx,%r13,1),%edi
addsd  (%rbx,%rdi,8),%xmm2
add    $0x1,%rsi
add    %r8d,%ecx
addsd  (%rbx,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
mov    %eax,%eax
movsd  %xmm2,(%r14,%rax,8)
mov    %rsi,%rcx
cmp    %rsi,%r11
jne    1630 <double_stencil5+0x4a0>
mov    0x34(%rsp),%eax
add    $0x1,%eax
add    %r12,%rbp
add    %r12,%r13
add    %r12,%r15
add    %r12,%r8
add    %r12,%r9
cmp    %r11d,%r10d
jne    1610 <double_stencil5+0x480>
jmp    1920 <double_stencil5+0x790>
xchg   %ax,%ax
mov    %r15,0x90(%rsp)
mov    %r10d,0x18(%rsp)
mov    %eax,%esi
mov    0x40(%rsp),%rax
imul   %eax,%esi
mov    0x88(%rsp),%rdi
lea    (%rdi,%rsi,1),%r15d
mov    0x118(%rsp),%rdx
add    %esi,%edx
mov    0x120(%rsp),%rdi
add    %esi,%edi
add    %esi,%eax
mov    %rax,0x50(%rsp)
mov    0x68(%rsp),%r12
add    %r12d,%eax
setb   0x60(%rsp)
mov    %rdi,0x58(%rsp)
mov    %edi,%eax
add    %r12d,%eax
setb   %al
mov    %rdx,0x48(%rsp)
mov    %edx,%r10d
add    %r12d,%r10d
setb   %dl
mov    %r15,0x38(%rsp)
mov    %r15d,%edi
add    %r12d,%edi
jb     18fb <double_stencil5+0x76b>
mov    0x80(%rsp),%rdi
test   %rdi,%rdi
mov    0x18(%rsp),%r10d
mov    0x90(%rsp),%r15
jne    18e2 <double_stencil5+0x752>
cmpb   $0x0,0x60(%rsp)
jne    18e2 <double_stencil5+0x752>
test   %rdi,%rdi
mov    0x10(%rsp),%r12
jne    1625 <double_stencil5+0x495>
test   %al,%al
jne    1625 <double_stencil5+0x495>
test   %rdi,%rdi
jne    1625 <double_stencil5+0x495>
mov    $0xfffffffe,%eax
sub    %esi,%eax
cmp    0x68(%rsp),%eax
jb     1625 <double_stencil5+0x495>
test   %rdi,%rdi
jne    1625 <double_stencil5+0x495>
test   %dl,%dl
jne    1625 <double_stencil5+0x495>
test   %rdi,%rdi
jne    1625 <double_stencil5+0x495>
add    $0x1,%esi
mov    0x38(%rsp),%rdx
lea    (%r14,%rdx,8),%rdi
mov    0xf0(%rsp),%rax
lea    (%rax,%rdx,8),%r12
mov    0x48(%rsp),%rdx
lea    (%rbx,%rdx,8),%rax
mov    %rax,0x110(%rsp)
mov    0xf8(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
mov    %rdx,0x100(%rsp)
lea    (%rbx,%rsi,8),%rdx
mov    %rdx,0x48(%rsp)
lea    (%rax,%rsi,8),%rsi
mov    0x58(%rsp),%r10
lea    (%rbx,%r10,8),%rdx
mov    %rdx,0x38(%rsp)
lea    (%rax,%r10,8),%rdx
mov    %rdx,0x108(%rsp)
mov    0x50(%rsp),%rdx
lea    (%rbx,%rdx,8),%r10
mov    %r10,0x60(%rsp)
lea    (%rax,%rdx,8),%r10
cmp    0x100(%rsp),%rdi
setb   %dl
cmp    %r12,0x110(%rsp)
setb   0x58(%rsp)
cmp    %rsi,%rdi
setb   %al
cmp    %r12,0x48(%rsp)
setb   0x50(%rsp)
cmp    0x108(%rsp),%rdi
setb   %sil
cmp    %r12,0x38(%rsp)
setb   0x38(%rsp)
cmp    %r10,%rdi
setb   %r10b
cmp    %r12,0x60(%rsp)
setb   %dil
test   %dl,0x58(%rsp)
jne    18ec <double_stencil5+0x75c>
and    0x50(%rsp),%al
mov    0x10(%rsp),%r12
jne    18f1 <double_stencil5+0x761>
and    0x38(%rsp),%sil
jne    18f1 <double_stencil5+0x761>
and    %dil,%r10b
mov    0xe8(%rsp),%rdx
mov    0x18(%rsp),%r10d
jne    1625 <double_stencil5+0x495>
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%rax
lea    0x1(%rax),%esi
mov    %eax,%edi
movupd (%rbx,%rdi,8),%xmm2
add    $0x2,%eax
movupd (%rbx,%rax,8),%xmm3
addpd  %xmm2,%xmm3
lea    (%rcx,%r13,1),%eax
add    $0x1,%eax
movupd (%rbx,%rax,8),%xmm2
addpd  %xmm3,%xmm2
lea    (%r15,%rcx,1),%eax
movupd (%rbx,%rax,8),%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm3
movupd %xmm3,(%r14,%rsi,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1880 <double_stencil5+0x6f0>
mov    0xd0(%rsp),%rcx
cmp    %rdx,0x28(%rsp)
jne    1625 <double_stencil5+0x495>
jmp    166e <double_stencil5+0x4de>
mov    0x10(%rsp),%r12
jmp    1625 <double_stencil5+0x495>
mov    0x10(%rsp),%r12
mov    0x18(%rsp),%r10d
jmp    1625 <double_stencil5+0x495>
mov    0x10(%rsp),%r12
mov    0x18(%rsp),%r10d
mov    0x90(%rsp),%r15
jmp    1625 <double_stencil5+0x495>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp),%r13
test   %r13b,%r13b
mov    0x40(%rsp),%r10
mov    0xb0(%rsp),%r15
je     15c0 <double_stencil5+0x430>
mov    $0x1,%edx
xor    %r9d,%r9d
mov    %r12,%rbp
mov    0x7c(%rsp),%r8d
jmp    1966 <double_stencil5+0x7d6>
nopl   (%rax)
add    $0x1,%edx
add    $0x1,%r9d
add    %r10d,%r8d
add    %r12,%rbp
cmp    %r11d,%edx
je     15c0 <double_stencil5+0x430>
mov    $0x1,%esi
cmpq   $0x4,0x28(%rsp)
jb     1a50 <double_stencil5+0x8c0>
cmpq   $0x0,0x80(%rsp)
setne  %al
mov    %r9d,%ecx
imul   %r10d,%ecx
add    0x88(%rsp),%ecx
add    0x68(%rsp),%ecx
setb   %cl
or     %al,%cl
or     0xf(%rsp),%cl
jne    1a50 <double_stencil5+0x8c0>
cmpq   $0x4,0xe0(%rsp)
jae    19b3 <double_stencil5+0x823>
xor    %esi,%esi
jmp    19fe <double_stencil5+0x86e>
mov    %r15,%rax
mov    %r8d,%ecx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    -0x4(%rcx),%edi
movups (%r14,%rdi,8),%xmm2
movups 0x10(%r14,%rdi,8),%xmm3
movups %xmm2,(%rbx,%rdi,8)
movups %xmm3,0x10(%rbx,%rdi,8)
mov    %ecx,%edi
movupd (%r14,%rdi,8),%xmm2
movupd 0x10(%r14,%rdi,8),%xmm3
movupd %xmm2,(%rbx,%rdi,8)
movupd %xmm3,0x10(%rbx,%rdi,8)
add    $0x8,%rsi
add    $0x8,%ecx
add    $0xfffffffffffffffe,%rax
jne    19c0 <double_stencil5+0x830>
testb  $0x1,0xd8(%rsp)
01
je     1a2b <double_stencil5+0x89b>
mov    %edx,%eax
imul   %r10d,%eax
or     $0x1,%esi
add    %eax,%esi
movupd (%r14,%rsi,8),%xmm2
movupd 0x10(%r14,%rsi,8),%xmm3
movupd %xmm2,(%rbx,%rsi,8)
movupd %xmm3,0x10(%rbx,%rsi,8)
mov    0xc0(%rsp),%rsi
mov    0xc8(%rsp),%rax
cmp    %rax,0x28(%rsp)
je     1950 <double_stencil5+0x7c0>
cs nopw 0x0(%rax,%rax,1)
mov    %r11d,%eax
sub    %esi,%eax
mov    %rsi,%rcx
not    %rcx
add    %r11,%rcx
and    $0x3,%rax
je     1a88 <double_stencil5+0x8f8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rsi,%rbp,1),%edi
movsd  (%r14,%rdi,8),%xmm2
movsd  %xmm2,(%rbx,%rdi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1a70 <double_stencil5+0x8e0>
cmp    $0x3,%rcx
jb     1950 <double_stencil5+0x7c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rsi,%rbp,1),%rax
mov    %eax,%ecx
movsd  (%r14,%rcx,8),%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
lea    0x1(%rax),%ecx
movsd  (%r14,%rcx,8),%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
lea    0x2(%rax),%ecx
movsd  (%r14,%rcx,8),%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
add    $0x3,%eax
movsd  (%r14,%rax,8),%xmm2
movsd  %xmm2,(%rbx,%rax,8)
add    $0x4,%rsi
cmp    %rsi,%r11
jne    1aa0 <double_stencil5+0x910>
jmp    1950 <double_stencil5+0x7c0>
mov    0x24f0(%rip),%rax
mov    (%rax),%edi
lea    0x70(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    0x78(%rsp),%edi
mov    0x70(%rsp),%esi
lea    0x541(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    %rbx,%rdi
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.timespec = type { i32 }
@.str = [67 x i8] c"9-point Double Precision Stencil Error: Unable to allocate memory\0A\00"
@.str.1 = [44 x i8] c"Running on Host with %d OpenMP thread(s):\0A\0A\00"
@RAND_MAX = global i64 0
@CLOCK_MONOTONIC_RAW = global i32 0
@.str.2 = [35 x i8] c"Double Precision Stencil - 5 point\00"
define void @double_stencil5(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca double
%8 = alloca double*
%9 = alloca double*
%10 = alloca %struct.timespec
%11 = alloca %struct.timespec
store i32 %0, i32* %2
%12 = load i32, i32* %2
%13 = sub i32 %12, 2
store i32 %13, i32* %6
store double 1.250000e-01, double* %7
%14 = load i32, i32* %2
%15 = zext i32 %14 to i64
%16 = mul i64 8, %15
%17 = load i32, i32* %2
%18 = zext i32 %17 to i64
%19 = mul i64 %16, %18
%20 = trunc i64 %19 to i32
%21 = call i64 @malloc(i32 %20)
%22 = inttoptr i64 %21 to double*
store double* %22, double** %8
%23 = load i32, i32* %2
%24 = zext i32 %23 to i64
%25 = mul i64 8, %24
%26 = load i32, i32* %2
%27 = zext i32 %26 to i64
%28 = mul i64 %25, %27
%29 = trunc i64 %28 to i32
%30 = call i64 @malloc(i32 %29)
%31 = inttoptr i64 %30 to double*
store double* %31, double** %9
%32 = load double*, double** %8
%33 = icmp eq double* %32, null
br i1 %33, label %37, label %34
34: ; preds = %1
%35 = load double*, double** %9
%36 = icmp eq double* %35, null
br i1 %36, label %37, label %39
37: ; preds = %34, %1
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str, i64 0, i64 0))
br label %39
39: ; preds = %37, %34
%40 = call i64 (...) @omp_get_thread_num()
%41 = icmp eq i64 %40, 0
br i1 %41, label %42, label %45
42: ; preds = %39
%43 = call i32 (...) @omp_get_num_threads()
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.1, i64 0, i64 0), i32 %43)
br label %45
45: ; preds = %42, %39
store i32 0, i32* %3
br label %46
46: ; preds = %68, %45
%47 = load i32, i32* %3
%48 = load i32, i32* %2
%49 = icmp ult i32 %47, %48
br i1 %49, label %50, label %71
50: ; preds = %46
store i32 0, i32* %4
br label %51
51: ; preds = %64, %50
%52 = load i32, i32* %4
%53 = load i32, i32* %2
%54 = icmp ult i32 %52, %53
br i1 %54, label %55, label %67
55: ; preds = %51
%56 = load double*, double** %8
%57 = load i32, i32* %3
%58 = load i32, i32* %2
%59 = mul i32 %57, %58
%60 = load i32, i32* %4
%61 = add i32 %59, %60
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds double, double* %56, i64 %62
store double 0.000000e+00, double* %63
br label %64
64: ; preds = %55
%65 = load i32, i32* %4
%66 = add nsw i32 %65, 1
store i32 %66, i32* %4
br label %51
67: ; preds = %51
br label %68
68: ; preds = %67
%69 = load i32, i32* %3
%70 = add nsw i32 %69, 1
store i32 %70, i32* %3
br label %46
71: ; preds = %46
store i32 1, i32* %3
br label %72
72: ; preds = %102, %71
%73 = load i32, i32* %3
%74 = load i32, i32* %6
%75 = add nsw i32 %74, 1
%76 = icmp slt i32 %73, %75
br i1 %76, label %77, label %105
77: ; preds = %72
store i32 1, i32* %4
br label %78
78: ; preds = %98, %77
%79 = load i32, i32* %4
%80 = load i32, i32* %6
%81 = add nsw i32 %80, 1
%82 = icmp slt i32 %79, %81
br i1 %82, label %83, label %101
83: ; preds = %78
%84 = call i64 (...) @rand()
%85 = sitofp i64 %84 to double
%86 = load i64, i64* @RAND_MAX
%87 = sitofp i64 %86 to double
%88 = fadd double 1.000000e+00, %87
%89 = fdiv double %85, %88
%90 = load double*, double** %8
%91 = load i32, i32* %3
%92 = load i32, i32* %2
%93 = mul i32 %91, %92
%94 = load i32, i32* %4
%95 = add i32 %93, %94
%96 = zext i32 %95 to i64
%97 = getelementptr inbounds double, double* %90, i64 %96
store double %89, double* %97
br label %98
98: ; preds = %83
%99 = load i32, i32* %4
%100 = add nsw i32 %99, 1
store i32 %100, i32* %4
br label %78
101: ; preds = %78
br label %102
102: ; preds = %101
%103 = load i32, i32* %3
%104 = add nsw i32 %103, 1
store i32 %104, i32* %3
br label %72
105: ; preds = %72
%106 = load i32, i32* @CLOCK_MONOTONIC_RAW
%107 = call i32 @clock_gettime(i32 %106, %struct.timespec* %10)
store i32 0, i32* %5
br label %108
108: ; preds = %222, %105
%109 = load i32, i32* %5
%110 = icmp slt i32 %109, 100
br i1 %110, label %111, label %225
111: ; preds = %108
store i32 1, i32* %3
br label %112
112: ; preds = %181, %111
%113 = load i32, i32* %3
%114 = load i32, i32* %6
%115 = add nsw i32 %114, 1
%116 = icmp slt i32 %113, %115
br i1 %116, label %117, label %184
117: ; preds = %112
store i32 1, i32* %4
br label %118
118: ; preds = %177, %117
%119 = load i32, i32* %4
%120 = load i32, i32* %6
%121 = add nsw i32 %120, 1
%122 = icmp slt i32 %119, %121
br i1 %122, label %123, label %180
123: ; preds = %118
%124 = load double*, double** %8
%125 = load i32, i32* %3
%126 = load i32, i32* %2
%127 = mul i32 %125, %126
%128 = load i32, i32* %4
%129 = sub nsw i32 %128, 1
%130 = add i32 %127, %129
%131 = zext i32 %130 to i64
%132 = getelementptr inbounds double, double* %124, i64 %131
%133 = load double, double* %132
%134 = load double*, double** %8
%135 = load i32, i32* %3
%136 = load i32, i32* %2
%137 = mul i32 %135, %136
%138 = load i32, i32* %4
%139 = add nsw i32 %138, 1
%140 = add i32 %137, %139
%141 = zext i32 %140 to i64
%142 = getelementptr inbounds double, double* %134, i64 %141
%143 = load double, double* %142
%144 = fadd double %133, %143
%145 = load double*, double** %8
%146 = load i32, i32* %3
%147 = sub nsw i32 %146, 1
%148 = load i32, i32* %2
%149 = mul i32 %147, %148
%150 = load i32, i32* %4
%151 = add i32 %149, %150
%152 = zext i32 %151 to i64
%153 = getelementptr inbounds double, double* %145, i64 %152
%154 = load double, double* %153
%155 = fadd double %144, %154
%156 = load double*, double** %8
%157 = load i32, i32* %3
%158 = add nsw i32 %157, 1
%159 = load i32, i32* %2
%160 = mul i32 %158, %159
%161 = load i32, i32* %4
%162 = add i32 %160, %161
%163 = zext i32 %162 to i64
%164 = getelementptr inbounds double, double* %156, i64 %163
%165 = load double, double* %164
%166 = fadd double %155, %165
%167 = load double, double* %7
%168 = fmul double %166, %167
%169 = load double*, double** %9
%170 = load i32, i32* %3
%171 = load i32, i32* %2
%172 = mul i32 %170, %171
%173 = load i32, i32* %4
%174 = add i32 %172, %173
%175 = zext i32 %174 to i64
%176 = getelementptr inbounds double, double* %169, i64 %175
store double %168, double* %176
br label %177
177: ; preds = %123
%178 = load i32, i32* %4
%179 = add nsw i32 %178, 1
store i32 %179, i32* %4
br label %118
180: ; preds = %118
br label %181
181: ; preds = %180
%182 = load i32, i32* %3
%183 = add nsw i32 %182, 1
store i32 %183, i32* %3
br label %112
184: ; preds = %112
store i32 1, i32* %3
br label %185
185: ; preds = %218, %184
%186 = load i32, i32* %3
%187 = load i32, i32* %6
%188 = add nsw i32 %187, 1
%189 = icmp slt i32 %186, %188
br i1 %189, label %190, label %221
190: ; preds = %185
store i32 1, i32* %4
br label %191
191: ; preds = %214, %190
%192 = load i32, i32* %4
%193 = load i32, i32* %6
%194 = add nsw i32 %193, 1
%195 = icmp slt i32 %192, %194
br i1 %195, label %196, label %217
196: ; preds = %191
%197 = load double*, double** %9
%198 = load i32, i32* %3
%199 = load i32, i32* %2
%200 = mul i32 %198, %199
%201 = load i32, i32* %4
%202 = add i32 %200, %201
%203 = zext i32 %202 to i64
%204 = getelementptr inbounds double, double* %197, i64 %203
%205 = load double, double* %204
%206 = load double*, double** %8
%207 = load i32, i32* %3
%208 = load i32, i32* %2
%209 = mul i32 %207, %208
%210 = load i32, i32* %4
%211 = add i32 %209, %210
%212 = zext i32 %211 to i64
%213 = getelementptr inbounds double, double* %206, i64 %212
store double %205, double* %213
br label %214
214: ; preds = %196
%215 = load i32, i32* %4
%216 = add nsw i32 %215, 1
store i32 %216, i32* %4
br label %191
217: ; preds = %191
br label %218
218: ; preds = %217
%219 = load i32, i32* %3
%220 = add nsw i32 %219, 1
store i32 %220, i32* %3
br label %185
221: ; preds = %185
br label %222
222: ; preds = %221
%223 = load i32, i32* %5
%224 = add nsw i32 %223, 1
store i32 %224, i32* %5
br label %108
225: ; preds = %108
%226 = load i32, i32* @CLOCK_MONOTONIC_RAW
%227 = call i32 @clock_gettime(i32 %226, %struct.timespec* %11)
%228 = getelementptr inbounds %struct.timespec, %struct.timespec* %10, i32 0, i32 0
%229 = load i32, i32* %228
%230 = getelementptr inbounds %struct.timespec, %struct.timespec* %11, i32 0, i32 0
%231 = load i32, i32* %230
%232 = call i32 @elapsed_time_hr(i32 %229, i32 %231, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.2, i64 0, i64 0))
%233 = load double*, double** %8
%234 = call i32 @free(double* %233)
%235 = load double*, double** %9
%236 = call i32 @free(double* %235)
ret void
}

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