#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 /*<<< orphan*/ printf(char *);
scalar_t__ rand();
int /*<<< orphan*/ rapl_deinit();
int /*<<< orphan*/ rapl_end();
int /*<<< orphan*/ rapl_init();
int /*<<< orphan*/ rapl_start();
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");
  }
  struct timespec start, end;
  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;
      }
    }
  }
  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);
      }
    }
  }
  rapl_init();
  rapl_start();
  clock_gettime(CLOCK_MONOTONIC_RAW, &start);
  for (iter = 0; iter < 100; iter++) {
    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;
        }
      }
    }
    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);
  rapl_end();
  rapl_deinit();
  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  0xe44(%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   1080 <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   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     1217 <float_stencil27+0x77>
cmpq   $0x0,-0x30(%rbp)
jne    1223 <float_stencil27+0x83>
lea    0xdf2(%rip),%rdi
call   1060 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12b5 <float_stencil27+0x115>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12a2 <float_stencil27+0x102>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    128f <float_stencil27+0xef>
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    1250 <float_stencil27+0xb0>
jmp    1294 <float_stencil27+0xf4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    123d <float_stencil27+0x9d>
jmp    12a7 <float_stencil27+0x107>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    122a <float_stencil27+0x8a>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    137f <float_stencil27+0x1df>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    136c <float_stencil27+0x1cc>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1359 <float_stencil27+0x1b9>
mov    $0x0,%al
call   10c0 <rand@plt>
cvtsi2ss %rax,%xmm0
mov    0x2cd8(%rip),%rax
cvtsi2sdq (%rax),%xmm2
movsd  0xceb(%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    12ec <float_stencil27+0x14c>
jmp    135e <float_stencil27+0x1be>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12d4 <float_stencil27+0x134>
jmp    1371 <float_stencil27+0x1d1>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12bc <float_stencil27+0x11c>
mov    $0x0,%al
call   10a0 <rapl_init@plt>
mov    $0x0,%al
call   1070 <rapl_start@plt>
mov    0x2c4c(%rip),%rax
mov    (%rax),%edi
lea    -0x38(%rbp),%rsi
call   1050 <clock_gettime@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    1960 <float_stencil27+0x7c0>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    188d <float_stencil27+0x6ed>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    187a <float_stencil27+0x6da>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1867 <float_stencil27+0x6c7>
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    13e7 <float_stencil27+0x247>
jmp    186c <float_stencil27+0x6cc>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13cf <float_stencil27+0x22f>
jmp    187f <float_stencil27+0x6df>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13b7 <float_stencil27+0x217>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    194d <float_stencil27+0x7ad>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    193a <float_stencil27+0x79a>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1927 <float_stencil27+0x787>
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    18c4 <float_stencil27+0x724>
jmp    192c <float_stencil27+0x78c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    18ac <float_stencil27+0x70c>
jmp    193f <float_stencil27+0x79f>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1894 <float_stencil27+0x6f4>
jmp    1952 <float_stencil27+0x7b2>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13a6 <float_stencil27+0x206>
mov    0x2679(%rip),%rax
mov    (%rax),%edi
lea    -0x40(%rbp),%rsi
call   1050 <clock_gettime@plt>
mov    $0x0,%al
call   1090 <rapl_end@plt>
mov    $0x0,%al
call   10b0 <rapl_deinit@plt>
mov    -0x38(%rbp),%edi
mov    -0x40(%rbp),%esi
lea    0x6c7(%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   1080 <malloc@plt>
mov    %rax,%rbx
mov    %r14d,%edi
call   1080 <malloc@plt>
mov    %rbx,0x8(%rsp)
test   %rbx,%rbx
mov    %rax,0x50(%rsp)
je     11ef <float_stencil27+0x4f>
test   %rax,%rax
jne    11fb <float_stencil27+0x5b>
lea    0xe3a(%rip),%rdi
call   1050 <puts@plt>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
xor    %ecx,%ecx
mov    0x30(%rsp),%r8
mov    %r8d,%esi
test   %r8d,%r8d
mov    %r13,0x48(%rsp)
mov    %rsi,0x38(%rsp)
je     14dc <float_stencil27+0x33c>
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,0x18(%rsp)
mov    %esi,%r9d
and    $0x3,%r9d
mov    $0x10,%r10d
xorps  %xmm0,%xmm0
xor    %eax,%eax
jmp    1286 <float_stencil27+0xe6>
mov    0x28(%rsp),%rcx
add    $0x1,%ecx
mov    0x48(%rsp),%r13
mov    0x10(%rsp),%r10d
add    %r13d,%r10d
mov    0x20(%rsp),%rax
add    %r13,%rax
cmp    %r8d,%ecx
je     140a <float_stencil27+0x26a>
mov    %rcx,0x28(%rsp)
imul   %ecx,%r13d
mov    %rax,%rcx
xor    %edi,%edi
mov    %rax,0x20(%rsp)
mov    %r10d,0x10(%rsp)
jmp    12ae <float_stencil27+0x10e>
add    $0x1,%edi
add    %r8d,%r10d
add    %rsi,%rcx
cmp    %r8d,%edi
je     1260 <float_stencil27+0xc0>
cmp    $0x8,%r8d
jae    12f0 <float_stencil27+0x150>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %rsi,%rax
test   %r9,%r9
je     1320 <float_stencil27+0x180>
mov    %r9,%rsi
mov    0x8(%rsp),%rbx
nopl   0x0(%rax)
lea    (%rcx,%rbp,1),%edx
movl   $0x0,(%rbx,%rdx,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rsi
jne    12d0 <float_stencil27+0x130>
jmp    1325 <float_stencil27+0x185>
cs nopw 0x0(%rax,%rax,1)
mov    %edi,%eax
imul   %r8d,%eax
add    %r13d,%eax
add    %r14d,%eax
jb     12b4 <float_stencil27+0x114>
mov    %r14,%rax
shr    $0x20,%rax
mov    $0x0,%ebp
jne    12b6 <float_stencil27+0x116>
cmp    $0x18,%r11
jae    1379 <float_stencil27+0x1d9>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
jmp    13d1 <float_stencil27+0x231>
xchg   %ax,%ax
mov    0x8(%rsp),%rbx
cmp    $0x3,%rax
mov    0x38(%rsp),%rsi
jb     12a0 <float_stencil27+0x100>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    1340 <float_stencil27+0x1a0>
jmp    12a0 <float_stencil27+0x100>
mov    0x18(%rsp),%rax
mov    %r10d,%r8d
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
lea    -0x10(%r8),%esi
movups %xmm0,(%rdx,%rsi,4)
movups %xmm0,0x10(%rdx,%rsi,4)
lea    -0x8(%r8),%esi
movups %xmm0,(%rdx,%rsi,4)
movups %xmm0,0x10(%rdx,%rsi,4)
mov    %r8d,%esi
movups %xmm0,(%rdx,%rsi,4)
movups %xmm0,0x10(%rdx,%rsi,4)
lea    0x8(%r8),%esi
movups %xmm0,(%rdx,%rsi,4)
movups %xmm0,0x10(%rdx,%rsi,4)
add    $0x20,%rbp
add    $0x20,%r8d
add    $0xfffffffffffffffc,%rax
jne    1390 <float_stencil27+0x1f0>
test   %r15,%r15
mov    0x30(%rsp),%r8
je     13f4 <float_stencil27+0x254>
add    %ecx,%ebp
mov    %r15,%rax
mov    %ebp,%esi
movups %xmm0,(%rdx,%rsi,4)
movups %xmm0,0x10(%rdx,%rsi,4)
add    $0x8,%ebp
add    $0xffffffffffffffff,%rax
jne    13e0 <float_stencil27+0x240>
mov    %r12,%rbp
mov    0x38(%rsp),%rsi
cmp    %rsi,%r12
je     12a0 <float_stencil27+0x100>
jmp    12b6 <float_stencil27+0x116>
lea    -0x1(%r8),%ebx
cmp    $0x2,%ebx
setge  %al
jl     14ea <float_stencil27+0x34a>
mov    %rax,0x28(%rsp)
mov    %ebx,%eax
lea    0x1(%r8),%r14d
imul   %r8d,%r14d
add    $0x1,%r14d
add    $0xffffffffffffffff,%rax
mov    %rax,0x10(%rsp)
mov    $0x1,%eax
mov    0x2ba6(%rip),%r15
mov    %ebx,0x18(%rsp)
mov    0x8(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
mov    %eax,0x40(%rsp)
mov    %r14d,0x20(%rsp)
mov    $0x1,%r12d
nop
mov    0x10(%rsp),%r13
mov    %r14d,%ebx
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10c0 <rand@plt>
movsd  0xb81(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdq (%r15),%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
divss  %xmm1,%xmm0
mov    %ebx,%eax
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x1,%ebx
add    $0xffffffffffffffff,%r13
jne    1470 <float_stencil27+0x2d0>
add    $0x1,%r12d
add    0x30(%rsp),%r14d
mov    0x18(%rsp),%ebx
cmp    %ebx,%r12d
jne    1460 <float_stencil27+0x2c0>
mov    0x40(%rsp),%eax
add    $0x1,%eax
mov    0x48(%rsp),%r13
mov    0x20(%rsp),%r14d
add    %r13d,%r14d
cmp    %ebx,%eax
jne    1450 <float_stencil27+0x2b0>
jmp    14f1 <float_stencil27+0x351>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    $0xffffffff,%ebx
jmp    14f1 <float_stencil27+0x351>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
xor    %ebp,%ebp
xor    %eax,%eax
call   10a0 <rapl_init@plt>
xor    %eax,%eax
call   1070 <rapl_start@plt>
mov    0x2ad8(%rip),%rax
mov    (%rax),%edi
lea    0x68(%rsp),%rsi
call   1060 <clock_gettime@plt>
mov    %ebx,%esi
lea    -0x2(%rsi),%rax
mov    %rax,0x130(%rsp)
mov    0x30(%rsp),%r10
lea    0x1(%r10),%r8d
imul   %r10d,%r8d
lea    0x1(%r8),%eax
mov    %eax,0x74(%rsp)
lea    -0x1(%rsi),%r11
mov    0x8(%rsp),%rbx
lea    -0x4(%rbx,%rsi,4),%r9
mov    0x50(%rsp),%rdi
lea    -0x4(%rdi,%rsi,4),%rcx
lea    -0x9(%rsi),%rax
mov    %rax,0x128(%rsp)
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
cmp    %rbx,%rcx
seta   %cl
cmp    %rdi,%r9
seta   %al
and    %cl,%al
mov    %al,0x7(%rsp)
mov    %rsi,%rcx
mov    %r11,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x118(%rsp)
add    $0x1,%rax
mov    %rax,0x110(%rsp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
add    $0x2,%rax
mov    %rdx,%rsi
mov    %rdx,0x120(%rsp)
and    %rdx,%rax
mov    %rax,0x108(%rsp)
lea    0x2(%r10),%eax
imul   %r10d,%eax
mov    %rax,0xb0(%rsp)
lea    (%r10,%r10,1),%eax
add    $0x1,%eax
imul   %r10d,%eax
mov    %rax,0xa8(%rsp)
lea    (%r10,%r10,1),%eax
add    $0x2,%eax
imul   %r10d,%eax
mov    %rax,0xa0(%rsp)
mov    $0x1,%edx
sub    %rcx,%rdx
mov    %r8,0x80(%rsp)
mov    %r8d,%eax
add    $0x9,%eax
mov    %eax,0x70(%rsp)
movss  0x9f6(%rip),%xmm0
lea    (%r10,%r10,1),%eax
mov    %rax,0x98(%rsp)
lea    0x0(%r13,%r13,1),%eax
mov    %rax,0x90(%rsp)
mov    %rcx,0x58(%rsp)
mov    %r11,0x88(%rsp)
mov    %rdx,0x138(%rsp)
jmp    1664 <float_stencil27+0x4c4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xb8(%rsp),%rbp
add    $0x1,%ebp
cmp    $0x64,%ebp
je     1bc5 <float_stencil27+0xa25>
mov    %rbp,0xb8(%rsp)
cmpb   $0x0,0x28(%rsp)
je     1650 <float_stencil27+0x4b0>
mov    $0x1,%r10d
mov    0x80(%rsp),%r12
mov    0xa0(%rsp),%rsi
mov    0x90(%rsp),%r9
mov    0x98(%rsp),%rax
xor    %r11d,%r11d
mov    0xa8(%rsp),%rdi
mov    0x38(%rsp),%r8
mov    0xb0(%rsp),%rbx
mov    %r13,%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r10d
mov    %r10d,0x78(%rsp)
mov    %r12,0x100(%rsp)
mov    %rsi,0xf8(%rsp)
mov    %rsi,0x10(%rsp)
mov    %r9,0xf0(%rsp)
mov    %r9,%r13
mov    %rax,0xe8(%rsp)
mov    %r11,0xe0(%rsp)
mov    %r11,%r10
mov    %rdi,0xd8(%rsp)
mov    %rdi,%r11
mov    %r8,0xd0(%rsp)
mov    %r8,%rdi
mov    %rax,%r8
mov    %rbx,0xc8(%rsp)
mov    %rbx,%rsi
mov    %r15,0xc0(%rsp)
mov    %r15,%rcx
mov    $0x1,%eax
add    $0x1,%eax
mov    %eax,0x7c(%rsp)
xor    %ebp,%ebp
mov    0x8(%rsp),%rbx
mov    %r10,0x20(%rsp)
mov    %r12,0x40(%rsp)
mov    %r13,0x150(%rsp)
mov    %rsi,0x148(%rsp)
mov    %rdi,0x18(%rsp)
mov    %r11,0x140(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rcx,%rbp,1),%rdi
lea    0x1(%rdi),%eax
movss  (%rbx,%rax,4),%xmm1
lea    (%rsi,%rbp,1),%rax
lea    0x1(%rax),%esi
addss  (%rbx,%rsi,4),%xmm1
mov    0x18(%rsp),%rdx
lea    (%rdx,%rbp,1),%r9
lea    0x1(%r9),%esi
addss  (%rbx,%rsi,4),%xmm1
lea    (%r11,%rbp,1),%r14
lea    0x1(%r14),%esi
addss  (%rbx,%rsi,4),%xmm1
lea    (%r10,%rbp,1),%rsi
lea    0x1(%rsi),%edx
addss  (%rbx,%rdx,4),%xmm1
mov    %r8,%r10
lea    (%r8,%rbp,1),%r8
lea    0x1(%r8),%edx
addss  (%rbx,%rdx,4),%xmm1
lea    0x0(%r13,%rbp,1),%r12
lea    0x1(%r12),%edx
addss  (%rbx,%rdx,4),%xmm1
mov    0x10(%rsp),%rdx
lea    (%rdx,%rbp,1),%r13
lea    0x1(%r13),%edx
addss  (%rbx,%rdx,4),%xmm1
mov    %edi,%edx
addss  (%rbx,%rdx,4),%xmm1
mov    %eax,%edx
addss  (%rbx,%rdx,4),%xmm1
mov    %r9d,%edx
addss  (%rbx,%rdx,4),%xmm1
mov    %r14d,%edx
addss  (%rbx,%rdx,4),%xmm1
mov    %esi,%edx
addss  (%rbx,%rdx,4),%xmm1
mov    %r8d,%edx
addss  (%rbx,%rdx,4),%xmm1
mov    %r12d,%edx
addss  (%rbx,%rdx,4),%xmm1
mov    %r13d,%edx
addss  (%rbx,%rdx,4),%xmm1
add    $0x2,%edi
addss  (%rbx,%rdi,4),%xmm1
mov    0x50(%rsp),%r15
add    $0x2,%eax
addss  (%rbx,%rax,4),%xmm1
add    $0x2,%r9d
addss  (%rbx,%r9,4),%xmm1
mov    0x18(%rsp),%rdi
add    $0x2,%r14d
addss  (%rbx,%r14,4),%xmm1
add    $0x2,%esi
addss  (%rbx,%rsi,4),%xmm1
mov    0x148(%rsp),%rsi
add    $0x2,%r8d
addss  (%rbx,%r8,4),%xmm1
mov    %r10,%r8
mov    0x20(%rsp),%r10
add    $0x2,%r12d
addss  (%rbx,%r12,4),%xmm1
add    $0x2,%r13d
addss  (%rbx,%r13,4),%xmm1
mov    0x140(%rsp),%r11
mov    0x150(%rsp),%r13
mov    0x40(%rsp),%r12
lea    (%r12,%rbp,1),%rax
mov    %eax,%edx
addss  (%rbx,%rdx,4),%xmm1
lea    0x2(%rax),%edx
addss  (%rbx,%rdx,4),%xmm1
mov    0x138(%rsp),%rdx
mulss  %xmm0,%xmm1
add    $0x1,%eax
movss  %xmm1,(%r15,%rax,4)
add    $0x1,%rbp
mov    %rdx,%rax
add    %rbp,%rax
jne    1770 <float_stencil27+0x5d0>
mov    0x38(%rsp),%rax
add    %rax,%rcx
add    %rax,%rsi
add    %rax,%rdi
add    %rax,%r11
add    %rax,%r10
add    %rax,%r8
add    %rax,%r13
add    %rax,0x10(%rsp)
add    %rax,%r12
mov    0x7c(%rsp),%eax
cmp    0x58(%rsp),%eax
jne    1730 <float_stencil27+0x590>
mov    %r15,%r14
mov    0x48(%rsp),%r13
mov    0xc0(%rsp),%r15
add    %r13,%r15
mov    0xc8(%rsp),%rbx
add    %r13,%rbx
mov    0xd0(%rsp),%r8
add    %r13,%r8
mov    0xd8(%rsp),%rdi
add    %r13,%rdi
mov    0xe0(%rsp),%r11
add    %r13,%r11
mov    0xe8(%rsp),%rax
add    %r13,%rax
mov    0xf0(%rsp),%r9
add    %r13,%r9
mov    0xf8(%rsp),%rsi
add    %r13,%rsi
mov    0x100(%rsp),%r12
add    %r13,%r12
mov    0x58(%rsp),%rcx
mov    0x78(%rsp),%r10d
cmp    %ecx,%r10d
jne    16c0 <float_stencil27+0x520>
cmpb   $0x0,0x28(%rsp)
mov    0x30(%rsp),%r8
mov    0x88(%rsp),%r11
mov    %r14,%rdi
mov    0x8(%rsp),%rbx
je     1650 <float_stencil27+0x4b0>
mov    $0x1,%eax
xor    %esi,%esi
mov    0x80(%rsp),%rbp
mov    0x70(%rsp),%r9d
jmp    19eb <float_stencil27+0x84b>
cs nopw 0x0(%rax,%rax,1)
mov    0x18(%rsp),%eax
add    $0x1,%eax
mov    0x10(%rsp),%esi
add    $0x1,%esi
mov    0x48(%rsp),%r13
mov    0x40(%rsp),%r9d
add    %r13d,%r9d
mov    0x20(%rsp),%rbp
add    %r13,%rbp
cmp    %ecx,%eax
je     1650 <float_stencil27+0x4b0>
mov    %esi,0x10(%rsp)
imul   %esi,%r13d
add    0x74(%rsp),%r13d
mov    %eax,0x18(%rsp)
mov    %eax,%r12d
imul   %r8d,%r12d
mov    %rbp,0x20(%rsp)
mov    %rbp,%rsi
mov    %r9d,0x40(%rsp)
xor    %r14d,%r14d
mov    $0x1,%r10d
jmp    1a35 <float_stencil27+0x895>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10d
add    $0x1,%r14d
add    %r8d,%r9d
add    0x38(%rsp),%rsi
cmp    %ecx,%r10d
je     19c0 <float_stencil27+0x820>
mov    $0x1,%ebp
cmp    $0x8,%r11
jb     1b30 <float_stencil27+0x990>
mov    0x130(%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     0x7(%rsp),%dl
jne    1b30 <float_stencil27+0x990>
cmpq   $0x8,0x128(%rsp)
jae    1a8e <float_stencil27+0x8ee>
xor    %eax,%eax
mov    0x50(%rsp),%r8
jmp    1adc <float_stencil27+0x93c>
mov    0x108(%rsp),%rdx
mov    %r9d,%ebp
xor    %eax,%eax
mov    0x50(%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    1aa0 <float_stencil27+0x900>
testb  $0x1,0x120(%rsp)
01
mov    %r8,%rdi
mov    0x30(%rsp),%r8
je     1b0f <float_stencil27+0x96f>
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    0x110(%rsp),%rbp
cmp    0x118(%rsp),%r11
je     1a20 <float_stencil27+0x880>
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     1b67 <float_stencil27+0x9c7>
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    1b50 <float_stencil27+0x9b0>
cmp    $0x3,%rax
mov    %rcx,%rdi
mov    0x58(%rsp),%rcx
jb     1a20 <float_stencil27+0x880>
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    1b80 <float_stencil27+0x9e0>
jmp    1a20 <float_stencil27+0x880>
mov    %rdi,%rbp
mov    0x2411(%rip),%rax
mov    (%rax),%edi
lea    0x60(%rsp),%rsi
call   1060 <clock_gettime@plt>
xor    %eax,%eax
call   1090 <rapl_end@plt>
xor    %eax,%eax
call   10b0 <rapl_deinit@plt>
mov    0x68(%rsp),%edi
mov    0x60(%rsp),%esi
lea    0x414(%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"
@RAND_MAX = global i64 0
@CLOCK_MONOTONIC_RAW = global i32 0
@.str.1 = [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 @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str, i64 0, i64 0))
br label %46
46: ; preds = %44, %41
store i32 0, i32* %3
br label %47
47: ; preds = %84, %46
%48 = load i32, i32* %3
%49 = load i32, i32* %2
%50 = icmp ult i32 %48, %49
br i1 %50, label %51, label %87
51: ; preds = %47
store i32 0, i32* %4
br label %52
52: ; preds = %80, %51
%53 = load i32, i32* %4
%54 = load i32, i32* %2
%55 = icmp ult i32 %53, %54
br i1 %55, label %56, label %83
56: ; preds = %52
store i32 0, i32* %5
br label %57
57: ; preds = %76, %56
%58 = load i32, i32* %5
%59 = load i32, i32* %2
%60 = icmp ult i32 %58, %59
br i1 %60, label %61, label %79
61: ; preds = %57
%62 = load float*, float** %9
%63 = load i32, i32* %3
%64 = load i32, i32* %2
%65 = mul i32 %63, %64
%66 = load i32, i32* %2
%67 = mul i32 %65, %66
%68 = load i32, i32* %4
%69 = load i32, i32* %2
%70 = mul i32 %68, %69
%71 = add i32 %67, %70
%72 = load i32, i32* %5
%73 = add i32 %71, %72
%74 = zext i32 %73 to i64
%75 = getelementptr inbounds float, float* %62, i64 %74
store float 0.000000e+00, float* %75
br label %76
76: ; preds = %61
%77 = load i32, i32* %5
%78 = add nsw i32 %77, 1
store i32 %78, i32* %5
br label %57
79: ; preds = %57
br label %80
80: ; preds = %79
%81 = load i32, i32* %4
%82 = add nsw i32 %81, 1
store i32 %82, i32* %4
br label %52
83: ; preds = %52
br label %84
84: ; preds = %83
%85 = load i32, i32* %3
%86 = add nsw i32 %85, 1
store i32 %86, i32* %3
br label %47
87: ; preds = %47
store i32 1, i32* %3
br label %88
88: ; preds = %135, %87
%89 = load i32, i32* %3
%90 = load i32, i32* %7
%91 = add nsw i32 %90, 1
%92 = icmp slt i32 %89, %91
br i1 %92, label %93, label %138
93: ; preds = %88
store i32 1, i32* %4
br label %94
94: ; preds = %131, %93
%95 = load i32, i32* %4
%96 = load i32, i32* %7
%97 = add nsw i32 %96, 1
%98 = icmp slt i32 %95, %97
br i1 %98, label %99, label %134
99: ; preds = %94
store i32 1, i32* %5
br label %100
100: ; preds = %127, %99
%101 = load i32, i32* %5
%102 = load i32, i32* %7
%103 = add nsw i32 %102, 1
%104 = icmp slt i32 %101, %103
br i1 %104, label %105, label %130
105: ; preds = %100
%106 = call i64 (...) @rand()
%107 = sitofp i64 %106 to float
%108 = load i64, i64* @RAND_MAX
%109 = sitofp i64 %108 to double
%110 = fadd double 1.000000e+00, %109
%111 = fptrunc double %110 to float
%112 = fdiv float %107, %111
%113 = load float*, float** %9
%114 = load i32, i32* %3
%115 = load i32, i32* %2
%116 = mul i32 %114, %115
%117 = load i32, i32* %2
%118 = mul i32 %116, %117
%119 = load i32, i32* %4
%120 = load i32, i32* %2
%121 = mul i32 %119, %120
%122 = add i32 %118, %121
%123 = load i32, i32* %5
%124 = add i32 %122, %123
%125 = zext i32 %124 to i64
%126 = getelementptr inbounds float, float* %113, i64 %125
store float %112, float* %126
br label %127
127: ; preds = %105
%128 = load i32, i32* %5
%129 = add nsw i32 %128, 1
store i32 %129, i32* %5
br label %100
130: ; preds = %100
br label %131
131: ; preds = %130
%132 = load i32, i32* %4
%133 = add nsw i32 %132, 1
store i32 %133, i32* %4
br label %94
134: ; preds = %94
br label %135
135: ; preds = %134
%136 = load i32, i32* %3
%137 = add nsw i32 %136, 1
store i32 %137, i32* %3
br label %88
138: ; preds = %88
%139 = call i32 (...) @rapl_init()
%140 = call i32 (...) @rapl_start()
%141 = load i32, i32* @CLOCK_MONOTONIC_RAW
%142 = call i32 @clock_gettime(i32 %141, %struct.timespec* %11)
store i32 0, i32* %6
br label %143
143: ; preds = %721, %138
%144 = load i32, i32* %6
%145 = icmp slt i32 %144, 100
br i1 %145, label %146, label %724
146: ; preds = %143
store i32 1, i32* %3
br label %147
147: ; preds = %658, %146
%148 = load i32, i32* %3
%149 = load i32, i32* %7
%150 = add nsw i32 %149, 1
%151 = icmp slt i32 %148, %150
br i1 %151, label %152, label %661
152: ; preds = %147
store i32 1, i32* %4
br label %153
153: ; preds = %654, %152
%154 = load i32, i32* %4
%155 = load i32, i32* %7
%156 = add nsw i32 %155, 1
%157 = icmp slt i32 %154, %156
br i1 %157, label %158, label %657
158: ; preds = %153
store i32 1, i32* %5
br label %159
159: ; preds = %650, %158
%160 = load i32, i32* %5
%161 = load i32, i32* %7
%162 = add nsw i32 %161, 1
%163 = icmp slt i32 %160, %162
br i1 %163, label %164, label %653
164: ; preds = %159
%165 = load float*, float** %9
%166 = load i32, i32* %3
%167 = load i32, i32* %2
%168 = mul i32 %166, %167
%169 = load i32, i32* %2
%170 = mul i32 %168, %169
%171 = load i32, i32* %4
%172 = sub nsw i32 %171, 1
%173 = load i32, i32* %2
%174 = mul i32 %172, %173
%175 = add i32 %170, %174
%176 = load i32, i32* %5
%177 = add i32 %175, %176
%178 = zext i32 %177 to i64
%179 = getelementptr inbounds float, float* %165, i64 %178
%180 = load float, float* %179
%181 = load float*, float** %9
%182 = load i32, i32* %3
%183 = load i32, i32* %2
%184 = mul i32 %182, %183
%185 = load i32, i32* %2
%186 = mul i32 %184, %185
%187 = load i32, i32* %4
%188 = add nsw i32 %187, 1
%189 = load i32, i32* %2
%190 = mul i32 %188, %189
%191 = add i32 %186, %190
%192 = load i32, i32* %5
%193 = add i32 %191, %192
%194 = zext i32 %193 to i64
%195 = getelementptr inbounds float, float* %181, i64 %194
%196 = load float, float* %195
%197 = fadd float %180, %196
%198 = load float*, float** %9
%199 = load i32, i32* %3
%200 = sub nsw i32 %199, 1
%201 = load i32, i32* %2
%202 = mul i32 %200, %201
%203 = load i32, i32* %2
%204 = mul i32 %202, %203
%205 = load i32, i32* %4
%206 = load i32, i32* %2
%207 = mul i32 %205, %206
%208 = add i32 %204, %207
%209 = load i32, i32* %5
%210 = add i32 %208, %209
%211 = zext i32 %210 to i64
%212 = getelementptr inbounds float, float* %198, i64 %211
%213 = load float, float* %212
%214 = fadd float %197, %213
%215 = load float*, float** %9
%216 = load i32, i32* %3
%217 = add nsw i32 %216, 1
%218 = load i32, i32* %2
%219 = mul i32 %217, %218
%220 = load i32, i32* %2
%221 = mul i32 %219, %220
%222 = load i32, i32* %4
%223 = load i32, i32* %2
%224 = mul i32 %222, %223
%225 = add i32 %221, %224
%226 = load i32, i32* %5
%227 = add i32 %225, %226
%228 = zext i32 %227 to i64
%229 = getelementptr inbounds float, float* %215, i64 %228
%230 = load float, float* %229
%231 = fadd float %214, %230
%232 = load float*, float** %9
%233 = load i32, i32* %3
%234 = sub nsw i32 %233, 1
%235 = load i32, i32* %2
%236 = mul i32 %234, %235
%237 = load i32, i32* %2
%238 = mul i32 %236, %237
%239 = load i32, i32* %4
%240 = sub nsw i32 %239, 1
%241 = load i32, i32* %2
%242 = mul i32 %240, %241
%243 = add i32 %238, %242
%244 = load i32, i32* %5
%245 = add i32 %243, %244
%246 = zext i32 %245 to i64
%247 = getelementptr inbounds float, float* %232, i64 %246
%248 = load float, float* %247
%249 = fadd float %231, %248
%250 = load float*, float** %9
%251 = load i32, i32* %3
%252 = sub nsw i32 %251, 1
%253 = load i32, i32* %2
%254 = mul i32 %252, %253
%255 = load i32, i32* %2
%256 = mul i32 %254, %255
%257 = load i32, i32* %4
%258 = add nsw i32 %257, 1
%259 = load i32, i32* %2
%260 = mul i32 %258, %259
%261 = add i32 %256, %260
%262 = load i32, i32* %5
%263 = add i32 %261, %262
%264 = zext i32 %263 to i64
%265 = getelementptr inbounds float, float* %250, i64 %264
%266 = load float, float* %265
%267 = fadd float %249, %266
%268 = load float*, float** %9
%269 = load i32, i32* %3
%270 = add nsw i32 %269, 1
%271 = load i32, i32* %2
%272 = mul i32 %270, %271
%273 = load i32, i32* %2
%274 = mul i32 %272, %273
%275 = load i32, i32* %4
%276 = sub nsw i32 %275, 1
%277 = load i32, i32* %2
%278 = mul i32 %276, %277
%279 = add i32 %274, %278
%280 = load i32, i32* %5
%281 = add i32 %279, %280
%282 = zext i32 %281 to i64
%283 = getelementptr inbounds float, float* %268, i64 %282
%284 = load float, float* %283
%285 = fadd float %267, %284
%286 = load float*, float** %9
%287 = load i32, i32* %3
%288 = add nsw i32 %287, 1
%289 = load i32, i32* %2
%290 = mul i32 %288, %289
%291 = load i32, i32* %2
%292 = mul i32 %290, %291
%293 = load i32, i32* %4
%294 = add nsw i32 %293, 1
%295 = load i32, i32* %2
%296 = mul i32 %294, %295
%297 = add i32 %292, %296
%298 = load i32, i32* %5
%299 = add i32 %297, %298
%300 = zext i32 %299 to i64
%301 = getelementptr inbounds float, float* %286, i64 %300
%302 = load float, float* %301
%303 = fadd float %285, %302
%304 = load float*, float** %9
%305 = load i32, i32* %3
%306 = load i32, i32* %2
%307 = mul i32 %305, %306
%308 = load i32, i32* %2
%309 = mul i32 %307, %308
%310 = load i32, i32* %4
%311 = sub nsw i32 %310, 1
%312 = load i32, i32* %2
%313 = mul i32 %311, %312
%314 = add i32 %309, %313
%315 = load i32, i32* %5
%316 = sub nsw i32 %315, 1
%317 = add i32 %314, %316
%318 = zext i32 %317 to i64
%319 = getelementptr inbounds float, float* %304, i64 %318
%320 = load float, float* %319
%321 = fadd float %303, %320
%322 = load float*, float** %9
%323 = load i32, i32* %3
%324 = load i32, i32* %2
%325 = mul i32 %323, %324
%326 = load i32, i32* %2
%327 = mul i32 %325, %326
%328 = load i32, i32* %4
%329 = add nsw i32 %328, 1
%330 = load i32, i32* %2
%331 = mul i32 %329, %330
%332 = add i32 %327, %331
%333 = load i32, i32* %5
%334 = sub nsw i32 %333, 1
%335 = add i32 %332, %334
%336 = zext i32 %335 to i64
%337 = getelementptr inbounds float, float* %322, i64 %336
%338 = load float, float* %337
%339 = fadd float %321, %338
%340 = load float*, float** %9
%341 = load i32, i32* %3
%342 = sub nsw i32 %341, 1
%343 = load i32, i32* %2
%344 = mul i32 %342, %343
%345 = load i32, i32* %2
%346 = mul i32 %344, %345
%347 = load i32, i32* %4
%348 = load i32, i32* %2
%349 = mul i32 %347, %348
%350 = add i32 %346, %349
%351 = load i32, i32* %5
%352 = sub nsw i32 %351, 1
%353 = add i32 %350, %352
%354 = zext i32 %353 to i64
%355 = getelementptr inbounds float, float* %340, i64 %354
%356 = load float, float* %355
%357 = fadd float %339, %356
%358 = load float*, float** %9
%359 = load i32, i32* %3
%360 = add nsw i32 %359, 1
%361 = load i32, i32* %2
%362 = mul i32 %360, %361
%363 = load i32, i32* %2
%364 = mul i32 %362, %363
%365 = load i32, i32* %4
%366 = load i32, i32* %2
%367 = mul i32 %365, %366
%368 = add i32 %364, %367
%369 = load i32, i32* %5
%370 = sub nsw i32 %369, 1
%371 = add i32 %368, %370
%372 = zext i32 %371 to i64
%373 = getelementptr inbounds float, float* %358, i64 %372
%374 = load float, float* %373
%375 = fadd float %357, %374
%376 = load float*, float** %9
%377 = load i32, i32* %3
%378 = sub nsw i32 %377, 1
%379 = load i32, i32* %2
%380 = mul i32 %378, %379
%381 = load i32, i32* %2
%382 = mul i32 %380, %381
%383 = load i32, i32* %4
%384 = sub nsw i32 %383, 1
%385 = load i32, i32* %2
%386 = mul i32 %384, %385
%387 = add i32 %382, %386
%388 = load i32, i32* %5
%389 = sub nsw i32 %388, 1
%390 = add i32 %387, %389
%391 = zext i32 %390 to i64
%392 = getelementptr inbounds float, float* %376, i64 %391
%393 = load float, float* %392
%394 = fadd float %375, %393
%395 = load float*, float** %9
%396 = load i32, i32* %3
%397 = sub nsw i32 %396, 1
%398 = load i32, i32* %2
%399 = mul i32 %397, %398
%400 = load i32, i32* %2
%401 = mul i32 %399, %400
%402 = load i32, i32* %4
%403 = add nsw i32 %402, 1
%404 = load i32, i32* %2
%405 = mul i32 %403, %404
%406 = add i32 %401, %405
%407 = load i32, i32* %5
%408 = sub nsw i32 %407, 1
%409 = add i32 %406, %408
%410 = zext i32 %409 to i64
%411 = getelementptr inbounds float, float* %395, i64 %410
%412 = load float, float* %411
%413 = fadd float %394, %412
%414 = load float*, float** %9
%415 = load i32, i32* %3
%416 = add nsw i32 %415, 1
%417 = load i32, i32* %2
%418 = mul i32 %416, %417
%419 = load i32, i32* %2
%420 = mul i32 %418, %419
%421 = load i32, i32* %4
%422 = sub nsw i32 %421, 1
%423 = load i32, i32* %2
%424 = mul i32 %422, %423
%425 = add i32 %420, %424
%426 = load i32, i32* %5
%427 = sub nsw i32 %426, 1
%428 = add i32 %425, %427
%429 = zext i32 %428 to i64
%430 = getelementptr inbounds float, float* %414, i64 %429
%431 = load float, float* %430
%432 = fadd float %413, %431
%433 = load float*, float** %9
%434 = load i32, i32* %3
%435 = add nsw i32 %434, 1
%436 = load i32, i32* %2
%437 = mul i32 %435, %436
%438 = load i32, i32* %2
%439 = mul i32 %437, %438
%440 = load i32, i32* %4
%441 = add nsw i32 %440, 1
%442 = load i32, i32* %2
%443 = mul i32 %441, %442
%444 = add i32 %439, %443
%445 = load i32, i32* %5
%446 = sub nsw i32 %445, 1
%447 = add i32 %444, %446
%448 = zext i32 %447 to i64
%449 = getelementptr inbounds float, float* %433, i64 %448
%450 = load float, float* %449
%451 = fadd float %432, %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 = sub nsw i32 %458, 1
%460 = load i32, i32* %2
%461 = mul i32 %459, %460
%462 = add i32 %457, %461
%463 = load i32, i32* %5
%464 = add nsw i32 %463, 1
%465 = add i32 %462, %464
%466 = zext i32 %465 to i64
%467 = getelementptr inbounds float, float* %452, i64 %466
%468 = load float, float* %467
%469 = fadd float %451, %468
%470 = load float*, float** %9
%471 = load i32, i32* %3
%472 = load i32, i32* %2
%473 = mul i32 %471, %472
%474 = load i32, i32* %2
%475 = mul i32 %473, %474
%476 = load i32, i32* %4
%477 = add nsw i32 %476, 1
%478 = load i32, i32* %2
%479 = mul i32 %477, %478
%480 = add i32 %475, %479
%481 = load i32, i32* %5
%482 = add nsw i32 %481, 1
%483 = add i32 %480, %482
%484 = zext i32 %483 to i64
%485 = getelementptr inbounds float, float* %470, i64 %484
%486 = load float, float* %485
%487 = fadd float %469, %486
%488 = load float*, float** %9
%489 = load i32, i32* %3
%490 = sub nsw i32 %489, 1
%491 = load i32, i32* %2
%492 = mul i32 %490, %491
%493 = load i32, i32* %2
%494 = mul i32 %492, %493
%495 = load i32, i32* %4
%496 = load i32, i32* %2
%497 = mul i32 %495, %496
%498 = add i32 %494, %497
%499 = load i32, i32* %5
%500 = add nsw i32 %499, 1
%501 = add i32 %498, %500
%502 = zext i32 %501 to i64
%503 = getelementptr inbounds float, float* %488, i64 %502
%504 = load float, float* %503
%505 = fadd float %487, %504
%506 = load float*, float** %9
%507 = load i32, i32* %3
%508 = add nsw i32 %507, 1
%509 = load i32, i32* %2
%510 = mul i32 %508, %509
%511 = load i32, i32* %2
%512 = mul i32 %510, %511
%513 = load i32, i32* %4
%514 = load i32, i32* %2
%515 = mul i32 %513, %514
%516 = add i32 %512, %515
%517 = load i32, i32* %5
%518 = add nsw i32 %517, 1
%519 = add i32 %516, %518
%520 = zext i32 %519 to i64
%521 = getelementptr inbounds float, float* %506, i64 %520
%522 = load float, float* %521
%523 = fadd float %505, %522
%524 = load float*, float** %9
%525 = load i32, i32* %3
%526 = sub nsw i32 %525, 1
%527 = load i32, i32* %2
%528 = mul i32 %526, %527
%529 = load i32, i32* %2
%530 = mul i32 %528, %529
%531 = load i32, i32* %4
%532 = sub nsw i32 %531, 1
%533 = load i32, i32* %2
%534 = mul i32 %532, %533
%535 = add i32 %530, %534
%536 = load i32, i32* %5
%537 = add nsw i32 %536, 1
%538 = add i32 %535, %537
%539 = zext i32 %538 to i64
%540 = getelementptr inbounds float, float* %524, i64 %539
%541 = load float, float* %540
%542 = fadd float %523, %541
%543 = load float*, float** %9
%544 = load i32, i32* %3
%545 = sub nsw i32 %544, 1
%546 = load i32, i32* %2
%547 = mul i32 %545, %546
%548 = load i32, i32* %2
%549 = mul i32 %547, %548
%550 = load i32, i32* %4
%551 = add nsw i32 %550, 1
%552 = load i32, i32* %2
%553 = mul i32 %551, %552
%554 = add i32 %549, %553
%555 = load i32, i32* %5
%556 = add nsw i32 %555, 1
%557 = add i32 %554, %556
%558 = zext i32 %557 to i64
%559 = getelementptr inbounds float, float* %543, i64 %558
%560 = load float, float* %559
%561 = fadd float %542, %560
%562 = load float*, float** %9
%563 = load i32, i32* %3
%564 = add nsw i32 %563, 1
%565 = load i32, i32* %2
%566 = mul i32 %564, %565
%567 = load i32, i32* %2
%568 = mul i32 %566, %567
%569 = load i32, i32* %4
%570 = sub nsw i32 %569, 1
%571 = load i32, i32* %2
%572 = mul i32 %570, %571
%573 = add i32 %568, %572
%574 = load i32, i32* %5
%575 = add nsw i32 %574, 1
%576 = add i32 %573, %575
%577 = zext i32 %576 to i64
%578 = getelementptr inbounds float, float* %562, i64 %577
%579 = load float, float* %578
%580 = fadd float %561, %579
%581 = load float*, float** %9
%582 = load i32, i32* %3
%583 = add nsw i32 %582, 1
%584 = load i32, i32* %2
%585 = mul i32 %583, %584
%586 = load i32, i32* %2
%587 = mul i32 %585, %586
%588 = load i32, i32* %4
%589 = add nsw i32 %588, 1
%590 = load i32, i32* %2
%591 = mul i32 %589, %590
%592 = add i32 %587, %591
%593 = load i32, i32* %5
%594 = add nsw i32 %593, 1
%595 = add i32 %592, %594
%596 = zext i32 %595 to i64
%597 = getelementptr inbounds float, float* %581, i64 %596
%598 = load float, float* %597
%599 = fadd float %580, %598
%600 = load float*, float** %9
%601 = load i32, i32* %3
%602 = load i32, i32* %2
%603 = mul i32 %601, %602
%604 = load i32, i32* %2
%605 = mul i32 %603, %604
%606 = load i32, i32* %4
%607 = load i32, i32* %2
%608 = mul i32 %606, %607
%609 = add i32 %605, %608
%610 = load i32, i32* %5
%611 = sub nsw i32 %610, 1
%612 = add i32 %609, %611
%613 = zext i32 %612 to i64
%614 = getelementptr inbounds float, float* %600, i64 %613
%615 = load float, float* %614
%616 = fadd float %599, %615
%617 = load float*, float** %9
%618 = load i32, i32* %3
%619 = load i32, i32* %2
%620 = mul i32 %618, %619
%621 = load i32, i32* %2
%622 = mul i32 %620, %621
%623 = load i32, i32* %4
%624 = load i32, i32* %2
%625 = mul i32 %623, %624
%626 = add i32 %622, %625
%627 = load i32, i32* %5
%628 = add nsw i32 %627, 1
%629 = add i32 %626, %628
%630 = zext i32 %629 to i64
%631 = getelementptr inbounds float, float* %617, i64 %630
%632 = load float, float* %631
%633 = fadd float %616, %632
%634 = load float, float* %8
%635 = fmul float %633, %634
%636 = load float*, float** %10
%637 = load i32, i32* %3
%638 = load i32, i32* %2
%639 = mul i32 %637, %638
%640 = load i32, i32* %2
%641 = mul i32 %639, %640
%642 = load i32, i32* %4
%643 = load i32, i32* %2
%644 = mul i32 %642, %643
%645 = add i32 %641, %644
%646 = load i32, i32* %5
%647 = add i32 %645, %646
%648 = zext i32 %647 to i64
%649 = getelementptr inbounds float, float* %636, i64 %648
store float %635, float* %649
br label %650
650: ; preds = %164
%651 = load i32, i32* %5
%652 = add nsw i32 %651, 1
store i32 %652, i32* %5
br label %159
653: ; preds = %159
br label %654
654: ; preds = %653
%655 = load i32, i32* %4
%656 = add nsw i32 %655, 1
store i32 %656, i32* %4
br label %153
657: ; preds = %153
br label %658
658: ; preds = %657
%659 = load i32, i32* %3
%660 = add nsw i32 %659, 1
store i32 %660, i32* %3
br label %147
661: ; preds = %147
store i32 1, i32* %3
br label %662
662: ; preds = %717, %661
%663 = load i32, i32* %3
%664 = load i32, i32* %7
%665 = add nsw i32 %664, 1
%666 = icmp slt i32 %663, %665
br i1 %666, label %667, label %720
667: ; preds = %662
store i32 1, i32* %4
br label %668
668: ; preds = %713, %667
%669 = load i32, i32* %4
%670 = load i32, i32* %7
%671 = add nsw i32 %670, 1
%672 = icmp slt i32 %669, %671
br i1 %672, label %673, label %716
673: ; preds = %668
store i32 1, i32* %5
br label %674
674: ; preds = %709, %673
%675 = load i32, i32* %5
%676 = load i32, i32* %7
%677 = add nsw i32 %676, 1
%678 = icmp slt i32 %675, %677
br i1 %678, label %679, label %712
679: ; preds = %674
%680 = load float*, float** %10
%681 = load i32, i32* %3
%682 = load i32, i32* %2
%683 = mul i32 %681, %682
%684 = load i32, i32* %2
%685 = mul i32 %683, %684
%686 = load i32, i32* %4
%687 = load i32, i32* %2
%688 = mul i32 %686, %687
%689 = add i32 %685, %688
%690 = load i32, i32* %5
%691 = add i32 %689, %690
%692 = zext i32 %691 to i64
%693 = getelementptr inbounds float, float* %680, i64 %692
%694 = load float, float* %693
%695 = load float*, float** %9
%696 = load i32, i32* %3
%697 = load i32, i32* %2
%698 = mul i32 %696, %697
%699 = load i32, i32* %2
%700 = mul i32 %698, %699
%701 = load i32, i32* %4
%702 = load i32, i32* %2
%703 = mul i32 %701, %702
%704 = add i32 %700, %703
%705 = load i32, i32* %5
%706 = add i32 %704, %705
%707 = zext i32 %706 to i64
%708 = getelementptr inbounds float, float* %695, i64 %707
store float %694, float* %708
br label %709
709: ; preds = %679
%710 = load i32, i32* %5
%711 = add nsw i32 %710, 1
store i32 %711, i32* %5
br label %674
712: ; preds = %674
br label %713
713: ; preds = %712
%714 = load i32, i32* %4
%715 = add nsw i32 %714, 1
store i32 %715, i32* %4
br label %668
716: ; preds = %668
br label %717
717: ; preds = %716
%718 = load i32, i32* %3
%719 = add nsw i32 %718, 1
store i32 %719, i32* %3
br label %662
720: ; preds = %662
br label %721
721: ; preds = %720
%722 = load i32, i32* %6
%723 = add nsw i32 %722, 1
store i32 %723, i32* %6
br label %143
724: ; preds = %143
%725 = load i32, i32* @CLOCK_MONOTONIC_RAW
%726 = call i32 @clock_gettime(i32 %725, %struct.timespec* %12)
%727 = call i32 (...) @rapl_end()
%728 = call i32 (...) @rapl_deinit()
%729 = getelementptr inbounds %struct.timespec, %struct.timespec* %11, i32 0, i32 0
%730 = load i32, i32* %729
%731 = getelementptr inbounds %struct.timespec, %struct.timespec* %12, i32 0, i32 0
%732 = load i32, i32* %731
%733 = call i32 @elapsed_time_hr(i32 %730, i32 %732, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0))
%734 = load float*, float** %9
%735 = call i32 @free(float* %734)
%736 = load float*, float** %10
%737 = call i32 @free(float* %736)
ret void
}

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