#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_stencil19(unsigned int size) {
  int i, j, k, iter;
  int n = size - 2;
  float fac = 1.0 / 18;
  float *a0 = (float *)malloc(sizeof(float) * size * size * size);
  float *a1 = (float *)malloc(sizeof(float) * size * size * size);
  if (a0 == NULL || a1 == NULL) {
    printf(
        "19-point Single Precision Stencil Error: Unable to allocate memory\n");
  }
  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 * size * size + (j - 1) * size + (k + 1)] +
               a0[i * size * size + (j + 1) * size + (k + 1)] +
               a0[(i - 1) * size * size + j * size + (k + 1)] +
               a0[(i + 1) * size * size + j * size + (k + 1)] +
               a0[i * size * size + j * size + (k - 1)] +
               a0[i * size * size + j * size + (k + 1)]) *
              fac;
        }
      }
    }
    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 - 19 point");
  free(a0);
  free(a1);
}


x86 assembly (clang, -O0):
<float_stencil19>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x18(%rbp)
movss  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_stencil19+0x77>
cmpq   $0x0,-0x30(%rbp)
jne    1223 <float_stencil19+0x83>
lea    0xdf2(%rip),%rdi
call   1060 <printf@plt>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12b5 <float_stencil19+0x115>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    12a2 <float_stencil19+0x102>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    128f <float_stencil19+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_stencil19+0xb0>
jmp    1294 <float_stencil19+0xf4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    123d <float_stencil19+0x9d>
jmp    12a7 <float_stencil19+0x107>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    122a <float_stencil19+0x8a>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    137f <float_stencil19+0x1df>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    136c <float_stencil19+0x1cc>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1359 <float_stencil19+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_stencil19+0x14c>
jmp    135e <float_stencil19+0x1be>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12d4 <float_stencil19+0x134>
jmp    1371 <float_stencil19+0x1d1>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12bc <float_stencil19+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    17f8 <float_stencil19+0x658>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1725 <float_stencil19+0x585>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1712 <float_stencil19+0x572>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    16ff <float_stencil19+0x55f>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
mov    %ecx,%ecx
addss  (%rax,%rcx,4),%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    -0x10(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13e7 <float_stencil19+0x247>
jmp    1704 <float_stencil19+0x564>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13cf <float_stencil19+0x22f>
jmp    1717 <float_stencil19+0x577>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13b7 <float_stencil19+0x217>
movl   $0x1,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17e5 <float_stencil19+0x645>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17d2 <float_stencil19+0x632>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17bf <float_stencil19+0x61f>
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    175c <float_stencil19+0x5bc>
jmp    17c4 <float_stencil19+0x624>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1744 <float_stencil19+0x5a4>
jmp    17d7 <float_stencil19+0x637>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    172c <float_stencil19+0x58c>
jmp    17ea <float_stencil19+0x64a>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13a6 <float_stencil19+0x206>
mov    0x27e1(%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    0x82f(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    -0x28(%rbp),%rdi
call   1040 <free@plt>
mov    -0x30(%rbp),%rdi
call   1040 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<float_stencil19>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %edi,%r12d
mov    %edi,%ebx
imul   %ebx,%ebx
mov    %ebx,%r14d
imul   %edi,%r14d
shl    $0x2,%r14d
mov    %r14d,%edi
call   1080 <malloc@plt>
mov    %rax,%r15
mov    %r14d,%edi
call   1080 <malloc@plt>
mov    %rax,%r14
test   %r15,%r15
je     11e4 <float_stencil19+0x44>
test   %r14,%r14
jne    11f0 <float_stencil19+0x50>
lea    0xe45(%rip),%rdi
call   1050 <puts@plt>
movabs $0x3ffffffffffffffc,%rcx
ff ff 3f
xor    %esi,%esi
mov    %r12d,%edi
test   %r12d,%r12d
mov    %r12,0x38(%rsp)
mov    %rbx,0x40(%rsp)
mov    %rdi,0x48(%rsp)
je     14e8 <float_stencil19+0x348>
mov    %r14,0x20(%rsp)
mov    %rbx,%rax
lea    -0x1(%rdi),%rbx
mov    %edi,%r13d
and    $0xfffffff8,%r13d
lea    -0x8(%r13),%rdx
mov    %rdx,0x18(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r12d
and    $0x3,%r12d
and    %rcx,%rdx
mov    %rdx,0x10(%rsp)
mov    %edi,%r10d
and    $0x3,%r10d
mov    $0x10,%r9d
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1285 <float_stencil19+0xe5>
xchg   %ax,%ax
mov    0x30(%rsp),%rsi
add    $0x1,%esi
mov    0x40(%rsp),%rax
mov    0x8(%rsp),%r9d
add    %eax,%r9d
mov    0x28(%rsp),%rcx
add    %rax,%rcx
cmp    %edx,%esi
je     13fc <float_stencil19+0x25c>
mov    %eax,%r14d
mov    %rsi,0x30(%rsp)
imul   %esi,%r14d
xor    %r11d,%r11d
mov    %rcx,0x28(%rsp)
mov    %r9d,0x8(%rsp)
mov    0x38(%rsp),%rdx
jmp    12c4 <float_stencil19+0x124>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r11d
mov    0x38(%rsp),%rdx
add    %edx,%r9d
add    %rdi,%rcx
cmp    %edx,%r11d
je     1260 <float_stencil19+0xc0>
cmp    $0x8,%edx
jae    1340 <float_stencil19+0x1a0>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %rdi,%rax
test   %r10,%r10
je     12f5 <float_stencil19+0x155>
mov    %r10,%rdx
nopl   0x0(%rax)
lea    (%rcx,%rbp,1),%esi
movl   $0x0,(%r15,%rsi,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    12e0 <float_stencil19+0x140>
cmp    $0x3,%rax
jb     12b0 <float_stencil19+0x110>
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rbp,1),%rax
mov    %eax,%edx
movl   $0x0,(%r15,%rdx,4)
lea    0x1(%rax),%edx
movl   $0x0,(%r15,%rdx,4)
lea    0x2(%rax),%edx
movl   $0x0,(%r15,%rdx,4)
add    $0x3,%eax
movl   $0x0,(%r15,%rax,4)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    1300 <float_stencil19+0x160>
jmp    12b0 <float_stencil19+0x110>
nopl   (%rax)
mov    %r11d,%eax
imul   %edx,%eax
add    %r14d,%eax
add    %ebx,%eax
jb     12c9 <float_stencil19+0x129>
mov    %rbx,%rax
shr    $0x20,%rax
mov    $0x0,%ebp
jne    12cb <float_stencil19+0x12b>
cmpq   $0x18,0x18(%rsp)
jae    136f <float_stencil19+0x1cf>
xor    %ebp,%ebp
jmp    13c5 <float_stencil19+0x225>
mov    0x10(%rsp),%rdx
mov    %r9d,%eax
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    -0x10(%rax),%r8d
movups %xmm0,(%r15,%r8,4)
movups %xmm0,0x10(%r15,%r8,4)
lea    -0x8(%rax),%esi
movups %xmm0,(%r15,%rsi,4)
movups %xmm0,0x10(%r15,%rsi,4)
mov    %eax,%esi
movups %xmm0,(%r15,%rsi,4)
movups %xmm0,0x10(%r15,%rsi,4)
lea    0x8(%rax),%esi
movups %xmm0,(%r15,%rsi,4)
movups %xmm0,0x10(%r15,%rsi,4)
add    $0x20,%rbp
add    $0x20,%eax
add    $0xfffffffffffffffc,%rdx
jne    1380 <float_stencil19+0x1e0>
test   %r12,%r12
je     13e6 <float_stencil19+0x246>
add    %ecx,%ebp
mov    %r12,%rax
nop
mov    %ebp,%edx
movups %xmm0,(%r15,%rdx,4)
movups %xmm0,0x10(%r15,%rdx,4)
add    $0x8,%ebp
add    $0xffffffffffffffff,%rax
jne    13d0 <float_stencil19+0x230>
mov    %r13,%rbp
mov    0x48(%rsp),%rdi
cmp    %rdi,%r13
je     12b0 <float_stencil19+0x110>
jmp    12cb <float_stencil19+0x12b>
mov    0x38(%rsp),%r12
lea    -0x1(%r12),%r13d
cmp    $0x2,%r13d
setge  %al
jl     14f7 <float_stencil19+0x357>
mov    %rax,0x30(%rsp)
mov    %r13d,%eax
lea    0x1(%r12),%ecx
imul   %r12d,%ecx
add    $0x1,%ecx
add    $0xffffffffffffffff,%rax
mov    %rax,0x10(%rsp)
mov    $0x1,%eax
mov    0x2bac(%rip),%rbp
mov    %r13d,0x18(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,0x28(%rsp)
mov    %ecx,0x8(%rsp)
mov    %ecx,%ebx
mov    $0x1,%r12d
mov    0x10(%rsp),%r13
mov    %ebx,%r14d
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 0x0(%rbp),%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
divss  %xmm1,%xmm0
mov    %r14d,%eax
movss  %xmm0,(%r15,%rax,4)
add    $0x1,%r14d
add    $0xffffffffffffffff,%r13
jne    1470 <float_stencil19+0x2d0>
add    $0x1,%r12d
add    0x38(%rsp),%ebx
mov    0x18(%rsp),%r13d
cmp    %r13d,%r12d
jne    1460 <float_stencil19+0x2c0>
mov    0x28(%rsp),%eax
add    $0x1,%eax
mov    0x40(%rsp),%rbx
mov    0x8(%rsp),%ecx
add    %ebx,%ecx
cmp    %r13d,%eax
jne    1450 <float_stencil19+0x2b0>
mov    0x20(%rsp),%r14
mov    0x38(%rsp),%r12
jmp    1508 <float_stencil19+0x368>
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    $0xffffffff,%r13d
jmp    1508 <float_stencil19+0x368>
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    0x20(%rsp),%r14
mov    0x40(%rsp),%rbx
xor    %ebp,%ebp
xor    %eax,%eax
call   10a0 <rapl_init@plt>
xor    %eax,%eax
call   1070 <rapl_start@plt>
mov    0x2ac1(%rip),%rax
mov    (%rax),%edi
lea    0x58(%rsp),%rsi
call   1060 <clock_gettime@plt>
mov    %r13d,%r13d
lea    -0x2(%r13),%rax
mov    %rax,0x118(%rsp)
lea    0x1(%r12),%r10d
imul   %r12d,%r10d
lea    -0x1(%r13),%rdi
lea    (%r15,%r13,4),%r8
add    $0xfffffffffffffffc,%r8
lea    -0x4(%r14,%r13,4),%r9
lea    -0x9(%r13),%rax
mov    %rax,0x110(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
cmp    %r15,%r9
seta   %r9b
cmp    %r14,%r8
seta   %al
and    %r9b,%al
mov    %al,0x7(%rsp)
mov    %rdi,0x70(%rsp)
mov    %rdi,%rdx
and    $0xfffffffffffffff8,%rdx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
add    $0x2,%rax
mov    %rcx,%rdi
mov    %rcx,0x108(%rsp)
and    %rcx,%rax
mov    %rax,0xf0(%rsp)
lea    0x2(%r12),%eax
imul   %r12d,%eax
mov    %rax,0x98(%rsp)
lea    (%r12,%r12,1),%eax
lea    (%r12,%r12,1),%ecx
add    $0x1,%ecx
imul   %r12d,%ecx
mov    %rcx,0x88(%rsp)
lea    (%r12,%r12,1),%ecx
add    $0x2,%ecx
imul   %r12d,%ecx
or     $0x1,%rcx
mov    %rcx,0x80(%rsp)
or     $0x1,%rax
mov    %rax,0x90(%rsp)
lea    (%rbx,%rbx,1),%eax
or     $0x1,%rax
mov    %rax,0x78(%rsp)
mov    $0x1,%eax
sub    %r13,%rax
mov    %r10d,%ecx
add    $0x9,%ecx
mov    %ecx,0x5c(%rsp)
movss  0x9e8(%rip),%xmm0
mov    %r10,0x68(%rsp)
lea    0x1(%r10),%ecx
mov    %ecx,0x60(%rsp)
mov    %rdx,0x100(%rsp)
lea    0x1(%rdx),%rcx
mov    %rcx,0xf8(%rsp)
mov    %r13,0x20(%rsp)
mov    %rax,0x120(%rsp)
jmp    1664 <float_stencil19+0x4c4>
mov    0xa0(%rsp),%rbp
add    $0x1,%ebp
cmp    $0x64,%ebp
je     1b4d <float_stencil19+0x9ad>
mov    %rbp,0xa0(%rsp)
cmpb   $0x0,0x30(%rsp)
je     1650 <float_stencil19+0x4b0>
mov    $0x1,%eax
xor    %ecx,%ecx
mov    0x78(%rsp),%rdx
mov    0x90(%rsp),%rdi
mov    0x80(%rsp),%r12
mov    0x68(%rsp),%rbp
mov    0x88(%rsp),%rsi
mov    0x48(%rsp),%r9
mov    0x98(%rsp),%r10
mov    %rbx,%r8
nopl   0x0(%rax)
add    $0x1,%eax
mov    %eax,0x64(%rsp)
mov    %rcx,0xe8(%rsp)
mov    %rcx,%rax
mov    %rdx,0xe0(%rsp)
mov    %rdi,0xd8(%rsp)
mov    %rdi,%rcx
mov    %r12,0xd0(%rsp)
mov    %r12,%rdi
mov    %rbp,0xc8(%rsp)
mov    %rbp,%rbx
mov    %rsi,0xc0(%rsp)
mov    %r9,0xb8(%rsp)
mov    %r10,0xb0(%rsp)
mov    %r8,0xa8(%rsp)
mov    %r8,%r12
mov    %r9,%r8
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    %rcx,0x8(%rsp)
mov    %rdx,0x10(%rsp)
mov    %rax,0x18(%rsp)
add    $0x1,%ebp
mov    %ebp,0x28(%rsp)
xor    %ebp,%ebp
mov    0x120(%rsp),%r13
mov    %rdi,%rcx
mov    %rsi,%rdx
cs nopw 0x0(%rax,%rax,1)
lea    (%r12,%rbp,1),%rsi
lea    0x1(%rsi),%eax
movss  (%r15,%rax,4),%xmm1
lea    (%r10,%rbp,1),%rax
lea    0x1(%rax),%edi
addss  (%r15,%rdi,4),%xmm1
lea    (%r8,%rbp,1),%r11
lea    0x1(%r11),%edi
addss  (%r15,%rdi,4),%xmm1
mov    %r12,%r9
mov    %r10,%r12
mov    %r8,%r10
mov    %r14,%r8
lea    (%rdx,%rbp,1),%r14
lea    0x1(%r14),%edi
addss  (%r15,%rdi,4),%xmm1
mov    0x18(%rsp),%rdi
lea    0x1(%rdi,%rbp,1),%edi
addss  (%r15,%rdi,4),%xmm1
mov    0x8(%rsp),%rdi
lea    (%rdi,%rbp,1),%edi
addss  (%r15,%rdi,4),%xmm1
mov    0x10(%rsp),%rdi
lea    (%rdi,%rbp,1),%edi
addss  (%r15,%rdi,4),%xmm1
lea    (%rcx,%rbp,1),%edi
addss  (%r15,%rdi,4),%xmm1
mov    %esi,%edi
addss  (%r15,%rdi,4),%xmm1
mov    %eax,%edi
addss  (%r15,%rdi,4),%xmm1
mov    %r11d,%edi
addss  (%r15,%rdi,4),%xmm1
mov    %r14d,%edi
addss  (%r15,%rdi,4),%xmm1
add    $0x2,%esi
addss  (%r15,%rsi,4),%xmm1
add    $0x2,%eax
addss  (%r15,%rax,4),%xmm1
add    $0x2,%r11d
addss  (%r15,%r11,4),%xmm1
add    $0x2,%r14d
addss  (%r15,%r14,4),%xmm1
mov    %r8,%r14
mov    %r10,%r8
mov    %r12,%r10
mov    %r9,%r12
lea    (%rbx,%rbp,1),%rax
mov    %eax,%esi
addss  (%r15,%rsi,4),%xmm1
lea    0x2(%rax),%esi
addss  (%r15,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
add    $0x1,%eax
movss  %xmm1,(%r14,%rax,4)
add    $0x1,%rbp
mov    %r13,%rax
add    %rbp,%rax
jne    1750 <float_stencil19+0x5b0>
mov    0x48(%rsp),%rax
add    %rax,%r12
add    %rax,%r10
add    %rax,%r8
mov    %rdx,%rsi
add    %rax,%rsi
add    %rax,%rbx
mov    %rcx,%rdi
add    %rax,%rdi
mov    0x8(%rsp),%r11
add    %rax,%r11
mov    0x10(%rsp),%rdx
add    %rax,%rdx
mov    0x18(%rsp),%rcx
add    %rax,%rcx
mov    0x20(%rsp),%r13
mov    0x28(%rsp),%ebp
cmp    %r13d,%ebp
mov    %rcx,%rax
mov    %r11,%rcx
jne    1720 <float_stencil19+0x580>
mov    0x40(%rsp),%rbx
mov    0xa8(%rsp),%r8
add    %rbx,%r8
mov    0xb0(%rsp),%r10
add    %rbx,%r10
mov    0xb8(%rsp),%r9
add    %rbx,%r9
mov    0xc0(%rsp),%rsi
add    %rbx,%rsi
mov    0xc8(%rsp),%rbp
add    %rbx,%rbp
mov    0xd0(%rsp),%r12
add    %rbx,%r12
mov    0xd8(%rsp),%rdi
add    %rbx,%rdi
mov    0xe0(%rsp),%rdx
add    %rbx,%rdx
mov    0xe8(%rsp),%rcx
add    %rbx,%rcx
mov    0x64(%rsp),%eax
cmp    %r13d,%eax
jne    16b0 <float_stencil19+0x510>
cmpb   $0x0,0x30(%rsp)
mov    0x38(%rsp),%rbp
je     1650 <float_stencil19+0x4b0>
mov    $0x1,%edx
xor    %ecx,%ecx
mov    0x68(%rsp),%rdi
mov    0x5c(%rsp),%r10d
jmp    1967 <float_stencil19+0x7c7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%edx
add    $0x1,%edx
mov    0x18(%rsp),%ecx
add    $0x1,%ecx
mov    0x8(%rsp),%r10d
add    %ebx,%r10d
mov    0x10(%rsp),%rdi
add    %rbx,%rdi
cmp    %r13d,%edx
je     1650 <float_stencil19+0x4b0>
mov    %ebx,%r12d
mov    %ecx,0x18(%rsp)
imul   %ecx,%r12d
add    0x60(%rsp),%r12d
mov    %edx,0x28(%rsp)
mov    %edx,%r11d
imul   %ebp,%r11d
mov    %rdi,0x10(%rsp)
mov    %r10d,0x8(%rsp)
xor    %r9d,%r9d
mov    $0x1,%r8d
jmp    19b5 <float_stencil19+0x815>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8d
add    $0x1,%r9d
add    %ebp,%r10d
add    0x48(%rsp),%rdi
cmp    %r13d,%r8d
je     1940 <float_stencil19+0x7a0>
mov    $0x1,%ecx
cmpq   $0x8,0x70(%rsp)
jb     1ab0 <float_stencil19+0x910>
mov    0x118(%rsp),%rdx
mov    %rdx,%rax
shr    $0x20,%rax
setne  %al
mov    %r9d,%esi
imul   %ebp,%esi
add    %r12d,%esi
add    %edx,%esi
mov    0x20(%rsp),%r13
setb   %dl
or     %al,%dl
or     0x7(%rsp),%dl
jne    1ab0 <float_stencil19+0x910>
cmpq   $0x8,0x110(%rsp)
jae    1a06 <float_stencil19+0x866>
xor    %eax,%eax
jmp    1a60 <float_stencil19+0x8c0>
mov    0xf0(%rsp),%rcx
mov    %r10d,%esi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x8(%rsi),%edx
movups (%r14,%rdx,4),%xmm1
movups 0x10(%r14,%rdx,4),%xmm2
movups %xmm1,(%r15,%rdx,4)
movups %xmm2,0x10(%r15,%rdx,4)
mov    %esi,%edx
movups (%r14,%rdx,4),%xmm1
movupd 0x10(%r14,%rdx,4),%xmm2
movups %xmm1,(%r15,%rdx,4)
movupd %xmm2,0x10(%r15,%rdx,4)
add    $0x10,%rax
add    $0x10,%esi
add    $0xfffffffffffffffe,%rcx
jne    1a20 <float_stencil19+0x880>
testb  $0x1,0x108(%rsp)
01
mov    0x20(%rsp),%r13
je     1a93 <float_stencil19+0x8f3>
lea    (%r8,%r11,1),%ecx
imul   %ebp,%ecx
or     $0x1,%eax
add    %ecx,%eax
movups (%r14,%rax,4),%xmm1
movupd 0x10(%r14,%rax,4),%xmm2
movups %xmm1,(%r15,%rax,4)
movupd %xmm2,0x10(%r15,%rax,4)
mov    0xf8(%rsp),%rcx
mov    0x100(%rsp),%rax
cmp    %rax,0x70(%rsp)
je     19a0 <float_stencil19+0x800>
xchg   %ax,%ax
mov    %r13d,%esi
sub    %ecx,%esi
mov    %rcx,%rax
not    %rax
add    %r13,%rax
and    $0x3,%rsi
je     1ae9 <float_stencil19+0x949>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdi,%rcx,1),%edx
movss  (%r14,%rdx,4),%xmm1
movss  %xmm1,(%r15,%rdx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1ad0 <float_stencil19+0x930>
cmp    $0x3,%rax
mov    0x20(%rsp),%r13
jb     19a0 <float_stencil19+0x800>
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%rax
mov    %eax,%edx
movss  (%r14,%rdx,4),%xmm1
movss  %xmm1,(%r15,%rdx,4)
lea    0x1(%rax),%edx
movss  (%r14,%rdx,4),%xmm1
movss  %xmm1,(%r15,%rdx,4)
lea    0x2(%rax),%edx
movss  (%r14,%rdx,4),%xmm1
movss  %xmm1,(%r15,%rdx,4)
add    $0x3,%eax
movss  (%r14,%rax,4),%xmm1
movss  %xmm1,(%r15,%rax,4)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    1b00 <float_stencil19+0x960>
jmp    19a0 <float_stencil19+0x800>
mov    0x248c(%rip),%rax
mov    (%rax),%edi
lea    0x50(%rsp),%rsi
call   1060 <clock_gettime@plt>
xor    %eax,%eax
call   1090 <rapl_end@plt>
xor    %eax,%eax
call   10b0 <rapl_deinit@plt>
mov    0x58(%rsp),%edi
mov    0x50(%rsp),%esi
lea    0x48f(%rip),%rdx
call   1030 <elapsed_time_hr@plt>
mov    %r15,%rdi
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.timespec = type { i32 }
@.str = [68 x i8] c"19-point Single Precision Stencil Error: Unable to allocate memory\0A\00"
@RAND_MAX = global i64 0
@CLOCK_MONOTONIC_RAW = global i32 0
@.str.1 = [36 x i8] c"Single Precision Stencil - 19 point\00"
define void @float_stencil19(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca float
%9 = alloca float*
%10 = alloca float*
%11 = alloca %struct.timespec
%12 = alloca %struct.timespec
store i32 %0, i32* %2
%13 = load i32, i32* %2
%14 = sub i32 %13, 2
store i32 %14, i32* %7
store float 0x3FAC71C720000000, float* %8
%15 = load i32, i32* %2
%16 = zext i32 %15 to i64
%17 = mul i64 4, %16
%18 = load i32, i32* %2
%19 = zext i32 %18 to i64
%20 = mul i64 %17, %19
%21 = load i32, i32* %2
%22 = zext i32 %21 to i64
%23 = mul i64 %20, %22
%24 = trunc i64 %23 to i32
%25 = call i64 @malloc(i32 %24)
%26 = inttoptr i64 %25 to float*
store float* %26, float** %9
%27 = load i32, i32* %2
%28 = zext i32 %27 to i64
%29 = mul i64 4, %28
%30 = load i32, i32* %2
%31 = zext i32 %30 to i64
%32 = mul i64 %29, %31
%33 = load i32, i32* %2
%34 = zext i32 %33 to i64
%35 = mul i64 %32, %34
%36 = trunc i64 %35 to i32
%37 = call i64 @malloc(i32 %36)
%38 = inttoptr i64 %37 to float*
store float* %38, float** %10
%39 = load float*, float** %9
%40 = icmp eq float* %39, null
br i1 %40, label %44, label %41
41: ; preds = %1
%42 = load float*, float** %10
%43 = icmp eq float* %42, null
br i1 %43, label %44, label %46
44: ; preds = %41, %1
%45 = call i32 @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 = %569, %138
%144 = load i32, i32* %6
%145 = icmp slt i32 %144, 100
br i1 %145, label %146, label %572
146: ; preds = %143
store i32 1, i32* %3
br label %147
147: ; preds = %506, %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 %509
152: ; preds = %147
store i32 1, i32* %4
br label %153
153: ; preds = %502, %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 %505
158: ; preds = %153
store i32 1, i32* %5
br label %159
159: ; preds = %498, %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 %501
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 = load i32, i32* %2
%379 = mul i32 %377, %378
%380 = load i32, i32* %2
%381 = mul i32 %379, %380
%382 = load i32, i32* %4
%383 = sub nsw i32 %382, 1
%384 = load i32, i32* %2
%385 = mul i32 %383, %384
%386 = add i32 %381, %385
%387 = load i32, i32* %5
%388 = add nsw i32 %387, 1
%389 = add i32 %386, %388
%390 = zext i32 %389 to i64
%391 = getelementptr inbounds float, float* %376, i64 %390
%392 = load float, float* %391
%393 = fadd float %375, %392
%394 = load float*, float** %9
%395 = load i32, i32* %3
%396 = load i32, i32* %2
%397 = mul i32 %395, %396
%398 = load i32, i32* %2
%399 = mul i32 %397, %398
%400 = load i32, i32* %4
%401 = add nsw i32 %400, 1
%402 = load i32, i32* %2
%403 = mul i32 %401, %402
%404 = add i32 %399, %403
%405 = load i32, i32* %5
%406 = add nsw i32 %405, 1
%407 = add i32 %404, %406
%408 = zext i32 %407 to i64
%409 = getelementptr inbounds float, float* %394, i64 %408
%410 = load float, float* %409
%411 = fadd float %393, %410
%412 = load float*, float** %9
%413 = load i32, i32* %3
%414 = sub nsw i32 %413, 1
%415 = load i32, i32* %2
%416 = mul i32 %414, %415
%417 = load i32, i32* %2
%418 = mul i32 %416, %417
%419 = load i32, i32* %4
%420 = load i32, i32* %2
%421 = mul i32 %419, %420
%422 = add i32 %418, %421
%423 = load i32, i32* %5
%424 = add nsw i32 %423, 1
%425 = add i32 %422, %424
%426 = zext i32 %425 to i64
%427 = getelementptr inbounds float, float* %412, i64 %426
%428 = load float, float* %427
%429 = fadd float %411, %428
%430 = load float*, float** %9
%431 = load i32, i32* %3
%432 = add nsw i32 %431, 1
%433 = load i32, i32* %2
%434 = mul i32 %432, %433
%435 = load i32, i32* %2
%436 = mul i32 %434, %435
%437 = load i32, i32* %4
%438 = load i32, i32* %2
%439 = mul i32 %437, %438
%440 = add i32 %436, %439
%441 = load i32, i32* %5
%442 = add nsw i32 %441, 1
%443 = add i32 %440, %442
%444 = zext i32 %443 to i64
%445 = getelementptr inbounds float, float* %430, i64 %444
%446 = load float, float* %445
%447 = fadd float %429, %446
%448 = load float*, float** %9
%449 = load i32, i32* %3
%450 = load i32, i32* %2
%451 = mul i32 %449, %450
%452 = load i32, i32* %2
%453 = mul i32 %451, %452
%454 = load i32, i32* %4
%455 = load i32, i32* %2
%456 = mul i32 %454, %455
%457 = add i32 %453, %456
%458 = load i32, i32* %5
%459 = sub nsw i32 %458, 1
%460 = add i32 %457, %459
%461 = zext i32 %460 to i64
%462 = getelementptr inbounds float, float* %448, i64 %461
%463 = load float, float* %462
%464 = fadd float %447, %463
%465 = load float*, float** %9
%466 = load i32, i32* %3
%467 = load i32, i32* %2
%468 = mul i32 %466, %467
%469 = load i32, i32* %2
%470 = mul i32 %468, %469
%471 = load i32, i32* %4
%472 = load i32, i32* %2
%473 = mul i32 %471, %472
%474 = add i32 %470, %473
%475 = load i32, i32* %5
%476 = add nsw i32 %475, 1
%477 = add i32 %474, %476
%478 = zext i32 %477 to i64
%479 = getelementptr inbounds float, float* %465, i64 %478
%480 = load float, float* %479
%481 = fadd float %464, %480
%482 = load float, float* %8
%483 = fmul float %481, %482
%484 = load float*, float** %10
%485 = load i32, i32* %3
%486 = load i32, i32* %2
%487 = mul i32 %485, %486
%488 = load i32, i32* %2
%489 = mul i32 %487, %488
%490 = load i32, i32* %4
%491 = load i32, i32* %2
%492 = mul i32 %490, %491
%493 = add i32 %489, %492
%494 = load i32, i32* %5
%495 = add i32 %493, %494
%496 = zext i32 %495 to i64
%497 = getelementptr inbounds float, float* %484, i64 %496
store float %483, float* %497
br label %498
498: ; preds = %164
%499 = load i32, i32* %5
%500 = add nsw i32 %499, 1
store i32 %500, i32* %5
br label %159
501: ; preds = %159
br label %502
502: ; preds = %501
%503 = load i32, i32* %4
%504 = add nsw i32 %503, 1
store i32 %504, i32* %4
br label %153
505: ; preds = %153
br label %506
506: ; preds = %505
%507 = load i32, i32* %3
%508 = add nsw i32 %507, 1
store i32 %508, i32* %3
br label %147
509: ; preds = %147
store i32 1, i32* %3
br label %510
510: ; preds = %565, %509
%511 = load i32, i32* %3
%512 = load i32, i32* %7
%513 = add nsw i32 %512, 1
%514 = icmp slt i32 %511, %513
br i1 %514, label %515, label %568
515: ; preds = %510
store i32 1, i32* %4
br label %516
516: ; preds = %561, %515
%517 = load i32, i32* %4
%518 = load i32, i32* %7
%519 = add nsw i32 %518, 1
%520 = icmp slt i32 %517, %519
br i1 %520, label %521, label %564
521: ; preds = %516
store i32 1, i32* %5
br label %522
522: ; preds = %557, %521
%523 = load i32, i32* %5
%524 = load i32, i32* %7
%525 = add nsw i32 %524, 1
%526 = icmp slt i32 %523, %525
br i1 %526, label %527, label %560
527: ; preds = %522
%528 = load float*, float** %10
%529 = load i32, i32* %3
%530 = load i32, i32* %2
%531 = mul i32 %529, %530
%532 = load i32, i32* %2
%533 = mul i32 %531, %532
%534 = load i32, i32* %4
%535 = load i32, i32* %2
%536 = mul i32 %534, %535
%537 = add i32 %533, %536
%538 = load i32, i32* %5
%539 = add i32 %537, %538
%540 = zext i32 %539 to i64
%541 = getelementptr inbounds float, float* %528, i64 %540
%542 = load float, float* %541
%543 = load float*, float** %9
%544 = load i32, i32* %3
%545 = load i32, i32* %2
%546 = mul i32 %544, %545
%547 = load i32, i32* %2
%548 = mul i32 %546, %547
%549 = load i32, i32* %4
%550 = load i32, i32* %2
%551 = mul i32 %549, %550
%552 = add i32 %548, %551
%553 = load i32, i32* %5
%554 = add i32 %552, %553
%555 = zext i32 %554 to i64
%556 = getelementptr inbounds float, float* %543, i64 %555
store float %542, float* %556
br label %557
557: ; preds = %527
%558 = load i32, i32* %5
%559 = add nsw i32 %558, 1
store i32 %559, i32* %5
br label %522
560: ; preds = %522
br label %561
561: ; preds = %560
%562 = load i32, i32* %4
%563 = add nsw i32 %562, 1
store i32 %563, i32* %4
br label %516
564: ; preds = %516
br label %565
565: ; preds = %564
%566 = load i32, i32* %3
%567 = add nsw i32 %566, 1
store i32 %567, i32* %3
br label %510
568: ; preds = %510
br label %569
569: ; preds = %568
%570 = load i32, i32* %6
%571 = add nsw i32 %570, 1
store i32 %571, i32* %6
br label %143
572: ; preds = %143
%573 = load i32, i32* @CLOCK_MONOTONIC_RAW
%574 = call i32 @clock_gettime(i32 %573, %struct.timespec* %12)
%575 = call i32 (...) @rapl_end()
%576 = call i32 (...) @rapl_deinit()
%577 = getelementptr inbounds %struct.timespec, %struct.timespec* %11, i32 0, i32 0
%578 = load i32, i32* %577
%579 = getelementptr inbounds %struct.timespec, %struct.timespec* %12, i32 0, i32 0
%580 = load i32, i32* %579
%581 = call i32 @elapsed_time_hr(i32 %578, i32 %580, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0))
%582 = load float*, float** %9
%583 = call i32 @free(float* %582)
%584 = load float*, float** %10
%585 = call i32 @free(float* %584)
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 - 19 point\00"
@str = [67 x i8] c"19-point Single Precision Stencil Error: Unable to allocate memory\00"
define void @float_stencil19(i32 %0) {
%2 = alloca %struct.timespec
%3 = alloca %struct.timespec
%4 = mul i32 %0, %0
%5 = shl i32 %4, 2
%6 = mul i32 %5, %0
%7 = tail call i64 @malloc(i32 %6)
%8 = inttoptr i64 %7 to float*
%9 = tail call i64 @malloc(i32 %6)
%10 = inttoptr i64 %9 to float*
%11 = icmp eq i64 %7, 0
%12 = icmp eq i64 %9, 0
%13 = select i1 %11, i1 true, i1 %12
br i1 %13, label %14, label %16
14: ; preds = %1
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([67 x i8], [67 x i8]* @str, i64 0, i64 0))
br label %16
16: ; preds = %1, %14
%17 = 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, %481
%221 = phi i32 [ 0, %186 ], [ %482, %481 ]
br i1 %187, label %223, label %481
222: ; preds = %347
br i1 %187, label %349, label %481
223: ; preds = %220, %347
%224 = phi i32 [ %228, %347 ], [ 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 = %345, %223
%231 = phi i32 [ 1, %223 ], [ %235, %345 ]
%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 %238, %225
br label %242
242: ; preds = %230, %242
%243 = phi i64 [ 1, %230 ], [ %308, %242 ]
%244 = trunc i64 %243 to i32
%245 = add i32 %234, %244
%246 = zext i32 %245 to i64
%247 = getelementptr inbounds float, float* %8, i64 %246
%248 = load float, float* %247
%249 = add i32 %237, %244
%250 = zext i32 %249 to i64
%251 = getelementptr inbounds float, float* %8, i64 %250
%252 = load float, float* %251
%253 = fadd float %248, %252
%254 = add i32 %239, %244
%255 = zext i32 %254 to i64
%256 = getelementptr inbounds float, float* %8, i64 %255
%257 = load float, float* %256
%258 = fadd float %253, %257
%259 = add i32 %240, %244
%260 = zext i32 %259 to i64
%261 = getelementptr inbounds float, float* %8, i64 %260
%262 = load float, float* %261
%263 = fadd float %258, %262
%264 = add i32 %233, %244
%265 = add i32 %264, %227
%266 = zext i32 %265 to i64
%267 = getelementptr inbounds float, float* %8, i64 %266
%268 = load float, float* %267
%269 = fadd float %263, %268
%270 = add i32 %236, %244
%271 = add i32 %270, %227
%272 = zext i32 %271 to i64
%273 = getelementptr inbounds float, float* %8, i64 %272
%274 = load float, float* %273
%275 = fadd float %269, %274
%276 = add i32 %264, %229
%277 = zext i32 %276 to i64
%278 = getelementptr inbounds float, float* %8, i64 %277
%279 = load float, float* %278
%280 = fadd float %275, %279
%281 = add i32 %270, %229
%282 = zext i32 %281 to i64
%283 = getelementptr inbounds float, float* %8, i64 %282
%284 = load float, float* %283
%285 = fadd float %280, %284
%286 = trunc i64 %243 to i32
%287 = add i32 %286, -1
%288 = add i32 %287, %234
%289 = zext i32 %288 to i64
%290 = getelementptr inbounds float, float* %8, i64 %289
%291 = load float, float* %290
%292 = fadd float %285, %291
%293 = add i32 %287, %237
%294 = zext i32 %293 to i64
%295 = getelementptr inbounds float, float* %8, i64 %294
%296 = load float, float* %295
%297 = fadd float %292, %296
%298 = add i32 %287, %239
%299 = zext i32 %298 to i64
%300 = getelementptr inbounds float, float* %8, i64 %299
%301 = load float, float* %300
%302 = fadd float %297, %301
%303 = add i32 %287, %240
%304 = zext i32 %303 to i64
%305 = getelementptr inbounds float, float* %8, i64 %304
%306 = load float, float* %305
%307 = fadd float %302, %306
%308 = add nuw nsw i64 %243, 1
%309 = trunc i64 %308 to i32
%310 = add i32 %234, %309
%311 = zext i32 %310 to i64
%312 = getelementptr inbounds float, float* %8, i64 %311
%313 = load float, float* %312
%314 = fadd float %307, %313
%315 = add i32 %237, %309
%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 %239, %309
%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 %240, %309
%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 i32 %287, %241
%331 = zext i32 %330 to i64
%332 = getelementptr inbounds float, float* %8, i64 %331
%333 = load float, float* %332
%334 = fadd float %329, %333
%335 = add i32 %241, %309
%336 = zext i32 %335 to i64
%337 = getelementptr inbounds float, float* %8, i64 %336
%338 = load float, float* %337
%339 = fadd float %334, %338
%340 = fmul float %339, 0x3FAC71C720000000
%341 = add i32 %241, %244
%342 = zext i32 %341 to i64
%343 = getelementptr inbounds float, float* %10, i64 %342
store float %340, float* %343
%344 = icmp eq i64 %308, %193
br i1 %344, label %345, label %242
345: ; preds = %242
%346 = icmp eq i32 %235, %188
br i1 %346, label %347, label %230
347: ; preds = %345
%348 = icmp eq i32 %228, %188
br i1 %348, label %222, label %223
349: ; preds = %222, %477
%350 = phi i32 [ %480, %477 ], [ 0, %222 ]
%351 = phi i32 [ %478, %477 ], [ 1, %222 ]
%352 = mul i32 %199, %350
%353 = add i32 %198, %352
%354 = mul i32 %351, %0
br label %355
355: ; preds = %473, %349
%356 = phi i32 [ %476, %473 ], [ 0, %349 ]
%357 = phi i32 [ %474, %473 ], [ 1, %349 ]
%358 = add i32 %357, %354
%359 = mul i32 %358, %0
br i1 %207, label %420, label %360
360: ; preds = %355
%361 = mul i32 %356, %0
%362 = add i32 %353, %361
%363 = xor i32 %362, -1
%364 = icmp ult i32 %363, %208
%365 = or i1 %364, %209
%366 = select i1 %365, i1 true, i1 %212
br i1 %366, label %420, label %367
367: ; preds = %360
br i1 %216, label %402, label %368
368: ; preds = %367, %368
%369 = phi i64 [ %399, %368 ], [ 0, %367 ]
%370 = phi i64 [ %400, %368 ], [ 0, %367 ]
%371 = trunc i64 %369 to i32
%372 = or i32 %371, 1
%373 = add i32 %359, %372
%374 = zext i32 %373 to i64
%375 = getelementptr inbounds float, float* %10, i64 %374
%376 = bitcast float* %375 to <4 x float>*
%377 = load <4 x float>, <4 x float>* %376
%378 = getelementptr inbounds float, float* %375, i64 4
%379 = bitcast float* %378 to <4 x float>*
%380 = load <4 x float>, <4 x float>* %379
%381 = getelementptr inbounds float, float* %8, i64 %374
%382 = bitcast float* %381 to <4 x float>*
store <4 x float> %377, <4 x float>* %382
%383 = getelementptr inbounds float, float* %381, i64 4
%384 = bitcast float* %383 to <4 x float>*
store <4 x float> %380, <4 x float>* %384
%385 = trunc i64 %369 to i32
%386 = or i32 %385, 9
%387 = add i32 %359, %386
%388 = zext i32 %387 to i64
%389 = getelementptr inbounds float, float* %10, i64 %388
%390 = bitcast float* %389 to <4 x float>*
%391 = load <4 x float>, <4 x float>* %390
%392 = getelementptr inbounds float, float* %389, i64 4
%393 = bitcast float* %392 to <4 x float>*
%394 = load <4 x float>, <4 x float>* %393
%395 = getelementptr inbounds float, float* %8, i64 %388
%396 = bitcast float* %395 to <4 x float>*
store <4 x float> %391, <4 x float>* %396
%397 = getelementptr inbounds float, float* %395, i64 4
%398 = bitcast float* %397 to <4 x float>*
store <4 x float> %394, <4 x float>* %398
%399 = add nuw i64 %369, 16
%400 = add i64 %370, 2
%401 = icmp eq i64 %400, %217
br i1 %401, label %402, label %368
402: ; preds = %368, %367
%403 = phi i64 [ 0, %367 ], [ %399, %368 ]
br i1 %218, label %419, label %404
404: ; preds = %402
%405 = trunc i64 %403 to i32
%406 = or i32 %405, 1
%407 = add i32 %359, %406
%408 = zext i32 %407 to i64
%409 = getelementptr inbounds float, float* %10, i64 %408
%410 = bitcast float* %409 to <4 x float>*
%411 = load <4 x float>, <4 x float>* %410
%412 = getelementptr inbounds float, float* %409, i64 4
%413 = bitcast float* %412 to <4 x float>*
%414 = load <4 x float>, <4 x float>* %413
%415 = getelementptr inbounds float, float* %8, i64 %408
%416 = bitcast float* %415 to <4 x float>*
store <4 x float> %411, <4 x float>* %416
%417 = getelementptr inbounds float, float* %415, i64 4
%418 = bitcast float* %417 to <4 x float>*
store <4 x float> %414, <4 x float>* %418
br label %419
419: ; preds = %402, %404
br i1 %219, label %473, label %420
420: ; preds = %360, %355, %419
%421 = phi i64 [ 1, %360 ], [ 1, %355 ], [ %214, %419 ]
%422 = sub nsw i64 %193, %421
%423 = xor i64 %421, -1
%424 = add nsw i64 %423, %193
%425 = and i64 %422, 3
%426 = icmp eq i64 %425, 0
br i1 %426, label %439, label %427
427: ; preds = %420, %427
%428 = phi i64 [ %436, %427 ], [ %421, %420 ]
%429 = phi i64 [ %437, %427 ], [ 0, %420 ]
%430 = trunc i64 %428 to i32
%431 = add i32 %359, %430
%432 = zext i32 %431 to i64
%433 = getelementptr inbounds float, float* %10, i64 %432
%434 = load float, float* %433
%435 = getelementptr inbounds float, float* %8, i64 %432
store float %434, float* %435
%436 = add nuw nsw i64 %428, 1
%437 = add i64 %429, 1
%438 = icmp eq i64 %437, %425
br i1 %438, label %439, label %427
439: ; preds = %427, %420
%440 = phi i64 [ %421, %420 ], [ %436, %427 ]
%441 = icmp ult i64 %424, 3
br i1 %441, label %473, label %442
442: ; preds = %439, %442
%443 = phi i64 [ %471, %442 ], [ %440, %439 ]
%444 = trunc i64 %443 to i32
%445 = add i32 %359, %444
%446 = zext i32 %445 to i64
%447 = getelementptr inbounds float, float* %10, i64 %446
%448 = load float, float* %447
%449 = getelementptr inbounds float, float* %8, i64 %446
store float %448, float* %449
%450 = trunc i64 %443 to i32
%451 = add i32 %450, 1
%452 = add i32 %359, %451
%453 = zext i32 %452 to i64
%454 = getelementptr inbounds float, float* %10, i64 %453
%455 = load float, float* %454
%456 = getelementptr inbounds float, float* %8, i64 %453
store float %455, float* %456
%457 = trunc i64 %443 to i32
%458 = add i32 %457, 2
%459 = add i32 %359, %458
%460 = zext i32 %459 to i64
%461 = getelementptr inbounds float, float* %10, i64 %460
%462 = load float, float* %461
%463 = getelementptr inbounds float, float* %8, i64 %460
store float %462, float* %463
%464 = trunc i64 %443 to i32
%465 = add i32 %464, 3
%466 = add i32 %359, %465
%467 = zext i32 %466 to i64
%468 = getelementptr inbounds float, float* %10, i64 %467
%469 = load float, float* %468
%470 = getelementptr inbounds float, float* %8, i64 %467
store float %469, float* %470
%471 = add nuw nsw i64 %443, 4
%472 = icmp eq i64 %471, %194
br i1 %472, label %473, label %442
473: ; preds = %439, %442, %419
%474 = add nuw nsw i32 %357, 1
%475 = icmp eq i32 %474, %188
%476 = add i32 %356, 1
br i1 %475, label %477, label %355
477: ; preds = %473
%478 = add nuw nsw i32 %351, 1
%479 = icmp eq i32 %478, %188
%480 = add i32 %350, 1
br i1 %479, label %481, label %349
481: ; preds = %477, %220, %222
%482 = add nuw nsw i32 %221, 1
%483 = icmp eq i32 %482, 100
br i1 %483, label %484, label %220
484: ; preds = %481
%485 = load i32, i32* @CLOCK_MONOTONIC_RAW
%486 = call i32 @clock_gettime(i32 %485, %struct.timespec* %3)
%487 = call i32 (...) @rapl_end()
%488 = call i32 (...) @rapl_deinit()
%489 = getelementptr inbounds %struct.timespec, %struct.timespec* %2, i64 0, i32 0
%490 = load i32, i32* %489
%491 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i64 0, i32 0
%492 = load i32, i32* %491
%493 = call i32 @elapsed_time_hr(i32 %490, i32 %492, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0))
%494 = call i32 @free(float* %8)
%495 = call i32 @free(float* %10)
ret void
}