#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(float *);
scalar_t__ malloc(int);
int omp_get_num_threads();
scalar_t__ omp_get_thread_num();
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ rand();
void float_stencil5(unsigned int size) {
  int i, j, iter;
  int n = size - 2;
  float fac = 1.0 / 8;
  float *a0 = (float *)malloc(sizeof(float) * size * size);
  float *a1 = (float *)malloc(sizeof(float) * size * size);
  if (a0 == NULL || a1 == NULL) {
    printf(
        "9-point Single 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] = (float)rand() / (float)(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, "Single Precision Stencil - 5 point");
  free(a0);
  free(a1);
}


x86 assembly (clang, -O0):
<float_stencil5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x14(%rbp)
movss  0xe64(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x2,%rax
mov    -0x4(%rbp),%ecx
imul   %rcx,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x2,%rax
mov    -0x4(%rbp),%ecx
imul   %rcx,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     11e9 <float_stencil5+0x69>
cmpq   $0x0,-0x28(%rbp)
jne    11f7 <float_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 <float_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 <float_stencil5+0xfe>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    126b <float_stencil5+0xeb>
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1239 <float_stencil5+0xb9>
jmp    1270 <float_stencil5+0xf0>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1226 <float_stencil5+0xa6>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1310 <float_stencil5+0x190>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12fd <float_stencil5+0x17d>
mov    $0x0,%al
call   10a0 <rand@plt>
cvtsi2ss %rax,%xmm0
mov    0x2d27(%rip),%rax
cvtsi2sdq (%rax),%xmm2
movsd  0xd3a(%rip),%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
divss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    129d <float_stencil5+0x11d>
jmp    1302 <float_stencil5+0x182>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1285 <float_stencil5+0x105>
mov    0x2cc9(%rip),%rax
mov    (%rax),%edi
lea    -0x30(%rbp),%rsi
call   1060 <clock_gettime@plt>
movl   $0x0,-0x10(%rbp)
cmpl   $0x64,-0x10(%rbp)
jge    1490 <float_stencil5+0x310>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1402 <float_stencil5+0x282>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13ef <float_stencil5+0x26f>
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1352 <float_stencil5+0x1d2>
jmp    13f4 <float_stencil5+0x274>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    133a <float_stencil5+0x1ba>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    147d <float_stencil5+0x2fd>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    146a <float_stencil5+0x2ea>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0xc(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1421 <float_stencil5+0x2a1>
jmp    146f <float_stencil5+0x2ef>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1409 <float_stencil5+0x289>
jmp    1482 <float_stencil5+0x302>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1329 <float_stencil5+0x1a9>
mov    0x2b49(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1060 <clock_gettime@plt>
mov    -0x30(%rbp),%edi
mov    -0x38(%rbp),%esi
lea    0xbd0(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    -0x20(%rbp),%rdi
call   1040 <free@plt>
mov    -0x28(%rbp),%rdi
call   1040 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<float_stencil5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %edi,%r13d
mov    %edi,%ebp
imul   %edi,%ebp
shl    $0x2,%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 <float_stencil5+0x3a>
test   %r14,%r14
jne    11d6 <float_stencil5+0x46>
lea    0xea2(%rip),%rdi
call   1050 <puts@plt>
xor    %eax,%eax
call   1060 <omp_get_thread_num@plt>
test   %rax,%rax
jne    11f9 <float_stencil5+0x69>
xor    %eax,%eax
call   1090 <omp_get_num_threads@plt>
lea    0xe34(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1080 <printf@plt>
movabs $0x3ffffffffffffffc,%r15
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %r13d,%r12d
test   %r13d,%r13d
mov    %r13,0x38(%rsp)
mov    %r12,0x8(%rsp)
je     1467 <float_stencil5+0x2d7>
lea    -0x1(%r12),%r8
mov    %r12d,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9d,%r10d
and    $0x3,%r10d
and    %r15,%r9
mov    %rcx,%r15
and    $0x3,%r12d
mov    $0x10,%edx
xorps  %xmm0,%xmm0
xor    %esi,%esi
jmp    127c <float_stencil5+0xec>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
add    $0x1,%eax
add    %r13d,%edx
add    %rbp,%rsi
mov    %rax,0x18(%rsp)
cmp    %r13d,%eax
je     13ba <float_stencil5+0x22a>
cmp    $0x8,%r13d
jae    1300 <float_stencil5+0x170>
xor    %ecx,%ecx
mov    0x8(%rsp),%rbp
mov    %rcx,%rax
not    %rax
add    %rbp,%rax
test   %r12,%r12
je     12b4 <float_stencil5+0x124>
mov    %r12,%rdi
xchg   %ax,%ax
lea    (%rsi,%rcx,1),%ebp
movl   $0x0,(%rbx,%rbp,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    12a0 <float_stencil5+0x110>
cmp    $0x3,%rax
mov    0x8(%rsp),%rbp
jb     1260 <float_stencil5+0xd0>
nop
lea    (%rsi,%rcx,1),%rax
mov    %eax,%edi
movl   $0x0,(%rbx,%rdi,4)
lea    0x1(%rax),%edi
movl   $0x0,(%rbx,%rdi,4)
lea    0x2(%rax),%edi
movl   $0x0,(%rbx,%rdi,4)
add    $0x3,%eax
movl   $0x0,(%rbx,%rax,4)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    12c0 <float_stencil5+0x130>
jmp    1260 <float_stencil5+0xd0>
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
imul   %r13d,%eax
add    %r8d,%eax
jb     1286 <float_stencil5+0xf6>
mov    %r8,%rax
shr    $0x20,%rax
mov    $0x0,%ecx
mov    0x8(%rsp),%rbp
jne    128d <float_stencil5+0xfd>
cmp    $0x18,%r15
jae    1333 <float_stencil5+0x1a3>
xor    %ecx,%ecx
jmp    137c <float_stencil5+0x1ec>
mov    %r9,%rdi
mov    %edx,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
lea    -0x10(%rax),%ebp
movups %xmm0,(%rbx,%rbp,4)
movups %xmm0,0x10(%rbx,%rbp,4)
lea    -0x8(%rax),%ebp
movups %xmm0,(%rbx,%rbp,4)
movups %xmm0,0x10(%rbx,%rbp,4)
mov    %eax,%ebp
movups %xmm0,(%rbx,%rbp,4)
movups %xmm0,0x10(%rbx,%rbp,4)
lea    0x8(%rax),%ebp
movups %xmm0,(%rbx,%rbp,4)
movups %xmm0,0x10(%rbx,%rbp,4)
add    $0x20,%rcx
add    $0x20,%eax
add    $0xfffffffffffffffc,%rdi
jne    1340 <float_stencil5+0x1b0>
test   %r10,%r10
je     13a4 <float_stencil5+0x214>
add    %esi,%ecx
mov    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
mov    %ecx,%edi
movups %xmm0,(%rbx,%rdi,4)
movups %xmm0,0x10(%rbx,%rdi,4)
add    $0x8,%ecx
add    $0xffffffffffffffff,%rax
jne    1390 <float_stencil5+0x200>
mov    %r11,%rcx
mov    0x8(%rsp),%rbp
cmp    %rbp,%r11
je     1260 <float_stencil5+0xd0>
jmp    128d <float_stencil5+0xfd>
lea    -0x1(%r13),%ebp
cmp    $0x2,%ebp
setge  %al
mov    %rax,0x18(%rsp)
jl     146e <float_stencil5+0x2de>
mov    %ebp,0x20(%rsp)
mov    %ebp,%eax
lea    0x1(%r13),%ecx
add    $0xffffffffffffffff,%rax
mov    %rax,0x10(%rsp)
mov    $0x1,%ebp
mov    0x2bfa(%rip),%r15
xchg   %ax,%ax
mov    0x10(%rsp),%r12
mov    %ecx,0x2c(%rsp)
mov    %ecx,%r13d
nopl   0x0(%rax)
xor    %eax,%eax
call   10b0 <rand@plt>
movsd  0xbf1(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdq (%r15),%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
divss  %xmm1,%xmm0
mov    %r13d,%eax
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%r13d
add    $0xffffffffffffffff,%r12
jne    1400 <float_stencil5+0x270>
add    $0x1,%ebp
mov    0x38(%rsp),%r13
mov    0x2c(%rsp),%ecx
add    %r13d,%ecx
cmp    0x20(%rsp),%ebp
jne    13f0 <float_stencil5+0x260>
movabs $0x3ffffffffffffffc,%r15
ff ff 3f
mov    0x8(%rsp),%r12
mov    0x20(%rsp),%ebp
jmp    1484 <float_stencil5+0x2f4>
mov    $0xffffffff,%ebp
jmp    1484 <float_stencil5+0x2f4>
xor    %eax,%eax
mov    %rax,0x18(%rsp)
movabs $0x3ffffffffffffffc,%r15
ff ff 3f
mov    0x8(%rsp),%r12
mov    0x2b55(%rip),%rax
mov    (%rax),%edi
lea    0x78(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    %ebp,%r8d
lea    -0x2(%r8),%r9
lea    0x1(%r13),%eax
mov    %rax,0x88(%rsp)
lea    -0x1(%r8),%rcx
lea    -0x4(%rbx,%r8,4),%rsi
lea    -0x4(%r14,%r8,4),%rax
lea    0x2(%r13),%edi
mov    %rdi,0x110(%rsp)
lea    0x0(%r13,%r13,1),%edi
lea    0x1(%r13,%r13,1),%ebp
mov    %rbp,0x108(%rsp)
lea    -0x9(%r8),%rbp
mov    %rbp,0xd8(%rsp)
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rax,0xe8(%rsp)
cmp    %rbx,%rax
seta   %r10b
mov    %rsi,0xf0(%rsp)
cmp    %r14,%rsi
seta   %al
and    %r10b,%al
mov    %al,0x7(%rsp)
mov    %rcx,0x20(%rsp)
and    $0xfffffffffffffff8,%rcx
add    $0x2,%r15
mov    %rbp,%rax
mov    %rbp,0xd0(%rsp)
and    %rbp,%r15
movss  0xae8(%rip),%xmm0
mov    %r9,%rax
mov    %r9,0x68(%rsp)
shr    $0x20,%r9
mov    %r9,0x80(%rsp)
movaps 0xabd(%rip),%xmm1
mov    %rdx,0xe0(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0xc0(%rsp)
mov    %rcx,0xc8(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0xb8(%rsp)
mov    %rdi,0xa0(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0x98(%rsp)
lea    -0x1(%r13),%eax
mov    %rax,0x90(%rsp)
lea    0x9(%r13),%eax
mov    %eax,0x7c(%rsp)
xor    %eax,%eax
mov    0x18(%rsp),%r13
mov    %r15,0xa8(%rsp)
jmp    15d4 <float_stencil5+0x444>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xb0(%rsp),%rax
add    $0x1,%eax
cmp    $0x64,%eax
je     1aa9 <float_stencil5+0x919>
mov    %rax,0xb0(%rsp)
test   %r13b,%r13b
je     15c0 <float_stencil5+0x430>
mov    $0x1,%r10d
xor    %r13d,%r13d
mov    0x90(%rsp),%r9
mov    0xa0(%rsp),%r11
mov    0x98(%rsp),%r15
mov    %r12,%rbp
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10d
mov    $0x1,%ecx
cmpq   $0x4,0x20(%rsp)
mov    %eax,0x2c(%rsp)
jae    1690 <float_stencil5+0x500>
mov    %rcx,%rsi
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%rax
lea    (%r9,%rcx,1),%edi
movss  (%rbx,%rdi,4),%xmm2
lea    0x1(%rax),%edi
addss  (%rbx,%rdi,4),%xmm2
lea    (%rcx,%r13,1),%edi
addss  (%rbx,%rdi,4),%xmm2
add    $0x1,%rsi
add    %r11d,%ecx
addss  (%rbx,%rcx,4),%xmm2
mulss  %xmm0,%xmm2
mov    %eax,%eax
movss  %xmm2,(%r14,%rax,4)
mov    %rsi,%rcx
cmp    %rsi,%r8
jne    1630 <float_stencil5+0x4a0>
mov    0x2c(%rsp),%eax
add    $0x1,%eax
add    %r12,%rbp
add    %r12,%r13
add    %r12,%r15
add    %r12,%r11
add    %r12,%r9
cmp    %r8d,%r10d
jne    1610 <float_stencil5+0x480>
jmp    18f0 <float_stencil5+0x760>
xchg   %ax,%ax
mov    %r10d,0x10(%rsp)
mov    %eax,%esi
mov    0x38(%rsp),%rax
imul   %eax,%esi
mov    0x88(%rsp),%rdi
lea    (%rdi,%rsi,1),%edx
mov    0x108(%rsp),%rdi
lea    (%rdi,%rsi,1),%r10d
mov    0x110(%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   0x30(%rsp)
mov    %r10,0x40(%rsp)
add    %r12d,%r10d
setb   %al
mov    %rdx,0x48(%rsp)
mov    %edx,%edi
add    %r12d,%edi
jb     18c9 <float_stencil5+0x739>
mov    0x80(%rsp),%rdi
test   %rdi,%rdi
mov    0x10(%rsp),%r10d
jne    18d8 <float_stencil5+0x748>
cmpb   $0x0,0x60(%rsp)
jne    18d8 <float_stencil5+0x748>
test   %rdi,%rdi
mov    0x8(%rsp),%r12
jne    1625 <float_stencil5+0x495>
cmpb   $0x0,0x30(%rsp)
jne    1625 <float_stencil5+0x495>
test   %rdi,%rdi
jne    1625 <float_stencil5+0x495>
mov    %eax,%edx
mov    $0xfffffffe,%eax
sub    %esi,%eax
cmp    0x68(%rsp),%eax
jb     1625 <float_stencil5+0x495>
test   %rdi,%rdi
jne    1625 <float_stencil5+0x495>
test   %dl,%dl
jne    1625 <float_stencil5+0x495>
test   %rdi,%rdi
jne    1625 <float_stencil5+0x495>
add    $0x1,%esi
mov    0x48(%rsp),%rdx
lea    (%r14,%rdx,4),%rdi
mov    0xe8(%rsp),%rax
lea    (%rax,%rdx,4),%r12
mov    0x40(%rsp),%rdx
lea    (%rbx,%rdx,4),%rax
mov    %rax,0x100(%rsp)
mov    0xf0(%rsp),%rax
lea    (%rax,%rdx,4),%rdx
mov    %rdx,0xf8(%rsp)
lea    (%rbx,%rsi,4),%rdx
mov    %rdx,0x48(%rsp)
lea    (%rax,%rsi,4),%rsi
mov    0x58(%rsp),%r10
lea    (%rbx,%r10,4),%rdx
mov    %rdx,0x30(%rsp)
lea    (%rax,%r10,4),%rdx
mov    %rdx,0x40(%rsp)
mov    0x50(%rsp),%rdx
lea    (%rbx,%rdx,4),%r10
mov    %r10,0x60(%rsp)
lea    (%rax,%rdx,4),%r10
cmp    0xf8(%rsp),%rdi
setb   %dl
cmp    %r12,0x100(%rsp)
setb   0x58(%rsp)
cmp    %rsi,%rdi
setb   %al
cmp    %r12,0x48(%rsp)
setb   0x50(%rsp)
cmp    0x40(%rsp),%rdi
setb   %sil
cmp    %r12,0x30(%rsp)
setb   0x30(%rsp)
cmp    %r10,%rdi
setb   %r10b
cmp    %r12,0x60(%rsp)
setb   %dil
test   %dl,0x58(%rsp)
jne    18c9 <float_stencil5+0x739>
and    0x50(%rsp),%al
mov    0x8(%rsp),%r12
jne    18ce <float_stencil5+0x73e>
and    0x30(%rsp),%sil
jne    18ce <float_stencil5+0x73e>
and    %dil,%r10b
mov    0xe0(%rsp),%rdx
mov    0x10(%rsp),%r10d
jne    1625 <float_stencil5+0x495>
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%rax
lea    0x1(%rax),%esi
mov    %eax,%edi
movups (%rbx,%rdi,4),%xmm2
add    $0x2,%eax
movups (%rbx,%rax,4),%xmm3
addps  %xmm2,%xmm3
lea    (%rcx,%r13,1),%eax
add    $0x1,%eax
movups (%rbx,%rax,4),%xmm2
addps  %xmm3,%xmm2
lea    (%r15,%rcx,1),%eax
movups (%rbx,%rax,4),%xmm3
addps  %xmm2,%xmm3
mulps  %xmm1,%xmm3
movups %xmm3,(%r14,%rsi,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1870 <float_stencil5+0x6e0>
mov    0xc0(%rsp),%rcx
cmp    %rdx,0x20(%rsp)
jne    1625 <float_stencil5+0x495>
jmp    166e <float_stencil5+0x4de>
mov    0x8(%rsp),%r12
mov    0x10(%rsp),%r10d
jmp    1625 <float_stencil5+0x495>
mov    0x8(%rsp),%r12
jmp    1625 <float_stencil5+0x495>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%r13
test   %r13b,%r13b
mov    0x38(%rsp),%r11
mov    0xa8(%rsp),%r15
je     15c0 <float_stencil5+0x430>
mov    $0x1,%edx
xor    %r10d,%r10d
mov    %r12,%rbp
mov    0x7c(%rsp),%r9d
jmp    1936 <float_stencil5+0x7a6>
nopl   (%rax)
add    $0x1,%edx
add    $0x1,%r10d
add    %r11d,%r9d
add    %r12,%rbp
cmp    %r8d,%edx
je     15c0 <float_stencil5+0x430>
mov    $0x1,%esi
cmpq   $0x8,0x20(%rsp)
jb     1a10 <float_stencil5+0x880>
cmpq   $0x0,0x80(%rsp)
setne  %al
mov    %r10d,%ecx
imul   %r11d,%ecx
add    0x88(%rsp),%ecx
add    0x68(%rsp),%ecx
setb   %cl
or     %al,%cl
or     0x7(%rsp),%cl
jne    1a10 <float_stencil5+0x880>
cmpq   $0x8,0xd8(%rsp)
jae    1983 <float_stencil5+0x7f3>
xor    %esi,%esi
jmp    19ca <float_stencil5+0x83a>
mov    %r15,%rax
mov    %r9d,%ecx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    -0x8(%rcx),%edi
movups (%r14,%rdi,4),%xmm2
movups 0x10(%r14,%rdi,4),%xmm3
movups %xmm2,(%rbx,%rdi,4)
movups %xmm3,0x10(%rbx,%rdi,4)
mov    %ecx,%edi
movups (%r14,%rdi,4),%xmm2
movups 0x10(%r14,%rdi,4),%xmm3
movups %xmm2,(%rbx,%rdi,4)
movups %xmm3,0x10(%rbx,%rdi,4)
add    $0x10,%rsi
add    $0x10,%ecx
add    $0xfffffffffffffffe,%rax
jne    1990 <float_stencil5+0x800>
testb  $0x1,0xd0(%rsp)
01
je     19f3 <float_stencil5+0x863>
mov    %edx,%eax
imul   %r11d,%eax
or     $0x1,%esi
add    %eax,%esi
movups (%r14,%rsi,4),%xmm2
movups 0x10(%r14,%rsi,4),%xmm3
movups %xmm2,(%rbx,%rsi,4)
movups %xmm3,0x10(%rbx,%rsi,4)
mov    0xb8(%rsp),%rsi
mov    0xc8(%rsp),%rax
cmp    %rax,0x20(%rsp)
je     1920 <float_stencil5+0x790>
xchg   %ax,%ax
mov    %r8d,%eax
sub    %esi,%eax
mov    %rsi,%rcx
not    %rcx
add    %r8,%rcx
and    $0x3,%rax
je     1a48 <float_stencil5+0x8b8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rsi,%rbp,1),%edi
movss  (%r14,%rdi,4),%xmm2
movss  %xmm2,(%rbx,%rdi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1a30 <float_stencil5+0x8a0>
cmp    $0x3,%rcx
jb     1920 <float_stencil5+0x790>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rsi,%rbp,1),%rax
mov    %eax,%ecx
movss  (%r14,%rcx,4),%xmm2
movss  %xmm2,(%rbx,%rcx,4)
lea    0x1(%rax),%ecx
movss  (%r14,%rcx,4),%xmm2
movss  %xmm2,(%rbx,%rcx,4)
lea    0x2(%rax),%ecx
movss  (%r14,%rcx,4),%xmm2
movss  %xmm2,(%rbx,%rcx,4)
add    $0x3,%eax
movss  (%r14,%rax,4),%xmm2
movss  %xmm2,(%rbx,%rax,4)
add    $0x4,%rsi
cmp    %rsi,%r8
jne    1a60 <float_stencil5+0x8d0>
jmp    1920 <float_stencil5+0x790>
mov    0x2530(%rip),%rax
mov    (%rax),%edi
lea    0x70(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    0x78(%rsp),%edi
mov    0x70(%rsp),%esi
lea    0x585(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    %rbx,%rdi
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
add    $0x118,%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 Single 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"Single Precision Stencil - 5 point\00"
define void @float_stencil5(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca float
%8 = alloca float*
%9 = alloca float*
%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 float 1.250000e-01, float* %7
%14 = load i32, i32* %2
%15 = zext i32 %14 to i64
%16 = mul i64 4, %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 float*
store float* %22, float** %8
%23 = load i32, i32* %2
%24 = zext i32 %23 to i64
%25 = mul i64 4, %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 float*
store float* %31, float** %9
%32 = load float*, float** %8
%33 = icmp eq float* %32, null
br i1 %33, label %37, label %34
34: ; preds = %1
%35 = load float*, float** %9
%36 = icmp eq float* %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 float*, float** %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 float, float* %56, i64 %62
store float 0.000000e+00, float* %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 = %103, %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 %106
77: ; preds = %72
store i32 1, i32* %4
br label %78
78: ; preds = %99, %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 %102
83: ; preds = %78
%84 = call i64 (...) @rand()
%85 = sitofp i64 %84 to float
%86 = load i64, i64* @RAND_MAX
%87 = sitofp i64 %86 to double
%88 = fadd double 1.000000e+00, %87
%89 = fptrunc double %88 to float
%90 = fdiv float %85, %89
%91 = load float*, float** %8
%92 = load i32, i32* %3
%93 = load i32, i32* %2
%94 = mul i32 %92, %93
%95 = load i32, i32* %4
%96 = add i32 %94, %95
%97 = zext i32 %96 to i64
%98 = getelementptr inbounds float, float* %91, i64 %97
store float %90, float* %98
br label %99
99: ; preds = %83
%100 = load i32, i32* %4
%101 = add nsw i32 %100, 1
store i32 %101, i32* %4
br label %78
102: ; preds = %78
br label %103
103: ; preds = %102
%104 = load i32, i32* %3
%105 = add nsw i32 %104, 1
store i32 %105, i32* %3
br label %72
106: ; preds = %72
%107 = load i32, i32* @CLOCK_MONOTONIC_RAW
%108 = call i32 @clock_gettime(i32 %107, %struct.timespec* %10)
store i32 0, i32* %5
br label %109
109: ; preds = %223, %106
%110 = load i32, i32* %5
%111 = icmp slt i32 %110, 100
br i1 %111, label %112, label %226
112: ; preds = %109
store i32 1, i32* %3
br label %113
113: ; preds = %182, %112
%114 = load i32, i32* %3
%115 = load i32, i32* %6
%116 = add nsw i32 %115, 1
%117 = icmp slt i32 %114, %116
br i1 %117, label %118, label %185
118: ; preds = %113
store i32 1, i32* %4
br label %119
119: ; preds = %178, %118
%120 = load i32, i32* %4
%121 = load i32, i32* %6
%122 = add nsw i32 %121, 1
%123 = icmp slt i32 %120, %122
br i1 %123, label %124, label %181
124: ; preds = %119
%125 = load float*, float** %8
%126 = load i32, i32* %3
%127 = load i32, i32* %2
%128 = mul i32 %126, %127
%129 = load i32, i32* %4
%130 = sub nsw i32 %129, 1
%131 = add i32 %128, %130
%132 = zext i32 %131 to i64
%133 = getelementptr inbounds float, float* %125, i64 %132
%134 = load float, float* %133
%135 = load float*, float** %8
%136 = load i32, i32* %3
%137 = load i32, i32* %2
%138 = mul i32 %136, %137
%139 = load i32, i32* %4
%140 = add nsw i32 %139, 1
%141 = add i32 %138, %140
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds float, float* %135, i64 %142
%144 = load float, float* %143
%145 = fadd float %134, %144
%146 = load float*, float** %8
%147 = load i32, i32* %3
%148 = sub nsw i32 %147, 1
%149 = load i32, i32* %2
%150 = mul i32 %148, %149
%151 = load i32, i32* %4
%152 = add i32 %150, %151
%153 = zext i32 %152 to i64
%154 = getelementptr inbounds float, float* %146, i64 %153
%155 = load float, float* %154
%156 = fadd float %145, %155
%157 = load float*, float** %8
%158 = load i32, i32* %3
%159 = add nsw i32 %158, 1
%160 = load i32, i32* %2
%161 = mul i32 %159, %160
%162 = load i32, i32* %4
%163 = add i32 %161, %162
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds float, float* %157, i64 %164
%166 = load float, float* %165
%167 = fadd float %156, %166
%168 = load float, float* %7
%169 = fmul float %167, %168
%170 = load float*, float** %9
%171 = load i32, i32* %3
%172 = load i32, i32* %2
%173 = mul i32 %171, %172
%174 = load i32, i32* %4
%175 = add i32 %173, %174
%176 = zext i32 %175 to i64
%177 = getelementptr inbounds float, float* %170, i64 %176
store float %169, float* %177
br label %178
178: ; preds = %124
%179 = load i32, i32* %4
%180 = add nsw i32 %179, 1
store i32 %180, i32* %4
br label %119
181: ; preds = %119
br label %182
182: ; preds = %181
%183 = load i32, i32* %3
%184 = add nsw i32 %183, 1
store i32 %184, i32* %3
br label %113
185: ; preds = %113
store i32 1, i32* %3
br label %186
186: ; preds = %219, %185
%187 = load i32, i32* %3
%188 = load i32, i32* %6
%189 = add nsw i32 %188, 1
%190 = icmp slt i32 %187, %189
br i1 %190, label %191, label %222
191: ; preds = %186
store i32 1, i32* %4
br label %192
192: ; preds = %215, %191
%193 = load i32, i32* %4
%194 = load i32, i32* %6
%195 = add nsw i32 %194, 1
%196 = icmp slt i32 %193, %195
br i1 %196, label %197, label %218
197: ; preds = %192
%198 = load float*, float** %9
%199 = load i32, i32* %3
%200 = load i32, i32* %2
%201 = mul i32 %199, %200
%202 = load i32, i32* %4
%203 = add i32 %201, %202
%204 = zext i32 %203 to i64
%205 = getelementptr inbounds float, float* %198, i64 %204
%206 = load float, float* %205
%207 = load float*, float** %8
%208 = load i32, i32* %3
%209 = load i32, i32* %2
%210 = mul i32 %208, %209
%211 = load i32, i32* %4
%212 = add i32 %210, %211
%213 = zext i32 %212 to i64
%214 = getelementptr inbounds float, float* %207, i64 %213
store float %206, float* %214
br label %215
215: ; preds = %197
%216 = load i32, i32* %4
%217 = add nsw i32 %216, 1
store i32 %217, i32* %4
br label %192
218: ; preds = %192
br label %219
219: ; preds = %218
%220 = load i32, i32* %3
%221 = add nsw i32 %220, 1
store i32 %221, i32* %3
br label %186
222: ; preds = %186
br label %223
223: ; preds = %222
%224 = load i32, i32* %5
%225 = add nsw i32 %224, 1
store i32 %225, i32* %5
br label %109
226: ; preds = %109
%227 = load i32, i32* @CLOCK_MONOTONIC_RAW
%228 = call i32 @clock_gettime(i32 %227, %struct.timespec* %11)
%229 = getelementptr inbounds %struct.timespec, %struct.timespec* %10, i32 0, i32 0
%230 = load i32, i32* %229
%231 = getelementptr inbounds %struct.timespec, %struct.timespec* %11, i32 0, i32 0
%232 = load i32, i32* %231
%233 = call i32 @elapsed_time_hr(i32 %230, i32 %232, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.2, i64 0, i64 0))
%234 = load float*, float** %8
%235 = call i32 @free(float* %234)
%236 = load float*, float** %9
%237 = call i32 @free(float* %236)
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"Single Precision Stencil - 5 point\00"
@str = [66 x i8] c"9-point Single Precision Stencil Error: Unable to allocate memory\00"
define void @float_stencil5(i32 %0) {
%2 = alloca %struct.timespec
%3 = alloca %struct.timespec
%4 = shl i32 %0, 2
%5 = mul i32 %4, %0
%6 = tail call i64 @malloc(i32 %5)
%7 = inttoptr i64 %6 to float*
%8 = tail call i64 @malloc(i32 %5)
%9 = inttoptr i64 %8 to float*
%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 %174, label %25
25: ; preds = %21
%26 = zext i32 %0 to i64
%27 = add nsw i64 %26, -1
%28 = and i64 %26, 4294967288
%29 = add nsw i64 %28, -8
%30 = lshr exact i64 %29, 3
%31 = add nuw nsw i64 %30, 1
%32 = icmp ult i32 %0, 8
%33 = trunc i64 %27 to i32
%34 = icmp ugt i64 %27, 4294967295
%35 = and i64 %26, 4294967288
%36 = and i64 %31, 3
%37 = icmp ult i64 %29, 24
%38 = and i64 %31, 4611686018427387900
%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 float, float* %7, i64 %57
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %59
%60 = getelementptr inbounds float, float* %58, i64 4
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %61
%62 = trunc i64 %53 to i32
%63 = or i32 %62, 8
%64 = add i32 %45, %63
%65 = zext i32 %64 to i64
%66 = getelementptr inbounds float, float* %7, i64 %65
%67 = bitcast float* %66 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %67
%68 = getelementptr inbounds float, float* %66, i64 4
%69 = bitcast float* %68 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %69
%70 = trunc i64 %53 to i32
%71 = or i32 %70, 16
%72 = add i32 %45, %71
%73 = zext i32 %72 to i64
%74 = getelementptr inbounds float, float* %7, i64 %73
%75 = bitcast float* %74 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %75
%76 = getelementptr inbounds float, float* %74, i64 4
%77 = bitcast float* %76 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %77
%78 = trunc i64 %53 to i32
%79 = or i32 %78, 24
%80 = add i32 %45, %79
%81 = zext i32 %80 to i64
%82 = getelementptr inbounds float, float* %7, i64 %81
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %83
%84 = getelementptr inbounds float, float* %82, i64 4
%85 = bitcast float* %84 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %85
%86 = add nuw i64 %53, 32
%87 = add 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 float, float* %7, i64 %96
%98 = bitcast float* %97 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %98
%99 = getelementptr inbounds float, float* %97, i64 4
%100 = bitcast float* %99 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %100
%101 = add nuw i64 %92, 8
%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 float, float* %7, i64 %114
store float 0.000000e+00, float* %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 %174
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 float, float* %7, i64 %131
store float 0.000000e+00, float* %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 float, float* %7, i64 %136
store float 0.000000e+00, float* %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 float, float* %7, i64 %141
store float 0.000000e+00, float* %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 float, float* %7, i64 %146
store float 0.000000e+00, float* %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 = %171, %125
%154 = phi i32 [ 1, %125 ], [ %172, %171 ]
%155 = mul i32 %154, %0
br label %156
156: ; preds = %153, %156
%157 = phi i64 [ 1, %153 ], [ %169, %156 ]
%158 = tail call i64 (...) @rand()
%159 = sitofp i64 %158 to float
%160 = load i64, i64* @RAND_MAX
%161 = sitofp i64 %160 to double
%162 = fadd double %161, 1.000000e+00
%163 = fptrunc double %162 to float
%164 = fdiv float %159, %163
%165 = trunc i64 %157 to i32
%166 = add i32 %155, %165
%167 = zext i32 %166 to i64
%168 = getelementptr inbounds float, float* %7, i64 %167
store float %164, float* %168
%169 = add nuw nsw i64 %157, 1
%170 = icmp eq i64 %169, %126
br i1 %170, label %171, label %156
171: ; preds = %156
%172 = add nuw nsw i32 %154, 1
%173 = icmp eq i32 %172, %123
br i1 %173, label %174, label %153
174: ; preds = %171, %21, %122
%175 = phi i1 [ false, %122 ], [ false, %21 ], [ %124, %171 ]
%176 = phi i32 [ %123, %122 ], [ -1, %21 ], [ %123, %171 ]
%177 = load i32, i32* @CLOCK_MONOTONIC_RAW
%178 = call i32 @clock_gettime(i32 %177, %struct.timespec* %2)
%179 = zext i32 %176 to i64
%180 = zext i32 %176 to i64
%181 = add nsw i64 %179, -2
%182 = add i32 %0, 1
%183 = add nsw i64 %179, -1
%184 = getelementptr float, float* %7, i64 %183
%185 = getelementptr float, float* %9, i64 %183
%186 = add nsw i64 %179, -1
%187 = add nsw i64 %179, -2
%188 = add i32 %0, 2
%189 = shl i32 %0, 1
%190 = or i32 %189, 1
%191 = add i32 %0, 1
%192 = add nsw i64 %179, -1
%193 = getelementptr float, float* %9, i64 %192
%194 = or i32 %189, 1
%195 = getelementptr float, float* %7, i64 %192
%196 = getelementptr float, float* %7, i64 %192
%197 = add i32 %0, 2
%198 = getelementptr float, float* %7, i64 %192
%199 = getelementptr float, float* %7, i64 %192
%200 = add nsw i64 %179, -1
%201 = add nsw i64 %179, -9
%202 = lshr i64 %201, 3
%203 = add nuw nsw i64 %202, 1
%204 = icmp ult i64 %200, 4
%205 = trunc i64 %187 to i32
%206 = icmp ugt i64 %187, 4294967295
%207 = trunc i64 %187 to i32
%208 = icmp ugt i64 %187, 4294967295
%209 = trunc i64 %187 to i32
%210 = icmp ugt i64 %187, 4294967295
%211 = trunc i64 %187 to i32
%212 = icmp ugt i64 %187, 4294967295
%213 = trunc i64 %187 to i32
%214 = icmp ugt i64 %187, 4294967295
%215 = and i64 %200, -4
%216 = or i64 %215, 1
%217 = icmp eq i64 %200, %215
%218 = icmp ult i64 %186, 8
%219 = trunc i64 %181 to i32
%220 = icmp ugt i64 %181, 4294967295
%221 = icmp ugt float* %185, %7
%222 = icmp ugt float* %184, %9
%223 = and i1 %221, %222
%224 = and i64 %186, -8
%225 = or i64 %224, 1
%226 = and i64 %203, 1
%227 = icmp ult i64 %201, 8
%228 = and i64 %203, 4611686018427387902
%229 = icmp eq i64 %226, 0
%230 = icmp eq i64 %186, %224
br label %231
231: ; preds = %174, %496
%232 = phi i32 [ 0, %174 ], [ %497, %496 ]
br i1 %175, label %234, label %496
233: ; preds = %372
br i1 %175, label %375, label %496
234: ; preds = %231, %372
%235 = phi i32 [ %374, %372 ], [ 0, %231 ]
%236 = phi i32 [ %262, %372 ], [ 1, %231 ]
%237 = mul i32 %235, %0
%238 = add i32 %191, %237
%239 = zext i32 %238 to i64
%240 = getelementptr float, float* %9, i64 %239
%241 = getelementptr float, float* %193, i64 %239
%242 = add i32 %194, %237
%243 = zext i32 %242 to i64
%244 = getelementptr float, float* %7, i64 %243
%245 = getelementptr float, float* %195, i64 %243
%246 = add i32 %237, 1
%247 = zext i32 %246 to i64
%248 = getelementptr float, float* %7, i64 %247
%249 = getelementptr float, float* %196, i64 %247
%250 = add i32 %197, %237
%251 = zext i32 %250 to i64
%252 = getelementptr float, float* %7, i64 %251
%253 = getelementptr float, float* %198, i64 %251
%254 = add i32 %237, %0
%255 = zext i32 %254 to i64
%256 = getelementptr float, float* %7, i64 %255
%257 = getelementptr float, float* %199, i64 %255
%258 = mul i32 %235, %0
%259 = mul i32 %236, %0
%260 = add nsw i32 %236, -1
%261 = mul i32 %260, %0
%262 = add nuw nsw i32 %236, 1
%263 = mul i32 %262, %0
br i1 %204, label %341, label %264
264: ; preds = %234
%265 = add i32 %190, %258
%266 = add i32 %188, %258
%267 = add i32 %258, %0
%268 = add i32 %182, %258
%269 = xor i32 %268, -1
%270 = icmp ult i32 %269, %205
%271 = or i1 %270, %206
%272 = xor i32 %267, -1
%273 = icmp ult i32 %272, %207
%274 = or i1 %273, %208
%275 = xor i32 %266, -1
%276 = icmp ult i32 %275, %209
%277 = or i1 %276, %210
%278 = sub i32 -2, %258
%279 = icmp ult i32 %278, %211
%280 = or i1 %279, %212
%281 = xor i32 %265, -1
%282 = icmp ult i32 %281, %213
%283 = or i1 %282, %214
%284 = or i1 %271, %274
%285 = or i1 %284, %277
%286 = or i1 %285, %280
%287 = or i1 %286, %283
br i1 %287, label %341, label %288
288: ; preds = %264
%289 = icmp ult float* %240, %245
%290 = icmp ult float* %244, %241
%291 = and i1 %289, %290
%292 = icmp ult float* %240, %249
%293 = icmp ult float* %248, %241
%294 = and i1 %292, %293
%295 = or i1 %291, %294
%296 = icmp ult float* %240, %253
%297 = icmp ult float* %252, %241
%298 = and i1 %296, %297
%299 = or i1 %295, %298
%300 = icmp ult float* %240, %257
%301 = icmp ult float* %256, %241
%302 = and i1 %300, %301
%303 = or i1 %299, %302
br i1 %303, label %341, label %304
304: ; preds = %288, %304
%305 = phi i64 [ %338, %304 ], [ 0, %288 ]
%306 = trunc i64 %305 to i32
%307 = or i32 %306, 1
%308 = add i32 %259, %307
%309 = add i32 %308, -1
%310 = zext i32 %309 to i64
%311 = getelementptr inbounds float, float* %7, i64 %310
%312 = bitcast float* %311 to <4 x float>*
%313 = load <4 x float>, <4 x float>* %312
%314 = trunc i64 %305 to i32
%315 = or i32 %314, 2
%316 = add i32 %259, %315
%317 = zext i32 %316 to i64
%318 = getelementptr inbounds float, float* %7, i64 %317
%319 = bitcast float* %318 to <4 x float>*
%320 = load <4 x float>, <4 x float>* %319
%321 = fadd <4 x float> %313, %320
%322 = add i32 %261, %307
%323 = zext i32 %322 to i64
%324 = getelementptr inbounds float, float* %7, i64 %323
%325 = bitcast float* %324 to <4 x float>*
%326 = load <4 x float>, <4 x float>* %325
%327 = fadd <4 x float> %321, %326
%328 = add i32 %263, %307
%329 = zext i32 %328 to i64
%330 = getelementptr inbounds float, float* %7, i64 %329
%331 = bitcast float* %330 to <4 x float>*
%332 = load <4 x float>, <4 x float>* %331
%333 = fadd <4 x float> %327, %332
%334 = fmul <4 x float> %333, <float 1.250000e-01, float 1.250000e-01, float 1.250000e-01, float 1.250000e-01>
%335 = zext i32 %308 to i64
%336 = getelementptr inbounds float, float* %9, i64 %335
%337 = bitcast float* %336 to <4 x float>*
store <4 x float> %334, <4 x float>* %337
%338 = add nuw i64 %305, 4
%339 = icmp eq i64 %338, %215
br i1 %339, label %340, label %304
340: ; preds = %304
br i1 %217, label %372, label %341
341: ; preds = %288, %264, %234, %340
%342 = phi i64 [ 1, %288 ], [ 1, %264 ], [ 1, %234 ], [ %216, %340 ]
br label %343
343: ; preds = %341, %343
%344 = phi i64 [ %351, %343 ], [ %342, %341 ]
%345 = trunc i64 %344 to i32
%346 = add i32 %259, %345
%347 = add i32 %346, -1
%348 = zext i32 %347 to i64
%349 = getelementptr inbounds float, float* %7, i64 %348
%350 = load float, float* %349
%351 = add nuw nsw i64 %344, 1
%352 = trunc i64 %351 to i32
%353 = add i32 %259, %352
%354 = zext i32 %353 to i64
%355 = getelementptr inbounds float, float* %7, i64 %354
%356 = load float, float* %355
%357 = fadd float %350, %356
%358 = add i32 %261, %345
%359 = zext i32 %358 to i64
%360 = getelementptr inbounds float, float* %7, i64 %359
%361 = load float, float* %360
%362 = fadd float %357, %361
%363 = add i32 %263, %345
%364 = zext i32 %363 to i64
%365 = getelementptr inbounds float, float* %7, i64 %364
%366 = load float, float* %365
%367 = fadd float %362, %366
%368 = fmul float %367, 1.250000e-01
%369 = zext i32 %346 to i64
%370 = getelementptr inbounds float, float* %9, i64 %369
store float %368, float* %370
%371 = icmp eq i64 %351, %179
br i1 %371, label %372, label %343
372: ; preds = %343, %340
%373 = icmp eq i32 %262, %176
%374 = add i32 %235, 1
br i1 %373, label %233, label %234
375: ; preds = %233, %492
%376 = phi i32 [ %495, %492 ], [ 0, %233 ]
%377 = phi i32 [ %493, %492 ], [ 1, %233 ]
%378 = mul i32 %377, %0
br i1 %218, label %439, label %379
379: ; preds = %375
%380 = mul i32 %376, %0
%381 = add i32 %182, %380
%382 = xor i32 %381, -1
%383 = icmp ult i32 %382, %219
%384 = or i1 %383, %220
%385 = select i1 %384, i1 true, i1 %223
br i1 %385, label %439, label %386
386: ; preds = %379
br i1 %227, label %421, label %387
387: ; preds = %386, %387
%388 = phi i64 [ %418, %387 ], [ 0, %386 ]
%389 = phi i64 [ %419, %387 ], [ 0, %386 ]
%390 = trunc i64 %388 to i32
%391 = or i32 %390, 1
%392 = add i32 %378, %391
%393 = zext i32 %392 to i64
%394 = getelementptr inbounds float, float* %9, i64 %393
%395 = bitcast float* %394 to <4 x float>*
%396 = load <4 x float>, <4 x float>* %395
%397 = getelementptr inbounds float, float* %394, i64 4
%398 = bitcast float* %397 to <4 x float>*
%399 = load <4 x float>, <4 x float>* %398
%400 = getelementptr inbounds float, float* %7, i64 %393
%401 = bitcast float* %400 to <4 x float>*
store <4 x float> %396, <4 x float>* %401
%402 = getelementptr inbounds float, float* %400, i64 4
%403 = bitcast float* %402 to <4 x float>*
store <4 x float> %399, <4 x float>* %403
%404 = trunc i64 %388 to i32
%405 = or i32 %404, 9
%406 = add i32 %378, %405
%407 = zext i32 %406 to i64
%408 = getelementptr inbounds float, float* %9, i64 %407
%409 = bitcast float* %408 to <4 x float>*
%410 = load <4 x float>, <4 x float>* %409
%411 = getelementptr inbounds float, float* %408, i64 4
%412 = bitcast float* %411 to <4 x float>*
%413 = load <4 x float>, <4 x float>* %412
%414 = getelementptr inbounds float, float* %7, i64 %407
%415 = bitcast float* %414 to <4 x float>*
store <4 x float> %410, <4 x float>* %415
%416 = getelementptr inbounds float, float* %414, i64 4
%417 = bitcast float* %416 to <4 x float>*
store <4 x float> %413, <4 x float>* %417
%418 = add nuw i64 %388, 16
%419 = add i64 %389, 2
%420 = icmp eq i64 %419, %228
br i1 %420, label %421, label %387
421: ; preds = %387, %386
%422 = phi i64 [ 0, %386 ], [ %418, %387 ]
br i1 %229, label %438, label %423
423: ; preds = %421
%424 = trunc i64 %422 to i32
%425 = or i32 %424, 1
%426 = add i32 %378, %425
%427 = zext i32 %426 to i64
%428 = getelementptr inbounds float, float* %9, i64 %427
%429 = bitcast float* %428 to <4 x float>*
%430 = load <4 x float>, <4 x float>* %429
%431 = getelementptr inbounds float, float* %428, i64 4
%432 = bitcast float* %431 to <4 x float>*
%433 = load <4 x float>, <4 x float>* %432
%434 = getelementptr inbounds float, float* %7, i64 %427
%435 = bitcast float* %434 to <4 x float>*
store <4 x float> %430, <4 x float>* %435
%436 = getelementptr inbounds float, float* %434, i64 4
%437 = bitcast float* %436 to <4 x float>*
store <4 x float> %433, <4 x float>* %437
br label %438
438: ; preds = %421, %423
br i1 %230, label %492, label %439
439: ; preds = %379, %375, %438
%440 = phi i64 [ 1, %379 ], [ 1, %375 ], [ %225, %438 ]
%441 = sub nsw i64 %179, %440
%442 = xor i64 %440, -1
%443 = add nsw i64 %442, %179
%444 = and i64 %441, 3
%445 = icmp eq i64 %444, 0
br i1 %445, label %458, label %446
446: ; preds = %439, %446
%447 = phi i64 [ %455, %446 ], [ %440, %439 ]
%448 = phi i64 [ %456, %446 ], [ 0, %439 ]
%449 = trunc i64 %447 to i32
%450 = add i32 %378, %449
%451 = zext i32 %450 to i64
%452 = getelementptr inbounds float, float* %9, i64 %451
%453 = load float, float* %452
%454 = getelementptr inbounds float, float* %7, i64 %451
store float %453, float* %454
%455 = add nuw nsw i64 %447, 1
%456 = add i64 %448, 1
%457 = icmp eq i64 %456, %444
br i1 %457, label %458, label %446
458: ; preds = %446, %439
%459 = phi i64 [ %440, %439 ], [ %455, %446 ]
%460 = icmp ult i64 %443, 3
br i1 %460, label %492, label %461
461: ; preds = %458, %461
%462 = phi i64 [ %490, %461 ], [ %459, %458 ]
%463 = trunc i64 %462 to i32
%464 = add i32 %378, %463
%465 = zext i32 %464 to i64
%466 = getelementptr inbounds float, float* %9, i64 %465
%467 = load float, float* %466
%468 = getelementptr inbounds float, float* %7, i64 %465
store float %467, float* %468
%469 = trunc i64 %462 to i32
%470 = add i32 %469, 1
%471 = add i32 %378, %470
%472 = zext i32 %471 to i64
%473 = getelementptr inbounds float, float* %9, i64 %472
%474 = load float, float* %473
%475 = getelementptr inbounds float, float* %7, i64 %472
store float %474, float* %475
%476 = trunc i64 %462 to i32
%477 = add i32 %476, 2
%478 = add i32 %378, %477
%479 = zext i32 %478 to i64
%480 = getelementptr inbounds float, float* %9, i64 %479
%481 = load float, float* %480
%482 = getelementptr inbounds float, float* %7, i64 %479
store float %481, float* %482
%483 = trunc i64 %462 to i32
%484 = add i32 %483, 3
%485 = add i32 %378, %484
%486 = zext i32 %485 to i64
%487 = getelementptr inbounds float, float* %9, i64 %486
%488 = load float, float* %487
%489 = getelementptr inbounds float, float* %7, i64 %486
store float %488, float* %489
%490 = add nuw nsw i64 %462, 4
%491 = icmp eq i64 %490, %180
br i1 %491, label %492, label %461
492: ; preds = %458, %461, %438
%493 = add nuw nsw i32 %377, 1
%494 = icmp eq i32 %493, %176
%495 = add i32 %376, 1
br i1 %494, label %496, label %375
496: ; preds = %492, %231, %233
%497 = add nuw nsw i32 %232, 1
%498 = icmp eq i32 %497, 100
br i1 %498, label %499, label %231
499: ; preds = %496
%500 = load i32, i32* @CLOCK_MONOTONIC_RAW
%501 = call i32 @clock_gettime(i32 %500, %struct.timespec* %3)
%502 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 0, i32 0
%503 = load i32, i32* %502
%504 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 0
%505 = load i32, i32* %504
%506 = call i32 @elapsed_time_hr(i32 %503, i32 %505, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.2, i64 0, i64 0))
%507 = call i32 @free(float* %7)
%508 = call i32 @free(float* %9)
ret void
}