#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_stencil9(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] +
               a0[(i - 1) * size + (j - 1)] + a0[(i - 1) * size + (j + 1)] +
               a0[(i + 1) * size + (j - 1)] + a0[(i + 1) * size + (j + 1)]) *
              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 - 9 point");
  free(a0);
  free(a1);
}


x86 assembly (clang, -O0):
<float_stencil9>:
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_stencil9+0x69>
cmpq   $0x0,-0x28(%rbp)
jne    11f7 <float_stencil9+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_stencil9+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_stencil9+0xfe>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    126b <float_stencil9+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_stencil9+0xb9>
jmp    1270 <float_stencil9+0xf0>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1226 <float_stencil9+0xa6>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1310 <float_stencil9+0x190>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12fd <float_stencil9+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_stencil9+0x11d>
jmp    1302 <float_stencil9+0x182>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1285 <float_stencil9+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    1504 <float_stencil9+0x384>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1476 <float_stencil9+0x2f6>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1463 <float_stencil9+0x2e3>
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
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $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
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
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
add    %edx,%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_stencil9+0x1d2>
jmp    1468 <float_stencil9+0x2e8>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    133a <float_stencil9+0x1ba>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14f1 <float_stencil9+0x371>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14de <float_stencil9+0x35e>
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    1495 <float_stencil9+0x315>
jmp    14e3 <float_stencil9+0x363>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    147d <float_stencil9+0x2fd>
jmp    14f6 <float_stencil9+0x376>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1329 <float_stencil9+0x1a9>
mov    0x2ad5(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1060 <clock_gettime@plt>
mov    -0x30(%rbp),%edi
mov    -0x38(%rbp),%esi
lea    0xb5c(%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_stencil9>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%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_stencil9+0x3a>
test   %r14,%r14
jne    11d6 <float_stencil9+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_stencil9+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,0x10(%rsp)
mov    %r13d,%ebp
test   %r13d,%r13d
mov    %r13,0x70(%rsp)
mov    %rbp,0x30(%rsp)
je     1477 <float_stencil9+0x2e7>
mov    %r15,%rax
lea    -0x1(%rbp),%r15
mov    %ebp,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%r8
mov    %r8,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9d,%r10d
and    $0x3,%r10d
and    %rax,%r9
mov    %ebp,%r12d
and    $0x3,%r12d
mov    $0x10,%edx
xorps  %xmm0,%xmm0
xor    %esi,%esi
jmp    127c <float_stencil9+0xec>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
add    $0x1,%eax
add    %r13d,%edx
add    %rbp,%rsi
mov    %rax,0x10(%rsp)
cmp    %r13d,%eax
je     13ba <float_stencil9+0x22a>
cmp    $0x8,%r13d
jae    1300 <float_stencil9+0x170>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %rbp,%rax
test   %r12,%r12
je     12b4 <float_stencil9+0x124>
mov    %r12,%rdi
nopl   0x0(%rax)
lea    (%rsi,%rcx,1),%ebp
movl   $0x0,(%rbx,%rbp,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    12a0 <float_stencil9+0x110>
cmp    $0x3,%rax
mov    0x30(%rsp),%rbp
jb     1260 <float_stencil9+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_stencil9+0x130>
jmp    1260 <float_stencil9+0xd0>
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
imul   %r13d,%eax
add    %r15d,%eax
jb     1286 <float_stencil9+0xf6>
mov    %r15,%rax
shr    $0x20,%rax
mov    $0x0,%ecx
jne    1288 <float_stencil9+0xf8>
cmp    $0x18,%r8
jae    132e <float_stencil9+0x19e>
xor    %ecx,%ecx
jmp    137c <float_stencil9+0x1ec>
mov    %r9,%rdi
mov    %edx,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
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_stencil9+0x1b0>
test   %r10,%r10
je     13a4 <float_stencil9+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_stencil9+0x200>
mov    %r11,%rcx
mov    0x30(%rsp),%rbp
cmp    %rbp,%r11
je     1260 <float_stencil9+0xd0>
jmp    1288 <float_stencil9+0xf8>
lea    -0x1(%r13),%r12d
cmp    $0x2,%r12d
setge  %al
mov    %rax,0x10(%rsp)
jl     147f <float_stencil9+0x2ef>
mov    %r12d,%eax
lea    0x1(%r13),%ecx
add    $0xffffffffffffffff,%rax
mov    %rax,0x38(%rsp)
mov    $0x1,%ebp
mov    0x2bfc(%rip),%r15
mov    %r12d,0x28(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%r12
mov    %ecx,0x2c(%rsp)
mov    %ecx,%r13d
nopl   0x0(%rax)
xor    %eax,%eax
call   10b0 <rand@plt>
movsd  0xbe1(%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    1410 <float_stencil9+0x280>
add    $0x1,%ebp
mov    0x70(%rsp),%r13
mov    0x2c(%rsp),%ecx
add    %r13d,%ecx
mov    0x28(%rsp),%r12d
cmp    %r12d,%ebp
jne    1400 <float_stencil9+0x270>
movabs $0x3ffffffffffffffc,%r15
ff ff 3f
mov    0x30(%rsp),%rbp
jmp    1490 <float_stencil9+0x300>
mov    $0xffffffff,%r12d
jmp    1490 <float_stencil9+0x300>
xor    %eax,%eax
mov    %rax,0x10(%rsp)
movabs $0x3ffffffffffffffc,%r15
ff ff 3f
mov    0x2b49(%rip),%rax
mov    (%rax),%edi
lea    0x98(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    %r12d,%r12d
lea    -0x2(%r12),%r8
lea    0x1(%r13),%eax
mov    %rax,0xa8(%rsp)
lea    -0x1(%r12),%rcx
lea    -0x4(%rbx,%r12,4),%r9
lea    -0x4(%r14,%r12,4),%rax
lea    0x2(%r13),%edi
mov    %rdi,0x128(%rsp)
lea    -0x9(%r12),%rdi
mov    %rdi,0xf8(%rsp)
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rax,0x100(%rsp)
cmp    %rbx,%rax
seta   %r10b
lea    0x0(%r13,%r13,1),%esi
mov    %rsi,0x80(%rsp)
mov    %r9,0x108(%rsp)
cmp    %r14,%r9
seta   %al
and    %r10b,%al
mov    %al,0xa(%rsp)
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffff8,%rcx
add    $0x2,%r15
mov    %rdi,%rax
mov    %rdi,0xf0(%rsp)
and    %rdi,%r15
lea    -0x2(%r13,%r13,1),%eax
or     $0x1,%rax
mov    %rax,0xb8(%rsp)
movss  0xaca(%rip),%xmm0
mov    %r8,%rax
mov    %r8,0x68(%rsp)
shr    $0x20,%r8
mov    %r8,0xa0(%rsp)
movaps 0xa9f(%rip),%xmm1
lea    0x1(%r13,%r13,1),%eax
mov    %rax,0x120(%rsp)
lea    0x2(%r13,%r13,1),%eax
mov    %rax,0x118(%rsp)
mov    %rdx,0xe8(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0xd8(%rsp)
mov    %rcx,0xe0(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0xd0(%rsp)
lea    -0x1(%r13),%eax
mov    %rax,0xb0(%rsp)
lea    0x9(%r13),%eax
mov    %eax,0x9c(%rsp)
xor    %eax,%eax
mov    0x10(%rsp),%r13
mov    %r15,0xc0(%rsp)
jmp    15f4 <float_stencil9+0x464>
nopl   0x0(%rax,%rax,1)
mov    0xc8(%rsp),%rax
add    $0x1,%eax
cmp    $0x64,%eax
je     1c89 <float_stencil9+0xaf9>
mov    %rax,0xc8(%rsp)
test   %r13b,%r13b
je     15e0 <float_stencil9+0x450>
mov    $0x1,%eax
xor    %r11d,%r11d
mov    $0xffffffffffffffff,%r13
mov    0xb8(%rsp),%r9
mov    0xb0(%rsp),%r10
mov    0x80(%rsp),%r15
mov    %rbp,%r8
xor    %ecx,%ecx
nopl   (%rax)
add    $0x1,%eax
mov    %eax,0x2c(%rsp)
mov    $0x1,%esi
cmpq   $0x4,0x38(%rsp)
mov    %ecx,0x28(%rsp)
jae    16f0 <float_stencil9+0x560>
nopl   0x0(%rax)
lea    (%r10,%rsi,1),%eax
movss  (%rbx,%rax,4),%xmm2
lea    (%r8,%rsi,1),%rcx
lea    0x1(%rcx),%eax
addss  (%rbx,%rax,4),%xmm2
lea    (%r11,%rsi,1),%rax
mov    %eax,%edx
addss  (%rbx,%rdx,4),%xmm2
lea    (%rsi,%r13,1),%edx
mov    %rsi,%rdi
add    %r15,%rdi
mov    %edi,%ebp
addss  (%rbx,%rbp,4),%xmm2
lea    (%r9,%rsi,1),%ebp
addss  (%rbx,%rdx,4),%xmm2
add    $0x1,%eax
addss  (%rbx,%rax,4),%xmm2
addss  (%rbx,%rbp,4),%xmm2
lea    0x1(%rsi),%rax
add    $0x1,%edi
addss  (%rbx,%rdi,4),%xmm2
mulss  %xmm0,%xmm2
mov    %ecx,%ecx
movss  %xmm2,(%r14,%rcx,4)
mov    %rax,%rsi
cmp    %rax,%r12
jne    1650 <float_stencil9+0x4c0>
mov    0x28(%rsp),%ecx
add    $0x1,%ecx
mov    0x30(%rsp),%rbp
add    %rbp,%r8
add    %rbp,%r11
add    %rbp,%r15
add    %rbp,%r10
add    %rbp,%r13
add    %rbp,%r9
mov    0x2c(%rsp),%eax
cmp    %r12d,%eax
jne    1630 <float_stencil9+0x4a0>
jmp    1ac0 <float_stencil9+0x930>
nopw   0x0(%rax,%rax,1)
mov    %ecx,%ebp
mov    0x70(%rsp),%rax
imul   %eax,%ebp
mov    0xa8(%rsp),%rcx
add    %ebp,%ecx
mov    %rcx,0x50(%rsp)
mov    0x118(%rsp),%rcx
lea    (%rcx,%rbp,1),%ecx
mov    %rcx,0x58(%rsp)
mov    0x120(%rsp),%rcx
lea    (%rcx,%rbp,1),%ecx
mov    %rcx,0x60(%rsp)
mov    0x128(%rsp),%rcx
lea    (%rcx,%rbp,1),%edi
lea    0x0(%rbp,%rax,1),%edx
mov    0x80(%rsp),%rax
lea    (%rax,%rbp,1),%ecx
mov    %rdx,0x130(%rsp)
mov    %edx,%eax
mov    0x68(%rsp),%rdx
add    %edx,%eax
setb   0x48(%rsp)
mov    %rdi,0x78(%rsp)
mov    %edi,%eax
mov    0x50(%rsp),%rdi
add    %edx,%eax
setb   0x20(%rsp)
mov    0x60(%rsp),%rax
add    %edx,%eax
setb   0x18(%rsp)
mov    %ebp,%eax
add    %edx,%eax
setb   0x40(%rsp)
add    %edx,%ecx
setb   0x88(%rsp)
mov    0x58(%rsp),%rax
add    %edx,%eax
setb   %cl
mov    %edi,%eax
add    %edx,%eax
jb     1650 <float_stencil9+0x4c0>
mov    %ecx,%edx
mov    0xa0(%rsp),%rcx
test   %rcx,%rcx
jne    1650 <float_stencil9+0x4c0>
cmpb   $0x0,0x48(%rsp)
jne    1650 <float_stencil9+0x4c0>
test   %rcx,%rcx
jne    1650 <float_stencil9+0x4c0>
cmpb   $0x0,0x20(%rsp)
jne    1650 <float_stencil9+0x4c0>
test   %rcx,%rcx
jne    1650 <float_stencil9+0x4c0>
mov    $0xfffffffe,%eax
sub    %ebp,%eax
cmp    0x68(%rsp),%eax
jb     1650 <float_stencil9+0x4c0>
test   %rcx,%rcx
jne    1650 <float_stencil9+0x4c0>
cmpb   $0x0,0x18(%rsp)
jne    1650 <float_stencil9+0x4c0>
test   %rcx,%rcx
jne    1650 <float_stencil9+0x4c0>
cmpb   $0x0,0x40(%rsp)
jne    1650 <float_stencil9+0x4c0>
test   %rcx,%rcx
jne    1650 <float_stencil9+0x4c0>
mov    $0xfffffffd,%eax
sub    %ebp,%eax
cmp    0x68(%rsp),%eax
jb     1650 <float_stencil9+0x4c0>
test   %rcx,%rcx
jne    1650 <float_stencil9+0x4c0>
cmpb   $0x0,0x88(%rsp)
jne    1650 <float_stencil9+0x4c0>
test   %rcx,%rcx
jne    1650 <float_stencil9+0x4c0>
test   %dl,%dl
jne    1650 <float_stencil9+0x4c0>
test   %rcx,%rcx
jne    1650 <float_stencil9+0x4c0>
mov    0x80(%rsp),%rax
add    %ebp,%eax
mov    %rax,0x18(%rsp)
lea    0x2(%rbp),%eax
mov    %rax,0x20(%rsp)
lea    0x1(%rbp),%eax
mov    %rax,0x48(%rsp)
lea    (%r14,%rdi,4),%rdx
mov    %rdx,0x88(%rsp)
mov    0x100(%rsp),%rax
lea    (%rax,%rdi,4),%rcx
mov    %rcx,0x110(%rsp)
mov    0x58(%rsp),%rdi
lea    (%rbx,%rdi,4),%rax
mov    %rax,0x50(%rsp)
mov    0x108(%rsp),%rax
lea    (%rax,%rdi,4),%rdi
cmp    %rdi,%rdx
setb   0x58(%rsp)
cmp    %rcx,0x50(%rsp)
mov    0x18(%rsp),%rdi
lea    (%rbx,%rdi,4),%rcx
mov    %rcx,0x40(%rsp)
lea    (%rax,%rdi,4),%rdi
setb   0x50(%rsp)
cmp    %rdi,%rdx
setb   0xf(%rsp)
mov    0x110(%rsp),%rcx
cmp    %rcx,0x40(%rsp)
mov    0x20(%rsp),%rdi
lea    (%rbx,%rdi,4),%rdx
mov    %rdx,0x18(%rsp)
lea    (%rax,%rdi,4),%rdi
setb   0x40(%rsp)
mov    0x88(%rsp),%rdx
cmp    %rdi,%rdx
setb   0xe(%rsp)
cmp    %rcx,0x18(%rsp)
lea    (%rbx,%rbp,4),%rdi
mov    %rdi,0x20(%rsp)
lea    (%rax,%rbp,4),%rdi
setb   0x18(%rsp)
cmp    %rdi,%rdx
setb   0xd(%rsp)
cmp    %rcx,0x20(%rsp)
mov    0x60(%rsp),%rdi
lea    (%rbx,%rdi,4),%rbp
lea    (%rax,%rdi,4),%rdi
setb   0x60(%rsp)
cmp    %rdi,%rdx
setb   0x20(%rsp)
cmp    %rcx,%rbp
mov    0x48(%rsp),%rdi
lea    (%rbx,%rdi,4),%rbp
lea    (%rax,%rdi,4),%rdi
setb   0x48(%rsp)
cmp    %rdi,%rdx
setb   0xc(%rsp)
cmp    %rcx,%rbp
mov    0x78(%rsp),%rdi
lea    (%rbx,%rdi,4),%rbp
lea    (%rax,%rdi,4),%rdi
setb   0x78(%rsp)
cmp    %rdi,%rdx
setb   0xb(%rsp)
cmp    %rcx,%rbp
mov    0x130(%rsp),%rdi
lea    (%rax,%rdi,4),%rax
setb   %bpl
cmp    %rax,%rdx
lea    (%rbx,%rdi,4),%rax
setb   %dl
cmp    %rcx,%rax
setb   %cl
mov    0x50(%rsp),%al
test   %al,0x58(%rsp)
jne    1650 <float_stencil9+0x4c0>
mov    0x40(%rsp),%al
and    %al,0xf(%rsp)
jne    1650 <float_stencil9+0x4c0>
mov    0x18(%rsp),%al
and    %al,0xe(%rsp)
jne    1650 <float_stencil9+0x4c0>
mov    0x60(%rsp),%al
and    %al,0xd(%rsp)
jne    1650 <float_stencil9+0x4c0>
mov    0x48(%rsp),%al
and    %al,0x20(%rsp)
jne    1650 <float_stencil9+0x4c0>
mov    0x78(%rsp),%al
and    %al,0xc(%rsp)
jne    1650 <float_stencil9+0x4c0>
and    %bpl,0xb(%rsp)
jne    1650 <float_stencil9+0x4c0>
and    %cl,%dl
jne    1650 <float_stencil9+0x4c0>
xor    %ecx,%ecx
mov    0xe8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r8,%rcx,1),%rsi
mov    %esi,%eax
movups (%rbx,%rax,4),%xmm2
lea    0x2(%rsi),%eax
movups (%rbx,%rax,4),%xmm3
addps  %xmm2,%xmm3
lea    (%r11,%rcx,1),%rax
lea    0x1(%rax),%edi
movups (%rbx,%rdi,4),%xmm2
addps  %xmm3,%xmm2
lea    (%r15,%rcx,1),%rdi
lea    0x1(%rdi),%edx
movups (%rbx,%rdx,4),%xmm3
addps  %xmm2,%xmm3
mov    %eax,%edx
movups (%rbx,%rdx,4),%xmm2
addps  %xmm3,%xmm2
add    $0x2,%eax
movups (%rbx,%rax,4),%xmm3
addps  %xmm2,%xmm3
mov    %edi,%eax
movups (%rbx,%rax,4),%xmm2
addps  %xmm3,%xmm2
add    $0x2,%edi
movups (%rbx,%rdi,4),%xmm3
addps  %xmm2,%xmm3
mulps  %xmm1,%xmm3
add    $0x1,%esi
movups %xmm3,(%r14,%rsi,4)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1a30 <float_stencil9+0x8a0>
mov    0xd8(%rsp),%rsi
cmp    %rbp,0x38(%rsp)
jne    1650 <float_stencil9+0x4c0>
jmp    16b7 <float_stencil9+0x527>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%r13
test   %r13b,%r13b
mov    0x70(%rsp),%r11
mov    0xc0(%rsp),%r15
je     15e0 <float_stencil9+0x450>
mov    $0x1,%edx
xor    %r9d,%r9d
mov    %rbp,%rdi
mov    0x9c(%rsp),%r8d
jmp    1b06 <float_stencil9+0x976>
add    $0x1,%edx
add    $0x1,%r9d
add    %r11d,%r8d
add    %rbp,%rdi
cmp    %r12d,%edx
je     15e0 <float_stencil9+0x450>
mov    $0x1,%ecx
cmpq   $0x8,0x38(%rsp)
jb     1bf0 <float_stencil9+0xa60>
cmpq   $0x0,0xa0(%rsp)
setne  %r10b
mov    %r9d,%esi
imul   %r11d,%esi
add    0xa8(%rsp),%esi
add    0x68(%rsp),%esi
setb   %al
or     %r10b,%al
or     0xa(%rsp),%al
jne    1bf0 <float_stencil9+0xa60>
cmpq   $0x8,0xf8(%rsp)
jae    1b55 <float_stencil9+0x9c5>
xor    %ecx,%ecx
jmp    1b9a <float_stencil9+0xa0a>
mov    %r15,%rax
mov    %r8d,%ebp
xor    %ecx,%ecx
nopl   (%rax)
lea    -0x8(%rbp),%esi
movups (%r14,%rsi,4),%xmm2
movups 0x10(%r14,%rsi,4),%xmm3
movups %xmm2,(%rbx,%rsi,4)
movups %xmm3,0x10(%rbx,%rsi,4)
mov    %ebp,%esi
movups (%r14,%rsi,4),%xmm2
movups 0x10(%r14,%rsi,4),%xmm3
movups %xmm2,(%rbx,%rsi,4)
movups %xmm3,0x10(%rbx,%rsi,4)
add    $0x10,%rcx
add    $0x10,%ebp
add    $0xfffffffffffffffe,%rax
jne    1b60 <float_stencil9+0x9d0>
testb  $0x1,0xf0(%rsp)
01
mov    0x30(%rsp),%rbp
je     1bc8 <float_stencil9+0xa38>
mov    %edx,%eax
imul   %r11d,%eax
or     $0x1,%ecx
add    %eax,%ecx
movups (%r14,%rcx,4),%xmm2
movups 0x10(%r14,%rcx,4),%xmm3
movups %xmm2,(%rbx,%rcx,4)
movups %xmm3,0x10(%rbx,%rcx,4)
mov    0xd0(%rsp),%rcx
mov    0xe0(%rsp),%rax
cmp    %rax,0x38(%rsp)
je     1af0 <float_stencil9+0x960>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12d,%eax
sub    %ecx,%eax
mov    %rcx,%rbp
not    %rbp
add    %r12,%rbp
and    $0x3,%rax
je     1c28 <float_stencil9+0xa98>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdi,%rcx,1),%esi
movss  (%r14,%rsi,4),%xmm2
movss  %xmm2,(%rbx,%rsi,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1c10 <float_stencil9+0xa80>
cmp    $0x3,%rbp
mov    0x30(%rsp),%rbp
jb     1af0 <float_stencil9+0x960>
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%rax
mov    %eax,%esi
movss  (%r14,%rsi,4),%xmm2
movss  %xmm2,(%rbx,%rsi,4)
lea    0x1(%rax),%esi
movss  (%r14,%rsi,4),%xmm2
movss  %xmm2,(%rbx,%rsi,4)
lea    0x2(%rax),%esi
movss  (%r14,%rsi,4),%xmm2
movss  %xmm2,(%rbx,%rsi,4)
add    $0x3,%eax
movss  (%r14,%rax,4),%xmm2
movss  %xmm2,(%rbx,%rax,4)
add    $0x4,%rcx
cmp    %rcx,%r12
jne    1c40 <float_stencil9+0xab0>
jmp    1af0 <float_stencil9+0x960>
mov    0x2350(%rip),%rax
mov    (%rax),%edi
lea    0x90(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    0x98(%rsp),%edi
mov    0x90(%rsp),%esi
lea    0x39c(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    %rbx,%rdi
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
add    $0x138,%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 - 9 point\00"
define void @float_stencil9(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 = %271, %106
%110 = load i32, i32* %5
%111 = icmp slt i32 %110, 100
br i1 %111, label %112, label %274
112: ; preds = %109
store i32 1, i32* %3
br label %113
113: ; preds = %230, %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 %233
118: ; preds = %113
store i32 1, i32* %4
br label %119
119: ; preds = %226, %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 %229
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** %8
%169 = load i32, i32* %3
%170 = sub nsw i32 %169, 1
%171 = load i32, i32* %2
%172 = mul i32 %170, %171
%173 = load i32, i32* %4
%174 = sub nsw i32 %173, 1
%175 = add i32 %172, %174
%176 = zext i32 %175 to i64
%177 = getelementptr inbounds float, float* %168, i64 %176
%178 = load float, float* %177
%179 = fadd float %167, %178
%180 = load float*, float** %8
%181 = load i32, i32* %3
%182 = sub nsw i32 %181, 1
%183 = load i32, i32* %2
%184 = mul i32 %182, %183
%185 = load i32, i32* %4
%186 = add nsw i32 %185, 1
%187 = add i32 %184, %186
%188 = zext i32 %187 to i64
%189 = getelementptr inbounds float, float* %180, i64 %188
%190 = load float, float* %189
%191 = fadd float %179, %190
%192 = load float*, float** %8
%193 = load i32, i32* %3
%194 = add nsw i32 %193, 1
%195 = load i32, i32* %2
%196 = mul i32 %194, %195
%197 = load i32, i32* %4
%198 = sub nsw i32 %197, 1
%199 = add i32 %196, %198
%200 = zext i32 %199 to i64
%201 = getelementptr inbounds float, float* %192, i64 %200
%202 = load float, float* %201
%203 = fadd float %191, %202
%204 = load float*, float** %8
%205 = load i32, i32* %3
%206 = add nsw i32 %205, 1
%207 = load i32, i32* %2
%208 = mul i32 %206, %207
%209 = load i32, i32* %4
%210 = add nsw i32 %209, 1
%211 = add i32 %208, %210
%212 = zext i32 %211 to i64
%213 = getelementptr inbounds float, float* %204, i64 %212
%214 = load float, float* %213
%215 = fadd float %203, %214
%216 = load float, float* %7
%217 = fmul float %215, %216
%218 = load float*, float** %9
%219 = load i32, i32* %3
%220 = load i32, i32* %2
%221 = mul i32 %219, %220
%222 = load i32, i32* %4
%223 = add i32 %221, %222
%224 = zext i32 %223 to i64
%225 = getelementptr inbounds float, float* %218, i64 %224
store float %217, float* %225
br label %226
226: ; preds = %124
%227 = load i32, i32* %4
%228 = add nsw i32 %227, 1
store i32 %228, i32* %4
br label %119
229: ; preds = %119
br label %230
230: ; preds = %229
%231 = load i32, i32* %3
%232 = add nsw i32 %231, 1
store i32 %232, i32* %3
br label %113
233: ; preds = %113
store i32 1, i32* %3
br label %234
234: ; preds = %267, %233
%235 = load i32, i32* %3
%236 = load i32, i32* %6
%237 = add nsw i32 %236, 1
%238 = icmp slt i32 %235, %237
br i1 %238, label %239, label %270
239: ; preds = %234
store i32 1, i32* %4
br label %240
240: ; preds = %263, %239
%241 = load i32, i32* %4
%242 = load i32, i32* %6
%243 = add nsw i32 %242, 1
%244 = icmp slt i32 %241, %243
br i1 %244, label %245, label %266
245: ; preds = %240
%246 = load float*, float** %9
%247 = load i32, i32* %3
%248 = load i32, i32* %2
%249 = mul i32 %247, %248
%250 = load i32, i32* %4
%251 = add i32 %249, %250
%252 = zext i32 %251 to i64
%253 = getelementptr inbounds float, float* %246, i64 %252
%254 = load float, float* %253
%255 = load float*, float** %8
%256 = load i32, i32* %3
%257 = load i32, i32* %2
%258 = mul i32 %256, %257
%259 = load i32, i32* %4
%260 = add i32 %258, %259
%261 = zext i32 %260 to i64
%262 = getelementptr inbounds float, float* %255, i64 %261
store float %254, float* %262
br label %263
263: ; preds = %245
%264 = load i32, i32* %4
%265 = add nsw i32 %264, 1
store i32 %265, i32* %4
br label %240
266: ; preds = %240
br label %267
267: ; preds = %266
%268 = load i32, i32* %3
%269 = add nsw i32 %268, 1
store i32 %269, i32* %3
br label %234
270: ; preds = %234
br label %271
271: ; preds = %270
%272 = load i32, i32* %5
%273 = add nsw i32 %272, 1
store i32 %273, i32* %5
br label %109
274: ; preds = %109
%275 = load i32, i32* @CLOCK_MONOTONIC_RAW
%276 = call i32 @clock_gettime(i32 %275, %struct.timespec* %11)
%277 = getelementptr inbounds %struct.timespec, %struct.timespec* %10, i32 0, i32 0
%278 = load i32, i32* %277
%279 = getelementptr inbounds %struct.timespec, %struct.timespec* %11, i32 0, i32 0
%280 = load i32, i32* %279
%281 = call i32 @elapsed_time_hr(i32 %278, i32 %280, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.2, i64 0, i64 0))
%282 = load float*, float** %8
%283 = call i32 @free(float* %282)
%284 = load float*, float** %9
%285 = call i32 @free(float* %284)
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 - 9 point\00"
@str = [66 x i8] c"9-point Single Precision Stencil Error: Unable to allocate memory\00"
define void @float_stencil9(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 %189, 2
%192 = add i32 %0, 1
%193 = add nsw i64 %179, -1
%194 = getelementptr float, float* %9, i64 %193
%195 = getelementptr float, float* %7, i64 %193
%196 = getelementptr float, float* %7, i64 %193
%197 = getelementptr float, float* %7, i64 %193
%198 = getelementptr float, float* %7, i64 %193
%199 = or i32 %189, 1
%200 = getelementptr float, float* %7, i64 %193
%201 = getelementptr float, float* %7, i64 %193
%202 = add i32 %0, 2
%203 = getelementptr float, float* %7, i64 %193
%204 = getelementptr float, float* %7, i64 %193
%205 = add nsw i64 %179, -1
%206 = add nsw i64 %179, -9
%207 = lshr i64 %206, 3
%208 = add nuw nsw i64 %207, 1
%209 = icmp ult i64 %205, 4
%210 = trunc i64 %187 to i32
%211 = icmp ugt i64 %187, 4294967295
%212 = trunc i64 %187 to i32
%213 = icmp ugt i64 %187, 4294967295
%214 = trunc i64 %187 to i32
%215 = icmp ugt i64 %187, 4294967295
%216 = trunc i64 %187 to i32
%217 = icmp ugt i64 %187, 4294967295
%218 = trunc i64 %187 to i32
%219 = icmp ugt i64 %187, 4294967295
%220 = trunc i64 %187 to i32
%221 = icmp ugt i64 %187, 4294967295
%222 = trunc i64 %187 to i32
%223 = icmp ugt i64 %187, 4294967295
%224 = trunc i64 %187 to i32
%225 = icmp ugt i64 %187, 4294967295
%226 = trunc i64 %187 to i32
%227 = icmp ugt i64 %187, 4294967295
%228 = and i64 %205, -4
%229 = or i64 %228, 1
%230 = icmp eq i64 %205, %228
%231 = icmp ult i64 %186, 8
%232 = trunc i64 %181 to i32
%233 = icmp ugt i64 %181, 4294967295
%234 = icmp ugt float* %185, %7
%235 = icmp ugt float* %184, %9
%236 = and i1 %234, %235
%237 = and i64 %186, -8
%238 = or i64 %237, 1
%239 = and i64 %208, 1
%240 = icmp ult i64 %206, 8
%241 = and i64 %208, 4611686018427387902
%242 = icmp eq i64 %239, 0
%243 = icmp eq i64 %186, %237
br label %244
244: ; preds = %174, %605
%245 = phi i32 [ 0, %174 ], [ %606, %605 ]
br i1 %175, label %247, label %605
246: ; preds = %481
br i1 %175, label %484, label %605
247: ; preds = %244, %481
%248 = phi i32 [ %483, %481 ], [ 0, %244 ]
%249 = phi i32 [ %290, %481 ], [ 1, %244 ]
%250 = mul i32 %248, %0
%251 = add i32 %192, %250
%252 = zext i32 %251 to i64
%253 = getelementptr float, float* %9, i64 %252
%254 = getelementptr float, float* %194, i64 %252
%255 = add i32 %191, %250
%256 = zext i32 %255 to i64
%257 = getelementptr float, float* %7, i64 %256
%258 = getelementptr float, float* %195, i64 %256
%259 = add i32 %189, %250
%260 = zext i32 %259 to i64
%261 = getelementptr float, float* %7, i64 %260
%262 = getelementptr float, float* %196, i64 %260
%263 = add i32 %250, 2
%264 = zext i32 %263 to i64
%265 = getelementptr float, float* %7, i64 %264
%266 = getelementptr float, float* %197, i64 %264
%267 = zext i32 %250 to i64
%268 = getelementptr float, float* %7, i64 %267
%269 = getelementptr float, float* %198, i64 %267
%270 = add i32 %199, %250
%271 = zext i32 %270 to i64
%272 = getelementptr float, float* %7, i64 %271
%273 = getelementptr float, float* %200, i64 %271
%274 = add i32 %250, 1
%275 = zext i32 %274 to i64
%276 = getelementptr float, float* %7, i64 %275
%277 = getelementptr float, float* %201, i64 %275
%278 = add i32 %202, %250
%279 = zext i32 %278 to i64
%280 = getelementptr float, float* %7, i64 %279
%281 = getelementptr float, float* %203, i64 %279
%282 = add i32 %250, %0
%283 = zext i32 %282 to i64
%284 = getelementptr float, float* %7, i64 %283
%285 = getelementptr float, float* %204, i64 %283
%286 = mul i32 %248, %0
%287 = mul i32 %249, %0
%288 = add nsw i32 %249, -1
%289 = mul i32 %288, %0
%290 = add nuw nsw i32 %249, 1
%291 = mul i32 %290, %0
br i1 %209, label %428, label %292
292: ; preds = %247
%293 = add i32 %191, %286
%294 = add i32 %189, %286
%295 = add i32 %190, %286
%296 = add i32 %188, %286
%297 = add i32 %286, %0
%298 = add i32 %182, %286
%299 = xor i32 %298, -1
%300 = icmp ult i32 %299, %210
%301 = or i1 %300, %211
%302 = xor i32 %297, -1
%303 = icmp ult i32 %302, %212
%304 = or i1 %303, %213
%305 = xor i32 %296, -1
%306 = icmp ult i32 %305, %214
%307 = or i1 %306, %215
%308 = sub i32 -2, %286
%309 = icmp ult i32 %308, %216
%310 = or i1 %309, %217
%311 = xor i32 %295, -1
%312 = icmp ult i32 %311, %218
%313 = or i1 %312, %219
%314 = xor i32 %286, -1
%315 = icmp ult i32 %314, %220
%316 = or i1 %315, %221
%317 = sub i32 -3, %286
%318 = icmp ult i32 %317, %222
%319 = or i1 %318, %223
%320 = xor i32 %294, -1
%321 = icmp ult i32 %320, %224
%322 = or i1 %321, %225
%323 = xor i32 %293, -1
%324 = icmp ult i32 %323, %226
%325 = or i1 %324, %227
%326 = or i1 %301, %304
%327 = or i1 %326, %307
%328 = or i1 %327, %310
%329 = or i1 %328, %313
%330 = or i1 %329, %316
%331 = or i1 %330, %319
%332 = or i1 %331, %322
%333 = or i1 %332, %325
br i1 %333, label %428, label %334
334: ; preds = %292
%335 = icmp ult float* %253, %258
%336 = icmp ult float* %257, %254
%337 = and i1 %335, %336
%338 = icmp ult float* %253, %262
%339 = icmp ult float* %261, %254
%340 = and i1 %338, %339
%341 = or i1 %337, %340
%342 = icmp ult float* %253, %266
%343 = icmp ult float* %265, %254
%344 = and i1 %342, %343
%345 = or i1 %341, %344
%346 = icmp ult float* %253, %269
%347 = icmp ult float* %268, %254
%348 = and i1 %346, %347
%349 = or i1 %345, %348
%350 = icmp ult float* %253, %273
%351 = icmp ult float* %272, %254
%352 = and i1 %350, %351
%353 = or i1 %349, %352
%354 = icmp ult float* %253, %277
%355 = icmp ult float* %276, %254
%356 = and i1 %354, %355
%357 = or i1 %353, %356
%358 = icmp ult float* %253, %281
%359 = icmp ult float* %280, %254
%360 = and i1 %358, %359
%361 = or i1 %357, %360
%362 = icmp ult float* %253, %285
%363 = icmp ult float* %284, %254
%364 = and i1 %362, %363
%365 = or i1 %361, %364
br i1 %365, label %428, label %366
366: ; preds = %334, %366
%367 = phi i64 [ %425, %366 ], [ 0, %334 ]
%368 = trunc i64 %367 to i32
%369 = trunc i64 %367 to i32
%370 = or i32 %369, 1
%371 = add i32 %287, %368
%372 = zext i32 %371 to i64
%373 = getelementptr inbounds float, float* %7, i64 %372
%374 = bitcast float* %373 to <4 x float>*
%375 = load <4 x float>, <4 x float>* %374
%376 = trunc i64 %367 to i32
%377 = or i32 %376, 2
%378 = add i32 %287, %377
%379 = zext i32 %378 to i64
%380 = getelementptr inbounds float, float* %7, i64 %379
%381 = bitcast float* %380 to <4 x float>*
%382 = load <4 x float>, <4 x float>* %381
%383 = fadd <4 x float> %375, %382
%384 = add i32 %289, %370
%385 = zext i32 %384 to i64
%386 = getelementptr inbounds float, float* %7, i64 %385
%387 = bitcast float* %386 to <4 x float>*
%388 = load <4 x float>, <4 x float>* %387
%389 = fadd <4 x float> %383, %388
%390 = add i32 %291, %370
%391 = zext i32 %390 to i64
%392 = getelementptr inbounds float, float* %7, i64 %391
%393 = bitcast float* %392 to <4 x float>*
%394 = load <4 x float>, <4 x float>* %393
%395 = fadd <4 x float> %389, %394
%396 = add i32 %289, %368
%397 = zext i32 %396 to i64
%398 = getelementptr inbounds float, float* %7, i64 %397
%399 = bitcast float* %398 to <4 x float>*
%400 = load <4 x float>, <4 x float>* %399
%401 = fadd <4 x float> %395, %400
%402 = add i32 %289, %377
%403 = zext i32 %402 to i64
%404 = getelementptr inbounds float, float* %7, i64 %403
%405 = bitcast float* %404 to <4 x float>*
%406 = load <4 x float>, <4 x float>* %405
%407 = fadd <4 x float> %401, %406
%408 = add i32 %291, %368
%409 = zext i32 %408 to i64
%410 = getelementptr inbounds float, float* %7, i64 %409
%411 = bitcast float* %410 to <4 x float>*
%412 = load <4 x float>, <4 x float>* %411
%413 = fadd <4 x float> %407, %412
%414 = add i32 %291, %377
%415 = zext i32 %414 to i64
%416 = getelementptr inbounds float, float* %7, i64 %415
%417 = bitcast float* %416 to <4 x float>*
%418 = load <4 x float>, <4 x float>* %417
%419 = fadd <4 x float> %413, %418
%420 = fmul <4 x float> %419, <float 1.250000e-01, float 1.250000e-01, float 1.250000e-01, float 1.250000e-01>
%421 = add i32 %287, %370
%422 = zext i32 %421 to i64
%423 = getelementptr inbounds float, float* %9, i64 %422
%424 = bitcast float* %423 to <4 x float>*
store <4 x float> %420, <4 x float>* %424
%425 = add nuw i64 %367, 4
%426 = icmp eq i64 %425, %228
br i1 %426, label %427, label %366
427: ; preds = %366
br i1 %230, label %481, label %428
428: ; preds = %334, %292, %247, %427
%429 = phi i64 [ 1, %334 ], [ 1, %292 ], [ 1, %247 ], [ %229, %427 ]
br label %430
430: ; preds = %428, %430
%431 = phi i64 [ %438, %430 ], [ %429, %428 ]
%432 = trunc i64 %431 to i32
%433 = add i32 %432, -1
%434 = add i32 %433, %287
%435 = zext i32 %434 to i64
%436 = getelementptr inbounds float, float* %7, i64 %435
%437 = load float, float* %436
%438 = add nuw nsw i64 %431, 1
%439 = trunc i64 %438 to i32
%440 = add i32 %287, %439
%441 = zext i32 %440 to i64
%442 = getelementptr inbounds float, float* %7, i64 %441
%443 = load float, float* %442
%444 = fadd float %437, %443
%445 = trunc i64 %431 to i32
%446 = add i32 %289, %445
%447 = zext i32 %446 to i64
%448 = getelementptr inbounds float, float* %7, i64 %447
%449 = load float, float* %448
%450 = fadd float %444, %449
%451 = add i32 %291, %445
%452 = zext i32 %451 to i64
%453 = getelementptr inbounds float, float* %7, i64 %452
%454 = load float, float* %453
%455 = fadd float %450, %454
%456 = add i32 %433, %289
%457 = zext i32 %456 to i64
%458 = getelementptr inbounds float, float* %7, i64 %457
%459 = load float, float* %458
%460 = fadd float %455, %459
%461 = add i32 %289, %439
%462 = zext i32 %461 to i64
%463 = getelementptr inbounds float, float* %7, i64 %462
%464 = load float, float* %463
%465 = fadd float %460, %464
%466 = add i32 %433, %291
%467 = zext i32 %466 to i64
%468 = getelementptr inbounds float, float* %7, i64 %467
%469 = load float, float* %468
%470 = fadd float %465, %469
%471 = add i32 %291, %439
%472 = zext i32 %471 to i64
%473 = getelementptr inbounds float, float* %7, i64 %472
%474 = load float, float* %473
%475 = fadd float %470, %474
%476 = fmul float %475, 1.250000e-01
%477 = add i32 %287, %445
%478 = zext i32 %477 to i64
%479 = getelementptr inbounds float, float* %9, i64 %478
store float %476, float* %479
%480 = icmp eq i64 %438, %179
br i1 %480, label %481, label %430
481: ; preds = %430, %427
%482 = icmp eq i32 %290, %176
%483 = add i32 %248, 1
br i1 %482, label %246, label %247
484: ; preds = %246, %601
%485 = phi i32 [ %604, %601 ], [ 0, %246 ]
%486 = phi i32 [ %602, %601 ], [ 1, %246 ]
%487 = mul i32 %486, %0
br i1 %231, label %548, label %488
488: ; preds = %484
%489 = mul i32 %485, %0
%490 = add i32 %182, %489
%491 = xor i32 %490, -1
%492 = icmp ult i32 %491, %232
%493 = or i1 %492, %233
%494 = select i1 %493, i1 true, i1 %236
br i1 %494, label %548, label %495
495: ; preds = %488
br i1 %240, label %530, label %496
496: ; preds = %495, %496
%497 = phi i64 [ %527, %496 ], [ 0, %495 ]
%498 = phi i64 [ %528, %496 ], [ 0, %495 ]
%499 = trunc i64 %497 to i32
%500 = or i32 %499, 1
%501 = add i32 %487, %500
%502 = zext i32 %501 to i64
%503 = getelementptr inbounds float, float* %9, i64 %502
%504 = bitcast float* %503 to <4 x float>*
%505 = load <4 x float>, <4 x float>* %504
%506 = getelementptr inbounds float, float* %503, i64 4
%507 = bitcast float* %506 to <4 x float>*
%508 = load <4 x float>, <4 x float>* %507
%509 = getelementptr inbounds float, float* %7, i64 %502
%510 = bitcast float* %509 to <4 x float>*
store <4 x float> %505, <4 x float>* %510
%511 = getelementptr inbounds float, float* %509, i64 4
%512 = bitcast float* %511 to <4 x float>*
store <4 x float> %508, <4 x float>* %512
%513 = trunc i64 %497 to i32
%514 = or i32 %513, 9
%515 = add i32 %487, %514
%516 = zext i32 %515 to i64
%517 = getelementptr inbounds float, float* %9, i64 %516
%518 = bitcast float* %517 to <4 x float>*
%519 = load <4 x float>, <4 x float>* %518
%520 = getelementptr inbounds float, float* %517, i64 4
%521 = bitcast float* %520 to <4 x float>*
%522 = load <4 x float>, <4 x float>* %521
%523 = getelementptr inbounds float, float* %7, i64 %516
%524 = bitcast float* %523 to <4 x float>*
store <4 x float> %519, <4 x float>* %524
%525 = getelementptr inbounds float, float* %523, i64 4
%526 = bitcast float* %525 to <4 x float>*
store <4 x float> %522, <4 x float>* %526
%527 = add nuw i64 %497, 16
%528 = add i64 %498, 2
%529 = icmp eq i64 %528, %241
br i1 %529, label %530, label %496
530: ; preds = %496, %495
%531 = phi i64 [ 0, %495 ], [ %527, %496 ]
br i1 %242, label %547, label %532
532: ; preds = %530
%533 = trunc i64 %531 to i32
%534 = or i32 %533, 1
%535 = add i32 %487, %534
%536 = zext i32 %535 to i64
%537 = getelementptr inbounds float, float* %9, i64 %536
%538 = bitcast float* %537 to <4 x float>*
%539 = load <4 x float>, <4 x float>* %538
%540 = getelementptr inbounds float, float* %537, i64 4
%541 = bitcast float* %540 to <4 x float>*
%542 = load <4 x float>, <4 x float>* %541
%543 = getelementptr inbounds float, float* %7, i64 %536
%544 = bitcast float* %543 to <4 x float>*
store <4 x float> %539, <4 x float>* %544
%545 = getelementptr inbounds float, float* %543, i64 4
%546 = bitcast float* %545 to <4 x float>*
store <4 x float> %542, <4 x float>* %546
br label %547
547: ; preds = %530, %532
br i1 %243, label %601, label %548
548: ; preds = %488, %484, %547
%549 = phi i64 [ 1, %488 ], [ 1, %484 ], [ %238, %547 ]
%550 = sub nsw i64 %179, %549
%551 = xor i64 %549, -1
%552 = add nsw i64 %551, %179
%553 = and i64 %550, 3
%554 = icmp eq i64 %553, 0
br i1 %554, label %567, label %555
555: ; preds = %548, %555
%556 = phi i64 [ %564, %555 ], [ %549, %548 ]
%557 = phi i64 [ %565, %555 ], [ 0, %548 ]
%558 = trunc i64 %556 to i32
%559 = add i32 %487, %558
%560 = zext i32 %559 to i64
%561 = getelementptr inbounds float, float* %9, i64 %560
%562 = load float, float* %561
%563 = getelementptr inbounds float, float* %7, i64 %560
store float %562, float* %563
%564 = add nuw nsw i64 %556, 1
%565 = add i64 %557, 1
%566 = icmp eq i64 %565, %553
br i1 %566, label %567, label %555
567: ; preds = %555, %548
%568 = phi i64 [ %549, %548 ], [ %564, %555 ]
%569 = icmp ult i64 %552, 3
br i1 %569, label %601, label %570
570: ; preds = %567, %570
%571 = phi i64 [ %599, %570 ], [ %568, %567 ]
%572 = trunc i64 %571 to i32
%573 = add i32 %487, %572
%574 = zext i32 %573 to i64
%575 = getelementptr inbounds float, float* %9, i64 %574
%576 = load float, float* %575
%577 = getelementptr inbounds float, float* %7, i64 %574
store float %576, float* %577
%578 = trunc i64 %571 to i32
%579 = add i32 %578, 1
%580 = add i32 %487, %579
%581 = zext i32 %580 to i64
%582 = getelementptr inbounds float, float* %9, i64 %581
%583 = load float, float* %582
%584 = getelementptr inbounds float, float* %7, i64 %581
store float %583, float* %584
%585 = trunc i64 %571 to i32
%586 = add i32 %585, 2
%587 = add i32 %487, %586
%588 = zext i32 %587 to i64
%589 = getelementptr inbounds float, float* %9, i64 %588
%590 = load float, float* %589
%591 = getelementptr inbounds float, float* %7, i64 %588
store float %590, float* %591
%592 = trunc i64 %571 to i32
%593 = add i32 %592, 3
%594 = add i32 %487, %593
%595 = zext i32 %594 to i64
%596 = getelementptr inbounds float, float* %9, i64 %595
%597 = load float, float* %596
%598 = getelementptr inbounds float, float* %7, i64 %595
store float %597, float* %598
%599 = add nuw nsw i64 %571, 4
%600 = icmp eq i64 %599, %180
br i1 %600, label %601, label %570
601: ; preds = %567, %570, %547
%602 = add nuw nsw i32 %486, 1
%603 = icmp eq i32 %602, %176
%604 = add i32 %485, 1
br i1 %603, label %605, label %484
605: ; preds = %601, %244, %246
%606 = add nuw nsw i32 %245, 1
%607 = icmp eq i32 %606, 100
br i1 %607, label %608, label %244
608: ; preds = %605
%609 = load i32, i32* @CLOCK_MONOTONIC_RAW
%610 = call i32 @clock_gettime(i32 %609, %struct.timespec* %3)
%611 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 0, i32 0
%612 = load i32, i32* %611
%613 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 0
%614 = load i32, i32* %613
%615 = call i32 @elapsed_time_hr(i32 %612, i32 %614, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.2, i64 0, i64 0))
%616 = call i32 @free(float* %7)
%617 = call i32 @free(float* %9)
ret void
}