#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_stencil27(unsigned int size) {
  int i, j, k, iter;
  int n = size - 2;
  float fac = 1.0 / 26;
  float *a0 = (float *)malloc(sizeof(float) * size * size * size);
  float *a1 = (float *)malloc(sizeof(float) * size * size * size);
  if (a0 == NULL || a1 == NULL) {
    printf(
        "27-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 - 1) * size * size + (j - 1) * size + (k - 1)] +
                 a0[(i - 1) * size * size + (j + 1) * size + (k - 1)] +
                 a0[(i + 1) * size * size + (j - 1) * size + (k - 1)] +
                 a0[(i + 1) * size * size + (j + 1) * 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 - 1) * size * size + (j - 1) * size + (k + 1)] +
                 a0[(i - 1) * size * size + (j + 1) * size + (k + 1)] +
                 a0[(i + 1) * size * size + (j - 1) * size + (k + 1)] +
                 a0[(i + 1) * size * size + (j + 1) * 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 - 27 point");
  free(a0);
  free(a1);
}


x86 assembly (clang, -O0):
<float_stencil27>:
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_stencil27+0x77>
cmpq   $0x0,-0x30(%rbp)
jne    1205 <float_stencil27+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_stencil27+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_stencil27+0x13f>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12ac <float_stencil27+0x12c>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1299 <float_stencil27+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_stencil27+0xda>
jmp    129e <float_stencil27+0x11e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1247 <float_stencil27+0xc7>
jmp    12b1 <float_stencil27+0x131>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1234 <float_stencil27+0xb4>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1389 <float_stencil27+0x209>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1376 <float_stencil27+0x1f6>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1363 <float_stencil27+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_stencil27+0x176>
jmp    1368 <float_stencil27+0x1e8>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12de <float_stencil27+0x15e>
jmp    137b <float_stencil27+0x1fb>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12c6 <float_stencil27+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    195c <float_stencil27+0x7dc>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1889 <float_stencil27+0x709>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1876 <float_stencil27+0x6f6>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1863 <float_stencil27+0x6e3>
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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_stencil27+0x263>
jmp    1868 <float_stencil27+0x6e8>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13cb <float_stencil27+0x24b>
jmp    187b <float_stencil27+0x6fb>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13b3 <float_stencil27+0x233>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1949 <float_stencil27+0x7c9>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1936 <float_stencil27+0x7b6>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1923 <float_stencil27+0x7a3>
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    18c0 <float_stencil27+0x740>
jmp    1928 <float_stencil27+0x7a8>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    18a8 <float_stencil27+0x728>
jmp    193b <float_stencil27+0x7bb>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1890 <float_stencil27+0x710>
jmp    194e <float_stencil27+0x7ce>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13a2 <float_stencil27+0x222>
mov    0x267d(%rip),%rax
mov    (%rax),%edi
lea    -0x40(%rbp),%rsi
call   1060 <clock_gettime@plt>
mov    -0x38(%rbp),%edi
mov    -0x40(%rbp),%esi
lea    0x705(%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_stencil27>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %edi,%r13d
imul   %r13d,%r13d
mov    %r13d,%r14d
mov    %rdi,0x30(%rsp)
imul   %edi,%r14d
shl    $0x2,%r14d
mov    %r14d,%edi
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %r14d,%edi
call   10a0 <malloc@plt>
test   %rbx,%rbx
mov    %rax,0x48(%rsp)
je     11da <float_stencil27+0x4a>
test   %rax,%rax
jne    11e6 <float_stencil27+0x56>
lea    0xe7b(%rip),%rdi
call   1050 <puts@plt>
xor    %eax,%eax
call   1060 <omp_get_thread_num@plt>
test   %rax,%rax
jne    1209 <float_stencil27+0x79>
xor    %eax,%eax
call   1090 <omp_get_num_threads@plt>
lea    0xe0c(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1080 <printf@plt>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
xor    %ecx,%ecx
mov    0x30(%rsp),%r8
mov    %r8d,%esi
test   %r8d,%r8d
mov    %r13,0x40(%rsp)
mov    %rsi,0x38(%rsp)
je     14d0 <float_stencil27+0x340>
lea    -0x1(%rsi),%r14
mov    %esi,%r12d
and    $0xfffffff8,%r12d
lea    -0x8(%r12),%r11
mov    %r11,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r15d
and    $0x3,%r15d
and    %rax,%rdx
mov    %rdx,0x10(%rsp)
mov    %esi,%r9d
and    $0x3,%r9d
mov    $0x10,%r10d
xorps  %xmm0,%xmm0
xor    %eax,%eax
jmp    1296 <float_stencil27+0x106>
xchg   %ax,%ax
mov    0x28(%rsp),%rcx
add    $0x1,%ecx
mov    0x40(%rsp),%r13
mov    0x20(%rsp),%r10d
add    %r13d,%r10d
mov    0x18(%rsp),%rax
add    %r13,%rax
cmp    %r8d,%ecx
je     13fa <float_stencil27+0x26a>
mov    %rcx,0x28(%rsp)
imul   %ecx,%r13d
mov    %rax,%rcx
xor    %edi,%edi
mov    %rax,0x18(%rsp)
mov    %r10d,0x20(%rsp)
jmp    12be <float_stencil27+0x12e>
add    $0x1,%edi
add    %r8d,%r10d
add    %rsi,%rcx
cmp    %r8d,%edi
je     1270 <float_stencil27+0xe0>
cmp    $0x8,%r8d
jae    1340 <float_stencil27+0x1b0>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %rsi,%rax
test   %r9,%r9
je     12f4 <float_stencil27+0x164>
mov    %r9,%rsi
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%edx
movl   $0x0,(%rbx,%rdx,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rsi
jne    12e0 <float_stencil27+0x150>
cmp    $0x3,%rax
mov    0x38(%rsp),%rsi
jb     12b0 <float_stencil27+0x120>
nop
lea    (%rcx,%rbp,1),%rax
mov    %eax,%edx
movl   $0x0,(%rbx,%rdx,4)
lea    0x1(%rax),%edx
movl   $0x0,(%rbx,%rdx,4)
lea    0x2(%rax),%edx
movl   $0x0,(%rbx,%rdx,4)
add    $0x3,%eax
movl   $0x0,(%rbx,%rax,4)
add    $0x4,%rbp
cmp    %rbp,%rsi
jne    1300 <float_stencil27+0x170>
jmp    12b0 <float_stencil27+0x120>
nopl   0x0(%rax)
mov    %edi,%eax
imul   %r8d,%eax
add    %r13d,%eax
add    %r14d,%eax
jb     12c4 <float_stencil27+0x134>
mov    %r14,%rax
shr    $0x20,%rax
mov    $0x0,%ebp
jne    12c6 <float_stencil27+0x136>
cmp    $0x18,%r11
jae    136e <float_stencil27+0x1de>
xor    %ebp,%ebp
jmp    13c1 <float_stencil27+0x231>
mov    0x10(%rsp),%rax
mov    %r10d,%r8d
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
lea    -0x10(%r8),%esi
movups %xmm0,(%rbx,%rsi,4)
movups %xmm0,0x10(%rbx,%rsi,4)
lea    -0x8(%r8),%esi
movups %xmm0,(%rbx,%rsi,4)
movups %xmm0,0x10(%rbx,%rsi,4)
mov    %r8d,%esi
movups %xmm0,(%rbx,%rsi,4)
movups %xmm0,0x10(%rbx,%rsi,4)
lea    0x8(%r8),%esi
movups %xmm0,(%rbx,%rsi,4)
movups %xmm0,0x10(%rbx,%rsi,4)
add    $0x20,%rbp
add    $0x20,%r8d
add    $0xfffffffffffffffc,%rax
jne    1380 <float_stencil27+0x1f0>
test   %r15,%r15
mov    0x30(%rsp),%r8
je     13e4 <float_stencil27+0x254>
add    %ecx,%ebp
mov    %r15,%rax
mov    %ebp,%esi
movups %xmm0,(%rbx,%rsi,4)
movups %xmm0,0x10(%rbx,%rsi,4)
add    $0x8,%ebp
add    $0xffffffffffffffff,%rax
jne    13d0 <float_stencil27+0x240>
mov    %r12,%rbp
mov    0x38(%rsp),%rsi
cmp    %rsi,%r12
je     12b0 <float_stencil27+0x120>
jmp    12c6 <float_stencil27+0x136>
lea    -0x1(%r8),%r15d
cmp    $0x2,%r15d
setge  %al
jl     14df <float_stencil27+0x34f>
mov    %rax,0x28(%rsp)
mov    %r15d,%eax
lea    0x1(%r8),%r14d
imul   %r8d,%r14d
add    $0x1,%r14d
add    $0xffffffffffffffff,%rax
mov    %rax,0x20(%rsp)
mov    $0x1,%eax
mov    0x2bb4(%rip),%rbp
mov    %r15d,0x10(%rsp)
nopl   0x0(%rax)
mov    %eax,0x58(%rsp)
mov    %r14d,0x18(%rsp)
mov    $0x1,%r12d
nop
mov    0x20(%rsp),%r13
mov    %r14d,%r15d
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10b0 <rand@plt>
movsd  0xb91(%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    %r15d,%eax
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%r15d
add    $0xffffffffffffffff,%r13
jne    1460 <float_stencil27+0x2d0>
add    $0x1,%r12d
add    0x30(%rsp),%r14d
mov    0x10(%rsp),%r15d
cmp    %r15d,%r12d
jne    1450 <float_stencil27+0x2c0>
mov    0x58(%rsp),%eax
add    $0x1,%eax
mov    0x40(%rsp),%r13
mov    0x18(%rsp),%r14d
add    %r13d,%r14d
cmp    %r15d,%eax
jne    1440 <float_stencil27+0x2b0>
jmp    14e6 <float_stencil27+0x356>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    $0xffffffff,%r15d
jmp    14e6 <float_stencil27+0x356>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    0x2af3(%rip),%rax
mov    (%rax),%edi
lea    0x68(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    %r15d,%esi
lea    -0x2(%rsi),%rax
mov    %rax,0x138(%rsp)
mov    0x30(%rsp),%rdx
lea    0x1(%rdx),%r9d
imul   %edx,%r9d
lea    0x1(%r9),%eax
mov    %eax,0x74(%rsp)
lea    -0x1(%rsi),%r11
lea    (%rbx,%rsi,4),%r8
add    $0xfffffffffffffffc,%r8
mov    0x48(%rsp),%rdi
lea    -0x4(%rdi,%rsi,4),%rcx
lea    -0x9(%rsi),%rax
mov    %rax,0x130(%rsp)
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
cmp    %rbx,%rcx
seta   %cl
cmp    %rdi,%r8
seta   %al
and    %cl,%al
mov    %al,0xf(%rsp)
mov    %rsi,%rcx
mov    %r11,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x120(%rsp)
add    $0x1,%rax
mov    %rax,0x118(%rsp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
add    $0x2,%rax
mov    %rbp,%rsi
mov    %rbp,0x128(%rsp)
and    %rbp,%rax
mov    %rax,0x110(%rsp)
lea    0x2(%rdx),%eax
imul   %edx,%eax
mov    %rax,0xb8(%rsp)
lea    (%rdx,%rdx,1),%eax
add    $0x1,%eax
imul   %edx,%eax
mov    %rax,0xb0(%rsp)
lea    (%rdx,%rdx,1),%eax
add    $0x2,%eax
imul   %edx,%eax
mov    %rax,0xa8(%rsp)
mov    $0x1,%eax
sub    %rcx,%rax
mov    %r9,0x80(%rsp)
mov    %r9d,%esi
add    $0x9,%esi
mov    %esi,0x70(%rsp)
movss  0xa18(%rip),%xmm0
add    %edx,%edx
mov    %rdx,0xa0(%rsp)
lea    0x0(%r13,%r13,1),%edx
mov    %rdx,0x98(%rsp)
xor    %edx,%edx
mov    %rcx,0x50(%rsp)
mov    %r11,0x88(%rsp)
mov    %rax,0x140(%rsp)
mov    %rbx,0x90(%rsp)
jmp    1644 <float_stencil27+0x4b4>
nopl   0x0(%rax,%rax,1)
mov    0xc0(%rsp),%rdx
add    $0x1,%edx
cmp    $0x64,%edx
je     1ba5 <float_stencil27+0xa15>
mov    %rdx,0xc0(%rsp)
cmpb   $0x0,0x28(%rsp)
je     1630 <float_stencil27+0x4a0>
mov    $0x1,%r8d
mov    0x80(%rsp),%rsi
mov    0xa8(%rsp),%rbx
mov    0x98(%rsp),%rdx
mov    0xa0(%rsp),%rax
xor    %r9d,%r9d
mov    0xb0(%rsp),%r14
mov    0x38(%rsp),%r11
mov    0xb8(%rsp),%rdi
mov    %r13,%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8d
mov    %r8d,0x78(%rsp)
mov    %rsi,0x108(%rsp)
mov    %rbx,0x100(%rsp)
mov    %rbx,%rcx
mov    %rdx,0xf8(%rsp)
mov    %rdx,%rbx
mov    %rax,0xf0(%rsp)
mov    %rax,%r8
mov    %r9,0xe8(%rsp)
mov    %r9,%rdx
mov    %r14,0xe0(%rsp)
mov    %r11,0xd8(%rsp)
mov    %r11,%r9
mov    %rdi,0xd0(%rsp)
mov    %rdi,%r11
mov    %r15,0xc8(%rsp)
mov    %r15,%rdi
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
mov    %eax,0x7c(%rsp)
xor    %ebp,%ebp
mov    0x90(%rsp),%r15
mov    %rdx,0x20(%rsp)
mov    %rsi,0x18(%rsp)
mov    %r14,0x58(%rsp)
mov    %r11,0x150(%rsp)
mov    %rdi,0x148(%rsp)
mov    %r8,0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
add    %rbp,%rdi
lea    0x1(%rdi),%eax
movss  (%r15,%rax,4),%xmm1
lea    (%r11,%rbp,1),%rax
lea    0x1(%rax),%esi
addss  (%r15,%rsi,4),%xmm1
mov    %r9,%r11
lea    (%r9,%rbp,1),%r9
lea    0x1(%r9),%esi
addss  (%r15,%rsi,4),%xmm1
lea    (%r14,%rbp,1),%r14
lea    0x1(%r14),%esi
addss  (%r15,%rsi,4),%xmm1
lea    (%rdx,%rbp,1),%rsi
lea    0x1(%rsi),%edx
addss  (%r15,%rdx,4),%xmm1
mov    0x10(%rsp),%rdx
lea    (%rdx,%rbp,1),%r8
lea    0x1(%r8),%edx
addss  (%r15,%rdx,4),%xmm1
lea    (%rbx,%rbp,1),%r12
lea    0x1(%r12),%edx
addss  (%r15,%rdx,4),%xmm1
lea    (%rcx,%rbp,1),%r13
lea    0x1(%r13),%edx
addss  (%r15,%rdx,4),%xmm1
mov    %edi,%edx
addss  (%r15,%rdx,4),%xmm1
mov    %eax,%edx
addss  (%r15,%rdx,4),%xmm1
mov    %r9d,%edx
addss  (%r15,%rdx,4),%xmm1
mov    %r14d,%edx
addss  (%r15,%rdx,4),%xmm1
mov    %esi,%edx
addss  (%r15,%rdx,4),%xmm1
mov    %r8d,%edx
addss  (%r15,%rdx,4),%xmm1
mov    %r12d,%edx
addss  (%r15,%rdx,4),%xmm1
mov    %r13d,%edx
addss  (%r15,%rdx,4),%xmm1
add    $0x2,%edi
addss  (%r15,%rdi,4),%xmm1
mov    0x48(%rsp),%r10
add    $0x2,%eax
addss  (%r15,%rax,4),%xmm1
add    $0x2,%r9d
addss  (%r15,%r9,4),%xmm1
mov    %r11,%r9
mov    0x150(%rsp),%r11
add    $0x2,%r14d
addss  (%r15,%r14,4),%xmm1
mov    0x148(%rsp),%rdi
add    $0x2,%esi
addss  (%r15,%rsi,4),%xmm1
mov    0x18(%rsp),%rsi
add    $0x2,%r8d
addss  (%r15,%r8,4),%xmm1
mov    0x10(%rsp),%r8
mov    0x58(%rsp),%r14
add    $0x2,%r12d
addss  (%r15,%r12,4),%xmm1
add    $0x2,%r13d
addss  (%r15,%r13,4),%xmm1
lea    (%rsi,%rbp,1),%rax
mov    %eax,%edx
addss  (%r15,%rdx,4),%xmm1
lea    0x2(%rax),%edx
addss  (%r15,%rdx,4),%xmm1
mov    0x20(%rsp),%rdx
mulss  %xmm0,%xmm1
add    $0x1,%eax
movss  %xmm1,(%r10,%rax,4)
add    $0x1,%rbp
mov    0x140(%rsp),%rax
add    %rbp,%rax
jne    1750 <float_stencil27+0x5c0>
mov    0x38(%rsp),%rax
add    %rax,%rdi
add    %rax,%r11
add    %rax,%r9
add    %rax,%r14
add    %rax,%rdx
add    %rax,%r8
add    %rax,%rbx
add    %rax,%rcx
add    %rax,%rsi
mov    0x7c(%rsp),%eax
cmp    0x50(%rsp),%eax
jne    1710 <float_stencil27+0x580>
mov    0x40(%rsp),%r13
mov    0xc8(%rsp),%r15
add    %r13,%r15
mov    0xd0(%rsp),%rdi
add    %r13,%rdi
mov    0xd8(%rsp),%r11
add    %r13,%r11
mov    0xe0(%rsp),%r14
add    %r13,%r14
mov    0xe8(%rsp),%r9
add    %r13,%r9
mov    0xf0(%rsp),%rax
add    %r13,%rax
mov    0xf8(%rsp),%rdx
add    %r13,%rdx
mov    0x100(%rsp),%rbx
add    %r13,%rbx
mov    0x108(%rsp),%rsi
add    %r13,%rsi
mov    0x50(%rsp),%rcx
mov    0x78(%rsp),%r8d
cmp    %ecx,%r8d
jne    16a0 <float_stencil27+0x510>
mov    %r10,%rbp
cmpb   $0x0,0x28(%rsp)
mov    0x30(%rsp),%r8
mov    0x88(%rsp),%r11
mov    0x90(%rsp),%rbx
mov    %r10,%rdi
je     1630 <float_stencil27+0x4a0>
mov    $0x1,%r15d
xor    %edx,%edx
mov    0x80(%rsp),%rsi
mov    0x70(%rsp),%r9d
jmp    19c9 <float_stencil27+0x839>
add    $0x1,%r15d
mov    0x10(%rsp),%edx
add    $0x1,%edx
mov    0x40(%rsp),%r13
mov    0x18(%rsp),%r9d
add    %r13d,%r9d
mov    0x20(%rsp),%rsi
add    %r13,%rsi
cmp    %ecx,%r15d
je     1630 <float_stencil27+0x4a0>
mov    %edx,0x10(%rsp)
imul   %edx,%r13d
add    0x74(%rsp),%r13d
mov    %r15d,%r12d
imul   %r8d,%r12d
mov    %rsi,0x20(%rsp)
mov    %r9d,0x18(%rsp)
xor    %r14d,%r14d
mov    $0x1,%r10d
jmp    1a15 <float_stencil27+0x885>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10d
add    $0x1,%r14d
add    %r8d,%r9d
add    0x38(%rsp),%rsi
cmp    %ecx,%r10d
je     19a0 <float_stencil27+0x810>
mov    $0x1,%ebp
cmp    $0x8,%r11
jb     1b10 <float_stencil27+0x980>
mov    0x138(%rsp),%r11
mov    %r11,%rax
shr    $0x20,%rax
setne  %al
mov    %r14d,%edx
imul   %r8d,%edx
add    %r13d,%edx
add    %r11d,%edx
mov    0x88(%rsp),%r11
setb   %dl
or     %al,%dl
or     0xf(%rsp),%dl
jne    1b10 <float_stencil27+0x980>
cmpq   $0x8,0x130(%rsp)
jae    1a6e <float_stencil27+0x8de>
xor    %eax,%eax
mov    0x48(%rsp),%r8
jmp    1abc <float_stencil27+0x92c>
mov    0x110(%rsp),%rdx
mov    %r9d,%ebp
xor    %eax,%eax
mov    0x48(%rsp),%r8
lea    -0x8(%rbp),%edi
movups (%r8,%rdi,4),%xmm1
movups 0x10(%r8,%rdi,4),%xmm2
movups %xmm1,(%rbx,%rdi,4)
movups %xmm2,0x10(%rbx,%rdi,4)
mov    %ebp,%edi
movups (%r8,%rdi,4),%xmm1
movupd 0x10(%r8,%rdi,4),%xmm2
movups %xmm1,(%rbx,%rdi,4)
movupd %xmm2,0x10(%rbx,%rdi,4)
add    $0x10,%rax
add    $0x10,%ebp
add    $0xfffffffffffffffe,%rdx
jne    1a80 <float_stencil27+0x8f0>
testb  $0x1,0x128(%rsp)
01
mov    %r8,%rdi
mov    0x30(%rsp),%r8
je     1aef <float_stencil27+0x95f>
lea    (%r10,%r12,1),%edx
imul   %r8d,%edx
or     $0x1,%eax
add    %edx,%eax
movups (%rdi,%rax,4),%xmm1
movupd 0x10(%rdi,%rax,4),%xmm2
movups %xmm1,(%rbx,%rax,4)
movupd %xmm2,0x10(%rbx,%rax,4)
mov    0x118(%rsp),%rbp
cmp    0x120(%rsp),%r11
je     1a00 <float_stencil27+0x870>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,%edx
sub    %ebp,%edx
mov    %rbp,%rax
not    %rax
add    %rcx,%rax
mov    %rdi,%rcx
and    $0x3,%rdx
je     1b47 <float_stencil27+0x9b7>
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%rbp,1),%edi
movss  (%rcx,%rdi,4),%xmm1
movss  %xmm1,(%rbx,%rdi,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    1b30 <float_stencil27+0x9a0>
cmp    $0x3,%rax
mov    %rcx,%rdi
mov    0x50(%rsp),%rcx
jb     1a00 <float_stencil27+0x870>
nopl   0x0(%rax)
lea    (%rsi,%rbp,1),%rax
mov    %eax,%edx
movss  (%rdi,%rdx,4),%xmm1
movss  %xmm1,(%rbx,%rdx,4)
lea    0x1(%rax),%edx
movss  (%rdi,%rdx,4),%xmm1
movss  %xmm1,(%rbx,%rdx,4)
lea    0x2(%rax),%edx
movss  (%rdi,%rdx,4),%xmm1
movss  %xmm1,(%rbx,%rdx,4)
add    $0x3,%eax
movss  (%rdi,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    1b60 <float_stencil27+0x9d0>
jmp    1a00 <float_stencil27+0x870>
mov    %rdi,%rbp
mov    0x2431(%rip),%rax
mov    (%rax),%edi
lea    0x60(%rsp),%rsi
call   1070 <clock_gettime@plt>
mov    0x68(%rsp),%edi
mov    0x60(%rsp),%esi
lea    0x46e(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    %rbx,%rdi
call   1040 <free@plt>
mov    %rbp,%rdi
call   1040 <free@plt>
add    $0x158,%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"27-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 - 27 point\00"
define void @float_stencil27(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 0x3FA3B13B20000000, 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 = %725, %144
%148 = load i32, i32* %6
%149 = icmp slt i32 %148, 100
br i1 %149, label %150, label %728
150: ; preds = %147
store i32 1, i32* %3
br label %151
151: ; preds = %662, %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 %665
156: ; preds = %151
store i32 1, i32* %4
br label %157
157: ; preds = %658, %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 %661
162: ; preds = %157
store i32 1, i32* %5
br label %163
163: ; preds = %654, %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 %657
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 = sub nsw i32 %381, 1
%383 = load i32, i32* %2
%384 = mul i32 %382, %383
%385 = load i32, i32* %2
%386 = mul i32 %384, %385
%387 = load i32, i32* %4
%388 = sub nsw i32 %387, 1
%389 = load i32, i32* %2
%390 = mul i32 %388, %389
%391 = add i32 %386, %390
%392 = load i32, i32* %5
%393 = sub nsw i32 %392, 1
%394 = add i32 %391, %393
%395 = zext i32 %394 to i64
%396 = getelementptr inbounds float, float* %380, i64 %395
%397 = load float, float* %396
%398 = fadd float %379, %397
%399 = load float*, float** %9
%400 = load i32, i32* %3
%401 = sub nsw i32 %400, 1
%402 = load i32, i32* %2
%403 = mul i32 %401, %402
%404 = load i32, i32* %2
%405 = mul i32 %403, %404
%406 = load i32, i32* %4
%407 = add nsw i32 %406, 1
%408 = load i32, i32* %2
%409 = mul i32 %407, %408
%410 = add i32 %405, %409
%411 = load i32, i32* %5
%412 = sub nsw i32 %411, 1
%413 = add i32 %410, %412
%414 = zext i32 %413 to i64
%415 = getelementptr inbounds float, float* %399, i64 %414
%416 = load float, float* %415
%417 = fadd float %398, %416
%418 = load float*, float** %9
%419 = load i32, i32* %3
%420 = add nsw i32 %419, 1
%421 = load i32, i32* %2
%422 = mul i32 %420, %421
%423 = load i32, i32* %2
%424 = mul i32 %422, %423
%425 = load i32, i32* %4
%426 = sub nsw i32 %425, 1
%427 = load i32, i32* %2
%428 = mul i32 %426, %427
%429 = add i32 %424, %428
%430 = load i32, i32* %5
%431 = sub nsw i32 %430, 1
%432 = add i32 %429, %431
%433 = zext i32 %432 to i64
%434 = getelementptr inbounds float, float* %418, i64 %433
%435 = load float, float* %434
%436 = fadd float %417, %435
%437 = load float*, float** %9
%438 = load i32, i32* %3
%439 = add nsw i32 %438, 1
%440 = load i32, i32* %2
%441 = mul i32 %439, %440
%442 = load i32, i32* %2
%443 = mul i32 %441, %442
%444 = load i32, i32* %4
%445 = add nsw i32 %444, 1
%446 = load i32, i32* %2
%447 = mul i32 %445, %446
%448 = add i32 %443, %447
%449 = load i32, i32* %5
%450 = sub nsw i32 %449, 1
%451 = add i32 %448, %450
%452 = zext i32 %451 to i64
%453 = getelementptr inbounds float, float* %437, i64 %452
%454 = load float, float* %453
%455 = fadd float %436, %454
%456 = load float*, float** %9
%457 = load i32, i32* %3
%458 = load i32, i32* %2
%459 = mul i32 %457, %458
%460 = load i32, i32* %2
%461 = mul i32 %459, %460
%462 = load i32, i32* %4
%463 = sub nsw i32 %462, 1
%464 = load i32, i32* %2
%465 = mul i32 %463, %464
%466 = add i32 %461, %465
%467 = load i32, i32* %5
%468 = add nsw i32 %467, 1
%469 = add i32 %466, %468
%470 = zext i32 %469 to i64
%471 = getelementptr inbounds float, float* %456, i64 %470
%472 = load float, float* %471
%473 = fadd float %455, %472
%474 = load float*, float** %9
%475 = load i32, i32* %3
%476 = load i32, i32* %2
%477 = mul i32 %475, %476
%478 = load i32, i32* %2
%479 = mul i32 %477, %478
%480 = load i32, i32* %4
%481 = add nsw i32 %480, 1
%482 = load i32, i32* %2
%483 = mul i32 %481, %482
%484 = add i32 %479, %483
%485 = load i32, i32* %5
%486 = add nsw i32 %485, 1
%487 = add i32 %484, %486
%488 = zext i32 %487 to i64
%489 = getelementptr inbounds float, float* %474, i64 %488
%490 = load float, float* %489
%491 = fadd float %473, %490
%492 = load float*, float** %9
%493 = load i32, i32* %3
%494 = sub nsw i32 %493, 1
%495 = load i32, i32* %2
%496 = mul i32 %494, %495
%497 = load i32, i32* %2
%498 = mul i32 %496, %497
%499 = load i32, i32* %4
%500 = load i32, i32* %2
%501 = mul i32 %499, %500
%502 = add i32 %498, %501
%503 = load i32, i32* %5
%504 = add nsw i32 %503, 1
%505 = add i32 %502, %504
%506 = zext i32 %505 to i64
%507 = getelementptr inbounds float, float* %492, i64 %506
%508 = load float, float* %507
%509 = fadd float %491, %508
%510 = load float*, float** %9
%511 = load i32, i32* %3
%512 = add nsw i32 %511, 1
%513 = load i32, i32* %2
%514 = mul i32 %512, %513
%515 = load i32, i32* %2
%516 = mul i32 %514, %515
%517 = load i32, i32* %4
%518 = load i32, i32* %2
%519 = mul i32 %517, %518
%520 = add i32 %516, %519
%521 = load i32, i32* %5
%522 = add nsw i32 %521, 1
%523 = add i32 %520, %522
%524 = zext i32 %523 to i64
%525 = getelementptr inbounds float, float* %510, i64 %524
%526 = load float, float* %525
%527 = fadd float %509, %526
%528 = load float*, float** %9
%529 = load i32, i32* %3
%530 = sub nsw i32 %529, 1
%531 = load i32, i32* %2
%532 = mul i32 %530, %531
%533 = load i32, i32* %2
%534 = mul i32 %532, %533
%535 = load i32, i32* %4
%536 = sub nsw i32 %535, 1
%537 = load i32, i32* %2
%538 = mul i32 %536, %537
%539 = add i32 %534, %538
%540 = load i32, i32* %5
%541 = add nsw i32 %540, 1
%542 = add i32 %539, %541
%543 = zext i32 %542 to i64
%544 = getelementptr inbounds float, float* %528, i64 %543
%545 = load float, float* %544
%546 = fadd float %527, %545
%547 = load float*, float** %9
%548 = load i32, i32* %3
%549 = sub nsw i32 %548, 1
%550 = load i32, i32* %2
%551 = mul i32 %549, %550
%552 = load i32, i32* %2
%553 = mul i32 %551, %552
%554 = load i32, i32* %4
%555 = add nsw i32 %554, 1
%556 = load i32, i32* %2
%557 = mul i32 %555, %556
%558 = add i32 %553, %557
%559 = load i32, i32* %5
%560 = add nsw i32 %559, 1
%561 = add i32 %558, %560
%562 = zext i32 %561 to i64
%563 = getelementptr inbounds float, float* %547, i64 %562
%564 = load float, float* %563
%565 = fadd float %546, %564
%566 = load float*, float** %9
%567 = load i32, i32* %3
%568 = add nsw i32 %567, 1
%569 = load i32, i32* %2
%570 = mul i32 %568, %569
%571 = load i32, i32* %2
%572 = mul i32 %570, %571
%573 = load i32, i32* %4
%574 = sub nsw i32 %573, 1
%575 = load i32, i32* %2
%576 = mul i32 %574, %575
%577 = add i32 %572, %576
%578 = load i32, i32* %5
%579 = add nsw i32 %578, 1
%580 = add i32 %577, %579
%581 = zext i32 %580 to i64
%582 = getelementptr inbounds float, float* %566, i64 %581
%583 = load float, float* %582
%584 = fadd float %565, %583
%585 = load float*, float** %9
%586 = load i32, i32* %3
%587 = add nsw i32 %586, 1
%588 = load i32, i32* %2
%589 = mul i32 %587, %588
%590 = load i32, i32* %2
%591 = mul i32 %589, %590
%592 = load i32, i32* %4
%593 = add nsw i32 %592, 1
%594 = load i32, i32* %2
%595 = mul i32 %593, %594
%596 = add i32 %591, %595
%597 = load i32, i32* %5
%598 = add nsw i32 %597, 1
%599 = add i32 %596, %598
%600 = zext i32 %599 to i64
%601 = getelementptr inbounds float, float* %585, i64 %600
%602 = load float, float* %601
%603 = fadd float %584, %602
%604 = load float*, float** %9
%605 = load i32, i32* %3
%606 = load i32, i32* %2
%607 = mul i32 %605, %606
%608 = load i32, i32* %2
%609 = mul i32 %607, %608
%610 = load i32, i32* %4
%611 = load i32, i32* %2
%612 = mul i32 %610, %611
%613 = add i32 %609, %612
%614 = load i32, i32* %5
%615 = sub nsw i32 %614, 1
%616 = add i32 %613, %615
%617 = zext i32 %616 to i64
%618 = getelementptr inbounds float, float* %604, i64 %617
%619 = load float, float* %618
%620 = fadd float %603, %619
%621 = load float*, float** %9
%622 = load i32, i32* %3
%623 = load i32, i32* %2
%624 = mul i32 %622, %623
%625 = load i32, i32* %2
%626 = mul i32 %624, %625
%627 = load i32, i32* %4
%628 = load i32, i32* %2
%629 = mul i32 %627, %628
%630 = add i32 %626, %629
%631 = load i32, i32* %5
%632 = add nsw i32 %631, 1
%633 = add i32 %630, %632
%634 = zext i32 %633 to i64
%635 = getelementptr inbounds float, float* %621, i64 %634
%636 = load float, float* %635
%637 = fadd float %620, %636
%638 = load float, float* %8
%639 = fmul float %637, %638
%640 = load float*, float** %10
%641 = load i32, i32* %3
%642 = load i32, i32* %2
%643 = mul i32 %641, %642
%644 = load i32, i32* %2
%645 = mul i32 %643, %644
%646 = load i32, i32* %4
%647 = load i32, i32* %2
%648 = mul i32 %646, %647
%649 = add i32 %645, %648
%650 = load i32, i32* %5
%651 = add i32 %649, %650
%652 = zext i32 %651 to i64
%653 = getelementptr inbounds float, float* %640, i64 %652
store float %639, float* %653
br label %654
654: ; preds = %168
%655 = load i32, i32* %5
%656 = add nsw i32 %655, 1
store i32 %656, i32* %5
br label %163
657: ; preds = %163
br label %658
658: ; preds = %657
%659 = load i32, i32* %4
%660 = add nsw i32 %659, 1
store i32 %660, i32* %4
br label %157
661: ; preds = %157
br label %662
662: ; preds = %661
%663 = load i32, i32* %3
%664 = add nsw i32 %663, 1
store i32 %664, i32* %3
br label %151
665: ; preds = %151
store i32 1, i32* %3
br label %666
666: ; preds = %721, %665
%667 = load i32, i32* %3
%668 = load i32, i32* %7
%669 = add nsw i32 %668, 1
%670 = icmp slt i32 %667, %669
br i1 %670, label %671, label %724
671: ; preds = %666
store i32 1, i32* %4
br label %672
672: ; preds = %717, %671
%673 = load i32, i32* %4
%674 = load i32, i32* %7
%675 = add nsw i32 %674, 1
%676 = icmp slt i32 %673, %675
br i1 %676, label %677, label %720
677: ; preds = %672
store i32 1, i32* %5
br label %678
678: ; preds = %713, %677
%679 = load i32, i32* %5
%680 = load i32, i32* %7
%681 = add nsw i32 %680, 1
%682 = icmp slt i32 %679, %681
br i1 %682, label %683, label %716
683: ; preds = %678
%684 = load float*, float** %10
%685 = load i32, i32* %3
%686 = load i32, i32* %2
%687 = mul i32 %685, %686
%688 = load i32, i32* %2
%689 = mul i32 %687, %688
%690 = load i32, i32* %4
%691 = load i32, i32* %2
%692 = mul i32 %690, %691
%693 = add i32 %689, %692
%694 = load i32, i32* %5
%695 = add i32 %693, %694
%696 = zext i32 %695 to i64
%697 = getelementptr inbounds float, float* %684, i64 %696
%698 = load float, float* %697
%699 = load float*, float** %9
%700 = load i32, i32* %3
%701 = load i32, i32* %2
%702 = mul i32 %700, %701
%703 = load i32, i32* %2
%704 = mul i32 %702, %703
%705 = load i32, i32* %4
%706 = load i32, i32* %2
%707 = mul i32 %705, %706
%708 = add i32 %704, %707
%709 = load i32, i32* %5
%710 = add i32 %708, %709
%711 = zext i32 %710 to i64
%712 = getelementptr inbounds float, float* %699, i64 %711
store float %698, float* %712
br label %713
713: ; preds = %683
%714 = load i32, i32* %5
%715 = add nsw i32 %714, 1
store i32 %715, i32* %5
br label %678
716: ; preds = %678
br label %717
717: ; preds = %716
%718 = load i32, i32* %4
%719 = add nsw i32 %718, 1
store i32 %719, i32* %4
br label %672
720: ; preds = %672
br label %721
721: ; preds = %720
%722 = load i32, i32* %3
%723 = add nsw i32 %722, 1
store i32 %723, i32* %3
br label %666
724: ; preds = %666
br label %725
725: ; preds = %724
%726 = load i32, i32* %6
%727 = add nsw i32 %726, 1
store i32 %727, i32* %6
br label %147
728: ; preds = %147
%729 = load i32, i32* @CLOCK_MONOTONIC_RAW
%730 = call i32 @clock_gettime(i32 %729, %struct.timespec* %12)
%731 = getelementptr inbounds %struct.timespec, %struct.timespec* %11, i32 0, i32 0
%732 = load i32, i32* %731
%733 = getelementptr inbounds %struct.timespec, %struct.timespec* %12, i32 0, i32 0
%734 = load i32, i32* %733
%735 = call i32 @elapsed_time_hr(i32 %732, i32 %734, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%736 = load float*, float** %9
%737 = call i32 @free(float* %736)
%738 = load float*, float** %10
%739 = call i32 @free(float* %738)
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 - 27 point\00"
@str = [67 x i8] c"27-point Single Precision Stencil Error: Unable to allocate memory\00"
define void @float_stencil27(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, %527
%225 = phi i32 [ 0, %192 ], [ %528, %527 ]
br i1 %193, label %227, label %527
226: ; preds = %393
br i1 %193, label %395, label %527
227: ; preds = %224, %393
%228 = phi i32 [ %232, %393 ], [ 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 = %391, %227
%235 = phi i32 [ 1, %227 ], [ %239, %391 ]
%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 %237, %231
%246 = add i32 %240, %231
%247 = add i32 %237, %233
%248 = add i32 %240, %233
%249 = add i32 %242, %229
br label %250
250: ; preds = %234, %250
%251 = phi i64 [ 1, %234 ], [ %334, %250 ]
%252 = trunc i64 %251 to i32
%253 = add i32 %238, %252
%254 = zext i32 %253 to i64
%255 = getelementptr inbounds float, float* %8, i64 %254
%256 = load float, float* %255
%257 = add i32 %241, %252
%258 = zext i32 %257 to i64
%259 = getelementptr inbounds float, float* %8, i64 %258
%260 = load float, float* %259
%261 = fadd float %256, %260
%262 = add i32 %243, %252
%263 = zext i32 %262 to i64
%264 = getelementptr inbounds float, float* %8, i64 %263
%265 = load float, float* %264
%266 = fadd float %261, %265
%267 = add i32 %244, %252
%268 = zext i32 %267 to i64
%269 = getelementptr inbounds float, float* %8, i64 %268
%270 = load float, float* %269
%271 = fadd float %266, %270
%272 = add i32 %245, %252
%273 = zext i32 %272 to i64
%274 = getelementptr inbounds float, float* %8, i64 %273
%275 = load float, float* %274
%276 = fadd float %271, %275
%277 = add i32 %246, %252
%278 = zext i32 %277 to i64
%279 = getelementptr inbounds float, float* %8, i64 %278
%280 = load float, float* %279
%281 = fadd float %276, %280
%282 = add i32 %247, %252
%283 = zext i32 %282 to i64
%284 = getelementptr inbounds float, float* %8, i64 %283
%285 = load float, float* %284
%286 = fadd float %281, %285
%287 = add i32 %248, %252
%288 = zext i32 %287 to i64
%289 = getelementptr inbounds float, float* %8, i64 %288
%290 = load float, float* %289
%291 = fadd float %286, %290
%292 = trunc i64 %251 to i32
%293 = add i32 %292, -1
%294 = add i32 %293, %238
%295 = zext i32 %294 to i64
%296 = getelementptr inbounds float, float* %8, i64 %295
%297 = load float, float* %296
%298 = fadd float %291, %297
%299 = add i32 %293, %241
%300 = zext i32 %299 to i64
%301 = getelementptr inbounds float, float* %8, i64 %300
%302 = load float, float* %301
%303 = fadd float %298, %302
%304 = add i32 %293, %243
%305 = zext i32 %304 to i64
%306 = getelementptr inbounds float, float* %8, i64 %305
%307 = load float, float* %306
%308 = fadd float %303, %307
%309 = add i32 %293, %244
%310 = zext i32 %309 to i64
%311 = getelementptr inbounds float, float* %8, i64 %310
%312 = load float, float* %311
%313 = fadd float %308, %312
%314 = add i32 %293, %245
%315 = zext i32 %314 to i64
%316 = getelementptr inbounds float, float* %8, i64 %315
%317 = load float, float* %316
%318 = fadd float %313, %317
%319 = add i32 %293, %246
%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 %293, %247
%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 %293, %248
%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 nuw nsw i64 %251, 1
%335 = trunc i64 %334 to i32
%336 = add i32 %238, %335
%337 = zext i32 %336 to i64
%338 = getelementptr inbounds float, float* %8, i64 %337
%339 = load float, float* %338
%340 = fadd float %333, %339
%341 = add i32 %241, %335
%342 = zext i32 %341 to i64
%343 = getelementptr inbounds float, float* %8, i64 %342
%344 = load float, float* %343
%345 = fadd float %340, %344
%346 = add i32 %243, %335
%347 = zext i32 %346 to i64
%348 = getelementptr inbounds float, float* %8, i64 %347
%349 = load float, float* %348
%350 = fadd float %345, %349
%351 = add i32 %244, %335
%352 = zext i32 %351 to i64
%353 = getelementptr inbounds float, float* %8, i64 %352
%354 = load float, float* %353
%355 = fadd float %350, %354
%356 = add i32 %245, %335
%357 = zext i32 %356 to i64
%358 = getelementptr inbounds float, float* %8, i64 %357
%359 = load float, float* %358
%360 = fadd float %355, %359
%361 = add i32 %246, %335
%362 = zext i32 %361 to i64
%363 = getelementptr inbounds float, float* %8, i64 %362
%364 = load float, float* %363
%365 = fadd float %360, %364
%366 = add i32 %247, %335
%367 = zext i32 %366 to i64
%368 = getelementptr inbounds float, float* %8, i64 %367
%369 = load float, float* %368
%370 = fadd float %365, %369
%371 = add i32 %248, %335
%372 = zext i32 %371 to i64
%373 = getelementptr inbounds float, float* %8, i64 %372
%374 = load float, float* %373
%375 = fadd float %370, %374
%376 = add i32 %293, %249
%377 = zext i32 %376 to i64
%378 = getelementptr inbounds float, float* %8, i64 %377
%379 = load float, float* %378
%380 = fadd float %375, %379
%381 = add i32 %249, %335
%382 = zext i32 %381 to i64
%383 = getelementptr inbounds float, float* %8, i64 %382
%384 = load float, float* %383
%385 = fadd float %380, %384
%386 = fmul float %385, 0x3FA3B13B20000000
%387 = add i32 %249, %252
%388 = zext i32 %387 to i64
%389 = getelementptr inbounds float, float* %10, i64 %388
store float %386, float* %389
%390 = icmp eq i64 %334, %197
br i1 %390, label %391, label %250
391: ; preds = %250
%392 = icmp eq i32 %239, %194
br i1 %392, label %393, label %234
393: ; preds = %391
%394 = icmp eq i32 %232, %194
br i1 %394, label %226, label %227
395: ; preds = %226, %523
%396 = phi i32 [ %526, %523 ], [ 0, %226 ]
%397 = phi i32 [ %524, %523 ], [ 1, %226 ]
%398 = mul i32 %203, %396
%399 = add i32 %202, %398
%400 = mul i32 %397, %0
br label %401
401: ; preds = %519, %395
%402 = phi i32 [ %522, %519 ], [ 0, %395 ]
%403 = phi i32 [ %520, %519 ], [ 1, %395 ]
%404 = add i32 %403, %400
%405 = mul i32 %404, %0
br i1 %211, label %466, label %406
406: ; preds = %401
%407 = mul i32 %402, %0
%408 = add i32 %399, %407
%409 = xor i32 %408, -1
%410 = icmp ult i32 %409, %212
%411 = or i1 %410, %213
%412 = select i1 %411, i1 true, i1 %216
br i1 %412, label %466, label %413
413: ; preds = %406
br i1 %220, label %448, label %414
414: ; preds = %413, %414
%415 = phi i64 [ %445, %414 ], [ 0, %413 ]
%416 = phi i64 [ %446, %414 ], [ 0, %413 ]
%417 = trunc i64 %415 to i32
%418 = or i32 %417, 1
%419 = add i32 %405, %418
%420 = zext i32 %419 to i64
%421 = getelementptr inbounds float, float* %10, i64 %420
%422 = bitcast float* %421 to <4 x float>*
%423 = load <4 x float>, <4 x float>* %422
%424 = getelementptr inbounds float, float* %421, i64 4
%425 = bitcast float* %424 to <4 x float>*
%426 = load <4 x float>, <4 x float>* %425
%427 = getelementptr inbounds float, float* %8, i64 %420
%428 = bitcast float* %427 to <4 x float>*
store <4 x float> %423, <4 x float>* %428
%429 = getelementptr inbounds float, float* %427, i64 4
%430 = bitcast float* %429 to <4 x float>*
store <4 x float> %426, <4 x float>* %430
%431 = trunc i64 %415 to i32
%432 = or i32 %431, 9
%433 = add i32 %405, %432
%434 = zext i32 %433 to i64
%435 = getelementptr inbounds float, float* %10, i64 %434
%436 = bitcast float* %435 to <4 x float>*
%437 = load <4 x float>, <4 x float>* %436
%438 = getelementptr inbounds float, float* %435, i64 4
%439 = bitcast float* %438 to <4 x float>*
%440 = load <4 x float>, <4 x float>* %439
%441 = getelementptr inbounds float, float* %8, i64 %434
%442 = bitcast float* %441 to <4 x float>*
store <4 x float> %437, <4 x float>* %442
%443 = getelementptr inbounds float, float* %441, i64 4
%444 = bitcast float* %443 to <4 x float>*
store <4 x float> %440, <4 x float>* %444
%445 = add nuw i64 %415, 16
%446 = add i64 %416, 2
%447 = icmp eq i64 %446, %221
br i1 %447, label %448, label %414
448: ; preds = %414, %413
%449 = phi i64 [ 0, %413 ], [ %445, %414 ]
br i1 %222, label %465, label %450
450: ; preds = %448
%451 = trunc i64 %449 to i32
%452 = or i32 %451, 1
%453 = add i32 %405, %452
%454 = zext i32 %453 to i64
%455 = getelementptr inbounds float, float* %10, i64 %454
%456 = bitcast float* %455 to <4 x float>*
%457 = load <4 x float>, <4 x float>* %456
%458 = getelementptr inbounds float, float* %455, i64 4
%459 = bitcast float* %458 to <4 x float>*
%460 = load <4 x float>, <4 x float>* %459
%461 = getelementptr inbounds float, float* %8, i64 %454
%462 = bitcast float* %461 to <4 x float>*
store <4 x float> %457, <4 x float>* %462
%463 = getelementptr inbounds float, float* %461, i64 4
%464 = bitcast float* %463 to <4 x float>*
store <4 x float> %460, <4 x float>* %464
br label %465
465: ; preds = %448, %450
br i1 %223, label %519, label %466
466: ; preds = %406, %401, %465
%467 = phi i64 [ 1, %406 ], [ 1, %401 ], [ %218, %465 ]
%468 = sub nsw i64 %197, %467
%469 = xor i64 %467, -1
%470 = add nsw i64 %469, %197
%471 = and i64 %468, 3
%472 = icmp eq i64 %471, 0
br i1 %472, label %485, label %473
473: ; preds = %466, %473
%474 = phi i64 [ %482, %473 ], [ %467, %466 ]
%475 = phi i64 [ %483, %473 ], [ 0, %466 ]
%476 = trunc i64 %474 to i32
%477 = add i32 %405, %476
%478 = zext i32 %477 to i64
%479 = getelementptr inbounds float, float* %10, i64 %478
%480 = load float, float* %479
%481 = getelementptr inbounds float, float* %8, i64 %478
store float %480, float* %481
%482 = add nuw nsw i64 %474, 1
%483 = add i64 %475, 1
%484 = icmp eq i64 %483, %471
br i1 %484, label %485, label %473
485: ; preds = %473, %466
%486 = phi i64 [ %467, %466 ], [ %482, %473 ]
%487 = icmp ult i64 %470, 3
br i1 %487, label %519, label %488
488: ; preds = %485, %488
%489 = phi i64 [ %517, %488 ], [ %486, %485 ]
%490 = trunc i64 %489 to i32
%491 = add i32 %405, %490
%492 = zext i32 %491 to i64
%493 = getelementptr inbounds float, float* %10, i64 %492
%494 = load float, float* %493
%495 = getelementptr inbounds float, float* %8, i64 %492
store float %494, float* %495
%496 = trunc i64 %489 to i32
%497 = add i32 %496, 1
%498 = add i32 %405, %497
%499 = zext i32 %498 to i64
%500 = getelementptr inbounds float, float* %10, i64 %499
%501 = load float, float* %500
%502 = getelementptr inbounds float, float* %8, i64 %499
store float %501, float* %502
%503 = trunc i64 %489 to i32
%504 = add i32 %503, 2
%505 = add i32 %405, %504
%506 = zext i32 %505 to i64
%507 = getelementptr inbounds float, float* %10, i64 %506
%508 = load float, float* %507
%509 = getelementptr inbounds float, float* %8, i64 %506
store float %508, float* %509
%510 = trunc i64 %489 to i32
%511 = add i32 %510, 3
%512 = add i32 %405, %511
%513 = zext i32 %512 to i64
%514 = getelementptr inbounds float, float* %10, i64 %513
%515 = load float, float* %514
%516 = getelementptr inbounds float, float* %8, i64 %513
store float %515, float* %516
%517 = add nuw nsw i64 %489, 4
%518 = icmp eq i64 %517, %198
br i1 %518, label %519, label %488
519: ; preds = %485, %488, %465
%520 = add nuw nsw i32 %403, 1
%521 = icmp eq i32 %520, %194
%522 = add i32 %402, 1
br i1 %521, label %523, label %401
523: ; preds = %519
%524 = add nuw nsw i32 %397, 1
%525 = icmp eq i32 %524, %194
%526 = add i32 %396, 1
br i1 %525, label %527, label %395
527: ; preds = %523, %224, %226
%528 = add nuw nsw i32 %225, 1
%529 = icmp eq i32 %528, 100
br i1 %529, label %530, label %224
530: ; preds = %527
%531 = load i32, i32* @CLOCK_MONOTONIC_RAW
%532 = call i32 @clock_gettime(i32 %531, %struct.timespec* %3)
%533 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 0, i32 0
%534 = load i32, i32* %533
%535 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 0
%536 = load i32, i32* %535
%537 = call i32 @elapsed_time_hr(i32 %534, i32 %536, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%538 = call i32 @free(float* %8)
%539 = call i32 @free(float* %10)
ret void
}