#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_stencil19(unsigned int size) {
  int i, j, k, iter;
  int n = size - 2;
  float fac = 1.0 / 18;
  float *a0 = (float *)malloc(sizeof(float) * size * size * size);
  float *a1 = (float *)malloc(sizeof(float) * size * size * size);
  if (a0 == NULL || a1 == NULL) {
    printf(
        "19-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, k)
  for (i = 0; i < size; i++) {
    for (j = 0; j < size; j++) {
      for (k = 0; k < size; k++) {
        a0[i * size * size + j * size + k] = 0.0;
      }
    }
  }
#pragma omp parallel for private(j, k)
  for (i = 1; i < n + 1; i++) {
    for (j = 1; j < n + 1; j++) {
      for (k = 1; k < n + 1; k++) {
        a0[i * size * size + j * size + k] =
            (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, k)
      for (i = 1; i < n + 1; i++) {
        for (j = 1; j < n + 1; j++) {
          for (k = 1; k < n + 1; k++) {
            a1[i * size * size + j * size + k] =
                (a0[i * size * size + (j - 1) * size + k] +
                 a0[i * size * size + (j + 1) * size + k] +
                 a0[(i - 1) * size * size + j * size + k] +
                 a0[(i + 1) * size * size + j * size + k] +
                 a0[(i - 1) * size * size + (j - 1) * size + k] +
                 a0[(i - 1) * size * size + (j + 1) * size + k] +
                 a0[(i + 1) * size * size + (j - 1) * size + k] +
                 a0[(i + 1) * size * size + (j + 1) * size + k] +
                 a0[i * size * size + (j - 1) * size + (k - 1)] +
                 a0[i * size * size + (j + 1) * size + (k - 1)] +
                 a0[(i - 1) * size * size + j * size + (k - 1)] +
                 a0[(i + 1) * size * size + j * size + (k - 1)] +
                 a0[i * size * size + (j - 1) * size + (k + 1)] +
                 a0[i * size * size + (j + 1) * size + (k + 1)] +
                 a0[(i - 1) * size * size + j * size + (k + 1)] +
                 a0[(i + 1) * size * size + j * size + (k + 1)] +
                 a0[i * size * size + j * size + (k - 1)] +
                 a0[i * size * size + j * size + (k + 1)]) *
                fac;
          }
        }
      }
#pragma omp for private(j, k)
      for (i = 1; i < n + 1; i++) {
        for (j = 1; j < n + 1; j++) {
          for (k = 1; k < n + 1; k++) {
            a0[i * size * size + j * size + k] =
                a1[i * size * size + j * size + k];
          }
        }
      }
    }
  }
  clock_gettime(CLOCK_MONOTONIC_RAW, &end);
  elapsed_time_hr(start, end, "Single Precision Stencil - 19 point");
  free(a0);
  free(a1);
}


x86 assembly (clang, -O0):
<float_stencil19>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x18(%rbp)
movss  0xe64(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x2,%rax
mov    -0x4(%rbp),%ecx
imul   %rcx,%rax
mov    -0x4(%rbp),%ecx
imul   %rcx,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x2,%rax
mov    -0x4(%rbp),%ecx
imul   %rcx,%rax
mov    -0x4(%rbp),%ecx
imul   %rcx,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     11f7 <float_stencil19+0x77>
cmpq   $0x0,-0x30(%rbp)
jne    1205 <float_stencil19+0x85>
lea    0xe12(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    $0x0,%al
call   1050 <omp_get_thread_num@plt>
cmp    $0x0,%rax
jne    122d <float_stencil19+0xad>
mov    $0x0,%al
call   1080 <omp_get_num_threads@plt>
mov    %eax,%esi
lea    0xe2e(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12bf <float_stencil19+0x13f>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12ac <float_stencil19+0x12c>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1299 <float_stencil19+0x119>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    125a <float_stencil19+0xda>
jmp    129e <float_stencil19+0x11e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1247 <float_stencil19+0xc7>
jmp    12b1 <float_stencil19+0x131>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1234 <float_stencil19+0xb4>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1389 <float_stencil19+0x209>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1376 <float_stencil19+0x1f6>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1363 <float_stencil19+0x1e3>
mov    $0x0,%al
call   10a0 <rand@plt>
cvtsi2ss %rax,%xmm0
mov    0x2cce(%rip),%rax
cvtsi2sdq (%rax),%xmm2
movsd  0xce1(%rip),%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
divss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12f6 <float_stencil19+0x176>
jmp    1368 <float_stencil19+0x1e8>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12de <float_stencil19+0x15e>
jmp    137b <float_stencil19+0x1fb>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12c6 <float_stencil19+0x146>
mov    0x2c50(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1060 <clock_gettime@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    17f4 <float_stencil19+0x674>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1721 <float_stencil19+0x5a1>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    170e <float_stencil19+0x58e>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    16fb <float_stencil19+0x57b>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13e3 <float_stencil19+0x263>
jmp    1700 <float_stencil19+0x580>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13cb <float_stencil19+0x24b>
jmp    1713 <float_stencil19+0x593>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13b3 <float_stencil19+0x233>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17e1 <float_stencil19+0x661>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17ce <float_stencil19+0x64e>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17bb <float_stencil19+0x63b>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1758 <float_stencil19+0x5d8>
jmp    17c0 <float_stencil19+0x640>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1740 <float_stencil19+0x5c0>
jmp    17d3 <float_stencil19+0x653>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1728 <float_stencil19+0x5a8>
jmp    17e6 <float_stencil19+0x666>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13a2 <float_stencil19+0x222>
mov    0x27e5(%rip),%rax
mov    (%rax),%edi
lea    -0x40(%rbp),%rsi
call   1060 <clock_gettime@plt>
mov    -0x38(%rbp),%edi
mov    -0x40(%rbp),%esi
lea    0x86d(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    -0x28(%rbp),%rdi
call   1040 <free@plt>
mov    -0x30(%rbp),%rdi
call   1040 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<float_stencil19>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %edi,%ebp
mov    %edi,%r13d
imul   %r13d,%r13d
mov    %r13d,%r14d
imul   %edi,%r14d
shl    $0x2,%r14d
mov    %r14d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r15
mov    %r14d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r14
test   %r15,%r15
je     11d5 <float_stencil19+0x45>
test   %r14,%r14
jne    11e1 <float_stencil19+0x51>
lea    0xe80(%rip),%rdi
call   1050 <puts@plt>
xor    %eax,%eax
call   1060 <omp_get_thread_num@plt>
test   %rax,%rax
jne    1204 <float_stencil19+0x74>
xor    %eax,%eax
call   1090 <omp_get_num_threads@plt>
lea    0xe11(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1080 <printf@plt>
movabs $0x3ffffffffffffffc,%rcx
ff ff 3f
xor    %esi,%esi
mov    %ebp,%edi
test   %ebp,%ebp
mov    %rbp,0x38(%rsp)
mov    %r13,0x40(%rsp)
mov    %rdi,0x48(%rsp)
je     14e7 <float_stencil19+0x357>
mov    %r14,0x20(%rsp)
mov    %r13,%rax
lea    -0x1(%rdi),%rbx
mov    %edi,%r13d
and    $0xfffffff8,%r13d
lea    -0x8(%r13),%rdx
mov    %rdx,0x18(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r12d
and    $0x3,%r12d
and    %rcx,%rdx
mov    %rdx,0x10(%rsp)
mov    %edi,%r10d
and    $0x3,%r10d
mov    $0x10,%r9d
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1295 <float_stencil19+0x105>
mov    0x30(%rsp),%rsi
add    $0x1,%esi
mov    0x40(%rsp),%rax
mov    0x8(%rsp),%r9d
add    %eax,%r9d
mov    0x28(%rsp),%rcx
add    %rax,%rcx
cmp    %edx,%esi
je     140c <float_stencil19+0x27c>
mov    %eax,%r14d
mov    %rsi,0x30(%rsp)
imul   %esi,%r14d
xor    %r11d,%r11d
mov    %rcx,0x28(%rsp)
mov    %r9d,0x8(%rsp)
mov    0x38(%rsp),%rdx
jmp    12d4 <float_stencil19+0x144>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r11d
mov    0x38(%rsp),%rdx
add    %edx,%r9d
add    %rdi,%rcx
cmp    %edx,%r11d
je     1270 <float_stencil19+0xe0>
cmp    $0x8,%edx
jae    1350 <float_stencil19+0x1c0>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %rdi,%rax
test   %r10,%r10
je     1305 <float_stencil19+0x175>
mov    %r10,%rdx
nopl   0x0(%rax)
lea    (%rcx,%rbp,1),%esi
movl   $0x0,(%r15,%rsi,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    12f0 <float_stencil19+0x160>
cmp    $0x3,%rax
jb     12c0 <float_stencil19+0x130>
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%rax
mov    %eax,%edx
movl   $0x0,(%r15,%rdx,4)
lea    0x1(%rax),%edx
movl   $0x0,(%r15,%rdx,4)
lea    0x2(%rax),%edx
movl   $0x0,(%r15,%rdx,4)
add    $0x3,%eax
movl   $0x0,(%r15,%rax,4)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    1310 <float_stencil19+0x180>
jmp    12c0 <float_stencil19+0x130>
nopl   (%rax)
mov    %r11d,%eax
imul   %edx,%eax
add    %r14d,%eax
add    %ebx,%eax
jb     12d9 <float_stencil19+0x149>
mov    %rbx,%rax
shr    $0x20,%rax
mov    $0x0,%ebp
jne    12db <float_stencil19+0x14b>
cmpq   $0x18,0x18(%rsp)
jae    137f <float_stencil19+0x1ef>
xor    %ebp,%ebp
jmp    13d5 <float_stencil19+0x245>
mov    0x10(%rsp),%rdx
mov    %r9d,%eax
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    -0x10(%rax),%r8d
movups %xmm0,(%r15,%r8,4)
movups %xmm0,0x10(%r15,%r8,4)
lea    -0x8(%rax),%esi
movups %xmm0,(%r15,%rsi,4)
movups %xmm0,0x10(%r15,%rsi,4)
mov    %eax,%esi
movups %xmm0,(%r15,%rsi,4)
movups %xmm0,0x10(%r15,%rsi,4)
lea    0x8(%rax),%esi
movups %xmm0,(%r15,%rsi,4)
movups %xmm0,0x10(%r15,%rsi,4)
add    $0x20,%rbp
add    $0x20,%eax
add    $0xfffffffffffffffc,%rdx
jne    1390 <float_stencil19+0x200>
test   %r12,%r12
je     13f6 <float_stencil19+0x266>
add    %ecx,%ebp
mov    %r12,%rax
nop
mov    %ebp,%edx
movups %xmm0,(%r15,%rdx,4)
movups %xmm0,0x10(%r15,%rdx,4)
add    $0x8,%ebp
add    $0xffffffffffffffff,%rax
jne    13e0 <float_stencil19+0x250>
mov    %r13,%rbp
mov    0x48(%rsp),%rdi
cmp    %rdi,%r13
je     12c0 <float_stencil19+0x130>
jmp    12db <float_stencil19+0x14b>
mov    0x38(%rsp),%rbp
lea    -0x1(%rbp),%ecx
cmp    $0x2,%ecx
setge  %al
jl     14f5 <float_stencil19+0x365>
mov    %rax,0x30(%rsp)
mov    %ecx,%eax
lea    0x1(%rbp),%ebx
imul   %ebp,%ebx
add    $0x1,%ebx
add    $0xffffffffffffffff,%rax
mov    %rax,0x10(%rsp)
mov    $0x1,%eax
mov    0x2ba3(%rip),%rbp
mov    %ecx,0x18(%rsp)
nopl   0x0(%rax)
mov    %eax,0x28(%rsp)
mov    %ebx,0x8(%rsp)
mov    $0x1,%r12d
xchg   %ax,%ax
mov    0x10(%rsp),%r13
mov    %ebx,%r14d
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10b0 <rand@plt>
movsd  0xb81(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdq 0x0(%rbp),%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
divss  %xmm1,%xmm0
mov    %r14d,%eax
movss  %xmm0,(%r15,%rax,4)
add    $0x1,%r14d
add    $0xffffffffffffffff,%r13
jne    1470 <float_stencil19+0x2e0>
add    $0x1,%r12d
add    0x38(%rsp),%ebx
mov    0x18(%rsp),%ecx
cmp    %ecx,%r12d
jne    1460 <float_stencil19+0x2d0>
mov    0x28(%rsp),%eax
add    $0x1,%eax
mov    0x40(%rsp),%r13
mov    0x8(%rsp),%ebx
add    %r13d,%ebx
cmp    %ecx,%eax
jne    1450 <float_stencil19+0x2c0>
mov    0x20(%rsp),%r14
mov    0x38(%rsp),%rbp
jmp    1506 <float_stencil19+0x376>
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    $0xffffffff,%ebx
jmp    1508 <float_stencil19+0x378>
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    0x20(%rsp),%r14
mov    0x40(%rsp),%r13
mov    %ecx,%ebx
mov    0x2ad1(%rip),%rax
mov    (%rax),%edi
lea    0x58(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    %ebx,%ebx
lea    -0x2(%rbx),%rax
mov    %rax,0x118(%rsp)
lea    0x1(%rbp),%r10d
imul   %ebp,%r10d
lea    -0x1(%rbx),%rdi
lea    (%r15,%rbx,4),%r8
add    $0xfffffffffffffffc,%r8
lea    -0x4(%r14,%rbx,4),%r9
lea    -0x9(%rbx),%rax
mov    %rax,0x110(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
cmp    %r15,%r9
seta   %r9b
cmp    %r14,%r8
seta   %al
and    %r9b,%al
mov    %al,0x7(%rsp)
mov    %rdi,0x70(%rsp)
mov    %rdi,%rdx
and    $0xfffffffffffffff8,%rdx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
add    $0x2,%rax
mov    %rcx,%rdi
mov    %rcx,0x108(%rsp)
and    %rcx,%rax
mov    %rax,0xf0(%rsp)
lea    0x2(%rbp),%eax
imul   %ebp,%eax
mov    %rax,0x98(%rsp)
lea    0x0(%rbp,%rbp,1),%eax
lea    0x1(%rbp,%rbp,1),%ecx
imul   %ebp,%ecx
mov    %rcx,0x88(%rsp)
lea    0x2(%rbp,%rbp,1),%ecx
imul   %ebp,%ecx
or     $0x1,%rcx
mov    %rcx,0x80(%rsp)
or     $0x1,%rax
mov    %rax,0x90(%rsp)
lea    0x0(%r13,%r13,1),%eax
or     $0x1,%rax
mov    %rax,0x78(%rsp)
mov    $0x1,%eax
sub    %rbx,%rax
mov    %r10d,%ecx
add    $0x9,%ecx
mov    %ecx,0x5c(%rsp)
movss  0xa03(%rip),%xmm0
mov    %r10,0x68(%rsp)
lea    0x1(%r10),%ecx
mov    %ecx,0x60(%rsp)
mov    %rdx,0x100(%rsp)
lea    0x1(%rdx),%rcx
mov    %rcx,0xf8(%rsp)
xor    %ecx,%ecx
mov    %rbx,0x20(%rsp)
mov    %rax,0x120(%rsp)
jmp    1654 <float_stencil19+0x4c4>
nopw   0x0(%rax,%rax,1)
mov    0xa0(%rsp),%rcx
add    $0x1,%ecx
cmp    $0x64,%ecx
je     1b3d <float_stencil19+0x9ad>
mov    %rcx,0xa0(%rsp)
cmpb   $0x0,0x30(%rsp)
je     1640 <float_stencil19+0x4b0>
mov    $0x1,%eax
xor    %ecx,%ecx
mov    0x78(%rsp),%rdx
mov    0x90(%rsp),%r11
mov    0x80(%rsp),%r12
mov    0x68(%rsp),%rbp
mov    0x88(%rsp),%rsi
mov    0x48(%rsp),%r9
mov    0x98(%rsp),%r10
mov    %r13,%r8
nopl   0x0(%rax)
add    $0x1,%eax
mov    %eax,0x64(%rsp)
mov    %rcx,0xe8(%rsp)
mov    %rcx,%r13
mov    %rdx,0xe0(%rsp)
mov    %r11,0xd8(%rsp)
mov    %r12,0xd0(%rsp)
mov    %r12,%rdi
mov    %rbp,0xc8(%rsp)
mov    %rbp,%rbx
mov    %rsi,0xc0(%rsp)
mov    %r9,0xb8(%rsp)
mov    %r10,0xb0(%rsp)
mov    %r8,0xa8(%rsp)
mov    %r8,%r12
mov    %r9,%r8
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r11,0x8(%rsp)
mov    %rdx,0x10(%rsp)
mov    %r13,0x18(%rsp)
add    $0x1,%ebp
mov    %ebp,0x28(%rsp)
xor    %ebp,%ebp
mov    0x120(%rsp),%r13
mov    %rdi,%rdx
mov    %rsi,%rcx
cs nopw 0x0(%rax,%rax,1)
lea    (%r12,%rbp,1),%rsi
lea    0x1(%rsi),%eax
movss  (%r15,%rax,4),%xmm1
lea    (%r10,%rbp,1),%rax
lea    0x1(%rax),%edi
addss  (%r15,%rdi,4),%xmm1
lea    (%r8,%rbp,1),%r11
lea    0x1(%r11),%edi
addss  (%r15,%rdi,4),%xmm1
mov    %r12,%r9
mov    %r10,%r12
mov    %r8,%r10
mov    %r14,%r8
lea    (%rcx,%rbp,1),%r14
lea    0x1(%r14),%edi
addss  (%r15,%rdi,4),%xmm1
mov    0x18(%rsp),%rdi
lea    0x1(%rdi,%rbp,1),%edi
addss  (%r15,%rdi,4),%xmm1
mov    0x8(%rsp),%rdi
lea    (%rdi,%rbp,1),%edi
addss  (%r15,%rdi,4),%xmm1
mov    0x10(%rsp),%rdi
lea    (%rdi,%rbp,1),%edi
addss  (%r15,%rdi,4),%xmm1
lea    (%rdx,%rbp,1),%edi
addss  (%r15,%rdi,4),%xmm1
mov    %esi,%edi
addss  (%r15,%rdi,4),%xmm1
mov    %eax,%edi
addss  (%r15,%rdi,4),%xmm1
mov    %r11d,%edi
addss  (%r15,%rdi,4),%xmm1
mov    %r14d,%edi
addss  (%r15,%rdi,4),%xmm1
add    $0x2,%esi
addss  (%r15,%rsi,4),%xmm1
add    $0x2,%eax
addss  (%r15,%rax,4),%xmm1
add    $0x2,%r11d
addss  (%r15,%r11,4),%xmm1
add    $0x2,%r14d
addss  (%r15,%r14,4),%xmm1
mov    %r8,%r14
mov    %r10,%r8
mov    %r12,%r10
mov    %r9,%r12
lea    (%rbx,%rbp,1),%rax
mov    %eax,%esi
addss  (%r15,%rsi,4),%xmm1
lea    0x2(%rax),%esi
addss  (%r15,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
add    $0x1,%eax
movss  %xmm1,(%r14,%rax,4)
add    $0x1,%rbp
mov    %r13,%rax
add    %rbp,%rax
jne    1740 <float_stencil19+0x5b0>
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%r10
add    %rax,%r8
mov    %rcx,%rsi
add    %rax,%rsi
add    %rax,%rbx
mov    %rdx,%rcx
add    %rax,%rcx
mov    0x8(%rsp),%r11
add    %rax,%r11
mov    0x10(%rsp),%rdi
add    %rax,%rdi
mov    0x18(%rsp),%r13
add    %rax,%r13
mov    0x20(%rsp),%rax
mov    0x28(%rsp),%ebp
cmp    %eax,%ebp
mov    %rdi,%rdx
mov    %rcx,%rdi
jne    1710 <float_stencil19+0x580>
mov    0x40(%rsp),%r13
mov    0xa8(%rsp),%r8
add    %r13,%r8
mov    0xb0(%rsp),%r10
add    %r13,%r10
mov    %rax,%rbx
mov    0xb8(%rsp),%r9
add    %r13,%r9
mov    0xc0(%rsp),%rsi
add    %r13,%rsi
mov    0xc8(%rsp),%rbp
add    %r13,%rbp
mov    0xd0(%rsp),%r12
add    %r13,%r12
mov    0xd8(%rsp),%r11
add    %r13,%r11
mov    0xe0(%rsp),%rdx
add    %r13,%rdx
mov    0xe8(%rsp),%rcx
add    %r13,%rcx
mov    0x64(%rsp),%eax
cmp    %ebx,%eax
jne    16a0 <float_stencil19+0x510>
cmpb   $0x0,0x30(%rsp)
mov    0x38(%rsp),%rbp
je     1640 <float_stencil19+0x4b0>
mov    $0x1,%edx
xor    %ecx,%ecx
mov    0x68(%rsp),%rdi
mov    0x5c(%rsp),%r10d
jmp    1956 <float_stencil19+0x7c6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%edx
add    $0x1,%edx
mov    0x18(%rsp),%ecx
add    $0x1,%ecx
mov    0x8(%rsp),%r10d
add    %r13d,%r10d
mov    0x10(%rsp),%rdi
add    %r13,%rdi
cmp    %ebx,%edx
je     1640 <float_stencil19+0x4b0>
mov    %r13d,%r12d
mov    %ecx,0x18(%rsp)
imul   %ecx,%r12d
add    0x60(%rsp),%r12d
mov    %edx,0x28(%rsp)
mov    %edx,%r11d
imul   %ebp,%r11d
mov    %rdi,0x10(%rsp)
mov    %r10d,0x8(%rsp)
xor    %r9d,%r9d
mov    $0x1,%r8d
jmp    19a5 <float_stencil19+0x815>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r8d
add    $0x1,%r9d
add    %ebp,%r10d
add    0x48(%rsp),%rdi
cmp    %ebx,%r8d
je     1930 <float_stencil19+0x7a0>
mov    $0x1,%ecx
cmpq   $0x8,0x70(%rsp)
jb     1aa0 <float_stencil19+0x910>
mov    0x118(%rsp),%rdx
mov    %rdx,%rax
shr    $0x20,%rax
setne  %al
mov    %r9d,%esi
imul   %ebp,%esi
add    %r12d,%esi
add    %edx,%esi
mov    0x20(%rsp),%rbx
setb   %dl
or     %al,%dl
or     0x7(%rsp),%dl
jne    1aa0 <float_stencil19+0x910>
cmpq   $0x8,0x110(%rsp)
jae    19f6 <float_stencil19+0x866>
xor    %eax,%eax
jmp    1a50 <float_stencil19+0x8c0>
mov    0xf0(%rsp),%rcx
mov    %r10d,%esi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x8(%rsi),%edx
movups (%r14,%rdx,4),%xmm1
movups 0x10(%r14,%rdx,4),%xmm2
movups %xmm1,(%r15,%rdx,4)
movups %xmm2,0x10(%r15,%rdx,4)
mov    %esi,%edx
movups (%r14,%rdx,4),%xmm1
movupd 0x10(%r14,%rdx,4),%xmm2
movups %xmm1,(%r15,%rdx,4)
movupd %xmm2,0x10(%r15,%rdx,4)
add    $0x10,%rax
add    $0x10,%esi
add    $0xfffffffffffffffe,%rcx
jne    1a10 <float_stencil19+0x880>
testb  $0x1,0x108(%rsp)
01
mov    0x20(%rsp),%rbx
je     1a83 <float_stencil19+0x8f3>
lea    (%r8,%r11,1),%ecx
imul   %ebp,%ecx
or     $0x1,%eax
add    %ecx,%eax
movups (%r14,%rax,4),%xmm1
movupd 0x10(%r14,%rax,4),%xmm2
movups %xmm1,(%r15,%rax,4)
movupd %xmm2,0x10(%r15,%rax,4)
mov    0xf8(%rsp),%rcx
mov    0x100(%rsp),%rax
cmp    %rax,0x70(%rsp)
je     1990 <float_stencil19+0x800>
xchg   %ax,%ax
mov    %rbx,%rdx
mov    %edx,%esi
sub    %ecx,%esi
mov    %rcx,%rax
not    %rax
add    %rbx,%rax
and    $0x3,%rsi
je     1ad9 <float_stencil19+0x949>
cs nopw 0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%edx
movss  (%r14,%rdx,4),%xmm1
movss  %xmm1,(%r15,%rdx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1ac0 <float_stencil19+0x930>
cmp    $0x3,%rax
mov    0x20(%rsp),%rbx
jb     1990 <float_stencil19+0x800>
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%rax
mov    %eax,%edx
movss  (%r14,%rdx,4),%xmm1
movss  %xmm1,(%r15,%rdx,4)
lea    0x1(%rax),%edx
movss  (%r14,%rdx,4),%xmm1
movss  %xmm1,(%r15,%rdx,4)
lea    0x2(%rax),%edx
movss  (%r14,%rdx,4),%xmm1
movss  %xmm1,(%r15,%rdx,4)
add    $0x3,%eax
movss  (%r14,%rax,4),%xmm1
movss  %xmm1,(%r15,%rax,4)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    1af0 <float_stencil19+0x960>
jmp    1990 <float_stencil19+0x800>
mov    0x249c(%rip),%rax
mov    (%rax),%edi
lea    0x50(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    0x58(%rsp),%edi
mov    0x50(%rsp),%esi
lea    0x4d9(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    %r15,%rdi
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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